effect 2.0.0-next.41 → 2.0.0-next.43

package/dist/Effect-cf226187.cjs.dev.js

@@ -1,3740 +0,0 @@
-'use strict';
-
-var Context_dist_effectContext = require('./Context-3c9e986b.cjs.dev.js');
-var Function_dist_effectFunction = require('./Function-41ce433d.cjs.dev.js');
-var defaultServices = require('./defaultServices-60c753dc.cjs.dev.js');
-var core = require('./core-ac668be0.cjs.dev.js');
-var coreEffect = require('./core-effect-a9b8ee08.cjs.dev.js');
-var circular = require('./circular-4cb0b79d.cjs.dev.js');
-var fiberRuntime = require('./fiberRuntime-e9680313.cjs.dev.js');
-var layer = require('./layer-7991a9d1.cjs.dev.js');
-var circular$1 = require('./circular-81e1906f.cjs.dev.js');
-var query = require('./query-193d0a89.cjs.dev.js');
-var runtime$1 = require('./runtime-3ae98f19.cjs.dev.js');
-var schedule$1 = require('./schedule-479d8fcc.cjs.dev.js');
-var Scheduler_dist_effectScheduler = require('./Scheduler-d080442d.cjs.dev.js');
-
-/**
- * @since 2.0.0
- */
-
-// -------------------------------------------------------------------------------------
-// models
-// -------------------------------------------------------------------------------------
-/**
- * @since 2.0.0
- */
-/**
- * @since 2.0.0
- * @category symbols
- */
-const EffectTypeId = core.EffectTypeId;
-
-/**
- * @since 2.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 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @category models
- * @since 2.0.0
- */
-
-/**
- * @category type lambdas
- * @since 2.0.0
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.0.0
- * @category models
- */
-
-/**
- * @since 2.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 2.0.0
- * @category refinements
- */
-const isEffect = core.isEffect;
-
-// -------------------------------------------------------------------------------------
-// caching
-// -------------------------------------------------------------------------------------
-
-/**
- * Returns an effect that, if evaluated, will return the cached result of this
- * effect. Cached results will expire after `timeToLive` duration.
- *
- * @since 2.0.0
- * @category caching
- */
-const cachedWithTTL = circular.cached;
-
-/**
- * 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 2.0.0
- * @category caching
- */
-const cachedInvalidateWithTTL = circular.cachedInvalidate;
-
-/**
- * Returns an effect that, if evaluated, will return the lazily computed
- * result of this effect.
- *
- * @since 2.0.0
- * @category caching
- */
-const cached = coreEffect.memoize;
-
-/**
- * Returns a memoized version of the specified effectual function.
- *
- * @since 2.0.0
- * @category caching
- */
-const cachedFunction = circular.memoizeFunction;
-
-/**
- * Returns an effect that will be executed at most once, even if it is
- * evaluated multiple times.
- *
- * @since 2.0.0
- * @category caching
- */
-const once = coreEffect.once;
-
-// -------------------------------------------------------------------------------------
-// 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 2.0.0
- * @category collecting & elements
- */
-const all = fiberRuntime.all;
-
-/**
- * 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 2.0.0
- * @category collecting & elements
- */
-const allWith = fiberRuntime.allWith;
-
-/**
- * @since 2.0.0
- */
-
-/**
- * Evaluate and run each effect in the structure and collect the results,
- * discarding results from failed effects.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const allSuccesses = fiberRuntime.allSuccesses;
-
-/**
- * Drops all elements until the effectful predicate returns true.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const dropUntil = coreEffect.dropUntil;
-
-/**
- * Drops all elements so long as the predicate returns true.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const dropWhile = coreEffect.dropWhile;
-
-/**
- * Determines whether all elements of the `Collection<A>` satisfies the effectual
- * predicate `f`.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const every = coreEffect.every;
-
-/**
- * Determines whether any element of the `Iterable<A>` satisfies the effectual
- * predicate `f`.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const exists = fiberRuntime.exists;
-
-/**
- * Filters the collection using the specified effectful predicate.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const filter = fiberRuntime.filter;
-
-/**
- * Returns the first element that satisfies the effectful predicate.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const findFirst = coreEffect.findFirst;
-
-/**
- * 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 2.0.0
- * @category collecting & elements
- */
-const firstSuccessOf = coreEffect.firstSuccessOf;
-
-/**
- * @since 2.0.0
- * @category collecting & elements
- */
-const forEach = fiberRuntime.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 2.0.0
- * @category collecting & elements
- */
-const head = coreEffect.head;
-
-/**
- * Merges an `Iterable<Effect<R, E, A>>` to a single effect, working
- * sequentially.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const mergeAll = fiberRuntime.mergeAll;
-
-/**
- * Feeds elements of type `A` to a function `f` that returns an effect.
- * Collects all successes and failures in a tupled fashion.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const partition = fiberRuntime.partition;
-
-/**
- * Folds an `Iterable<A>` using an effectual function f, working sequentially
- * from left to right.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const reduce = coreEffect.reduce;
-
-/**
- * Reduces an `Iterable<Effect<R, E, A>>` to a single effect.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const reduceEffect = fiberRuntime.reduceEffect;
-
-/**
- * Folds an `Iterable<A>` using an effectual function f, working sequentially from left to right.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const reduceRight = coreEffect.reduceRight;
-
-/**
- * Folds over the elements in this chunk from the left, stopping the fold early
- * when the predicate is not satisfied.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const reduceWhile = coreEffect.reduceWhile;
-
-/**
- * Replicates the given effect `n` times.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const replicate = fiberRuntime.replicate;
-
-/**
- * Performs this effect the specified number of times and collects the
- * results.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const replicateEffect = fiberRuntime.replicateEffect;
-
-/**
- * Takes elements until the effectual predicate returns true.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const takeUntil = coreEffect.takeUntil;
-
-/**
- * Takes all elements so long as the effectual predicate returns true.
- *
- * @since 2.0.0
- * @category collecting & elements
- */
-const takeWhile = coreEffect.takeWhile;
-
-/**
- * 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 2.0.0
- * @category collecting & elements
- */
-const validateAll = fiberRuntime.validateAll;
-
-/**
- * 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 2.0.0
- * @category collecting & elements
- */
-const validateFirst = fiberRuntime.validateFirst;
-
-// -------------------------------------------------------------------------------------
-// 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 2.0.0
- * @category constructors
- */
-const async = core.async;
-
-/**
- * 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 2.0.0
- * @category constructors
- */
-const asyncEffect = runtime$1.asyncEffect;
-
-/**
- * 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 2.0.0
- * @category constructors
- */
-const asyncOption = coreEffect.asyncOption;
-
-/**
- * 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 2.0.0
- * @category constructors
- */
-const asyncEither = core.asyncEither;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const fail = core.fail;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const failSync = core.failSync;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const failCause = core.failCause;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const failCauseSync = core.failCauseSync;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const die = core.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 2.0.0
- * @category constructors
- */
-const dieMessage = core.dieMessage;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const dieSync = core.dieSync;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const gen = coreEffect.gen;
-
-/**
- * @category models
- * @since 2.0.0
- */
-
-/**
- * @since 2.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 2.0.0
- * @category constructors
- */
-const never = core.never;
-
-/**
- * Requires the option produced by this value to be `None`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const none = coreEffect.none;
-
-/**
- * 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 2.0.0
- * @category constructors
- */
-const promise = coreEffect.promise;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const succeed = core.succeed;
-
-/**
- * Returns an effect which succeeds with `None`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const succeedNone = coreEffect.succeedNone;
-
-/**
- * Returns an effect which succeeds with the value wrapped in a `Some`.
- *
- * @since 2.0.0
- * @category constructors
- */
-const succeedSome = coreEffect.succeedSome;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const suspend = core.suspend;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const sync = core.sync;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const unit = core.unit;
-
-/**
- * @since 2.0.0
- * @category constructors
- */
-const yieldNow = core.yieldNow;
-
-// -------------------------------------------------------------------------------------
-// error handling
-// -------------------------------------------------------------------------------------
-
-const _catch = coreEffect._catch;
-
-/**
- * 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 2.0.0
- * @category error handling
- */
-const catchAll = core.catchAll;
-
-/**
- * Recovers from both recoverable and unrecoverable errors.
- *
- * See `absorb`, `sandbox`, `mapErrorCause` for other functions that can
- * recover from defects.
- *
- * @since 2.0.0
- * @category error handling
- */
-const catchAllCause = core.catchAllCause;
-
-/**
- * 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 2.0.0
- * @category error handling
- */
-const catchAllDefect = coreEffect.catchAllDefect;
-
-/**
- * Recovers from errors that match the given predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-const catchIf = core.catchIf;
-
-/**
- * Recovers from some or all of the error cases.
- *
- * @since 2.0.0
- * @category error handling
- */
-const catchSome = core.catchSome;
-
-/**
- * Recovers from some or all of the error cases with provided cause.
- *
- * @since 2.0.0
- * @category error handling
- */
-const catchSomeCause = coreEffect.catchSomeCause;
-
-/**
- * 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 2.0.0
- * @category error handling
- */
-const catchSomeDefect = coreEffect.catchSomeDefect;
-
-/**
- * Recovers from the specified tagged error.
- *
- * @since 2.0.0
- * @category error handling
- */
-const catchTag = coreEffect.catchTag;
-
-/**
- * Recovers from the specified tagged errors.
- *
- * @since 2.0.0
- * @category error handling
- */
-const catchTags = coreEffect.catchTags;
-
-/**
- * Returns an effect that succeeds with the cause of failure of this effect,
- * or `Cause.empty` if the effect did succeed.
- *
- * @since 2.0.0
- * @category error handling
- */
-const cause = coreEffect.cause;
-
-/**
- * Returns an effect that ignores errors and runs repeatedly until it
- * eventually succeeds.
- *
- * @since 2.0.0
- * @category error handling
- */
-const eventually = coreEffect.eventually;
-
-/**
- * Returns a new effect that ignores the success or failure of this effect.
- *
- * @since 2.0.0
- * @category error handling
- */
-const ignore = coreEffect.ignore;
-
-/**
- * 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 2.0.0
- * @category error handling
- */
-const ignoreLogged = coreEffect.ignoreLogged;
-
-/**
- * Exposes all parallel errors in a single call.
- *
- * @since 2.0.0
- * @category error handling
- */
-const parallelErrors = coreEffect.parallelErrors;
-
-/**
- * Exposes the full `Cause` of failure for the specified effect.
- *
- * @since 2.0.0
- * @category error handling
- */
-const sandbox = coreEffect.sandbox;
-
-/**
- * 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 2.0.0
- * @category error handling
- */
-const retry = schedule$1.retry_Effect;
-
-/**
- * Retries this effect the specified number of times.
- *
- * @since 2.0.0
- * @category error handling
- */
-const retryN = schedule$1.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 2.0.0
- * @category error handling
- */
-const retryOrElse = schedule$1.retryOrElse_Effect;
-
-/**
- * Retries this effect until its error satisfies the specified predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-const retryUntil = schedule$1.retryUntil_Effect;
-
-/**
- * Retries this effect until its error satisfies the specified effectful
- * predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-const retryUntilEffect = schedule$1.retryUntilEffect_Effect;
-
-/**
- * Retries this effect while its error satisfies the specified predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-const retryWhile = schedule$1.retryWhile_Effect;
-
-/**
- * Retries this effect while its error satisfies the specified effectful
- * predicate.
- *
- * @since 2.0.0
- * @category error handling
- */
-const retryWhileEffect = schedule$1.retryWhileEffect_Effect;
-const try_ = coreEffect.try_;
-
-/**
- * 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 2.0.0
- * @category error handling
- */
-const tryMap = coreEffect.tryMap;
-
-/**
- * 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 2.0.0
- * @category error handling
- */
-const tryMapPromise = coreEffect.tryMapPromise;
-
-/**
- * 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 2.0.0
- * @category error handling
- */
-const tryPromise = coreEffect.tryPromise;
-
-/**
- * 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 2.0.0
- * @category error handling
- */
-const unsandbox = coreEffect.unsandbox;
-
-// -------------------------------------------------------------------------------------
-// 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 2.0.0
- * @category interruption
- */
-const allowInterrupt = coreEffect.allowInterrupt;
-
-/**
- * Checks the interrupt status, and produces the effect returned by the
- * specified callback.
- *
- * @since 2.0.0
- * @category interruption
- */
-const checkInterruptible = core.checkInterruptible;
-
-/**
- * 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 2.0.0
- * @category interruption
- */
-const disconnect = fiberRuntime.disconnect;
-
-/**
- * @since 2.0.0
- * @category interruption
- */
-const interrupt = core.interrupt;
-
-/**
- * @since 2.0.0
- * @category interruption
- */
-const interruptWith = core.interruptWith;
-
-/**
- * @since 2.0.0
- * @category interruption
- */
-const interruptible = core.interruptible;
-
-/**
- * @since 2.0.0
- * @category interruption
- */
-const interruptibleMask = core.interruptibleMask;
-
-/**
- * @since 2.0.0
- * @category interruption
- */
-const onInterrupt = core.onInterrupt;
-
-/**
- * @since 2.0.0
- * @category interruption
- */
-const uninterruptible = core.uninterruptible;
-
-/**
- * @since 2.0.0
- * @category interruption
- */
-const uninterruptibleMask = core.uninterruptibleMask;
-
-// -------------------------------------------------------------------------------------
-// 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 2.0.0
- * @category mapping
- */
-const as = core.as;
-
-/**
- * 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 2.0.0
- */
-const asSome = coreEffect.asSome;
-
-/**
- * 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 2.0.0
- */
-const asSomeError = coreEffect.asSomeError;
-
-/**
- * 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 2.0.0
- * @category mapping
- */
-const asUnit = core.asUnit;
-
-/**
- * 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 2.0.0
- * @category mapping
- */
-const flip = core.flip;
-
-/**
- * Swaps the error/value parameters, applies the function `f` and flips the
- * parameters back
- *
- * @since 2.0.0
- * @category mapping
- */
-const flipWith = coreEffect.flipWith;
-
-/**
- * @since 2.0.0
- * @category mapping
- */
-const map = core.map;
-
-/**
- * Statefully and effectfully maps over the elements of this chunk to produce
- * new elements.
- *
- * @since 2.0.0
- * @category mapping
- */
-const mapAccum = coreEffect.mapAccum;
-
-/**
- * Returns an effect whose failure and success channels have been mapped by
- * the specified `onFailure` and `onSuccess` functions.
- *
- * @since 2.0.0
- * @category mapping
- */
-const mapBoth = core.mapBoth;
-
-/**
- * Returns an effect with its error channel mapped using the specified function.
- *
- * @since 2.0.0
- * @category mapping
- */
-const mapError = core.mapError;
-
-/**
- * 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 2.0.0
- * @category mapping
- */
-const mapErrorCause = coreEffect.mapErrorCause;
-
-/**
- * Returns a new effect where the error channel has been merged into the
- * success channel to their common combined type.
- *
- * @since 2.0.0
- * @category mapping
- */
-const merge = coreEffect.merge;
-
-/**
- * Returns a new effect where boolean value of this effect is negated.
- *
- * @since 2.0.0
- * @category mapping
- */
-const negate = coreEffect.negate;
-
-// -------------------------------------------------------------------------------------
-// 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 2.0.0
- * @category scoping, resources & finalization
- */
-const acquireRelease = fiberRuntime.acquireRelease;
-
-/**
- * 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 2.0.0
- * @category scoping, resources & finalization
- */
-const acquireReleaseInterruptible = fiberRuntime.acquireReleaseInterruptible;
-
-/**
- * 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 2.0.0
- * @category scoping, resources & finalization
- */
-const acquireUseRelease = core.acquireUseRelease;
-
-/**
- * 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 2.0.0
- * @category scoping, resources & finalization
- */
-const addFinalizer = fiberRuntime.addFinalizer;
-
-/**
- * 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 2.0.0
- * @category scoping, resources & finalization
- */
-const ensuring = fiberRuntime.ensuring;
-
-/**
- * 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 2.0.0
- * @category scoping, resources & finalization
- */
-const onError = core.onError;
-
-/**
- * Ensures that a cleanup functions runs, whether this effect succeeds, fails,
- * or is interrupted.
- *
- * @since 2.0.0
- * @category scoping, resources & finalization
- */
-const onExit = core.onExit;
-
-/**
- * @since 2.0.0
- * @category scoping, resources & finalization
- */
-const parallelFinalizers = fiberRuntime.parallelFinalizers;
-
-/**
- * @since 2.0.0
- * @category scoping, resources & finalization
- */
-const finalizersMask = fiberRuntime.finalizersMask;
-
-/**
- * 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 2.0.0
- * @category scoping, resources & finalization
- */
-const sequentialFinalizers = fiberRuntime.sequentialFinalizers;
-
-/**
- * @since 2.0.0
- * @category scoping, resources & finalization
- */
-const scope = fiberRuntime.scope;
-
-/**
- * Accesses the current scope and uses it to perform the specified effect.
- *
- * @since 2.0.0
- * @category scoping, resources & finalization
- */
-const scopeWith = fiberRuntime.scopeWith;
-
-/**
- * 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 2.0.0
- * @category scoping, resources & finalization
- */
-const scoped = fiberRuntime.scopedEffect;
-
-/**
- * Scopes all resources acquired by `resource` to the lifetime of `use`
- * without effecting the scope of any resources acquired by `use`.
- *
- * @since 2.0.0
- * @category scoping, resources & finalization
- */
-const using = fiberRuntime.using;
-
-/**
- * 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 2.0.0
- * @category scoping, resources & finalization
- */
-const withEarlyRelease = fiberRuntime.withEarlyRelease;
-
-// -------------------------------------------------------------------------------------
-// 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 2.0.0
- * @category supervision & fibers
- */
-const awaitAllChildren = circular.awaitAllChildren;
-
-/**
- * Returns a new workflow that will not supervise any fibers forked by this
- * workflow.
- *
- * @since 2.0.0
- * @category supervision & fibers
- */
-const daemonChildren = fiberRuntime.daemonChildren;
-
-/**
- * Constructs an effect with information about the current `Fiber`.
- *
- * @since 2.0.0
- * @category supervision & fibers
- */
-const descriptor = coreEffect.descriptor;
-
-/**
- * Constructs an effect based on information about the current `Fiber`.
- *
- * @since 2.0.0
- * @category supervision & fibers
- */
-const descriptorWith = coreEffect.descriptorWith;
-
-/**
- * Returns a new workflow that executes this one and captures the changes in
- * `FiberRef` values.
- *
- * @since 2.0.0
- * @category supervision & fibers
- */
-const diffFiberRefs = coreEffect.diffFiberRefs;
-
-/**
- * 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 2.0.0
- * @category supervision & fibers
- */
-const ensuringChild = circular.ensuringChild;
-
-/**
- * Acts on the children of this fiber, guaranteeing the specified callback
- * will be invoked, whether or not this effect succeeds.
- *
- * @since 2.0.0
- * @category supervision & fibers
- */
-const ensuringChildren = circular.ensuringChildren;
-
-/**
- * @since 2.0.0
- * @category supervision & fibers
- */
-const fiberId = core.fiberId;
-
-/**
- * @since 2.0.0
- * @category supervision & fibers
- */
-const fiberIdWith = core.fiberIdWith;
-
-/**
- * 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 2.0.0
- * @category supervision & fibers
- */
-const fork = fiberRuntime.fork;
-
-/**
- * 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 2.0.0
- * @category supervision & fibers
- */
-const forkDaemon = fiberRuntime.forkDaemon;
-
-/**
- * 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 2.0.0
- * @category supervision & fibers
- */
-const forkAll = circular.forkAll;
-
-/**
- * Forks the effect in the specified scope. The fiber will be interrupted
- * when the scope is closed.
- *
- * @since 2.0.0
- * @category supervision & fibers
- */
-const forkIn = circular.forkIn;
-
-/**
- * Forks the fiber in a `Scope`, interrupting it when the scope is closed.
- *
- * @since 2.0.0
- * @category supervision & fibers
- */
-const forkScoped = circular.forkScoped;
-
-/**
- * Like fork but handles an error with the provided handler.
- *
- * @since 2.0.0
- * @category supervision & fibers
- */
-const forkWithErrorHandler = fiberRuntime.forkWithErrorHandler;
-
-/**
- * Creates an `Effect` value that represents the exit value of the specified
- * fiber.
- *
- * @since 2.0.0
- * @category supervision & fibers
- */
-const fromFiber = circular.fromFiber;
-
-/**
- * Creates an `Effect` value that represents the exit value of the specified
- * fiber.
- *
- * @since 2.0.0
- * @category supervision & fibers
- */
-const fromFiberEffect = circular.fromFiberEffect;
-
-/**
- * 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 2.0.0
- * @category supervision & fibers
- */
-const supervised = circular.supervised;
-
-/**
- * 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 2.0.0
- * @category supervision & fibers
- */
-const transplant = core.transplant;
-
-/**
- * @since 2.0.0
- * @category supervision & fibers
- */
-const withConcurrency = core.withConcurrency;
-
-// ---------------------------------------------------------------------------------------
-// scheduler
-// ---------------------------------------------------------------------------------------
-
-/**
- * @since 2.0.0
- * @category scheduler
- */
-const setScheduler = scheduler => layer.scopedDiscard(fiberRuntime.fiberRefLocallyScoped(Scheduler_dist_effectScheduler.currentScheduler, scheduler));
-
-/**
- * Sets the provided scheduler for usage in the wrapped effect
- *
- * @since 2.0.0
- * @category scheduler
- */
-const withScheduler = Scheduler_dist_effectScheduler.withScheduler;
-
-/**
- * Sets the scheduling priority used when yielding
- *
- * @since 2.0.0
- * @category utils
- */
-const withSchedulingPriority = core.withSchedulingPriority;
-
-/**
- * Sets the maximum number of operations before yield by the default schedulers
- *
- * @since 2.0.0
- * @category utils
- */
-const withMaxOpsBeforeYield = core.withMaxOpsBeforeYield;
-
-// ---------------------------------------------------------------------------------------
-// clock
-// ---------------------------------------------------------------------------------------
-
-/**
- * Retreives the `Clock` service from the context
- *
- * @since 2.0.0
- * @category clock
- */
-const clock = coreEffect.clock;
-
-/**
- * Retreives the `Clock` service from the context and provides it to the
- * specified effectful function.
- *
- * @since 2.0.0
- * @category clock
- */
-const clockWith = coreEffect.clockWith;
-
-/**
- * @since 2.0.0
- * @category clock
- */
-const setClock = clock => layer.scopedDiscard(fiberRuntime.fiberRefLocallyScopedWith(defaultServices.currentServices, Context_dist_effectContext.add(defaultServices.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 2.0.0
- * @category constructors
- */
-const withClockScoped = fiberRuntime.withClockScoped;
-
-/**
- * Executes the specified workflow with the specified implementation of the
- * clock service.
- *
- * @since 2.0.0
- * @category clock
- */
-const withClock = defaultServices.withClock;
-
-// ---------------------------------------------------------------------------------------
-// delays & timeouts
-// ---------------------------------------------------------------------------------------
-
-/**
- * Returns an effect that is delayed from this effect by the specified
- * `Duration`.
- *
- * @since 2.0.0
- * @category delays & timeouts
- */
-const delay = coreEffect.delay;
-
-/**
- * Returns an effect that suspends for the specified duration. This method is
- * asynchronous, and does not actually block the fiber executing the effect.
- *
- * @since 2.0.0
- * @category delays & timeouts
- */
-const sleep = coreEffect.sleep;
-
-/**
- * Returns a new effect that executes this one and times the execution.
- *
- * @since 2.0.0
- * @category delays & timeouts
- */
-const timed = coreEffect.timed;
-
-/**
- * A more powerful variation of `timed` that allows specifying the clock.
- *
- * @since 2.0.0
- * @category delays & timeouts
- */
-const timedWith = coreEffect.timedWith;
-
-/**
- * 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 2.0.0
- * @category delays & timeouts
- */
-const timeout = circular.timeout;
-
-/**
- * The same as `timeout`, but instead of producing a `None` in the event of
- * timeout, it will produce the specified error.
- *
- * @since 2.0.0
- * @category delays & timeouts
- */
-const timeoutFail = circular.timeoutFail;
-
-/**
- * The same as `timeout`, but instead of producing a `None` in the event of
- * timeout, it will produce the specified failure.
- *
- * @since 2.0.0
- * @category delays & timeouts
- */
-const timeoutFailCause = circular.timeoutFailCause;
-
-/**
- * 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 2.0.0
- * @category delays & timeouts
- */
-const timeoutTo = circular.timeoutTo;
-
-// -------------------------------------------------------------------------------------
-// config
-// -------------------------------------------------------------------------------------
-
-/**
- * Uses the default config provider to load the specified config, or fail with
- * an error of type Config.Error.
- *
- * @since 2.0.0
- * @category config
- */
-const config = defaultServices.config;
-
-/**
- * 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 2.0.0
- * @category config
- */
-const configProviderWith = defaultServices.configProviderWith;
-
-/**
- * Sets the current `ConfigProvider`.
- *
- * @since 2.0.0
- * @category config
- */
-const setConfigProvider = circular$1.setConfigProvider;
-
-/**
- * Executes the specified workflow with the specified configuration provider.
- *
- * @since 2.0.0
- * @category config
- */
-const withConfigProvider = defaultServices.withConfigProvider;
-
-/**
- * Sets the configuration provider to the specified value and restores it to its original value
- * when the scope is closed.
- *
- * @since 2.0.0
- * @category config
- */
-const withConfigProviderScoped = fiberRuntime.withConfigProviderScoped;
-
-// -------------------------------------------------------------------------------------
-// context
-// -------------------------------------------------------------------------------------
-
-/**
- * @since 2.0.0
- * @category context
- */
-const context = core.context;
-
-/**
- * Accesses the context of the effect.
- *
- * @since 2.0.0
- * @category context
- */
-const contextWith = coreEffect.contextWith;
-
-/**
- * Effectually accesses the context of the effect.
- *
- * @since 2.0.0
- * @category context
- */
-const contextWithEffect = core.contextWithEffect;
-
-/**
- * Provides some of the context required to run this effect,
- * leaving the remainder `R0`.
- *
- * @since 2.0.0
- * @category context
- */
-const mapInputContext = core.mapInputContext;
-
-/**
- * Splits the context into two parts, providing one part using the
- * specified layer/context/runtime and leaving the remainder `R0`
- *
- * @since 2.0.0
- * @category context
- */
-const provide = layer.effect_provide;
-
-/**
- * Provides the effect with the single service it requires. If the effect
- * requires more than one service use `provideContext` instead.
- *
- * @since 2.0.0
- * @category context
- */
-const provideService = coreEffect.provideService;
-
-/**
- * Provides the effect with the single service it requires. If the effect
- * requires more than one service use `provideContext` instead.
- *
- * @since 2.0.0
- * @category context
- */
-const provideServiceEffect = coreEffect.provideServiceEffect;
-
-/**
- * @since 2.0.0
- * @category context
- */
-const serviceFunction = coreEffect.serviceFunction;
-
-/**
- * @since 2.0.0
- * @category context
- */
-const serviceFunctionEffect = coreEffect.serviceFunctionEffect;
-
-/**
- * @since 2.0.0
- * @category context
- */
-const serviceFunctions = coreEffect.serviceFunctions;
-
-/**
- * @since 2.0.0
- * @category context
- */
-const serviceConstants = coreEffect.serviceConstants;
-
-/**
- * @since 2.0.0
- * @category context
- */
-const serviceMembers = coreEffect.serviceMembers;
-
-/**
- * @since 2.0.0
- * @category context
- */
-const serviceOption = tag => contextWith(_ => Context_dist_effectContext.getOption(_, tag));
-
-/**
- * Updates the service with the required service entry.
- *
- * @since 2.0.0
- * @category context
- */
-const updateService = coreEffect.updateService;
-
-// -------------------------------------------------------------------------------------
-// do notation
-// -------------------------------------------------------------------------------------
-
-/**
- * @since 2.0.0
- * @category do notation
- */
-const Do = coreEffect.Do;
-
-/**
- * Binds an effectful value in a `do` scope
- *
- * @since 2.0.0
- * @category do notation
- */
-const bind = coreEffect.bind;
-
-/**
- * @category do notation
- * @since 2.0.0
- */
-const bindTo = coreEffect.bindTo;
-const let_ = coreEffect.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 2.0.0
- * @category conversions
- */
-const either = core.either;
-
-/**
- * @since 2.0.0
- * @category conversions
- */
-const exit = core.exit;
-
-/**
- * @since 2.0.0
- * @category conversions
- */
-const intoDeferred = core.intoDeferred;
-
-/**
- * Executes this effect, skipping the error but returning optionally the
- * success.
- *
- * @since 2.0.0
- * @category conversions
- */
-const option = coreEffect.option;
-
-// -------------------------------------------------------------------------------------
-// filtering & conditionals
-// -------------------------------------------------------------------------------------
-
-const if_ = core.if_;
-
-/**
- * Filter the specified effect with the provided function, dying with specified
- * defect if the predicate fails.
- *
- * @since 2.0.0
- * @category filtering & conditionals
- */
-const filterOrDie = coreEffect.filterOrDie;
-
-/**
- * Filter the specified effect with the provided function, dying with specified
- * message if the predicate fails.
- *
- * @since 2.0.0
- * @category filtering & conditionals
- */
-const filterOrDieMessage = coreEffect.filterOrDieMessage;
-
-/**
- * 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 2.0.0
- * @category filtering & conditionals
- */
-const filterOrElse = coreEffect.filterOrElse;
-
-/**
- * Filter the specified effect with the provided function, failing with specified
- * error if the predicate fails.
- *
- * @since 2.0.0
- * @category filtering & conditionals
- */
-const filterOrFail = coreEffect.filterOrFail;
-
-/**
- * The moral equivalent of `if (!p) exp`.
- *
- * @since 2.0.0
- * @category filtering & conditionals
- */
-const unless = coreEffect.unless;
-
-/**
- * The moral equivalent of `if (!p) exp` when `p` has side-effects.
- *
- * @since 2.0.0
- * @category filtering & conditionals
- */
-const unlessEffect = coreEffect.unlessEffect;
-
-/**
- * The moral equivalent of `if (p) exp`.
- *
- * @since 2.0.0
- * @category filtering & conditionals
- */
-const when = coreEffect.when;
-
-/**
- * @since 2.0.0
- * @category filtering & conditionals
- */
-const whenEffect = core.whenEffect;
-
-/**
- * Executes this workflow when value of the specified `FiberRef` satisfies the
- * predicate.
- *
- * @since 2.0.0
- * @category filtering & conditionals
- */
-const whenFiberRef = coreEffect.whenFiberRef;
-
-/**
- * Executes this workflow when the value of the `Ref` satisfies the predicate.
- *
- * @since 2.0.0
- * @category filtering & conditionals
- */
-const whenRef = coreEffect.whenRef;
-
-// -------------------------------------------------------------------------------------
-// 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 2.0.0
- * @category sequencing
- */
-const flatMap = core.flatMap;
-
-/**
- * @since 2.0.0
- * @category sequencing
- */
-const flatten = core.flatten;
-
-/**
- * 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 2.0.0
- * @category sequencing
- */
-const raceAll = fiberRuntime.raceAll;
-
-/**
- * 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 2.0.0
- * @category sequencing
- */
-const race = fiberRuntime.race;
-
-/**
- * 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 2.0.0
- * @category sequencing
- */
-const raceFirst = circular.raceFirst;
-
-/**
- * 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 2.0.0
- * @category sequencing
- */
-const raceWith = fiberRuntime.raceWith;
-
-/**
- * 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 2.0.0
- * @category sequencing
- */
-const summarized = coreEffect.summarized;
-
-/**
- * @since 2.0.0
- * @category sequencing
- */
-const tap = core.tap;
-
-/**
- * Returns an effect that effectfully "peeks" at the failure or success of
- * this effect.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const tapBoth = coreEffect.tapBoth;
-
-/**
- * Returns an effect that effectually "peeks" at the defect of this effect.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const tapDefect = coreEffect.tapDefect;
-
-/**
- * Returns an effect that effectfully "peeks" at the failure of this effect.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const tapError = coreEffect.tapError;
-
-/**
- * Returns an effect that effectfully "peeks" at the specific tagged failure of this effect.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const tapErrorTag = coreEffect.tapErrorTag;
-
-/**
- * Returns an effect that effectually "peeks" at the cause of the failure of
- * this effect.
- *
- * @since 2.0.0
- * @category sequencing
- */
-const tapErrorCause = coreEffect.tapErrorCause;
-
-// -------------------------------------------------------------------------------------
-// repetition / recursion
-// -------------------------------------------------------------------------------------
-
-/**
- * Repeats this effect forever (until the first error).
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-const forever = coreEffect.forever;
-
-/**
- * Iterates with the specified effectual function. The moral equivalent of:
- *
- * ```ts
- * let s = initial
- *
- * while (cont(s)) {
- *   s = body(s)
- * }
- *
- * return s
- * ```
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-const iterate = coreEffect.iterate;
-
-/**
- * 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 2.0.0
- * @category repetition / recursion
- */
-const loop = coreEffect.loop;
-
-/**
- * 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 2.0.0
- * @category repetition / recursion
- */
-const repeat = schedule$1.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 2.0.0
- * @category repetition / recursion
- */
-const repeatN = coreEffect.repeatN;
-
-/**
- * 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 2.0.0
- * @category repetition / recursion
- */
-const repeatOrElse = schedule$1.repeatOrElse_Effect;
-
-/**
- * Repeats this effect until its value satisfies the specified predicate or
- * until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-const repeatUntil = schedule$1.repeatUntil_Effect;
-
-/**
- * Repeats this effect until its value satisfies the specified effectful
- * predicate or until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-const repeatUntilEffect = schedule$1.repeatUntilEffect_Effect;
-
-/**
- * Repeats this effect while its value satisfies the specified effectful
- * predicate or until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-const repeatWhile = schedule$1.repeatWhile_Effect;
-
-/**
- * Repeats this effect while its value satisfies the specified effectful
- * predicate or until the first failure.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-const repeatWhileEffect = schedule$1.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 2.0.0
- * @category repetition / recursion
- */
-const schedule = schedule$1.schedule_Effect;
-
-/**
- * Runs this effect according to the specified schedule in a new fiber
- * attached to the current scope.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-const scheduleForked = circular.scheduleForked;
-
-/**
- * Runs this effect according to the specified schedule starting from the
- * specified input value.
- *
- * @since 2.0.0
- * @category repetition / recursion
- */
-const scheduleFrom = schedule$1.scheduleFrom_Effect;
-
-/**
- * @since 2.0.0
- * @category repetition / recursion
- */
-const whileLoop = core.whileLoop;
-
-// -------------------------------------------------------------------------------------
-// fiber refs
-// -------------------------------------------------------------------------------------
-
-/**
- * Returns a collection of all `FiberRef` values for the fiber running this
- * effect.
- *
- * @since 2.0.0
- * @category fiber refs
- */
-const getFiberRefs = coreEffect.fiberRefs;
-
-/**
- * Inherits values from all `FiberRef` instances into current fiber.
- *
- * @since 2.0.0
- * @category fiber refs
- */
-const inheritFiberRefs = coreEffect.inheritFiberRefs;
-
-/**
- * @since 2.0.0
- * @category fiber refs
- */
-const locally = core.fiberRefLocally;
-
-/**
- * @since 2.0.0
- * @category fiber refs
- */
-const locallyWith = core.fiberRefLocallyWith;
-
-/**
- * @since 2.0.0
- * @category fiber refs
- */
-const locallyScoped = fiberRuntime.fiberRefLocallyScoped;
-
-/**
- * @since 2.0.0
- * @category fiber refs
- */
-const locallyScopedWith = fiberRuntime.fiberRefLocallyScopedWith;
-
-/**
- * Applies the specified changes to the `FiberRef` values for the fiber
- * running this workflow.
- *
- * @since 2.0.0
- * @category fiber refs
- */
-const patchFiberRefs = coreEffect.patchFiberRefs;
-
-/**
- * Sets the `FiberRef` values for the fiber running this effect to the values
- * in the specified collection of `FiberRef` values.
- *
- * @since 2.0.0
- * @category fiber refs
- */
-const setFiberRefs = coreEffect.setFiberRefs;
-
-/**
- * Updates the `FiberRef` values for the fiber running this effect using the
- * specified function.
- *
- * @since 2.0.0
- * @category fiber refs
- */
-const updateFiberRefs = coreEffect.updateFiberRefs;
-
-// -------------------------------------------------------------------------------------
-// getters & folding
-// -------------------------------------------------------------------------------------
-
-/**
- * Returns `true` if this effect is a failure, `false` otherwise.
- *
- * @since 2.0.0
- * @category getters & folding
- */
-const isFailure = coreEffect.isFailure;
-
-/**
- * Returns `true` if this effect is a success, `false` otherwise.
- *
- * @since 2.0.0
- * @category getters & folding
- */
-const isSuccess = coreEffect.isSuccess;
-
-/**
- * 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 2.0.0
- * @category getters & folding
- */
-const match = coreEffect.match;
-
-/**
- * @since 2.0.0
- * @category getters & folding
- */
-const matchCause = core.matchCause;
-
-/**
- * @since 2.0.0
- * @category getters & folding
- */
-const matchCauseEffect = core.matchCauseEffect;
-
-/**
- * @since 2.0.0
- * @category getters & folding
- */
-const matchEffect = core.matchEffect;
-
-// -------------------------------------------------------------------------------------
-// logging
-// -------------------------------------------------------------------------------------
-
-/**
- * Logs the specified message or cause at the current log level.
- *
- * You can set the current log level using `FiberRef.currentLogLevel`.
- *
- * @since 2.0.0
- * @category logging
- */
-const log = coreEffect.log;
-
-/**
- * Logs the specified message or cause at the Trace log level.
- *
- * @since 2.0.0
- * @category logging
- */
-const logTrace = coreEffect.logTrace;
-
-/**
- * Logs the specified message or cause at the Debug log level.
- *
- * @since 2.0.0
- * @category logging
- */
-const logDebug = coreEffect.logDebug;
-
-/**
- * Logs the specified message or cause at the Info log level.
- *
- * @since 2.0.0
- * @category logging
- */
-const logInfo = coreEffect.logInfo;
-
-/**
- * Logs the specified message or cause at the Warning log level.
- *
- * @since 2.0.0
- * @category logging
- */
-const logWarning = coreEffect.logWarning;
-
-/**
- * Logs the specified message or cause at the Error log level.
- *
- * @since 2.0.0
- * @category logging
- */
-const logError = coreEffect.logError;
-
-/**
- * Logs the specified message or cause at the Fatal log level.
- *
- * @since 2.0.0
- * @category logging
- */
-const logFatal = coreEffect.logFatal;
-
-/**
- * Adjusts the label for the current logging span.
- *
- * @since 2.0.0
- * @category logging
- */
-const withLogSpan = coreEffect.withLogSpan;
-
-/**
- * Annotates each log in this effect with the specified log annotation.
- *
- * @since 2.0.0
- * @category logging
- */
-const annotateLogs = coreEffect.annotateLogs;
-
-/**
- * Retrieves the log annotations associated with the current scope.
- *
- * @since 2.0.0
- * @category logging
- */
-const logAnnotations = coreEffect.logAnnotations;
-
-/**
- * Decides wether child fibers will report or not unhandled errors via the logger
- *
- * @since 2.0.0
- * @category logging
- */
-const withUnhandledErrorLogLevel = core.withUnhandledErrorLogLevel;
-
-/**
- * @since 2.0.0
- * @category logging
- */
-const setUnhandledErrorLogLevel = level => layer.scopedDiscard(fiberRuntime.fiberRefLocallyScoped(core.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 2.0.0
- * @category alternatives
- */
-const orDie = core.orDie;
-
-/**
- * Keeps none of the errors, and terminates the fiber with them, using the
- * specified function to convert the `E` into a `Throwable`.
- *
- * @since 2.0.0
- * @category alternatives
- */
-const orDieWith = core.orDieWith;
-
-/**
- * Executes this effect and returns its value, if it succeeds, but otherwise
- * executes the specified effect.
- *
- * @since 2.0.0
- * @category alternatives
- */
-const orElse = core.orElse;
-
-/**
- * Executes this effect and returns its value, if it succeeds, but otherwise
- * fails with the specified error.
- *
- * @since 2.0.0
- * @category alternatives
- */
-const orElseFail = coreEffect.orElseFail;
-
-/**
- * Executes this effect and returns its value, if it succeeds, but
- * otherwise succeeds with the specified value.
- *
- * @since 2.0.0
- * @category alternatives
- */
-const orElseSucceed = coreEffect.orElseSucceed;
-
-// -------------------------------------------------------------------------------------
-// random
-// -------------------------------------------------------------------------------------
-
-/**
- * Retreives the `Random` service from the context.
- *
- * @since 2.0.0
- * @category random
- */
-const random = coreEffect.random;
-
-/**
- * Retreives the `Random` service from the context and uses it to run the
- * specified workflow.
- *
- * @since 2.0.0
- * @category random
- */
-const randomWith = defaultServices.randomWith;
-
-// -------------------------------------------------------------------------------------
-// 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 2.0.0
- * @category runtime
- */
-const runtime = runtime$1.runtime;
-
-/**
- * Retrieves an effect that succeeds with the current runtime flags, which
- * govern behavior and features of the runtime system.
- *
- * @since 2.0.0
- * @category runtime
- */
-const getRuntimeFlags = core.runtimeFlags;
-
-/**
- * @since 2.0.0
- * @category runtime
- */
-const patchRuntimeFlags = core.updateRuntimeFlags;
-
-/**
- * @since 2.0.0
- * @category runtime
- */
-const withRuntimeFlagsPatch = core.withRuntimeFlags;
-
-/**
- * @since 2.0.0
- * @category runtime
- */
-const withRuntimeFlagsPatchScoped = fiberRuntime.withRuntimeFlagsScoped;
-
-// -------------------------------------------------------------------------------------
-// metrics
-// -------------------------------------------------------------------------------------
-
-/**
- * Tags each metric in this effect with the specific tag.
- *
- * @since 2.0.0
- * @category metrics
- */
-const tagMetrics = coreEffect.tagMetrics;
-
-/**
- * Tags each metric in this effect with the specific tag.
- *
- * @since 2.0.0
- * @category metrics
- */
-const labelMetrics = coreEffect.labelMetrics;
-
-/**
- * Tags each metric in this effect with the specific tag.
- *
- * @since 2.0.0
- * @category metrics
- */
-const labelMetricsSet = coreEffect.labelMetricsSet;
-
-/**
- * Tags each metric in a scope with a the specific tag.
- *
- * @since 2.0.0
- * @category metrics
- */
-const tagMetricsScoped = fiberRuntime.tagMetricsScoped;
-
-/**
- * Tags each metric in a scope with a the specific tag.
- *
- * @since 2.0.0
- * @category metrics
- */
-const labelMetricsScoped = fiberRuntime.labelMetricsScoped;
-
-/**
- * Tags each metric in a scope with a the specific tag.
- *
- * @since 2.0.0
- * @category metrics
- */
-const labelMetricsScopedSet = fiberRuntime.labelMetricsScopedSet;
-
-/**
- * Retrieves the metric labels associated with the current scope.
- *
- * @since 2.0.0
- * @category metrics
- */
-const metricLabels = core.metricLabels;
-
-/**
- * @since 2.0.0
- * @category metrics
- */
-const withMetric = coreEffect.withMetric;
-
-// -------------------------------------------------------------------------------------
-// unify
-// -------------------------------------------------------------------------------------
-
-/**
- * Used to unify functions that would otherwise return `Effect<A, B, C> | Effect<D, E, F>`
- *
- * @category unify
- * @since 2.0.0
- */
-const unifiedFn = core.unified;
-
-/**
- * Used to unify effects that would otherwise be `Effect<A, B, C> | Effect<D, E, F>`
- *
- * @category unify
- * @since 2.0.0
- */
-const unified = Function_dist_effectFunction.identity;
-
-// -------------------------------------------------------------------------------------
-// semaphore
-// -------------------------------------------------------------------------------------
-
-/**
- * @category semaphore
- * @since 2.0.0
- */
-/**
- * @category semaphore
- * @since 2.0.0
- */
-/**
- * Unsafely creates a new Semaphore
- *
- * @since 2.0.0
- * @category semaphore
- */
-const unsafeMakeSemaphore = circular.unsafeMakeSemaphore;
-
-/**
- * Creates a new Semaphore
- *
- * @since 2.0.0
- * @category semaphore
- */
-const makeSemaphore = circular.makeSemaphore;
-
-// -------------------------------------------------------------------------------------
-// execution
-// -------------------------------------------------------------------------------------
-
-/**
- * @since 2.0.0
- * @category execution
- */
-const runFork = runtime$1.unsafeForkEffect;
-
-/**
- * @since 2.0.0
- * @category execution
- */
-const runCallback = runtime$1.unsafeRunEffect;
-
-/**
- * Runs an `Effect` workflow, returning a `Promise` which resolves with the
- * result of the workflow or rejects with an error.
- *
- * @since 2.0.0
- * @category execution
- */
-const runPromise = runtime$1.unsafeRunPromiseEffect;
-
-/**
- * Runs an `Effect` workflow, returning a `Promise` which resolves with the
- * `Exit` value of the workflow.
- *
- * @since 2.0.0
- * @category execution
- */
-const runPromiseExit = runtime$1.unsafeRunPromiseExitEffect;
-
-/**
- * @since 2.0.0
- * @category execution
- */
-const runSync = runtime$1.unsafeRunSyncEffect;
-
-/**
- * @since 2.0.0
- * @category execution
- */
-const runSyncExit = runtime$1.unsafeRunSyncExitEffect;
-
-// -------------------------------------------------------------------------------------
-// zipping
-// -------------------------------------------------------------------------------------
-
-/**
- * Sequentially zips the this result with the specified result. Combines both
- * `Cause`s when both effects fail.
- *
- * @since 2.0.0
- * @category zipping
- */
-const validate = fiberRuntime.validate;
-
-/**
- * Sequentially zips this effect with the specified effect using the specified
- * combiner function. Combines the causes in case both effect fail.
- *
- * @since 2.0.0
- * @category zipping
- */
-const validateWith = fiberRuntime.validateWith;
-
-/**
- * @since 2.0.0
- * @category zipping
- */
-const zip = fiberRuntime.zipOptions;
-
-/**
- * @since 2.0.0
- * @category zipping
- */
-const zipLeft = fiberRuntime.zipLeftOptions;
-
-/**
- * @since 2.0.0
- * @category zipping
- */
-const zipRight = fiberRuntime.zipRightOptions;
-
-/**
- * @since 2.0.0
- * @category zipping
- */
-const zipWith = fiberRuntime.zipWithOptions;
-
-// -------------------------------------------------------------------------------------
-// requests & batching
-// -------------------------------------------------------------------------------------
-
-/**
- * @category requests & batching
- * @since 2.0.0
- */
-const blocked = core.blocked;
-
-/**
- * @category requests & batching
- * @since 2.0.0
- */
-const runRequestBlock = core.runRequestBlock;
-
-/**
- * @category requests & batching
- * @since 2.0.0
- */
-const step = core.step;
-
-/**
- * @category requests & batching
- * @since 2.0.0
- */
-const flatMapStep = core.flatMapStep;
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-const request = query.fromRequest;
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-const cacheRequestResult = query.cacheRequest;
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-const withRequestBatching = core.withRequestBatching;
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-const setRequestBatching = requestBatching => layer.scopedDiscard(fiberRuntime.fiberRefLocallyScoped(core.currentRequestBatching, requestBatching));
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-const setRequestCaching = requestCaching => layer.scopedDiscard(fiberRuntime.fiberRefLocallyScoped(query.currentCacheEnabled, requestCaching));
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-const setRequestCache = cache => layer.scopedDiscard(core.isEffect(cache) ? core.flatMap(cache, x => fiberRuntime.fiberRefLocallyScoped(query.currentCache, x)) : fiberRuntime.fiberRefLocallyScoped(query.currentCache, cache));
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-const withRequestCaching = query.withRequestCaching;
-
-/**
- * @since 2.0.0
- * @category requests & batching
- */
-const withRequestCache = query.withRequestCache;
-
-// -------------------------------------------------------------------------------------
-// tracing
-// -------------------------------------------------------------------------------------
-
-/**
- * Create a Layer that sets the current Tracer
- *
- * @since 2.0.0
- * @category tracing
- */
-const setTracer = circular$1.setTracer;
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-const tracer = coreEffect.tracer;
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-const tracerWith = defaultServices.tracerWith;
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-const withTracer = defaultServices.withTracer;
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-const withTracerScoped = fiberRuntime.withTracerScoped;
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-const withTracerTiming = core.withTracerTiming;
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-const setTracerTiming = enabled => layer.scopedDiscard(fiberRuntime.fiberRefLocallyScoped(core.currentTracerTimingEnabled, enabled));
-
-/**
- * Adds an annotation to each span in this effect.
- *
- * @since 2.0.0
- * @category tracing
- */
-const annotateSpans = coreEffect.annotateSpans;
-
-/**
- * Adds an annotation to the current span if available
- *
- * @since 2.0.0
- * @category tracing
- */
-const annotateCurrentSpan = coreEffect.annotateCurrentSpan;
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-const currentSpan = coreEffect.currentSpan;
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-const currentParentSpan = coreEffect.currentParentSpan;
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-const spanAnnotations = coreEffect.spanAnnotations;
-
-/**
- * @since 2.0.0
- * @category tracing
- */
-const spanLinks = coreEffect.spanLinks;
-
-/**
- * For all spans in this effect, add a link with the provided span.
- *
- * @since 2.0.0
- * @category tracing
- */
-const linkSpans = coreEffect.linkSpans;
-
-/**
- * Create a new span for tracing.
- *
- * @since 2.0.0
- * @category tracing
- */
-const makeSpan = coreEffect.makeSpan;
-
-/**
- * Adds the provided span to the span stack.
- *
- * @since 2.0.0
- * @category tracing
- */
-const setParentSpan = circular$1.setParentSpan;
-
-/**
- * Create and add a span to the current span stack.
- *
- * The span is ended when the Layer is released.
- *
- * @since 2.0.0
- * @category tracing
- */
-const setSpan = circular$1.setSpan;
-
-/**
- * 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 2.0.0
- * @category tracing
- */
-const useSpan = coreEffect.useSpan;
-
-/**
- * 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 2.0.0
- * @category tracing
- */
-const useSpanScoped = fiberRuntime.useSpanScoped;
-
-/**
- * Wraps the effect with a new span for tracing.
- *
- * @since 2.0.0
- * @category tracing
- */
-const withSpan = coreEffect.withSpan;
-
-/**
- * Create and add a span to the current span stack.
- *
- * The span is ended when the Scope is finalized.
- *
- * @since 2.0.0
- * @category tracing
- */
-const withSpanScoped = fiberRuntime.withSpanScoped;
-
-/**
- * Adds the provided span to the current span stack.
- *
- * @since 2.0.0
- * @category tracing
- */
-const withParentSpan = coreEffect.withParentSpan;
-
-/**
- * Adds the provided span to the current span stack.
- *
- * @since 2.0.0
- * @category tracing
- */
-const withParentSpanScoped = fiberRuntime.withParentSpanScoped;
-
-// -------------------------------------------------------------------------------------
-// optionality
-// -------------------------------------------------------------------------------------
-
-/**
- * Returns an effect that errors with `NoSuchElementException` if the value is
- * null or undefined, otherwise succeeds with the value.
- *
- * @since 2.0.0
- * @category optionality
- */
-const fromNullable = coreEffect.fromNullable;
-
-/**
- * Wraps the success value of this effect with `Option.some`, and maps
- * `Cause.NoSuchElementException` to `Option.none`.
- *
- * @since 2.0.0
- * @category optionality
- */
-const optionFromOptional = coreEffect.optionFromOptional;
-
-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
-});
-
-exports.Do = Do;
-exports.Effect = Effect;
-exports.EffectTypeId = EffectTypeId;
-exports._catch = _catch;
-exports.acquireRelease = acquireRelease;
-exports.acquireReleaseInterruptible = acquireReleaseInterruptible;
-exports.acquireUseRelease = acquireUseRelease;
-exports.addFinalizer = addFinalizer;
-exports.all = all;
-exports.allSuccesses = allSuccesses;
-exports.allWith = allWith;
-exports.allowInterrupt = allowInterrupt;
-exports.annotateCurrentSpan = annotateCurrentSpan;
-exports.annotateLogs = annotateLogs;
-exports.annotateSpans = annotateSpans;
-exports.as = as;
-exports.asSome = asSome;
-exports.asSomeError = asSomeError;
-exports.asUnit = asUnit;
-exports.async = async;
-exports.asyncEffect = asyncEffect;
-exports.asyncEither = asyncEither;
-exports.asyncOption = asyncOption;
-exports.awaitAllChildren = awaitAllChildren;
-exports.bind = bind;
-exports.bindTo = bindTo;
-exports.blocked = blocked;
-exports.cacheRequestResult = cacheRequestResult;
-exports.cached = cached;
-exports.cachedFunction = cachedFunction;
-exports.cachedInvalidateWithTTL = cachedInvalidateWithTTL;
-exports.cachedWithTTL = cachedWithTTL;
-exports.catchAll = catchAll;
-exports.catchAllCause = catchAllCause;
-exports.catchAllDefect = catchAllDefect;
-exports.catchIf = catchIf;
-exports.catchSome = catchSome;
-exports.catchSomeCause = catchSomeCause;
-exports.catchSomeDefect = catchSomeDefect;
-exports.catchTag = catchTag;
-exports.catchTags = catchTags;
-exports.cause = cause;
-exports.checkInterruptible = checkInterruptible;
-exports.clock = clock;
-exports.clockWith = clockWith;
-exports.config = config;
-exports.configProviderWith = configProviderWith;
-exports.context = context;
-exports.contextWith = contextWith;
-exports.contextWithEffect = contextWithEffect;
-exports.currentParentSpan = currentParentSpan;
-exports.currentSpan = currentSpan;
-exports.daemonChildren = daemonChildren;
-exports.delay = delay;
-exports.descriptor = descriptor;
-exports.descriptorWith = descriptorWith;
-exports.die = die;
-exports.dieMessage = dieMessage;
-exports.dieSync = dieSync;
-exports.diffFiberRefs = diffFiberRefs;
-exports.disconnect = disconnect;
-exports.dropUntil = dropUntil;
-exports.dropWhile = dropWhile;
-exports.either = either;
-exports.ensuring = ensuring;
-exports.ensuringChild = ensuringChild;
-exports.ensuringChildren = ensuringChildren;
-exports.eventually = eventually;
-exports.every = every;
-exports.exists = exists;
-exports.exit = exit;
-exports.fail = fail;
-exports.failCause = failCause;
-exports.failCauseSync = failCauseSync;
-exports.failSync = failSync;
-exports.fiberId = fiberId;
-exports.fiberIdWith = fiberIdWith;
-exports.filter = filter;
-exports.filterOrDie = filterOrDie;
-exports.filterOrDieMessage = filterOrDieMessage;
-exports.filterOrElse = filterOrElse;
-exports.filterOrFail = filterOrFail;
-exports.finalizersMask = finalizersMask;
-exports.findFirst = findFirst;
-exports.firstSuccessOf = firstSuccessOf;
-exports.flatMap = flatMap;
-exports.flatMapStep = flatMapStep;
-exports.flatten = flatten;
-exports.flip = flip;
-exports.flipWith = flipWith;
-exports.forEach = forEach;
-exports.forever = forever;
-exports.fork = fork;
-exports.forkAll = forkAll;
-exports.forkDaemon = forkDaemon;
-exports.forkIn = forkIn;
-exports.forkScoped = forkScoped;
-exports.forkWithErrorHandler = forkWithErrorHandler;
-exports.fromFiber = fromFiber;
-exports.fromFiberEffect = fromFiberEffect;
-exports.fromNullable = fromNullable;
-exports.gen = gen;
-exports.getFiberRefs = getFiberRefs;
-exports.getRuntimeFlags = getRuntimeFlags;
-exports.head = head;
-exports.if_ = if_;
-exports.ignore = ignore;
-exports.ignoreLogged = ignoreLogged;
-exports.inheritFiberRefs = inheritFiberRefs;
-exports.interrupt = interrupt;
-exports.interruptWith = interruptWith;
-exports.interruptible = interruptible;
-exports.interruptibleMask = interruptibleMask;
-exports.intoDeferred = intoDeferred;
-exports.isEffect = isEffect;
-exports.isFailure = isFailure;
-exports.isSuccess = isSuccess;
-exports.iterate = iterate;
-exports.labelMetrics = labelMetrics;
-exports.labelMetricsScoped = labelMetricsScoped;
-exports.labelMetricsScopedSet = labelMetricsScopedSet;
-exports.labelMetricsSet = labelMetricsSet;
-exports.let_ = let_;
-exports.linkSpans = linkSpans;
-exports.locally = locally;
-exports.locallyScoped = locallyScoped;
-exports.locallyScopedWith = locallyScopedWith;
-exports.locallyWith = locallyWith;
-exports.log = log;
-exports.logAnnotations = logAnnotations;
-exports.logDebug = logDebug;
-exports.logError = logError;
-exports.logFatal = logFatal;
-exports.logInfo = logInfo;
-exports.logTrace = logTrace;
-exports.logWarning = logWarning;
-exports.loop = loop;
-exports.makeSemaphore = makeSemaphore;
-exports.makeSpan = makeSpan;
-exports.map = map;
-exports.mapAccum = mapAccum;
-exports.mapBoth = mapBoth;
-exports.mapError = mapError;
-exports.mapErrorCause = mapErrorCause;
-exports.mapInputContext = mapInputContext;
-exports.match = match;
-exports.matchCause = matchCause;
-exports.matchCauseEffect = matchCauseEffect;
-exports.matchEffect = matchEffect;
-exports.merge = merge;
-exports.mergeAll = mergeAll;
-exports.metricLabels = metricLabels;
-exports.negate = negate;
-exports.never = never;
-exports.none = none;
-exports.onError = onError;
-exports.onExit = onExit;
-exports.onInterrupt = onInterrupt;
-exports.once = once;
-exports.option = option;
-exports.optionFromOptional = optionFromOptional;
-exports.orDie = orDie;
-exports.orDieWith = orDieWith;
-exports.orElse = orElse;
-exports.orElseFail = orElseFail;
-exports.orElseSucceed = orElseSucceed;
-exports.parallelErrors = parallelErrors;
-exports.parallelFinalizers = parallelFinalizers;
-exports.partition = partition;
-exports.patchFiberRefs = patchFiberRefs;
-exports.patchRuntimeFlags = patchRuntimeFlags;
-exports.promise = promise;
-exports.provide = provide;
-exports.provideService = provideService;
-exports.provideServiceEffect = provideServiceEffect;
-exports.race = race;
-exports.raceAll = raceAll;
-exports.raceFirst = raceFirst;
-exports.raceWith = raceWith;
-exports.random = random;
-exports.randomWith = randomWith;
-exports.reduce = reduce;
-exports.reduceEffect = reduceEffect;
-exports.reduceRight = reduceRight;
-exports.reduceWhile = reduceWhile;
-exports.repeat = repeat;
-exports.repeatN = repeatN;
-exports.repeatOrElse = repeatOrElse;
-exports.repeatUntil = repeatUntil;
-exports.repeatUntilEffect = repeatUntilEffect;
-exports.repeatWhile = repeatWhile;
-exports.repeatWhileEffect = repeatWhileEffect;
-exports.replicate = replicate;
-exports.replicateEffect = replicateEffect;
-exports.request = request;
-exports.retry = retry;
-exports.retryN = retryN;
-exports.retryOrElse = retryOrElse;
-exports.retryUntil = retryUntil;
-exports.retryUntilEffect = retryUntilEffect;
-exports.retryWhile = retryWhile;
-exports.retryWhileEffect = retryWhileEffect;
-exports.runCallback = runCallback;
-exports.runFork = runFork;
-exports.runPromise = runPromise;
-exports.runPromiseExit = runPromiseExit;
-exports.runRequestBlock = runRequestBlock;
-exports.runSync = runSync;
-exports.runSyncExit = runSyncExit;
-exports.runtime = runtime;
-exports.sandbox = sandbox;
-exports.schedule = schedule;
-exports.scheduleForked = scheduleForked;
-exports.scheduleFrom = scheduleFrom;
-exports.scope = scope;
-exports.scopeWith = scopeWith;
-exports.scoped = scoped;
-exports.sequentialFinalizers = sequentialFinalizers;
-exports.serviceConstants = serviceConstants;
-exports.serviceFunction = serviceFunction;
-exports.serviceFunctionEffect = serviceFunctionEffect;
-exports.serviceFunctions = serviceFunctions;
-exports.serviceMembers = serviceMembers;
-exports.serviceOption = serviceOption;
-exports.setClock = setClock;
-exports.setConfigProvider = setConfigProvider;
-exports.setFiberRefs = setFiberRefs;
-exports.setParentSpan = setParentSpan;
-exports.setRequestBatching = setRequestBatching;
-exports.setRequestCache = setRequestCache;
-exports.setRequestCaching = setRequestCaching;
-exports.setScheduler = setScheduler;
-exports.setSpan = setSpan;
-exports.setTracer = setTracer;
-exports.setTracerTiming = setTracerTiming;
-exports.setUnhandledErrorLogLevel = setUnhandledErrorLogLevel;
-exports.sleep = sleep;
-exports.spanAnnotations = spanAnnotations;
-exports.spanLinks = spanLinks;
-exports.step = step;
-exports.succeed = succeed;
-exports.succeedNone = succeedNone;
-exports.succeedSome = succeedSome;
-exports.summarized = summarized;
-exports.supervised = supervised;
-exports.suspend = suspend;
-exports.sync = sync;
-exports.tagMetrics = tagMetrics;
-exports.tagMetricsScoped = tagMetricsScoped;
-exports.takeUntil = takeUntil;
-exports.takeWhile = takeWhile;
-exports.tap = tap;
-exports.tapBoth = tapBoth;
-exports.tapDefect = tapDefect;
-exports.tapError = tapError;
-exports.tapErrorCause = tapErrorCause;
-exports.tapErrorTag = tapErrorTag;
-exports.timed = timed;
-exports.timedWith = timedWith;
-exports.timeout = timeout;
-exports.timeoutFail = timeoutFail;
-exports.timeoutFailCause = timeoutFailCause;
-exports.timeoutTo = timeoutTo;
-exports.tracer = tracer;
-exports.tracerWith = tracerWith;
-exports.transplant = transplant;
-exports.tryMap = tryMap;
-exports.tryMapPromise = tryMapPromise;
-exports.tryPromise = tryPromise;
-exports.try_ = try_;
-exports.unified = unified;
-exports.unifiedFn = unifiedFn;
-exports.uninterruptible = uninterruptible;
-exports.uninterruptibleMask = uninterruptibleMask;
-exports.unit = unit;
-exports.unless = unless;
-exports.unlessEffect = unlessEffect;
-exports.unsafeMakeSemaphore = unsafeMakeSemaphore;
-exports.unsandbox = unsandbox;
-exports.updateFiberRefs = updateFiberRefs;
-exports.updateService = updateService;
-exports.useSpan = useSpan;
-exports.useSpanScoped = useSpanScoped;
-exports.using = using;
-exports.validate = validate;
-exports.validateAll = validateAll;
-exports.validateFirst = validateFirst;
-exports.validateWith = validateWith;
-exports.when = when;
-exports.whenEffect = whenEffect;
-exports.whenFiberRef = whenFiberRef;
-exports.whenRef = whenRef;
-exports.whileLoop = whileLoop;
-exports.withClock = withClock;
-exports.withClockScoped = withClockScoped;
-exports.withConcurrency = withConcurrency;
-exports.withConfigProvider = withConfigProvider;
-exports.withConfigProviderScoped = withConfigProviderScoped;
-exports.withEarlyRelease = withEarlyRelease;
-exports.withLogSpan = withLogSpan;
-exports.withMaxOpsBeforeYield = withMaxOpsBeforeYield;
-exports.withMetric = withMetric;
-exports.withParentSpan = withParentSpan;
-exports.withParentSpanScoped = withParentSpanScoped;
-exports.withRequestBatching = withRequestBatching;
-exports.withRequestCache = withRequestCache;
-exports.withRequestCaching = withRequestCaching;
-exports.withRuntimeFlagsPatch = withRuntimeFlagsPatch;
-exports.withRuntimeFlagsPatchScoped = withRuntimeFlagsPatchScoped;
-exports.withScheduler = withScheduler;
-exports.withSchedulingPriority = withSchedulingPriority;
-exports.withSpan = withSpan;
-exports.withSpanScoped = withSpanScoped;
-exports.withTracer = withTracer;
-exports.withTracerScoped = withTracerScoped;
-exports.withTracerTiming = withTracerTiming;
-exports.withUnhandledErrorLogLevel = withUnhandledErrorLogLevel;
-exports.yieldNow = yieldNow;
-exports.zip = zip;
-exports.zipLeft = zipLeft;
-exports.zipRight = zipRight;
-exports.zipWith = zipWith;