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

package/internal/fiberScope.esm.js

@@ -1,58 +0,0 @@
-import { none } from '../FiberId/dist/effect-FiberId.esm.js';
-import { globalValue } from '../GlobalValue/dist/effect-GlobalValue.esm.js';
-import { stateful } from './fiberMessage.esm.js';
-
-/** @internal */
-const FiberScopeSymbolKey = "effect/FiberScope";
-
-/** @internal */
-const FiberScopeTypeId = /*#__PURE__*/Symbol.for(FiberScopeSymbolKey);
-
-/**
- * A `FiberScope` represents the scope of a fiber lifetime. The scope of a
- * fiber can be retrieved using `Effect.descriptor`, and when forking fibers,
- * you can specify a custom scope to fork them on by using the `forkIn`.
- *
- * @since 2.0.0
- * @category models
- */
-
-/** @internal */
-class Global {
-  [FiberScopeTypeId] = FiberScopeTypeId;
-  fiberId = none;
-  roots = new Set();
-  add(_runtimeFlags, child) {
-    this.roots.add(child);
-    child.addObserver(() => {
-      this.roots.delete(child);
-    });
-  }
-}
-
-/** @internal */
-class Local {
-  [FiberScopeTypeId] = FiberScopeTypeId;
-  constructor(fiberId, parent) {
-    this.fiberId = fiberId;
-    this.parent = parent;
-  }
-  add(_runtimeFlags, child) {
-    this.parent.tell(stateful(parentFiber => {
-      parentFiber.addChild(child);
-      child.addObserver(() => {
-        parentFiber.removeChild(child);
-      });
-    }));
-  }
-}
-
-/** @internal */
-const unsafeMake = fiber => {
-  return new Local(fiber.id(), fiber);
-};
-
-/** @internal */
-const globalScope = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberScope/Global"), () => new Global());
-
-export { FiberScopeTypeId, globalScope, unsafeMake };

package/internal/fiberStatus.esm.js

