effect 2.0.0-next.37 → 2.0.0-next.38

package/dist/fiberRuntime-bfcf5f49.esm.js

@@ -0,0 +1,2857 @@
+import { n as not } from './Boolean-bf38e241.esm.js';
+import { o as of$1, h as isNonEmpty, j as headNonEmpty, p as prepend, t as tailNonEmpty, f as fromIterable$2, l as unsafeFromArray } from './Chunk-4c1f4599.esm.js';
+import { g as get$2, a as getOption, b as add$1, T as Tag, m as merge, c as make$6, u as unsafeGet } from './Context-c41aa832.esm.js';
+import { _ as _await$1 } from './Deferred-9010d2ac.esm.js';
+import { p as parallel, a as sequential, s as sequential$2, b as parallelN, i as isSequential, c as isParallel } from './ExecutionStrategy-e3775e86.esm.js';
+import { t as threadName, a as threadName$1, c as combine$1, n as none$3, u as unsafeMake$1 } from './FiberId-17e50f05.esm.js';
+import { g as getOrDefault } from './FiberRefs-f705c1b5.esm.js';
+import { d as diff$2, p as patch$2 } from './FiberRefsPatch-04e0adc7.esm.js';
+import { i as isDone, d as done, s as suspended, r as running } from './FiberStatus-7a24d5ef.esm.js';
+import { d as dual, b as constVoid, p as pipe, i as identity } from './Function-12511160.esm.js';
+import { e as empty$2, m as make$2, u as union, c as fromIterable, i as isHashSet, r as reduce, d as difference, s as size$1 } from './HashSet-ae2856c1.esm.js';
+import { r as fiberRefUnsafeMake, v as fiberRefGetWith, x as currentConcurrency, y as empty$1, A as pretty, t as tap, s as sync$2, B as matchCauseEffect, C as failCause, j as succeed$3, D as defects, m as map$2, E as currentMetricLabels, q as deferredUnsafeDone, F as matchEffect, G as exitFail, H as exitSucceed, J as zip$2, p as unit, K as currentTracerSpan, L as fiberRefUnsafeMakeHashSet, u as uninterruptible, M as isEffect, w as withFiberRuntime, N as fiberRefLocally, O as currentForkScopeOverride, P as exit, Q as exitIsSuccess, R as onError, S as failureOrCause, T as partitionMap, U as either, f as flatMap$1, V as fail$1, W as dieSync, X as uninterruptibleMask, Y as interruptible, Z as forEachSequential, z as zipRight$1, c as asUnit, o as onInterrupt, _ as zipLeft$1, $ as interruptFiber, d as deferredMake, a0 as exitMatchEffect, a1 as flatten, a2 as deferredFailCause, g as deferredSucceed, a3 as contextWithEffect, a4 as scopeFork, a5 as acquireUseRelease, a6 as scopeClose, a7 as exitZipWith, a8 as parallel$1, a9 as sequential$1, aa as flip, ab as fiberIdWith, ac as updateRuntimeFlags, ad as runtimeFlags, ae as ScopeTypeId, af as releaseMapMake, ag as CloseableScopeTypeId, ah as releaseMapAdd, ai as scopeAddFinalizerExit, aj as as, ak as mapInputContext, al as onExit, am as fiberRefUnsafeMakePatch, an as fiberRefGet, ao as fiberRefSet, ap as fiberRefUpdate, aq as fiberRefDelete, ar as fiberRefUnsafeMakeContext, as as fiberRefUnsafeMakeRuntimeFlags, at as forEachSequentialDiscard, a as suspend, au as currentInterruptedCause, l as deferredUnsafeMake, b as deferredAwait, av as async, aw as interrupt, ax as currentSchedulingPriority, ay as isEmpty, az as whileLoop, aA as currentUnhandledErrorLogLevel, aB as isInterruptedOnly, aC as currentLogLevel, aD as currentLogSpan, aE as currentLogAnnotations, aF as exitFailCause, aG as exitUnit, aH as die, aI as currentContext, aJ as NoSuchElementException, aK as stripFailures, aL as blocked, aM as catchAllCause, aN as runRequestBlock, aO as RevertFlags, aP as yieldNow$1, aQ as isEffectError, aR as isInterruptedException, aS as withRuntimeFlags, aT as if_, aU as zipWith, aV as currentRequestBatching, aW as transplant, aX as step, aY as par, aZ as deferredFail, a_ as exitCollectAll, a$ as exitIsFailure, b0 as IllegalArgumentException, h as exitInterrupt, b1 as exitAsUnit, b2 as interruptAsFiber, b3 as flatten$2, b4 as sequentialCollectionToChunk, b5 as flatMapStep } from './core-64ab7ff5.esm.js';
+import { c as currentServices, a as clockTag, t as tracerTag, b as consoleTag } from './defaultServices-b9ca1236.esm.js';
+import { g as globalValue } from './GlobalValue-b5edf230.esm.js';
+import { c as configProviderTag } from './configProvider-c997961d.esm.js';
+import { t as tapDefect, a as tapError, m as makeSpan, c as currentTimeNanosTracing, b as mapErrorCause } from './core-effect-57445976.esm.js';
+import { g as globalScope, _ as _await, F as FiberTypeId, f as fiberVariance, j as join, R as RuntimeFiberTypeId, r as resume, u as unsafeMake, s as stateful, i as interruptSignal, c as currentFiberURI, O as OP_STATEFUL, a as OP_RESUME, b as OP_INTERRUPT_SIGNAL, d as OP_YIELD_NOW, y as yieldNow, e as inheritAll, h as interruptAsFork } from './fiber-8fb398f3.esm.js';
+import { g as get$1, j as joinAs, d as delete_, u as updatedAs, f as forkAs, a as getOrDefault$1 } from './fiberRefs-69cce1a0.esm.js';
+import { b as size } from './HashMap-6c230bde.esm.js';
+import { i as isCons, h as head, p as prepend$1 } from './List-6e58a1e9.esm.js';
+import { r as render } from './LogSpan-f36e9619.esm.js';
+import { s as some, n as none$2, f as flatMap, m as map$3, b as match$1, e as fromNullable, i as isSome, g as getOrElse } from './Option-df40d2b9.esm.js';
+import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
+import { c as clockWith } from './Clock-f8b987d7.esm.js';
+import { t as toMillis, n as nanos } from './Duration-98bca14c.esm.js';
+import { e as exponential, f as fromChunk } from './boundaries-52029180.esm.js';
+import { c as counter$1, f as frequency$1, g as gauge$1, h as histogram$1, s as summary$1, t as taggedWithLabelSet } from './key-340a2bae.esm.js';
+import { m as make$3 } from './label-0cc6c9a0.esm.js';
+import { m as make$1 } from './registry-c59aeb06.esm.js';
+import { C as forEach, f as fromIterable$1, a as filterMap, A as reduce$1, D as flatten$1, B as reduceRight, E as compact } from './ReadonlyArray-0a71b226.esm.js';
+import { a as OP_FAILURE, O as OP_SUCCESS, i as OP_YIELD, k as OP_ASYNC, c as OP_ON_FAILURE, d as OP_ON_SUCCESS, h as OP_WHILE, l as OP_TAG, g as OP_SYNC, j as OP_REVERT_FLAGS, e as OP_ON_SUCCESS_AND_FAILURE, b as OP_WITH_RUNTIME, f as OP_UPDATE_RUNTIME_FLAGS, m as OP_COMMIT } from './Effectable-a292d920.esm.js';
+import { s as struct } from './Data-dee529b9.esm.js';
+import { b as empty$3, p as patch$1, c as diff$1, r as runtimeMetrics, f as exclude, W as WindDown, I as Interruption, g as interruptible$1, h as enable, j as cooperativeYielding, O as OpSupervision, n as none$4 } from './RuntimeFlagsPatch-51f77dce.esm.js';
+import { g as get, s as set$1, m as make$7, c as compareAndSet } from './MutableRef-2734b082.esm.js';
+import { a as add, r as remove } from './SortedSet-ffc2cefd.esm.js';
+import { m as make$4 } from './Differ-a249bf4d.esm.js';
+import { e as equals } from './Equal-2a99fde3.esm.js';
+import { f as fromLiteral, g as greaterThan } from './LogLevel-5a4fa506.esm.js';
+import { a as isIterable } from './Predicate-6b61b95b.esm.js';
+import { m as make$5, a as modify, u as update$1, g as get$3 } from './Ref-5eefaff1.esm.js';
+import { c as currentScheduler } from './Scheduler-844c1a90.esm.js';
+
+/** @internal */
+const currentRequestMap = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentRequestMap"), () => fiberRefUnsafeMake(new Map()));
+
+/** @internal */
+const match = (options, sequential, unbounded, bounded) => {
+  switch (options?.concurrency) {
+    case undefined:
+      {
+        return sequential();
+      }
+    case "unbounded":
+      {
+        return unbounded();
+      }
+    case "inherit":
+      {
+        return fiberRefGetWith(currentConcurrency, concurrency => concurrency === "unbounded" ? unbounded() : concurrency > 1 ? bounded(concurrency) : sequential());
+      }
+    default:
+      {
+        return options.concurrency > 1 ? bounded(options.concurrency) : sequential();
+      }
+  }
+};
+
+/** @internal */
+const matchSimple = (options, sequential, concurrent) => {
+  switch (options?.concurrency) {
+    case undefined:
+      {
+        return sequential();
+      }
+    case "unbounded":
+      {
+        return concurrent();
+      }
+    case "inherit":
+      {
+        return fiberRefGetWith(currentConcurrency, concurrency => concurrency === "unbounded" ? concurrent() : concurrency > 1 ? concurrent() : sequential());
+      }
+    default:
+      {
+        return options.concurrency > 1 ? concurrent() : sequential();
+      }
+  }
+};
+
+/** @internal */
+const LoggerSymbolKey = "effect/Logger";
+
+/** @internal */
+const LoggerTypeId = /*#__PURE__*/Symbol.for(LoggerSymbolKey);
+
+/** @internal */
+const loggerVariance = {
+  _Message: _ => _,
+  _Output: _ => _
+};
+
+/** @internal */
+const makeLogger = log => ({
+  [LoggerTypeId]: loggerVariance,
+  log,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+});
+
+/** @internal */
+const mapInput$1 = /*#__PURE__*/dual(2, (self, f) => makeLogger(options => self.log({
+  ...options,
+  message: f(options.message)
+})));
+
+/** @internal */
+const filterLogLevel = /*#__PURE__*/dual(2, (self, f) => makeLogger(options => f(options.logLevel) ? some(self.log(options)) : none$2()));
+
+/** @internal */
+const map$1 = /*#__PURE__*/dual(2, (self, f) => makeLogger(options => f(self.log(options))));
+
+/** @internal */
+const none$1 = {
+  [LoggerTypeId]: loggerVariance,
+  log: constVoid,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+
+/** @internal */
+const simple = log => ({
+  [LoggerTypeId]: loggerVariance,
+  log: ({
+    message
+  }) => log(message),
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+});
+
+/** @internal */
+const succeed$2 = value => {
+  return simple(() => value);
+};
+
+/** @internal */
+const sync$1 = evaluate => {
+  return simple(evaluate);
+};
+
+/** @internal */
+const zip$1 = /*#__PURE__*/dual(2, (self, that) => makeLogger(options => [self.log(options), that.log(options)]));
+
+/** @internal */
+const zipLeft = /*#__PURE__*/dual(2, (self, that) => map$1(zip$1(self, that), tuple => tuple[0]));
+
+/** @internal */
+const zipRight = /*#__PURE__*/dual(2, (self, that) => map$1(zip$1(self, that), tuple => tuple[1]));
+
+/** @internal */
+const stringLogger = /*#__PURE__*/makeLogger(({
+  annotations,
+  cause,
+  date,
+  fiberId,
+  logLevel,
+  message,
+  spans
+}) => {
+  const nowMillis = date.getTime();
+  const outputArray = [`timestamp=${date.toISOString()}`, `level=${logLevel.label}`, `fiber=${threadName(fiberId)}`];
+  let output = outputArray.join(" ");
+  const stringMessage = serializeUnknown(message);
+  if (stringMessage.length > 0) {
+    output = output + " message=";
+    output = appendQuoted(stringMessage, output);
+  }
+  if (cause != null && cause != empty$1) {
+    output = output + " cause=";
+    output = appendQuoted(pretty(cause), output);
+  }
+  if (isCons(spans)) {
+    output = output + " ";
+    let first = true;
+    for (const span of spans) {
+      if (first) {
+        first = false;
+      } else {
+        output = output + " ";
+      }
+      output = output + pipe(span, render(nowMillis));
+    }
+  }
+  if (pipe(annotations, size) > 0) {
+    output = output + " ";
+    let first = true;
+    for (const [key, value] of annotations) {
+      if (first) {
+        first = false;
+      } else {
+        output = output + " ";
+      }
+      output = output + filterKeyName(key);
+      output = output + "=";
+      output = appendQuoted(String(value), output);
+    }
+  }
+  return output;
+});
+const serializeUnknown = u => {
+  try {
+    return typeof u === "object" ? JSON.stringify(u) : String(u);
+  } catch (_) {
+    return String(u);
+  }
+};
+
+/** @internal */
+const escapeDoubleQuotes = str => `"${str.replace(/\\([\s\S])|(")/g, "\\$1$2")}"`;
+const textOnly = /^[^\s"=]+$/;
+
+/** @internal */
+const appendQuoted = (label, output) => output + (label.match(textOnly) ? label : escapeDoubleQuotes(label));
+
+/** @internal */
+const logfmtLogger = /*#__PURE__*/makeLogger(({
+  annotations,
+  cause,
+  date,
+  fiberId,
+  logLevel,
+  message,
+  spans
+}) => {
+  const nowMillis = date.getTime();
+  const outputArray = [`timestamp=${date.toISOString()}`, `level=${logLevel.label}`, `fiber=${threadName(fiberId)}`];
+  let output = outputArray.join(" ");
+  const stringMessage = serializeUnknown(message);
+  if (stringMessage.length > 0) {
+    output = output + " message=";
+    output = appendQuotedLogfmt(stringMessage, output);
+  }
+  if (cause != null && cause != empty$1) {
+    output = output + " cause=";
+    output = appendQuotedLogfmt(pretty(cause), output);
+  }
+  if (isCons(spans)) {
+    output = output + " ";
+    let first = true;
+    for (const span of spans) {
+      if (first) {
+        first = false;
+      } else {
+        output = output + " ";
+      }
+      output = output + pipe(span, renderLogSpanLogfmt(nowMillis));
+    }
+  }
+  if (pipe(annotations, size) > 0) {
+    output = output + " ";
+    let first = true;
+    for (const [key, value] of annotations) {
+      if (first) {
+        first = false;
+      } else {
+        output = output + " ";
+      }
+      output = output + filterKeyName(key);
+      output = output + "=";
+      output = appendQuotedLogfmt(String(value), output);
+    }
+  }
+  return output;
+});
+
+/** @internal */
+const filterKeyName = key => key.replace(/[\s="]/g, "_");
+
+/** @internal */
+const escapeDoubleQuotesLogfmt = str => JSON.stringify(str);
+
+/** @internal */
+const appendQuotedLogfmt = (label, output) => output + (label.match(textOnly) ? label : escapeDoubleQuotesLogfmt(label));
+
+/** @internal */
+const renderLogSpanLogfmt = now => self => {
+  const label = filterKeyName(self.label);
+  return `${label}=${now - self.startTime}ms`;
+};
+
+/** @internal */
+const MetricSymbolKey = "effect/Metric";
+
+/** @internal */
+const MetricTypeId = /*#__PURE__*/Symbol.for(MetricSymbolKey);
+
+/** @internal */
+const metricVariance = {
+  _Type: _ => _,
+  _In: _ => _,
+  _Out: _ => _
+};
+
+/** @internal */
+const globalMetricRegistry = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Metric/globalMetricRegistry"), () => make$1());
+
+/** @internal */
+const make = function (keyType, unsafeUpdate, unsafeValue) {
+  const metric = Object.assign(effect => tap(effect, a => sync$2(() => unsafeUpdate(a, empty$2()))), {
+    [MetricTypeId]: metricVariance,
+    keyType,
+    unsafeUpdate,
+    unsafeValue,
+    pipe() {
+      return pipeArguments(this, arguments);
+    }
+  });
+  return metric;
+};
+
+/** @internal */
+const mapInput = /*#__PURE__*/dual(2, (self, f) => make(self.keyType, (input, extraTags) => self.unsafeUpdate(f(input), extraTags), self.unsafeValue));
+
+/** @internal */
+const counter = (name, description) => fromMetricKey(counter$1(name, description));
+
+/** @internal */
+const frequency = (name, description) => fromMetricKey(frequency$1(name, description));
+
+/** @internal */
+const withConstantInput = /*#__PURE__*/dual(2, (self, input) => mapInput(self, () => input));
+
+/** @internal */
+const fromMetricKey = key => {
+  const hook = extraTags => {
+    const fullKey = pipe(key, taggedWithLabelSet(extraTags));
+    return globalMetricRegistry.get(fullKey);
+  };
+  return make(key.keyType, (input, extraTags) => hook(extraTags).update(input), extraTags => hook(extraTags).get());
+};
+
+/** @internal */
+const gauge = (name, description) => fromMetricKey(gauge$1(name, description));
+
+/** @internal */
+const histogram = (name, boundaries, description) => fromMetricKey(histogram$1(name, boundaries, description));
+
+/* @internal */
+const increment = self => update(self, 1);
+
+/* @internal */
+const incrementBy = /*#__PURE__*/dual(2, (self, amount) => update(self, amount));
+
+/** @internal */
+const map = /*#__PURE__*/dual(2, (self, f) => make(self.keyType, self.unsafeUpdate, extraTags => f(self.unsafeValue(extraTags))));
+
+/** @internal */
+const mapType = /*#__PURE__*/dual(2, (self, f) => make(f(self.keyType), self.unsafeUpdate, self.unsafeValue));
+
+/* @internal */
+const set = /*#__PURE__*/dual(2, (self, value) => update(self, value));
+
+/** @internal */
+const succeed$1 = out => make(void 0, constVoid, () => out);
+
+/** @internal */
+const sync = evaluate => make(void 0, constVoid, evaluate);
+
+/** @internal */
+const summary = options => withNow(summaryTimestamp(options));
+
+/** @internal */
+const summaryTimestamp = options => fromMetricKey(summary$1(options));
+
+/** @internal */
+const tagged$1 = /*#__PURE__*/dual(3, (self, key, value) => taggedWithLabels(self, make$2(make$3(key, value))));
+
+/** @internal */
+const taggedWithLabelsInput = /*#__PURE__*/dual(2, (self, f) => map(make(self.keyType, (input, extraTags) => self.unsafeUpdate(input, union(fromIterable(f(input)), extraTags)), self.unsafeValue), constVoid));
+
+/** @internal */
+const taggedWithLabels = /*#__PURE__*/dual(2, (self, extraTagsIterable) => {
+  const extraTags = isHashSet(extraTagsIterable) ? extraTagsIterable : fromIterable(extraTagsIterable);
+  return make(self.keyType, (input, extraTags1) => self.unsafeUpdate(input, pipe(extraTags, union(extraTags1))), extraTags1 => self.unsafeValue(pipe(extraTags, union(extraTags1))));
+});
+
+/** @internal */
+const timer = name => {
+  const boundaries = exponential({
+    start: 1,
+    factor: 2,
+    count: 100
+  });
+  const base = pipe(histogram(name, boundaries), tagged$1("time_unit", "milliseconds"));
+  return mapInput(base, toMillis);
+};
+
+/** @internal */
+const timerWithBoundaries = (name, boundaries) => {
+  const base = pipe(histogram(name, fromChunk(boundaries)), tagged$1("time_unit", "milliseconds"));
+  return mapInput(base, toMillis);
+};
+
+/* @internal */
+const trackAll = /*#__PURE__*/dual(2, (self, input) => effect => matchCauseEffect(effect, {
+  onFailure: cause => {
+    self.unsafeUpdate(input, empty$2());
+    return failCause(cause);
+  },
+  onSuccess: value => {
+    self.unsafeUpdate(input, empty$2());
+    return succeed$3(value);
+  }
+}));
+
+/* @internal */
+const trackDefect = /*#__PURE__*/dual(2, (self, metric) => trackDefectWith(self, metric, identity));
+
+/* @internal */
+const trackDefectWith = /*#__PURE__*/dual(3, (self, metric, f) => {
+  const updater = defect => metric.unsafeUpdate(f(defect), empty$2());
+  return tapDefect(self, cause => sync$2(() => pipe(defects(cause), forEach(updater))));
+});
+
+/* @internal */
+const trackDuration = /*#__PURE__*/dual(2, (self, metric) => trackDurationWith(self, metric, identity));
+
+/* @internal */
+const trackDurationWith = /*#__PURE__*/dual(3, (self, metric, f) => clockWith(clock => {
+  const startTime = clock.unsafeCurrentTimeNanos();
+  return map$2(self, a => {
+    const endTime = clock.unsafeCurrentTimeNanos();
+    const duration = nanos(endTime - startTime);
+    metric.unsafeUpdate(f(duration), empty$2());
+    return a;
+  });
+}));
+
+/* @internal */
+const trackError = /*#__PURE__*/dual(2, (self, metric) => trackErrorWith(self, metric, a => a));
+
+/* @internal */
+const trackErrorWith = /*#__PURE__*/dual(3, (self, metric, f) => {
+  const updater = error => update(metric, f(error));
+  return tapError(self, updater);
+});
+
+/* @internal */
+const trackSuccess = /*#__PURE__*/dual(2, (self, metric) => trackSuccessWith(self, metric, a => a));
+
+/* @internal */
+const trackSuccessWith = /*#__PURE__*/dual(3, (self, metric, f) => {
+  const updater = value => update(metric, f(value));
+  return tap(self, updater);
+});
+
+/* @internal */
+const update = /*#__PURE__*/dual(2, (self, input) => fiberRefGetWith(currentMetricLabels, tags => sync$2(() => self.unsafeUpdate(input, tags))));
+
+/* @internal */
+const value = self => fiberRefGetWith(currentMetricLabels, tags => sync$2(() => self.unsafeValue(tags)));
+
+/** @internal */
+const withNow = self => mapInput(self, input => [input, Date.now()]);
+
+/** @internal */
+const zip = /*#__PURE__*/dual(2, (self, that) => make([self.keyType, that.keyType], (input, extraTags) => {
+  const [l, r] = input;
+  self.unsafeUpdate(l, extraTags);
+  that.unsafeUpdate(r, extraTags);
+}, extraTags => [self.unsafeValue(extraTags), that.unsafeValue(extraTags)]));
+
+/** @internal */
+const unsafeSnapshot = () => globalMetricRegistry.snapshot();
+
+/** @internal */
+const snapshot = /*#__PURE__*/sync$2(unsafeSnapshot);
+
+/** @internal */
+const RequestSymbolKey = "effect/Request";
+
+/** @internal */
+const RequestTypeId = /*#__PURE__*/Symbol.for(RequestSymbolKey);
+
+/** @internal */
+const requestVariance = {
+  _E: _ => _,
+  _A: _ => _
+};
+
+/** @internal */
+const isRequest = u => typeof u === "object" && u != null && RequestTypeId in u;
+
+/** @internal */
+const of = () => args =>
+// @ts-expect-error
+struct({
+  [RequestTypeId]: requestVariance,
+  ...args
+});
+
+/** @internal */
+const tagged = tag => args =>
+// @ts-expect-error
+struct({
+  [RequestTypeId]: requestVariance,
+  _tag: tag,
+  ...args
+});
+
+/** @internal */
+const complete = /*#__PURE__*/dual(2, (self, result) => fiberRefGetWith(currentRequestMap, map => sync$2(() => {
+  if (map.has(self)) {
+    const entry = map.get(self);
+    if (!entry.state.completed) {
+      entry.state.completed = true;
+      deferredUnsafeDone(entry.result, result);
+    }
+  }
+})));
+
+/** @internal */
+const completeEffect = /*#__PURE__*/dual(2, (self, effect) => matchEffect(effect, {
+  onFailure: error => complete(self, exitFail(error)),
+  onSuccess: value => complete(self, exitSucceed(value))
+}));
+
+/** @internal */
+const fail = /*#__PURE__*/dual(2, (self, error) => complete(self, exitFail(error)));
+
+/** @internal */
+const succeed = /*#__PURE__*/dual(2, (self, value) => complete(self, exitSucceed(value)));
+
+/** @internal */
+class Listeners {
+  count = 0;
+  observers = new Set();
+  addObserver(f) {
+    this.observers.add(f);
+  }
+  removeObserver(f) {
+    this.observers.delete(f);
+  }
+  increment() {
+    this.count++;
+    this.observers.forEach(f => f(this.count));
+  }
+  decrement() {
+    this.count--;
+    this.observers.forEach(f => f(this.count));
+  }
+}
+
+/** @internal */
+const SupervisorSymbolKey = "effect/Supervisor";
+
+/** @internal */
+const SupervisorTypeId = /*#__PURE__*/Symbol.for(SupervisorSymbolKey);
+
+/** @internal */
+const supervisorVariance = {
+  _T: _ => _
+};
+
+/** @internal */
+class ProxySupervisor {
+  [SupervisorTypeId] = supervisorVariance;
+  constructor(underlying, value0) {
+    this.underlying = underlying;
+    this.value0 = value0;
+  }
+  value() {
+    return this.value0();
+  }
+  onStart(context, effect, parent, fiber) {
+    this.underlying.onStart(context, effect, parent, fiber);
+  }
+  onEnd(value, fiber) {
+    this.underlying.onEnd(value, fiber);
+  }
+  onEffect(fiber, effect) {
+    this.underlying.onEffect(fiber, effect);
+  }
+  onSuspend(fiber) {
+    this.underlying.onSuspend(fiber);
+  }
+  onResume(fiber) {
+    this.underlying.onResume(fiber);
+  }
+  map(f) {
+    return new ProxySupervisor(this, () => pipe(this.value(), map$2(f)));
+  }
+  zip(right) {
+    return new Zip(this, right);
+  }
+}
+
+/** @internal */
+class Zip {
+  [SupervisorTypeId] = supervisorVariance;
+  constructor(left, right) {
+    this.left = left;
+    this.right = right;
+  }
+  value() {
+    return zip$2(this.left.value(), this.right.value());
+  }
+  onStart(context, effect, parent, fiber) {
+    this.left.onStart(context, effect, parent, fiber);
+    this.right.onStart(context, effect, parent, fiber);
+  }
+  onEnd(value, fiber) {
+    this.left.onEnd(value, fiber);
+    this.right.onEnd(value, fiber);
+  }
+  onEffect(fiber, effect) {
+    this.left.onEffect(fiber, effect);
+    this.right.onEffect(fiber, effect);
+  }
+  onSuspend(fiber) {
+    this.left.onSuspend(fiber);
+    this.right.onSuspend(fiber);
+  }
+  onResume(fiber) {
+    this.left.onResume(fiber);
+    this.right.onResume(fiber);
+  }
+  map(f) {
+    return new ProxySupervisor(this, () => pipe(this.value(), map$2(f)));
+  }
+  zip(right) {
+    return new Zip(this, right);
+  }
+}
+class Track {
+  [SupervisorTypeId] = supervisorVariance;
+  fibers = new Set();
+  value() {
+    return sync$2(() => Array.from(this.fibers));
+  }
+  onStart(_context, _effect, _parent, fiber) {
+    this.fibers.add(fiber);
+  }
+  onEnd(_value, fiber) {
+    this.fibers.delete(fiber);
+  }
+  onEffect(_fiber, _effect) {
+    //
+  }
+  onSuspend(_fiber) {
+    //
+  }
+  onResume(_fiber) {
+    //
+  }
+  map(f) {
+    return new ProxySupervisor(this, () => pipe(this.value(), map$2(f)));
+  }
+  zip(right) {
+    return new Zip(this, right);
+  }
+  onRun(execution, _fiber) {
+    return execution();
+  }
+}
+class Const {
+  [SupervisorTypeId] = supervisorVariance;
+  constructor(effect) {
+    this.effect = effect;
+  }
+  value() {
+    return this.effect;
+  }
+  onStart(_context, _effect, _parent, _fiber) {
+    //
+  }
+  onEnd(_value, _fiber) {
+    //
+  }
+  onEffect(_fiber, _effect) {
+    //
+  }
+  onSuspend(_fiber) {
+    //
+  }
+  onResume(_fiber) {
+    //
+  }
+  map(f) {
+    return new ProxySupervisor(this, () => pipe(this.value(), map$2(f)));
+  }
+  zip(right) {
+    return new Zip(this, right);
+  }
+  onRun(execution, _fiber) {
+    return execution();
+  }
+}
+class FibersIn {
+  [SupervisorTypeId] = supervisorVariance;
+  constructor(ref) {
+    this.ref = ref;
+  }
+  value() {
+    return sync$2(() => get(this.ref));
+  }
+  onStart(_context, _effect, _parent, fiber) {
+    pipe(this.ref, set$1(pipe(get(this.ref), add(fiber))));
+  }
+  onEnd(_value, fiber) {
+    pipe(this.ref, set$1(pipe(get(this.ref), remove(fiber))));
+  }
+  onEffect(_fiber, _effect) {
+    //
+  }
+  onSuspend(_fiber) {
+    //
+  }
+  onResume(_fiber) {
+    //
+  }
+  map(f) {
+    return new ProxySupervisor(this, () => pipe(this.value(), map$2(f)));
+  }
+  zip(right) {
+    return new Zip(this, right);
+  }
+  onRun(execution, _fiber) {
+    return execution();
+  }
+}
+
+/** @internal */
+const unsafeTrack = () => {
+  return new Track();
+};
+
+/** @internal */
+const track = /*#__PURE__*/sync$2(unsafeTrack);
+
+/** @internal */
+const fromEffect = effect => {
+  return new Const(effect);
+};
+
+/** @internal */
+const none = /*#__PURE__*/fromEffect(unit);
+
+/** @internal */
+const fibersIn = ref => sync$2(() => new FibersIn(ref));
+
+/** @internal */
+
+/** @internal */
+const OP_EMPTY = "Empty";
+
+/** @internal */
+
+/** @internal */
+const OP_ADD_SUPERVISOR = "AddSupervisor";
+
+/** @internal */
+
+/** @internal */
+const OP_REMOVE_SUPERVISOR = "RemoveSupervisor";
+
+/** @internal */
+
+/** @internal */
+const OP_AND_THEN = "AndThen";
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/** @internal */
+
+/**
+ * The empty `SupervisorPatch`.
+ *
+ * @internal
+ */
+const empty = {
+  _tag: OP_EMPTY
+};
+
+/**
+ * Combines two patches to produce a new patch that describes applying the
+ * updates from this patch and then the updates from the specified patch.
+ *
+ * @internal
+ */
+const combine = (self, that) => {
+  return {
+    _tag: OP_AND_THEN,
+    first: self,
+    second: that
+  };
+};
+
+/**
+ * Applies a `SupervisorPatch` to a `Supervisor` to produce a new `Supervisor`.
+ *
+ * @internal
+ */
+const patch = (self, supervisor) => {
+  return patchLoop(supervisor, of$1(self));
+};
+
+/** @internal */
+const patchLoop = (_supervisor, _patches) => {
+  let supervisor = _supervisor;
+  let patches = _patches;
+  while (isNonEmpty(patches)) {
+    const head = headNonEmpty(patches);
+    switch (head._tag) {
+      case OP_EMPTY:
+        {
+          patches = tailNonEmpty(patches);
+          break;
+        }
+      case OP_ADD_SUPERVISOR:
+        {
+          supervisor = supervisor.zip(head.supervisor);
+          patches = tailNonEmpty(patches);
+          break;
+        }
+      case OP_REMOVE_SUPERVISOR:
+        {
+          supervisor = removeSupervisor(supervisor, head.supervisor);
+          patches = tailNonEmpty(patches);
+          break;
+        }
+      case OP_AND_THEN:
+        {
+          patches = prepend(head.first)(prepend(head.second)(tailNonEmpty(patches)));
+          break;
+        }
+    }
+  }
+  return supervisor;
+};
+
+/** @internal */
+const removeSupervisor = (self, that) => {
+  if (equals(self, that)) {
+    return none;
+  } else {
+    if (self instanceof Zip) {
+      return removeSupervisor(self.left, that).zip(removeSupervisor(self.right, that));
+    } else {
+      return self;
+    }
+  }
+};
+
+/** @internal */
+const toSet = self => {
+  if (equals(self, none)) {
+    return empty$2();
+  } else {
+    if (self instanceof Zip) {
+      return pipe(toSet(self.left), union(toSet(self.right)));
+    } else {
+      return make$2(self);
+    }
+  }
+};
+
+/** @internal */
+const diff = (oldValue, newValue) => {
+  if (equals(oldValue, newValue)) {
+    return empty;
+  }
+  const oldSupervisors = toSet(oldValue);
+  const newSupervisors = toSet(newValue);
+  const added = pipe(newSupervisors, difference(oldSupervisors), reduce(empty, (patch, supervisor) => combine(patch, {
+    _tag: OP_ADD_SUPERVISOR,
+    supervisor
+  })));
+  const removed = pipe(oldSupervisors, difference(newSupervisors), reduce(empty, (patch, supervisor) => combine(patch, {
+    _tag: OP_REMOVE_SUPERVISOR,
+    supervisor
+  })));
+  return combine(added, removed);
+};
+
+/** @internal */
+const differ = /*#__PURE__*/make$4({
+  empty,
+  patch,
+  combine,
+  diff
+});
+
+/** @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$1( /*#__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$2(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$2(() => 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$3(exit));
+      this.tell(stateful((fiber, _) => {
+        if (fiber._exitValue !== null) {
+          cb(this._exitValue);
+        } else {
+          fiber.addObserver(cb);
+        }
+      }));
+      return sync$2(() => 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$1(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$2(() => 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$2(() => 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$2(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$2(() => {
+            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$1(loggers) > 0) {
+      const clockService = get$2(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) {
+    const newRuntimeFlags = patch$1(oldRuntimeFlags, patch);
+    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$2(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$1(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$1(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$3)));
+          } 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$2(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$1(context, currentTracerSpan), head);
+  const clockService = map$3(get$1(context, currentServices), _ => get$2(_, clockTag));
+  if (span._tag === "None" || span.value._tag === "ExternalSpan" || clockService._tag === "None") {
+    return;
+  }
+  const attributes = Object.fromEntries(annotations);
+  attributes["effect.fiberId"] = threadName$1(fiberId);
+  attributes["effect.logLevel"] = logLevel.label;
+  if (cause !== null && cause !== empty$1) {
+    attributes["effect.cause"] = pretty(cause);
+  }
+  span.value.event(String(message), clockService.value.unsafeCurrentTimeNanos(), attributes);
+});
+
+/** @internal */
+const currentLoggers = /*#__PURE__*/fiberRefUnsafeMakeHashSet( /*#__PURE__*/make$2(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$2(preRefs, acquireRefs);
+    const patchFlags = diff$1(preFlags, acquireFlags);
+    const inverseRefs = diff$2(acquireRefs, preRefs);
+    runtimeFinalizer.setFiberRefs(patch$2(patchRefs, runtimeFinalizer.id(), acquireRefs));
+    return ensuring(withRuntimeFlags(finalizer(exit), patchFlags), sync$2(() => {
+      runtimeFinalizer.setFiberRefs(patch$2(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$1(_existsParFound),
+  onFalse: unit
+}), options), {
+  onFailure: e => e === _existsParFound ? succeed$3(true) : fail$1(e),
+  onSuccess: () => succeed$3(false)
+})));
+const existsLoop = (iterator, index, f) => {
+  const next = iterator.next();
+  if (next.done) {
+    return succeed$3(false);
+  }
+  return pipe(flatMap$1(f(next.value, index), b => b ? succeed$3(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$2(f(a, i), not) : f;
+  return matchSimple(options, () => suspend(() => fromIterable$1(elements).reduceRight((effect, a, i) => zipWith(effect, suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), sync$2(() => new Array()))), () => map$2(forEachOptions(elements, (a, i) => map$2(predicate(a, i), b => b ? some(a) : none$2()), options), compact));
+});
+
+// === all
+
+const allResolveInput = input => {
+  if (Array.isArray(input) || isIterable(input)) {
+    return [input, none$2()];
+  }
+  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 = none$2();
+    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;
+      }
+    }
+    if (errored) {
+      return reconcile._tag === "Some" ? fail$1(reconcile.value(errors)) : fail$1(errors);
+    } else if (options?.discard) {
+      return unit;
+    }
+    return reconcile._tag === "Some" ? succeed$3(reconcile.value(successes)) : succeed$3(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$2(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$2(forEachOptions(effects, identity, options), reconcile.value) : forEachOptions(effects, identity, options);
+};
+
+/* @internal */
+const allWith = options => arg => all(arg, options);
+
+/* @internal */
+const allSuccesses = (elements, options) => map$2(all(fromIterable$1(elements).map(exit), options), filterMap(exit => exitIsSuccess(exit) ? some(exit.i0) : none$2()));
+
+/* @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(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(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$1(self);
+  const array = new Array(as.length);
+  const fn = (a, i) => flatMap$1(f(a, i), b => sync$2(() => array[i] = b));
+  return zipRight$1(forEachParUnboundedDiscard(as, fn, batching), succeed$3(array));
+});
+const forEachBatchedDiscard = (self, f) => suspend(() => {
+  const as = fromIterable$1(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$1(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$3);
+    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$1(deferredFail(deferred, void 0), failCause(parallel$1(cause, exit.cause))),
+                onSuccess: () => zipRight$1(deferredFail(deferred, void 0), failCause(exit.cause))
+              }));
+            }
+            return zipRight$1(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$2(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$1(self);
+  const array = new Array(as.length);
+  const fn = (a, i) => map$2(f(a, i), b => array[i] = b);
+  return zipRight$1(forEachParNDiscard(as, n, fn, batching), succeed$3(array));
+});
+
+/* @internal */
+const forEachParNDiscard = (self, n, f, batching) => suspend(() => {
+  let i = 0;
+  const iterator = self[Symbol.iterator]();
+  const residual = [];
+  const worker = flatMap$1(sync$2(() => 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$3(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$3(unsafeFork(self, parentFiber, parentStatus.runtimeFlags, scopeOverride)));
+
+/* @internal */
+const mergeAll = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => fromIterable$1(elements).reduce((acc, a, i) => zipWith(acc, a, (acc, a) => f(acc, a, i)), succeed$3(zero)), () => flatMap$1(make$5(zero), acc => flatMap$1(forEachOptions(elements, (effect, i) => flatMap$1(effect, a => update$1(acc, b => f(b, a, i))), options), () => get$3(acc)))));
+
+/* @internal */
+const partition = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => pipe(forEachOptions(elements, (a, i) => either(f(a, i)), options), map$2(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$3(bs) : fail$1(es)));
+
+/* @internal */
+const raceAll = all => {
+  const list = fromIterable$2(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$5(effects.length), flatMap$1(fails => uninterruptibleMask(restore => pipe(fork(interruptible(self)), flatMap$1(head => pipe(effects, forEachSequential(effect => fork(interruptible(effect))), map$2(unsafeFromArray), map$2(tail => pipe(tail, prepend(head))), tap(fibers => pipe(fibers, reduce$1(unit, (effect, fiber) => pipe(effect, zipRight$1(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$1(unit, (effect, fiber) => pipe(effect, zipLeft$1(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$2(fibers), reduce$1(unit, (effect, fiber) => fiber === winner ? effect : pipe(effect, zipLeft$1(interruptFiber(fiber))))) : unit))
+});
+
+/* @internal */
+const reduceEffect = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => fromIterable$1(elements).reduce((acc, a, i) => zipWith(acc, a, (acc, a) => f(acc, a, i)), zero), () => suspend(() => pipe(mergeAll([zero, ...elements], none$2(), (acc, elem, i) => {
+  switch (acc._tag) {
+    case "None":
+      {
+        return some(elem);
+      }
+    case "Some":
+      {
+        return some(f(acc.value, elem, i));
+      }
+  }
+}, options), map$2(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$1(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$1(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$1(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$1(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(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$1(clockTag, value));
+
+/* @internal */
+const withConfigProviderScoped = value => fiberRefLocallyScopedWith(currentServices, add$1(configProviderTag, value));
+
+/* @internal */
+const withEarlyRelease = self => scopeWith(parent => flatMap$1(scopeFork(parent, sequential$2), child => pipe(self, scopeExtend(child), map$2(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$2(all([self, that], {
+  concurrency: options?.concurrent ? 2 : 1,
+  batching: options?.batching
+}), ([a, a2]) => f(a, a2)));
+
+/* @internal */
+const withRuntimeFlagsScoped = update => {
+  if (update === empty$3) {
+    return unit;
+  }
+  return pipe(runtimeFlags, flatMap$1(runtimeFlags => {
+    const updatedRuntimeFlags = patch$1(runtimeFlags, update);
+    const revertRuntimeFlags = diff$1(updatedRuntimeFlags, runtimeFlags);
+    return pipe(updateRuntimeFlags(update), zipRight$1(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$3(exitAsUnit), getOrElse(() => exitUnit)))) : isParallel(strategy) ? pipe(forEachParUnbounded(finalizers, fin => exit(update(fin)(exit$1)), false), flatMap$1(results => pipe(exitCollectAll(results, {
+          parallel: true
+        }), map$3(exitAsUnit), getOrElse(() => exitUnit)))) : pipe(forEachParN(finalizers, strategy.parallelism, fin => exit(update(fin)(exit$1)), false), flatMap$1(results => pipe(exitCollectAll(results, {
+          parallel: true
+        }), map$3(exitAsUnit), getOrElse(() => exitUnit))));
+      }
+  }
+});
+
+// circular with Scope
+
+/** @internal */
+const scopeTag = /*#__PURE__*/Tag(ScopeTypeId);
+
+/* @internal */
+const scope = scopeTag;
+
+/* @internal */
+const scopeMake = (strategy = sequential$2) => map$2(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$6(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
+});
+
+// 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$2(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$4);
+
+/** @internal */
+const currentSupervisor = /*#__PURE__*/fiberRefUnsafeMakeSupervisor(none);
+
+// circular with Fiber
+
+/* @internal */
+const fiberAwaitAll = fibers => asUnit(_await(fiberAll(fibers)));
+
+/** @internal */
+const fiberAll = fibers => ({
+  [FiberTypeId]: fiberVariance,
+  id: () => fromIterable$1(fibers).reduce((id, fiber) => combine$1(id, fiber.id()), none$3),
+  await: () => exit(forEachParUnbounded(fibers, fiber => flatten(fiber.await()), false)),
+  children: () => map$2(forEachParUnbounded(fibers, fiber => fiber.children(), false), flatten$1),
+  inheritAll: () => forEachSequentialDiscard(fibers, fiber => fiber.inheritAll()),
+  poll: () => map$2(forEachSequential(fibers, fiber => fiber.poll()), reduceRight(some(exitSucceed(new Array())), (optionB, optionA) => {
+    switch (optionA._tag) {
+      case "None":
+        {
+          return none$2();
+        }
+      case "Some":
+        {
+          switch (optionB._tag) {
+            case "None":
+              {
+                return none$2();
+              }
+            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$3(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$7(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$1(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$2(() => {
+    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$1(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$2(() => 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$1(tracerTag, value));
+
+/* @internal */
+const withParentSpanScoped = span => fiberRefLocallyScopedWith(currentTracerSpan, prepend$1(span));
+
+export { withParentSpanScoped as $, scopedEffect as A, using as B, withEarlyRelease as C, daemonChildren as D, fork as E, forkDaemon as F, forkWithErrorHandler as G, fiberRefLocallyScoped as H, fiberRefLocallyScopedWith as I, withClockScoped as J, withConfigProviderScoped as K, raceAll as L, race as M, raceWith as N, withRuntimeFlagsScoped as O, tagMetricsScoped as P, labelMetricsScoped as Q, labelMetricsScopedSet as R, validate as S, validateWith as T, zipOptions as U, zipLeftOptions as V, zipRightOptions as W, zipWithOptions as X, withTracerScoped as Y, useSpanScoped as Z, withSpanScoped as _, all as a, timer as a$, fiberRefMake as a0, fiberRefMakeWith as a1, fiberRefMakeContext as a2, fiberRefMakeRuntimeFlags as a3, fiberRefUnsafeMakeSupervisor as a4, currentLoggers as a5, currentMinimumLogLevel as a6, currentRuntimeFlags as a7, currentSupervisor as a8, fiberAwaitAll as a9, logfmtLogger as aA, stringLogger as aB, tracerLogger as aC, logFmtLogger as aD, MetricTypeId as aE, globalMetricRegistry as aF, make as aG, mapInput as aH, counter as aI, frequency as aJ, withConstantInput as aK, fromMetricKey as aL, gauge as aM, histogram as aN, increment as aO, incrementBy as aP, map as aQ, mapType as aR, set as aS, snapshot as aT, succeed$1 as aU, sync as aV, summary as aW, summaryTimestamp as aX, tagged$1 as aY, taggedWithLabelsInput as aZ, taggedWithLabels as a_, fiberAll as aa, track as ab, raceFibersWith as ac, scopeExtend as ad, Zip as ae, Listeners as af, FiberRuntime as ag, none as ah, scopeTag as ai, scopeUse as aj, fiberInterruptFork as ak, fiberJoinAll as al, fiberScoped as am, LoggerTypeId as an, makeLogger as ao, mapInput$1 as ap, filterLogLevel as aq, map$1 as ar, none$1 as as, simple as at, succeed$2 as au, sync$1 as av, zip$1 as aw, zipLeft as ax, zipRight as ay, defaultLogger as az, acquireRelease as b, timerWithBoundaries as b0, trackAll as b1, trackDefect as b2, trackDefectWith as b3, trackDuration as b4, trackDurationWith as b5, trackError as b6, trackErrorWith as b7, trackSuccess as b8, trackSuccessWith as b9, update as ba, value as bb, withNow as bc, zip as bd, unsafeSnapshot as be, fiberStarted as bf, fiberSuccesses as bg, fiberFailures as bh, fiberLifetimes as bi, fiberActive as bj, RequestTypeId as bk, isRequest as bl, of as bm, tagged as bn, complete as bo, interruptWhenPossible as bp, completeEffect as bq, fail as br, succeed as bs, SupervisorTypeId as bt, fibersIn as bu, fromEffect as bv, unsafeTrack as bw, ProxySupervisor as bx, supervisorVariance as by, invokeWithInterrupt as bz, forEachParUnboundedDiscard as c, allWith as d, allSuccesses as e, forEachParUnbounded as f, exists as g, filter as h, forEachOptions as i, replicate as j, replicateEffect as k, validateFirst as l, mergeAll as m, disconnect as n, acquireReleaseInterruptible as o, partition as p, addFinalizer as q, reduceEffect as r, scopeMake as s, ensuring as t, parallelFinalizers as u, validateAll as v, finalizersMask as w, sequentialFinalizers as x, scope as y, scopeWith as z };