effect 2.0.0-next.38 → 2.0.0-next.39

package/{dist/fiberRuntime-bfcf5f49.esm.js → internal/fiberRuntime.esm.js}

@@ -1,903 +1,49 @@
-import { n as not } from './Boolean-bf38e241.esm.js';
-import { o as of$1, h as isNonEmpty, j as headNonEmpty, p as prepend, t as tailNonEmpty, f as fromIterable$2, l as unsafeFromArray } from './Chunk-4c1f4599.esm.js';
-import { g as get$2, a as getOption, b as add$1, T as Tag, m as merge, c as make$6, u as unsafeGet } from './Context-c41aa832.esm.js';
-import { _ as _await$1 } from './Deferred-9010d2ac.esm.js';
-import { p as parallel, a as sequential, s as sequential$2, b as parallelN, i as isSequential, c as isParallel } from './ExecutionStrategy-e3775e86.esm.js';
-import { t as threadName, a as threadName$1, c as combine$1, n as none$3, u as unsafeMake$1 } from './FiberId-17e50f05.esm.js';
-import { g as getOrDefault } from './FiberRefs-f705c1b5.esm.js';
-import { d as diff$2, p as patch$2 } from './FiberRefsPatch-04e0adc7.esm.js';
-import { i as isDone, d as done, s as suspended, r as running } from './FiberStatus-7a24d5ef.esm.js';
-import { d as dual, b as constVoid, p as pipe, i as identity } from './Function-12511160.esm.js';
-import { e as empty$2, m as make$2, u as union, c as fromIterable, i as isHashSet, r as reduce, d as difference, s as size$1 } from './HashSet-ae2856c1.esm.js';
-import { r as fiberRefUnsafeMake, v as fiberRefGetWith, x as currentConcurrency, y as empty$1, A as pretty, t as tap, s as sync$2, B as matchCauseEffect, C as failCause, j as succeed$3, D as defects, m as map$2, E as currentMetricLabels, q as deferredUnsafeDone, F as matchEffect, G as exitFail, H as exitSucceed, J as zip$2, p as unit, K as currentTracerSpan, L as fiberRefUnsafeMakeHashSet, u as uninterruptible, M as isEffect, w as withFiberRuntime, N as fiberRefLocally, O as currentForkScopeOverride, P as exit, Q as exitIsSuccess, R as onError, S as failureOrCause, T as partitionMap, U as either, f as flatMap$1, V as fail$1, W as dieSync, X as uninterruptibleMask, Y as interruptible, Z as forEachSequential, z as zipRight$1, c as asUnit, o as onInterrupt, _ as zipLeft$1, $ as interruptFiber, d as deferredMake, a0 as exitMatchEffect, a1 as flatten, a2 as deferredFailCause, g as deferredSucceed, a3 as contextWithEffect, a4 as scopeFork, a5 as acquireUseRelease, a6 as scopeClose, a7 as exitZipWith, a8 as parallel$1, a9 as sequential$1, aa as flip, ab as fiberIdWith, ac as updateRuntimeFlags, ad as runtimeFlags, ae as ScopeTypeId, af as releaseMapMake, ag as CloseableScopeTypeId, ah as releaseMapAdd, ai as scopeAddFinalizerExit, aj as as, ak as mapInputContext, al as onExit, am as fiberRefUnsafeMakePatch, an as fiberRefGet, ao as fiberRefSet, ap as fiberRefUpdate, aq as fiberRefDelete, ar as fiberRefUnsafeMakeContext, as as fiberRefUnsafeMakeRuntimeFlags, at as forEachSequentialDiscard, a as suspend, au as currentInterruptedCause, l as deferredUnsafeMake, b as deferredAwait, av as async, aw as interrupt, ax as currentSchedulingPriority, ay as isEmpty, az as whileLoop, aA as currentUnhandledErrorLogLevel, aB as isInterruptedOnly, aC as currentLogLevel, aD as currentLogSpan, aE as currentLogAnnotations, aF as exitFailCause, aG as exitUnit, aH as die, aI as currentContext, aJ as NoSuchElementException, aK as stripFailures, aL as blocked, aM as catchAllCause, aN as runRequestBlock, aO as RevertFlags, aP as yieldNow$1, aQ as isEffectError, aR as isInterruptedException, aS as withRuntimeFlags, aT as if_, aU as zipWith, aV as currentRequestBatching, aW as transplant, aX as step, aY as par, aZ as deferredFail, a_ as exitCollectAll, a$ as exitIsFailure, b0 as IllegalArgumentException, h as exitInterrupt, b1 as exitAsUnit, b2 as interruptAsFiber, b3 as flatten$2, b4 as sequentialCollectionToChunk, b5 as flatMapStep } from './core-64ab7ff5.esm.js';
-import { c as currentServices, a as clockTag, t as tracerTag, b as consoleTag } from './defaultServices-b9ca1236.esm.js';
-import { g as globalValue } from './GlobalValue-b5edf230.esm.js';
-import { c as configProviderTag } from './configProvider-c997961d.esm.js';
-import { t as tapDefect, a as tapError, m as makeSpan, c as currentTimeNanosTracing, b as mapErrorCause } from './core-effect-57445976.esm.js';
-import { g as globalScope, _ as _await, F as FiberTypeId, f as fiberVariance, j as join, R as RuntimeFiberTypeId, r as resume, u as unsafeMake, s as stateful, i as interruptSignal, c as currentFiberURI, O as OP_STATEFUL, a as OP_RESUME, b as OP_INTERRUPT_SIGNAL, d as OP_YIELD_NOW, y as yieldNow, e as inheritAll, h as interruptAsFork } from './fiber-8fb398f3.esm.js';
-import { g as get$1, j as joinAs, d as delete_, u as updatedAs, f as forkAs, a as getOrDefault$1 } from './fiberRefs-69cce1a0.esm.js';
-import { b as size } from './HashMap-6c230bde.esm.js';
-import { i as isCons, h as head, p as prepend$1 } from './List-6e58a1e9.esm.js';
-import { r as render } from './LogSpan-f36e9619.esm.js';
-import { s as some, n as none$2, f as flatMap, m as map$3, b as match$1, e as fromNullable, i as isSome, g as getOrElse } from './Option-df40d2b9.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
-import { c as clockWith } from './Clock-f8b987d7.esm.js';
-import { t as toMillis, n as nanos } from './Duration-98bca14c.esm.js';
-import { e as exponential, f as fromChunk } from './boundaries-52029180.esm.js';
-import { c as counter$1, f as frequency$1, g as gauge$1, h as histogram$1, s as summary$1, t as taggedWithLabelSet } from './key-340a2bae.esm.js';
-import { m as make$3 } from './label-0cc6c9a0.esm.js';
-import { m as make$1 } from './registry-c59aeb06.esm.js';
-import { C as forEach, f as fromIterable$1, a as filterMap, A as reduce$1, D as flatten$1, B as reduceRight, E as compact } from './ReadonlyArray-0a71b226.esm.js';
-import { a as OP_FAILURE, O as OP_SUCCESS, i as OP_YIELD, k as OP_ASYNC, c as OP_ON_FAILURE, d as OP_ON_SUCCESS, h as OP_WHILE, l as OP_TAG, g as OP_SYNC, j as OP_REVERT_FLAGS, e as OP_ON_SUCCESS_AND_FAILURE, b as OP_WITH_RUNTIME, f as OP_UPDATE_RUNTIME_FLAGS, m as OP_COMMIT } from './Effectable-a292d920.esm.js';
-import { s as struct } from './Data-dee529b9.esm.js';
-import { b as empty$3, p as patch$1, c as diff$1, r as runtimeMetrics, f as exclude, W as WindDown, I as Interruption, g as interruptible$1, h as enable, j as cooperativeYielding, O as OpSupervision, n as none$4 } from './RuntimeFlagsPatch-51f77dce.esm.js';
-import { g as get, s as set$1, m as make$7, c as compareAndSet } from './MutableRef-2734b082.esm.js';
-import { a as add, r as remove } from './SortedSet-ffc2cefd.esm.js';
-import { m as make$4 } from './Differ-a249bf4d.esm.js';
-import { e as equals } from './Equal-2a99fde3.esm.js';
-import { f as fromLiteral, g as greaterThan } from './LogLevel-5a4fa506.esm.js';
-import { a as isIterable } from './Predicate-6b61b95b.esm.js';
-import { m as make$5, a as modify, u as update$1, g as get$3 } from './Ref-5eefaff1.esm.js';
-import { c as currentScheduler } from './Scheduler-844c1a90.esm.js';
-
-/** @internal */
-const currentRequestMap = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberRef/currentRequestMap"), () => fiberRefUnsafeMake(new Map()));
-
-/** @internal */
-const match = (options, sequential, unbounded, bounded) => {
-  switch (options?.concurrency) {
-    case undefined:
-      {
-        return sequential();
-      }
-    case "unbounded":
-      {
-        return unbounded();
-      }
-    case "inherit":
-      {
-        return fiberRefGetWith(currentConcurrency, concurrency => concurrency === "unbounded" ? unbounded() : concurrency > 1 ? bounded(concurrency) : sequential());
-      }
-    default:
-      {
-        return options.concurrency > 1 ? bounded(options.concurrency) : sequential();
-      }
-  }
-};
-
-/** @internal */
-const matchSimple = (options, sequential, concurrent) => {
-  switch (options?.concurrency) {
-    case undefined:
-      {
-        return sequential();
-      }
-    case "unbounded":
-      {
-        return concurrent();
-      }
-    case "inherit":
-      {
-        return fiberRefGetWith(currentConcurrency, concurrency => concurrency === "unbounded" ? concurrent() : concurrency > 1 ? concurrent() : sequential());
-      }
-    default:
-      {
-        return options.concurrency > 1 ? concurrent() : sequential();
-      }
-  }
-};
-
-/** @internal */
-const LoggerSymbolKey = "effect/Logger";
-
-/** @internal */
-const LoggerTypeId = /*#__PURE__*/Symbol.for(LoggerSymbolKey);
-
-/** @internal */
-const loggerVariance = {
-  _Message: _ => _,
-  _Output: _ => _
-};
-
-/** @internal */
-const makeLogger = log => ({
-  [LoggerTypeId]: loggerVariance,
-  log,
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-});
-
-/** @internal */
-const mapInput$1 = /*#__PURE__*/dual(2, (self, f) => makeLogger(options => self.log({
-  ...options,
-  message: f(options.message)
-})));
-
-/** @internal */
-const filterLogLevel = /*#__PURE__*/dual(2, (self, f) => makeLogger(options => f(options.logLevel) ? some(self.log(options)) : none$2()));
-
-/** @internal */
-const map$1 = /*#__PURE__*/dual(2, (self, f) => makeLogger(options => f(self.log(options))));
-
-/** @internal */
-const none$1 = {
-  [LoggerTypeId]: loggerVariance,
-  log: constVoid,
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-};
-
-/** @internal */
-const simple = log => ({
-  [LoggerTypeId]: loggerVariance,
-  log: ({
-    message
-  }) => log(message),
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-});
-
-/** @internal */
-const succeed$2 = value => {
-  return simple(() => value);
-};
-
-/** @internal */
-const sync$1 = evaluate => {
-  return simple(evaluate);
-};
-
-/** @internal */
-const zip$1 = /*#__PURE__*/dual(2, (self, that) => makeLogger(options => [self.log(options), that.log(options)]));
-
-/** @internal */
-const zipLeft = /*#__PURE__*/dual(2, (self, that) => map$1(zip$1(self, that), tuple => tuple[0]));
-
-/** @internal */
-const zipRight = /*#__PURE__*/dual(2, (self, that) => map$1(zip$1(self, that), tuple => tuple[1]));
-
-/** @internal */
-const stringLogger = /*#__PURE__*/makeLogger(({
-  annotations,
-  cause,
-  date,
-  fiberId,
-  logLevel,
-  message,
-  spans
-}) => {
-  const nowMillis = date.getTime();
-  const outputArray = [`timestamp=${date.toISOString()}`, `level=${logLevel.label}`, `fiber=${threadName(fiberId)}`];
-  let output = outputArray.join(" ");
-  const stringMessage = serializeUnknown(message);
-  if (stringMessage.length > 0) {
-    output = output + " message=";
-    output = appendQuoted(stringMessage, output);
-  }
-  if (cause != null && cause != empty$1) {
-    output = output + " cause=";
-    output = appendQuoted(pretty(cause), output);
-  }
-  if (isCons(spans)) {
-    output = output + " ";
-    let first = true;
-    for (const span of spans) {
-      if (first) {
-        first = false;
-      } else {
-        output = output + " ";
-      }
-      output = output + pipe(span, render(nowMillis));
-    }
-  }
-  if (pipe(annotations, size) > 0) {
-    output = output + " ";
-    let first = true;
-    for (const [key, value] of annotations) {
-      if (first) {
-        first = false;
-      } else {
-        output = output + " ";
-      }
-      output = output + filterKeyName(key);
-      output = output + "=";
-      output = appendQuoted(String(value), output);
-    }
-  }
-  return output;
-});
-const serializeUnknown = u => {
-  try {
-    return typeof u === "object" ? JSON.stringify(u) : String(u);
-  } catch (_) {
-    return String(u);
-  }
-};
-
-/** @internal */
-const escapeDoubleQuotes = str => `"${str.replace(/\\([\s\S])|(")/g, "\\$1$2")}"`;
-const textOnly = /^[^\s"=]+$/;
-
-/** @internal */
-const appendQuoted = (label, output) => output + (label.match(textOnly) ? label : escapeDoubleQuotes(label));
-
-/** @internal */
-const logfmtLogger = /*#__PURE__*/makeLogger(({
-  annotations,
-  cause,
-  date,
-  fiberId,
-  logLevel,
-  message,
-  spans
-}) => {
-  const nowMillis = date.getTime();
-  const outputArray = [`timestamp=${date.toISOString()}`, `level=${logLevel.label}`, `fiber=${threadName(fiberId)}`];
-  let output = outputArray.join(" ");
-  const stringMessage = serializeUnknown(message);
-  if (stringMessage.length > 0) {
-    output = output + " message=";
-    output = appendQuotedLogfmt(stringMessage, output);
-  }
-  if (cause != null && cause != empty$1) {
-    output = output + " cause=";
-    output = appendQuotedLogfmt(pretty(cause), output);
-  }
-  if (isCons(spans)) {
-    output = output + " ";
-    let first = true;
-    for (const span of spans) {
-      if (first) {
-        first = false;
-      } else {
-        output = output + " ";
-      }
-      output = output + pipe(span, renderLogSpanLogfmt(nowMillis));
-    }
-  }
-  if (pipe(annotations, size) > 0) {
-    output = output + " ";
-    let first = true;
-    for (const [key, value] of annotations) {
-      if (first) {
-        first = false;
-      } else {
-        output = output + " ";
-      }
-      output = output + filterKeyName(key);
-      output = output + "=";
-      output = appendQuotedLogfmt(String(value), output);
-    }
-  }
-  return output;
-});
-
-/** @internal */
-const filterKeyName = key => key.replace(/[\s="]/g, "_");
-
-/** @internal */
-const escapeDoubleQuotesLogfmt = str => JSON.stringify(str);
-
-/** @internal */
-const appendQuotedLogfmt = (label, output) => output + (label.match(textOnly) ? label : escapeDoubleQuotesLogfmt(label));
-
-/** @internal */
-const renderLogSpanLogfmt = now => self => {
-  const label = filterKeyName(self.label);
-  return `${label}=${now - self.startTime}ms`;
-};
-
-/** @internal */
-const MetricSymbolKey = "effect/Metric";
-
-/** @internal */
-const MetricTypeId = /*#__PURE__*/Symbol.for(MetricSymbolKey);
-
-/** @internal */
-const metricVariance = {
-  _Type: _ => _,
-  _In: _ => _,
-  _Out: _ => _
-};
-
-/** @internal */
-const globalMetricRegistry = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Metric/globalMetricRegistry"), () => make$1());
-
-/** @internal */
-const make = function (keyType, unsafeUpdate, unsafeValue) {
-  const metric = Object.assign(effect => tap(effect, a => sync$2(() => unsafeUpdate(a, empty$2()))), {
-    [MetricTypeId]: metricVariance,
-    keyType,
-    unsafeUpdate,
-    unsafeValue,
-    pipe() {
-      return pipeArguments(this, arguments);
-    }
-  });
-  return metric;
-};
-
-/** @internal */
-const mapInput = /*#__PURE__*/dual(2, (self, f) => make(self.keyType, (input, extraTags) => self.unsafeUpdate(f(input), extraTags), self.unsafeValue));
-
-/** @internal */
-const counter = (name, description) => fromMetricKey(counter$1(name, description));
-
-/** @internal */
-const frequency = (name, description) => fromMetricKey(frequency$1(name, description));
-
-/** @internal */
-const withConstantInput = /*#__PURE__*/dual(2, (self, input) => mapInput(self, () => input));
-
-/** @internal */
-const fromMetricKey = key => {
-  const hook = extraTags => {
-    const fullKey = pipe(key, taggedWithLabelSet(extraTags));
-    return globalMetricRegistry.get(fullKey);
-  };
-  return make(key.keyType, (input, extraTags) => hook(extraTags).update(input), extraTags => hook(extraTags).get());
-};
-
-/** @internal */
-const gauge = (name, description) => fromMetricKey(gauge$1(name, description));
-
-/** @internal */
-const histogram = (name, boundaries, description) => fromMetricKey(histogram$1(name, boundaries, description));
-
-/* @internal */
-const increment = self => update(self, 1);
-
-/* @internal */
-const incrementBy = /*#__PURE__*/dual(2, (self, amount) => update(self, amount));
-
-/** @internal */
-const map = /*#__PURE__*/dual(2, (self, f) => make(self.keyType, self.unsafeUpdate, extraTags => f(self.unsafeValue(extraTags))));
-
-/** @internal */
-const mapType = /*#__PURE__*/dual(2, (self, f) => make(f(self.keyType), self.unsafeUpdate, self.unsafeValue));
-
-/* @internal */
-const set = /*#__PURE__*/dual(2, (self, value) => update(self, value));
-
-/** @internal */
-const succeed$1 = out => make(void 0, constVoid, () => out);
-
-/** @internal */
-const sync = evaluate => make(void 0, constVoid, evaluate);
-
-/** @internal */
-const summary = options => withNow(summaryTimestamp(options));
-
-/** @internal */
-const summaryTimestamp = options => fromMetricKey(summary$1(options));
-
-/** @internal */
-const tagged$1 = /*#__PURE__*/dual(3, (self, key, value) => taggedWithLabels(self, make$2(make$3(key, value))));
-
-/** @internal */
-const taggedWithLabelsInput = /*#__PURE__*/dual(2, (self, f) => map(make(self.keyType, (input, extraTags) => self.unsafeUpdate(input, union(fromIterable(f(input)), extraTags)), self.unsafeValue), constVoid));
-
-/** @internal */
-const taggedWithLabels = /*#__PURE__*/dual(2, (self, extraTagsIterable) => {
-  const extraTags = isHashSet(extraTagsIterable) ? extraTagsIterable : fromIterable(extraTagsIterable);
-  return make(self.keyType, (input, extraTags1) => self.unsafeUpdate(input, pipe(extraTags, union(extraTags1))), extraTags1 => self.unsafeValue(pipe(extraTags, union(extraTags1))));
-});
-
-/** @internal */
-const timer = name => {
-  const boundaries = exponential({
-    start: 1,
-    factor: 2,
-    count: 100
-  });
-  const base = pipe(histogram(name, boundaries), tagged$1("time_unit", "milliseconds"));
-  return mapInput(base, toMillis);
-};
-
-/** @internal */
-const timerWithBoundaries = (name, boundaries) => {
-  const base = pipe(histogram(name, fromChunk(boundaries)), tagged$1("time_unit", "milliseconds"));
-  return mapInput(base, toMillis);
-};
-
-/* @internal */
-const trackAll = /*#__PURE__*/dual(2, (self, input) => effect => matchCauseEffect(effect, {
-  onFailure: cause => {
-    self.unsafeUpdate(input, empty$2());
-    return failCause(cause);
-  },
-  onSuccess: value => {
-    self.unsafeUpdate(input, empty$2());
-    return succeed$3(value);
-  }
-}));
-
-/* @internal */
-const trackDefect = /*#__PURE__*/dual(2, (self, metric) => trackDefectWith(self, metric, identity));
-
-/* @internal */
-const trackDefectWith = /*#__PURE__*/dual(3, (self, metric, f) => {
-  const updater = defect => metric.unsafeUpdate(f(defect), empty$2());
-  return tapDefect(self, cause => sync$2(() => pipe(defects(cause), forEach(updater))));
-});
-
-/* @internal */
-const trackDuration = /*#__PURE__*/dual(2, (self, metric) => trackDurationWith(self, metric, identity));
-
-/* @internal */
-const trackDurationWith = /*#__PURE__*/dual(3, (self, metric, f) => clockWith(clock => {
-  const startTime = clock.unsafeCurrentTimeNanos();
-  return map$2(self, a => {
-    const endTime = clock.unsafeCurrentTimeNanos();
-    const duration = nanos(endTime - startTime);
-    metric.unsafeUpdate(f(duration), empty$2());
-    return a;
-  });
-}));
-
-/* @internal */
-const trackError = /*#__PURE__*/dual(2, (self, metric) => trackErrorWith(self, metric, a => a));
-
-/* @internal */
-const trackErrorWith = /*#__PURE__*/dual(3, (self, metric, f) => {
-  const updater = error => update(metric, f(error));
-  return tapError(self, updater);
-});
-
-/* @internal */
-const trackSuccess = /*#__PURE__*/dual(2, (self, metric) => trackSuccessWith(self, metric, a => a));
-
-/* @internal */
-const trackSuccessWith = /*#__PURE__*/dual(3, (self, metric, f) => {
-  const updater = value => update(metric, f(value));
-  return tap(self, updater);
-});
-
-/* @internal */
-const update = /*#__PURE__*/dual(2, (self, input) => fiberRefGetWith(currentMetricLabels, tags => sync$2(() => self.unsafeUpdate(input, tags))));
-
-/* @internal */
-const value = self => fiberRefGetWith(currentMetricLabels, tags => sync$2(() => self.unsafeValue(tags)));
-
-/** @internal */
-const withNow = self => mapInput(self, input => [input, Date.now()]);
-
-/** @internal */
-const zip = /*#__PURE__*/dual(2, (self, that) => make([self.keyType, that.keyType], (input, extraTags) => {
-  const [l, r] = input;
-  self.unsafeUpdate(l, extraTags);
-  that.unsafeUpdate(r, extraTags);
-}, extraTags => [self.unsafeValue(extraTags), that.unsafeValue(extraTags)]));
-
-/** @internal */
-const unsafeSnapshot = () => globalMetricRegistry.snapshot();
-
-/** @internal */
-const snapshot = /*#__PURE__*/sync$2(unsafeSnapshot);
-
-/** @internal */
-const RequestSymbolKey = "effect/Request";
-
-/** @internal */
-const RequestTypeId = /*#__PURE__*/Symbol.for(RequestSymbolKey);
-
-/** @internal */
-const requestVariance = {
-  _E: _ => _,
-  _A: _ => _
-};
-
-/** @internal */
-const isRequest = u => typeof u === "object" && u != null && RequestTypeId in u;
-
-/** @internal */
-const of = () => args =>
-// @ts-expect-error
-struct({
-  [RequestTypeId]: requestVariance,
-  ...args
-});
-
-/** @internal */
-const tagged = tag => args =>
-// @ts-expect-error
-struct({
-  [RequestTypeId]: requestVariance,
-  _tag: tag,
-  ...args
-});
-
-/** @internal */
-const complete = /*#__PURE__*/dual(2, (self, result) => fiberRefGetWith(currentRequestMap, map => sync$2(() => {
-  if (map.has(self)) {
-    const entry = map.get(self);
-    if (!entry.state.completed) {
-      entry.state.completed = true;
-      deferredUnsafeDone(entry.result, result);
-    }
-  }
-})));
-
-/** @internal */
-const completeEffect = /*#__PURE__*/dual(2, (self, effect) => matchEffect(effect, {
-  onFailure: error => complete(self, exitFail(error)),
-  onSuccess: value => complete(self, exitSucceed(value))
-}));
-
-/** @internal */
-const fail = /*#__PURE__*/dual(2, (self, error) => complete(self, exitFail(error)));
-
-/** @internal */
-const succeed = /*#__PURE__*/dual(2, (self, value) => complete(self, exitSucceed(value)));
-
-/** @internal */
-class Listeners {
-  count = 0;
-  observers = new Set();
-  addObserver(f) {
-    this.observers.add(f);
-  }
-  removeObserver(f) {
-    this.observers.delete(f);
-  }
-  increment() {
-    this.count++;
-    this.observers.forEach(f => f(this.count));
-  }
-  decrement() {
-    this.count--;
-    this.observers.forEach(f => f(this.count));
-  }
-}
-
-/** @internal */
-const SupervisorSymbolKey = "effect/Supervisor";
-
-/** @internal */
-const SupervisorTypeId = /*#__PURE__*/Symbol.for(SupervisorSymbolKey);
-
-/** @internal */
-const supervisorVariance = {
-  _T: _ => _
-};
-
-/** @internal */
-class ProxySupervisor {
-  [SupervisorTypeId] = supervisorVariance;
-  constructor(underlying, value0) {
-    this.underlying = underlying;
-    this.value0 = value0;
-  }
-  value() {
-    return this.value0();
-  }
-  onStart(context, effect, parent, fiber) {
-    this.underlying.onStart(context, effect, parent, fiber);
-  }
-  onEnd(value, fiber) {
-    this.underlying.onEnd(value, fiber);
-  }
-  onEffect(fiber, effect) {
-    this.underlying.onEffect(fiber, effect);
-  }
-  onSuspend(fiber) {
-    this.underlying.onSuspend(fiber);
-  }
-  onResume(fiber) {
-    this.underlying.onResume(fiber);
-  }
-  map(f) {
-    return new ProxySupervisor(this, () => pipe(this.value(), map$2(f)));
-  }
-  zip(right) {
-    return new Zip(this, right);
-  }
-}
-
-/** @internal */
-class Zip {
-  [SupervisorTypeId] = supervisorVariance;
-  constructor(left, right) {
-    this.left = left;
-    this.right = right;
-  }
-  value() {
-    return zip$2(this.left.value(), this.right.value());
-  }
-  onStart(context, effect, parent, fiber) {
-    this.left.onStart(context, effect, parent, fiber);
-    this.right.onStart(context, effect, parent, fiber);
-  }
-  onEnd(value, fiber) {
-    this.left.onEnd(value, fiber);
-    this.right.onEnd(value, fiber);
-  }
-  onEffect(fiber, effect) {
-    this.left.onEffect(fiber, effect);
-    this.right.onEffect(fiber, effect);
-  }
-  onSuspend(fiber) {
-    this.left.onSuspend(fiber);
-    this.right.onSuspend(fiber);
-  }
-  onResume(fiber) {
-    this.left.onResume(fiber);
-    this.right.onResume(fiber);
-  }
-  map(f) {
-    return new ProxySupervisor(this, () => pipe(this.value(), map$2(f)));
-  }
-  zip(right) {
-    return new Zip(this, right);
-  }
-}
-class Track {
-  [SupervisorTypeId] = supervisorVariance;
-  fibers = new Set();
-  value() {
-    return sync$2(() => Array.from(this.fibers));
-  }
-  onStart(_context, _effect, _parent, fiber) {
-    this.fibers.add(fiber);
-  }
-  onEnd(_value, fiber) {
-    this.fibers.delete(fiber);
-  }
-  onEffect(_fiber, _effect) {
-    //
-  }
-  onSuspend(_fiber) {
-    //
-  }
-  onResume(_fiber) {
-    //
-  }
-  map(f) {
-    return new ProxySupervisor(this, () => pipe(this.value(), map$2(f)));
-  }
-  zip(right) {
-    return new Zip(this, right);
-  }
-  onRun(execution, _fiber) {
-    return execution();
-  }
-}
-class Const {
-  [SupervisorTypeId] = supervisorVariance;
-  constructor(effect) {
-    this.effect = effect;
-  }
-  value() {
-    return this.effect;
-  }
-  onStart(_context, _effect, _parent, _fiber) {
-    //
-  }
-  onEnd(_value, _fiber) {
-    //
-  }
-  onEffect(_fiber, _effect) {
-    //
-  }
-  onSuspend(_fiber) {
-    //
-  }
-  onResume(_fiber) {
-    //
-  }
-  map(f) {
-    return new ProxySupervisor(this, () => pipe(this.value(), map$2(f)));
-  }
-  zip(right) {
-    return new Zip(this, right);
-  }
-  onRun(execution, _fiber) {
-    return execution();
-  }
-}
-class FibersIn {
-  [SupervisorTypeId] = supervisorVariance;
-  constructor(ref) {
-    this.ref = ref;
-  }
-  value() {
-    return sync$2(() => get(this.ref));
-  }
-  onStart(_context, _effect, _parent, fiber) {
-    pipe(this.ref, set$1(pipe(get(this.ref), add(fiber))));
-  }
-  onEnd(_value, fiber) {
-    pipe(this.ref, set$1(pipe(get(this.ref), remove(fiber))));
-  }
-  onEffect(_fiber, _effect) {
-    //
-  }
-  onSuspend(_fiber) {
-    //
-  }
-  onResume(_fiber) {
-    //
-  }
-  map(f) {
-    return new ProxySupervisor(this, () => pipe(this.value(), map$2(f)));
-  }
-  zip(right) {
-    return new Zip(this, right);
-  }
-  onRun(execution, _fiber) {
-    return execution();
-  }
-}
-
-/** @internal */
-const unsafeTrack = () => {
-  return new Track();
-};
-
-/** @internal */
-const track = /*#__PURE__*/sync$2(unsafeTrack);
-
-/** @internal */
-const fromEffect = effect => {
-  return new Const(effect);
-};
-
-/** @internal */
-const none = /*#__PURE__*/fromEffect(unit);
-
-/** @internal */
-const fibersIn = ref => sync$2(() => new FibersIn(ref));
-
-/** @internal */
-
-/** @internal */
-const OP_EMPTY = "Empty";
-
-/** @internal */
-
-/** @internal */
-const OP_ADD_SUPERVISOR = "AddSupervisor";
-
-/** @internal */
-
-/** @internal */
-const OP_REMOVE_SUPERVISOR = "RemoveSupervisor";
-
-/** @internal */
-
-/** @internal */
-const OP_AND_THEN = "AndThen";
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/** @internal */
-
-/**
- * The empty `SupervisorPatch`.
- *
- * @internal
- */
-const empty = {
-  _tag: OP_EMPTY
-};
-
-/**
- * Combines two patches to produce a new patch that describes applying the
- * updates from this patch and then the updates from the specified patch.
- *
- * @internal
- */
-const combine = (self, that) => {
-  return {
-    _tag: OP_AND_THEN,
-    first: self,
-    second: that
-  };
-};
-
-/**
- * Applies a `SupervisorPatch` to a `Supervisor` to produce a new `Supervisor`.
- *
- * @internal
- */
-const patch = (self, supervisor) => {
-  return patchLoop(supervisor, of$1(self));
-};
-
-/** @internal */
-const patchLoop = (_supervisor, _patches) => {
-  let supervisor = _supervisor;
-  let patches = _patches;
-  while (isNonEmpty(patches)) {
-    const head = headNonEmpty(patches);
-    switch (head._tag) {
-      case OP_EMPTY:
-        {
-          patches = tailNonEmpty(patches);
-          break;
-        }
-      case OP_ADD_SUPERVISOR:
-        {
-          supervisor = supervisor.zip(head.supervisor);
-          patches = tailNonEmpty(patches);
-          break;
-        }
-      case OP_REMOVE_SUPERVISOR:
-        {
-          supervisor = removeSupervisor(supervisor, head.supervisor);
-          patches = tailNonEmpty(patches);
-          break;
-        }
-      case OP_AND_THEN:
-        {
-          patches = prepend(head.first)(prepend(head.second)(tailNonEmpty(patches)));
-          break;
-        }
-    }
-  }
-  return supervisor;
-};
-
-/** @internal */
-const removeSupervisor = (self, that) => {
-  if (equals(self, that)) {
-    return none;
-  } else {
-    if (self instanceof Zip) {
-      return removeSupervisor(self.left, that).zip(removeSupervisor(self.right, that));
-    } else {
-      return self;
-    }
-  }
-};
-
-/** @internal */
-const toSet = self => {
-  if (equals(self, none)) {
-    return empty$2();
-  } else {
-    if (self instanceof Zip) {
-      return pipe(toSet(self.left), union(toSet(self.right)));
-    } else {
-      return make$2(self);
-    }
-  }
-};
-
-/** @internal */
-const diff = (oldValue, newValue) => {
-  if (equals(oldValue, newValue)) {
-    return empty;
-  }
-  const oldSupervisors = toSet(oldValue);
-  const newSupervisors = toSet(newValue);
-  const added = pipe(newSupervisors, difference(oldSupervisors), reduce(empty, (patch, supervisor) => combine(patch, {
-    _tag: OP_ADD_SUPERVISOR,
-    supervisor
-  })));
-  const removed = pipe(oldSupervisors, difference(newSupervisors), reduce(empty, (patch, supervisor) => combine(patch, {
-    _tag: OP_REMOVE_SUPERVISOR,
-    supervisor
-  })));
-  return combine(added, removed);
-};
-
-/** @internal */
-const differ = /*#__PURE__*/make$4({
-  empty,
-  patch,
-  combine,
-  diff
-});
+import { not } from '../Boolean/dist/effect-Boolean.esm.js';
+import { fromIterable as fromIterable$1, isNonEmpty, headNonEmpty, tailNonEmpty, unsafeFromArray, prepend } from '../Chunk/dist/effect-Chunk.esm.js';
+import { get as get$1, getOption, add, Tag, merge, make as make$2, unsafeGet } from '../Context/dist/effect-Context.esm.js';
+import { await as _await$1 } from '../Deferred/dist/effect-Deferred.esm.js';
+import { parallel, sequential, parallelN } from '../ExecutionStrategy/dist/effect-ExecutionStrategy.esm.js';
+import { threadName, combine, none as none$2, unsafeMake as unsafeMake$1 } from '../FiberId/dist/effect-FiberId.esm.js';
+import { getOrDefault } from '../FiberRefs/dist/effect-FiberRefs.esm.js';
+import { diff as diff$1, patch as patch$1 } from '../FiberRefsPatch/dist/effect-FiberRefsPatch.esm.js';
+import { isDone, done, suspended, running } from '../FiberStatus/dist/effect-FiberStatus.esm.js';
+import { dual, identity, pipe } from '../Function/dist/effect-Function.esm.js';
+import { make, fromIterable as fromIterable$2, union, size } from '../HashSet/dist/effect-HashSet.esm.js';
+import { par, flatten as flatten$2, sequentialCollectionToChunk } from './blockedRequests.esm.js';
+import { empty, pretty, failureOrCause, parallel as parallel$1, sequential as sequential$1, interrupt, isEmpty, isInterruptedOnly, die, NoSuchElementException, stripFailures, isInterruptedException, IllegalArgumentException } from './cause.esm.js';
+import { clockTag } from './clock.esm.js';
+import { currentRequestMap } from './completedRequestMap.esm.js';
+import { matchSimple, match as match$1 } from './concurrency.esm.js';
+import { configProviderTag } from './configProvider.esm.js';
+import { fiberRefUnsafeMake, currentTracerSpan, fiberRefUnsafeMakeHashSet, uninterruptible, tap, isEffect, withFiberRuntime, fiberRefLocally, currentForkScopeOverride, map as map$1, exit, exitIsSuccess, onError, failCause, partitionMap, either, flatMap as flatMap$1, unit, succeed, fail, dieSync, uninterruptibleMask, interruptible, forEachSequential, zipRight, asUnit, onInterrupt, zipLeft, interruptFiber, deferredMake, exitMatchEffect, flatten, deferredFailCause, deferredSucceed, contextWithEffect, scopeFork, currentMetricLabels, acquireUseRelease, scopeClose, exitZipWith, flip, fiberIdWith, updateRuntimeFlags, runtimeFlags, ScopeTypeId, releaseMapMake, CloseableScopeTypeId, releaseMapAdd, scopeAddFinalizerExit, as, mapInputContext, onExit, fiberRefUnsafeMakePatch, fiberRefGet, fiberRefSet, fiberRefGetWith, sync, fiberRefUpdate, fiberRefDelete, fiberRefUnsafeMakeContext, fiberRefUnsafeMakeRuntimeFlags, forEachSequentialDiscard, exitSucceed, matchCauseEffect, suspend, currentInterruptedCause, deferredUnsafeMake, deferredAwait, async, currentSchedulingPriority, whileLoop, currentUnhandledErrorLogLevel, currentLogLevel, currentLogSpan, currentLogAnnotations, exitFailCause, exitUnit, currentContext, exitFail, blocked, catchAllCause, runRequestBlock, RevertFlags, yieldNow as yieldNow$1, isEffectError, withRuntimeFlags, matchEffect, if_, zipWith, currentRequestBatching, transplant, step, deferredUnsafeDone, deferredFail, exitCollectAll, exitIsFailure, exitInterrupt, exitAsUnit, interruptAsFiber, flatMapStep } from './core.esm.js';
+import { makeSpan, currentTimeNanosTracing, mapErrorCause } from './core-effect.esm.js';
+import { currentServices } from './defaultServices.esm.js';
+import { consoleTag } from './defaultServices/console.esm.js';
+import { sequential as sequential$2, isSequential, isParallel } from './executionStrategy.esm.js';
+import { _await, FiberTypeId, fiberVariance, join, RuntimeFiberTypeId, currentFiberURI, inheritAll, interruptAsFork } from './fiber.esm.js';
+import { resume, stateful, interruptSignal, OP_STATEFUL, OP_RESUME, OP_INTERRUPT_SIGNAL, OP_YIELD_NOW, yieldNow } from './fiberMessage.esm.js';
+import { get, joinAs, delete_, updatedAs, forkAs, getOrDefault as getOrDefault$1 } from './fiberRefs.esm.js';
+import { globalScope, unsafeMake } from './fiberScope.esm.js';
+import { makeLogger, stringLogger, logfmtLogger } from './logger.esm.js';
+import { counter, tagged, histogram } from './metric.esm.js';
+import { exponential } from './metric/boundaries.esm.js';
+import { make as make$3 } from './metric/label.esm.js';
+import { OP_FAILURE, OP_SUCCESS, OP_YIELD, OP_ASYNC, OP_ON_FAILURE, OP_ON_SUCCESS, OP_WHILE, OP_TAG, OP_SYNC, OP_REVERT_FLAGS, OP_ON_SUCCESS_AND_FAILURE, OP_WITH_RUNTIME, OP_UPDATE_RUNTIME_FLAGS, OP_COMMIT } from './opCodes/effect.esm.js';
+import { complete } from './request.esm.js';
+import { patch, diff, runtimeMetrics, WindDown, Interruption, interruptible as interruptible$1, enable, cooperativeYielding, OpSupervision, none as none$3 } from './runtimeFlags.esm.js';
+import { none as none$1 } from './supervisor.esm.js';
+import { differ, empty as empty$2 } from './supervisor/patch.esm.js';
+import { tracerTag } from './tracer.esm.js';
+import { head, prepend as prepend$1 } from '../List/dist/effect-List.esm.js';
+import { fromLiteral, greaterThan } from '../LogLevel/dist/effect-LogLevel.esm.js';
+import { make as make$4, compareAndSet } from '../MutableRef/dist/effect-MutableRef.esm.js';
+import { flatMap, map, some, none, match, fromNullable, isSome, getOrElse } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { isIterable } from '../Predicate/dist/effect-Predicate.esm.js';
+import { fromIterable, filterMap, reduce, flatten as flatten$1, reduceRight, compact } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
+import { make as make$1, modify, update, get as get$2 } from '../Ref/dist/effect-Ref.esm.js';
+import { empty as empty$1, exclude } from '../RuntimeFlagsPatch/dist/effect-RuntimeFlagsPatch.esm.js';
+import { currentScheduler } from '../Scheduler/dist/effect-Scheduler.esm.js';
 
 /** @internal */
 const fiberStarted = /*#__PURE__*/counter("effect_fiber_started");
@@ -908,7 +54,7 @@ const fiberSuccesses = /*#__PURE__*/counter("effect_fiber_successes");
 /** @internal */
 const fiberFailures = /*#__PURE__*/counter("effect_fiber_failures");
 /** @internal */
-const fiberLifetimes = /*#__PURE__*/tagged$1( /*#__PURE__*/histogram("effect_fiber_lifetimes", /*#__PURE__*/exponential({
+const fiberLifetimes = /*#__PURE__*/tagged( /*#__PURE__*/histogram("effect_fiber_lifetimes", /*#__PURE__*/exponential({
   start: 1.0,
   factor: 1.3,
   count: 100
@@ -1025,7 +171,7 @@ class FiberRuntime {
       fiberStarted.unsafeUpdate(1, tags);
       fiberActive.unsafeUpdate(1, tags);
     }
-    this._tracer = get$2(this.getFiberRef(currentServices), tracerTag);
+    this._tracer = get$1(this.getFiberRef(currentServices), tracerTag);
   }
 
   /**
@@ -1117,7 +263,7 @@ class FiberRuntime {
     return suspend(() => {
       const deferred = deferredUnsafeMake(this._fiberId);
       this.tell(stateful((fiber, status) => {
-        deferredUnsafeDone(deferred, sync$2(() => f(fiber, status)));
+        deferredUnsafeDone(deferred, sync(() => f(fiber, status)));
       }));
       return deferredAwait(deferred);
     });
@@ -1135,7 +281,7 @@ class FiberRuntime {
   }
   await() {
     return async(resume => {
-      const cb = exit => resume(succeed$3(exit));
+      const cb = exit => resume(succeed(exit));
       this.tell(stateful((fiber, _) => {
         if (fiber._exitValue !== null) {
           cb(this._exitValue);
@@ -1143,7 +289,7 @@ class FiberRuntime {
           fiber.addObserver(cb);
         }
       }));
-      return sync$2(() => this.tell(stateful((fiber, _) => {
+      return sync(() => this.tell(stateful((fiber, _) => {
         fiber.removeObserver(cb);
       })));
     }, this.id());
@@ -1157,7 +303,7 @@ class FiberRuntime {
       const updatedFiberRefs = joinAs(parentFiberRefs, parentFiberId, childFiberRefs);
       parentFiber.setFiberRefs(updatedFiberRefs);
       const updatedRuntimeFlags = parentFiber.getFiberRef(currentRuntimeFlags);
-      const patch = pipe(diff$1(parentRuntimeFlags, updatedRuntimeFlags),
+      const patch = pipe(diff(parentRuntimeFlags, updatedRuntimeFlags),
       // Do not inherit WindDown or Interruption!
       exclude(Interruption), exclude(WindDown));
       return updateRuntimeFlags(patch);
@@ -1169,7 +315,7 @@ class FiberRuntime {
    * already done.
    */
   poll() {
-    return sync$2(() => fromNullable(this._exitValue));
+    return sync(() => fromNullable(this._exitValue));
   }
 
   /**
@@ -1184,7 +330,7 @@ class FiberRuntime {
    * In the background, interrupts the fiber as if interrupted from the specified fiber.
    */
   interruptAsFork(fiberId) {
-    return sync$2(() => this.tell(interruptSignal(interrupt(fiberId))));
+    return sync(() => this.tell(interruptSignal(interrupt(fiberId))));
   }
 
   /**
@@ -1258,7 +404,7 @@ class FiberRuntime {
     this.refreshRefCache();
   }
   refreshRefCache() {
-    this._tracer = get$2(this.getFiberRef(currentServices), tracerTag);
+    this._tracer = get$1(this.getFiberRef(currentServices), tracerTag);
     this._supervisor = this.getFiberRef(currentSupervisor);
     this._scheduler = this.getFiberRef(currentScheduler);
   }
@@ -1427,7 +573,7 @@ class FiberRuntime {
         if (!next.done) {
           return asUnit(next.value.await());
         } else {
-          return sync$2(() => {
+          return sync(() => {
             isDone = true;
           });
         }
@@ -1492,8 +638,8 @@ class FiberRuntime {
     const annotations = this.getFiberRef(currentLogAnnotations);
     const loggers = this.getLoggers();
     const contextMap = this.getFiberRefs();
-    if (size$1(loggers) > 0) {
-      const clockService = get$2(this.getFiberRef(currentServices), clockTag);
+    if (size(loggers) > 0) {
+      const clockService = get$1(this.getFiberRef(currentServices), clockTag);
       const date = new Date(clockService.unsafeCurrentTimeMillis());
       for (const logger of loggers) {
         logger.log({
@@ -1652,8 +798,8 @@ class FiberRuntime {
    *
    * **NOTE**: This method must be invoked by the fiber itself.
    */
-  patchRuntimeFlags(oldRuntimeFlags, patch) {
-    const newRuntimeFlags = patch$1(oldRuntimeFlags, patch);
+  patchRuntimeFlags(oldRuntimeFlags, patch$1) {
+    const newRuntimeFlags = patch(oldRuntimeFlags, patch$1);
     globalThis[currentFiberURI] = this;
     this._runtimeFlags = newRuntimeFlags;
     return newRuntimeFlags;
@@ -1721,7 +867,7 @@ class FiberRuntime {
     }
   }
   [OP_TAG](op) {
-    return map$2(fiberRefGet(currentContext), context => {
+    return map$1(fiberRefGet(currentContext), context => {
       try {
         return unsafeGet(context, op);
       } catch (e) {
@@ -1867,7 +1013,7 @@ class FiberRuntime {
   [OP_UPDATE_RUNTIME_FLAGS](op) {
     const updateFlags = op.i0;
     const oldRuntimeFlags = this._runtimeFlags;
-    const newRuntimeFlags = patch$1(oldRuntimeFlags, updateFlags);
+    const newRuntimeFlags = patch(oldRuntimeFlags, updateFlags);
     // One more chance to short circuit: if we're immediately going
     // to interrupt. Interruption will cause immediate reversion of
     // the flag, so as long as we "peek ahead", there's no need to
@@ -1879,7 +1025,7 @@ class FiberRuntime {
       this.patchRuntimeFlags(this._runtimeFlags, updateFlags);
       if (op.i1) {
         // Since we updated the flags, we need to revert them
-        const revertFlags = diff$1(newRuntimeFlags, oldRuntimeFlags);
+        const revertFlags = diff(newRuntimeFlags, oldRuntimeFlags);
         this.pushStack(new RevertFlags(revertFlags, op));
         return op.i1(oldRuntimeFlags);
       } else {
@@ -1977,7 +1123,7 @@ class FiberRuntime {
           if (isEffectError(e)) {
             cur = exitFailCause(e.cause);
           } else if (isInterruptedException(e)) {
-            cur = exitFailCause(sequential$1(die(e), interrupt(none$3)));
+            cur = exitFailCause(sequential$1(die(e), interrupt(none$2)));
           } else {
             cur = exitFailCause(die(e));
           }
@@ -1998,7 +1144,7 @@ const currentMinimumLogLevel = /*#__PURE__*/fiberRefUnsafeMake( /*#__PURE__*/fro
 /** @internal */
 const getConsole = refs => {
   const defaultServicesValue = getOrDefault(refs, currentServices);
-  const cnsl = get$2(defaultServicesValue, consoleTag);
+  const cnsl = get$1(defaultServicesValue, consoleTag);
   return cnsl.unsafe;
 };
 
@@ -2023,22 +1169,22 @@ const tracerLogger = /*#__PURE__*/makeLogger(({
   logLevel,
   message
 }) => {
-  const span = flatMap(get$1(context, currentTracerSpan), head);
-  const clockService = map$3(get$1(context, currentServices), _ => get$2(_, clockTag));
+  const span = flatMap(get(context, currentTracerSpan), head);
+  const clockService = map(get(context, currentServices), _ => get$1(_, clockTag));
   if (span._tag === "None" || span.value._tag === "ExternalSpan" || clockService._tag === "None") {
     return;
   }
   const attributes = Object.fromEntries(annotations);
-  attributes["effect.fiberId"] = threadName$1(fiberId);
+  attributes["effect.fiberId"] = threadName(fiberId);
   attributes["effect.logLevel"] = logLevel.label;
-  if (cause !== null && cause !== empty$1) {
+  if (cause !== null && cause !== empty) {
     attributes["effect.cause"] = pretty(cause);
   }
   span.value.event(String(message), clockService.value.unsafeCurrentTimeNanos(), attributes);
 });
 
 /** @internal */
-const currentLoggers = /*#__PURE__*/fiberRefUnsafeMakeHashSet( /*#__PURE__*/make$2(defaultLogger, tracerLogger));
+const currentLoggers = /*#__PURE__*/fiberRefUnsafeMakeHashSet( /*#__PURE__*/make(defaultLogger, tracerLogger));
 
 // circular with Effect
 
@@ -2059,12 +1205,12 @@ const addFinalizer = finalizer => withFiberRuntime(runtime => {
   return flatMap$1(scope, scope => scopeAddFinalizerExit(scope, exit => withFiberRuntime(runtimeFinalizer => {
     const preRefs = runtimeFinalizer.getFiberRefs();
     const preFlags = runtimeFinalizer._runtimeFlags;
-    const patchRefs = diff$2(preRefs, acquireRefs);
-    const patchFlags = diff$1(preFlags, acquireFlags);
-    const inverseRefs = diff$2(acquireRefs, preRefs);
-    runtimeFinalizer.setFiberRefs(patch$2(patchRefs, runtimeFinalizer.id(), acquireRefs));
-    return ensuring(withRuntimeFlags(finalizer(exit), patchFlags), sync$2(() => {
-      runtimeFinalizer.setFiberRefs(patch$2(inverseRefs, runtimeFinalizer.id(), runtimeFinalizer.getFiberRefs()));
+    const patchRefs = diff$1(preRefs, acquireRefs);
+    const patchFlags = diff(preFlags, acquireFlags);
+    const inverseRefs = diff$1(acquireRefs, preRefs);
+    runtimeFinalizer.setFiberRefs(patch$1(patchRefs, runtimeFinalizer.id(), acquireRefs));
+    return ensuring(withRuntimeFlags(finalizer(exit), patchFlags), sync(() => {
+      runtimeFinalizer.setFiberRefs(patch$1(inverseRefs, runtimeFinalizer.id(), runtimeFinalizer.getFiberRefs()));
     }));
   })));
 });
@@ -2080,31 +1226,31 @@ const _existsParFound = /*#__PURE__*/Symbol("effect/Effect/existsPar/found");
 
 /* @internal */
 const exists = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => matchSimple(options, () => suspend(() => existsLoop(elements[Symbol.iterator](), 0, f)), () => matchEffect(forEachOptions(elements, (a, i) => if_(f(a, i), {
-  onTrue: fail$1(_existsParFound),
+  onTrue: fail(_existsParFound),
   onFalse: unit
 }), options), {
-  onFailure: e => e === _existsParFound ? succeed$3(true) : fail$1(e),
-  onSuccess: () => succeed$3(false)
+  onFailure: e => e === _existsParFound ? succeed(true) : fail(e),
+  onSuccess: () => succeed(false)
 })));
 const existsLoop = (iterator, index, f) => {
   const next = iterator.next();
   if (next.done) {
-    return succeed$3(false);
+    return succeed(false);
   }
-  return pipe(flatMap$1(f(next.value, index), b => b ? succeed$3(b) : existsLoop(iterator, index + 1, f)));
+  return pipe(flatMap$1(f(next.value, index), b => b ? succeed(b) : existsLoop(iterator, index + 1, f)));
 };
 
 /* @internal */
 const filter = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => {
-  const predicate = options?.negate ? (a, i) => map$2(f(a, i), not) : f;
-  return matchSimple(options, () => suspend(() => fromIterable$1(elements).reduceRight((effect, a, i) => zipWith(effect, suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), sync$2(() => new Array()))), () => map$2(forEachOptions(elements, (a, i) => map$2(predicate(a, i), b => b ? some(a) : none$2()), options), compact));
+  const predicate = options?.negate ? (a, i) => map$1(f(a, i), not) : f;
+  return matchSimple(options, () => suspend(() => fromIterable(elements).reduceRight((effect, a, i) => zipWith(effect, suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), sync(() => new Array()))), () => map$1(forEachOptions(elements, (a, i) => map$1(predicate(a, i), b => b ? some(a) : none()), options), compact));
 });
 
 // === all
 
 const allResolveInput = input => {
   if (Array.isArray(input) || isIterable(input)) {
-    return [input, none$2()];
+    return [input, none()];
   }
   const keys = Object.keys(input);
   const size = keys.length;
@@ -2125,7 +1271,7 @@ const allValidate = (effects, reconcile, options) => {
     concurrency: options?.concurrency,
     batching: options?.batching
   }), eithers => {
-    const none = none$2();
+    const none$1 = none();
     const size = eithers.length;
     const errors = new Array(size);
     const successes = new Array(size);
@@ -2137,15 +1283,15 @@ const allValidate = (effects, reconcile, options) => {
         errored = true;
       } else {
         successes[i] = either.right;
-        errors[i] = none;
+        errors[i] = none$1;
       }
     }
     if (errored) {
-      return reconcile._tag === "Some" ? fail$1(reconcile.value(errors)) : fail$1(errors);
+      return reconcile._tag === "Some" ? fail(reconcile.value(errors)) : fail(errors);
     } else if (options?.discard) {
       return unit;
     }
-    return reconcile._tag === "Some" ? succeed$3(reconcile.value(successes)) : succeed$3(successes);
+    return reconcile._tag === "Some" ? succeed(reconcile.value(successes)) : succeed(successes);
   });
 };
 const allEither = (effects, reconcile, options) => {
@@ -2160,7 +1306,7 @@ const allEither = (effects, reconcile, options) => {
       discard: true
     });
   }
-  return map$2(forEachOptions(eitherEffects, identity, {
+  return map$1(forEachOptions(eitherEffects, identity, {
     concurrency: options?.concurrency,
     batching: options?.batching
   }), eithers => reconcile._tag === "Some" ? reconcile.value(eithers) : eithers);
@@ -2174,14 +1320,14 @@ const all = (arg, options) => {
   } else if (options?.mode === "either") {
     return allEither(effects, reconcile, options);
   }
-  return reconcile._tag === "Some" ? map$2(forEachOptions(effects, identity, options), reconcile.value) : forEachOptions(effects, identity, options);
+  return reconcile._tag === "Some" ? map$1(forEachOptions(effects, identity, options), reconcile.value) : forEachOptions(effects, identity, options);
 };
 
 /* @internal */
 const allWith = options => arg => all(arg, options);
 
 /* @internal */
-const allSuccesses = (elements, options) => map$2(all(fromIterable$1(elements).map(exit), options), filterMap(exit => exitIsSuccess(exit) ? some(exit.i0) : none$2()));
+const allSuccesses = (elements, options) => map$1(all(fromIterable(elements).map(exit), options), filterMap(exit => exitIsSuccess(exit) ? some(exit.i0) : none()));
 
 /* @internal */
 const replicate = /*#__PURE__*/dual(2, (self, n) => Array.from({
@@ -2195,20 +1341,20 @@ const replicateEffect = /*#__PURE__*/dual(args => isEffect(args[0]), (self, n, o
 const forEachOptions = /*#__PURE__*/dual(args => isIterable(args[0]), (self, f, options) => withFiberRuntime(r => {
   const requestBatchingEnabled = options?.batching === true || options?.batching === "inherit" && r.getFiberRef(currentRequestBatching);
   if (options?.discard) {
-    return match(options, () => finalizersMask(sequential)(restore => requestBatchingEnabled ? forEachBatchedDiscard(self, (a, i) => restore(f(a, i))) : forEachSequentialDiscard(self, (a, i) => restore(f(a, i)))), () => finalizersMask(parallel)(restore => forEachParUnboundedDiscard(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(parallelN(n))(restore => forEachParNDiscard(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
+    return match$1(options, () => finalizersMask(sequential)(restore => requestBatchingEnabled ? forEachBatchedDiscard(self, (a, i) => restore(f(a, i))) : forEachSequentialDiscard(self, (a, i) => restore(f(a, i)))), () => finalizersMask(parallel)(restore => forEachParUnboundedDiscard(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(parallelN(n))(restore => forEachParNDiscard(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
   }
-  return match(options, () => finalizersMask(sequential)(restore => requestBatchingEnabled ? forEachParN(self, 1, (a, i) => restore(f(a, i)), true) : forEachSequential(self, (a, i) => restore(f(a, i)))), () => finalizersMask(parallel)(restore => forEachParUnbounded(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(parallelN(n))(restore => forEachParN(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
+  return match$1(options, () => finalizersMask(sequential)(restore => requestBatchingEnabled ? forEachParN(self, 1, (a, i) => restore(f(a, i)), true) : forEachSequential(self, (a, i) => restore(f(a, i)))), () => finalizersMask(parallel)(restore => forEachParUnbounded(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(parallelN(n))(restore => forEachParN(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
 }));
 
 /* @internal */
 const forEachParUnbounded = (self, f, batching) => suspend(() => {
-  const as = fromIterable$1(self);
+  const as = fromIterable(self);
   const array = new Array(as.length);
-  const fn = (a, i) => flatMap$1(f(a, i), b => sync$2(() => array[i] = b));
-  return zipRight$1(forEachParUnboundedDiscard(as, fn, batching), succeed$3(array));
+  const fn = (a, i) => flatMap$1(f(a, i), b => sync(() => array[i] = b));
+  return zipRight(forEachParUnboundedDiscard(as, fn, batching), succeed(array));
 });
 const forEachBatchedDiscard = (self, f) => suspend(() => {
-  const as = fromIterable$1(self);
+  const as = fromIterable(self);
   const size = as.length;
   if (size === 0) {
     return unit;
@@ -2244,7 +1390,7 @@ const forEachBatchedDiscard = (self, f) => suspend(() => {
 
 /* @internal */
 const forEachParUnboundedDiscard = (self, f, batching) => suspend(() => {
-  const as = fromIterable$1(self);
+  const as = fromIterable(self);
   const size = as.length;
   if (size === 0) {
     return unit;
@@ -2252,7 +1398,7 @@ const forEachParUnboundedDiscard = (self, f, batching) => suspend(() => {
     return asUnit(f(as[0], 0));
   }
   return uninterruptibleMask(restore => {
-    const deferred = deferredUnsafeMake(none$3);
+    const deferred = deferredUnsafeMake(none$2);
     let ref = 0;
     const residual = [];
     const joinOrder = [];
@@ -2264,11 +1410,11 @@ const forEachParUnboundedDiscard = (self, f, batching) => suspend(() => {
               const requests = residual.map(blocked => blocked.i0).reduce(par);
               const _continue = forEachParUnboundedDiscard(residual, blocked => blocked.i1, batching);
               return blocked(requests, matchCauseEffect(_continue, {
-                onFailure: cause => zipRight$1(deferredFail(deferred, void 0), failCause(parallel$1(cause, exit.cause))),
-                onSuccess: () => zipRight$1(deferredFail(deferred, void 0), failCause(exit.cause))
+                onFailure: cause => zipRight(deferredFail(deferred, void 0), failCause(parallel$1(cause, exit.cause))),
+                onSuccess: () => zipRight(deferredFail(deferred, void 0), failCause(exit.cause))
               }));
             }
-            return zipRight$1(deferredFail(deferred, void 0), failCause(exit.cause));
+            return zipRight(deferredFail(deferred, void 0), failCause(exit.cause));
           }
         default:
           {
@@ -2289,7 +1435,7 @@ const forEachParUnboundedDiscard = (self, f, batching) => suspend(() => {
             return unit;
           }
       }
-    }))), forkDaemon, map$2(fiber => {
+    }))), forkDaemon, map$1(fiber => {
       fiber.addObserver(() => {
         joinOrder.push(fiber);
       });
@@ -2313,10 +1459,10 @@ const forEachParUnboundedDiscard = (self, f, batching) => suspend(() => {
 
 /* @internal */
 const forEachParN = (self, n, f, batching) => suspend(() => {
-  const as = fromIterable$1(self);
+  const as = fromIterable(self);
   const array = new Array(as.length);
-  const fn = (a, i) => map$2(f(a, i), b => array[i] = b);
-  return zipRight$1(forEachParNDiscard(as, n, fn, batching), succeed$3(array));
+  const fn = (a, i) => map$1(f(a, i), b => array[i] = b);
+  return zipRight(forEachParNDiscard(as, n, fn, batching), succeed(array));
 });
 
 /* @internal */
@@ -2324,7 +1470,7 @@ const forEachParNDiscard = (self, n, f, batching) => suspend(() => {
   let i = 0;
   const iterator = self[Symbol.iterator]();
   const residual = [];
-  const worker = flatMap$1(sync$2(() => iterator.next()), next => next.done ? unit : flatMap$1((batching ? step : exit)(asUnit(f(next.value, i++))), res => {
+  const worker = flatMap$1(sync(() => iterator.next()), next => next.done ? unit : flatMap$1((batching ? step : exit)(asUnit(f(next.value, i++))), res => {
     switch (res._op) {
       case "Blocked":
         {
@@ -2360,7 +1506,7 @@ const forEachParNDiscard = (self, n, f, batching) => suspend(() => {
 });
 
 /* @internal */
-const fork = self => withFiberRuntime((state, status) => succeed$3(unsafeFork(self, state, status.runtimeFlags)));
+const fork = self => withFiberRuntime((state, status) => succeed(unsafeFork(self, state, status.runtimeFlags)));
 
 /* @internal */
 const forkDaemon = self => forkWithScopeOverride(self, globalScope);
@@ -2403,40 +1549,40 @@ const unsafeMakeChildFiber = (effect, parentFiber, parentRuntimeFlags, overrideS
 };
 
 /* @internal */
-const forkWithScopeOverride = (self, scopeOverride) => withFiberRuntime((parentFiber, parentStatus) => succeed$3(unsafeFork(self, parentFiber, parentStatus.runtimeFlags, scopeOverride)));
+const forkWithScopeOverride = (self, scopeOverride) => withFiberRuntime((parentFiber, parentStatus) => succeed(unsafeFork(self, parentFiber, parentStatus.runtimeFlags, scopeOverride)));
 
 /* @internal */
-const mergeAll = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => fromIterable$1(elements).reduce((acc, a, i) => zipWith(acc, a, (acc, a) => f(acc, a, i)), succeed$3(zero)), () => flatMap$1(make$5(zero), acc => flatMap$1(forEachOptions(elements, (effect, i) => flatMap$1(effect, a => update$1(acc, b => f(b, a, i))), options), () => get$3(acc)))));
+const mergeAll = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => fromIterable(elements).reduce((acc, a, i) => zipWith(acc, a, (acc, a) => f(acc, a, i)), succeed(zero)), () => flatMap$1(make$1(zero), acc => flatMap$1(forEachOptions(elements, (effect, i) => flatMap$1(effect, a => update(acc, b => f(b, a, i))), options), () => get$2(acc)))));
 
 /* @internal */
-const partition = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => pipe(forEachOptions(elements, (a, i) => either(f(a, i)), options), map$2(chunk => partitionMap(chunk, identity))));
+const partition = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => pipe(forEachOptions(elements, (a, i) => either(f(a, i)), options), map$1(chunk => partitionMap(chunk, identity))));
 
 /* @internal */
 const validateAll = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => flatMap$1(partition(elements, f, {
   concurrency: options?.concurrency,
   batching: options?.batching
-}), ([es, bs]) => es.length === 0 ? options?.discard ? unit : succeed$3(bs) : fail$1(es)));
+}), ([es, bs]) => es.length === 0 ? options?.discard ? unit : succeed(bs) : fail(es)));
 
 /* @internal */
 const raceAll = all => {
-  const list = fromIterable$2(all);
+  const list = fromIterable$1(all);
   if (!isNonEmpty(list)) {
     return dieSync(() => IllegalArgumentException(`Received an empty collection of effects`));
   }
   const self = headNonEmpty(list);
   const effects = tailNonEmpty(list);
   const inheritAll$1 = res => pipe(inheritAll(res[1]), as(res[0]));
-  return pipe(deferredMake(), flatMap$1(done => pipe(make$5(effects.length), flatMap$1(fails => uninterruptibleMask(restore => pipe(fork(interruptible(self)), flatMap$1(head => pipe(effects, forEachSequential(effect => fork(interruptible(effect))), map$2(unsafeFromArray), map$2(tail => pipe(tail, prepend(head))), tap(fibers => pipe(fibers, reduce$1(unit, (effect, fiber) => pipe(effect, zipRight$1(pipe(_await(fiber), flatMap$1(raceAllArbiter(fibers, fiber, done, fails)), fork, asUnit)))))), flatMap$1(fibers => pipe(restore(pipe(_await$1(done), flatMap$1(inheritAll$1))), onInterrupt(() => pipe(fibers, reduce$1(unit, (effect, fiber) => pipe(effect, zipLeft$1(interruptFiber(fiber))))))))))))))));
+  return pipe(deferredMake(), flatMap$1(done => pipe(make$1(effects.length), flatMap$1(fails => uninterruptibleMask(restore => pipe(fork(interruptible(self)), flatMap$1(head => pipe(effects, forEachSequential(effect => fork(interruptible(effect))), map$1(unsafeFromArray), map$1(tail => pipe(tail, prepend(head))), tap(fibers => pipe(fibers, reduce(unit, (effect, fiber) => pipe(effect, zipRight(pipe(_await(fiber), flatMap$1(raceAllArbiter(fibers, fiber, done, fails)), fork, asUnit)))))), flatMap$1(fibers => pipe(restore(pipe(_await$1(done), flatMap$1(inheritAll$1))), onInterrupt(() => pipe(fibers, reduce(unit, (effect, fiber) => pipe(effect, zipLeft(interruptFiber(fiber))))))))))))))));
 };
 
 /* @internal */
 const raceAllArbiter = (fibers, winner, deferred, fails) => exit => exitMatchEffect(exit, {
   onFailure: cause => pipe(modify(fails, fails => [fails === 0 ? pipe(deferredFailCause(deferred, cause), asUnit) : unit, fails - 1]), flatten),
-  onSuccess: value => pipe(deferredSucceed(deferred, [value, winner]), flatMap$1(set => set ? pipe(fromIterable$2(fibers), reduce$1(unit, (effect, fiber) => fiber === winner ? effect : pipe(effect, zipLeft$1(interruptFiber(fiber))))) : unit))
+  onSuccess: value => pipe(deferredSucceed(deferred, [value, winner]), flatMap$1(set => set ? pipe(fromIterable$1(fibers), reduce(unit, (effect, fiber) => fiber === winner ? effect : pipe(effect, zipLeft(interruptFiber(fiber))))) : unit))
 });
 
 /* @internal */
-const reduceEffect = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => fromIterable$1(elements).reduce((acc, a, i) => zipWith(acc, a, (acc, a) => f(acc, a, i)), zero), () => suspend(() => pipe(mergeAll([zero, ...elements], none$2(), (acc, elem, i) => {
+const reduceEffect = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => fromIterable(elements).reduce((acc, a, i) => zipWith(acc, a, (acc, a) => f(acc, a, i)), zero), () => suspend(() => pipe(mergeAll([zero, ...elements], none(), (acc, elem, i) => {
   switch (acc._tag) {
     case "None":
       {
@@ -2447,7 +1593,7 @@ const reduceEffect = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, z
         return some(f(acc.value, elem, i));
       }
   }
-}, options), map$2(option => {
+}, options), map$1(option => {
   switch (option._tag) {
     case "None":
       {
@@ -2461,7 +1607,7 @@ const reduceEffect = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, z
 })))));
 
 /* @internal */
-const parallelFinalizers = self => contextWithEffect(context => match$1(getOption(context, scopeTag), {
+const parallelFinalizers = self => contextWithEffect(context => match(getOption(context, scopeTag), {
   onNone: () => self,
   onSome: scope => {
     switch (scope.strategy._tag) {
@@ -2475,7 +1621,7 @@ const parallelFinalizers = self => contextWithEffect(context => match$1(getOptio
 }));
 
 /* @internal */
-const parallelNFinalizers = parallelism => self => contextWithEffect(context => match$1(getOption(context, scopeTag), {
+const parallelNFinalizers = parallelism => self => contextWithEffect(context => match(getOption(context, scopeTag), {
   onNone: () => self,
   onSome: scope => {
     if (scope.strategy._tag === "ParallelN" && scope.strategy.parallelism === parallelism) {
@@ -2486,7 +1632,7 @@ const parallelNFinalizers = parallelism => self => contextWithEffect(context =>
 }));
 
 /* @internal */
-const finalizersMask = strategy => self => contextWithEffect(context => match$1(getOption(context, scopeTag), {
+const finalizersMask = strategy => self => contextWithEffect(context => match(getOption(context, scopeTag), {
   onNone: () => self(identity),
   onSome: scope => {
     const patch = strategy._tag === "Parallel" ? parallelFinalizers : strategy._tag === "Sequential" ? sequentialFinalizers : parallelNFinalizers(strategy.parallelism);
@@ -2508,7 +1654,7 @@ const scopeWith = f => flatMap$1(scopeTag, f);
 const scopedEffect = effect => flatMap$1(scopeMake(), scope => scopeUse(scope)(effect));
 
 /* @internal */
-const sequentialFinalizers = self => contextWithEffect(context => match$1(getOption(context, scopeTag), {
+const sequentialFinalizers = self => contextWithEffect(context => match(getOption(context, scopeTag), {
   onNone: () => self,
   onSome: scope => {
     switch (scope.strategy._tag) {
@@ -2525,7 +1671,7 @@ const sequentialFinalizers = self => contextWithEffect(context => match$1(getOpt
 const tagMetricsScoped = (key, value) => labelMetricsScoped([make$3(key, value)]);
 
 /* @internal */
-const labelMetricsScoped = labels => labelMetricsScopedSet(fromIterable(labels));
+const labelMetricsScoped = labels => labelMetricsScopedSet(fromIterable$2(labels));
 
 /* @internal */
 const labelMetricsScopedSet = labels => fiberRefLocallyScopedWith(currentMetricLabels, set => pipe(set, union(labels)));
@@ -2546,13 +1692,13 @@ const validateWith = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, f
 const validateFirst = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => flip(forEachOptions(elements, (a, i) => flip(f(a, i)), options)));
 
 /* @internal */
-const withClockScoped = value => fiberRefLocallyScopedWith(currentServices, add$1(clockTag, value));
+const withClockScoped = value => fiberRefLocallyScopedWith(currentServices, add(clockTag, value));
 
 /* @internal */
-const withConfigProviderScoped = value => fiberRefLocallyScopedWith(currentServices, add$1(configProviderTag, value));
+const withConfigProviderScoped = value => fiberRefLocallyScopedWith(currentServices, add(configProviderTag, value));
 
 /* @internal */
-const withEarlyRelease = self => scopeWith(parent => flatMap$1(scopeFork(parent, sequential$2), child => pipe(self, scopeExtend(child), map$2(value => [fiberIdWith(fiberId => scopeClose(child, exitInterrupt(fiberId))), value]))));
+const withEarlyRelease = self => scopeWith(parent => flatMap$1(scopeFork(parent, sequential$2), child => pipe(self, scopeExtend(child), map$1(value => [fiberIdWith(fiberId => scopeClose(child, exitInterrupt(fiberId))), value]))));
 
 /** @internal */
 const zipOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (a, b) => [a, b], options));
@@ -2564,20 +1710,20 @@ const zipLeftOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that,
 const zipRightOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (_, b) => b, options));
 
 /** @internal */
-const zipWithOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, f, options) => map$2(all([self, that], {
+const zipWithOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, f, options) => map$1(all([self, that], {
   concurrency: options?.concurrent ? 2 : 1,
   batching: options?.batching
 }), ([a, a2]) => f(a, a2)));
 
 /* @internal */
 const withRuntimeFlagsScoped = update => {
-  if (update === empty$3) {
+  if (update === empty$1) {
     return unit;
   }
   return pipe(runtimeFlags, flatMap$1(runtimeFlags => {
-    const updatedRuntimeFlags = patch$1(runtimeFlags, update);
-    const revertRuntimeFlags = diff$1(updatedRuntimeFlags, runtimeFlags);
-    return pipe(updateRuntimeFlags(update), zipRight$1(addFinalizer(() => updateRuntimeFlags(revertRuntimeFlags))), asUnit);
+    const updatedRuntimeFlags = patch(runtimeFlags, update);
+    const revertRuntimeFlags = diff(updatedRuntimeFlags, runtimeFlags);
+    return pipe(updateRuntimeFlags(update), zipRight(addFinalizer(() => updateRuntimeFlags(revertRuntimeFlags))), asUnit);
   }), uninterruptible);
 };
 
@@ -2601,11 +1747,11 @@ const releaseMapReleaseAll = (strategy, exit$1) => self => suspend(() => {
           exit: exit$1,
           update
         };
-        return isSequential(strategy) ? pipe(finalizers, forEachSequential(fin => exit(update(fin)(exit$1))), flatMap$1(results => pipe(exitCollectAll(results), map$3(exitAsUnit), getOrElse(() => exitUnit)))) : isParallel(strategy) ? pipe(forEachParUnbounded(finalizers, fin => exit(update(fin)(exit$1)), false), flatMap$1(results => pipe(exitCollectAll(results, {
+        return isSequential(strategy) ? pipe(finalizers, forEachSequential(fin => exit(update(fin)(exit$1))), flatMap$1(results => pipe(exitCollectAll(results), map(exitAsUnit), getOrElse(() => exitUnit)))) : isParallel(strategy) ? pipe(forEachParUnbounded(finalizers, fin => exit(update(fin)(exit$1)), false), flatMap$1(results => pipe(exitCollectAll(results, {
           parallel: true
-        }), map$3(exitAsUnit), getOrElse(() => exitUnit)))) : pipe(forEachParN(finalizers, strategy.parallelism, fin => exit(update(fin)(exit$1)), false), flatMap$1(results => pipe(exitCollectAll(results, {
+        }), map(exitAsUnit), getOrElse(() => exitUnit)))) : pipe(forEachParN(finalizers, strategy.parallelism, fin => exit(update(fin)(exit$1)), false), flatMap$1(results => pipe(exitCollectAll(results, {
           parallel: true
-        }), map$3(exitAsUnit), getOrElse(() => exitUnit))));
+        }), map(exitAsUnit), getOrElse(() => exitUnit))));
       }
   }
 });
@@ -2619,7 +1765,7 @@ const scopeTag = /*#__PURE__*/Tag(ScopeTypeId);
 const scope = scopeTag;
 
 /* @internal */
-const scopeMake = (strategy = sequential$2) => map$2(releaseMapMake, rm => ({
+const scopeMake = (strategy = sequential$2) => map$1(releaseMapMake, rm => ({
   [ScopeTypeId]: ScopeTypeId,
   [CloseableScopeTypeId]: CloseableScopeTypeId,
   strategy,
@@ -2634,7 +1780,7 @@ const scopeMake = (strategy = sequential$2) => map$2(releaseMapMake, rm => ({
 /* @internal */
 const scopeExtend = /*#__PURE__*/dual(2, (effect, scope) => mapInputContext(effect,
 // @ts-expect-error
-merge(make$6(scopeTag, scope))));
+merge(make$2(scopeTag, scope))));
 
 /* @internal */
 const scopeUse = /*#__PURE__*/dual(2, (effect, scope) => pipe(effect, scopeExtend(scope), onExit(exit => scope.close(exit))));
@@ -2644,7 +1790,7 @@ const scopeUse = /*#__PURE__*/dual(2, (effect, scope) => pipe(effect, scopeExten
 /** @internal */
 const fiberRefUnsafeMakeSupervisor = initial => fiberRefUnsafeMakePatch(initial, {
   differ: differ,
-  fork: empty
+  fork: empty$2
 });
 
 // circular with FiberRef
@@ -2659,7 +1805,7 @@ const fiberRefLocallyScopedWith = /*#__PURE__*/dual(2, (self, f) => fiberRefGetW
 const fiberRefMake = (initial, options) => fiberRefMakeWith(() => fiberRefUnsafeMake(initial, options));
 
 /* @internal */
-const fiberRefMakeWith = ref => acquireRelease(tap(sync$2(ref), ref => fiberRefUpdate(ref, identity)), fiberRef => fiberRefDelete(fiberRef));
+const fiberRefMakeWith = ref => acquireRelease(tap(sync(ref), ref => fiberRefUpdate(ref, identity)), fiberRef => fiberRefDelete(fiberRef));
 
 /* @internal */
 const fiberRefMakeContext = initial => fiberRefMakeWith(() => fiberRefUnsafeMakeContext(initial));
@@ -2668,10 +1814,10 @@ const fiberRefMakeContext = initial => fiberRefMakeWith(() => fiberRefUnsafeMake
 const fiberRefMakeRuntimeFlags = initial => fiberRefMakeWith(() => fiberRefUnsafeMakeRuntimeFlags(initial));
 
 /** @internal */
-const currentRuntimeFlags = /*#__PURE__*/fiberRefUnsafeMakeRuntimeFlags(none$4);
+const currentRuntimeFlags = /*#__PURE__*/fiberRefUnsafeMakeRuntimeFlags(none$3);
 
 /** @internal */
-const currentSupervisor = /*#__PURE__*/fiberRefUnsafeMakeSupervisor(none);
+const currentSupervisor = /*#__PURE__*/fiberRefUnsafeMakeSupervisor(none$1);
 
 // circular with Fiber
 
@@ -2681,22 +1827,22 @@ const fiberAwaitAll = fibers => asUnit(_await(fiberAll(fibers)));
 /** @internal */
 const fiberAll = fibers => ({
   [FiberTypeId]: fiberVariance,
-  id: () => fromIterable$1(fibers).reduce((id, fiber) => combine$1(id, fiber.id()), none$3),
+  id: () => fromIterable(fibers).reduce((id, fiber) => combine(id, fiber.id()), none$2),
   await: () => exit(forEachParUnbounded(fibers, fiber => flatten(fiber.await()), false)),
-  children: () => map$2(forEachParUnbounded(fibers, fiber => fiber.children(), false), flatten$1),
+  children: () => map$1(forEachParUnbounded(fibers, fiber => fiber.children(), false), flatten$1),
   inheritAll: () => forEachSequentialDiscard(fibers, fiber => fiber.inheritAll()),
-  poll: () => map$2(forEachSequential(fibers, fiber => fiber.poll()), reduceRight(some(exitSucceed(new Array())), (optionB, optionA) => {
+  poll: () => map$1(forEachSequential(fibers, fiber => fiber.poll()), reduceRight(some(exitSucceed(new Array())), (optionB, optionA) => {
     switch (optionA._tag) {
       case "None":
         {
-          return none$2();
+          return none();
         }
       case "Some":
         {
           switch (optionB._tag) {
             case "None":
               {
-                return none$2();
+                return none();
               }
             case "Some":
               {
@@ -2722,7 +1868,7 @@ const fiberInterruptFork = self => asUnit(forkDaemon(interruptFiber(self)));
 const fiberJoinAll = fibers => asUnit(join(fiberAll(fibers)));
 
 /* @internal */
-const fiberScoped = self => acquireRelease(succeed$3(self), interruptFiber);
+const fiberScoped = self => acquireRelease(succeed(self), interruptFiber);
 
 //
 // circular race
@@ -2774,7 +1920,7 @@ const race = /*#__PURE__*/dual(2, (self, that) => fiberIdWith(parentFiberId => r
 /** @internal */
 const raceFibersWith = /*#__PURE__*/dual(3, (self, other, options) => withFiberRuntime((parentFiber, parentStatus) => {
   const parentRuntimeFlags = parentStatus.runtimeFlags;
-  const raceIndicator = make$7(true);
+  const raceIndicator = make$4(true);
   const leftFiber = unsafeMakeChildFiber(self, parentFiber, parentRuntimeFlags, options.selfScope);
   const rightFiber = unsafeMakeChildFiber(other, parentFiber, parentRuntimeFlags, options.otherScope);
   return async(cb => {
@@ -2782,7 +1928,7 @@ const raceFibersWith = /*#__PURE__*/dual(3, (self, other, options) => withFiberR
     rightFiber.addObserver(() => completeRace(rightFiber, leftFiber, options.onOtherWin, raceIndicator, cb));
     leftFiber.startFork(self);
     rightFiber.startFork(other);
-  }, combine$1(leftFiber.id(), rightFiber.id()));
+  }, combine(leftFiber.id(), rightFiber.id()));
 }));
 const completeRace = (winner, loser, cont, ab, cb) => {
   if (compareAndSet(true, false)(ab)) {
@@ -2821,7 +1967,7 @@ const invokeWithInterrupt = (dataSource, all) => fiberIdWith(id => flatMap$1(fla
     return () => r.listeners.removeObserver(observer);
   });
   checkDone();
-  return sync$2(() => {
+  return sync(() => {
     cleanup.forEach(f => f());
   });
 })), () => suspend(() => {
@@ -2836,22 +1982,22 @@ const invokeWithInterrupt = (dataSource, all) => fiberIdWith(id => flatMap$1(fla
 
 /** @internal */
 const interruptWhenPossible = /*#__PURE__*/dual(2, (self, all) => fiberRefGetWith(currentRequestMap, map => suspend(() => {
-  const entries = fromIterable$1(all).flatMap(_ => map.has(_) ? [map.get(_)] : []);
+  const entries = fromIterable(all).flatMap(_ => map.has(_) ? [map.get(_)] : []);
   return invokeWithInterrupt(self, entries);
 })));
 
 // circular Tracer
 
 /** @internal */
-const useSpanScoped = (name, options) => acquireRelease(makeSpan(name, options), (span, exit) => flatMap$1(currentTimeNanosTracing, endTime => sync$2(() => span.end(endTime, exit))));
+const useSpanScoped = (name, options) => acquireRelease(makeSpan(name, options), (span, exit) => flatMap$1(currentTimeNanosTracing, endTime => sync(() => span.end(endTime, exit))));
 
 /* @internal */
 const withSpanScoped = (name, options) => flatMap$1(useSpanScoped(name, options), span => fiberRefLocallyScopedWith(currentTracerSpan, prepend$1(span)));
 
 /* @internal */
-const withTracerScoped = value => fiberRefLocallyScopedWith(currentServices, add$1(tracerTag, value));
+const withTracerScoped = value => fiberRefLocallyScopedWith(currentServices, add(tracerTag, value));
 
 /* @internal */
 const withParentSpanScoped = span => fiberRefLocallyScopedWith(currentTracerSpan, prepend$1(span));
 
-export { withParentSpanScoped as $, scopedEffect as A, using as B, withEarlyRelease as C, daemonChildren as D, fork as E, forkDaemon as F, forkWithErrorHandler as G, fiberRefLocallyScoped as H, fiberRefLocallyScopedWith as I, withClockScoped as J, withConfigProviderScoped as K, raceAll as L, race as M, raceWith as N, withRuntimeFlagsScoped as O, tagMetricsScoped as P, labelMetricsScoped as Q, labelMetricsScopedSet as R, validate as S, validateWith as T, zipOptions as U, zipLeftOptions as V, zipRightOptions as W, zipWithOptions as X, withTracerScoped as Y, useSpanScoped as Z, withSpanScoped as _, all as a, timer as a$, fiberRefMake as a0, fiberRefMakeWith as a1, fiberRefMakeContext as a2, fiberRefMakeRuntimeFlags as a3, fiberRefUnsafeMakeSupervisor as a4, currentLoggers as a5, currentMinimumLogLevel as a6, currentRuntimeFlags as a7, currentSupervisor as a8, fiberAwaitAll as a9, logfmtLogger as aA, stringLogger as aB, tracerLogger as aC, logFmtLogger as aD, MetricTypeId as aE, globalMetricRegistry as aF, make as aG, mapInput as aH, counter as aI, frequency as aJ, withConstantInput as aK, fromMetricKey as aL, gauge as aM, histogram as aN, increment as aO, incrementBy as aP, map as aQ, mapType as aR, set as aS, snapshot as aT, succeed$1 as aU, sync as aV, summary as aW, summaryTimestamp as aX, tagged$1 as aY, taggedWithLabelsInput as aZ, taggedWithLabels as a_, fiberAll as aa, track as ab, raceFibersWith as ac, scopeExtend as ad, Zip as ae, Listeners as af, FiberRuntime as ag, none as ah, scopeTag as ai, scopeUse as aj, fiberInterruptFork as ak, fiberJoinAll as al, fiberScoped as am, LoggerTypeId as an, makeLogger as ao, mapInput$1 as ap, filterLogLevel as aq, map$1 as ar, none$1 as as, simple as at, succeed$2 as au, sync$1 as av, zip$1 as aw, zipLeft as ax, zipRight as ay, defaultLogger as az, acquireRelease as b, timerWithBoundaries as b0, trackAll as b1, trackDefect as b2, trackDefectWith as b3, trackDuration as b4, trackDurationWith as b5, trackError as b6, trackErrorWith as b7, trackSuccess as b8, trackSuccessWith as b9, update as ba, value as bb, withNow as bc, zip as bd, unsafeSnapshot as be, fiberStarted as bf, fiberSuccesses as bg, fiberFailures as bh, fiberLifetimes as bi, fiberActive as bj, RequestTypeId as bk, isRequest as bl, of as bm, tagged as bn, complete as bo, interruptWhenPossible as bp, completeEffect as bq, fail as br, succeed as bs, SupervisorTypeId as bt, fibersIn as bu, fromEffect as bv, unsafeTrack as bw, ProxySupervisor as bx, supervisorVariance as by, invokeWithInterrupt as bz, forEachParUnboundedDiscard as c, allWith as d, allSuccesses as e, forEachParUnbounded as f, exists as g, filter as h, forEachOptions as i, replicate as j, replicateEffect as k, validateFirst as l, mergeAll as m, disconnect as n, acquireReleaseInterruptible as o, partition as p, addFinalizer as q, reduceEffect as r, scopeMake as s, ensuring as t, parallelFinalizers as u, validateAll as v, finalizersMask as w, sequentialFinalizers as x, scope as y, scopeWith as z };
+export { FiberRuntime, acquireRelease, acquireReleaseInterruptible, addFinalizer, all, allSuccesses, allWith, currentLoggers, currentMinimumLogLevel, currentRuntimeFlags, currentSupervisor, daemonChildren, defaultLogger, disconnect, ensuring, exists, fiberActive, fiberAll, fiberAwaitAll, fiberFailures, fiberInterruptFork, fiberJoinAll, fiberLifetimes, fiberRefLocallyScoped, fiberRefLocallyScopedWith, fiberRefMake, fiberRefMakeContext, fiberRefMakeRuntimeFlags, fiberRefMakeWith, fiberRefUnsafeMakeSupervisor, fiberScoped, fiberStarted, fiberSuccesses, filter, finalizersMask, forEachOptions, forEachParN, forEachParNDiscard, forEachParUnbounded, forEachParUnboundedDiscard, fork, forkDaemon, forkWithErrorHandler, getConsole, interruptWhenPossible, invokeWithInterrupt, labelMetricsScoped, labelMetricsScopedSet, logFmtLogger, mergeAll, parallelFinalizers, parallelNFinalizers, partition, race, raceAll, raceFibersWith, raceWith, reduceEffect, releaseMapReleaseAll, replicate, replicateEffect, runtimeFiberVariance, scope, scopeExtend, scopeMake, scopeTag, scopeUse, scopeWith, scopedEffect, sequentialFinalizers, tagMetricsScoped, tracerLogger, unsafeFork, unsafeMakeChildFiber, useSpanScoped, using, validate, validateAll, validateFirst, validateWith, withClockScoped, withConfigProviderScoped, withEarlyRelease, withParentSpanScoped, withRuntimeFlagsScoped, withSpanScoped, withTracerScoped, zipLeftOptions, zipOptions, zipRightOptions, zipWithOptions };