effect 2.0.0-next.53 → 2.0.0-next.55

package/dist/fiberRuntime-1d260336.cjs.dev.js

@@ -1,3015 +0,0 @@
-'use strict';
-
-var Boolean_dist_effectBoolean = require('../Boolean/dist/effect-Boolean.cjs.dev.js');
-var Chunk_dist_effectChunk = require('../Chunk/dist/effect-Chunk.cjs.dev.js');
-var Context_dist_effectContext = require('../Context/dist/effect-Context.cjs.dev.js');
-var Deferred_dist_effectDeferred = require('../Deferred/dist/effect-Deferred.cjs.dev.js');
-var Effectable_dist_effectEffectable = require('../Effectable/dist/effect-Effectable.cjs.dev.js');
-var ExecutionStrategy_dist_effectExecutionStrategy = require('./ExecutionStrategy-7d9d457b.cjs.dev.js');
-var FiberId_dist_effectFiberId = require('./FiberId-fe3586bc.cjs.dev.js');
-var FiberRefs_dist_effectFiberRefs = require('../FiberRefs/dist/effect-FiberRefs.cjs.dev.js');
-var FiberRefsPatch_dist_effectFiberRefsPatch = require('../FiberRefsPatch/dist/effect-FiberRefsPatch.cjs.dev.js');
-var FiberStatus_dist_effectFiberStatus = require('../FiberStatus/dist/effect-FiberStatus.cjs.dev.js');
-var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.dev.js');
-var GlobalValue_dist_effectGlobalValue = require('./GlobalValue-871500cb.cjs.dev.js');
-var HashMap_dist_effectHashMap = require('../HashMap/dist/effect-HashMap.cjs.dev.js');
-var HashSet_dist_effectHashSet = require('../HashSet/dist/effect-HashSet.cjs.dev.js');
-var core = require('./core-908ae0ff.cjs.dev.js');
-var defaultServices = require('./defaultServices-d02bba35.cjs.dev.js');
-var configProvider = require('./configProvider-db30779f.cjs.dev.js');
-var coreEffect = require('./core-effect-a83699c2.cjs.dev.js');
-var fiber = require('./fiber-98ad468a.cjs.dev.js');
-var fiberRefs = require('./fiberRefs-a89aceb0.cjs.dev.js');
-var List_dist_effectList = require('../List/dist/effect-List.cjs.dev.js');
-var LogSpan_dist_effectLogSpan = require('../LogSpan/dist/effect-LogSpan.cjs.dev.js');
-var Option_dist_effectOption = require('../Option/dist/effect-Option.cjs.dev.js');
-var Pipeable_dist_effectPipeable = require('../Pipeable/dist/effect-Pipeable.cjs.dev.js');
-var Clock_dist_effectClock = require('../Clock/dist/effect-Clock.cjs.dev.js');
-var Duration_dist_effectDuration = require('../Duration/dist/effect-Duration.cjs.dev.js');
-var boundaries = require('./boundaries-0a4ac5a1.cjs.dev.js');
-var key = require('./key-ef346a50.cjs.dev.js');
-var label = require('./label-b8010065.cjs.dev.js');
-var registry = require('./registry-e3bbc631.cjs.dev.js');
-var ReadonlyArray_dist_effectReadonlyArray = require('../ReadonlyArray/dist/effect-ReadonlyArray.cjs.dev.js');
-var Effectable = require('./Effectable-ed77aaf6.cjs.dev.js');
-var Predicate_dist_effectPredicate = require('../Predicate/dist/effect-Predicate.cjs.dev.js');
-var RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch = require('./RuntimeFlagsPatch-5a4ff83e.cjs.dev.js');
-var MutableRef_dist_effectMutableRef = require('../MutableRef/dist/effect-MutableRef.cjs.dev.js');
-var SortedSet_dist_effectSortedSet = require('../SortedSet/dist/effect-SortedSet.cjs.dev.js');
-var Differ_dist_effectDiffer = require('../Differ/dist/effect-Differ.cjs.dev.js');
-var Equal_dist_effectEqual = require('../Equal/dist/effect-Equal.cjs.dev.js');
-var LogLevel_dist_effectLogLevel = require('../LogLevel/dist/effect-LogLevel.cjs.dev.js');
-var Ref_dist_effectRef = require('./Ref-891bdaff.cjs.dev.js');
-var Scheduler_dist_effectScheduler = require('../Scheduler/dist/effect-Scheduler.cjs.dev.js');
-
-/** @internal */
-const currentRequestMap = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentRequestMap"), () => core.fiberRefUnsafeMake(new Map()));
-
-/** @internal */
-const match = (options, sequential, unbounded, bounded) => {
-  switch (options?.concurrency) {
-    case undefined:
-      {
-        return sequential();
-      }
-    case "unbounded":
-      {
-        return unbounded();
-      }
-    case "inherit":
-      {
-        return core.fiberRefGetWith(core.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 core.fiberRefGetWith(core.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 Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-});
-
-/** @internal */
-const mapInput$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeLogger(options => self.log({
-  ...options,
-  message: f(options.message)
-})));
-
-/** @internal */
-const filterLogLevel = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeLogger(options => f(options.logLevel) ? Option_dist_effectOption.some(self.log(options)) : Option_dist_effectOption.none()));
-
-/** @internal */
-const map$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeLogger(options => f(self.log(options))));
-
-/** @internal */
-const none$1 = {
-  [LoggerTypeId]: loggerVariance,
-  log: Function_dist_effectFunction.constVoid,
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-const simple = log => ({
-  [LoggerTypeId]: loggerVariance,
-  log: ({
-    message
-  }) => log(message),
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-});
-
-/** @internal */
-const succeed$2 = value => {
-  return simple(() => value);
-};
-
-/** @internal */
-const sync$1 = evaluate => {
-  return simple(evaluate);
-};
-
-/** @internal */
-const zip$1 = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeLogger(options => [self.log(options), that.log(options)]));
-
-/** @internal */
-const zipLeft = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => map$1(zip$1(self, that), tuple => tuple[0]));
-
-/** @internal */
-const zipRight = /*#__PURE__*/Function_dist_effectFunction.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=${FiberId_dist_effectFiberId.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._tag !== "Empty") {
-    output = output + " cause=";
-    output = appendQuoted(core.pretty(cause), output);
-  }
-  if (List_dist_effectList.isCons(spans)) {
-    output = output + " ";
-    let first = true;
-    for (const span of spans) {
-      if (first) {
-        first = false;
-      } else {
-        output = output + " ";
-      }
-      output = output + Function_dist_effectFunction.pipe(span, LogSpan_dist_effectLogSpan.render(nowMillis));
-    }
-  }
-  if (Function_dist_effectFunction.pipe(annotations, HashMap_dist_effectHashMap.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(serializeUnknown(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=${FiberId_dist_effectFiberId.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._tag !== "Empty") {
-    output = output + " cause=";
-    output = appendQuotedLogfmt(core.pretty(cause), output);
-  }
-  if (List_dist_effectList.isCons(spans)) {
-    output = output + " ";
-    let first = true;
-    for (const span of spans) {
-      if (first) {
-        first = false;
-      } else {
-        output = output + " ";
-      }
-      output = output + Function_dist_effectFunction.pipe(span, renderLogSpanLogfmt(nowMillis));
-    }
-  }
-  if (Function_dist_effectFunction.pipe(annotations, HashMap_dist_effectHashMap.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(serializeUnknown(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_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/Metric/globalMetricRegistry"), () => registry.make());
-
-/** @internal */
-const make = function (keyType, unsafeUpdate, unsafeValue) {
-  const metric = Object.assign(effect => core.tap(effect, a => core.sync(() => unsafeUpdate(a, HashSet_dist_effectHashSet.empty()))), {
-    [MetricTypeId]: metricVariance,
-    keyType,
-    unsafeUpdate,
-    unsafeValue,
-    pipe() {
-      return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-    }
-  });
-  return metric;
-};
-
-/** @internal */
-const mapInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => make(self.keyType, (input, extraTags) => self.unsafeUpdate(f(input), extraTags), self.unsafeValue));
-
-/** @internal */
-const counter = (name, options) => fromMetricKey(key.counter(name, options));
-
-/** @internal */
-const frequency = (name, description) => fromMetricKey(key.frequency(name, description));
-
-/** @internal */
-const withConstantInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, input) => mapInput(self, () => input));
-
-/** @internal */
-const fromMetricKey = key$1 => {
-  const hook = extraTags => {
-    const fullKey = Function_dist_effectFunction.pipe(key$1, key.taggedWithLabelSet(extraTags));
-    return globalMetricRegistry.get(fullKey);
-  };
-  return make(key$1.keyType, (input, extraTags) => hook(extraTags).update(input), extraTags => hook(extraTags).get());
-};
-
-/** @internal */
-const gauge = (name, options) => fromMetricKey(key.gauge(name, options));
-
-/** @internal */
-const histogram = (name, boundaries, description) => fromMetricKey(key.histogram(name, boundaries, description));
-
-/* @internal */
-const increment = self => update(self, self.keyType.bigint ? BigInt(1) : 1);
-
-/* @internal */
-const incrementBy = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, amount) => update(self, amount));
-
-/** @internal */
-const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => make(self.keyType, self.unsafeUpdate, extraTags => f(self.unsafeValue(extraTags))));
-
-/** @internal */
-const mapType = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => make(f(self.keyType), self.unsafeUpdate, self.unsafeValue));
-
-/* @internal */
-const set = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => update(self, value));
-
-/** @internal */
-const succeed$1 = out => make(void 0, Function_dist_effectFunction.constVoid, () => out);
-
-/** @internal */
-const sync = evaluate => make(void 0, Function_dist_effectFunction.constVoid, evaluate);
-
-/** @internal */
-const summary = options => withNow(summaryTimestamp(options));
-
-/** @internal */
-const summaryTimestamp = options => fromMetricKey(key.summary(options));
-
-/** @internal */
-const tagged$1 = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, key, value) => taggedWithLabels(self, HashSet_dist_effectHashSet.make(label.make(key, value))));
-
-/** @internal */
-const taggedWithLabelsInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => map(make(self.keyType, (input, extraTags) => self.unsafeUpdate(input, HashSet_dist_effectHashSet.union(HashSet_dist_effectHashSet.fromIterable(f(input)), extraTags)), self.unsafeValue), Function_dist_effectFunction.constVoid));
-
-/** @internal */
-const taggedWithLabels = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, extraTagsIterable) => {
-  const extraTags = HashSet_dist_effectHashSet.isHashSet(extraTagsIterable) ? extraTagsIterable : HashSet_dist_effectHashSet.fromIterable(extraTagsIterable);
-  return make(self.keyType, (input, extraTags1) => self.unsafeUpdate(input, Function_dist_effectFunction.pipe(extraTags, HashSet_dist_effectHashSet.union(extraTags1))), extraTags1 => self.unsafeValue(Function_dist_effectFunction.pipe(extraTags, HashSet_dist_effectHashSet.union(extraTags1))));
-});
-
-/** @internal */
-const timer = name => {
-  const boundaries$1 = boundaries.exponential({
-    start: 1,
-    factor: 2,
-    count: 100
-  });
-  const base = Function_dist_effectFunction.pipe(histogram(name, boundaries$1), tagged$1("time_unit", "milliseconds"));
-  return mapInput(base, Duration_dist_effectDuration.toMillis);
-};
-
-/** @internal */
-const timerWithBoundaries = (name, boundaries$1) => {
-  const base = Function_dist_effectFunction.pipe(histogram(name, boundaries.fromChunk(boundaries$1)), tagged$1("time_unit", "milliseconds"));
-  return mapInput(base, Duration_dist_effectDuration.toMillis);
-};
-
-/* @internal */
-const trackAll = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, input) => effect => core.matchCauseEffect(effect, {
-  onFailure: cause => {
-    self.unsafeUpdate(input, HashSet_dist_effectHashSet.empty());
-    return core.failCause(cause);
-  },
-  onSuccess: value => {
-    self.unsafeUpdate(input, HashSet_dist_effectHashSet.empty());
-    return core.succeed(value);
-  }
-}));
-
-/* @internal */
-const trackDefect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, metric) => trackDefectWith(self, metric, Function_dist_effectFunction.identity));
-
-/* @internal */
-const trackDefectWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, metric, f) => {
-  const updater = defect => metric.unsafeUpdate(f(defect), HashSet_dist_effectHashSet.empty());
-  return coreEffect.tapDefect(self, cause => core.sync(() => Function_dist_effectFunction.pipe(core.defects(cause), ReadonlyArray_dist_effectReadonlyArray.forEach(updater))));
-});
-
-/* @internal */
-const trackDuration = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, metric) => trackDurationWith(self, metric, Function_dist_effectFunction.identity));
-
-/* @internal */
-const trackDurationWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, metric, f) => Clock_dist_effectClock.clockWith(clock => {
-  const startTime = clock.unsafeCurrentTimeNanos();
-  return core.map$1(self, a => {
-    const endTime = clock.unsafeCurrentTimeNanos();
-    const duration = Duration_dist_effectDuration.nanos(endTime - startTime);
-    metric.unsafeUpdate(f(duration), HashSet_dist_effectHashSet.empty());
-    return a;
-  });
-}));
-
-/* @internal */
-const trackError = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, metric) => trackErrorWith(self, metric, a => a));
-
-/* @internal */
-const trackErrorWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, metric, f) => {
-  const updater = error => update(metric, f(error));
-  return coreEffect.tapError(self, updater);
-});
-
-/* @internal */
-const trackSuccess = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, metric) => trackSuccessWith(self, metric, a => a));
-
-/* @internal */
-const trackSuccessWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, metric, f) => {
-  const updater = value => update(metric, f(value));
-  return core.tap(self, updater);
-});
-
-/* @internal */
-const update = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, input) => core.fiberRefGetWith(core.currentMetricLabels, tags => core.sync(() => self.unsafeUpdate(input, tags))));
-
-/* @internal */
-const value = self => core.fiberRefGetWith(core.currentMetricLabels, tags => core.sync(() => self.unsafeValue(tags)));
-
-/** @internal */
-const withNow = self => mapInput(self, input => [input, Date.now()]);
-
-/** @internal */
-const zip = /*#__PURE__*/Function_dist_effectFunction.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__*/core.sync(unsafeSnapshot);
-
-/** @internal */
-const RequestSymbolKey = "effect/Request";
-
-/** @internal */
-const RequestTypeId = /*#__PURE__*/Symbol.for(RequestSymbolKey);
-
-/** @internal */
-const requestVariance = {
-  _E: _ => _,
-  _A: _ => _
-};
-
-/** @internal */
-const isRequest = u => Predicate_dist_effectPredicate.hasProperty(u, RequestTypeId);
-
-/** @internal */
-const of = () => args =>
-// @ts-expect-error
-Effectable.struct({
-  [RequestTypeId]: requestVariance,
-  ...args
-});
-
-/** @internal */
-const tagged = tag => args =>
-// @ts-expect-error
-Effectable.struct({
-  [RequestTypeId]: requestVariance,
-  _tag: tag,
-  ...args
-});
-
-/** @internal */
-const complete = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, result) => core.fiberRefGetWith(currentRequestMap, map => core.sync(() => {
-  if (map.has(self)) {
-    const entry = map.get(self);
-    if (!entry.state.completed) {
-      entry.state.completed = true;
-      core.deferredUnsafeDone(entry.result, result);
-    }
-  }
-})));
-
-/** @internal */
-const completeEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, effect) => core.matchEffect(effect, {
-  onFailure: error => complete(self, core.exitFail(error)),
-  onSuccess: value => complete(self, core.exitSucceed(value))
-}));
-
-/** @internal */
-const fail = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, error) => complete(self, core.exitFail(error)));
-
-/** @internal */
-const succeed = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => complete(self, core.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, () => Function_dist_effectFunction.pipe(this.value(), core.map$1(f)));
-  }
-  zip(right) {
-    return new Zip(this, right);
-  }
-}
-
-/** @internal */
-class Zip {
-  _tag = "Zip";
-  [SupervisorTypeId] = supervisorVariance;
-  constructor(left, right) {
-    this.left = left;
-    this.right = right;
-  }
-  value() {
-    return core.zip(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, () => Function_dist_effectFunction.pipe(this.value(), core.map$1(f)));
-  }
-  zip(right) {
-    return new Zip(this, right);
-  }
-}
-const isZip = self => Predicate_dist_effectPredicate.hasProperty(self, SupervisorTypeId) && Predicate_dist_effectPredicate.isTagged(self, "Zip");
-class Track {
-  [SupervisorTypeId] = supervisorVariance;
-  fibers = new Set();
-  value() {
-    return core.sync(() => 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, () => Function_dist_effectFunction.pipe(this.value(), core.map$1(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, () => Function_dist_effectFunction.pipe(this.value(), core.map$1(f)));
-  }
-  zip(right) {
-    return new Zip(this, right);
-  }
-  onRun(execution, _fiber) {
-    return execution();
-  }
-}
-class FibersIn {
-  [SupervisorTypeId] = supervisorVariance;
-  constructor(ref) {
-    this.ref = ref;
-  }
-  value() {
-    return core.sync(() => MutableRef_dist_effectMutableRef.get(this.ref));
-  }
-  onStart(_context, _effect, _parent, fiber) {
-    Function_dist_effectFunction.pipe(this.ref, MutableRef_dist_effectMutableRef.set(Function_dist_effectFunction.pipe(MutableRef_dist_effectMutableRef.get(this.ref), SortedSet_dist_effectSortedSet.add(fiber))));
-  }
-  onEnd(_value, fiber) {
-    Function_dist_effectFunction.pipe(this.ref, MutableRef_dist_effectMutableRef.set(Function_dist_effectFunction.pipe(MutableRef_dist_effectMutableRef.get(this.ref), SortedSet_dist_effectSortedSet.remove(fiber))));
-  }
-  onEffect(_fiber, _effect) {
-    //
-  }
-  onSuspend(_fiber) {
-    //
-  }
-  onResume(_fiber) {
-    //
-  }
-  map(f) {
-    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map$1(f)));
-  }
-  zip(right) {
-    return new Zip(this, right);
-  }
-  onRun(execution, _fiber) {
-    return execution();
-  }
-}
-
-/** @internal */
-const unsafeTrack = () => {
-  return new Track();
-};
-
-/** @internal */
-const track = /*#__PURE__*/core.sync(unsafeTrack);
-
-/** @internal */
-const fromEffect = effect => {
-  return new Const(effect);
-};
-
-/** @internal */
-const none = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue("effect/Supervisor/none", () => fromEffect(core.unit));
-
-/** @internal */
-const fibersIn = ref => core.sync(() => 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, Chunk_dist_effectChunk.of(self));
-};
-
-/** @internal */
-const patchLoop = (_supervisor, _patches) => {
-  let supervisor = _supervisor;
-  let patches = _patches;
-  while (Chunk_dist_effectChunk.isNonEmpty(patches)) {
-    const head = Chunk_dist_effectChunk.headNonEmpty(patches);
-    switch (head._tag) {
-      case OP_EMPTY:
-        {
-          patches = Chunk_dist_effectChunk.tailNonEmpty(patches);
-          break;
-        }
-      case OP_ADD_SUPERVISOR:
-        {
-          supervisor = supervisor.zip(head.supervisor);
-          patches = Chunk_dist_effectChunk.tailNonEmpty(patches);
-          break;
-        }
-      case OP_REMOVE_SUPERVISOR:
-        {
-          supervisor = removeSupervisor(supervisor, head.supervisor);
-          patches = Chunk_dist_effectChunk.tailNonEmpty(patches);
-          break;
-        }
-      case OP_AND_THEN:
-        {
-          patches = Chunk_dist_effectChunk.prepend(head.first)(Chunk_dist_effectChunk.prepend(head.second)(Chunk_dist_effectChunk.tailNonEmpty(patches)));
-          break;
-        }
-    }
-  }
-  return supervisor;
-};
-
-/** @internal */
-const removeSupervisor = (self, that) => {
-  if (Equal_dist_effectEqual.equals(self, that)) {
-    return none;
-  } else {
-    if (isZip(self)) {
-      return removeSupervisor(self.left, that).zip(removeSupervisor(self.right, that));
-    } else {
-      return self;
-    }
-  }
-};
-
-/** @internal */
-const toSet = self => {
-  if (Equal_dist_effectEqual.equals(self, none)) {
-    return HashSet_dist_effectHashSet.empty();
-  } else {
-    if (isZip(self)) {
-      return Function_dist_effectFunction.pipe(toSet(self.left), HashSet_dist_effectHashSet.union(toSet(self.right)));
-    } else {
-      return HashSet_dist_effectHashSet.make(self);
-    }
-  }
-};
-
-/** @internal */
-const diff = (oldValue, newValue) => {
-  if (Equal_dist_effectEqual.equals(oldValue, newValue)) {
-    return empty;
-  }
-  const oldSupervisors = toSet(oldValue);
-  const newSupervisors = toSet(newValue);
-  const added = Function_dist_effectFunction.pipe(newSupervisors, HashSet_dist_effectHashSet.difference(oldSupervisors), HashSet_dist_effectHashSet.reduce(empty, (patch, supervisor) => combine(patch, {
-    _tag: OP_ADD_SUPERVISOR,
-    supervisor
-  })));
-  const removed = Function_dist_effectFunction.pipe(oldSupervisors, HashSet_dist_effectHashSet.difference(newSupervisors), HashSet_dist_effectHashSet.reduce(empty, (patch, supervisor) => combine(patch, {
-    _tag: OP_REMOVE_SUPERVISOR,
-    supervisor
-  })));
-  return combine(added, removed);
-};
-
-/** @internal */
-const differ = /*#__PURE__*/Differ_dist_effectDiffer.make({
-  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__*/boundaries.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 = {
-  [Effectable.OP_ON_SUCCESS]: (_, cont, value) => {
-    return cont.i1(value);
-  },
-  ["OnStep"]: (_, cont, value) => {
-    return cont.i1(core.exitSucceed(value));
-  },
-  [Effectable.OP_ON_SUCCESS_AND_FAILURE]: (_, cont, value) => {
-    return cont.i2(value);
-  },
-  [Effectable.OP_REVERT_FLAGS]: (self, cont, value) => {
-    self.patchRuntimeFlags(self._runtimeFlags, cont.patch);
-    if (RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.interruptible(self._runtimeFlags) && self.isInterrupted()) {
-      return core.exitFailCause(self.getInterruptedCause());
-    } else {
-      return core.exitSucceed(value);
-    }
-  },
-  [Effectable.OP_WHILE]: (self, cont, value) => {
-    cont.i2(value);
-    if (cont.i0()) {
-      self.pushStack(cont);
-      return cont.i1();
-    } else {
-      return core.unit;
-    }
-  }
-};
-const drainQueueWhileRunningTable = {
-  [fiber.OP_INTERRUPT_SIGNAL]: (self, runtimeFlags, cur, message) => {
-    self.processNewInterruptSignal(message.cause);
-    return RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.interruptible(runtimeFlags) ? core.exitFailCause(message.cause) : cur;
-  },
-  [fiber.OP_RESUME]: (_self, _runtimeFlags, _cur, _message) => {
-    throw new Error("It is illegal to have multiple concurrent run loops in a single fiber");
-  },
-  [fiber.OP_STATEFUL]: (self, runtimeFlags, cur, message) => {
-    message.onFiber(self, FiberStatus_dist_effectFiberStatus.running(runtimeFlags));
-    return cur;
-  },
-  [fiber.OP_YIELD_NOW]: (_self, _runtimeFlags, cur, _message) => {
-    return core.flatMap$1(core.yieldNow(), () => cur);
-  }
-};
-
-/**
- * Executes all requests, submitting requests to each data source in parallel.
- */
-const runBlockedRequests = self => core.forEachSequentialDiscard(core.flatten$2(self), requestsByRequestResolver => forEachParUnboundedDiscard(core.sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential]) => {
-  const map = new Map();
-  for (const block of sequential) {
-    for (const entry of block) {
-      map.set(entry.request, entry);
-    }
-  }
-  return core.fiberRefLocally(invokeWithInterrupt(dataSource.runAll(sequential), sequential.flat()), currentRequestMap, map);
-}, false));
-
-/** @internal */
-class FiberRuntime {
-  [fiber.FiberTypeId] = fiber.fiberVariance;
-  [fiber.RuntimeFiberTypeId] = runtimeFiberVariance;
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-  _queue = new Array();
-  _children = null;
-  _observers = new Array();
-  _running = false;
-  _stack = [];
-  _asyncInterruptor = null;
-  _asyncBlockingOn = null;
-  _exitValue = null;
-  _steps = [false];
-  currentOpCount = 0;
-  isYielding = false;
-  constructor(fiberId, fiberRefs0, runtimeFlags0) {
-    this._runtimeFlags = runtimeFlags0;
-    this._fiberId = fiberId;
-    this._fiberRefs = fiberRefs0;
-    this._supervisor = this.getFiberRef(currentSupervisor);
-    this._scheduler = this.getFiberRef(Scheduler_dist_effectScheduler.currentScheduler);
-    if (RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.runtimeMetrics(runtimeFlags0)) {
-      const tags = this.getFiberRef(core.currentMetricLabels);
-      fiberStarted.unsafeUpdate(1, tags);
-      fiberActive.unsafeUpdate(1, tags);
-    }
-    this._tracer = Context_dist_effectContext.get(this.getFiberRef(defaultServices.currentServices), core.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(fiber.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 (FiberStatus_dist_effectFiberStatus.isDone(status)) {
-        return state._runtimeFlags;
-      }
-      return status.runtimeFlags;
-    });
-  }
-
-  /**
-   * Returns the current `FiberScope` for the fiber.
-   */
-  scope() {
-    return fiber.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(core.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 core.suspend(() => {
-      const deferred = core.deferredUnsafeMake(this._fiberId);
-      this.tell(fiber.stateful((fiber, status) => {
-        core.deferredUnsafeDone(deferred, core.sync(() => f(fiber, status)));
-      }));
-      return core.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 core.async(resume => {
-      const cb = exit => resume(core.succeed(exit));
-      this.tell(fiber.stateful((fiber, _) => {
-        if (fiber._exitValue !== null) {
-          cb(this._exitValue);
-        } else {
-          fiber.addObserver(cb);
-        }
-      }));
-      return core.sync(() => this.tell(fiber.stateful((fiber, _) => {
-        fiber.removeObserver(cb);
-      })));
-    }, this.id());
-  }
-  inheritAll() {
-    return core.withFiberRuntime((parentFiber, parentStatus) => {
-      const parentFiberId = parentFiber.id();
-      const parentFiberRefs = parentFiber.getFiberRefs();
-      const parentRuntimeFlags = parentStatus.runtimeFlags;
-      const childFiberRefs = this.getFiberRefs();
-      const updatedFiberRefs = fiberRefs.joinAs(parentFiberRefs, parentFiberId, childFiberRefs);
-      parentFiber.setFiberRefs(updatedFiberRefs);
-      const updatedRuntimeFlags = parentFiber.getFiberRef(currentRuntimeFlags);
-      const patch = Function_dist_effectFunction.pipe(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.diff(parentRuntimeFlags, updatedRuntimeFlags),
-      // Do not inherit WindDown or Interruption!
-      RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.exclude(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.Interruption), RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.exclude(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.WindDown));
-      return core.updateRuntimeFlags(patch);
-    });
-  }
-
-  /**
-   * Tentatively observes the fiber, but returns immediately if it is not
-   * already done.
-   */
-  poll() {
-    return core.sync(() => Option_dist_effectOption.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 core.sync(() => this.tell(fiber.interruptSignal(core.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 = 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 = fiberRefs.updatedAs(this._fiberRefs, {
-      fiberId: this._fiberId,
-      fiberRef,
-      value
-    });
-    this.refreshRefCache();
-  }
-  refreshRefCache() {
-    this._tracer = Context_dist_effectContext.get(this.getFiberRef(defaultServices.currentServices), core.tracerTag);
-    this._supervisor = this.getFiberRef(currentSupervisor);
-    this._scheduler = this.getFiberRef(Scheduler_dist_effectScheduler.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[fiber.currentFiberURI];
-      globalThis[fiber.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[fiber.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(core.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 !core.isEmpty(this.getFiberRef(core.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(core.currentInterruptedCause);
-    this.setFiberRef(core.currentInterruptedCause, core.sequential(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(fiber.interruptSignal(core.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 core.asUnit(next.value.await());
-        } else {
-          return core.sync(() => {
-            isDone = true;
-          });
-        }
-      };
-      return core.whileLoop({
-        while: () => !isDone,
-        body,
-        step: () => {
-          //
-        }
-      });
-    }
-    return null;
-  }
-  reportExitValue(exit) {
-    if (RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.runtimeMetrics(this._runtimeFlags)) {
-      const tags = this.getFiberRef(core.currentMetricLabels);
-      fiberActive.unsafeUpdate(-1, tags);
-      switch (exit._tag) {
-        case Effectable.OP_SUCCESS:
-          {
-            fiberSuccesses.unsafeUpdate(1, tags);
-            break;
-          }
-        case Effectable.OP_FAILURE:
-          {
-            fiberFailures.unsafeUpdate(1, tags);
-            break;
-          }
-      }
-    }
-    if (exit._tag === "Failure") {
-      const level = this.getFiberRef(core.currentUnhandledErrorLogLevel);
-      if (!core.isInterruptedOnly(exit.cause) && level._tag === "Some") {
-        this.log("Fiber terminated with a non handled error", exit.cause, level);
-      }
-    }
-  }
-  setExitValue(exit) {
-    this._exitValue = exit;
-    if (RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.runtimeMetrics(this._runtimeFlags)) {
-      const tags = this.getFiberRef(core.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 = Option_dist_effectOption.isSome(overrideLogLevel) ? overrideLogLevel.value : this.getFiberRef(core.currentLogLevel);
-    const minimumLogLevel = this.getFiberRef(currentMinimumLogLevel);
-    if (LogLevel_dist_effectLogLevel.greaterThan(minimumLogLevel, logLevel)) {
-      return;
-    }
-    const spans = this.getFiberRef(core.currentLogSpan);
-    const annotations = this.getFiberRef(core.currentLogAnnotations);
-    const loggers = this.getLoggers();
-    const contextMap = this.getFiberRefs();
-    if (HashSet_dist_effectHashSet.size(loggers) > 0) {
-      const clockService = Context_dist_effectContext.get(this.getFiberRef(defaultServices.currentServices), defaultServices.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 fiber.OP_YIELD_NOW:
-        {
-          return EvaluationSignalYieldNow;
-        }
-      case fiber.OP_INTERRUPT_SIGNAL:
-        {
-          this.processNewInterruptSignal(message.cause);
-          if (this._asyncInterruptor !== null) {
-            this._asyncInterruptor(core.exitFailCause(message.cause));
-            this._asyncInterruptor = null;
-          }
-          return EvaluationSignalContinue;
-        }
-      case fiber.OP_RESUME:
-        {
-          this._asyncInterruptor = null;
-          this._asyncBlockingOn = null;
-          this.evaluateEffect(message.effect);
-          return EvaluationSignalContinue;
-        }
-      case fiber.OP_STATEFUL:
-        {
-          message.onFiber(this, this._exitValue !== null ? FiberStatus_dist_effectFiberStatus.done : FiberStatus_dist_effectFiberStatus.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 = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.interruptible(this._runtimeFlags) && this.isInterrupted() ? core.exitFailCause(this.getInterruptedCause()) : effect0;
-      while (effect !== null) {
-        try {
-          const eff = effect;
-          const exit = this.runLoop(eff);
-          this._runtimeFlags = Function_dist_effectFunction.pipe(this._runtimeFlags, RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.enable$1(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.WindDown));
-          const interruption = this.interruptAllChildren();
-          if (interruption !== null) {
-            effect = core.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(fiber.resume(exit));
-            }
-            effect = null;
-          }
-        } catch (e) {
-          if (core.isEffect(e)) {
-            if (e._op === Effectable.OP_YIELD) {
-              if (RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.cooperativeYielding(this._runtimeFlags)) {
-                this.tell(fiber.yieldNow());
-                this.tell(fiber.resume(core.exitUnit));
-                effect = null;
-              } else {
-                effect = core.exitUnit;
-              }
-            } else if (e._op === Effectable.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[fiber.currentFiberURI];
-      globalThis[fiber.currentFiberURI] = this;
-      try {
-        this.evaluateEffect(effect);
-      } finally {
-        this._running = false;
-        globalThis[fiber.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(fiber.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(fiber.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 = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.patch(oldRuntimeFlags, patch);
-    globalThis[fiber.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(fiber.resume(effect));
-      }
-    };
-    if (RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.interruptible(runtimeFlags)) {
-      this._asyncInterruptor = callback;
-    }
-    try {
-      asyncRegister(callback);
-    } catch (e) {
-      callback(core.failCause(core.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 !== Effectable.OP_ON_FAILURE) {
-        return frame;
-      }
-      frame = this.popStack();
-    }
-  }
-  getNextFailCont() {
-    let frame = this.popStack();
-    while (frame) {
-      if (frame._op !== Effectable.OP_ON_SUCCESS && frame._op !== Effectable.OP_WHILE) {
-        return frame;
-      }
-      frame = this.popStack();
-    }
-  }
-  [Effectable.OP_TAG](op) {
-    return core.map$1(core.fiberRefGet(core.currentContext), context => {
-      try {
-        return Context_dist_effectContext.unsafeGet(context, op);
-      } catch (e) {
-        console.log(e);
-        throw e;
-      }
-    });
-  }
-  ["Left"](op) {
-    return core.fail$1(op.left);
-  }
-  ["None"](_) {
-    return core.fail$1(core.NoSuchElementException());
-  }
-  ["Right"](op) {
-    return core.exitSucceed(op.right);
-  }
-  ["Some"](op) {
-    return core.exitSucceed(op.value);
-  }
-  [Effectable.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 core.exitSucceed(value);
-    }
-  }
-  [Effectable.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;
-    }
-  }
-  [Effectable.OP_FAILURE](op) {
-    const cause = op.i0;
-    const cont = this.getNextFailCont();
-    if (cont !== undefined) {
-      switch (cont._op) {
-        case Effectable.OP_ON_FAILURE:
-        case Effectable.OP_ON_SUCCESS_AND_FAILURE:
-          {
-            if (!(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.interruptible(this._runtimeFlags) && this.isInterrupted())) {
-              return cont.i1(cause);
-            } else {
-              return core.exitFailCause(core.stripFailures(cause));
-            }
-          }
-        case "OnStep":
-          {
-            if (!(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.interruptible(this._runtimeFlags) && this.isInterrupted())) {
-              return cont.i1(core.exitFailCause(cause));
-            } else {
-              return core.exitFailCause(core.stripFailures(cause));
-            }
-          }
-        case Effectable.OP_REVERT_FLAGS:
-          {
-            this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
-            if (RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.interruptible(this._runtimeFlags) && this.isInterrupted()) {
-              return core.exitFailCause(core.sequential(cause, this.getInterruptedCause()));
-            } else {
-              return core.exitFailCause(cause);
-            }
-          }
-        default:
-          {
-            absurd(cont);
-          }
-      }
-    } else {
-      throw core.exitFailCause(cause);
-    }
-  }
-  [Effectable.OP_WITH_RUNTIME](op) {
-    return op.i0(this, FiberStatus_dist_effectFiberStatus.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 core.blocked(op.i0, core.flatMap$1(op.i1, nextOp.i1));
-            }
-          case "OnSuccessAndFailure":
-            {
-              return core.blocked(op.i0, core.matchCauseEffect(op.i1, {
-                onFailure: nextOp.i1,
-                onSuccess: nextOp.i2
-              }));
-            }
-          case "OnFailure":
-            {
-              return core.blocked(op.i0, core.catchAllCause(op.i1, nextOp.i1));
-            }
-          case "While":
-            {
-              return core.blocked(op.i0, core.flatMap$1(op.i1, a => {
-                nextOp.i2(a);
-                if (nextOp.i0()) {
-                  return core.whileLoop({
-                    while: nextOp.i0,
-                    body: nextOp.i1,
-                    step: nextOp.i2
-                  });
-                }
-                return core.unit;
-              }));
-            }
-          case "RevertFlags":
-            {
-              this.pushStack(nextOp);
-              break;
-            }
-        }
-      }
-    }
-    return core.uninterruptibleMask(restore => core.flatMap$1(fork(core.runRequestBlock(op.i0)), () => restore(op.i1)));
-  }
-  ["RunBlocked"](op) {
-    return runBlockedRequests(op.i0);
-  }
-  [Effectable.OP_UPDATE_RUNTIME_FLAGS](op) {
-    const updateFlags = op.i0;
-    const oldRuntimeFlags = this._runtimeFlags;
-    const newRuntimeFlags = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.patch(oldRuntimeFlags, updateFlags);
-    // One more chance to short circuit: if we're immediately going
-    // to interrupt. Interruption will cause immediate reversion of
-    // the flag, so as long as we "peek ahead", there's no need to
-    // set them to begin with.
-    if (RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.interruptible(newRuntimeFlags) && this.isInterrupted()) {
-      return core.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 = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.diff(newRuntimeFlags, oldRuntimeFlags);
-        this.pushStack(new core.RevertFlags(revertFlags, op));
-        return op.i1(oldRuntimeFlags);
-      } else {
-        return core.exitUnit;
-      }
-    }
-  }
-  [Effectable.OP_ON_SUCCESS](op) {
-    this.pushStack(op);
-    return op.i0;
-  }
-  ["OnStep"](op) {
-    this.pushStack(op);
-    return op.i0;
-  }
-  [Effectable.OP_ON_FAILURE](op) {
-    this.pushStack(op);
-    return op.i0;
-  }
-  [Effectable.OP_ON_SUCCESS_AND_FAILURE](op) {
-    this.pushStack(op);
-    return op.i0;
-  }
-  [Effectable.OP_ASYNC](op) {
-    this._asyncBlockingOn = op.i1;
-    this.initiateAsync(this._runtimeFlags, op.i0);
-    throw op;
-  }
-  [Effectable.OP_YIELD](op) {
-    this.isYielding = false;
-    throw op;
-  }
-  [Effectable.OP_WHILE](op) {
-    const check = op.i0;
-    const body = op.i1;
-    if (check()) {
-      this.pushStack(op);
-      return body();
-    } else {
-      return core.exitUnit;
-    }
-  }
-  [Effectable.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 & RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.OpSupervision) !== 0) {
-        this._supervisor.onEffect(this, cur);
-      }
-      if (this._queue.length > 0) {
-        cur = this.drainQueueWhileRunning(this._runtimeFlags, cur);
-      }
-      if (!this.isYielding) {
-        this.currentOpCount += 1;
-        const shouldYield = this._scheduler.shouldYield(this);
-        if (shouldYield !== false) {
-          this.isYielding = true;
-          this.currentOpCount = 0;
-          const oldCur = cur;
-          cur = core.flatMap$1(core.yieldNow({
-            priority: shouldYield
-          }), () => oldCur);
-        }
-      }
-      try {
-        if (!("_op" in cur) || !(cur._op in this)) {
-          console.log(cur);
-          // @ts-expect-error
-          absurd(cur);
-        }
-
-        // @ts-expect-error
-        cur = this._tracer.context(() => {
-          if (GlobalValue_dist_effectGlobalValue.moduleVersion !== cur[Effectable_dist_effectEffectable.EffectTypeId]._V) {
-            return core.dieMessage(`Cannot execute an Effect versioned ${cur[Effectable_dist_effectEffectable.EffectTypeId]._V} with a Runtime of version ${GlobalValue_dist_effectGlobalValue.moduleVersion}`);
-          }
-          // @ts-expect-error
-          return this[cur._op](cur);
-        }, this);
-      } catch (e) {
-        if (core.isEffect(e)) {
-          if (e._op === Effectable.OP_YIELD || e._op === Effectable.OP_ASYNC) {
-            throw e;
-          }
-          if (e._op === Effectable.OP_SUCCESS || e._op === Effectable.OP_FAILURE) {
-            return e;
-          }
-        } else {
-          if (core.isEffectError(e)) {
-            cur = core.exitFailCause(e.cause);
-          } else if (core.isInterruptedException(e)) {
-            cur = core.exitFailCause(core.sequential(core.die(e), core.interrupt(FiberId_dist_effectFiberId.none)));
-          } else {
-            cur = core.exitFailCause(core.die(e));
-          }
-        }
-      }
-    }
-  }
-  run = () => {
-    this.drainQueueOnCurrentThread();
-  };
-}
-
-// circular with Logger
-
-/** @internal */
-const currentMinimumLogLevel = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue("effect/FiberRef/currentMinimumLogLevel", () => core.fiberRefUnsafeMake(LogLevel_dist_effectLogLevel.fromLiteral("Info")));
-
-/** @internal */
-const getConsole = refs => {
-  const defaultServicesValue = FiberRefs_dist_effectFiberRefs.getOrDefault(refs, defaultServices.currentServices);
-  const cnsl = Context_dist_effectContext.get(defaultServicesValue, defaultServices.consoleTag);
-  return cnsl.unsafe;
-};
-
-/** @internal */
-const defaultLogger = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/Logger/defaultLogger"), () => makeLogger(options => {
-  const formatted = stringLogger.log(options);
-  getConsole(options.context).log(formatted);
-}));
-
-/** @internal */
-const logFmtLogger = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/Logger/logFmtLogger"), () => makeLogger(options => {
-  const formatted = logfmtLogger.log(options);
-  getConsole(options.context).log(formatted);
-}));
-
-/** @internal */
-const tracerLogger = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/Logger/tracerLogger"), () => makeLogger(({
-  annotations,
-  cause,
-  context,
-  fiberId,
-  logLevel,
-  message
-}) => {
-  const span = Option_dist_effectOption.flatMap(fiberRefs.get(context, core.currentContext), Context_dist_effectContext.getOption(core.spanTag));
-  const clockService = Option_dist_effectOption.map(fiberRefs.get(context, defaultServices.currentServices), _ => Context_dist_effectContext.get(_, defaultServices.clockTag));
-  if (span._tag === "None" || span.value._tag === "ExternalSpan" || clockService._tag === "None") {
-    return;
-  }
-  const attributes = Object.fromEntries(HashMap_dist_effectHashMap.map(annotations, value => serializeUnknown(value)));
-  attributes["effect.fiberId"] = FiberId_dist_effectFiberId.threadName$1(fiberId);
-  attributes["effect.logLevel"] = logLevel.label;
-  if (cause !== null && cause._tag !== "Empty") {
-    attributes["effect.cause"] = core.pretty(cause);
-  }
-  span.value.event(String(message), clockService.value.unsafeCurrentTimeNanos(), attributes);
-}));
-
-/** @internal */
-const currentLoggers = /*#__PURE__*/GlobalValue_dist_effectGlobalValue.globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentLoggers"), () => core.fiberRefUnsafeMakeHashSet(HashSet_dist_effectHashSet.make(defaultLogger, tracerLogger)));
-
-// circular with Effect
-
-/* @internal */
-const acquireRelease = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[0]), (acquire, release) => {
-  return core.uninterruptible(core.tap(acquire, a => addFinalizer(exit => release(a, exit))));
-});
-
-/* @internal */
-const acquireReleaseInterruptible = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[0]), (acquire, release) => {
-  return ensuring(acquire, addFinalizer(exit => release(exit)));
-});
-
-/* @internal */
-const addFinalizer = finalizer => core.withFiberRuntime(runtime => {
-  const acquireRefs = runtime.getFiberRefs();
-  const acquireFlags = runtime._runtimeFlags;
-  return core.flatMap$1(scope, scope => core.scopeAddFinalizerExit(scope, exit => core.withFiberRuntime(runtimeFinalizer => {
-    const preRefs = runtimeFinalizer.getFiberRefs();
-    const preFlags = runtimeFinalizer._runtimeFlags;
-    const patchRefs = FiberRefsPatch_dist_effectFiberRefsPatch.diff(preRefs, acquireRefs);
-    const patchFlags = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.diff(preFlags, acquireFlags);
-    const inverseRefs = FiberRefsPatch_dist_effectFiberRefsPatch.diff(acquireRefs, preRefs);
-    runtimeFinalizer.setFiberRefs(FiberRefsPatch_dist_effectFiberRefsPatch.patch(patchRefs, runtimeFinalizer.id(), acquireRefs));
-    return ensuring(core.withRuntimeFlags(finalizer(exit), patchFlags), core.sync(() => {
-      runtimeFinalizer.setFiberRefs(FiberRefsPatch_dist_effectFiberRefsPatch.patch(inverseRefs, runtimeFinalizer.id(), runtimeFinalizer.getFiberRefs()));
-    }));
-  })));
-});
-
-/* @internal */
-const daemonChildren = self => {
-  const forkScope = core.fiberRefLocally(core.currentForkScopeOverride, Option_dist_effectOption.some(fiber.globalScope));
-  return forkScope(self);
-};
-
-/** @internal */
-const _existsParFound = /*#__PURE__*/Symbol.for("effect/Effect/existsPar/found");
-
-/* @internal */
-const exists = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => matchSimple(options, () => core.suspend(() => existsLoop(elements[Symbol.iterator](), 0, f)), () => core.matchEffect(forEachOptions(elements, (a, i) => core.if_(f(a, i), {
-  onTrue: core.fail$1(_existsParFound),
-  onFalse: core.unit
-}), options), {
-  onFailure: e => e === _existsParFound ? core.succeed(true) : core.fail$1(e),
-  onSuccess: () => core.succeed(false)
-})));
-const existsLoop = (iterator, index, f) => {
-  const next = iterator.next();
-  if (next.done) {
-    return core.succeed(false);
-  }
-  return Function_dist_effectFunction.pipe(core.flatMap$1(f(next.value, index), b => b ? core.succeed(b) : existsLoop(iterator, index + 1, f)));
-};
-
-/* @internal */
-const filter = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => {
-  const predicate = options?.negate ? (a, i) => core.map$1(f(a, i), Boolean_dist_effectBoolean.not) : f;
-  return matchSimple(options, () => core.suspend(() => ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).reduceRight((effect, a, i) => core.zipWith(effect, core.suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), core.sync(() => new Array()))), () => core.map$1(forEachOptions(elements, (a, i) => core.map$1(predicate(a, i), b => b ? Option_dist_effectOption.some(a) : Option_dist_effectOption.none()), options), ReadonlyArray_dist_effectReadonlyArray.compact));
-});
-
-// === all
-
-const allResolveInput = input => {
-  if (Array.isArray(input) || Predicate_dist_effectPredicate.isIterable(input)) {
-    return [input, Option_dist_effectOption.none()];
-  }
-  const keys = Object.keys(input);
-  const size = keys.length;
-  return [keys.map(k => input[k]), Option_dist_effectOption.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(core.either(effect));
-  }
-  return core.flatMap$1(forEachOptions(eitherEffects, Function_dist_effectFunction.identity, {
-    concurrency: options?.concurrency,
-    batching: options?.batching
-  }), eithers => {
-    const none = Option_dist_effectOption.none();
-    const size = eithers.length;
-    const errors = new Array(size);
-    const successes = new Array(size);
-    let errored = false;
-    for (let i = 0; i < size; i++) {
-      const either = eithers[i];
-      if (either._tag === "Left") {
-        errors[i] = Option_dist_effectOption.some(either.left);
-        errored = true;
-      } else {
-        successes[i] = either.right;
-        errors[i] = none;
-      }
-    }
-    if (errored) {
-      return reconcile._tag === "Some" ? core.fail$1(reconcile.value(errors)) : core.fail$1(errors);
-    } else if (options?.discard) {
-      return core.unit;
-    }
-    return reconcile._tag === "Some" ? core.succeed(reconcile.value(successes)) : core.succeed(successes);
-  });
-};
-const allEither = (effects, reconcile, options) => {
-  const eitherEffects = [];
-  for (const effect of effects) {
-    eitherEffects.push(core.either(effect));
-  }
-  if (options?.discard) {
-    return forEachOptions(eitherEffects, Function_dist_effectFunction.identity, {
-      concurrency: options?.concurrency,
-      batching: options?.batching,
-      discard: true
-    });
-  }
-  return core.map$1(forEachOptions(eitherEffects, Function_dist_effectFunction.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" ? core.map$1(forEachOptions(effects, Function_dist_effectFunction.identity, options), reconcile.value) : forEachOptions(effects, Function_dist_effectFunction.identity, options);
-};
-
-/* @internal */
-const allWith = options => arg => all(arg, options);
-
-/* @internal */
-const allSuccesses = (elements, options) => core.map$1(all(ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).map(core.exit), options), ReadonlyArray_dist_effectReadonlyArray.filterMap(exit => core.exitIsSuccess(exit) ? Option_dist_effectOption.some(exit.i0) : Option_dist_effectOption.none()));
-
-/* @internal */
-const replicate = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => Array.from({
-  length: n
-}, () => self));
-
-/* @internal */
-const replicateEffect = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[0]), (self, n, options) => all(replicate(self, n), options));
-
-// @ts-expect-error
-const forEachOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (self, f, options) => core.withFiberRuntime(r => {
-  const requestBatchingEnabled = options?.batching === true || options?.batching === "inherit" && r.getFiberRef(core.currentRequestBatching);
-  if (options?.discard) {
-    return match(options, () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.sequential)(restore => requestBatchingEnabled ? forEachBatchedDiscard(self, (a, i) => restore(f(a, i))) : core.forEachSequentialDiscard(self, (a, i) => restore(f(a, i)))), () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallel)(restore => forEachParUnboundedDiscard(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallelN(n))(restore => forEachParNDiscard(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
-  }
-  return match(options, () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.sequential)(restore => requestBatchingEnabled ? forEachParN(self, 1, (a, i) => restore(f(a, i)), true) : core.forEachSequential(self, (a, i) => restore(f(a, i)))), () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallel)(restore => forEachParUnbounded(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallelN(n))(restore => forEachParN(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
-}));
-
-/* @internal */
-const forEachParUnbounded = (self, f, batching) => core.suspend(() => {
-  const as = ReadonlyArray_dist_effectReadonlyArray.fromIterable(self);
-  const array = new Array(as.length);
-  const fn = (a, i) => core.flatMap$1(f(a, i), b => core.sync(() => array[i] = b));
-  return core.zipRight(forEachParUnboundedDiscard(as, fn, batching), core.succeed(array));
-});
-const forEachBatchedDiscard = (self, f) => core.suspend(() => {
-  const as = ReadonlyArray_dist_effectReadonlyArray.fromIterable(self);
-  const size = as.length;
-  if (size === 0) {
-    return core.unit;
-  } else if (size === 1) {
-    return core.asUnit(f(as[0], 0));
-  }
-  const effects = as.map(f);
-  const blocked = new Array();
-  const loop = i => i === effects.length ? core.suspend(() => {
-    if (blocked.length > 0) {
-      const requests = blocked.map(b => b.i0).reduce(core.par);
-      return core.blocked(requests, forEachBatchedDiscard(blocked.map(b => b.i1), Function_dist_effectFunction.identity));
-    }
-    return core.unit;
-  }) : core.flatMapStep(effects[i], s => {
-    if (s._op === "Blocked") {
-      blocked.push(s);
-      return loop(i + 1);
-    } else if (s._op === "Failure") {
-      return core.suspend(() => {
-        if (blocked.length > 0) {
-          const requests = blocked.map(b => b.i0).reduce(core.par);
-          return core.blocked(requests, core.flatMap$1(forEachBatchedDiscard(blocked.map(b => b.i1), Function_dist_effectFunction.identity), () => s));
-        }
-        return core.unit;
-      });
-    } else {
-      return loop(i + 1);
-    }
-  });
-  return loop(0);
-});
-
-/* @internal */
-const forEachParUnboundedDiscard = (self, f, batching) => core.suspend(() => {
-  const as = ReadonlyArray_dist_effectReadonlyArray.fromIterable(self);
-  const size = as.length;
-  if (size === 0) {
-    return core.unit;
-  } else if (size === 1) {
-    return core.asUnit(f(as[0], 0));
-  }
-  return core.uninterruptibleMask(restore => {
-    const deferred = core.deferredUnsafeMake(FiberId_dist_effectFiberId.none);
-    let ref = 0;
-    const residual = [];
-    const joinOrder = [];
-    const process = core.transplant(graft => core.forEachSequential(as, (a, i) => Function_dist_effectFunction.pipe(graft(Function_dist_effectFunction.pipe(core.suspend(() => restore((batching ? core.step : core.exit)(f(a, i)))), core.flatMap$1(exit => {
-      switch (exit._op) {
-        case "Failure":
-          {
-            if (residual.length > 0) {
-              const requests = residual.map(blocked => blocked.i0).reduce(core.par);
-              const _continue = forEachParUnboundedDiscard(residual, blocked => blocked.i1, batching);
-              return core.blocked(requests, core.matchCauseEffect(_continue, {
-                onFailure: cause => core.zipRight(core.deferredFail(deferred, void 0), core.failCause(core.parallel(cause, exit.cause))),
-                onSuccess: () => core.zipRight(core.deferredFail(deferred, void 0), core.failCause(exit.cause))
-              }));
-            }
-            return core.zipRight(core.deferredFail(deferred, void 0), core.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(core.par);
-                const _continue = forEachParUnboundedDiscard(residual, blocked => blocked.i1, batching);
-                return core.deferredSucceed(deferred, core.blocked(requests, _continue));
-              } else {
-                core.deferredUnsafeDone(deferred, core.exitSucceed(core.exitUnit));
-              }
-            } else {
-              ref = ref + 1;
-            }
-            return core.unit;
-          }
-      }
-    }))), forkDaemon, core.map$1(fiber => {
-      fiber.addObserver(() => {
-        joinOrder.push(fiber);
-      });
-      return fiber;
-    }))));
-    return core.flatMap$1(process, fibers => core.matchCauseEffect(restore(core.deferredAwait(deferred)), {
-      onFailure: cause => core.flatMap$1(forEachParUnbounded(fibers, core.interruptFiber, batching), exits => {
-        const exit = core.exitCollectAll(exits, {
-          parallel: true
-        });
-        if (exit._tag === "Some" && core.exitIsFailure(exit.value)) {
-          return core.failCause(core.parallel(core.stripFailures(cause), exit.value.i0));
-        } else {
-          return core.failCause(core.stripFailures(cause));
-        }
-      }),
-      onSuccess: rest => core.flatMap$1(rest, () => core.forEachSequentialDiscard(joinOrder, f => f.inheritAll()))
-    }));
-  });
-});
-
-/* @internal */
-const forEachParN = (self, n, f, batching) => core.suspend(() => {
-  const as = ReadonlyArray_dist_effectReadonlyArray.fromIterable(self);
-  const array = new Array(as.length);
-  const fn = (a, i) => core.map$1(f(a, i), b => array[i] = b);
-  return core.zipRight(forEachParNDiscard(as, n, fn, batching), core.succeed(array));
-});
-
-/* @internal */
-const forEachParNDiscard = (self, n, f, batching) => core.suspend(() => {
-  let i = 0;
-  const iterator = self[Symbol.iterator]();
-  const residual = [];
-  const worker = core.flatMap$1(core.sync(() => iterator.next()), next => next.done ? core.unit : core.flatMap$1((batching ? core.step : core.exit)(core.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 core.flatMap$1(core.exit(forEachParUnboundedDiscard(effects, Function_dist_effectFunction.identity, batching)), exit => {
-    if (residual.length === 0) {
-      return exit;
-    }
-    const requests = residual.map(blocked => blocked.i0).reduce(core.par);
-    const _continue = forEachParNDiscard(residual, n, blocked => blocked.i1, batching);
-    if (exit._tag === "Failure") {
-      return core.blocked(requests, core.matchCauseEffect(_continue, {
-        onFailure: cause => core.exitFailCause(core.parallel(exit.cause, cause)),
-        onSuccess: () => exit
-      }));
-    }
-    return core.blocked(requests, _continue);
-  });
-});
-
-/* @internal */
-const fork = self => core.withFiberRuntime((state, status) => core.succeed(unsafeFork(self, state, status.runtimeFlags)));
-
-/* @internal */
-const forkDaemon = self => forkWithScopeOverride(self, fiber.globalScope);
-
-/* @internal */
-const forkWithErrorHandler = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, handler) => fork(core.onError(self, cause => {
-  const either = core.failureOrCause(cause);
-  switch (either._tag) {
-    case "Left":
-      {
-        return handler(either.left);
-      }
-    case "Right":
-      {
-        return core.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 = FiberId_dist_effectFiberId.unsafeMake();
-  const parentFiberRefs = parentFiber.getFiberRefs();
-  const childFiberRefs = fiberRefs.forkAs(parentFiberRefs, childId);
-  const childFiber = new FiberRuntime(childId, childFiberRefs, parentRuntimeFlags);
-  const childContext = fiberRefs.getOrDefault(childFiberRefs, core.currentContext);
-  const supervisor = childFiber._supervisor;
-  supervisor.onStart(childContext, effect, Option_dist_effectOption.some(parentFiber), childFiber);
-  childFiber.addObserver(exit => supervisor.onEnd(exit, childFiber));
-  const parentScope = overrideScope !== null ? overrideScope : Function_dist_effectFunction.pipe(parentFiber.getFiberRef(core.currentForkScopeOverride), Option_dist_effectOption.getOrElse(() => parentFiber.scope()));
-  parentScope.add(parentRuntimeFlags, childFiber);
-  return childFiber;
-};
-
-/* @internal */
-const forkWithScopeOverride = (self, scopeOverride) => core.withFiberRuntime((parentFiber, parentStatus) => core.succeed(unsafeFork(self, parentFiber, parentStatus.runtimeFlags, scopeOverride)));
-
-/* @internal */
-const mergeAll = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).reduce((acc, a, i) => core.zipWith(acc, a, (acc, a) => f(acc, a, i)), core.succeed(zero)), () => core.flatMap$1(Ref_dist_effectRef.make(zero), acc => core.flatMap$1(forEachOptions(elements, (effect, i) => core.flatMap$1(effect, a => Ref_dist_effectRef.update(acc, b => f(b, a, i))), options), () => Ref_dist_effectRef.get(acc)))));
-
-/* @internal */
-const partition = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => Function_dist_effectFunction.pipe(forEachOptions(elements, (a, i) => core.either(f(a, i)), options), core.map$1(chunk => core.partitionMap(chunk, Function_dist_effectFunction.identity))));
-
-/* @internal */
-const validateAll = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => core.flatMap$1(partition(elements, f, {
-  concurrency: options?.concurrency,
-  batching: options?.batching
-}), ([es, bs]) => es.length === 0 ? options?.discard ? core.unit : core.succeed(bs) : core.fail$1(es)));
-
-/* @internal */
-const raceAll = all => {
-  const list = Chunk_dist_effectChunk.fromIterable(all);
-  if (!Chunk_dist_effectChunk.isNonEmpty(list)) {
-    return core.dieSync(() => core.IllegalArgumentException(`Received an empty collection of effects`));
-  }
-  const self = Chunk_dist_effectChunk.headNonEmpty(list);
-  const effects = Chunk_dist_effectChunk.tailNonEmpty(list);
-  const inheritAll = res => Function_dist_effectFunction.pipe(fiber.inheritAll(res[1]), core.as$1(res[0]));
-  return Function_dist_effectFunction.pipe(core.deferredMake(), core.flatMap$1(done => Function_dist_effectFunction.pipe(Ref_dist_effectRef.make(effects.length), core.flatMap$1(fails => core.uninterruptibleMask(restore => Function_dist_effectFunction.pipe(fork(core.interruptible(self)), core.flatMap$1(head => Function_dist_effectFunction.pipe(effects, core.forEachSequential(effect => fork(core.interruptible(effect))), core.map$1(Chunk_dist_effectChunk.unsafeFromArray), core.map$1(tail => Function_dist_effectFunction.pipe(tail, Chunk_dist_effectChunk.prepend(head))), core.tap(fibers => Function_dist_effectFunction.pipe(fibers, ReadonlyArray_dist_effectReadonlyArray.reduce(core.unit, (effect, fiber$1) => Function_dist_effectFunction.pipe(effect, core.zipRight(Function_dist_effectFunction.pipe(fiber._await(fiber$1), core.flatMap$1(raceAllArbiter(fibers, fiber$1, done, fails)), fork, core.asUnit)))))), core.flatMap$1(fibers => Function_dist_effectFunction.pipe(restore(Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred["await"](done), core.flatMap$1(inheritAll))), core.onInterrupt(() => Function_dist_effectFunction.pipe(fibers, ReadonlyArray_dist_effectReadonlyArray.reduce(core.unit, (effect, fiber) => Function_dist_effectFunction.pipe(effect, core.zipLeft(core.interruptFiber(fiber))))))))))))))));
-};
-
-/* @internal */
-const raceAllArbiter = (fibers, winner, deferred, fails) => exit => core.exitMatchEffect(exit, {
-  onFailure: cause => Function_dist_effectFunction.pipe(Ref_dist_effectRef.modify(fails, fails => [fails === 0 ? Function_dist_effectFunction.pipe(core.deferredFailCause(deferred, cause), core.asUnit) : core.unit, fails - 1]), core.flatten$1),
-  onSuccess: value => Function_dist_effectFunction.pipe(core.deferredSucceed(deferred, [value, winner]), core.flatMap$1(set => set ? Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.fromIterable(fibers), ReadonlyArray_dist_effectReadonlyArray.reduce(core.unit, (effect, fiber) => fiber === winner ? effect : Function_dist_effectFunction.pipe(effect, core.zipLeft(core.interruptFiber(fiber))))) : core.unit))
-});
-
-/* @internal */
-const reduceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).reduce((acc, a, i) => core.zipWith(acc, a, (acc, a) => f(acc, a, i)), zero), () => core.suspend(() => Function_dist_effectFunction.pipe(mergeAll([zero, ...elements], Option_dist_effectOption.none(), (acc, elem, i) => {
-  switch (acc._tag) {
-    case "None":
-      {
-        return Option_dist_effectOption.some(elem);
-      }
-    case "Some":
-      {
-        return Option_dist_effectOption.some(f(acc.value, elem, i));
-      }
-  }
-}, options), core.map$1(option => {
-  switch (option._tag) {
-    case "None":
-      {
-        throw new Error("BUG: Effect.reduceEffect - please report an issue at https://github.com/Effect-TS/io/issues");
-      }
-    case "Some":
-      {
-        return option.value;
-      }
-  }
-})))));
-
-/* @internal */
-const parallelFinalizers = self => core.contextWithEffect(context => Option_dist_effectOption.match(Context_dist_effectContext.getOption(context, scopeTag), {
-  onNone: () => self,
-  onSome: scope => {
-    switch (scope.strategy._tag) {
-      case "Parallel":
-        return self;
-      case "Sequential":
-      case "ParallelN":
-        return core.flatMap$1(core.scopeFork(scope, ExecutionStrategy_dist_effectExecutionStrategy.parallel), inner => scopeExtend(self, inner));
-    }
-  }
-}));
-
-/* @internal */
-const parallelNFinalizers = parallelism => self => core.contextWithEffect(context => Option_dist_effectOption.match(Context_dist_effectContext.getOption(context, scopeTag), {
-  onNone: () => self,
-  onSome: scope => {
-    if (scope.strategy._tag === "ParallelN" && scope.strategy.parallelism === parallelism) {
-      return self;
-    }
-    return core.flatMap$1(core.scopeFork(scope, ExecutionStrategy_dist_effectExecutionStrategy.parallelN(parallelism)), inner => scopeExtend(self, inner));
-  }
-}));
-
-/* @internal */
-const finalizersMask = strategy => self => core.contextWithEffect(context => Option_dist_effectOption.match(Context_dist_effectContext.getOption(context, scopeTag), {
-  onNone: () => self(Function_dist_effectFunction.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 => core.flatMap$1(scopeTag, f);
-
-/* @internal */
-const scopedEffect = effect => core.flatMap$1(scopeMake(), scope => scopeUse(scope)(effect));
-
-/* @internal */
-const sequentialFinalizers = self => core.contextWithEffect(context => Option_dist_effectOption.match(Context_dist_effectContext.getOption(context, scopeTag), {
-  onNone: () => self,
-  onSome: scope => {
-    switch (scope.strategy._tag) {
-      case "Sequential":
-        return self;
-      case "Parallel":
-      case "ParallelN":
-        return core.flatMap$1(core.scopeFork(scope, ExecutionStrategy_dist_effectExecutionStrategy.sequential), inner => scopeExtend(self, inner));
-    }
-  }
-}));
-
-/* @internal */
-const tagMetricsScoped = (key, value) => labelMetricsScoped([label.make(key, value)]);
-
-/* @internal */
-const labelMetricsScoped = labels => labelMetricsScopedSet(HashSet_dist_effectHashSet.fromIterable(labels));
-
-/* @internal */
-const labelMetricsScopedSet = labels => fiberRefLocallyScopedWith(core.currentMetricLabels, set => Function_dist_effectFunction.pipe(set, HashSet_dist_effectHashSet.union(labels)));
-
-/* @internal */
-const using = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, use) => core.acquireUseRelease(scopeMake(), scope => core.flatMap$1(scopeExtend(self, scope), use), (scope, exit) => core.scopeClose(scope, exit)));
-
-/** @internal */
-const validate = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, options) => validateWith(self, that, (a, b) => [a, b], options));
-
-/** @internal */
-const validateWith = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, f, options) => core.flatten$1(zipWithOptions(core.exit(self), core.exit(that), (ea, eb) => core.exitZipWith(ea, eb, {
-  onSuccess: f,
-  onFailure: (ca, cb) => options?.concurrent ? core.parallel(ca, cb) : core.sequential(ca, cb)
-}), options)));
-
-/* @internal */
-const validateFirst = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => core.flip(forEachOptions(elements, (a, i) => core.flip(f(a, i)), options)));
-
-/* @internal */
-const withClockScoped = value => fiberRefLocallyScopedWith(defaultServices.currentServices, Context_dist_effectContext.add(defaultServices.clockTag, value));
-
-/* @internal */
-const withConfigProviderScoped = value => fiberRefLocallyScopedWith(defaultServices.currentServices, Context_dist_effectContext.add(configProvider.configProviderTag, value));
-
-/* @internal */
-const withEarlyRelease = self => scopeWith(parent => core.flatMap$1(core.scopeFork(parent, ExecutionStrategy_dist_effectExecutionStrategy.sequential$1), child => Function_dist_effectFunction.pipe(self, scopeExtend(child), core.map$1(value => [core.fiberIdWith(fiberId => core.scopeClose(child, core.exitInterrupt(fiberId))), value]))));
-
-/** @internal */
-const zipOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (a, b) => [a, b], options));
-
-/** @internal */
-const zipLeftOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (a, _) => a, options));
-
-/** @internal */
-const zipRightOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (_, b) => b, options));
-
-/** @internal */
-const zipWithOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, f, options) => core.map$1(all([self, that], {
-  concurrency: options?.concurrent ? 2 : 1,
-  batching: options?.batching
-}), ([a, a2]) => f(a, a2)));
-
-/* @internal */
-const withRuntimeFlagsScoped = update => {
-  if (update === RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.empty) {
-    return core.unit;
-  }
-  return Function_dist_effectFunction.pipe(core.runtimeFlags, core.flatMap$1(runtimeFlags => {
-    const updatedRuntimeFlags = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.patch(runtimeFlags, update);
-    const revertRuntimeFlags = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.diff(updatedRuntimeFlags, runtimeFlags);
-    return Function_dist_effectFunction.pipe(core.updateRuntimeFlags(update), core.zipRight(addFinalizer(() => core.updateRuntimeFlags(revertRuntimeFlags))), core.asUnit);
-  }), core.uninterruptible);
-};
-
-// circular with ReleaseMap
-
-/* @internal */
-const releaseMapReleaseAll = (strategy, exit) => self => core.suspend(() => {
-  switch (self.state._tag) {
-    case "Exited":
-      {
-        return core.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,
-          update
-        };
-        return ExecutionStrategy_dist_effectExecutionStrategy.isSequential(strategy) ? Function_dist_effectFunction.pipe(finalizers, core.forEachSequential(fin => core.exit(update(fin)(exit))), core.flatMap$1(results => Function_dist_effectFunction.pipe(core.exitCollectAll(results), Option_dist_effectOption.map(core.exitAsUnit), Option_dist_effectOption.getOrElse(() => core.exitUnit)))) : ExecutionStrategy_dist_effectExecutionStrategy.isParallel(strategy) ? Function_dist_effectFunction.pipe(forEachParUnbounded(finalizers, fin => core.exit(update(fin)(exit)), false), core.flatMap$1(results => Function_dist_effectFunction.pipe(core.exitCollectAll(results, {
-          parallel: true
-        }), Option_dist_effectOption.map(core.exitAsUnit), Option_dist_effectOption.getOrElse(() => core.exitUnit)))) : Function_dist_effectFunction.pipe(forEachParN(finalizers, strategy.parallelism, fin => core.exit(update(fin)(exit)), false), core.flatMap$1(results => Function_dist_effectFunction.pipe(core.exitCollectAll(results, {
-          parallel: true
-        }), Option_dist_effectOption.map(core.exitAsUnit), Option_dist_effectOption.getOrElse(() => core.exitUnit))));
-      }
-  }
-});
-
-// circular with Scope
-
-/** @internal */
-const scopeTag = /*#__PURE__*/Context_dist_effectContext.Tag(core.ScopeTypeId);
-
-/* @internal */
-const scope = scopeTag;
-
-/* @internal */
-const scopeMake = (strategy = ExecutionStrategy_dist_effectExecutionStrategy.sequential$1) => core.map$1(core.releaseMapMake, rm => ({
-  [core.ScopeTypeId]: core.ScopeTypeId,
-  [core.CloseableScopeTypeId]: core.CloseableScopeTypeId,
-  strategy,
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  },
-  fork: strategy => core.uninterruptible(Function_dist_effectFunction.pipe(scopeMake(strategy), core.flatMap$1(scope => Function_dist_effectFunction.pipe(core.releaseMapAdd(rm, exit => core.scopeClose(scope, exit)), core.tap(fin => core.scopeAddFinalizerExit(scope, fin)), core.as$1(scope))))),
-  close: exit => core.asUnit(releaseMapReleaseAll(strategy, exit)(rm)),
-  addFinalizer: fin => core.asUnit(core.releaseMapAdd(fin)(rm))
-}));
-
-/* @internal */
-const scopeExtend = /*#__PURE__*/Function_dist_effectFunction.dual(2, (effect, scope) => core.mapInputContext(effect,
-// @ts-expect-error
-Context_dist_effectContext.merge(Context_dist_effectContext.make(scopeTag, scope))));
-
-/* @internal */
-const scopeUse = /*#__PURE__*/Function_dist_effectFunction.dual(2, (effect, scope) => Function_dist_effectFunction.pipe(effect, scopeExtend(scope), core.onExit(exit => scope.close(exit))));
-
-// circular with Supervisor
-
-/** @internal */
-const fiberRefUnsafeMakeSupervisor = initial => core.fiberRefUnsafeMakePatch(initial, {
-  differ: differ,
-  fork: empty
-});
-
-// circular with FiberRef
-
-/* @internal */
-const fiberRefLocallyScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => core.asUnit(acquireRelease(core.flatMap$1(core.fiberRefGet(self), oldValue => core.as$1(core.fiberRefSet(self, value), oldValue)), oldValue => core.fiberRefSet(self, oldValue))));
-
-/* @internal */
-const fiberRefLocallyScopedWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.fiberRefGetWith(self, a => fiberRefLocallyScoped(self, f(a))));
-
-/* @internal */
-const fiberRefMake = (initial, options) => fiberRefMakeWith(() => core.fiberRefUnsafeMake(initial, options));
-
-/* @internal */
-const fiberRefMakeWith = ref => acquireRelease(core.tap(core.sync(ref), ref => core.fiberRefUpdate(ref, Function_dist_effectFunction.identity)), fiberRef => core.fiberRefDelete(fiberRef));
-
-/* @internal */
-const fiberRefMakeContext = initial => fiberRefMakeWith(() => core.fiberRefUnsafeMakeContext(initial));
-
-/* @internal */
-const fiberRefMakeRuntimeFlags = initial => fiberRefMakeWith(() => core.fiberRefUnsafeMakeRuntimeFlags(initial));
-
-/** @internal */
-const currentRuntimeFlags = /*#__PURE__*/core.fiberRefUnsafeMakeRuntimeFlags(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.none);
-
-/** @internal */
-const currentSupervisor = /*#__PURE__*/fiberRefUnsafeMakeSupervisor(none);
-
-// circular with Fiber
-
-/* @internal */
-const fiberAwaitAll = fibers => core.asUnit(fiber._await(fiberAll(fibers)));
-
-/** @internal */
-const fiberAll = fibers => ({
-  [fiber.FiberTypeId]: fiber.fiberVariance,
-  id: () => ReadonlyArray_dist_effectReadonlyArray.fromIterable(fibers).reduce((id, fiber) => FiberId_dist_effectFiberId.combine(id, fiber.id()), FiberId_dist_effectFiberId.none),
-  await: () => core.exit(forEachParUnbounded(fibers, fiber => core.flatten$1(fiber.await()), false)),
-  children: () => core.map$1(forEachParUnbounded(fibers, fiber => fiber.children(), false), ReadonlyArray_dist_effectReadonlyArray.flatten),
-  inheritAll: () => core.forEachSequentialDiscard(fibers, fiber => fiber.inheritAll()),
-  poll: () => core.map$1(core.forEachSequential(fibers, fiber => fiber.poll()), ReadonlyArray_dist_effectReadonlyArray.reduceRight(Option_dist_effectOption.some(core.exitSucceed(new Array())), (optionB, optionA) => {
-    switch (optionA._tag) {
-      case "None":
-        {
-          return Option_dist_effectOption.none();
-        }
-      case "Some":
-        {
-          switch (optionB._tag) {
-            case "None":
-              {
-                return Option_dist_effectOption.none();
-              }
-            case "Some":
-              {
-                return Option_dist_effectOption.some(core.exitZipWith(optionA.value, optionB.value, {
-                  onSuccess: (a, chunk) => [a, ...chunk],
-                  onFailure: core.parallel
-                }));
-              }
-          }
-        }
-    }
-  })),
-  interruptAsFork: fiberId => core.forEachSequentialDiscard(fibers, fiber => fiber.interruptAsFork(fiberId)),
-  pipe() {
-    return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
-  }
-});
-
-/* @internal */
-const fiberInterruptFork = self => core.asUnit(forkDaemon(core.interruptFiber(self)));
-
-/* @internal */
-const fiberJoinAll = fibers => core.asUnit(fiber.join(fiberAll(fibers)));
-
-/* @internal */
-const fiberScoped = self => acquireRelease(core.succeed(self), core.interruptFiber);
-
-//
-// circular race
-//
-
-/** @internal */
-const raceWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other, options) => raceFibersWith(self, other, {
-  onSelfWin: (winner, loser) => core.flatMap$1(winner.await(), exit => {
-    switch (exit._tag) {
-      case Effectable.OP_SUCCESS:
-        {
-          return core.flatMap$1(winner.inheritAll(), () => options.onSelfDone(exit, loser));
-        }
-      case Effectable.OP_FAILURE:
-        {
-          return options.onSelfDone(exit, loser);
-        }
-    }
-  }),
-  onOtherWin: (winner, loser) => core.flatMap$1(winner.await(), exit => {
-    switch (exit._tag) {
-      case Effectable.OP_SUCCESS:
-        {
-          return core.flatMap$1(winner.inheritAll(), () => options.onOtherDone(exit, loser));
-        }
-      case Effectable.OP_FAILURE:
-        {
-          return options.onOtherDone(exit, loser);
-        }
-    }
-  })
-}));
-
-/** @internal */
-const disconnect = self => core.uninterruptibleMask(restore => core.fiberIdWith(fiberId => core.flatMap$1(forkDaemon(restore(self)), fiber$1 => Function_dist_effectFunction.pipe(restore(fiber.join(fiber$1)), core.onInterrupt(() => Function_dist_effectFunction.pipe(fiber$1, fiber.interruptAsFork(fiberId)))))));
-
-/** @internal */
-const race = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => core.fiberIdWith(parentFiberId => raceWith(self, that, {
-  onSelfDone: (exit, right) => core.exitMatchEffect(exit, {
-    onFailure: cause => Function_dist_effectFunction.pipe(fiber.join(right), coreEffect.mapErrorCause(cause2 => core.parallel(cause, cause2))),
-    onSuccess: value => Function_dist_effectFunction.pipe(right, core.interruptAsFiber(parentFiberId), core.as$1(value))
-  }),
-  onOtherDone: (exit, left) => core.exitMatchEffect(exit, {
-    onFailure: cause => Function_dist_effectFunction.pipe(fiber.join(left), coreEffect.mapErrorCause(cause2 => core.parallel(cause2, cause))),
-    onSuccess: value => Function_dist_effectFunction.pipe(left, core.interruptAsFiber(parentFiberId), core.as$1(value))
-  })
-})));
-
-/** @internal */
-const raceFibersWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other, options) => core.withFiberRuntime((parentFiber, parentStatus) => {
-  const parentRuntimeFlags = parentStatus.runtimeFlags;
-  const raceIndicator = MutableRef_dist_effectMutableRef.make(true);
-  const leftFiber = unsafeMakeChildFiber(self, parentFiber, parentRuntimeFlags, options.selfScope);
-  const rightFiber = unsafeMakeChildFiber(other, parentFiber, parentRuntimeFlags, options.otherScope);
-  return core.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);
-  }, FiberId_dist_effectFiberId.combine(leftFiber.id(), rightFiber.id()));
-}));
-const completeRace = (winner, loser, cont, ab, cb) => {
-  if (MutableRef_dist_effectMutableRef.compareAndSet(true, false)(ab)) {
-    cb(cont(winner, loser));
-  }
-};
-
-/** @internal */
-const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => core.uninterruptibleMask(restore => core.matchCauseEffect(restore(self), {
-  onFailure: cause1 => core.matchCauseEffect(finalizer, {
-    onFailure: cause2 => core.failCause(core.sequential(cause1, cause2)),
-    onSuccess: () => core.failCause(cause1)
-  }),
-  onSuccess: a => core.as$1(finalizer, a)
-})));
-
-/** @internal */
-const invokeWithInterrupt = (dataSource, all) => core.fiberIdWith(id => core.flatMap$1(core.flatMap$1(forkDaemon(core.interruptible(dataSource)), processing => core.async(cb => {
-  const counts = all.map(_ => _.listeners.count);
-  const checkDone = () => {
-    if (counts.every(count => count === 0)) {
-      cleanup.forEach(f => f());
-      cb(core.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 core.sync(() => {
-    cleanup.forEach(f => f());
-  });
-})), () => core.suspend(() => {
-  const residual = all.flatMap(entry => {
-    if (!entry.state.completed) {
-      return [entry];
-    }
-    return [];
-  });
-  return core.forEachSequentialDiscard(residual, entry => complete(entry.request, core.exitInterrupt(id)));
-})));
-
-/** @internal */
-const interruptWhenPossible = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, all) => core.fiberRefGetWith(currentRequestMap, map => core.suspend(() => {
-  const entries = ReadonlyArray_dist_effectReadonlyArray.fromIterable(all).flatMap(_ => map.has(_) ? [map.get(_)] : []);
-  return invokeWithInterrupt(self, entries);
-})));
-
-// circular Tracer
-
-/** @internal */
-const makeSpanScoped = (name, options) => acquireRelease(coreEffect.makeSpan(name, options), (span, exit) => core.flatMap$1(coreEffect.currentTimeNanosTracing, endTime => core.sync(() => span.end(endTime, exit))));
-
-/* @internal */
-const withTracerScoped = value => fiberRefLocallyScopedWith(defaultServices.currentServices, Context_dist_effectContext.add(core.tracerTag, value));
-
-/** @internal */
-const withSpanScoped = /*#__PURE__*/Function_dist_effectFunction.dual(args => typeof args[0] !== "string", (self, name, options) => core.flatMap$1(makeSpanScoped(name, options), span => coreEffect.provideService(self, core.spanTag, span)));
-
-exports.FiberRuntime = FiberRuntime;
-exports.Listeners = Listeners;
-exports.LoggerTypeId = LoggerTypeId;
-exports.MetricTypeId = MetricTypeId;
-exports.ProxySupervisor = ProxySupervisor;
-exports.RequestTypeId = RequestTypeId;
-exports.SupervisorTypeId = SupervisorTypeId;
-exports.Zip = Zip;
-exports.acquireRelease = acquireRelease;
-exports.acquireReleaseInterruptible = acquireReleaseInterruptible;
-exports.addFinalizer = addFinalizer;
-exports.all = all;
-exports.allSuccesses = allSuccesses;
-exports.allWith = allWith;
-exports.complete = complete;
-exports.completeEffect = completeEffect;
-exports.counter = counter;
-exports.currentLoggers = currentLoggers;
-exports.currentMinimumLogLevel = currentMinimumLogLevel;
-exports.currentRuntimeFlags = currentRuntimeFlags;
-exports.currentSupervisor = currentSupervisor;
-exports.daemonChildren = daemonChildren;
-exports.defaultLogger = defaultLogger;
-exports.disconnect = disconnect;
-exports.ensuring = ensuring;
-exports.exists = exists;
-exports.fail = fail;
-exports.fiberActive = fiberActive;
-exports.fiberAll = fiberAll;
-exports.fiberAwaitAll = fiberAwaitAll;
-exports.fiberFailures = fiberFailures;
-exports.fiberInterruptFork = fiberInterruptFork;
-exports.fiberJoinAll = fiberJoinAll;
-exports.fiberLifetimes = fiberLifetimes;
-exports.fiberRefLocallyScoped = fiberRefLocallyScoped;
-exports.fiberRefLocallyScopedWith = fiberRefLocallyScopedWith;
-exports.fiberRefMake = fiberRefMake;
-exports.fiberRefMakeContext = fiberRefMakeContext;
-exports.fiberRefMakeRuntimeFlags = fiberRefMakeRuntimeFlags;
-exports.fiberRefMakeWith = fiberRefMakeWith;
-exports.fiberRefUnsafeMakeSupervisor = fiberRefUnsafeMakeSupervisor;
-exports.fiberScoped = fiberScoped;
-exports.fiberStarted = fiberStarted;
-exports.fiberSuccesses = fiberSuccesses;
-exports.fibersIn = fibersIn;
-exports.filter = filter;
-exports.filterLogLevel = filterLogLevel;
-exports.finalizersMask = finalizersMask;
-exports.forEachOptions = forEachOptions;
-exports.forEachParUnbounded = forEachParUnbounded;
-exports.forEachParUnboundedDiscard = forEachParUnboundedDiscard;
-exports.fork = fork;
-exports.forkDaemon = forkDaemon;
-exports.forkWithErrorHandler = forkWithErrorHandler;
-exports.frequency = frequency;
-exports.fromEffect = fromEffect;
-exports.fromMetricKey = fromMetricKey;
-exports.gauge = gauge;
-exports.globalMetricRegistry = globalMetricRegistry;
-exports.histogram = histogram;
-exports.increment = increment;
-exports.incrementBy = incrementBy;
-exports.interruptWhenPossible = interruptWhenPossible;
-exports.invokeWithInterrupt = invokeWithInterrupt;
-exports.isRequest = isRequest;
-exports.labelMetricsScoped = labelMetricsScoped;
-exports.labelMetricsScopedSet = labelMetricsScopedSet;
-exports.logFmtLogger = logFmtLogger;
-exports.logfmtLogger = logfmtLogger;
-exports.make = make;
-exports.makeLogger = makeLogger;
-exports.makeSpanScoped = makeSpanScoped;
-exports.map = map$1;
-exports.map$1 = map;
-exports.mapInput = mapInput$1;
-exports.mapInput$1 = mapInput;
-exports.mapType = mapType;
-exports.mergeAll = mergeAll;
-exports.none = none;
-exports.none$1 = none$1;
-exports.of = of;
-exports.parallelFinalizers = parallelFinalizers;
-exports.partition = partition;
-exports.race = race;
-exports.raceAll = raceAll;
-exports.raceFibersWith = raceFibersWith;
-exports.raceWith = raceWith;
-exports.reduceEffect = reduceEffect;
-exports.replicate = replicate;
-exports.replicateEffect = replicateEffect;
-exports.scope = scope;
-exports.scopeExtend = scopeExtend;
-exports.scopeMake = scopeMake;
-exports.scopeTag = scopeTag;
-exports.scopeUse = scopeUse;
-exports.scopeWith = scopeWith;
-exports.scopedEffect = scopedEffect;
-exports.sequentialFinalizers = sequentialFinalizers;
-exports.set = set;
-exports.simple = simple;
-exports.snapshot = snapshot;
-exports.stringLogger = stringLogger;
-exports.succeed = succeed$2;
-exports.succeed$1 = succeed$1;
-exports.succeed$2 = succeed;
-exports.summary = summary;
-exports.summaryTimestamp = summaryTimestamp;
-exports.supervisorVariance = supervisorVariance;
-exports.sync = sync$1;
-exports.sync$1 = sync;
-exports.tagMetricsScoped = tagMetricsScoped;
-exports.tagged = tagged$1;
-exports.tagged$1 = tagged;
-exports.taggedWithLabels = taggedWithLabels;
-exports.taggedWithLabelsInput = taggedWithLabelsInput;
-exports.timer = timer;
-exports.timerWithBoundaries = timerWithBoundaries;
-exports.tracerLogger = tracerLogger;
-exports.track = track;
-exports.trackAll = trackAll;
-exports.trackDefect = trackDefect;
-exports.trackDefectWith = trackDefectWith;
-exports.trackDuration = trackDuration;
-exports.trackDurationWith = trackDurationWith;
-exports.trackError = trackError;
-exports.trackErrorWith = trackErrorWith;
-exports.trackSuccess = trackSuccess;
-exports.trackSuccessWith = trackSuccessWith;
-exports.unsafeSnapshot = unsafeSnapshot;
-exports.unsafeTrack = unsafeTrack;
-exports.update = update;
-exports.using = using;
-exports.validate = validate;
-exports.validateAll = validateAll;
-exports.validateFirst = validateFirst;
-exports.validateWith = validateWith;
-exports.value = value;
-exports.withClockScoped = withClockScoped;
-exports.withConfigProviderScoped = withConfigProviderScoped;
-exports.withConstantInput = withConstantInput;
-exports.withEarlyRelease = withEarlyRelease;
-exports.withNow = withNow;
-exports.withRuntimeFlagsScoped = withRuntimeFlagsScoped;
-exports.withSpanScoped = withSpanScoped;
-exports.withTracerScoped = withTracerScoped;
-exports.zip = zip$1;
-exports.zip$1 = zip;
-exports.zipLeft = zipLeft;
-exports.zipLeftOptions = zipLeftOptions;
-exports.zipOptions = zipOptions;
-exports.zipRight = zipRight;
-exports.zipRightOptions = zipRightOptions;
-exports.zipWithOptions = zipWithOptions;