effect 2.0.0-next.35 → 2.0.0-next.37

package/dist/Effect-d5910dae.esm.js

@@ -0,0 +1,3417 @@
+import { b as add, a as getOption } from './Context-48179faa.esm.js';
+import { i as identity } from './Function-52fb7d21.esm.js';
+import { c as currentServices, a as clockTag, w as withClock$1, i as config$1, j as configProviderWith$1, k as withConfigProvider$1, r as randomWith$1, h as tracerWith$1, l as withTracer$1 } from './defaultServices-86214de4.esm.js';
+import { cS as EffectTypeId$1, M as isEffect$1, av as async$1, bk as asyncEither$1, V as fail$1, by as failSync$1, C as failCause$1, bz as failCauseSync$1, cT as die$1, bx as dieMessage$1, W as dieSync$1, bM as never$1, j as succeed$1, a as suspend$1, s as sync$1, p as unit$1, aP as yieldNow$1, b6 as catchAll$1, aM as catchAllCause$1, bt as catchIf$1, cU as catchSome$1, cV as checkInterruptible$1, i as interrupt$1, cW as interruptWith$1, Y as interruptible$1, cX as interruptibleMask$1, o as onInterrupt$1, u as uninterruptible$1, X as uninterruptibleMask$1, aj as as$1, c as asUnit$1, aa as flip$1, m as map$1, bm as mapBoth$1, bn as mapError$1, a5 as acquireUseRelease$1, R as onError$1, al as onExit$1, n as fiberId$1, ab as fiberIdWith$1, aW as transplant$1, cY as withConcurrency$1, cZ as withSchedulingPriority$1, c_ as withMaxOpsBeforeYield$1, bv as context$1, a3 as contextWithEffect$1, ak as mapInputContext$1, U as either$1, P as exit$1, bA as intoDeferred$1, aT as if_$1, e as whenEffect$1, f as flatMap$1, a1 as flatten$1, t as tap$1, az as whileLoop$1, N as fiberRefLocally, bl as fiberRefLocallyWith, bu as matchCause$1, B as matchCauseEffect$1, F as matchEffect$1, c$ as withUnhandledErrorLogLevel$1, aA as currentUnhandledErrorLogLevel, d0 as orDie$1, d1 as orDieWith$1, bw as orElse$1, ad as runtimeFlags, ac as updateRuntimeFlags, aS as withRuntimeFlags, d2 as metricLabels$1, bq as unified$1, aL as blocked$1, aN as runRequestBlock$1, aX as step$1, b5 as flatMapStep$1, d3 as withRequestBatching$1, aV as currentRequestBatching, d4 as withTracerTiming$1, bJ as currentTracerTimingEnabled } from './core-9f5f0dc2.esm.js';
+import { d as memoize, o as once$1, e as dropUntil$1, f as dropWhile$1, g as every$1, h as findFirst$1, i as firstSuccessOf$1, j as head$1, r as reduce$1, k as reduceRight$1, l as reduceWhile$1, n as takeUntil$1, p as takeWhile$1, q as asyncOption$1, s as gen$1, u as none$1, v as promise$1, w as succeedNone$1, x as succeedSome$1, _ as _catch$1, y as catchAllDefect$1, z as catchSomeCause$1, A as catchSomeDefect$1, B as catchTag$1, C as catchTags$1, D as cause$1, E as eventually$1, F as ignore$1, G as ignoreLogged$1, H as parallelErrors$1, I as sandbox$1, J as try_$1, K as tryMap$1, L as tryMapPromise$1, M as tryPromise$1, N as unsandbox$1, O as allowInterrupt$1, P as asSome$1, Q as asSomeError$1, R as flipWith$1, T as mapAccum$1, b as mapErrorCause$1, U as merge$1, V as negate$1, W as descriptor$1, X as descriptorWith$1, Y as diffFiberRefs$1, Z as clock$1, $ as clockWith$1, a0 as delay$1, a1 as sleep$1, a2 as timed$1, a3 as timedWith$1, a4 as contextWith$1, a5 as provideService$1, a6 as provideServiceEffect$1, a7 as serviceFunction$1, a8 as serviceFunctionEffect$1, a9 as serviceFunctions$1, aa as serviceConstants$1, ab as serviceMembers$1, ac as updateService$1, ad as Do$1, ae as bind$1, af as bindTo$1, ag as bindValue, ah as option$1, ai as filterOrDie$1, aj as filterOrDieMessage$1, ak as filterOrElse$1, al as filterOrFail$1, am as unless$1, an as unlessEffect$1, ao as when$1, ap as whenFiberRef$1, aq as whenRef$1, ar as summarized$1, as as tapBoth$1, t as tapDefect$1, a as tapError$1, at as tapErrorTag$1, au as tapErrorCause$1, av as forever$1, aw as iterate$1, ax as loop$1, ay as repeatN$1, az as fiberRefs, aA as inheritFiberRefs$1, aB as patchFiberRefs$1, aC as setFiberRefs$1, aD as updateFiberRefs$1, aE as isFailure$1, aF as isSuccess$1, aG as match$1, aH as log$1, aI as logTrace$1, aJ as logDebug$1, aK as logInfo$1, aL as logWarning$1, aM as logError$1, aN as logFatal$1, aO as withLogSpan$1, aP as annotateLogs$1, aQ as logAnnotations$1, aR as orElseFail$1, aS as orElseSucceed$1, aT as random$1, aU as tagMetrics$1, aV as labelMetrics$1, aW as labelMetricsSet$1, aX as withMetric$1, aY as tracer$1, aZ as annotateSpans$1, a_ as annotateCurrentSpan$1, a$ as currentSpan$1, b0 as currentParentSpan$1, b1 as spanAnnotations$1, b2 as spanLinks$1, b3 as linkSpans$1, m as makeSpan$1, b4 as useSpan$1, b5 as withSpan$1, b6 as withParentSpan$1, b7 as fromNullable$1, b8 as optionFromOptional$1 } from './core-effect-e762d50b.esm.js';
+import { c as cached$1, a as cachedInvalidate, m as memoizeFunction, b as awaitAllChildren$1, e as ensuringChild$1, d as ensuringChildren$1, f as forkAll$1, g as forkIn$1, h as forkScoped$1, i as fromFiber$1, j as fromFiberEffect$1, s as supervised$1, t as timeout$1, k as timeoutFail$1, l as timeoutFailCause$1, n as timeoutTo$1, r as raceFirst$1, o as scheduleForked$1, u as unsafeMakeSemaphore$1, p as makeSemaphore$1 } from './circular-cff58c30.esm.js';
+import { a as all$1, d as allWith$1, e as allSuccesses$1, g as exists$1, h as filter$1, i as forEachOptions, m as mergeAll$1, p as partition$1, r as reduceEffect$1, j as replicate$1, k as replicateEffect$1, v as validateAll$1, l as validateFirst$1, n as disconnect$1, b as acquireRelease$1, o as acquireReleaseInterruptible$1, q as addFinalizer$1, t as ensuring$1, u as parallelFinalizers$1, w as finalizersMask$1, x as sequentialFinalizers$1, y as scope$1, z as scopeWith$1, A as scopedEffect, B as using$1, C as withEarlyRelease$1, D as daemonChildren$1, E as fork$1, F as forkDaemon$1, G as forkWithErrorHandler$1, H as fiberRefLocallyScoped, I as fiberRefLocallyScopedWith, J as withClockScoped$1, K as withConfigProviderScoped$1, L as raceAll$1, M as race$1, N as raceWith$1, O as withRuntimeFlagsScoped, P as tagMetricsScoped$1, Q as labelMetricsScoped$1, R as labelMetricsScopedSet$1, S as validate$1, T as validateWith$1, U as zipOptions, V as zipLeftOptions, W as zipRightOptions, X as zipWithOptions, Y as withTracerScoped$1, Z as useSpanScoped$1, _ as withSpanScoped$1, $ as withParentSpanScoped$1 } from './fiberRuntime-98f09d31.esm.js';
+import { s as scopedDiscard, e as effect_provide } from './layer-f8ec8454.esm.js';
+import { s as setConfigProvider$1, a as setTracer$1, b as setParentSpan$1, c as setSpan$1 } from './circular-3ebc9b78.esm.js';
+import { f as fromRequest, c as cacheRequest, a as currentCacheEnabled, b as currentCache, w as withRequestCaching$1, d as withRequestCache$1 } from './query-1685a476.esm.js';
+import { a as asyncEffect$1, r as runtime$1, u as unsafeForkEffect, b as unsafeRunEffect, c as unsafeRunPromiseEffect, d as unsafeRunPromiseExitEffect, e as unsafeRunSyncEffect, f as unsafeRunSyncExitEffect } from './runtime-f91ca239.esm.js';
+import { r as retry_Effect, a as retryN_Effect, b as retryOrElse_Effect, c as retryUntil_Effect, d as retryUntilEffect_Effect, e as retryWhile_Effect, f as retryWhileEffect_Effect, g as repeat_Effect, h as repeatOrElse_Effect, i as repeatUntil_Effect, j as repeatUntilEffect_Effect, k as repeatWhile_Effect, l as repeatWhileEffect_Effect, s as schedule_Effect, m as scheduleFrom_Effect } from './schedule-0d31f4cc.esm.js';
+import { c as currentScheduler, w as withScheduler$1 } from './Scheduler-d2f7e5c7.esm.js';
+
+/**
+ * @since 1.0.0
+ */
+
+// -------------------------------------------------------------------------------------
+// models
+// -------------------------------------------------------------------------------------
+/**
+ * @since 1.0.0
+ */
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+const EffectTypeId = EffectTypeId$1;
+
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+
+/**
+ * The `Effect` interface defines a value that lazily describes a workflow or job.
+ * The workflow requires some context `R`, and may fail with an error of type `E`,
+ * or succeed with a value of type `A`.
+ *
+ * `Effect` values model resourceful interaction with the outside world, including
+ * synchronous, asynchronous, concurrent, and parallel interaction. They use a
+ * fiber-based concurrency model, with built-in support for scheduling, fine-grained
+ * interruption, structured concurrency, and high scalability.
+ *
+ * To run an `Effect` value, you need a `Runtime`, which is a type that is capable
+ * of executing `Effect` values.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+
+/**
+ * @category type lambdas
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * @since 1.0.0
+ */
+
+// -------------------------------------------------------------------------------------
+// refinements
+// -------------------------------------------------------------------------------------
+/**
+ * This function returns `true` if the specified value is an `Effect` value,
+ * `false` otherwise.
+ *
+ * This function can be useful for checking the type of a value before
+ * attempting to operate on it as an `Effect` value. For example, you could
+ * use `isEffect` to check the type of a value before using it as an
+ * argument to a function that expects an `Effect` value.
+ *
+ * @param u - The value to check for being an `Effect` value.
+ *
+ * @returns `true` if the specified value is an `Effect` value, `false`
+ * otherwise.
+ *
+ * @since 1.0.0
+ * @category refinements
+ */
+const isEffect = isEffect$1;
+
+// -------------------------------------------------------------------------------------
+// caching
+// -------------------------------------------------------------------------------------
+
+/**
+ * Returns an effect that, if evaluated, will return the cached result of this
+ * effect. Cached results will expire after `timeToLive` duration.
+ *
+ * @since 1.0.0
+ * @category caching
+ */
+const cachedWithTTL = cached$1;
+
+/**
+ * Returns an effect that, if evaluated, will return the cached result of this
+ * effect. Cached results will expire after `timeToLive` duration. In
+ * addition, returns an effect that can be used to invalidate the current
+ * cached value before the `timeToLive` duration expires.
+ *
+ * @since 1.0.0
+ * @category caching
+ */
+const cachedInvalidateWithTTL = cachedInvalidate;
+
+/**
+ * Returns an effect that, if evaluated, will return the lazily computed
+ * result of this effect.
+ *
+ * @since 1.0.0
+ * @category caching
+ */
+const cached = memoize;
+
+/**
+ * Returns a memoized version of the specified effectual function.
+ *
+ * @since 1.0.0
+ * @category caching
+ */
+const cachedFunction = memoizeFunction;
+
+/**
+ * Returns an effect that will be executed at most once, even if it is
+ * evaluated multiple times.
+ *
+ * @since 1.0.0
+ * @category caching
+ */
+const once = once$1;
+
+// -------------------------------------------------------------------------------------
+// collecting & elements
+// -------------------------------------------------------------------------------------
+
+/**
+ * Runs all the provided effects in sequence respecting the structure provided in input.
+ *
+ * Supports multiple arguments, a single argument tuple / array or record / struct.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const all = all$1;
+
+/**
+ * Data-last variant of `Effect.all`.
+ *
+ * Runs all the provided effects in sequence respecting the structure provided in input.
+ *
+ * Supports multiple arguments, a single argument tuple / array or record / struct.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const allWith = allWith$1;
+
+/**
+ * @since 1.0.0
+ */
+
+/**
+ * Evaluate and run each effect in the structure and collect the results,
+ * discarding results from failed effects.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const allSuccesses = allSuccesses$1;
+
+/**
+ * Drops all elements until the effectful predicate returns true.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const dropUntil = dropUntil$1;
+
+/**
+ * Drops all elements so long as the predicate returns true.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const dropWhile = dropWhile$1;
+
+/**
+ * Determines whether all elements of the `Collection<A>` satisfies the effectual
+ * predicate `f`.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const every = every$1;
+
+/**
+ * Determines whether any element of the `Iterable<A>` satisfies the effectual
+ * predicate `f`.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const exists = exists$1;
+
+/**
+ * Filters the collection using the specified effectful predicate.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const filter = filter$1;
+
+/**
+ * Returns the first element that satisfies the effectful predicate.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const findFirst = findFirst$1;
+
+/**
+ * This function takes an iterable of `Effect` values and returns a new
+ * `Effect` value that represents the first `Effect` value in the iterable
+ * that succeeds. If all of the `Effect` values in the iterable fail, then
+ * the resulting `Effect` value will fail as well.
+ *
+ * This function is sequential, meaning that the `Effect` values in the
+ * iterable will be executed in sequence, and the first one that succeeds
+ * will determine the outcome of the resulting `Effect` value.
+ *
+ * @param effects - The iterable of `Effect` values to evaluate.
+ *
+ * @returns A new `Effect` value that represents the first successful
+ * `Effect` value in the iterable, or a failed `Effect` value if all of the
+ * `Effect` values in the iterable fail.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const firstSuccessOf = firstSuccessOf$1;
+
+/**
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const forEach = forEachOptions;
+
+/**
+ * Returns a successful effect with the head of the collection if the collection
+ * is non-empty, or fails with the error `None` if the collection is empty.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const head = head$1;
+
+/**
+ * Merges an `Iterable<Effect<R, E, A>>` to a single effect, working
+ * sequentially.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const mergeAll = mergeAll$1;
+
+/**
+ * Feeds elements of type `A` to a function `f` that returns an effect.
+ * Collects all successes and failures in a tupled fashion.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const partition = partition$1;
+
+/**
+ * Folds an `Iterable<A>` using an effectual function f, working sequentially
+ * from left to right.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const reduce = reduce$1;
+
+/**
+ * Reduces an `Iterable<Effect<R, E, A>>` to a single effect.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const reduceEffect = reduceEffect$1;
+
+/**
+ * Folds an `Iterable<A>` using an effectual function f, working sequentially from left to right.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const reduceRight = reduceRight$1;
+
+/**
+ * Folds over the elements in this chunk from the left, stopping the fold early
+ * when the predicate is not satisfied.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const reduceWhile = reduceWhile$1;
+
+/**
+ * Replicates the given effect `n` times.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const replicate = replicate$1;
+
+/**
+ * Performs this effect the specified number of times and collects the
+ * results.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const replicateEffect = replicateEffect$1;
+
+/**
+ * Takes elements until the effectual predicate returns true.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const takeUntil = takeUntil$1;
+
+/**
+ * Takes all elements so long as the effectual predicate returns true.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const takeWhile = takeWhile$1;
+
+/**
+ * Feeds elements of type `A` to `f` and accumulates all errors in error
+ * channel or successes in success channel.
+ *
+ * This combinator is lossy meaning that if there are errors all successes
+ * will be lost. To retain all information please use `partition`.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const validateAll = validateAll$1;
+
+/**
+ * Feeds elements of type `A` to `f` until it succeeds. Returns first success
+ * or the accumulation of all errors.
+ *
+ * If `elements` is empty then `Effect.fail([])` is returned.
+ *
+ * @example
+ * import * as Effect from "effect/Effect"
+ * import * as Exit from "effect/Exit"
+ *
+ * const f = (n: number) => (n > 0 ? Effect.succeed(n) : Effect.fail(`${n} is negative`))
+ *
+ * assert.deepStrictEqual(Effect.runSyncExit(Effect.validateFirst([], f)), Exit.fail([]))
+ * assert.deepStrictEqual(Effect.runSyncExit(Effect.validateFirst([1, 2], f)), Exit.succeed(1))
+ * assert.deepStrictEqual(Effect.runSyncExit(Effect.validateFirst([1, -1], f)), Exit.succeed(1))
+ * assert.deepStrictEqual(Effect.runSyncExit(Effect.validateFirst([-1, 2], f)), Exit.succeed(2))
+ * assert.deepStrictEqual(Effect.runSyncExit(Effect.validateFirst([-1, -2], f)), Exit.fail(['-1 is negative', '-2 is negative']))
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+const validateFirst = validateFirst$1;
+
+// -------------------------------------------------------------------------------------
+// constructors
+// -------------------------------------------------------------------------------------
+
+/**
+ * Imports an asynchronous side-effect into a pure `Effect` value.
+ * The callback function `Effect<R, E, A> => void` must be called at most once.
+ *
+ * If an Effect is returned by the registration function, it will be executed
+ * if the fiber executing the effect is interrupted.
+ *
+ * The registration function can also receive an `AbortSignal` if required for
+ * interruption.
+ *
+ * The `FiberId` of the fiber that may complete the async callback may be
+ * provided to allow for better diagnostics.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const async = async$1;
+
+/**
+ * Converts an asynchronous, callback-style API into an `Effect`, which will
+ * be executed asynchronously.
+ *
+ * With this variant, the registration function may return a an `Effect`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const asyncEffect = asyncEffect$1;
+
+/**
+ * Imports an asynchronous effect into a pure `Effect` value, possibly returning
+ * the value synchronously.
+ *
+ * If the register function returns a value synchronously, then the callback
+ * function `Effect<R, E, A> => void` must not be called. Otherwise the callback
+ * function must be called at most once.
+ *
+ * The `FiberId` of the fiber that may complete the async callback may be
+ * provided to allow for better diagnostics.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const asyncOption = asyncOption$1;
+
+/**
+ * Imports an asynchronous side-effect into an effect. It has the option of
+ * returning the value synchronously, which is useful in cases where it cannot
+ * be determined if the effect is synchronous or asynchronous until the register
+ * is actually executed. It also has the option of returning a canceler,
+ * which will be used by the runtime to cancel the asynchronous effect if the fiber
+ * executing the effect is interrupted.
+ *
+ * If the register function returns a value synchronously, then the callback
+ * function `Effect<R, E, A> => void` must not be called. Otherwise the callback
+ * function must be called at most once.
+ *
+ * The `FiberId` of the fiber that may complete the async callback may be
+ * provided to allow for better diagnostics.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const asyncEither = asyncEither$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const fail = fail$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const failSync = failSync$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const failCause = failCause$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const failCauseSync = failCauseSync$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const die = die$1;
+
+/**
+ * Returns an effect that dies with a `RuntimeException` having the specified
+ * text message. This method can be used for terminating a fiber because a
+ * defect has been detected in the code.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const dieMessage = dieMessage$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const dieSync = dieSync$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const gen = gen$1;
+
+/**
+ * @category models
+ * @since 1.0.0
+ */
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+
+/**
+ * Returns a effect that will never produce anything. The moral equivalent of
+ * `while(true) {}`, only without the wasted CPU cycles.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const never = never$1;
+
+/**
+ * Requires the option produced by this value to be `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const none = none$1;
+
+/**
+ * Like `tryPromise` but produces a defect in case of errors.
+ *
+ * An optional `AbortSignal` can be provided to allow for interruption of the
+ * wrapped Promise api.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const promise = promise$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const succeed = succeed$1;
+
+/**
+ * Returns an effect which succeeds with `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const succeedNone = succeedNone$1;
+
+/**
+ * Returns an effect which succeeds with the value wrapped in a `Some`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const succeedSome = succeedSome$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const suspend = suspend$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const sync = sync$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const unit = unit$1;
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+const yieldNow = yieldNow$1;
+
+// -------------------------------------------------------------------------------------
+// error handling
+// -------------------------------------------------------------------------------------
+
+const _catch = _catch$1;
+
+/**
+ * Recovers from all recoverable errors.
+ *
+ * **Note**: that `Effect.catchAll` will not recover from unrecoverable defects. To
+ * recover from both recoverable and unrecoverable errors use
+ * `Effect.catchAllCause`.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const catchAll = catchAll$1;
+
+/**
+ * Recovers from both recoverable and unrecoverable errors.
+ *
+ * See `absorb`, `sandbox`, `mapErrorCause` for other functions that can
+ * recover from defects.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const catchAllCause = catchAllCause$1;
+
+/**
+ * Recovers from all defects with provided function.
+ *
+ * **WARNING**: There is no sensible way to recover from defects. This
+ * method should be used only at the boundary between Effect and an external
+ * system, to transmit information on a defect for diagnostic or explanatory
+ * purposes.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const catchAllDefect = catchAllDefect$1;
+
+/**
+ * Recovers from errors that match the given predicate.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const catchIf = catchIf$1;
+
+/**
+ * Recovers from some or all of the error cases.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const catchSome = catchSome$1;
+
+/**
+ * Recovers from some or all of the error cases with provided cause.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const catchSomeCause = catchSomeCause$1;
+
+/**
+ * Recovers from some or all of the defects with provided partial function.
+ *
+ * **WARNING**: There is no sensible way to recover from defects. This
+ * method should be used only at the boundary between Effect and an external
+ * system, to transmit information on a defect for diagnostic or explanatory
+ * purposes.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const catchSomeDefect = catchSomeDefect$1;
+
+/**
+ * Recovers from the specified tagged error.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const catchTag = catchTag$1;
+
+/**
+ * Recovers from the specified tagged errors.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const catchTags = catchTags$1;
+
+/**
+ * Returns an effect that succeeds with the cause of failure of this effect,
+ * or `Cause.empty` if the effect did succeed.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const cause = cause$1;
+
+/**
+ * Returns an effect that ignores errors and runs repeatedly until it
+ * eventually succeeds.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const eventually = eventually$1;
+
+/**
+ * Returns a new effect that ignores the success or failure of this effect.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const ignore = ignore$1;
+
+/**
+ * Returns a new effect that ignores the success or failure of this effect,
+ * but which also logs failures at the Debug level, just in case the failure
+ * turns out to be important.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const ignoreLogged = ignoreLogged$1;
+
+/**
+ * Exposes all parallel errors in a single call.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const parallelErrors = parallelErrors$1;
+
+/**
+ * Exposes the full `Cause` of failure for the specified effect.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const sandbox = sandbox$1;
+
+/**
+ * Retries with the specified retry policy. Retries are done following the
+ * failure of the original `io` (up to a fixed maximum with `once` or `recurs`
+ * for example), so that that `io.retry(Schedule.once)` means "execute `io`
+ * and in case of failure, try again once".
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const retry = retry_Effect;
+
+/**
+ * Retries this effect the specified number of times.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const retryN = retryN_Effect;
+
+/**
+ * Retries with the specified schedule, until it fails, and then both the
+ * value produced by the schedule together with the last error are passed to
+ * the recovery function.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const retryOrElse = retryOrElse_Effect;
+
+/**
+ * Retries this effect until its error satisfies the specified predicate.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const retryUntil = retryUntil_Effect;
+
+/**
+ * Retries this effect until its error satisfies the specified effectful
+ * predicate.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const retryUntilEffect = retryUntilEffect_Effect;
+
+/**
+ * Retries this effect while its error satisfies the specified predicate.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const retryWhile = retryWhile_Effect;
+
+/**
+ * Retries this effect while its error satisfies the specified effectful
+ * predicate.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const retryWhileEffect = retryWhileEffect_Effect;
+const try_ = try_$1;
+
+/**
+ * Returns an effect whose success is mapped by the specified side effecting
+ * `try` function, translating any promise rejections into typed failed effects
+ * via the `catch` function.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const tryMap = tryMap$1;
+
+/**
+ * Returns an effect whose success is mapped by the specified side effecting
+ * `try` function, translating any promise rejections into typed failed effects
+ * via the `catch` function.
+ *
+ * An optional `AbortSignal` can be provided to allow for interruption of the
+ * wrapped Promise api.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const tryMapPromise = tryMapPromise$1;
+
+/**
+ * Create an `Effect` that when executed will construct `promise` and wait for
+ * its result, errors will produce failure as `unknown`.
+ *
+ * An optional `AbortSignal` can be provided to allow for interruption of the
+ * wrapped Promise api.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const tryPromise = tryPromise$1;
+
+/**
+ * The inverse operation `sandbox(effect)`
+ *
+ * Terminates with exceptions on the `Left` side of the `Either` error, if it
+ * exists. Otherwise extracts the contained `Effect<R, E, A>`
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+const unsandbox = unsandbox$1;
+
+// -------------------------------------------------------------------------------------
+// interuption
+// -------------------------------------------------------------------------------------
+
+/**
+ * This function checks if any fibers are attempting to interrupt the current
+ * fiber, and if so, performs self-interruption.
+ *
+ * Note that this allows for interruption to occur in uninterruptible regions.
+ *
+ * @returns A new `Effect` value that represents the check for interruption
+ * and the potential self-interruption of the current fiber.
+ *
+ * @since 1.0.0
+ * @category interruption
+ */
+const allowInterrupt = allowInterrupt$1;
+
+/**
+ * Checks the interrupt status, and produces the effect returned by the
+ * specified callback.
+ *
+ * @since 1.0.0
+ * @category interruption
+ */
+const checkInterruptible = checkInterruptible$1;
+
+/**
+ * Returns an effect whose interruption will be disconnected from the
+ * fiber's own interruption, being performed in the background without
+ * slowing down the fiber's interruption.
+ *
+ * This method is useful to create "fast interrupting" effects. For
+ * example, if you call this on a bracketed effect, then even if the
+ * effect is "stuck" in acquire or release, its interruption will return
+ * immediately, while the acquire / release are performed in the
+ * background.
+ *
+ * See timeout and race for other applications.
+ *
+ * @since 1.0.0
+ * @category interruption
+ */
+const disconnect = disconnect$1;
+
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+const interrupt = interrupt$1;
+
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+const interruptWith = interruptWith$1;
+
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+const interruptible = interruptible$1;
+
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+const interruptibleMask = interruptibleMask$1;
+
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+const onInterrupt = onInterrupt$1;
+
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+const uninterruptible = uninterruptible$1;
+
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+const uninterruptibleMask = uninterruptibleMask$1;
+
+// -------------------------------------------------------------------------------------
+// mapping
+// -------------------------------------------------------------------------------------
+
+/**
+ * This function maps the success value of an `Effect` value to a specified
+ * constant value.
+ *
+ * @param value - The constant value that the success value of the `Effect`
+ * value will be mapped to.
+ * @param self - The `Effect` value whose success value will be mapped to the
+ * specified constant value.
+ *
+ * @returns A new `Effect` value that represents the mapping of the success
+ * value of the original `Effect` value to the specified constant value.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+const as = as$1;
+
+/**
+ * This function maps the success value of an `Effect` value to a `Some` value
+ * in an `Option` value. If the original `Effect` value fails, the returned
+ * `Effect` value will also fail.
+ *
+ * @param self - The `Effect` value whose success value will be mapped to a
+ * `Some` value in an `Option` value.
+ *
+ * @returns A new `Effect` value that represents the mapping of the success
+ * value of the original `Effect` value to a `Some` value in an `Option`
+ * value. The returned `Effect` value may fail if the original `Effect` value
+ * fails.
+ *
+ * @category mapping
+ * @since 1.0.0
+ */
+const asSome = asSome$1;
+
+/**
+ * This function maps the error value of an `Effect` value to a `Some` value
+ * in an `Option` value. If the original `Effect` value succeeds, the returned
+ * `Effect` value will also succeed.
+ *
+ * @param self - The `Effect` value whose error value will be mapped to a
+ * `Some` value in an `Option` value.
+ *
+ * @returns A new `Effect` value that represents the mapping of the error
+ * value of the original `Effect` value to a `Some` value in an `Option`
+ * value. The returned `Effect` value may succeed if the original `Effect`
+ * value succeeds.
+ *
+ * @category mapping
+ * @since 1.0.0
+ */
+const asSomeError = asSomeError$1;
+
+/**
+ * This function maps the success value of an `Effect` value to `void`. If the
+ * original `Effect` value succeeds, the returned `Effect` value will also
+ * succeed. If the original `Effect` value fails, the returned `Effect` value
+ * will fail with the same error.
+ *
+ * @param self - The `Effect` value whose success value will be mapped to `void`.
+ *
+ * @returns A new `Effect` value that represents the mapping of the success
+ * value of the original `Effect` value to `void`.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+const asUnit = asUnit$1;
+
+/**
+ * Returns an effect that swaps the error/success cases. This allows you to
+ * use all methods on the error channel, possibly before flipping back.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+const flip = flip$1;
+
+/**
+ * Swaps the error/value parameters, applies the function `f` and flips the
+ * parameters back
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+const flipWith = flipWith$1;
+
+/**
+ * @since 1.0.0
+ * @category mapping
+ */
+const map = map$1;
+
+/**
+ * Statefully and effectfully maps over the elements of this chunk to produce
+ * new elements.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+const mapAccum = mapAccum$1;
+
+/**
+ * Returns an effect whose failure and success channels have been mapped by
+ * the specified `onFailure` and `onSuccess` functions.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+const mapBoth = mapBoth$1;
+
+/**
+ * Returns an effect with its error channel mapped using the specified function.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+const mapError = mapError$1;
+
+/**
+ * Returns an effect with its full cause of failure mapped using the specified
+ * function. This can be used to transform errors while preserving the
+ * original structure of `Cause`.
+ *
+ * See `absorb`, `sandbox`, `catchAllCause` for other functions for dealing
+ * with defects.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+const mapErrorCause = mapErrorCause$1;
+
+/**
+ * Returns a new effect where the error channel has been merged into the
+ * success channel to their common combined type.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+const merge = merge$1;
+
+/**
+ * Returns a new effect where boolean value of this effect is negated.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+const negate = negate$1;
+
+// -------------------------------------------------------------------------------------
+// scoping, resources & finalization
+// -------------------------------------------------------------------------------------
+
+/**
+ * This function constructs a scoped resource from an `acquire` and `release`
+ * `Effect` value.
+ *
+ * If the `acquire` `Effect` value successfully completes execution, then the
+ * `release` `Effect` value will be added to the finalizers associated with the
+ * scope of this `Effect` value, and it is guaranteed to be run when the scope
+ * is closed.
+ *
+ * The `acquire` and `release` `Effect` values will be run uninterruptibly.
+ * Additionally, the `release` `Effect` value may depend on the `Exit` value
+ * specified when the scope is closed.
+ *
+ * @param acquire - The `Effect` value that acquires the resource.
+ * @param release - The `Effect` value that releases the resource.
+ *
+ * @returns A new `Effect` value that represents the scoped resource.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const acquireRelease = acquireRelease$1;
+
+/**
+ * This function constructs a scoped resource from an `acquire` and `release`
+ * `Effect` value.
+ *
+ * If the `acquire` `Effect` value successfully completes execution, then the
+ * `release` `Effect` value will be added to the finalizers associated with the
+ * scope of this `Effect` value, and it is guaranteed to be run when the scope
+ * is closed.
+ *
+ * The `acquire` `Effect` values will be run interruptibly.
+ * The `release` `Effect` values will be run uninterruptibly.
+ *
+ * Additionally, the `release` `Effect` value may depend on the `Exit` value
+ * specified when the scope is closed.
+ *
+ * @param acquire - The `Effect` value that acquires the resource.
+ * @param release - The `Effect` value that releases the resource.
+ *
+ * @returns A new `Effect` value that represents the scoped resource.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const acquireReleaseInterruptible = acquireReleaseInterruptible$1;
+
+/**
+ * This function is used to ensure that an `Effect` value that represents the
+ * acquisition of a resource (for example, opening a file, launching a thread,
+ * etc.) will not be interrupted, and that the resource will always be released
+ * when the `Effect` value completes execution.
+ *
+ * `acquireUseRelease` does the following:
+ *
+ *   1. Ensures that the `Effect` value that acquires the resource will not be
+ *      interrupted. Note that acquisition may still fail due to internal
+ *      reasons (such as an uncaught exception).
+ *   2. Ensures that the `release` `Effect` value will not be interrupted,
+ *      and will be executed as long as the acquisition `Effect` value
+ *      successfully acquires the resource.
+ *
+ * During the time period between the acquisition and release of the resource,
+ * the `use` `Effect` value will be executed.
+ *
+ * If the `release` `Effect` value fails, then the entire `Effect` value will
+ * fail, even if the `use` `Effect` value succeeds. If this fail-fast behavior
+ * is not desired, errors produced by the `release` `Effect` value can be caught
+ * and ignored.
+ *
+ * @param acquire - The `Effect` value that acquires the resource.
+ * @param use - The `Effect` value that is executed between the acquisition
+ * and release of the resource.
+ * @param release - The `Effect` value that releases the resource.
+ *
+ * @returns A new `Effect` value that represents the acquisition, use, and
+ * release of the resource.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const acquireUseRelease = acquireUseRelease$1;
+
+/**
+ * This function adds a finalizer to the scope of the calling `Effect` value.
+ * The finalizer is guaranteed to be run when the scope is closed, and it may
+ * depend on the `Exit` value that the scope is closed with.
+ *
+ * @param finalizer - The finalizer to add to the scope of the calling
+ * `Effect` value. This function must take an `Exit` value as its parameter,
+ * and return a new `Effect` value.
+ *
+ * @returns A new `Effect` value that represents the addition of the finalizer
+ * to the scope of the calling `Effect` value.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const addFinalizer = addFinalizer$1;
+
+/**
+ * Returns an effect that, if this effect _starts_ execution, then the
+ * specified `finalizer` is guaranteed to be executed, whether this effect
+ * succeeds, fails, or is interrupted.
+ *
+ * For use cases that need access to the effect's result, see `onExit`.
+ *
+ * Finalizers offer very powerful guarantees, but they are low-level, and
+ * should generally not be used for releasing resources. For higher-level
+ * logic built on `ensuring`, see the `acquireRelease` family of methods.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const ensuring = ensuring$1;
+
+/**
+ * Runs the specified effect if this effect fails, providing the error to the
+ * effect if it exists. The provided effect will not be interrupted.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const onError = onError$1;
+
+/**
+ * Ensures that a cleanup functions runs, whether this effect succeeds, fails,
+ * or is interrupted.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const onExit = onExit$1;
+
+/**
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const parallelFinalizers = parallelFinalizers$1;
+
+/**
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const finalizersMask = finalizersMask$1;
+
+/**
+ * Returns a new scoped workflow that runs finalizers added to the scope of
+ * this workflow sequentially in the reverse of the order in which they were
+ * added. Note that finalizers are run sequentially by default so this only
+ * has meaning if used within a scope where finalizers are being run in
+ * parallel.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const sequentialFinalizers = sequentialFinalizers$1;
+
+/**
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const scope = scope$1;
+
+/**
+ * Accesses the current scope and uses it to perform the specified effect.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const scopeWith = scopeWith$1;
+
+/**
+ * Scopes all resources uses in this workflow to the lifetime of the workflow,
+ * ensuring that their finalizers are run as soon as this workflow completes
+ * execution, whether by success, failure, or interruption.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const scoped = scopedEffect;
+
+/**
+ * Scopes all resources acquired by `resource` to the lifetime of `use`
+ * without effecting the scope of any resources acquired by `use`.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const using = using$1;
+
+/**
+ * Returns a new scoped workflow that returns the result of this workflow as
+ * well as a finalizer that can be run to close the scope of this workflow.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+const withEarlyRelease = withEarlyRelease$1;
+
+// -------------------------------------------------------------------------------------
+// supervision & fibers
+// -------------------------------------------------------------------------------------
+
+/**
+ * Returns a new effect that will not succeed with its value before first
+ * waiting for the end of all child fibers forked by the effect.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const awaitAllChildren = awaitAllChildren$1;
+
+/**
+ * Returns a new workflow that will not supervise any fibers forked by this
+ * workflow.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const daemonChildren = daemonChildren$1;
+
+/**
+ * Constructs an effect with information about the current `Fiber`.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const descriptor = descriptor$1;
+
+/**
+ * Constructs an effect based on information about the current `Fiber`.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const descriptorWith = descriptorWith$1;
+
+/**
+ * Returns a new workflow that executes this one and captures the changes in
+ * `FiberRef` values.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const diffFiberRefs = diffFiberRefs$1;
+
+/**
+ * Acts on the children of this fiber (collected into a single fiber),
+ * guaranteeing the specified callback will be invoked, whether or not this
+ * effect succeeds.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const ensuringChild = ensuringChild$1;
+
+/**
+ * Acts on the children of this fiber, guaranteeing the specified callback
+ * will be invoked, whether or not this effect succeeds.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const ensuringChildren = ensuringChildren$1;
+
+/**
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const fiberId = fiberId$1;
+
+/**
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const fiberIdWith = fiberIdWith$1;
+
+/**
+ * Returns an effect that forks this effect into its own separate fiber,
+ * returning the fiber immediately, without waiting for it to begin executing
+ * the effect.
+ *
+ * You can use the `fork` method whenever you want to execute an effect in a
+ * new fiber, concurrently and without "blocking" the fiber executing other
+ * effects. Using fibers can be tricky, so instead of using this method
+ * directly, consider other higher-level methods, such as `raceWith`,
+ * `zipPar`, and so forth.
+ *
+ * The fiber returned by this method has methods to interrupt the fiber and to
+ * wait for it to finish executing the effect. See `Fiber` for more
+ * information.
+ *
+ * Whenever you use this method to launch a new fiber, the new fiber is
+ * attached to the parent fiber's scope. This means when the parent fiber
+ * terminates, the child fiber will be terminated as well, ensuring that no
+ * fibers leak. This behavior is called "auto supervision", and if this
+ * behavior is not desired, you may use the `forkDaemon` or `forkIn` methods.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const fork = fork$1;
+
+/**
+ * Forks the effect into a new fiber attached to the global scope. Because the
+ * new fiber is attached to the global scope, when the fiber executing the
+ * returned effect terminates, the forked fiber will continue running.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const forkDaemon = forkDaemon$1;
+
+/**
+ * Returns an effect that forks all of the specified values, and returns a
+ * composite fiber that produces a list of their results, in order.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const forkAll = forkAll$1;
+
+/**
+ * Forks the effect in the specified scope. The fiber will be interrupted
+ * when the scope is closed.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const forkIn = forkIn$1;
+
+/**
+ * Forks the fiber in a `Scope`, interrupting it when the scope is closed.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const forkScoped = forkScoped$1;
+
+/**
+ * Like fork but handles an error with the provided handler.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const forkWithErrorHandler = forkWithErrorHandler$1;
+
+/**
+ * Creates an `Effect` value that represents the exit value of the specified
+ * fiber.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const fromFiber = fromFiber$1;
+
+/**
+ * Creates an `Effect` value that represents the exit value of the specified
+ * fiber.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const fromFiberEffect = fromFiberEffect$1;
+
+/**
+ * Returns an effect with the behavior of this one, but where all child fibers
+ * forked in the effect are reported to the specified supervisor.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const supervised = supervised$1;
+
+/**
+ * Transplants specified effects so that when those effects fork other
+ * effects, the forked effects will be governed by the scope of the fiber that
+ * executes this effect.
+ *
+ * This can be used to "graft" deep grandchildren onto a higher-level scope,
+ * effectively extending their lifespans into the parent scope.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const transplant = transplant$1;
+
+/**
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+const withConcurrency = withConcurrency$1;
+
+// ---------------------------------------------------------------------------------------
+// scheduler
+// ---------------------------------------------------------------------------------------
+
+/**
+ * @since 1.0.0
+ * @category scheduler
+ */
+const setScheduler = scheduler => scopedDiscard(fiberRefLocallyScoped(currentScheduler, scheduler));
+
+/**
+ * Sets the provided scheduler for usage in the wrapped effect
+ *
+ * @since 1.0.0
+ * @category scheduler
+ */
+const withScheduler = withScheduler$1;
+
+/**
+ * Sets the scheduling priority used when yielding
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+const withSchedulingPriority = withSchedulingPriority$1;
+
+/**
+ * Sets the maximum number of operations before yield by the default schedulers
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+const withMaxOpsBeforeYield = withMaxOpsBeforeYield$1;
+
+// ---------------------------------------------------------------------------------------
+// clock
+// ---------------------------------------------------------------------------------------
+
+/**
+ * Retreives the `Clock` service from the context
+ *
+ * @since 1.0.0
+ * @category clock
+ */
+const clock = clock$1;
+
+/**
+ * Retreives the `Clock` service from the context and provides it to the
+ * specified effectful function.
+ *
+ * @since 1.0.0
+ * @category clock
+ */
+const clockWith = clockWith$1;
+
+/**
+ * @since 1.0.0
+ * @category clock
+ */
+const setClock = clock => scopedDiscard(fiberRefLocallyScopedWith(currentServices, add(clockTag, clock)));
+
+/**
+ * Sets the implementation of the clock service to the specified value and
+ * restores it to its original value when the scope is closed.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+const withClockScoped = withClockScoped$1;
+
+/**
+ * Executes the specified workflow with the specified implementation of the
+ * clock service.
+ *
+ * @since 1.0.0
+ * @category clock
+ */
+const withClock = withClock$1;
+
+// ---------------------------------------------------------------------------------------
+// delays & timeouts
+// ---------------------------------------------------------------------------------------
+
+/**
+ * Returns an effect that is delayed from this effect by the specified
+ * `Duration`.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+const delay = delay$1;
+
+/**
+ * Returns an effect that suspends for the specified duration. This method is
+ * asynchronous, and does not actually block the fiber executing the effect.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+const sleep = sleep$1;
+
+/**
+ * Returns a new effect that executes this one and times the execution.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+const timed = timed$1;
+
+/**
+ * A more powerful variation of `timed` that allows specifying the clock.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+const timedWith = timedWith$1;
+
+/**
+ * Returns an effect that will timeout this effect, returning `None` if the
+ * timeout elapses before the effect has produced a value; and returning
+ * `Some` of the produced value otherwise.
+ *
+ * If the timeout elapses without producing a value, the running effect will
+ * be safely interrupted.
+ *
+ * WARNING: The effect returned by this method will not itself return until
+ * the underlying effect is actually interrupted. This leads to more
+ * predictable resource utilization. If early return is desired, then instead
+ * of using `effect.timeout(d)`, use `effect.disconnect.timeout(d)`, which
+ * first disconnects the effect's interruption signal before performing the
+ * timeout, resulting in earliest possible return, before an underlying effect
+ * has been successfully interrupted.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+const timeout = timeout$1;
+
+/**
+ * The same as `timeout`, but instead of producing a `None` in the event of
+ * timeout, it will produce the specified error.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+const timeoutFail = timeoutFail$1;
+
+/**
+ * The same as `timeout`, but instead of producing a `None` in the event of
+ * timeout, it will produce the specified failure.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+const timeoutFailCause = timeoutFailCause$1;
+
+/**
+ * Returns an effect that will timeout this effect, returning either the
+ * default value if the timeout elapses before the effect has produced a
+ * value or returning the result of applying the function `onSuccess` to the
+ * success value of the effect.
+ *
+ * If the timeout elapses without producing a value, the running effect will
+ * be safely interrupted.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+const timeoutTo = timeoutTo$1;
+
+// -------------------------------------------------------------------------------------
+// config
+// -------------------------------------------------------------------------------------
+
+/**
+ * Uses the default config provider to load the specified config, or fail with
+ * an error of type Config.Error.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+const config = config$1;
+
+/**
+ * Retrieves the default config provider, and passes it to the specified
+ * function, which may return an effect that uses the provider to perform some
+ * work or compute some value.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+const configProviderWith = configProviderWith$1;
+
+/**
+ * Sets the current `ConfigProvider`.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+const setConfigProvider = setConfigProvider$1;
+
+/**
+ * Executes the specified workflow with the specified configuration provider.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+const withConfigProvider = withConfigProvider$1;
+
+/**
+ * Sets the configuration provider to the specified value and restores it to its original value
+ * when the scope is closed.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+const withConfigProviderScoped = withConfigProviderScoped$1;
+
+// -------------------------------------------------------------------------------------
+// context
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+const context = context$1;
+
+/**
+ * Accesses the context of the effect.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+const contextWith = contextWith$1;
+
+/**
+ * Effectually accesses the context of the effect.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+const contextWithEffect = contextWithEffect$1;
+
+/**
+ * Provides some of the context required to run this effect,
+ * leaving the remainder `R0`.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+const mapInputContext = mapInputContext$1;
+
+/**
+ * Splits the context into two parts, providing one part using the
+ * specified layer/context/runtime and leaving the remainder `R0`
+ *
+ * @since 1.0.0
+ * @category context
+ */
+const provide = effect_provide;
+
+/**
+ * Provides the effect with the single service it requires. If the effect
+ * requires more than one service use `provideContext` instead.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+const provideService = provideService$1;
+
+/**
+ * Provides the effect with the single service it requires. If the effect
+ * requires more than one service use `provideContext` instead.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+const provideServiceEffect = provideServiceEffect$1;
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+const serviceFunction = serviceFunction$1;
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+const serviceFunctionEffect = serviceFunctionEffect$1;
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+const serviceFunctions = serviceFunctions$1;
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+const serviceConstants = serviceConstants$1;
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+const serviceMembers = serviceMembers$1;
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+const serviceOption = tag => contextWith(_ => getOption(_, tag));
+
+/**
+ * Updates the service with the required service entry.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+const updateService = updateService$1;
+
+// -------------------------------------------------------------------------------------
+// do notation
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 1.0.0
+ * @category do notation
+ */
+const Do = Do$1;
+
+/**
+ * Binds an effectful value in a `do` scope
+ *
+ * @since 1.0.0
+ * @category do notation
+ */
+const bind = bind$1;
+
+/**
+ * @category do notation
+ * @since 1.0.0
+ */
+const bindTo = bindTo$1;
+const let_ = bindValue;
+
+// -------------------------------------------------------------------------------------
+// conversions
+// -------------------------------------------------------------------------------------
+
+/**
+ * Returns an effect whose failure and success have been lifted into an
+ * `Either`. The resulting effect cannot fail, because the failure case has
+ * been exposed as part of the `Either` success case.
+ *
+ * This method is useful for recovering from effects that may fail.
+ *
+ * The error parameter of the returned `Effect` is `never`, since it is
+ * guaranteed the effect does not model failure.
+ *
+ * @since 1.0.0
+ * @category conversions
+ */
+const either = either$1;
+
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+const exit = exit$1;
+
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+const intoDeferred = intoDeferred$1;
+
+/**
+ * Executes this effect, skipping the error but returning optionally the
+ * success.
+ *
+ * @since 1.0.0
+ * @category conversions
+ */
+const option = option$1;
+
+// -------------------------------------------------------------------------------------
+// filtering & conditionals
+// -------------------------------------------------------------------------------------
+
+const if_ = if_$1;
+
+/**
+ * Filter the specified effect with the provided function, dying with specified
+ * defect if the predicate fails.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+const filterOrDie = filterOrDie$1;
+
+/**
+ * Filter the specified effect with the provided function, dying with specified
+ * message if the predicate fails.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+const filterOrDieMessage = filterOrDieMessage$1;
+
+/**
+ * Filters the specified effect with the provided function returning the value
+ * of the effect if it is successful, otherwise returns the value of `orElse`.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+const filterOrElse = filterOrElse$1;
+
+/**
+ * Filter the specified effect with the provided function, failing with specified
+ * error if the predicate fails.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+const filterOrFail = filterOrFail$1;
+
+/**
+ * The moral equivalent of `if (!p) exp`.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+const unless = unless$1;
+
+/**
+ * The moral equivalent of `if (!p) exp` when `p` has side-effects.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+const unlessEffect = unlessEffect$1;
+
+/**
+ * The moral equivalent of `if (p) exp`.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+const when = when$1;
+
+/**
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+const whenEffect = whenEffect$1;
+
+/**
+ * Executes this workflow when value of the specified `FiberRef` satisfies the
+ * predicate.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+const whenFiberRef = whenFiberRef$1;
+
+/**
+ * Executes this workflow when the value of the `Ref` satisfies the predicate.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+const whenRef = whenRef$1;
+
+// -------------------------------------------------------------------------------------
+// sequencing
+// -------------------------------------------------------------------------------------
+
+/**
+ * This function is a pipeable operator that maps over an `Effect` value,
+ * flattening the result of the mapping function into a new `Effect` value.
+ *
+ * @param f - The mapping function to apply to the `Effect` value.
+ * This function must return another `Effect` value.
+ *
+ * @returns A new `Effect` value that is the result of flattening the
+ * mapped `Effect` value.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const flatMap = flatMap$1;
+
+/**
+ * @since 1.0.0
+ * @category sequencing
+ */
+const flatten = flatten$1;
+
+/**
+ * Returns an effect that races this effect with all the specified effects,
+ * yielding the value of the first effect to succeed with a value. Losers of
+ * the race will be interrupted immediately
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const raceAll = raceAll$1;
+
+/**
+ * Returns an effect that races this effect with the specified effect,
+ * returning the first successful `A` from the faster side. If one effect
+ * succeeds, the other will be interrupted. If neither succeeds, then the
+ * effect will fail with some error.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const race = race$1;
+
+/**
+ * Returns an effect that races this effect with the specified effect,
+ * yielding the first result to complete, whether by success or failure. If
+ * neither effect completes, then the composed effect will not complete.
+ *
+ * WARNING: The raced effect will safely interrupt the "loser", but will not
+ * resume until the loser has been cleanly terminated. If early return is
+ * desired, then instead of performing `l raceFirst r`, perform
+ * `l.disconnect raceFirst r.disconnect`, which disconnects left and right
+ * interrupt signal, allowing a fast return, with interruption performed
+ * in the background.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const raceFirst = raceFirst$1;
+
+/**
+ * Returns an effect that races this effect with the specified effect, calling
+ * the specified finisher as soon as one result or the other has been computed.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const raceWith = raceWith$1;
+
+/**
+ * Summarizes a effect by computing some value before and after execution, and
+ * then combining the values to produce a summary, together with the result of
+ * execution.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const summarized = summarized$1;
+
+/**
+ * @since 1.0.0
+ * @category sequencing
+ */
+const tap = tap$1;
+
+/**
+ * Returns an effect that effectfully "peeks" at the failure or success of
+ * this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const tapBoth = tapBoth$1;
+
+/**
+ * Returns an effect that effectually "peeks" at the defect of this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const tapDefect = tapDefect$1;
+
+/**
+ * Returns an effect that effectfully "peeks" at the failure of this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const tapError = tapError$1;
+
+/**
+ * Returns an effect that effectfully "peeks" at the specific tagged failure of this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const tapErrorTag = tapErrorTag$1;
+
+/**
+ * Returns an effect that effectually "peeks" at the cause of the failure of
+ * this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+const tapErrorCause = tapErrorCause$1;
+
+// -------------------------------------------------------------------------------------
+// repetition / recursion
+// -------------------------------------------------------------------------------------
+
+/**
+ * Repeats this effect forever (until the first error).
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const forever = forever$1;
+
+/**
+ * Iterates with the specified effectual function. The moral equivalent of:
+ *
+ * ```ts
+ * let s = initial
+ *
+ * while (cont(s)) {
+ *   s = body(s)
+ * }
+ *
+ * return s
+ * ```
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const iterate = iterate$1;
+
+/**
+ * Loops with the specified effectual function, collecting the results into a
+ * list. The moral equivalent of:
+ *
+ * ```ts
+ * let s  = initial
+ * let as = [] as readonly A[]
+ *
+ * while (cont(s)) {
+ *   as = [body(s), ...as]
+ *   s  = inc(s)
+ * }
+ *
+ * A.reverse(as)
+ * ```
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const loop = loop$1;
+
+/**
+ * Returns a new effect that repeats this effect according to the specified
+ * schedule or until the first failure. Scheduled recurrences are in addition
+ * to the first execution, so that `io.repeat(Schedule.once)` yields an effect
+ * that executes `io`, and then if that succeeds, executes `io` an additional
+ * time.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const repeat = repeat_Effect;
+
+/**
+ * Returns a new effect that repeats this effect the specified number of times
+ * or until the first failure. Repeats are in addition to the first execution,
+ * so that `io.repeatN(1)` yields an effect that executes `io`, and then if
+ * that succeeds, executes `io` an additional time.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const repeatN = repeatN$1;
+
+/**
+ * Returns a new effect that repeats this effect according to the specified
+ * schedule or until the first failure, at which point, the failure value and
+ * schedule output are passed to the specified handler.
+ *
+ * Scheduled recurrences are in addition to the first execution, so that
+ * `pipe(effect, Effect.repeat(Schedule.once()))` yields an effect that executes
+ * `effect`, and then if that succeeds, executes `effect` an additional time.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const repeatOrElse = repeatOrElse_Effect;
+
+/**
+ * Repeats this effect until its value satisfies the specified predicate or
+ * until the first failure.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const repeatUntil = repeatUntil_Effect;
+
+/**
+ * Repeats this effect until its value satisfies the specified effectful
+ * predicate or until the first failure.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const repeatUntilEffect = repeatUntilEffect_Effect;
+
+/**
+ * Repeats this effect while its value satisfies the specified effectful
+ * predicate or until the first failure.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const repeatWhile = repeatWhile_Effect;
+
+/**
+ * Repeats this effect while its value satisfies the specified effectful
+ * predicate or until the first failure.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const repeatWhileEffect = repeatWhileEffect_Effect;
+
+/**
+ * Runs this effect according to the specified schedule.
+ *
+ * See `scheduleFrom` for a variant that allows the schedule's decision to
+ * depend on the result of this effect.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const schedule = schedule_Effect;
+
+/**
+ * Runs this effect according to the specified schedule in a new fiber
+ * attached to the current scope.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const scheduleForked = scheduleForked$1;
+
+/**
+ * Runs this effect according to the specified schedule starting from the
+ * specified input value.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const scheduleFrom = scheduleFrom_Effect;
+
+/**
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+const whileLoop = whileLoop$1;
+
+// -------------------------------------------------------------------------------------
+// fiber refs
+// -------------------------------------------------------------------------------------
+
+/**
+ * Returns a collection of all `FiberRef` values for the fiber running this
+ * effect.
+ *
+ * @since 1.0.0
+ * @category fiber refs
+ */
+const getFiberRefs = fiberRefs;
+
+/**
+ * Inherits values from all `FiberRef` instances into current fiber.
+ *
+ * @since 1.0.0
+ * @category fiber refs
+ */
+const inheritFiberRefs = inheritFiberRefs$1;
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+const locally = fiberRefLocally;
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+const locallyWith = fiberRefLocallyWith;
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+const locallyScoped = fiberRefLocallyScoped;
+
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+const locallyScopedWith = fiberRefLocallyScopedWith;
+
+/**
+ * Applies the specified changes to the `FiberRef` values for the fiber
+ * running this workflow.
+ *
+ * @since 1.0.0
+ * @category fiber refs
+ */
+const patchFiberRefs = patchFiberRefs$1;
+
+/**
+ * Sets the `FiberRef` values for the fiber running this effect to the values
+ * in the specified collection of `FiberRef` values.
+ *
+ * @since 1.0.0
+ * @category fiber refs
+ */
+const setFiberRefs = setFiberRefs$1;
+
+/**
+ * Updates the `FiberRef` values for the fiber running this effect using the
+ * specified function.
+ *
+ * @since 1.0.0
+ * @category fiber refs
+ */
+const updateFiberRefs = updateFiberRefs$1;
+
+// -------------------------------------------------------------------------------------
+// getters & folding
+// -------------------------------------------------------------------------------------
+
+/**
+ * Returns `true` if this effect is a failure, `false` otherwise.
+ *
+ * @since 1.0.0
+ * @category getters & folding
+ */
+const isFailure = isFailure$1;
+
+/**
+ * Returns `true` if this effect is a success, `false` otherwise.
+ *
+ * @since 1.0.0
+ * @category getters & folding
+ */
+const isSuccess = isSuccess$1;
+
+/**
+ * Folds over the failure value or the success value to yield an effect that
+ * does not fail, but succeeds with the value returned by the left or right
+ * function passed to `match`.
+ *
+ * @since 1.0.0
+ * @category getters & folding
+ */
+const match = match$1;
+
+/**
+ * @since 1.0.0
+ * @category getters & folding
+ */
+const matchCause = matchCause$1;
+
+/**
+ * @since 1.0.0
+ * @category getters & folding
+ */
+const matchCauseEffect = matchCauseEffect$1;
+
+/**
+ * @since 1.0.0
+ * @category getters & folding
+ */
+const matchEffect = matchEffect$1;
+
+// -------------------------------------------------------------------------------------
+// logging
+// -------------------------------------------------------------------------------------
+
+/**
+ * Logs the specified message or cause at the current log level.
+ *
+ * You can set the current log level using `FiberRef.currentLogLevel`.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const log = log$1;
+
+/**
+ * Logs the specified message or cause at the Trace log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const logTrace = logTrace$1;
+
+/**
+ * Logs the specified message or cause at the Debug log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const logDebug = logDebug$1;
+
+/**
+ * Logs the specified message or cause at the Info log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const logInfo = logInfo$1;
+
+/**
+ * Logs the specified message or cause at the Warning log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const logWarning = logWarning$1;
+
+/**
+ * Logs the specified message or cause at the Error log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const logError = logError$1;
+
+/**
+ * Logs the specified message or cause at the Fatal log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const logFatal = logFatal$1;
+
+/**
+ * Adjusts the label for the current logging span.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const withLogSpan = withLogSpan$1;
+
+/**
+ * Annotates each log in this effect with the specified log annotation.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const annotateLogs = annotateLogs$1;
+
+/**
+ * Retrieves the log annotations associated with the current scope.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const logAnnotations = logAnnotations$1;
+
+/**
+ * Decides wether child fibers will report or not unhandled errors via the logger
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+const withUnhandledErrorLogLevel = withUnhandledErrorLogLevel$1;
+
+/**
+ * @since 1.0.0
+ * @category logging
+ */
+const setUnhandledErrorLogLevel = level => scopedDiscard(fiberRefLocallyScoped(currentUnhandledErrorLogLevel, level));
+
+// -------------------------------------------------------------------------------------
+// alternatives
+// -------------------------------------------------------------------------------------
+
+/**
+ * Translates effect failure into death of the fiber, making all failures
+ * unchecked and not a part of the type of the effect.
+ *
+ * @since 1.0.0
+ * @category alternatives
+ */
+const orDie = orDie$1;
+
+/**
+ * Keeps none of the errors, and terminates the fiber with them, using the
+ * specified function to convert the `E` into a `Throwable`.
+ *
+ * @since 1.0.0
+ * @category alternatives
+ */
+const orDieWith = orDieWith$1;
+
+/**
+ * Executes this effect and returns its value, if it succeeds, but otherwise
+ * executes the specified effect.
+ *
+ * @since 1.0.0
+ * @category alternatives
+ */
+const orElse = orElse$1;
+
+/**
+ * Executes this effect and returns its value, if it succeeds, but otherwise
+ * fails with the specified error.
+ *
+ * @since 1.0.0
+ * @category alternatives
+ */
+const orElseFail = orElseFail$1;
+
+/**
+ * Executes this effect and returns its value, if it succeeds, but
+ * otherwise succeeds with the specified value.
+ *
+ * @since 1.0.0
+ * @category alternatives
+ */
+const orElseSucceed = orElseSucceed$1;
+
+// -------------------------------------------------------------------------------------
+// random
+// -------------------------------------------------------------------------------------
+
+/**
+ * Retreives the `Random` service from the context.
+ *
+ * @since 1.0.0
+ * @category random
+ */
+const random = random$1;
+
+/**
+ * Retreives the `Random` service from the context and uses it to run the
+ * specified workflow.
+ *
+ * @since 1.0.0
+ * @category random
+ */
+const randomWith = randomWith$1;
+
+// -------------------------------------------------------------------------------------
+// runtime
+// -------------------------------------------------------------------------------------
+
+/**
+ * Returns an effect that accesses the runtime, which can be used to
+ * (unsafely) execute tasks. This is useful for integration with legacy code
+ * that must call back into Effect code.
+ *
+ * @since 1.0.0
+ * @category runtime
+ */
+const runtime = runtime$1;
+
+/**
+ * Retrieves an effect that succeeds with the current runtime flags, which
+ * govern behavior and features of the runtime system.
+ *
+ * @since 1.0.0
+ * @category runtime
+ */
+const getRuntimeFlags = runtimeFlags;
+
+/**
+ * @since 1.0.0
+ * @category runtime
+ */
+const patchRuntimeFlags = updateRuntimeFlags;
+
+/**
+ * @since 1.0.0
+ * @category runtime
+ */
+const withRuntimeFlagsPatch = withRuntimeFlags;
+
+/**
+ * @since 1.0.0
+ * @category runtime
+ */
+const withRuntimeFlagsPatchScoped = withRuntimeFlagsScoped;
+
+// -------------------------------------------------------------------------------------
+// metrics
+// -------------------------------------------------------------------------------------
+
+/**
+ * Tags each metric in this effect with the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+const tagMetrics = tagMetrics$1;
+
+/**
+ * Tags each metric in this effect with the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+const labelMetrics = labelMetrics$1;
+
+/**
+ * Tags each metric in this effect with the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+const labelMetricsSet = labelMetricsSet$1;
+
+/**
+ * Tags each metric in a scope with a the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+const tagMetricsScoped = tagMetricsScoped$1;
+
+/**
+ * Tags each metric in a scope with a the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+const labelMetricsScoped = labelMetricsScoped$1;
+
+/**
+ * Tags each metric in a scope with a the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+const labelMetricsScopedSet = labelMetricsScopedSet$1;
+
+/**
+ * Retrieves the metric labels associated with the current scope.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+const metricLabels = metricLabels$1;
+
+/**
+ * @since 1.0.0
+ * @category metrics
+ */
+const withMetric = withMetric$1;
+
+// -------------------------------------------------------------------------------------
+// unify
+// -------------------------------------------------------------------------------------
+
+/**
+ * Used to unify functions that would otherwise return `Effect<A, B, C> | Effect<D, E, F>`
+ *
+ * @category unify
+ * @since 1.0.0
+ */
+const unifiedFn = unified$1;
+
+/**
+ * Used to unify effects that would otherwise be `Effect<A, B, C> | Effect<D, E, F>`
+ *
+ * @category unify
+ * @since 1.0.0
+ */
+const unified = identity;
+
+// -------------------------------------------------------------------------------------
+// semaphore
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category semaphore
+ * @since 1.0.0
+ */
+/**
+ * @category semaphore
+ * @since 1.0.0
+ */
+/**
+ * Unsafely creates a new Semaphore
+ *
+ * @since 1.0.0
+ * @category semaphore
+ */
+const unsafeMakeSemaphore = unsafeMakeSemaphore$1;
+
+/**
+ * Creates a new Semaphore
+ *
+ * @since 1.0.0
+ * @category semaphore
+ */
+const makeSemaphore = makeSemaphore$1;
+
+// -------------------------------------------------------------------------------------
+// execution
+// -------------------------------------------------------------------------------------
+
+/**
+ * @since 1.0.0
+ * @category execution
+ */
+const runFork = unsafeForkEffect;
+
+/**
+ * @since 1.0.0
+ * @category execution
+ */
+const runCallback = unsafeRunEffect;
+
+/**
+ * Runs an `Effect` workflow, returning a `Promise` which resolves with the
+ * result of the workflow or rejects with an error.
+ *
+ * @since 1.0.0
+ * @category execution
+ */
+const runPromise = unsafeRunPromiseEffect;
+
+/**
+ * Runs an `Effect` workflow, returning a `Promise` which resolves with the
+ * `Exit` value of the workflow.
+ *
+ * @since 1.0.0
+ * @category execution
+ */
+const runPromiseExit = unsafeRunPromiseExitEffect;
+
+/**
+ * @since 1.0.0
+ * @category execution
+ */
+const runSync = unsafeRunSyncEffect;
+
+/**
+ * @since 1.0.0
+ * @category execution
+ */
+const runSyncExit = unsafeRunSyncExitEffect;
+
+// -------------------------------------------------------------------------------------
+// zipping
+// -------------------------------------------------------------------------------------
+
+/**
+ * Sequentially zips the this result with the specified result. Combines both
+ * `Cause`s when both effects fail.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+const validate = validate$1;
+
+/**
+ * Sequentially zips this effect with the specified effect using the specified
+ * combiner function. Combines the causes in case both effect fail.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+const validateWith = validateWith$1;
+
+/**
+ * @since 1.0.0
+ * @category zipping
+ */
+const zip = zipOptions;
+
+/**
+ * @since 1.0.0
+ * @category zipping
+ */
+const zipLeft = zipLeftOptions;
+
+/**
+ * @since 1.0.0
+ * @category zipping
+ */
+const zipRight = zipRightOptions;
+
+/**
+ * @since 1.0.0
+ * @category zipping
+ */
+const zipWith = zipWithOptions;
+
+// -------------------------------------------------------------------------------------
+// requests & batching
+// -------------------------------------------------------------------------------------
+
+/**
+ * @category requests & batching
+ * @since 1.0.0
+ */
+const blocked = blocked$1;
+
+/**
+ * @category requests & batching
+ * @since 1.0.0
+ */
+const runRequestBlock = runRequestBlock$1;
+
+/**
+ * @category requests & batching
+ * @since 1.0.0
+ */
+const step = step$1;
+
+/**
+ * @category requests & batching
+ * @since 1.0.0
+ */
+const flatMapStep = flatMapStep$1;
+
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+const request = fromRequest;
+
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+const cacheRequestResult = cacheRequest;
+
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+const withRequestBatching = withRequestBatching$1;
+
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+const setRequestBatching = requestBatching => scopedDiscard(fiberRefLocallyScoped(currentRequestBatching, requestBatching));
+
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+const setRequestCaching = requestCaching => scopedDiscard(fiberRefLocallyScoped(currentCacheEnabled, requestCaching));
+
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+const setRequestCache = cache => scopedDiscard(isEffect$1(cache) ? flatMap$1(cache, x => fiberRefLocallyScoped(currentCache, x)) : fiberRefLocallyScoped(currentCache, cache));
+
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+const withRequestCaching = withRequestCaching$1;
+
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+const withRequestCache = withRequestCache$1;
+
+// -------------------------------------------------------------------------------------
+// tracing
+// -------------------------------------------------------------------------------------
+
+/**
+ * Create a Layer that sets the current Tracer
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const setTracer = setTracer$1;
+
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+const tracer = tracer$1;
+
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+const tracerWith = tracerWith$1;
+
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+const withTracer = withTracer$1;
+
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+const withTracerScoped = withTracerScoped$1;
+
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+const withTracerTiming = withTracerTiming$1;
+
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+const setTracerTiming = enabled => scopedDiscard(fiberRefLocallyScoped(currentTracerTimingEnabled, enabled));
+
+/**
+ * Adds an annotation to each span in this effect.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const annotateSpans = annotateSpans$1;
+
+/**
+ * Adds an annotation to the current span if available
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const annotateCurrentSpan = annotateCurrentSpan$1;
+
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+const currentSpan = currentSpan$1;
+
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+const currentParentSpan = currentParentSpan$1;
+
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+const spanAnnotations = spanAnnotations$1;
+
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+const spanLinks = spanLinks$1;
+
+/**
+ * For all spans in this effect, add a link with the provided span.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const linkSpans = linkSpans$1;
+
+/**
+ * Create a new span for tracing.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const makeSpan = makeSpan$1;
+
+/**
+ * Adds the provided span to the span stack.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const setParentSpan = setParentSpan$1;
+
+/**
+ * Create and add a span to the current span stack.
+ *
+ * The span is ended when the Layer is released.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const setSpan = setSpan$1;
+
+/**
+ * Create a new span for tracing, and automatically close it when the effect
+ * completes.
+ *
+ * The span is not added to the current span stack, so no child spans will be
+ * created for it.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const useSpan = useSpan$1;
+
+/**
+ * Create a new span for tracing, and automatically close it when the Scope
+ * finalizes.
+ *
+ * The span is not added to the current span stack, so no child spans will be
+ * created for it.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const useSpanScoped = useSpanScoped$1;
+
+/**
+ * Wraps the effect with a new span for tracing.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const withSpan = withSpan$1;
+
+/**
+ * Create and add a span to the current span stack.
+ *
+ * The span is ended when the Scope is finalized.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const withSpanScoped = withSpanScoped$1;
+
+/**
+ * Adds the provided span to the current span stack.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const withParentSpan = withParentSpan$1;
+
+/**
+ * Adds the provided span to the current span stack.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+const withParentSpanScoped = withParentSpanScoped$1;
+
+// -------------------------------------------------------------------------------------
+// optionality
+// -------------------------------------------------------------------------------------
+
+/**
+ * Returns an effect that errors with `NoSuchElementException` if the value is
+ * null or undefined, otherwise succeeds with the value.
+ *
+ * @since 1.0.0
+ * @category optionality
+ */
+const fromNullable = fromNullable$1;
+
+/**
+ * Wraps the success value of this effect with `Option.some`, and maps
+ * `Cause.NoSuchElementException` to `Option.none`.
+ *
+ * @since 1.0.0
+ * @category optionality
+ */
+const optionFromOptional = optionFromOptional$1;
+
+var Effect = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  EffectTypeId: EffectTypeId,
+  isEffect: isEffect,
+  cachedWithTTL: cachedWithTTL,
+  cachedInvalidateWithTTL: cachedInvalidateWithTTL,
+  cached: cached,
+  cachedFunction: cachedFunction,
+  once: once,
+  all: all,
+  allWith: allWith,
+  allSuccesses: allSuccesses,
+  dropUntil: dropUntil,
+  dropWhile: dropWhile,
+  every: every,
+  exists: exists,
+  filter: filter,
+  findFirst: findFirst,
+  firstSuccessOf: firstSuccessOf,
+  forEach: forEach,
+  head: head,
+  mergeAll: mergeAll,
+  partition: partition,
+  reduce: reduce,
+  reduceEffect: reduceEffect,
+  reduceRight: reduceRight,
+  reduceWhile: reduceWhile,
+  replicate: replicate,
+  replicateEffect: replicateEffect,
+  takeUntil: takeUntil,
+  takeWhile: takeWhile,
+  validateAll: validateAll,
+  validateFirst: validateFirst,
+  async: async,
+  asyncEffect: asyncEffect,
+  asyncOption: asyncOption,
+  asyncEither: asyncEither,
+  fail: fail,
+  failSync: failSync,
+  failCause: failCause,
+  failCauseSync: failCauseSync,
+  die: die,
+  dieMessage: dieMessage,
+  dieSync: dieSync,
+  gen: gen,
+  never: never,
+  none: none,
+  promise: promise,
+  succeed: succeed,
+  succeedNone: succeedNone,
+  succeedSome: succeedSome,
+  suspend: suspend,
+  sync: sync,
+  unit: unit,
+  yieldNow: yieldNow,
+  'catch': _catch,
+  catchAll: catchAll,
+  catchAllCause: catchAllCause,
+  catchAllDefect: catchAllDefect,
+  catchIf: catchIf,
+  catchSome: catchSome,
+  catchSomeCause: catchSomeCause,
+  catchSomeDefect: catchSomeDefect,
+  catchTag: catchTag,
+  catchTags: catchTags,
+  cause: cause,
+  eventually: eventually,
+  ignore: ignore,
+  ignoreLogged: ignoreLogged,
+  parallelErrors: parallelErrors,
+  sandbox: sandbox,
+  retry: retry,
+  retryN: retryN,
+  retryOrElse: retryOrElse,
+  retryUntil: retryUntil,
+  retryUntilEffect: retryUntilEffect,
+  retryWhile: retryWhile,
+  retryWhileEffect: retryWhileEffect,
+  'try': try_,
+  tryMap: tryMap,
+  tryMapPromise: tryMapPromise,
+  tryPromise: tryPromise,
+  unsandbox: unsandbox,
+  allowInterrupt: allowInterrupt,
+  checkInterruptible: checkInterruptible,
+  disconnect: disconnect,
+  interrupt: interrupt,
+  interruptWith: interruptWith,
+  interruptible: interruptible,
+  interruptibleMask: interruptibleMask,
+  onInterrupt: onInterrupt,
+  uninterruptible: uninterruptible,
+  uninterruptibleMask: uninterruptibleMask,
+  as: as,
+  asSome: asSome,
+  asSomeError: asSomeError,
+  asUnit: asUnit,
+  flip: flip,
+  flipWith: flipWith,
+  map: map,
+  mapAccum: mapAccum,
+  mapBoth: mapBoth,
+  mapError: mapError,
+  mapErrorCause: mapErrorCause,
+  merge: merge,
+  negate: negate,
+  acquireRelease: acquireRelease,
+  acquireReleaseInterruptible: acquireReleaseInterruptible,
+  acquireUseRelease: acquireUseRelease,
+  addFinalizer: addFinalizer,
+  ensuring: ensuring,
+  onError: onError,
+  onExit: onExit,
+  parallelFinalizers: parallelFinalizers,
+  finalizersMask: finalizersMask,
+  sequentialFinalizers: sequentialFinalizers,
+  scope: scope,
+  scopeWith: scopeWith,
+  scoped: scoped,
+  using: using,
+  withEarlyRelease: withEarlyRelease,
+  awaitAllChildren: awaitAllChildren,
+  daemonChildren: daemonChildren,
+  descriptor: descriptor,
+  descriptorWith: descriptorWith,
+  diffFiberRefs: diffFiberRefs,
+  ensuringChild: ensuringChild,
+  ensuringChildren: ensuringChildren,
+  fiberId: fiberId,
+  fiberIdWith: fiberIdWith,
+  fork: fork,
+  forkDaemon: forkDaemon,
+  forkAll: forkAll,
+  forkIn: forkIn,
+  forkScoped: forkScoped,
+  forkWithErrorHandler: forkWithErrorHandler,
+  fromFiber: fromFiber,
+  fromFiberEffect: fromFiberEffect,
+  supervised: supervised,
+  transplant: transplant,
+  withConcurrency: withConcurrency,
+  setScheduler: setScheduler,
+  withScheduler: withScheduler,
+  withSchedulingPriority: withSchedulingPriority,
+  withMaxOpsBeforeYield: withMaxOpsBeforeYield,
+  clock: clock,
+  clockWith: clockWith,
+  setClock: setClock,
+  withClockScoped: withClockScoped,
+  withClock: withClock,
+  delay: delay,
+  sleep: sleep,
+  timed: timed,
+  timedWith: timedWith,
+  timeout: timeout,
+  timeoutFail: timeoutFail,
+  timeoutFailCause: timeoutFailCause,
+  timeoutTo: timeoutTo,
+  config: config,
+  configProviderWith: configProviderWith,
+  setConfigProvider: setConfigProvider,
+  withConfigProvider: withConfigProvider,
+  withConfigProviderScoped: withConfigProviderScoped,
+  context: context,
+  contextWith: contextWith,
+  contextWithEffect: contextWithEffect,
+  mapInputContext: mapInputContext,
+  provide: provide,
+  provideService: provideService,
+  provideServiceEffect: provideServiceEffect,
+  serviceFunction: serviceFunction,
+  serviceFunctionEffect: serviceFunctionEffect,
+  serviceFunctions: serviceFunctions,
+  serviceConstants: serviceConstants,
+  serviceMembers: serviceMembers,
+  serviceOption: serviceOption,
+  updateService: updateService,
+  Do: Do,
+  bind: bind,
+  bindTo: bindTo,
+  'let': let_,
+  either: either,
+  exit: exit,
+  intoDeferred: intoDeferred,
+  option: option,
+  'if': if_,
+  filterOrDie: filterOrDie,
+  filterOrDieMessage: filterOrDieMessage,
+  filterOrElse: filterOrElse,
+  filterOrFail: filterOrFail,
+  unless: unless,
+  unlessEffect: unlessEffect,
+  when: when,
+  whenEffect: whenEffect,
+  whenFiberRef: whenFiberRef,
+  whenRef: whenRef,
+  flatMap: flatMap,
+  flatten: flatten,
+  raceAll: raceAll,
+  race: race,
+  raceFirst: raceFirst,
+  raceWith: raceWith,
+  summarized: summarized,
+  tap: tap,
+  tapBoth: tapBoth,
+  tapDefect: tapDefect,
+  tapError: tapError,
+  tapErrorTag: tapErrorTag,
+  tapErrorCause: tapErrorCause,
+  forever: forever,
+  iterate: iterate,
+  loop: loop,
+  repeat: repeat,
+  repeatN: repeatN,
+  repeatOrElse: repeatOrElse,
+  repeatUntil: repeatUntil,
+  repeatUntilEffect: repeatUntilEffect,
+  repeatWhile: repeatWhile,
+  repeatWhileEffect: repeatWhileEffect,
+  schedule: schedule,
+  scheduleForked: scheduleForked,
+  scheduleFrom: scheduleFrom,
+  whileLoop: whileLoop,
+  getFiberRefs: getFiberRefs,
+  inheritFiberRefs: inheritFiberRefs,
+  locally: locally,
+  locallyWith: locallyWith,
+  locallyScoped: locallyScoped,
+  locallyScopedWith: locallyScopedWith,
+  patchFiberRefs: patchFiberRefs,
+  setFiberRefs: setFiberRefs,
+  updateFiberRefs: updateFiberRefs,
+  isFailure: isFailure,
+  isSuccess: isSuccess,
+  match: match,
+  matchCause: matchCause,
+  matchCauseEffect: matchCauseEffect,
+  matchEffect: matchEffect,
+  log: log,
+  logTrace: logTrace,
+  logDebug: logDebug,
+  logInfo: logInfo,
+  logWarning: logWarning,
+  logError: logError,
+  logFatal: logFatal,
+  withLogSpan: withLogSpan,
+  annotateLogs: annotateLogs,
+  logAnnotations: logAnnotations,
+  withUnhandledErrorLogLevel: withUnhandledErrorLogLevel,
+  setUnhandledErrorLogLevel: setUnhandledErrorLogLevel,
+  orDie: orDie,
+  orDieWith: orDieWith,
+  orElse: orElse,
+  orElseFail: orElseFail,
+  orElseSucceed: orElseSucceed,
+  random: random,
+  randomWith: randomWith,
+  runtime: runtime,
+  getRuntimeFlags: getRuntimeFlags,
+  patchRuntimeFlags: patchRuntimeFlags,
+  withRuntimeFlagsPatch: withRuntimeFlagsPatch,
+  withRuntimeFlagsPatchScoped: withRuntimeFlagsPatchScoped,
+  tagMetrics: tagMetrics,
+  labelMetrics: labelMetrics,
+  labelMetricsSet: labelMetricsSet,
+  tagMetricsScoped: tagMetricsScoped,
+  labelMetricsScoped: labelMetricsScoped,
+  labelMetricsScopedSet: labelMetricsScopedSet,
+  metricLabels: metricLabels,
+  withMetric: withMetric,
+  unifiedFn: unifiedFn,
+  unified: unified,
+  unsafeMakeSemaphore: unsafeMakeSemaphore,
+  makeSemaphore: makeSemaphore,
+  runFork: runFork,
+  runCallback: runCallback,
+  runPromise: runPromise,
+  runPromiseExit: runPromiseExit,
+  runSync: runSync,
+  runSyncExit: runSyncExit,
+  validate: validate,
+  validateWith: validateWith,
+  zip: zip,
+  zipLeft: zipLeft,
+  zipRight: zipRight,
+  zipWith: zipWith,
+  blocked: blocked,
+  runRequestBlock: runRequestBlock,
+  step: step,
+  flatMapStep: flatMapStep,
+  request: request,
+  cacheRequestResult: cacheRequestResult,
+  withRequestBatching: withRequestBatching,
+  setRequestBatching: setRequestBatching,
+  setRequestCaching: setRequestCaching,
+  setRequestCache: setRequestCache,
+  withRequestCaching: withRequestCaching,
+  withRequestCache: withRequestCache,
+  setTracer: setTracer,
+  tracer: tracer,
+  tracerWith: tracerWith,
+  withTracer: withTracer,
+  withTracerScoped: withTracerScoped,
+  withTracerTiming: withTracerTiming,
+  setTracerTiming: setTracerTiming,
+  annotateSpans: annotateSpans,
+  annotateCurrentSpan: annotateCurrentSpan,
+  currentSpan: currentSpan,
+  currentParentSpan: currentParentSpan,
+  spanAnnotations: spanAnnotations,
+  spanLinks: spanLinks,
+  linkSpans: linkSpans,
+  makeSpan: makeSpan,
+  setParentSpan: setParentSpan,
+  setSpan: setSpan,
+  useSpan: useSpan,
+  useSpanScoped: useSpanScoped,
+  withSpan: withSpan,
+  withSpanScoped: withSpanScoped,
+  withParentSpan: withParentSpan,
+  withParentSpanScoped: withParentSpanScoped,
+  fromNullable: fromNullable,
+  optionFromOptional: optionFromOptional
+});
+
+export { contextWith as $, forkScoped as A, addFinalizer as B, zipLeft as C, all as D, EffectTypeId as E, dieMessage as F, acquireUseRelease as G, intoDeferred as H, tapErrorCause as I, tap as J, context as K, matchCause as L, gen as M, acquireRelease as N, makeSemaphore as O, interruptible as P, asUnit as Q, raceFirst as R, forever as S, raceWith as T, race as U, when as V, repeatWhile as W, never as X, withSpanScoped as Y, repeatUntil as Z, takeWhile as _, async as a, _catch as a$, filter as a0, dropUntil as a1, dropWhile as a2, catchSomeCause as a3, die as a4, fail as a5, mapBoth as a6, mapError as a7, runtime as a8, match as a9, cachedWithTTL as aA, cachedInvalidateWithTTL as aB, cached as aC, cachedFunction as aD, once as aE, allWith as aF, allSuccesses as aG, every as aH, exists as aI, firstSuccessOf as aJ, head as aK, mergeAll as aL, partition as aM, reduceEffect as aN, reduceRight as aO, reduceWhile as aP, replicate as aQ, replicateEffect as aR, takeUntil as aS, validateAll as aT, validateFirst as aU, asyncEffect as aV, asyncOption as aW, asyncEither as aX, none as aY, succeedSome as aZ, yieldNow as a_, onError as aa, transplant as ab, dieSync as ac, failSync as ad, failCauseSync as ae, findFirst as af, tryPromise as ag, promise as ah, orDie as ai, matchEffect as aj, timeoutFail as ak, timeoutFailCause as al, runSync as am, catchTags as an, runPromise as ao, forkIn as ap, reduce as aq, orElse as ar, catchAll as as, asSome as at, succeedNone as au, fork as av, fiberIdWith as aw, interrupt as ax, Effect as ay, acquireReleaseInterruptible as az, as as b, withClock as b$, catchAllDefect as b0, catchIf as b1, catchSome as b2, catchSomeDefect as b3, catchTag as b4, cause as b5, eventually as b6, ignoreLogged as b7, parallelErrors as b8, sandbox as b9, finalizersMask as bA, sequentialFinalizers as bB, scopeWith as bC, using as bD, withEarlyRelease as bE, awaitAllChildren as bF, daemonChildren as bG, descriptor as bH, descriptorWith as bI, diffFiberRefs as bJ, ensuringChild as bK, ensuringChildren as bL, fiberId as bM, forkAll as bN, forkWithErrorHandler as bO, fromFiber as bP, fromFiberEffect as bQ, supervised as bR, withConcurrency as bS, setScheduler as bT, withScheduler as bU, withSchedulingPriority as bV, withMaxOpsBeforeYield as bW, clock as bX, clockWith as bY, setClock as bZ, withClockScoped as b_, retry as ba, retryN as bb, retryOrElse as bc, retryUntil as bd, retryUntilEffect as be, retryWhile as bf, retryWhileEffect as bg, try_ as bh, tryMap as bi, tryMapPromise as bj, unsandbox as bk, allowInterrupt as bl, checkInterruptible as bm, disconnect as bn, interruptWith as bo, interruptibleMask as bp, onInterrupt as bq, asSomeError as br, flip as bs, flipWith as bt, mapAccum as bu, mapErrorCause as bv, merge as bw, negate as bx, onExit as by, parallelFinalizers as bz, catchAllCause as c, updateFiberRefs as c$, delay as c0, sleep as c1, timed as c2, timedWith as c3, timeout as c4, timeoutTo as c5, config as c6, configProviderWith as c7, setConfigProvider as c8, withConfigProvider as c9, whenFiberRef as cA, whenRef as cB, raceAll as cC, summarized as cD, tapBoth as cE, tapDefect as cF, tapError as cG, tapErrorTag as cH, iterate as cI, loop as cJ, repeat as cK, repeatN as cL, repeatOrElse as cM, repeatUntilEffect as cN, repeatWhileEffect as cO, schedule as cP, scheduleForked as cQ, scheduleFrom as cR, whileLoop as cS, getFiberRefs as cT, inheritFiberRefs as cU, locally as cV, locallyWith as cW, locallyScoped as cX, locallyScopedWith as cY, patchFiberRefs as cZ, setFiberRefs as c_, withConfigProviderScoped as ca, contextWithEffect as cb, mapInputContext as cc, provideService as cd, provideServiceEffect as ce, serviceFunction as cf, serviceFunctionEffect as cg, serviceFunctions as ch, serviceConstants as ci, serviceMembers as cj, serviceOption as ck, updateService as cl, Do as cm, bind as cn, bindTo as co, let_ as cp, either as cq, option as cr, if_ as cs, filterOrDie as ct, filterOrDieMessage as cu, filterOrElse as cv, filterOrFail as cw, unless as cx, unlessEffect as cy, whenEffect as cz, flatten as d, currentParentSpan as d$, isFailure as d0, isSuccess as d1, log as d2, logTrace as d3, logDebug as d4, logInfo as d5, logWarning as d6, logError as d7, logFatal as d8, withLogSpan as d9, runCallback as dA, runPromiseExit as dB, runSyncExit as dC, validate as dD, validateWith as dE, blocked as dF, runRequestBlock as dG, step as dH, flatMapStep as dI, request as dJ, cacheRequestResult as dK, withRequestBatching as dL, setRequestBatching as dM, setRequestCaching as dN, setRequestCache as dO, withRequestCaching as dP, withRequestCache as dQ, setTracer as dR, tracer as dS, tracerWith as dT, withTracer as dU, withTracerScoped as dV, withTracerTiming as dW, setTracerTiming as dX, annotateSpans as dY, annotateCurrentSpan as dZ, currentSpan as d_, annotateLogs as da, logAnnotations as db, withUnhandledErrorLogLevel as dc, setUnhandledErrorLogLevel as dd, orDieWith as de, orElseFail as df, orElseSucceed as dg, random as dh, randomWith as di, getRuntimeFlags as dj, patchRuntimeFlags as dk, withRuntimeFlagsPatch as dl, withRuntimeFlagsPatchScoped as dm, tagMetrics as dn, labelMetrics as dp, labelMetricsSet as dq, tagMetricsScoped as dr, labelMetricsScoped as ds, labelMetricsScopedSet as dt, metricLabels as du, withMetric as dv, unifiedFn as dw, unified as dx, unsafeMakeSemaphore as dy, runFork as dz, unit as e, spanAnnotations as e0, spanLinks as e1, linkSpans as e2, makeSpan as e3, setParentSpan as e4, setSpan as e5, useSpan as e6, useSpanScoped as e7, withSpan as e8, withParentSpan as e9, withParentSpanScoped as ea, fromNullable as eb, optionFromOptional as ec, failCause as f, ignore as g, exit as h, isEffect as i, zipRight as j, flatMap as k, suspend as l, matchCauseEffect as m, forkDaemon as n, ensuring as o, provide as p, uninterruptible as q, map as r, sync as s, zip as t, uninterruptibleMask as u, forEach as v, succeed as w, scoped as x, scope as y, zipWith as z };