@@ -1,90 +0,0 @@
-import { symbol as symbol$1, equals } from '../Equal/dist/effect-Equal.esm.js';
-import { pipe } from '../Function/dist/effect-Function.esm.js';
-import { symbol, combine, hash } from '../Hash/dist/effect-Hash.esm.js';
-import { hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
-
-const FiberStatusSymbolKey = "effect/FiberStatus";
-
-/** @internal */
-const FiberStatusTypeId = /*#__PURE__*/Symbol.for(FiberStatusSymbolKey);
-
-/** @internal */
-const OP_DONE = "Done";
-
-/** @internal */
-
-/** @internal */
-const OP_RUNNING = "Running";
-
-/** @internal */
-
-/** @internal */
-const OP_SUSPENDED = "Suspended";
-
-/** @internal */
-
-/** @internal */
-class Done {
-  [FiberStatusTypeId] = FiberStatusTypeId;
-  _tag = OP_DONE;
-  [symbol]() {
-    return pipe(hash(FiberStatusSymbolKey), combine(hash(this._tag)));
-  }
-  [symbol$1](that) {
-    return isFiberStatus(that) && that._tag === OP_DONE;
-  }
-}
-
-/** @internal */
-class Running {
-  [FiberStatusTypeId] = FiberStatusTypeId;
-  _tag = OP_RUNNING;
-  constructor(runtimeFlags) {
-    this.runtimeFlags = runtimeFlags;
-  }
-  [symbol]() {
-    return pipe(hash(FiberStatusSymbolKey), combine(hash(this._tag)), combine(hash(this.runtimeFlags)));
-  }
-  [symbol$1](that) {
-    return isFiberStatus(that) && that._tag === OP_RUNNING && this.runtimeFlags === that.runtimeFlags;
-  }
-}
-
-/** @internal */
-class Suspended {
-  [FiberStatusTypeId] = FiberStatusTypeId;
-  _tag = OP_SUSPENDED;
-  constructor(runtimeFlags, blockingOn) {
-    this.runtimeFlags = runtimeFlags;
-    this.blockingOn = blockingOn;
-  }
-  [symbol]() {
-    return pipe(hash(FiberStatusSymbolKey), combine(hash(this._tag)), combine(hash(this.runtimeFlags)), combine(hash(this.blockingOn)));
-  }
-  [symbol$1](that) {
-    return isFiberStatus(that) && that._tag === OP_SUSPENDED && this.runtimeFlags === that.runtimeFlags && equals(this.blockingOn, that.blockingOn);
-  }
-}
-
-/** @internal */
-const done = /*#__PURE__*/new Done();
-
-/** @internal */
-const running = runtimeFlags => new Running(runtimeFlags);
-
-/** @internal */
-const suspended = (runtimeFlags, blockingOn) => new Suspended(runtimeFlags, blockingOn);
-
-/** @internal */
-const isFiberStatus = u => hasProperty(u, FiberStatusTypeId);
-
-/** @internal */
-const isDone = self => self._tag === OP_DONE;
-
-/** @internal */
-const isRunning = self => self._tag === OP_RUNNING;
-
-/** @internal */
-const isSuspended = self => self._tag === OP_SUSPENDED;
-
-export { FiberStatusTypeId, OP_DONE, OP_RUNNING, OP_SUSPENDED, done, isDone, isFiberStatus, isRunning, isSuspended, running, suspended };

package/internal/groupBy.esm.js

@@ -1,212 +0,0 @@
-import { isInterruptedOnly } from '../Cause/dist/effect-Cause.esm.js';
-import { map as map$2, of, unsafeFromArray } from '../Chunk/dist/effect-Chunk.esm.js';
-import { make as make$1, await as _await, succeed as succeed$1 } from '../Deferred/dist/effect-Deferred.esm.js';
-import { succeed, as, gen, acquireRelease, flatMap as flatMap$1, zipRight, map as map$1, forkScoped, sync, forEach, catchSomeCause, unit } from '../Effect/dist/effect-Effect.esm.js';
-import { succeed as succeed$2, map as map$4 } from '../Exit/dist/effect-Exit.esm.js';
-import { dual, pipe } from '../Function/dist/effect-Function.esm.js';
-import { match, fromNullable, map as map$3, some, none } from '../Option/dist/effect-Option.esm.js';
-import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
-import { hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
-import { shutdown, bounded, offer, DequeueTypeId, capacity, size, awaitShutdown, isShutdown, isFull, isEmpty, take, takeAll, takeUpTo, takeBetween, takeN, poll, unbounded } from '../Queue/dist/effect-Queue.esm.js';
-import { make as make$2, update, get } from '../Ref/dist/effect-Ref.esm.js';
-import { drain } from './channel.esm.js';
-import { runScoped } from './channel/channelExecutor.esm.js';
-import { pipeTo, readWithCause, flatMap as flatMap$2, fromEffect as fromEffect$1 } from './core-stream.esm.js';
-import { flatMap, flattenTake, fromQueue, filterEffect, map, zipWithIndex, unwrapScoped, mapEffectSequential, distributedWithDynamicCallback, flattenExitOption, isStream, matchConcurrency, fromEffect, mapEffectPar, toChannel } from './stream.esm.js';
-import { TakeImpl, of as of$1, chunk, failCause, end } from './take.esm.js';
-
-/** @internal */
-const GroupBySymbolKey = "effect/GroupBy";
-
-/** @internal */
-const GroupByTypeId = /*#__PURE__*/Symbol.for(GroupBySymbolKey);
-
-/** @internal */
-const groupByVariance = {
-  _R: _ => _,
-  _E: _ => _,
-  _K: _ => _,
-  _V: _ => _
-};
-
-/** @internal */
-const isGroupBy = u => hasProperty(u, GroupByTypeId);
-
-/** @internal */
-const evaluate = /*#__PURE__*/dual(args => isGroupBy(args[0]), (self, f, options) => flatMap(self.grouped, ([key, queue]) => f(key, flattenTake(fromQueue(queue, {
-  shutdown: true
-}))), {
-  concurrency: "unbounded",
-  bufferSize: options?.bufferSize ?? 16
-}));
-
-/** @internal */
-const filter = /*#__PURE__*/dual(2, (self, predicate) => make(pipe(self.grouped, filterEffect(tuple => {
-  if (predicate(tuple[0])) {
-    return pipe(succeed(tuple), as(true));
-  }
-  return pipe(shutdown(tuple[1]), as(false));
-}))));
-
-/** @internal */
-const first = /*#__PURE__*/dual(2, (self, n) => make(pipe(zipWithIndex(self.grouped), filterEffect(tuple => {
-  const index = tuple[1];
-  const queue = tuple[0][1];
-  if (index < n) {
-    return pipe(succeed(tuple), as(true));
-  }
-  return pipe(shutdown(queue), as(false));
-}), map(tuple => tuple[0]))));
-
-/** @internal */
-const make = grouped => ({
-  [GroupByTypeId]: groupByVariance,
-  pipe() {
-    return pipeArguments(this, arguments);
-  },
-  grouped
-});
-
-// Circular with Stream
-
-/** @internal */
-const groupBy = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, options) => make(unwrapScoped(gen(function* ($) {
-  const decider = yield* $(make$1());
-  const output = yield* $(acquireRelease(bounded(options?.bufferSize ?? 16), queue => shutdown(queue)));
-  const ref = yield* $(make$2(new Map()));
-  const add = yield* $(mapEffectSequential(self, f), distributedWithDynamicCallback(options?.bufferSize ?? 16, ([key, value]) => flatMap$1(_await(decider), f => f(key, value)), exit => offer(output, exit)));
-  yield* $(succeed$1(decider, (key, _) => pipe(get(ref), map$1(map => fromNullable(map.get(key))), flatMap$1(match({
-    onNone: () => flatMap$1(add, ([index, queue]) => zipRight(update(ref, map => map.set(key, index)), pipe(offer(output, succeed$2([key, mapDequeue(queue, exit => new TakeImpl(pipe(exit, map$4(tuple => of(tuple[1])))))])), as(n => n === index)))),
-    onSome: index => succeed(n => n === index)
-  })))));
-  return flattenExitOption(fromQueue(output, {
-    shutdown: true
-  }));
-}))));
-
-/** @internal */
-const mapEffectOptions = /*#__PURE__*/dual(args => typeof args[0] !== "function", (self, f, options) => {
-  if (options?.key) {
-    return evaluate(groupByKey(self, options.key, {
-      bufferSize: options.bufferSize
-    }), (_, s) => mapEffectSequential(s, f));
-  }
-  return matchConcurrency(options?.concurrency, () => mapEffectSequential(self, f), n => options?.unordered ? flatMap(self, a => fromEffect(f(a)), {
-    concurrency: n
-  }) : mapEffectPar(self, n, f));
-});
-
-/** @internal */
-const bindEffect = /*#__PURE__*/dual(args => typeof args[0] !== "string", (self, tag, f, options) => mapEffectOptions(self, k => map$1(f(k), a => ({
-  ...k,
-  [tag]: a
-})), options));
-const mapDequeue = (dequeue, f) => new MapDequeue(dequeue, f);
-class MapDequeue {
-  [DequeueTypeId] = {
-    _Out: _ => _
-  };
-  constructor(dequeue, f) {
-    this.dequeue = dequeue;
-    this.f = f;
-  }
-  capacity() {
-    return capacity(this.dequeue);
-  }
-  size() {
-    return size(this.dequeue);
-  }
-  unsafeSize() {
-    return this.dequeue.unsafeSize();
-  }
-  awaitShutdown() {
-    return awaitShutdown(this.dequeue);
-  }
-  isActive() {
-    return this.dequeue.isActive();
-  }
-  isShutdown() {
-    return isShutdown(this.dequeue);
-  }
-  shutdown() {
-    return shutdown(this.dequeue);
-  }
-  isFull() {
-    return isFull(this.dequeue);
-  }
-  isEmpty() {
-    return isEmpty(this.dequeue);
-  }
-  take() {
-    return pipe(take(this.dequeue), map$1(a => this.f(a)));
-  }
-  takeAll() {
-    return pipe(takeAll(this.dequeue), map$1(map$2(a => this.f(a))));
-  }
-  takeUpTo(max) {
-    return pipe(takeUpTo(this.dequeue, max), map$1(map$2(a => this.f(a))));
-  }
-  takeBetween(min, max) {
-    return pipe(takeBetween(this.dequeue, min, max), map$1(map$2(a => this.f(a))));
-  }
-  takeN(n) {
-    return pipe(takeN(this.dequeue, n), map$1(map$2(a => this.f(a))));
-  }
-  poll() {
-    return pipe(poll(this.dequeue), map$1(map$3(a => this.f(a))));
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-}
-
-/** @internal */
-const groupByKey = /*#__PURE__*/dual(args => typeof args[0] !== "function", (self, f, options) => {
-  const loop = (map, outerQueue) => readWithCause({
-    onInput: input => flatMap$2(fromEffect$1(forEach(groupByIterable(input, f), ([key, values]) => {
-      const innerQueue = map.get(key);
-      if (innerQueue === undefined) {
-        return pipe(bounded(options?.bufferSize ?? 16), flatMap$1(innerQueue => pipe(sync(() => {
-          map.set(key, innerQueue);
-        }), zipRight(offer(outerQueue, of$1([key, innerQueue]))), zipRight(pipe(offer(innerQueue, chunk(values)), catchSomeCause(cause => isInterruptedOnly(cause) ? some(unit) : none()))))));
-      }
-      return catchSomeCause(offer(innerQueue, chunk(values)), cause => isInterruptedOnly(cause) ? some(unit) : none());
-    }, {
-      discard: true
-    })), () => loop(map, outerQueue)),
-    onFailure: cause => fromEffect$1(offer(outerQueue, failCause(cause))),
-    onDone: () => pipe(fromEffect$1(pipe(forEach(map.entries(), ([_, innerQueue]) => pipe(offer(innerQueue, end), catchSomeCause(cause => isInterruptedOnly(cause) ? some(unit) : none())), {
-      discard: true
-    }), zipRight(offer(outerQueue, end)))))
-  });
-  return make(unwrapScoped(pipe(sync(() => new Map()), flatMap$1(map => pipe(acquireRelease(unbounded(), queue => shutdown(queue)), flatMap$1(queue => pipe(self, toChannel, pipeTo(loop(map, queue)), drain, runScoped, forkScoped, as(flattenTake(fromQueue(queue, {
-    shutdown: true
-  }))))))))));
-});
-
-/**
- * A variant of `groupBy` that retains the insertion order of keys.
- *
- * @internal
- */
-const groupByIterable = /*#__PURE__*/dual(2, (iterable, f) => {
-  const builder = [];
-  const iterator = iterable[Symbol.iterator]();
-  const map = new Map();
-  let next;
-  while ((next = iterator.next()) && !next.done) {
-    const value = next.value;
-    const key = f(value);
-    if (map.has(key)) {
-      const innerBuilder = map.get(key);
-      innerBuilder.push(value);
-    } else {
-      const innerBuilder = [value];
-      builder.push([key, innerBuilder]);
-      map.set(key, innerBuilder);
-    }
-  }
-  return unsafeFromArray(builder.map(tuple => [tuple[0], unsafeFromArray(tuple[1])]));
-});
-
-export { GroupByTypeId, bindEffect, evaluate, filter, first, groupBy, groupByIterable, groupByKey, isGroupBy, make, mapEffectOptions };

package/internal/keyedPool.esm.js

@@ -1,161 +0,0 @@
-import { decode, infinity } from '../Duration/dist/effect-Duration.esm.js';
-import { equals, symbol as symbol$1 } from '../Equal/dist/effect-Equal.esm.js';
-import { dual, pipe } from '../Function/dist/effect-Function.esm.js';
-import { symbol, combine, hash, string } from '../Hash/dist/effect-Hash.esm.js';
-import { empty, get as get$2, has, set, remove, values } from '../HashMap/dist/effect-HashMap.esm.js';
-import { map, context, fiberId, sync, flatMap, forEachSequentialDiscard, suspend, uninterruptibleMask, deferredUnsafeMake, provideContext, matchCauseEffect, zipRight, deferredFailCause, failCause, as, deferredSucceed, deferredAwait, succeed, forEachSequential } from './core.esm.js';
-import { all, scopeMake, scopeExtend } from './fiberRuntime.esm.js';
-import { get as get$1, makeWithTTL as makeWithTTL$1 } from './pool.esm.js';
-import { make as make$1, get as get$3, update } from '../MutableRef/dist/effect-MutableRef.esm.js';
-import { getOrUndefined, getOrElse, none, some } from '../Option/dist/effect-Option.esm.js';
-import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
-import { isTagged } from '../Predicate/dist/effect-Predicate.esm.js';
-
-/** @internal */
-const KeyedPoolSymbolKey = "effect/KeyedPool";
-
-/** @internal */
-const KeyedPoolTypeId = /*#__PURE__*/Symbol.for(KeyedPoolSymbolKey);
-const KeyedPoolMapValueSymbol = /*#__PURE__*/Symbol.for("effect/KeyedPool/MapValue");
-const keyedPoolVariance = {
-  _K: _ => _,
-  _E: _ => _,
-  _A: _ => _
-};
-class KeyedPoolImpl {
-  [KeyedPoolTypeId] = keyedPoolVariance;
-  constructor(getOrCreatePool, activePools) {
-    this.getOrCreatePool = getOrCreatePool;
-    this.activePools = activePools;
-  }
-  get(key) {
-    return flatMap(this.getOrCreatePool(key), get$1);
-  }
-  invalidate(item) {
-    return flatMap(this.activePools(), forEachSequentialDiscard(pool => pool.invalidate(item)));
-  }
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-}
-class Complete {
-  _tag = "Complete";
-  [KeyedPoolMapValueSymbol] = KeyedPoolMapValueSymbol;
-  constructor(pool) {
-    this.pool = pool;
-  }
-  [symbol]() {
-    return pipe(string("effect/KeyedPool/Complete"), combine(hash(this.pool)));
-  }
-  [symbol$1](u) {
-    return isComplete(u) && equals(this.pool, u.pool);
-  }
-}
-const isComplete = u => isTagged(u, "Complete") && KeyedPoolMapValueSymbol in u;
-class Pending {
-  _tag = "Pending";
-  [KeyedPoolMapValueSymbol] = KeyedPoolMapValueSymbol;
-  constructor(deferred) {
-    this.deferred = deferred;
-  }
-  [symbol]() {
-    return pipe(string("effect/KeyedPool/Pending"), combine(hash(this.deferred)));
-  }
-  [symbol$1](u) {
-    return isPending(u) && equals(this.deferred, u.deferred);
-  }
-}
-const isPending = u => isTagged(u, "Pending") && KeyedPoolMapValueSymbol in u;
-const makeImpl = (get, min, max, timeToLive) => pipe(all([context(), fiberId, sync(() => make$1(empty())), scopeMake()]), map(([context, fiberId, map, scope]) => {
-  const getOrCreatePool = key => suspend(() => {
-    let value = getOrUndefined(get$2(get$3(map), key));
-    if (value === undefined) {
-      return uninterruptibleMask(restore => {
-        const deferred = deferredUnsafeMake(fiberId);
-        value = new Pending(deferred);
-        let previous = undefined;
-        if (has(get$3(map), key)) {
-          previous = getOrUndefined(get$2(get$3(map), key));
-        } else {
-          update(map, set(key, value));
-        }
-        if (previous === undefined) {
-          return pipe(restore(scopeExtend(makeWithTTL$1({
-            acquire: provideContext(get(key), context),
-            min: min(key),
-            max: max(key),
-            timeToLive: getOrElse(timeToLive(key), () => infinity)
-          }), scope)), matchCauseEffect({
-            onFailure: cause => {
-              const current = getOrUndefined(get$2(get$3(map), key));
-              if (equals(current, value)) {
-                update(map, remove(key));
-              }
-              return zipRight(deferredFailCause(deferred, cause), failCause(cause));
-            },
-            onSuccess: pool => {
-              update(map, set(key, new Complete(pool)));
-              return as(deferredSucceed(deferred, pool), pool);
-            }
-          }));
-        }
-        switch (previous._tag) {
-          case "Complete":
-            {
-              return succeed(previous.pool);
-            }
-          case "Pending":
-            {
-              return restore(deferredAwait(previous.deferred));
-            }
-        }
-      });
-    }
-    switch (value._tag) {
-      case "Complete":
-        {
-          return succeed(value.pool);
-        }
-      case "Pending":
-        {
-          return deferredAwait(value.deferred);
-        }
-    }
-  });
-  const activePools = () => suspend(() => forEachSequential(Array.from(values(get$3(map))), value => {
-    switch (value._tag) {
-      case "Complete":
-        {
-          return succeed(value.pool);
-        }
-      case "Pending":
-        {
-          return deferredAwait(value.deferred);
-        }
-    }
-  }));
-  return new KeyedPoolImpl(getOrCreatePool, activePools);
-}));
-
-/** @internal */
-const make = options => makeImpl(options.acquire, () => options.size, () => options.size, () => none());
-
-/** @internal */
-const makeWith = options => makeImpl(options.acquire, options.size, options.size, () => none());
-
-/** @internal */
-const makeWithTTL = options => {
-  const timeToLive = decode(options.timeToLive);
-  return makeImpl(options.acquire, options.min, options.max, () => some(timeToLive));
-};
-
-/** @internal */
-const makeWithTTLBy = options => makeImpl(options.acquire, options.min, options.max, key => some(decode(options.timeToLive(key))));
-
-/** @internal */
-const get = /*#__PURE__*/dual(2, (self, key) => self.get(key));
-
-/** @internal */
-const invalidate = /*#__PURE__*/dual(2, (self, item) => self.invalidate(item));
-
-export { KeyedPoolTypeId, get, invalidate, make, makeWith, makeWithTTL, makeWithTTLBy };

package/internal/layer/circular.esm.js

@@ -1,86 +0,0 @@
-import { make } from '../../Context/dist/effect-Context.esm.js';
-import { dual } from '../../Function/dist/effect-Function.esm.js';
-import { add, remove } from '../../HashSet/dist/effect-HashSet.esm.js';
-import { fiberRefLocally, map, tap } from '../core.esm.js';
-import { fiberRefLocallyScoped, currentMinimumLogLevel, fiberRefLocallyScopedWith, currentLoggers, currentSupervisor, withRuntimeFlagsScoped, withConfigProviderScoped, makeSpanScoped, addFinalizer, withTracerScoped } from '../fiberRuntime.esm.js';
-import { scopedDiscard, unwrapEffect, unwrapScoped, flatMap, succeedContext, scoped } from '../layer.esm.js';
-import { CooperativeYielding, Interruption, OpSupervision, RuntimeMetrics, WindDown } from '../runtimeFlags.esm.js';
-import { enable, disable } from '../runtimeFlagsPatch.esm.js';
-import { Zip } from '../supervisor.esm.js';
-import { spanTag } from '../tracer.esm.js';
-
-// circular with Logger
-
-/** @internal */
-const minimumLogLevel = level => scopedDiscard(fiberRefLocallyScoped(currentMinimumLogLevel, level));
-
-/** @internal */
-const withMinimumLogLevel = /*#__PURE__*/dual(2, (self, level) => fiberRefLocally(currentMinimumLogLevel, level)(self));
-
-/** @internal */
-const addLogger = logger => scopedDiscard(fiberRefLocallyScopedWith(currentLoggers, add(logger)));
-
-/** @internal */
-const addLoggerEffect = effect => unwrapEffect(map(effect, addLogger));
-
-/** @internal */
-const addLoggerScoped = effect => unwrapScoped(map(effect, addLogger));
-
-/** @internal */
-const removeLogger = logger => scopedDiscard(fiberRefLocallyScopedWith(currentLoggers, remove(logger)));
-
-/** @internal */
-const replaceLogger = /*#__PURE__*/dual(2, (self, that) => flatMap(removeLogger(self), () => addLogger(that)));
-
-/** @internal */
-const replaceLoggerEffect = /*#__PURE__*/dual(2, (self, that) => flatMap(removeLogger(self), () => addLoggerEffect(that)));
-
-/** @internal */
-const replaceLoggerScoped = /*#__PURE__*/dual(2, (self, that) => flatMap(removeLogger(self), () => addLoggerScoped(that)));
-
-/** @internal */
-const addSupervisor = supervisor => scopedDiscard(fiberRefLocallyScopedWith(currentSupervisor, current => new Zip(current, supervisor)));
-
-/** @internal */
-const enableCooperativeYielding = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlagsScoped( /*#__PURE__*/enable(CooperativeYielding)));
-
-/** @internal */
-const enableInterruption = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlagsScoped( /*#__PURE__*/enable(Interruption)));
-
-/** @internal */
-const enableOpSupervision = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlagsScoped( /*#__PURE__*/enable(OpSupervision)));
-
-/** @internal */
-const enableRuntimeMetrics = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlagsScoped( /*#__PURE__*/enable(RuntimeMetrics)));
-
-/** @internal */
-const enableWindDown = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlagsScoped( /*#__PURE__*/enable(WindDown)));
-
-/** @internal */
-const disableCooperativeYielding = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlagsScoped( /*#__PURE__*/disable(CooperativeYielding)));
-
-/** @internal */
-const disableInterruption = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlagsScoped( /*#__PURE__*/disable(Interruption)));
-
-/** @internal */
-const disableOpSupervision = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlagsScoped( /*#__PURE__*/disable(OpSupervision)));
-
-/** @internal */
-const disableRuntimeMetrics = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlagsScoped( /*#__PURE__*/disable(RuntimeMetrics)));
-
-/** @internal */
-const disableWindDown = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlagsScoped( /*#__PURE__*/disable(WindDown)));
-
-/** @internal */
-const setConfigProvider = configProvider => scopedDiscard(withConfigProviderScoped(configProvider));
-
-/** @internal */
-const parentSpan = span => succeedContext(make(spanTag, span));
-
-/** @internal */
-const span = (name, options) => scoped(spanTag, options?.onEnd ? tap(makeSpanScoped(name, options), span => addFinalizer(exit => options.onEnd(span, exit))) : makeSpanScoped(name, options));
-
-/** @internal */
-const setTracer = tracer => scopedDiscard(withTracerScoped(tracer));
-
-export { addLogger, addLoggerEffect, addLoggerScoped, addSupervisor, disableCooperativeYielding, disableInterruption, disableOpSupervision, disableRuntimeMetrics, disableWindDown, enableCooperativeYielding, enableInterruption, enableOpSupervision, enableRuntimeMetrics, enableWindDown, minimumLogLevel, parentSpan, removeLogger, replaceLogger, replaceLoggerEffect, replaceLoggerScoped, setConfigProvider, setTracer, span, withMinimumLogLevel };