effect 2.0.0-next.4 → 2.0.0-next.41

package/internal/fiberRuntime.esm.js

@@ -0,0 +1,2003 @@
+import { not } from '../Boolean/dist/effect-Boolean.esm.js';
+import { fromIterable as fromIterable$1, isNonEmpty, headNonEmpty, tailNonEmpty, unsafeFromArray, prepend } from '../Chunk/dist/effect-Chunk.esm.js';
+import { get as get$1, getOption, add, Tag, merge, make as make$2, unsafeGet } from '../Context/dist/effect-Context.esm.js';
+import { await as _await$1 } from '../Deferred/dist/effect-Deferred.esm.js';
+import { parallel, sequential, parallelN } from '../ExecutionStrategy/dist/effect-ExecutionStrategy.esm.js';
+import { threadName, combine, none as none$2, unsafeMake as unsafeMake$1 } from '../FiberId/dist/effect-FiberId.esm.js';
+import { getOrDefault } from '../FiberRefs/dist/effect-FiberRefs.esm.js';
+import { diff as diff$1, patch as patch$1 } from '../FiberRefsPatch/dist/effect-FiberRefsPatch.esm.js';
+import { isDone, done, suspended, running } from '../FiberStatus/dist/effect-FiberStatus.esm.js';
+import { dual, identity, pipe } from '../Function/dist/effect-Function.esm.js';
+import { make, fromIterable as fromIterable$2, union, size } from '../HashSet/dist/effect-HashSet.esm.js';
+import { par, flatten as flatten$2, sequentialCollectionToChunk } from './blockedRequests.esm.js';
+import { empty, pretty, failureOrCause, parallel as parallel$1, sequential as sequential$1, interrupt, isEmpty, isInterruptedOnly, die, NoSuchElementException, stripFailures, isInterruptedException, IllegalArgumentException } from './cause.esm.js';
+import { clockTag } from './clock.esm.js';
+import { currentRequestMap } from './completedRequestMap.esm.js';
+import { matchSimple, match as match$1 } from './concurrency.esm.js';
+import { configProviderTag } from './configProvider.esm.js';
+import { fiberRefUnsafeMake, currentTracerSpan, fiberRefUnsafeMakeHashSet, uninterruptible, tap, isEffect, withFiberRuntime, fiberRefLocally, currentForkScopeOverride, map as map$1, exit, exitIsSuccess, onError, failCause, partitionMap, either, flatMap as flatMap$1, unit, succeed, fail, dieSync, uninterruptibleMask, interruptible, forEachSequential, zipRight, asUnit, onInterrupt, zipLeft, interruptFiber, deferredMake, exitMatchEffect, flatten, deferredFailCause, deferredSucceed, contextWithEffect, scopeFork, currentMetricLabels, acquireUseRelease, scopeClose, exitZipWith, flip, fiberIdWith, updateRuntimeFlags, runtimeFlags, ScopeTypeId, releaseMapMake, CloseableScopeTypeId, releaseMapAdd, scopeAddFinalizerExit, as, mapInputContext, onExit, fiberRefUnsafeMakePatch, fiberRefGet, fiberRefSet, fiberRefGetWith, sync, fiberRefUpdate, fiberRefDelete, fiberRefUnsafeMakeContext, fiberRefUnsafeMakeRuntimeFlags, forEachSequentialDiscard, exitSucceed, matchCauseEffect, suspend, currentInterruptedCause, deferredUnsafeMake, deferredAwait, async, currentSchedulingPriority, whileLoop, currentUnhandledErrorLogLevel, currentLogLevel, currentLogSpan, currentLogAnnotations, exitFailCause, exitUnit, currentContext, exitFail, blocked, catchAllCause, runRequestBlock, RevertFlags, yieldNow as yieldNow$1, isEffectError, withRuntimeFlags, matchEffect, if_, zipWith, currentRequestBatching, transplant, step, deferredUnsafeDone, deferredFail, exitCollectAll, exitIsFailure, exitInterrupt, exitAsUnit, interruptAsFiber, flatMapStep } from './core.esm.js';
+import { makeSpan, currentTimeNanosTracing, mapErrorCause } from './core-effect.esm.js';
+import { currentServices } from './defaultServices.esm.js';
+import { consoleTag } from './defaultServices/console.esm.js';
+import { sequential as sequential$2, isSequential, isParallel } from './executionStrategy.esm.js';
+import { _await, FiberTypeId, fiberVariance, join, RuntimeFiberTypeId, currentFiberURI, inheritAll, interruptAsFork } from './fiber.esm.js';
+import { resume, stateful, interruptSignal, OP_STATEFUL, OP_RESUME, OP_INTERRUPT_SIGNAL, OP_YIELD_NOW, yieldNow } from './fiberMessage.esm.js';
+import { get, joinAs, delete_, updatedAs, forkAs, getOrDefault as getOrDefault$1 } from './fiberRefs.esm.js';
+import { globalScope, unsafeMake } from './fiberScope.esm.js';
+import { makeLogger, stringLogger, logfmtLogger } from './logger.esm.js';
+import { counter, tagged, histogram } from './metric.esm.js';
+import { exponential } from './metric/boundaries.esm.js';
+import { make as make$3 } from './metric/label.esm.js';
+import { OP_FAILURE, OP_SUCCESS, OP_YIELD, OP_ASYNC, OP_ON_FAILURE, OP_ON_SUCCESS, OP_WHILE, OP_TAG, OP_SYNC, OP_REVERT_FLAGS, OP_ON_SUCCESS_AND_FAILURE, OP_WITH_RUNTIME, OP_UPDATE_RUNTIME_FLAGS, OP_COMMIT } from './opCodes/effect.esm.js';
+import { complete } from './request.esm.js';
+import { patch, diff, runtimeMetrics, WindDown, Interruption, interruptible as interruptible$1, enable, cooperativeYielding, OpSupervision, none as none$3 } from './runtimeFlags.esm.js';
+import { none as none$1 } from './supervisor.esm.js';
+import { differ, empty as empty$2 } from './supervisor/patch.esm.js';
+import { tracerTag } from './tracer.esm.js';
+import { head, prepend as prepend$1 } from '../List/dist/effect-List.esm.js';
+import { fromLiteral, greaterThan } from '../LogLevel/dist/effect-LogLevel.esm.js';
+import { make as make$4, compareAndSet } from '../MutableRef/dist/effect-MutableRef.esm.js';
+import { flatMap, map, some, none, match, fromNullable, isSome, getOrElse } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { isIterable } from '../Predicate/dist/effect-Predicate.esm.js';
+import { fromIterable, filterMap, reduce, flatten as flatten$1, reduceRight, compact } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
+import { make as make$1, modify, update, get as get$2 } from '../Ref/dist/effect-Ref.esm.js';
+import { empty as empty$1, exclude } from '../RuntimeFlagsPatch/dist/effect-RuntimeFlagsPatch.esm.js';
+import { currentScheduler } from '../Scheduler/dist/effect-Scheduler.esm.js';
+
+/** @internal */
+const fiberStarted = /*#__PURE__*/counter("effect_fiber_started");
+/** @internal */
+const fiberActive = /*#__PURE__*/counter("effect_fiber_active");
+/** @internal */
+const fiberSuccesses = /*#__PURE__*/counter("effect_fiber_successes");
+/** @internal */
+const fiberFailures = /*#__PURE__*/counter("effect_fiber_failures");
+/** @internal */
+const fiberLifetimes = /*#__PURE__*/tagged( /*#__PURE__*/histogram("effect_fiber_lifetimes", /*#__PURE__*/exponential({
+  start: 1.0,
+  factor: 1.3,
+  count: 100
+})), "time_unit", "milliseconds");
+
+/** @internal */
+
+/** @internal */
+const EvaluationSignalContinue = "Continue";
+
+/** @internal */
+
+/** @internal */
+const EvaluationSignalDone = "Done";
+
+/** @internal */
+
+/** @internal */
+const EvaluationSignalYieldNow = "Yield";
+
+/** @internal */
+
+/** @internal */
+const runtimeFiberVariance = {
+  _E: _ => _,
+  _A: _ => _
+};
+const absurd = _ => {
+  throw new Error(`BUG: FiberRuntime - ${JSON.stringify(_)} - please report an issue at https://github.com/Effect-TS/io/issues`);
+};
+const contOpSuccess = {
+  [OP_ON_SUCCESS]: (_, cont, value) => {
+    return cont.i1(value);
+  },
+  ["OnStep"]: (_, cont, value) => {
+    return cont.i1(exitSucceed(value));
+  },
+  [OP_ON_SUCCESS_AND_FAILURE]: (_, cont, value) => {
+    return cont.i2(value);
+  },
+  [OP_REVERT_FLAGS]: (self, cont, value) => {
+    self.patchRuntimeFlags(self._runtimeFlags, cont.patch);
+    if (interruptible$1(self._runtimeFlags) && self.isInterrupted()) {
+      return exitFailCause(self.getInterruptedCause());
+    } else {
+      return exitSucceed(value);
+    }
+  },
+  [OP_WHILE]: (self, cont, value) => {
+    cont.i2(value);
+    if (cont.i0()) {
+      self.pushStack(cont);
+      return cont.i1();
+    } else {
+      return unit;
+    }
+  }
+};
+const drainQueueWhileRunningTable = {
+  [OP_INTERRUPT_SIGNAL]: (self, runtimeFlags, cur, message) => {
+    self.processNewInterruptSignal(message.cause);
+    return interruptible$1(runtimeFlags) ? exitFailCause(message.cause) : cur;
+  },
+  [OP_RESUME]: (_self, _runtimeFlags, _cur, _message) => {
+    throw new Error("It is illegal to have multiple concurrent run loops in a single fiber");
+  },
+  [OP_STATEFUL]: (self, runtimeFlags, cur, message) => {
+    message.onFiber(self, running(runtimeFlags));
+    return cur;
+  },
+  [OP_YIELD_NOW]: (_self, _runtimeFlags, cur, _message) => {
+    return flatMap$1(yieldNow$1(), () => cur);
+  }
+};
+
+/**
+ * Executes all requests, submitting requests to each data source in parallel.
+ */
+const runBlockedRequests = self => forEachSequentialDiscard(flatten$2(self), requestsByRequestResolver => forEachParUnboundedDiscard(sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential]) => {
+  const map = new Map();
+  for (const block of sequential) {
+    for (const entry of block) {
+      map.set(entry.request, entry);
+    }
+  }
+  return fiberRefLocally(invokeWithInterrupt(dataSource.runAll(sequential), sequential.flat()), currentRequestMap, map);
+}, false));
+
+/** @internal */
+class FiberRuntime {
+  [FiberTypeId] = fiberVariance;
+  [RuntimeFiberTypeId] = runtimeFiberVariance;
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  _queue = new Array();
+  _children = null;
+  _observers = new Array();
+  _running = false;
+  _stack = [];
+  _asyncInterruptor = null;
+  _asyncBlockingOn = null;
+  _exitValue = null;
+  _steps = [false];
+  currentOpCount = 0;
+  constructor(fiberId, fiberRefs0, runtimeFlags0) {
+    this._runtimeFlags = runtimeFlags0;
+    this._fiberId = fiberId;
+    this._fiberRefs = fiberRefs0;
+    this._supervisor = this.getFiberRef(currentSupervisor);
+    this._scheduler = this.getFiberRef(currentScheduler);
+    if (runtimeMetrics(runtimeFlags0)) {
+      const tags = this.getFiberRef(currentMetricLabels);
+      fiberStarted.unsafeUpdate(1, tags);
+      fiberActive.unsafeUpdate(1, tags);
+    }
+    this._tracer = get$1(this.getFiberRef(currentServices), tracerTag);
+  }
+
+  /**
+   * The identity of the fiber.
+   */
+  id() {
+    return this._fiberId;
+  }
+
+  /**
+   * Begins execution of the effect associated with this fiber on in the
+   * background. This can be called to "kick off" execution of a fiber after
+   * it has been created.
+   */
+  resume(effect) {
+    this.tell(resume(effect));
+  }
+
+  /**
+   * The status of the fiber.
+   */
+  status() {
+    return this.ask((_, status) => status);
+  }
+
+  /**
+   * Gets the fiber runtime flags.
+   */
+  runtimeFlags() {
+    return this.ask((state, status) => {
+      if (isDone(status)) {
+        return state._runtimeFlags;
+      }
+      return status.runtimeFlags;
+    });
+  }
+
+  /**
+   * Returns the current `FiberScope` for the fiber.
+   */
+  scope() {
+    return unsafeMake(this);
+  }
+
+  /**
+   * Retrieves the immediate children of the fiber.
+   */
+  children() {
+    return this.ask(fiber => Array.from(fiber.getChildren()));
+  }
+
+  /**
+   * Gets the fiber's set of children.
+   */
+  getChildren() {
+    if (this._children === null) {
+      this._children = new Set();
+    }
+    return this._children;
+  }
+
+  /**
+   * Retrieves the interrupted cause of the fiber, which will be `Cause.empty`
+   * if the fiber has not been interrupted.
+   *
+   * **NOTE**: This method is safe to invoke on any fiber, but if not invoked
+   * on this fiber, then values derived from the fiber's state (including the
+   * log annotations and log level) may not be up-to-date.
+   */
+  getInterruptedCause() {
+    return this.getFiberRef(currentInterruptedCause);
+  }
+
+  /**
+   * Retrieves the whole set of fiber refs.
+   */
+  fiberRefs() {
+    return this.ask(fiber => fiber.getFiberRefs());
+  }
+
+  /**
+   * Returns an effect that will contain information computed from the fiber
+   * state and status while running on the fiber.
+   *
+   * This allows the outside world to interact safely with mutable fiber state
+   * without locks or immutable data.
+   */
+  ask(f) {
+    return suspend(() => {
+      const deferred = deferredUnsafeMake(this._fiberId);
+      this.tell(stateful((fiber, status) => {
+        deferredUnsafeDone(deferred, sync(() => f(fiber, status)));
+      }));
+      return deferredAwait(deferred);
+    });
+  }
+
+  /**
+   * Adds a message to be processed by the fiber on the fiber.
+   */
+  tell(message) {
+    this._queue.push(message);
+    if (!this._running) {
+      this._running = true;
+      this.drainQueueLaterOnExecutor();
+    }
+  }
+  await() {
+    return async(resume => {
+      const cb = exit => resume(succeed(exit));
+      this.tell(stateful((fiber, _) => {
+        if (fiber._exitValue !== null) {
+          cb(this._exitValue);
+        } else {
+          fiber.addObserver(cb);
+        }
+      }));
+      return sync(() => this.tell(stateful((fiber, _) => {
+        fiber.removeObserver(cb);
+      })));
+    }, this.id());
+  }
+  inheritAll() {
+    return withFiberRuntime((parentFiber, parentStatus) => {
+      const parentFiberId = parentFiber.id();
+      const parentFiberRefs = parentFiber.getFiberRefs();
+      const parentRuntimeFlags = parentStatus.runtimeFlags;
+      const childFiberRefs = this.getFiberRefs();
+      const updatedFiberRefs = joinAs(parentFiberRefs, parentFiberId, childFiberRefs);
+      parentFiber.setFiberRefs(updatedFiberRefs);
+      const updatedRuntimeFlags = parentFiber.getFiberRef(currentRuntimeFlags);
+      const patch = pipe(diff(parentRuntimeFlags, updatedRuntimeFlags),
+      // Do not inherit WindDown or Interruption!
+      exclude(Interruption), exclude(WindDown));
+      return updateRuntimeFlags(patch);
+    });
+  }
+
+  /**
+   * Tentatively observes the fiber, but returns immediately if it is not
+   * already done.
+   */
+  poll() {
+    return sync(() => fromNullable(this._exitValue));
+  }
+
+  /**
+   * Unsafely observes the fiber, but returns immediately if it is not
+   * already done.
+   */
+  unsafePoll() {
+    return this._exitValue;
+  }
+
+  /**
+   * In the background, interrupts the fiber as if interrupted from the specified fiber.
+   */
+  interruptAsFork(fiberId) {
+    return sync(() => this.tell(interruptSignal(interrupt(fiberId))));
+  }
+
+  /**
+   * Adds an observer to the list of observers.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  addObserver(observer) {
+    if (this._exitValue !== null) {
+      observer(this._exitValue);
+    } else {
+      this._observers.push(observer);
+    }
+  }
+
+  /**
+   * Removes the specified observer from the list of observers that will be
+   * notified when the fiber exits.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  removeObserver(observer) {
+    this._observers = this._observers.filter(o => o !== observer);
+  }
+  /**
+   * Retrieves all fiber refs of the fiber.
+   *
+   * **NOTE**: This method is safe to invoke on any fiber, but if not invoked
+   * on this fiber, then values derived from the fiber's state (including the
+   * log annotations and log level) may not be up-to-date.
+   */
+  getFiberRefs() {
+    this.setFiberRef(currentRuntimeFlags, this._runtimeFlags);
+    return this._fiberRefs;
+  }
+
+  /**
+   * Deletes the specified fiber ref.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  unsafeDeleteFiberRef(fiberRef) {
+    this._fiberRefs = delete_(this._fiberRefs, fiberRef);
+  }
+
+  /**
+   * Retrieves the state of the fiber ref, or else its initial value.
+   *
+   * **NOTE**: This method is safe to invoke on any fiber, but if not invoked
+   * on this fiber, then values derived from the fiber's state (including the
+   * log annotations and log level) may not be up-to-date.
+   */
+  getFiberRef(fiberRef) {
+    if (this._fiberRefs.locals.has(fiberRef)) {
+      return this._fiberRefs.locals.get(fiberRef)[0][1];
+    }
+    return fiberRef.initial;
+  }
+
+  /**
+   * Sets the fiber ref to the specified value.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  setFiberRef(fiberRef, value) {
+    this._fiberRefs = updatedAs(this._fiberRefs, {
+      fiberId: this._fiberId,
+      fiberRef,
+      value
+    });
+    this.refreshRefCache();
+  }
+  refreshRefCache() {
+    this._tracer = get$1(this.getFiberRef(currentServices), tracerTag);
+    this._supervisor = this.getFiberRef(currentSupervisor);
+    this._scheduler = this.getFiberRef(currentScheduler);
+  }
+
+  /**
+   * Wholesale replaces all fiber refs of this fiber.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  setFiberRefs(fiberRefs) {
+    this._fiberRefs = fiberRefs;
+    this.refreshRefCache();
+  }
+
+  /**
+   * Adds a reference to the specified fiber inside the children set.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  addChild(child) {
+    this.getChildren().add(child);
+  }
+
+  /**
+   * Removes a reference to the specified fiber inside the children set.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  removeChild(child) {
+    this.getChildren().delete(child);
+  }
+
+  /**
+   * On the current thread, executes all messages in the fiber's inbox. This
+   * method may return before all work is done, in the event the fiber executes
+   * an asynchronous operation.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  drainQueueOnCurrentThread() {
+    let recurse = true;
+    while (recurse) {
+      let evaluationSignal = EvaluationSignalContinue;
+      const prev = globalThis[currentFiberURI];
+      globalThis[currentFiberURI] = this;
+      try {
+        while (evaluationSignal === EvaluationSignalContinue) {
+          evaluationSignal = this._queue.length === 0 ? EvaluationSignalDone : this.evaluateMessageWhileSuspended(this._queue.splice(0, 1)[0]);
+        }
+      } finally {
+        this._running = false;
+        globalThis[currentFiberURI] = prev;
+      }
+      // Maybe someone added something to the queue between us checking, and us
+      // giving up the drain. If so, we need to restart the draining, but only
+      // if we beat everyone else to the restart:
+      if (this._queue.length > 0 && !this._running) {
+        this._running = true;
+        if (evaluationSignal === EvaluationSignalYieldNow) {
+          this.drainQueueLaterOnExecutor();
+          recurse = false;
+        } else {
+          recurse = true;
+        }
+      } else {
+        recurse = false;
+      }
+    }
+  }
+
+  /**
+   * Schedules the execution of all messages in the fiber's inbox.
+   *
+   * This method will return immediately after the scheduling
+   * operation is completed, but potentially before such messages have been
+   * executed.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  drainQueueLaterOnExecutor() {
+    this._scheduler.scheduleTask(this.run, this.getFiberRef(currentSchedulingPriority));
+  }
+
+  /**
+   * Drains the fiber's message queue while the fiber is actively running,
+   * returning the next effect to execute, which may be the input effect if no
+   * additional effect needs to be executed.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  drainQueueWhileRunning(runtimeFlags, cur0) {
+    let cur = cur0;
+    while (this._queue.length > 0) {
+      const message = this._queue.splice(0, 1)[0];
+      // @ts-expect-error
+      cur = drainQueueWhileRunningTable[message._tag](this, runtimeFlags, cur, message);
+    }
+    return cur;
+  }
+
+  /**
+   * Determines if the fiber is interrupted.
+   *
+   * **NOTE**: This method is safe to invoke on any fiber, but if not invoked
+   * on this fiber, then values derived from the fiber's state (including the
+   * log annotations and log level) may not be up-to-date.
+   */
+  isInterrupted() {
+    return !isEmpty(this.getFiberRef(currentInterruptedCause));
+  }
+
+  /**
+   * Adds an interruptor to the set of interruptors that are interrupting this
+   * fiber.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  addInterruptedCause(cause) {
+    const oldSC = this.getFiberRef(currentInterruptedCause);
+    this.setFiberRef(currentInterruptedCause, sequential$1(oldSC, cause));
+  }
+
+  /**
+   * Processes a new incoming interrupt signal.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  processNewInterruptSignal(cause) {
+    this.addInterruptedCause(cause);
+    this.sendInterruptSignalToAllChildren();
+  }
+
+  /**
+   * Interrupts all children of the current fiber, returning an effect that will
+   * await the exit of the children. This method will return null if the fiber
+   * has no children.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  sendInterruptSignalToAllChildren() {
+    if (this._children === null || this._children.size === 0) {
+      return false;
+    }
+    let told = false;
+    for (const child of this._children) {
+      child.tell(interruptSignal(interrupt(this.id())));
+      told = true;
+    }
+    return told;
+  }
+
+  /**
+   * Interrupts all children of the current fiber, returning an effect that will
+   * await the exit of the children. This method will return null if the fiber
+   * has no children.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  interruptAllChildren() {
+    if (this.sendInterruptSignalToAllChildren()) {
+      const it = this._children.values();
+      this._children = null;
+      let isDone = false;
+      const body = () => {
+        const next = it.next();
+        if (!next.done) {
+          return asUnit(next.value.await());
+        } else {
+          return sync(() => {
+            isDone = true;
+          });
+        }
+      };
+      return whileLoop({
+        while: () => !isDone,
+        body,
+        step: () => {
+          //
+        }
+      });
+    }
+    return null;
+  }
+  reportExitValue(exit) {
+    if (runtimeMetrics(this._runtimeFlags)) {
+      const tags = this.getFiberRef(currentMetricLabels);
+      fiberActive.unsafeUpdate(-1, tags);
+      switch (exit._tag) {
+        case OP_SUCCESS:
+          {
+            fiberSuccesses.unsafeUpdate(1, tags);
+            break;
+          }
+        case OP_FAILURE:
+          {
+            fiberFailures.unsafeUpdate(1, tags);
+            break;
+          }
+      }
+    }
+    if (exit._tag === "Failure") {
+      const level = this.getFiberRef(currentUnhandledErrorLogLevel);
+      if (!isInterruptedOnly(exit.cause) && level._tag === "Some") {
+        this.log("Fiber terminated with a non handled error", exit.cause, level);
+      }
+    }
+  }
+  setExitValue(exit) {
+    this._exitValue = exit;
+    if (runtimeMetrics(this._runtimeFlags)) {
+      const tags = this.getFiberRef(currentMetricLabels);
+      const startTimeMillis = this.id().startTimeMillis;
+      const endTimeMillis = new Date().getTime();
+      fiberLifetimes.unsafeUpdate(endTimeMillis - startTimeMillis, tags);
+    }
+    this.reportExitValue(exit);
+    for (let i = this._observers.length - 1; i >= 0; i--) {
+      this._observers[i](exit);
+    }
+  }
+  getLoggers() {
+    return this.getFiberRef(currentLoggers);
+  }
+  log(message, cause, overrideLogLevel) {
+    const logLevel = isSome(overrideLogLevel) ? overrideLogLevel.value : this.getFiberRef(currentLogLevel);
+    const minimumLogLevel = this.getFiberRef(currentMinimumLogLevel);
+    if (greaterThan(minimumLogLevel, logLevel)) {
+      return;
+    }
+    const spans = this.getFiberRef(currentLogSpan);
+    const annotations = this.getFiberRef(currentLogAnnotations);
+    const loggers = this.getLoggers();
+    const contextMap = this.getFiberRefs();
+    if (size(loggers) > 0) {
+      const clockService = get$1(this.getFiberRef(currentServices), clockTag);
+      const date = new Date(clockService.unsafeCurrentTimeMillis());
+      for (const logger of loggers) {
+        logger.log({
+          fiberId: this.id(),
+          logLevel,
+          message,
+          cause,
+          context: contextMap,
+          spans,
+          annotations,
+          date
+        });
+      }
+    }
+  }
+
+  /**
+   * Evaluates a single message on the current thread, while the fiber is
+   * suspended. This method should only be called while evaluation of the
+   * fiber's effect is suspended due to an asynchronous operation.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  evaluateMessageWhileSuspended(message) {
+    switch (message._tag) {
+      case OP_YIELD_NOW:
+        {
+          return EvaluationSignalYieldNow;
+        }
+      case OP_INTERRUPT_SIGNAL:
+        {
+          this.processNewInterruptSignal(message.cause);
+          if (this._asyncInterruptor !== null) {
+            this._asyncInterruptor(exitFailCause(message.cause));
+            this._asyncInterruptor = null;
+          }
+          return EvaluationSignalContinue;
+        }
+      case OP_RESUME:
+        {
+          this._asyncInterruptor = null;
+          this._asyncBlockingOn = null;
+          this.evaluateEffect(message.effect);
+          return EvaluationSignalContinue;
+        }
+      case OP_STATEFUL:
+        {
+          message.onFiber(this, this._exitValue !== null ? done : suspended(this._runtimeFlags, this._asyncBlockingOn));
+          return EvaluationSignalContinue;
+        }
+      default:
+        {
+          return absurd(message);
+        }
+    }
+  }
+
+  /**
+   * Evaluates an effect until completion, potentially asynchronously.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  evaluateEffect(effect0) {
+    this._supervisor.onResume(this);
+    try {
+      let effect = interruptible$1(this._runtimeFlags) && this.isInterrupted() ? exitFailCause(this.getInterruptedCause()) : effect0;
+      while (effect !== null) {
+        try {
+          const eff = effect;
+          const exit = this.runLoop(eff);
+          this._runtimeFlags = pipe(this._runtimeFlags, enable(WindDown));
+          const interruption = this.interruptAllChildren();
+          if (interruption !== null) {
+            effect = flatMap$1(interruption, () => exit);
+          } else {
+            if (this._queue.length === 0) {
+              // No more messages to process, so we will allow the fiber to end life:
+              this.setExitValue(exit);
+            } else {
+              // There are messages, possibly added by the final op executed by
+              // the fiber. To be safe, we should execute those now before we
+              // allow the fiber to end life:
+              this.tell(resume(exit));
+            }
+            effect = null;
+          }
+        } catch (e) {
+          if (isEffect(e)) {
+            if (e._op === OP_YIELD) {
+              if (cooperativeYielding(this._runtimeFlags)) {
+                this.tell(yieldNow());
+                this.tell(resume(exitUnit));
+                effect = null;
+              } else {
+                effect = exitUnit;
+              }
+            } else if (e._op === OP_ASYNC) {
+              // Terminate this evaluation, async resumption will continue evaluation:
+              effect = null;
+            }
+          } else {
+            throw e;
+          }
+        }
+      }
+    } finally {
+      this._supervisor.onSuspend(this);
+    }
+  }
+
+  /**
+   * Begins execution of the effect associated with this fiber on the current
+   * thread. This can be called to "kick off" execution of a fiber after it has
+   * been created, in hopes that the effect can be executed synchronously.
+   *
+   * This is not the normal way of starting a fiber, but it is useful when the
+   * express goal of executing the fiber is to synchronously produce its exit.
+   */
+  start(effect) {
+    if (!this._running) {
+      this._running = true;
+      const prev = globalThis[currentFiberURI];
+      globalThis[currentFiberURI] = this;
+      try {
+        this.evaluateEffect(effect);
+      } finally {
+        this._running = false;
+        globalThis[currentFiberURI] = prev;
+        // Because we're special casing `start`, we have to be responsible
+        // for spinning up the fiber if there were new messages added to
+        // the queue between the completion of the effect and the transition
+        // to the not running state.
+        if (this._queue.length > 0) {
+          this.drainQueueLaterOnExecutor();
+        }
+      }
+    } else {
+      this.tell(resume(effect));
+    }
+  }
+
+  /**
+   * Begins execution of the effect associated with this fiber on in the
+   * background, and on the correct thread pool. This can be called to "kick
+   * off" execution of a fiber after it has been created, in hopes that the
+   * effect can be executed synchronously.
+   */
+  startFork(effect) {
+    this.tell(resume(effect));
+  }
+
+  /**
+   * Takes the current runtime flags, patches them to return the new runtime
+   * flags, and then makes any changes necessary to fiber state based on the
+   * specified patch.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  patchRuntimeFlags(oldRuntimeFlags, patch$1) {
+    const newRuntimeFlags = patch(oldRuntimeFlags, patch$1);
+    globalThis[currentFiberURI] = this;
+    this._runtimeFlags = newRuntimeFlags;
+    return newRuntimeFlags;
+  }
+
+  /**
+   * Initiates an asynchronous operation, by building a callback that will
+   * resume execution, and then feeding that callback to the registration
+   * function, handling error cases and repeated resumptions appropriately.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  initiateAsync(runtimeFlags, asyncRegister) {
+    let alreadyCalled = false;
+    const callback = effect => {
+      if (!alreadyCalled) {
+        alreadyCalled = true;
+        this.tell(resume(effect));
+      }
+    };
+    if (interruptible$1(runtimeFlags)) {
+      this._asyncInterruptor = callback;
+    }
+    try {
+      asyncRegister(callback);
+    } catch (e) {
+      callback(failCause(die(e)));
+    }
+  }
+  pushStack(cont) {
+    this._stack.push(cont);
+    if (cont._op === "OnStep") {
+      this._steps.push(true);
+    }
+    if (cont._op === "RevertFlags") {
+      this._steps.push(false);
+    }
+  }
+  popStack() {
+    const item = this._stack.pop();
+    if (item) {
+      if (item._op === "OnStep" || item._op === "RevertFlags") {
+        this._steps.pop();
+      }
+      return item;
+    }
+    return;
+  }
+  getNextSuccessCont() {
+    let frame = this.popStack();
+    while (frame) {
+      if (frame._op !== OP_ON_FAILURE) {
+        return frame;
+      }
+      frame = this.popStack();
+    }
+  }
+  getNextFailCont() {
+    let frame = this.popStack();
+    while (frame) {
+      if (frame._op !== OP_ON_SUCCESS && frame._op !== OP_WHILE) {
+        return frame;
+      }
+      frame = this.popStack();
+    }
+  }
+  [OP_TAG](op) {
+    return map$1(fiberRefGet(currentContext), context => {
+      try {
+        return unsafeGet(context, op);
+      } catch (e) {
+        console.log(e);
+        throw e;
+      }
+    });
+  }
+  ["Left"](op) {
+    return exitFail(op.left);
+  }
+  ["None"](_) {
+    return exitFail(NoSuchElementException());
+  }
+  ["Right"](op) {
+    return exitSucceed(op.right);
+  }
+  ["Some"](op) {
+    return exitSucceed(op.value);
+  }
+  [OP_SYNC](op) {
+    const value = op.i0();
+    const cont = this.getNextSuccessCont();
+    if (cont !== undefined) {
+      if (!(cont._op in contOpSuccess)) {
+        // @ts-expect-error
+        absurd(cont);
+      }
+      // @ts-expect-error
+      return contOpSuccess[cont._op](this, cont, value);
+    } else {
+      throw exitSucceed(value);
+    }
+  }
+  [OP_SUCCESS](op) {
+    const oldCur = op;
+    const cont = this.getNextSuccessCont();
+    if (cont !== undefined) {
+      if (!(cont._op in contOpSuccess)) {
+        // @ts-expect-error
+        absurd(cont);
+      }
+      // @ts-expect-error
+      return contOpSuccess[cont._op](this, cont, oldCur.i0);
+    } else {
+      throw oldCur;
+    }
+  }
+  [OP_FAILURE](op) {
+    const cause = op.i0;
+    const cont = this.getNextFailCont();
+    if (cont !== undefined) {
+      switch (cont._op) {
+        case OP_ON_FAILURE:
+        case OP_ON_SUCCESS_AND_FAILURE:
+          {
+            if (!(interruptible$1(this._runtimeFlags) && this.isInterrupted())) {
+              return cont.i1(cause);
+            } else {
+              return exitFailCause(stripFailures(cause));
+            }
+          }
+        case "OnStep":
+          {
+            if (!(interruptible$1(this._runtimeFlags) && this.isInterrupted())) {
+              return cont.i1(exitFailCause(cause));
+            } else {
+              return exitFailCause(stripFailures(cause));
+            }
+          }
+        case OP_REVERT_FLAGS:
+          {
+            this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
+            if (interruptible$1(this._runtimeFlags) && this.isInterrupted()) {
+              return exitFailCause(sequential$1(cause, this.getInterruptedCause()));
+            } else {
+              return exitFailCause(cause);
+            }
+          }
+        default:
+          {
+            absurd(cont);
+          }
+      }
+    } else {
+      throw exitFailCause(cause);
+    }
+  }
+  [OP_WITH_RUNTIME](op) {
+    return op.i0(this, running(this._runtimeFlags));
+  }
+  ["Blocked"](op) {
+    if (this._steps[this._steps.length - 1]) {
+      const nextOp = this.popStack();
+      if (nextOp) {
+        switch (nextOp._op) {
+          case "OnStep":
+            {
+              return nextOp.i1(op);
+            }
+          case "OnSuccess":
+            {
+              return blocked(op.i0, flatMap$1(op.i1, nextOp.i1));
+            }
+          case "OnSuccessAndFailure":
+            {
+              return blocked(op.i0, matchCauseEffect(op.i1, {
+                onFailure: nextOp.i1,
+                onSuccess: nextOp.i2
+              }));
+            }
+          case "OnFailure":
+            {
+              return blocked(op.i0, catchAllCause(op.i1, nextOp.i1));
+            }
+          case "While":
+            {
+              return blocked(op.i0, flatMap$1(op.i1, a => {
+                nextOp.i2(a);
+                if (nextOp.i0()) {
+                  return whileLoop({
+                    while: nextOp.i0,
+                    body: nextOp.i1,
+                    step: nextOp.i2
+                  });
+                }
+                return unit;
+              }));
+            }
+          case "RevertFlags":
+            {
+              this.pushStack(nextOp);
+              break;
+            }
+        }
+      }
+    }
+    return uninterruptibleMask(restore => flatMap$1(fork(runRequestBlock(op.i0)), () => restore(op.i1)));
+  }
+  ["RunBlocked"](op) {
+    return runBlockedRequests(op.i0);
+  }
+  [OP_UPDATE_RUNTIME_FLAGS](op) {
+    const updateFlags = op.i0;
+    const oldRuntimeFlags = this._runtimeFlags;
+    const newRuntimeFlags = patch(oldRuntimeFlags, updateFlags);
+    // One more chance to short circuit: if we're immediately going
+    // to interrupt. Interruption will cause immediate reversion of
+    // the flag, so as long as we "peek ahead", there's no need to
+    // set them to begin with.
+    if (interruptible$1(newRuntimeFlags) && this.isInterrupted()) {
+      return exitFailCause(this.getInterruptedCause());
+    } else {
+      // Impossible to short circuit, so record the changes
+      this.patchRuntimeFlags(this._runtimeFlags, updateFlags);
+      if (op.i1) {
+        // Since we updated the flags, we need to revert them
+        const revertFlags = diff(newRuntimeFlags, oldRuntimeFlags);
+        this.pushStack(new RevertFlags(revertFlags, op));
+        return op.i1(oldRuntimeFlags);
+      } else {
+        return exitUnit;
+      }
+    }
+  }
+  [OP_ON_SUCCESS](op) {
+    this.pushStack(op);
+    return op.i0;
+  }
+  ["OnStep"](op) {
+    this.pushStack(op);
+    return op.i0;
+  }
+  [OP_ON_FAILURE](op) {
+    this.pushStack(op);
+    return op.i0;
+  }
+  [OP_ON_SUCCESS_AND_FAILURE](op) {
+    this.pushStack(op);
+    return op.i0;
+  }
+  [OP_ASYNC](op) {
+    this._asyncBlockingOn = op.i1;
+    this.initiateAsync(this._runtimeFlags, op.i0);
+    throw op;
+  }
+  [OP_YIELD](op) {
+    throw op;
+  }
+  [OP_WHILE](op) {
+    const check = op.i0;
+    const body = op.i1;
+    if (check()) {
+      this.pushStack(op);
+      return body();
+    } else {
+      return exitUnit;
+    }
+  }
+  [OP_COMMIT](op) {
+    return op.commit();
+  }
+
+  /**
+   * The main run-loop for evaluating effects.
+   *
+   * **NOTE**: This method must be invoked by the fiber itself.
+   */
+  runLoop(effect0) {
+    let cur = effect0;
+    this.currentOpCount = 0;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      if ((this._runtimeFlags & OpSupervision) !== 0) {
+        this._supervisor.onEffect(this, cur);
+      }
+      if (this._queue.length > 0) {
+        cur = this.drainQueueWhileRunning(this._runtimeFlags, cur);
+      }
+      this.currentOpCount += 1;
+      const shouldYield = this._scheduler.shouldYield(this);
+      if (shouldYield !== false) {
+        this.currentOpCount = 0;
+        const oldCur = cur;
+        cur = flatMap$1(yieldNow$1({
+          priority: shouldYield
+        }), () => oldCur);
+      }
+      try {
+        if (!("_op" in cur)) {
+          console.log(cur);
+        }
+        if (!(cur._op in this)) {
+          if (typeof cur === "function") {
+            console.log(cur());
+          }
+          // @ts-expect-error
+          absurd(cur);
+        }
+        // @ts-expect-error
+        cur = this._tracer.context(
+        // @ts-expect-error
+        () => this[cur._op](cur), this);
+      } catch (e) {
+        if (isEffect(e)) {
+          if (e._op === OP_YIELD || e._op === OP_ASYNC) {
+            throw e;
+          }
+          if (e._op === OP_SUCCESS || e._op === OP_FAILURE) {
+            return e;
+          }
+        } else {
+          if (isEffectError(e)) {
+            cur = exitFailCause(e.cause);
+          } else if (isInterruptedException(e)) {
+            cur = exitFailCause(sequential$1(die(e), interrupt(none$2)));
+          } else {
+            cur = exitFailCause(die(e));
+          }
+        }
+      }
+    }
+  }
+  run = () => {
+    this.drainQueueOnCurrentThread();
+  };
+}
+
+// circular with Logger
+
+/** @internal */
+const currentMinimumLogLevel = /*#__PURE__*/fiberRefUnsafeMake( /*#__PURE__*/fromLiteral("Info"));
+
+/** @internal */
+const getConsole = refs => {
+  const defaultServicesValue = getOrDefault(refs, currentServices);
+  const cnsl = get$1(defaultServicesValue, consoleTag);
+  return cnsl.unsafe;
+};
+
+/** @internal */
+const defaultLogger = /*#__PURE__*/makeLogger(options => {
+  const formatted = stringLogger.log(options);
+  getConsole(options.context).log(formatted);
+});
+
+/** @internal */
+const logFmtLogger = /*#__PURE__*/makeLogger(options => {
+  const formatted = logfmtLogger.log(options);
+  getConsole(options.context).log(formatted);
+});
+
+/** @internal */
+const tracerLogger = /*#__PURE__*/makeLogger(({
+  annotations,
+  cause,
+  context,
+  fiberId,
+  logLevel,
+  message
+}) => {
+  const span = flatMap(get(context, currentTracerSpan), head);
+  const clockService = map(get(context, currentServices), _ => get$1(_, clockTag));
+  if (span._tag === "None" || span.value._tag === "ExternalSpan" || clockService._tag === "None") {
+    return;
+  }
+  const attributes = Object.fromEntries(annotations);
+  attributes["effect.fiberId"] = threadName(fiberId);
+  attributes["effect.logLevel"] = logLevel.label;
+  if (cause !== null && cause !== empty) {
+    attributes["effect.cause"] = pretty(cause);
+  }
+  span.value.event(String(message), clockService.value.unsafeCurrentTimeNanos(), attributes);
+});
+
+/** @internal */
+const currentLoggers = /*#__PURE__*/fiberRefUnsafeMakeHashSet( /*#__PURE__*/make(defaultLogger, tracerLogger));
+
+// circular with Effect
+
+/* @internal */
+const acquireRelease = /*#__PURE__*/dual(args => isEffect(args[0]), (acquire, release) => {
+  return uninterruptible(tap(acquire, a => addFinalizer(exit => release(a, exit))));
+});
+
+/* @internal */
+const acquireReleaseInterruptible = /*#__PURE__*/dual(args => isEffect(args[0]), (acquire, release) => {
+  return ensuring(acquire, addFinalizer(exit => release(exit)));
+});
+
+/* @internal */
+const addFinalizer = finalizer => withFiberRuntime(runtime => {
+  const acquireRefs = runtime.getFiberRefs();
+  const acquireFlags = runtime._runtimeFlags;
+  return flatMap$1(scope, scope => scopeAddFinalizerExit(scope, exit => withFiberRuntime(runtimeFinalizer => {
+    const preRefs = runtimeFinalizer.getFiberRefs();
+    const preFlags = runtimeFinalizer._runtimeFlags;
+    const patchRefs = diff$1(preRefs, acquireRefs);
+    const patchFlags = diff(preFlags, acquireFlags);
+    const inverseRefs = diff$1(acquireRefs, preRefs);
+    runtimeFinalizer.setFiberRefs(patch$1(patchRefs, runtimeFinalizer.id(), acquireRefs));
+    return ensuring(withRuntimeFlags(finalizer(exit), patchFlags), sync(() => {
+      runtimeFinalizer.setFiberRefs(patch$1(inverseRefs, runtimeFinalizer.id(), runtimeFinalizer.getFiberRefs()));
+    }));
+  })));
+});
+
+/* @internal */
+const daemonChildren = self => {
+  const forkScope = fiberRefLocally(currentForkScopeOverride, some(globalScope));
+  return forkScope(self);
+};
+
+/** @internal */
+const _existsParFound = /*#__PURE__*/Symbol("effect/Effect/existsPar/found");
+
+/* @internal */
+const exists = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => matchSimple(options, () => suspend(() => existsLoop(elements[Symbol.iterator](), 0, f)), () => matchEffect(forEachOptions(elements, (a, i) => if_(f(a, i), {
+  onTrue: fail(_existsParFound),
+  onFalse: unit
+}), options), {
+  onFailure: e => e === _existsParFound ? succeed(true) : fail(e),
+  onSuccess: () => succeed(false)
+})));
+const existsLoop = (iterator, index, f) => {
+  const next = iterator.next();
+  if (next.done) {
+    return succeed(false);
+  }
+  return pipe(flatMap$1(f(next.value, index), b => b ? succeed(b) : existsLoop(iterator, index + 1, f)));
+};
+
+/* @internal */
+const filter = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => {
+  const predicate = options?.negate ? (a, i) => map$1(f(a, i), not) : f;
+  return matchSimple(options, () => suspend(() => fromIterable(elements).reduceRight((effect, a, i) => zipWith(effect, suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), sync(() => new Array()))), () => map$1(forEachOptions(elements, (a, i) => map$1(predicate(a, i), b => b ? some(a) : none()), options), compact));
+});
+
+// === all
+
+const allResolveInput = input => {
+  if (Array.isArray(input) || isIterable(input)) {
+    return [input, none()];
+  }
+  const keys = Object.keys(input);
+  const size = keys.length;
+  return [keys.map(k => input[k]), some(values => {
+    const res = {};
+    for (let i = 0; i < size; i++) {
+      res[keys[i]] = values[i];
+    }
+    return res;
+  })];
+};
+const allValidate = (effects, reconcile, options) => {
+  const eitherEffects = [];
+  for (const effect of effects) {
+    eitherEffects.push(either(effect));
+  }
+  return flatMap$1(forEachOptions(eitherEffects, identity, {
+    concurrency: options?.concurrency,
+    batching: options?.batching
+  }), eithers => {
+    const none$1 = none();
+    const size = eithers.length;
+    const errors = new Array(size);
+    const successes = new Array(size);
+    let errored = false;
+    for (let i = 0; i < size; i++) {
+      const either = eithers[i];
+      if (either._tag === "Left") {
+        errors[i] = some(either.left);
+        errored = true;
+      } else {
+        successes[i] = either.right;
+        errors[i] = none$1;
+      }
+    }
+    if (errored) {
+      return reconcile._tag === "Some" ? fail(reconcile.value(errors)) : fail(errors);
+    } else if (options?.discard) {
+      return unit;
+    }
+    return reconcile._tag === "Some" ? succeed(reconcile.value(successes)) : succeed(successes);
+  });
+};
+const allEither = (effects, reconcile, options) => {
+  const eitherEffects = [];
+  for (const effect of effects) {
+    eitherEffects.push(either(effect));
+  }
+  if (options?.discard) {
+    return forEachOptions(eitherEffects, identity, {
+      concurrency: options?.concurrency,
+      batching: options?.batching,
+      discard: true
+    });
+  }
+  return map$1(forEachOptions(eitherEffects, identity, {
+    concurrency: options?.concurrency,
+    batching: options?.batching
+  }), eithers => reconcile._tag === "Some" ? reconcile.value(eithers) : eithers);
+};
+
+/* @internal */
+const all = (arg, options) => {
+  const [effects, reconcile] = allResolveInput(arg);
+  if (options?.mode === "validate") {
+    return allValidate(effects, reconcile, options);
+  } else if (options?.mode === "either") {
+    return allEither(effects, reconcile, options);
+  }
+  return reconcile._tag === "Some" ? map$1(forEachOptions(effects, identity, options), reconcile.value) : forEachOptions(effects, identity, options);
+};
+
+/* @internal */
+const allWith = options => arg => all(arg, options);
+
+/* @internal */
+const allSuccesses = (elements, options) => map$1(all(fromIterable(elements).map(exit), options), filterMap(exit => exitIsSuccess(exit) ? some(exit.i0) : none()));
+
+/* @internal */
+const replicate = /*#__PURE__*/dual(2, (self, n) => Array.from({
+  length: n
+}, () => self));
+
+/* @internal */
+const replicateEffect = /*#__PURE__*/dual(args => isEffect(args[0]), (self, n, options) => all(replicate(self, n), options));
+
+// @ts-expect-error
+const forEachOptions = /*#__PURE__*/dual(args => isIterable(args[0]), (self, f, options) => withFiberRuntime(r => {
+  const requestBatchingEnabled = options?.batching === true || options?.batching === "inherit" && r.getFiberRef(currentRequestBatching);
+  if (options?.discard) {
+    return match$1(options, () => finalizersMask(sequential)(restore => requestBatchingEnabled ? forEachBatchedDiscard(self, (a, i) => restore(f(a, i))) : forEachSequentialDiscard(self, (a, i) => restore(f(a, i)))), () => finalizersMask(parallel)(restore => forEachParUnboundedDiscard(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(parallelN(n))(restore => forEachParNDiscard(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
+  }
+  return match$1(options, () => finalizersMask(sequential)(restore => requestBatchingEnabled ? forEachParN(self, 1, (a, i) => restore(f(a, i)), true) : forEachSequential(self, (a, i) => restore(f(a, i)))), () => finalizersMask(parallel)(restore => forEachParUnbounded(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(parallelN(n))(restore => forEachParN(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
+}));
+
+/* @internal */
+const forEachParUnbounded = (self, f, batching) => suspend(() => {
+  const as = fromIterable(self);
+  const array = new Array(as.length);
+  const fn = (a, i) => flatMap$1(f(a, i), b => sync(() => array[i] = b));
+  return zipRight(forEachParUnboundedDiscard(as, fn, batching), succeed(array));
+});
+const forEachBatchedDiscard = (self, f) => suspend(() => {
+  const as = fromIterable(self);
+  const size = as.length;
+  if (size === 0) {
+    return unit;
+  } else if (size === 1) {
+    return asUnit(f(as[0], 0));
+  }
+  const effects = as.map(f);
+  const blocked$1 = new Array();
+  const loop = i => i === effects.length ? suspend(() => {
+    if (blocked$1.length > 0) {
+      const requests = blocked$1.map(b => b.i0).reduce(par);
+      return blocked(requests, forEachBatchedDiscard(blocked$1.map(b => b.i1), identity));
+    }
+    return unit;
+  }) : flatMapStep(effects[i], s => {
+    if (s._op === "Blocked") {
+      blocked$1.push(s);
+      return loop(i + 1);
+    } else if (s._op === "Failure") {
+      return suspend(() => {
+        if (blocked$1.length > 0) {
+          const requests = blocked$1.map(b => b.i0).reduce(par);
+          return blocked(requests, flatMap$1(forEachBatchedDiscard(blocked$1.map(b => b.i1), identity), () => s));
+        }
+        return unit;
+      });
+    } else {
+      return loop(i + 1);
+    }
+  });
+  return loop(0);
+});
+
+/* @internal */
+const forEachParUnboundedDiscard = (self, f, batching) => suspend(() => {
+  const as = fromIterable(self);
+  const size = as.length;
+  if (size === 0) {
+    return unit;
+  } else if (size === 1) {
+    return asUnit(f(as[0], 0));
+  }
+  return uninterruptibleMask(restore => {
+    const deferred = deferredUnsafeMake(none$2);
+    let ref = 0;
+    const residual = [];
+    const joinOrder = [];
+    const process = transplant(graft => forEachSequential(as, (a, i) => pipe(graft(pipe(suspend(() => restore((batching ? step : exit)(f(a, i)))), flatMap$1(exit => {
+      switch (exit._op) {
+        case "Failure":
+          {
+            if (residual.length > 0) {
+              const requests = residual.map(blocked => blocked.i0).reduce(par);
+              const _continue = forEachParUnboundedDiscard(residual, blocked => blocked.i1, batching);
+              return blocked(requests, matchCauseEffect(_continue, {
+                onFailure: cause => zipRight(deferredFail(deferred, void 0), failCause(parallel$1(cause, exit.cause))),
+                onSuccess: () => zipRight(deferredFail(deferred, void 0), failCause(exit.cause))
+              }));
+            }
+            return zipRight(deferredFail(deferred, void 0), failCause(exit.cause));
+          }
+        default:
+          {
+            if (exit._op === "Blocked") {
+              residual.push(exit);
+            }
+            if (ref + 1 === size) {
+              if (residual.length > 0) {
+                const requests = residual.map(blocked => blocked.i0).reduce(par);
+                const _continue = forEachParUnboundedDiscard(residual, blocked => blocked.i1, batching);
+                return deferredSucceed(deferred, blocked(requests, _continue));
+              } else {
+                deferredUnsafeDone(deferred, exitSucceed(exitUnit));
+              }
+            } else {
+              ref = ref + 1;
+            }
+            return unit;
+          }
+      }
+    }))), forkDaemon, map$1(fiber => {
+      fiber.addObserver(() => {
+        joinOrder.push(fiber);
+      });
+      return fiber;
+    }))));
+    return flatMap$1(process, fibers => matchCauseEffect(restore(deferredAwait(deferred)), {
+      onFailure: cause => flatMap$1(forEachParUnbounded(fibers, interruptFiber, batching), exits => {
+        const exit = exitCollectAll(exits, {
+          parallel: true
+        });
+        if (exit._tag === "Some" && exitIsFailure(exit.value)) {
+          return failCause(parallel$1(stripFailures(cause), exit.value.i0));
+        } else {
+          return failCause(stripFailures(cause));
+        }
+      }),
+      onSuccess: rest => flatMap$1(rest, () => forEachSequentialDiscard(joinOrder, f => f.inheritAll()))
+    }));
+  });
+});
+
+/* @internal */
+const forEachParN = (self, n, f, batching) => suspend(() => {
+  const as = fromIterable(self);
+  const array = new Array(as.length);
+  const fn = (a, i) => map$1(f(a, i), b => array[i] = b);
+  return zipRight(forEachParNDiscard(as, n, fn, batching), succeed(array));
+});
+
+/* @internal */
+const forEachParNDiscard = (self, n, f, batching) => suspend(() => {
+  let i = 0;
+  const iterator = self[Symbol.iterator]();
+  const residual = [];
+  const worker = flatMap$1(sync(() => iterator.next()), next => next.done ? unit : flatMap$1((batching ? step : exit)(asUnit(f(next.value, i++))), res => {
+    switch (res._op) {
+      case "Blocked":
+        {
+          residual.push(res);
+          return worker;
+        }
+      case "Failure":
+        {
+          return res;
+        }
+      case "Success":
+        return worker;
+    }
+  }));
+  const effects = [];
+  for (let i = 0; i < n; i++) {
+    effects.push(worker);
+  }
+  return flatMap$1(exit(forEachParUnboundedDiscard(effects, identity, batching)), exit => {
+    if (residual.length === 0) {
+      return exit;
+    }
+    const requests = residual.map(blocked => blocked.i0).reduce(par);
+    const _continue = forEachParNDiscard(residual, n, blocked => blocked.i1, batching);
+    if (exit._tag === "Failure") {
+      return blocked(requests, matchCauseEffect(_continue, {
+        onFailure: cause => exitFailCause(parallel$1(exit.cause, cause)),
+        onSuccess: () => exit
+      }));
+    }
+    return blocked(requests, _continue);
+  });
+});
+
+/* @internal */
+const fork = self => withFiberRuntime((state, status) => succeed(unsafeFork(self, state, status.runtimeFlags)));
+
+/* @internal */
+const forkDaemon = self => forkWithScopeOverride(self, globalScope);
+
+/* @internal */
+const forkWithErrorHandler = /*#__PURE__*/dual(2, (self, handler) => fork(onError(self, cause => {
+  const either = failureOrCause(cause);
+  switch (either._tag) {
+    case "Left":
+      {
+        return handler(either.left);
+      }
+    case "Right":
+      {
+        return failCause(either.right);
+      }
+  }
+})));
+
+/** @internal */
+const unsafeFork = (effect, parentFiber, parentRuntimeFlags, overrideScope = null) => {
+  const childFiber = unsafeMakeChildFiber(effect, parentFiber, parentRuntimeFlags, overrideScope);
+  childFiber.resume(effect);
+  return childFiber;
+};
+
+/** @internal */
+const unsafeMakeChildFiber = (effect, parentFiber, parentRuntimeFlags, overrideScope = null) => {
+  const childId = unsafeMake$1();
+  const parentFiberRefs = parentFiber.getFiberRefs();
+  const childFiberRefs = forkAs(parentFiberRefs, childId);
+  const childFiber = new FiberRuntime(childId, childFiberRefs, parentRuntimeFlags);
+  const childContext = getOrDefault$1(childFiberRefs, currentContext);
+  const supervisor = childFiber._supervisor;
+  supervisor.onStart(childContext, effect, some(parentFiber), childFiber);
+  childFiber.addObserver(exit => supervisor.onEnd(exit, childFiber));
+  const parentScope = overrideScope !== null ? overrideScope : pipe(parentFiber.getFiberRef(currentForkScopeOverride), getOrElse(() => parentFiber.scope()));
+  parentScope.add(parentRuntimeFlags, childFiber);
+  return childFiber;
+};
+
+/* @internal */
+const forkWithScopeOverride = (self, scopeOverride) => withFiberRuntime((parentFiber, parentStatus) => succeed(unsafeFork(self, parentFiber, parentStatus.runtimeFlags, scopeOverride)));
+
+/* @internal */
+const mergeAll = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => fromIterable(elements).reduce((acc, a, i) => zipWith(acc, a, (acc, a) => f(acc, a, i)), succeed(zero)), () => flatMap$1(make$1(zero), acc => flatMap$1(forEachOptions(elements, (effect, i) => flatMap$1(effect, a => update(acc, b => f(b, a, i))), options), () => get$2(acc)))));
+
+/* @internal */
+const partition = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => pipe(forEachOptions(elements, (a, i) => either(f(a, i)), options), map$1(chunk => partitionMap(chunk, identity))));
+
+/* @internal */
+const validateAll = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => flatMap$1(partition(elements, f, {
+  concurrency: options?.concurrency,
+  batching: options?.batching
+}), ([es, bs]) => es.length === 0 ? options?.discard ? unit : succeed(bs) : fail(es)));
+
+/* @internal */
+const raceAll = all => {
+  const list = fromIterable$1(all);
+  if (!isNonEmpty(list)) {
+    return dieSync(() => IllegalArgumentException(`Received an empty collection of effects`));
+  }
+  const self = headNonEmpty(list);
+  const effects = tailNonEmpty(list);
+  const inheritAll$1 = res => pipe(inheritAll(res[1]), as(res[0]));
+  return pipe(deferredMake(), flatMap$1(done => pipe(make$1(effects.length), flatMap$1(fails => uninterruptibleMask(restore => pipe(fork(interruptible(self)), flatMap$1(head => pipe(effects, forEachSequential(effect => fork(interruptible(effect))), map$1(unsafeFromArray), map$1(tail => pipe(tail, prepend(head))), tap(fibers => pipe(fibers, reduce(unit, (effect, fiber) => pipe(effect, zipRight(pipe(_await(fiber), flatMap$1(raceAllArbiter(fibers, fiber, done, fails)), fork, asUnit)))))), flatMap$1(fibers => pipe(restore(pipe(_await$1(done), flatMap$1(inheritAll$1))), onInterrupt(() => pipe(fibers, reduce(unit, (effect, fiber) => pipe(effect, zipLeft(interruptFiber(fiber))))))))))))))));
+};
+
+/* @internal */
+const raceAllArbiter = (fibers, winner, deferred, fails) => exit => exitMatchEffect(exit, {
+  onFailure: cause => pipe(modify(fails, fails => [fails === 0 ? pipe(deferredFailCause(deferred, cause), asUnit) : unit, fails - 1]), flatten),
+  onSuccess: value => pipe(deferredSucceed(deferred, [value, winner]), flatMap$1(set => set ? pipe(fromIterable$1(fibers), reduce(unit, (effect, fiber) => fiber === winner ? effect : pipe(effect, zipLeft(interruptFiber(fiber))))) : unit))
+});
+
+/* @internal */
+const reduceEffect = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => fromIterable(elements).reduce((acc, a, i) => zipWith(acc, a, (acc, a) => f(acc, a, i)), zero), () => suspend(() => pipe(mergeAll([zero, ...elements], none(), (acc, elem, i) => {
+  switch (acc._tag) {
+    case "None":
+      {
+        return some(elem);
+      }
+    case "Some":
+      {
+        return some(f(acc.value, elem, i));
+      }
+  }
+}, options), map$1(option => {
+  switch (option._tag) {
+    case "None":
+      {
+        throw new Error("BUG: Effect.reduceEffect - please report an issue at https://github.com/Effect-TS/io/issues");
+      }
+    case "Some":
+      {
+        return option.value;
+      }
+  }
+})))));
+
+/* @internal */
+const parallelFinalizers = self => contextWithEffect(context => match(getOption(context, scopeTag), {
+  onNone: () => self,
+  onSome: scope => {
+    switch (scope.strategy._tag) {
+      case "Parallel":
+        return self;
+      case "Sequential":
+      case "ParallelN":
+        return flatMap$1(scopeFork(scope, parallel), inner => scopeExtend(self, inner));
+    }
+  }
+}));
+
+/* @internal */
+const parallelNFinalizers = parallelism => self => contextWithEffect(context => match(getOption(context, scopeTag), {
+  onNone: () => self,
+  onSome: scope => {
+    if (scope.strategy._tag === "ParallelN" && scope.strategy.parallelism === parallelism) {
+      return self;
+    }
+    return flatMap$1(scopeFork(scope, parallelN(parallelism)), inner => scopeExtend(self, inner));
+  }
+}));
+
+/* @internal */
+const finalizersMask = strategy => self => contextWithEffect(context => match(getOption(context, scopeTag), {
+  onNone: () => self(identity),
+  onSome: scope => {
+    const patch = strategy._tag === "Parallel" ? parallelFinalizers : strategy._tag === "Sequential" ? sequentialFinalizers : parallelNFinalizers(strategy.parallelism);
+    switch (scope.strategy._tag) {
+      case "Parallel":
+        return patch(self(parallelFinalizers));
+      case "Sequential":
+        return patch(self(sequentialFinalizers));
+      case "ParallelN":
+        return patch(self(parallelNFinalizers(scope.strategy.parallelism)));
+    }
+  }
+}));
+
+/* @internal */
+const scopeWith = f => flatMap$1(scopeTag, f);
+
+/* @internal */
+const scopedEffect = effect => flatMap$1(scopeMake(), scope => scopeUse(scope)(effect));
+
+/* @internal */
+const sequentialFinalizers = self => contextWithEffect(context => match(getOption(context, scopeTag), {
+  onNone: () => self,
+  onSome: scope => {
+    switch (scope.strategy._tag) {
+      case "Sequential":
+        return self;
+      case "Parallel":
+      case "ParallelN":
+        return flatMap$1(scopeFork(scope, sequential), inner => scopeExtend(self, inner));
+    }
+  }
+}));
+
+/* @internal */
+const tagMetricsScoped = (key, value) => labelMetricsScoped([make$3(key, value)]);
+
+/* @internal */
+const labelMetricsScoped = labels => labelMetricsScopedSet(fromIterable$2(labels));
+
+/* @internal */
+const labelMetricsScopedSet = labels => fiberRefLocallyScopedWith(currentMetricLabels, set => pipe(set, union(labels)));
+
+/* @internal */
+const using = /*#__PURE__*/dual(2, (self, use) => acquireUseRelease(scopeMake(), scope => flatMap$1(scopeExtend(self, scope), use), (scope, exit) => scopeClose(scope, exit)));
+
+/** @internal */
+const validate = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => validateWith(self, that, (a, b) => [a, b], options));
+
+/** @internal */
+const validateWith = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, f, options) => flatten(zipWithOptions(exit(self), exit(that), (ea, eb) => exitZipWith(ea, eb, {
+  onSuccess: f,
+  onFailure: (ca, cb) => options?.concurrent ? parallel$1(ca, cb) : sequential$1(ca, cb)
+}), options)));
+
+/* @internal */
+const validateFirst = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => flip(forEachOptions(elements, (a, i) => flip(f(a, i)), options)));
+
+/* @internal */
+const withClockScoped = value => fiberRefLocallyScopedWith(currentServices, add(clockTag, value));
+
+/* @internal */
+const withConfigProviderScoped = value => fiberRefLocallyScopedWith(currentServices, add(configProviderTag, value));
+
+/* @internal */
+const withEarlyRelease = self => scopeWith(parent => flatMap$1(scopeFork(parent, sequential$2), child => pipe(self, scopeExtend(child), map$1(value => [fiberIdWith(fiberId => scopeClose(child, exitInterrupt(fiberId))), value]))));
+
+/** @internal */
+const zipOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (a, b) => [a, b], options));
+
+/** @internal */
+const zipLeftOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (a, _) => a, options));
+
+/** @internal */
+const zipRightOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (_, b) => b, options));
+
+/** @internal */
+const zipWithOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, f, options) => map$1(all([self, that], {
+  concurrency: options?.concurrent ? 2 : 1,
+  batching: options?.batching
+}), ([a, a2]) => f(a, a2)));
+
+/* @internal */
+const withRuntimeFlagsScoped = update => {
+  if (update === empty$1) {
+    return unit;
+  }
+  return pipe(runtimeFlags, flatMap$1(runtimeFlags => {
+    const updatedRuntimeFlags = patch(runtimeFlags, update);
+    const revertRuntimeFlags = diff(updatedRuntimeFlags, runtimeFlags);
+    return pipe(updateRuntimeFlags(update), zipRight(addFinalizer(() => updateRuntimeFlags(revertRuntimeFlags))), asUnit);
+  }), uninterruptible);
+};
+
+// circular with ReleaseMap
+
+/* @internal */
+const releaseMapReleaseAll = (strategy, exit$1) => self => suspend(() => {
+  switch (self.state._tag) {
+    case "Exited":
+      {
+        return unit;
+      }
+    case "Running":
+      {
+        const finalizersMap = self.state.finalizers;
+        const update = self.state.update;
+        const finalizers = Array.from(finalizersMap.keys()).sort((a, b) => b - a).map(key => finalizersMap.get(key));
+        self.state = {
+          _tag: "Exited",
+          nextKey: self.state.nextKey,
+          exit: exit$1,
+          update
+        };
+        return isSequential(strategy) ? pipe(finalizers, forEachSequential(fin => exit(update(fin)(exit$1))), flatMap$1(results => pipe(exitCollectAll(results), map(exitAsUnit), getOrElse(() => exitUnit)))) : isParallel(strategy) ? pipe(forEachParUnbounded(finalizers, fin => exit(update(fin)(exit$1)), false), flatMap$1(results => pipe(exitCollectAll(results, {
+          parallel: true
+        }), map(exitAsUnit), getOrElse(() => exitUnit)))) : pipe(forEachParN(finalizers, strategy.parallelism, fin => exit(update(fin)(exit$1)), false), flatMap$1(results => pipe(exitCollectAll(results, {
+          parallel: true
+        }), map(exitAsUnit), getOrElse(() => exitUnit))));
+      }
+  }
+});
+
+// circular with Scope
+
+/** @internal */
+const scopeTag = /*#__PURE__*/Tag(ScopeTypeId);
+
+/* @internal */
+const scope = scopeTag;
+
+/* @internal */
+const scopeMake = (strategy = sequential$2) => map$1(releaseMapMake, rm => ({
+  [ScopeTypeId]: ScopeTypeId,
+  [CloseableScopeTypeId]: CloseableScopeTypeId,
+  strategy,
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  fork: strategy => uninterruptible(pipe(scopeMake(strategy), flatMap$1(scope => pipe(releaseMapAdd(rm, exit => scopeClose(scope, exit)), tap(fin => scopeAddFinalizerExit(scope, fin)), as(scope))))),
+  close: exit => asUnit(releaseMapReleaseAll(strategy, exit)(rm)),
+  addFinalizer: fin => asUnit(releaseMapAdd(fin)(rm))
+}));
+
+/* @internal */
+const scopeExtend = /*#__PURE__*/dual(2, (effect, scope) => mapInputContext(effect,
+// @ts-expect-error
+merge(make$2(scopeTag, scope))));
+
+/* @internal */
+const scopeUse = /*#__PURE__*/dual(2, (effect, scope) => pipe(effect, scopeExtend(scope), onExit(exit => scope.close(exit))));
+
+// circular with Supervisor
+
+/** @internal */
+const fiberRefUnsafeMakeSupervisor = initial => fiberRefUnsafeMakePatch(initial, {
+  differ: differ,
+  fork: empty$2
+});
+
+// circular with FiberRef
+
+/* @internal */
+const fiberRefLocallyScoped = /*#__PURE__*/dual(2, (self, value) => asUnit(acquireRelease(flatMap$1(fiberRefGet(self), oldValue => as(fiberRefSet(self, value), oldValue)), oldValue => fiberRefSet(self, oldValue))));
+
+/* @internal */
+const fiberRefLocallyScopedWith = /*#__PURE__*/dual(2, (self, f) => fiberRefGetWith(self, a => fiberRefLocallyScoped(self, f(a))));
+
+/* @internal */
+const fiberRefMake = (initial, options) => fiberRefMakeWith(() => fiberRefUnsafeMake(initial, options));
+
+/* @internal */
+const fiberRefMakeWith = ref => acquireRelease(tap(sync(ref), ref => fiberRefUpdate(ref, identity)), fiberRef => fiberRefDelete(fiberRef));
+
+/* @internal */
+const fiberRefMakeContext = initial => fiberRefMakeWith(() => fiberRefUnsafeMakeContext(initial));
+
+/* @internal */
+const fiberRefMakeRuntimeFlags = initial => fiberRefMakeWith(() => fiberRefUnsafeMakeRuntimeFlags(initial));
+
+/** @internal */
+const currentRuntimeFlags = /*#__PURE__*/fiberRefUnsafeMakeRuntimeFlags(none$3);
+
+/** @internal */
+const currentSupervisor = /*#__PURE__*/fiberRefUnsafeMakeSupervisor(none$1);
+
+// circular with Fiber
+
+/* @internal */
+const fiberAwaitAll = fibers => asUnit(_await(fiberAll(fibers)));
+
+/** @internal */
+const fiberAll = fibers => ({
+  [FiberTypeId]: fiberVariance,
+  id: () => fromIterable(fibers).reduce((id, fiber) => combine(id, fiber.id()), none$2),
+  await: () => exit(forEachParUnbounded(fibers, fiber => flatten(fiber.await()), false)),
+  children: () => map$1(forEachParUnbounded(fibers, fiber => fiber.children(), false), flatten$1),
+  inheritAll: () => forEachSequentialDiscard(fibers, fiber => fiber.inheritAll()),
+  poll: () => map$1(forEachSequential(fibers, fiber => fiber.poll()), reduceRight(some(exitSucceed(new Array())), (optionB, optionA) => {
+    switch (optionA._tag) {
+      case "None":
+        {
+          return none();
+        }
+      case "Some":
+        {
+          switch (optionB._tag) {
+            case "None":
+              {
+                return none();
+              }
+            case "Some":
+              {
+                return some(exitZipWith(optionA.value, optionB.value, {
+                  onSuccess: (a, chunk) => [a, ...chunk],
+                  onFailure: parallel$1
+                }));
+              }
+          }
+        }
+    }
+  })),
+  interruptAsFork: fiberId => forEachSequentialDiscard(fibers, fiber => fiber.interruptAsFork(fiberId)),
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+});
+
+/* @internal */
+const fiberInterruptFork = self => asUnit(forkDaemon(interruptFiber(self)));
+
+/* @internal */
+const fiberJoinAll = fibers => asUnit(join(fiberAll(fibers)));
+
+/* @internal */
+const fiberScoped = self => acquireRelease(succeed(self), interruptFiber);
+
+//
+// circular race
+//
+
+/** @internal */
+const raceWith = /*#__PURE__*/dual(3, (self, other, options) => raceFibersWith(self, other, {
+  onSelfWin: (winner, loser) => flatMap$1(winner.await(), exit => {
+    switch (exit._tag) {
+      case OP_SUCCESS:
+        {
+          return flatMap$1(winner.inheritAll(), () => options.onSelfDone(exit, loser));
+        }
+      case OP_FAILURE:
+        {
+          return options.onSelfDone(exit, loser);
+        }
+    }
+  }),
+  onOtherWin: (winner, loser) => flatMap$1(winner.await(), exit => {
+    switch (exit._tag) {
+      case OP_SUCCESS:
+        {
+          return flatMap$1(winner.inheritAll(), () => options.onOtherDone(exit, loser));
+        }
+      case OP_FAILURE:
+        {
+          return options.onOtherDone(exit, loser);
+        }
+    }
+  })
+}));
+
+/** @internal */
+const disconnect = self => uninterruptibleMask(restore => fiberIdWith(fiberId => flatMap$1(forkDaemon(restore(self)), fiber => pipe(restore(join(fiber)), onInterrupt(() => pipe(fiber, interruptAsFork(fiberId)))))));
+
+/** @internal */
+const race = /*#__PURE__*/dual(2, (self, that) => fiberIdWith(parentFiberId => raceWith(self, that, {
+  onSelfDone: (exit, right) => exitMatchEffect(exit, {
+    onFailure: cause => pipe(join(right), mapErrorCause(cause2 => parallel$1(cause, cause2))),
+    onSuccess: value => pipe(right, interruptAsFiber(parentFiberId), as(value))
+  }),
+  onOtherDone: (exit, left) => exitMatchEffect(exit, {
+    onFailure: cause => pipe(join(left), mapErrorCause(cause2 => parallel$1(cause2, cause))),
+    onSuccess: value => pipe(left, interruptAsFiber(parentFiberId), as(value))
+  })
+})));
+
+/** @internal */
+const raceFibersWith = /*#__PURE__*/dual(3, (self, other, options) => withFiberRuntime((parentFiber, parentStatus) => {
+  const parentRuntimeFlags = parentStatus.runtimeFlags;
+  const raceIndicator = make$4(true);
+  const leftFiber = unsafeMakeChildFiber(self, parentFiber, parentRuntimeFlags, options.selfScope);
+  const rightFiber = unsafeMakeChildFiber(other, parentFiber, parentRuntimeFlags, options.otherScope);
+  return async(cb => {
+    leftFiber.addObserver(() => completeRace(leftFiber, rightFiber, options.onSelfWin, raceIndicator, cb));
+    rightFiber.addObserver(() => completeRace(rightFiber, leftFiber, options.onOtherWin, raceIndicator, cb));
+    leftFiber.startFork(self);
+    rightFiber.startFork(other);
+  }, combine(leftFiber.id(), rightFiber.id()));
+}));
+const completeRace = (winner, loser, cont, ab, cb) => {
+  if (compareAndSet(true, false)(ab)) {
+    cb(cont(winner, loser));
+  }
+};
+
+/** @internal */
+const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => uninterruptibleMask(restore => matchCauseEffect(restore(self), {
+  onFailure: cause1 => matchCauseEffect(finalizer, {
+    onFailure: cause2 => failCause(sequential$1(cause1, cause2)),
+    onSuccess: () => failCause(cause1)
+  }),
+  onSuccess: a => as(finalizer, a)
+})));
+
+/** @internal */
+const invokeWithInterrupt = (dataSource, all) => fiberIdWith(id => flatMap$1(flatMap$1(forkDaemon(interruptible(dataSource)), processing => async(cb => {
+  const counts = all.map(_ => _.listeners.count);
+  const checkDone = () => {
+    if (counts.every(count => count === 0)) {
+      cleanup.forEach(f => f());
+      cb(interruptFiber(processing));
+    }
+  };
+  processing.addObserver(exit => {
+    cleanup.forEach(f => f());
+    cb(exit);
+  });
+  const cleanup = all.map((r, i) => {
+    const observer = count => {
+      counts[i] = count;
+      checkDone();
+    };
+    r.listeners.addObserver(observer);
+    return () => r.listeners.removeObserver(observer);
+  });
+  checkDone();
+  return sync(() => {
+    cleanup.forEach(f => f());
+  });
+})), () => suspend(() => {
+  const residual = all.flatMap(entry => {
+    if (!entry.state.completed) {
+      return [entry];
+    }
+    return [];
+  });
+  return forEachSequentialDiscard(residual, entry => complete(entry.request, exitInterrupt(id)));
+})));
+
+/** @internal */
+const interruptWhenPossible = /*#__PURE__*/dual(2, (self, all) => fiberRefGetWith(currentRequestMap, map => suspend(() => {
+  const entries = fromIterable(all).flatMap(_ => map.has(_) ? [map.get(_)] : []);
+  return invokeWithInterrupt(self, entries);
+})));
+
+// circular Tracer
+
+/** @internal */
+const useSpanScoped = (name, options) => acquireRelease(makeSpan(name, options), (span, exit) => flatMap$1(currentTimeNanosTracing, endTime => sync(() => span.end(endTime, exit))));
+
+/* @internal */
+const withSpanScoped = (name, options) => flatMap$1(useSpanScoped(name, options), span => fiberRefLocallyScopedWith(currentTracerSpan, prepend$1(span)));
+
+/* @internal */
+const withTracerScoped = value => fiberRefLocallyScopedWith(currentServices, add(tracerTag, value));
+
+/* @internal */
+const withParentSpanScoped = span => fiberRefLocallyScopedWith(currentTracerSpan, prepend$1(span));
+
+export { FiberRuntime, acquireRelease, acquireReleaseInterruptible, addFinalizer, all, allSuccesses, allWith, currentLoggers, currentMinimumLogLevel, currentRuntimeFlags, currentSupervisor, daemonChildren, defaultLogger, disconnect, ensuring, exists, fiberActive, fiberAll, fiberAwaitAll, fiberFailures, fiberInterruptFork, fiberJoinAll, fiberLifetimes, fiberRefLocallyScoped, fiberRefLocallyScopedWith, fiberRefMake, fiberRefMakeContext, fiberRefMakeRuntimeFlags, fiberRefMakeWith, fiberRefUnsafeMakeSupervisor, fiberScoped, fiberStarted, fiberSuccesses, filter, finalizersMask, forEachOptions, forEachParN, forEachParNDiscard, forEachParUnbounded, forEachParUnboundedDiscard, fork, forkDaemon, forkWithErrorHandler, getConsole, interruptWhenPossible, invokeWithInterrupt, labelMetricsScoped, labelMetricsScopedSet, logFmtLogger, mergeAll, parallelFinalizers, parallelNFinalizers, partition, race, raceAll, raceFibersWith, raceWith, reduceEffect, releaseMapReleaseAll, replicate, replicateEffect, runtimeFiberVariance, scope, scopeExtend, scopeMake, scopeTag, scopeUse, scopeWith, scopedEffect, sequentialFinalizers, tagMetricsScoped, tracerLogger, unsafeFork, unsafeMakeChildFiber, useSpanScoped, using, validate, validateAll, validateFirst, validateWith, withClockScoped, withConfigProviderScoped, withEarlyRelease, withParentSpanScoped, withRuntimeFlagsScoped, withSpanScoped, withTracerScoped, zipLeftOptions, zipOptions, zipRightOptions, zipWithOptions };