effect 2.0.0-next.44 → 2.0.0-next.45

package/dist/{fiberRuntime-c7280769.cjs.dev.js → fiberRuntime-6e93adff.cjs.dev.js}

@@ -4,20 +4,20 @@ var Boolean_dist_effectBoolean = require('../Boolean/dist/effect-Boolean.cjs.dev
 var Chunk_dist_effectChunk = require('../Chunk/dist/effect-Chunk.cjs.dev.js');
 var Context_dist_effectContext = require('../Context/dist/effect-Context.cjs.dev.js');
 var Deferred_dist_effectDeferred = require('../Deferred/dist/effect-Deferred.cjs.dev.js');
-var ExecutionStrategy_dist_effectExecutionStrategy = require('./ExecutionStrategy-70f1a920.cjs.dev.js');
-var FiberId_dist_effectFiberId = require('./FiberId-557db880.cjs.dev.js');
+var ExecutionStrategy_dist_effectExecutionStrategy = require('./ExecutionStrategy-7d9d457b.cjs.dev.js');
+var FiberId_dist_effectFiberId = require('./FiberId-9c555b91.cjs.dev.js');
 var FiberRefs_dist_effectFiberRefs = require('../FiberRefs/dist/effect-FiberRefs.cjs.dev.js');
 var FiberRefsPatch_dist_effectFiberRefsPatch = require('../FiberRefsPatch/dist/effect-FiberRefsPatch.cjs.dev.js');
 var FiberStatus_dist_effectFiberStatus = require('../FiberStatus/dist/effect-FiberStatus.cjs.dev.js');
 var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.dev.js');
 var HashSet_dist_effectHashSet = require('../HashSet/dist/effect-HashSet.cjs.dev.js');
-var core = require('./core-b4d7b4f5.cjs.dev.js');
-var defaultServices = require('./defaultServices-5530ff0e.cjs.dev.js');
+var core = require('./core-efee9c5a.cjs.dev.js');
+var defaultServices = require('./defaultServices-eb04fba1.cjs.dev.js');
 var GlobalValue_dist_effectGlobalValue = require('../GlobalValue/dist/effect-GlobalValue.cjs.dev.js');
-var configProvider = require('./configProvider-ce43fdbf.cjs.dev.js');
-var coreEffect = require('./core-effect-892f3686.cjs.dev.js');
-var fiber = require('./fiber-1bfb4c1d.cjs.dev.js');
-var fiberRefs = require('./fiberRefs-be4fae6a.cjs.dev.js');
+var configProvider = require('./configProvider-3cdbe5f3.cjs.dev.js');
+var coreEffect = require('./core-effect-f99b558c.cjs.dev.js');
+var fiber = require('./fiber-4d2acba3.cjs.dev.js');
+var fiberRefs = require('./fiberRefs-e08092fb.cjs.dev.js');
 var HashMap_dist_effectHashMap = require('../HashMap/dist/effect-HashMap.cjs.dev.js');
 var List_dist_effectList = require('../List/dist/effect-List.cjs.dev.js');
 var LogSpan_dist_effectLogSpan = require('../LogSpan/dist/effect-LogSpan.cjs.dev.js');
@@ -25,21 +25,21 @@ var Option_dist_effectOption = require('../Option/dist/effect-Option.cjs.dev.js'
 var Pipeable_dist_effectPipeable = require('../Pipeable/dist/effect-Pipeable.cjs.dev.js');
 var Clock_dist_effectClock = require('../Clock/dist/effect-Clock.cjs.dev.js');
 var Duration_dist_effectDuration = require('../Duration/dist/effect-Duration.cjs.dev.js');
-var boundaries = require('./boundaries-3810d885.cjs.dev.js');
-var key = require('./key-f0a1408a.cjs.dev.js');
+var boundaries = require('./boundaries-60c435b8.cjs.dev.js');
+var key = require('./key-6d9b350e.cjs.dev.js');
 var label = require('./label-011edbe7.cjs.dev.js');
-var registry = require('./registry-1099de3f.cjs.dev.js');
+var registry = require('./registry-fc4cef7b.cjs.dev.js');
 var ReadonlyArray_dist_effectReadonlyArray = require('../ReadonlyArray/dist/effect-ReadonlyArray.cjs.dev.js');
-var Effectable = require('./Effectable-2f022879.cjs.dev.js');
+var Effectable = require('./Effectable-07258ce9.cjs.dev.js');
 var Data_dist_effectData = require('../Data/dist/effect-Data.cjs.dev.js');
-var RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch = require('./RuntimeFlagsPatch-ea268c50.cjs.dev.js');
+var RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch = require('./RuntimeFlagsPatch-197be4f3.cjs.dev.js');
 var MutableRef_dist_effectMutableRef = require('../MutableRef/dist/effect-MutableRef.cjs.dev.js');
 var SortedSet_dist_effectSortedSet = require('../SortedSet/dist/effect-SortedSet.cjs.dev.js');
 var Differ_dist_effectDiffer = require('../Differ/dist/effect-Differ.cjs.dev.js');
 var Equal_dist_effectEqual = require('../Equal/dist/effect-Equal.cjs.dev.js');
 var LogLevel_dist_effectLogLevel = require('../LogLevel/dist/effect-LogLevel.cjs.dev.js');
 var Predicate_dist_effectPredicate = require('../Predicate/dist/effect-Predicate.cjs.dev.js');
-var Ref_dist_effectRef = require('./Ref-74b592a4.cjs.dev.js');
+var Ref_dist_effectRef = require('./Ref-4009db78.cjs.dev.js');
 var Scheduler_dist_effectScheduler = require('../Scheduler/dist/effect-Scheduler.cjs.dev.js');
 
 /** @internal */
@@ -326,7 +326,7 @@ const make = function (keyType, unsafeUpdate, unsafeValue) {
 const mapInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => make(self.keyType, (input, extraTags) => self.unsafeUpdate(f(input), extraTags), self.unsafeValue));
 
 /** @internal */
-const counter = (name, description) => fromMetricKey(key.counter(name, description));
+const counter = (name, options) => fromMetricKey(key.counter(name, options));
 
 /** @internal */
 const frequency = (name, description) => fromMetricKey(key.frequency(name, description));
@@ -344,13 +344,13 @@ const fromMetricKey = key$1 => {
 };
 
 /** @internal */
-const gauge = (name, description) => fromMetricKey(key.gauge(name, description));
+const gauge = (name, options) => fromMetricKey(key.gauge(name, options));
 
 /** @internal */
 const histogram = (name, boundaries, description) => fromMetricKey(key.histogram(name, boundaries, description));
 
 /* @internal */
-const increment = self => update(self, 1);
+const increment = self => update(self, self.keyType.bigint ? BigInt(1) : 1);
 
 /* @internal */
 const incrementBy = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, amount) => update(self, amount));
@@ -432,7 +432,7 @@ const trackDuration = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, m
 /* @internal */
 const trackDurationWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, metric, f) => Clock_dist_effectClock.clockWith(clock => {
   const startTime = clock.unsafeCurrentTimeNanos();
-  return core.map(self, a => {
+  return core.map$1(self, a => {
     const endTime = clock.unsafeCurrentTimeNanos();
     const duration = Duration_dist_effectDuration.nanos(endTime - startTime);
     metric.unsafeUpdate(f(duration), HashSet_dist_effectHashSet.empty());
@@ -592,7 +592,7 @@ class ProxySupervisor {
     this.underlying.onResume(fiber);
   }
   map(f) {
-    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map(f)));
+    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map$1(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -630,7 +630,7 @@ class Zip {
     this.right.onResume(fiber);
   }
   map(f) {
-    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map(f)));
+    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map$1(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -658,7 +658,7 @@ class Track {
     //
   }
   map(f) {
-    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map(f)));
+    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map$1(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -691,7 +691,7 @@ class Const {
     //
   }
   map(f) {
-    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map(f)));
+    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map$1(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -724,7 +724,7 @@ class FibersIn {
     //
   }
   map(f) {
-    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map(f)));
+    return new ProxySupervisor(this, () => Function_dist_effectFunction.pipe(this.value(), core.map$1(f)));
   }
   zip(right) {
     return new Zip(this, right);
@@ -982,14 +982,14 @@ const drainQueueWhileRunningTable = {
     return cur;
   },
   [fiber.OP_YIELD_NOW]: (_self, _runtimeFlags, cur, _message) => {
-    return core.flatMap(core.yieldNow(), () => cur);
+    return core.flatMap$1(core.yieldNow(), () => cur);
   }
 };
 
 /**
  * Executes all requests, submitting requests to each data source in parallel.
  */
-const runBlockedRequests = self => core.forEachSequentialDiscard(core.flatten$1(self), requestsByRequestResolver => forEachParUnboundedDiscard(core.sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential]) => {
+const runBlockedRequests = self => core.forEachSequentialDiscard(core.flatten$2(self), requestsByRequestResolver => forEachParUnboundedDiscard(core.sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential]) => {
   const map = new Map();
   for (const block of sequential) {
     for (const entry of block) {
@@ -1187,7 +1187,7 @@ class FiberRuntime {
    * In the background, interrupts the fiber as if interrupted from the specified fiber.
    */
   interruptAsFork(fiberId) {
-    return core.sync(() => this.tell(fiber.interruptSignal(core.interrupt$1(fiberId))));
+    return core.sync(() => this.tell(fiber.interruptSignal(core.interrupt(fiberId))));
   }
 
   /**
@@ -1407,7 +1407,7 @@ class FiberRuntime {
     }
     let told = false;
     for (const child of this._children) {
-      child.tell(fiber.interruptSignal(core.interrupt$1(this.id())));
+      child.tell(fiber.interruptSignal(core.interrupt(this.id())));
       told = true;
     }
     return told;
@@ -1570,7 +1570,7 @@ class FiberRuntime {
           this._runtimeFlags = Function_dist_effectFunction.pipe(this._runtimeFlags, RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.enable$1(RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.WindDown));
           const interruption = this.interruptAllChildren();
           if (interruption !== null) {
-            effect = core.flatMap(interruption, () => exit);
+            effect = core.flatMap$1(interruption, () => exit);
           } else {
             if (this._queue.length === 0) {
               // No more messages to process, so we will allow the fiber to end life:
@@ -1724,7 +1724,7 @@ class FiberRuntime {
     }
   }
   [Effectable.OP_TAG](op) {
-    return core.map(core.fiberRefGet(core.currentContext), context => {
+    return core.map$1(core.fiberRefGet(core.currentContext), context => {
       try {
         return Context_dist_effectContext.unsafeGet(context, op);
       } catch (e) {
@@ -1827,7 +1827,7 @@ class FiberRuntime {
             }
           case "OnSuccess":
             {
-              return core.blocked(op.i0, core.flatMap(op.i1, nextOp.i1));
+              return core.blocked(op.i0, core.flatMap$1(op.i1, nextOp.i1));
             }
           case "OnSuccessAndFailure":
             {
@@ -1842,7 +1842,7 @@ class FiberRuntime {
             }
           case "While":
             {
-              return core.blocked(op.i0, core.flatMap(op.i1, a => {
+              return core.blocked(op.i0, core.flatMap$1(op.i1, a => {
                 nextOp.i2(a);
                 if (nextOp.i0()) {
                   return core.whileLoop({
@@ -1862,7 +1862,7 @@ class FiberRuntime {
         }
       }
     }
-    return core.uninterruptibleMask(restore => core.flatMap(fork(core.runRequestBlock(op.i0)), () => restore(op.i1)));
+    return core.uninterruptibleMask(restore => core.flatMap$1(fork(core.runRequestBlock(op.i0)), () => restore(op.i1)));
   }
   ["RunBlocked"](op) {
     return runBlockedRequests(op.i0);
@@ -1952,7 +1952,7 @@ class FiberRuntime {
           this.isYielding = true;
           this.currentOpCount = 0;
           const oldCur = cur;
-          cur = core.flatMap(core.yieldNow({
+          cur = core.flatMap$1(core.yieldNow({
             priority: shouldYield
           }), () => oldCur);
         }
@@ -1984,7 +1984,7 @@ class FiberRuntime {
           if (core.isEffectError(e)) {
             cur = core.exitFailCause(e.cause);
           } else if (core.isInterruptedException(e)) {
-            cur = core.exitFailCause(core.sequential(core.die(e), core.interrupt$1(FiberId_dist_effectFiberId.none)));
+            cur = core.exitFailCause(core.sequential(core.die(e), core.interrupt(FiberId_dist_effectFiberId.none)));
           } else {
             cur = core.exitFailCause(core.die(e));
           }
@@ -2063,7 +2063,7 @@ const acquireReleaseInterruptible = /*#__PURE__*/Function_dist_effectFunction.du
 const addFinalizer = finalizer => core.withFiberRuntime(runtime => {
   const acquireRefs = runtime.getFiberRefs();
   const acquireFlags = runtime._runtimeFlags;
-  return core.flatMap(scope, scope => core.scopeAddFinalizerExit(scope, exit => core.withFiberRuntime(runtimeFinalizer => {
+  return core.flatMap$1(scope, scope => core.scopeAddFinalizerExit(scope, exit => core.withFiberRuntime(runtimeFinalizer => {
     const preRefs = runtimeFinalizer.getFiberRefs();
     const preFlags = runtimeFinalizer._runtimeFlags;
     const patchRefs = FiberRefsPatch_dist_effectFiberRefsPatch.diff(preRefs, acquireRefs);
@@ -2087,10 +2087,10 @@ const _existsParFound = /*#__PURE__*/Symbol.for("effect/Effect/existsPar/found")
 
 /* @internal */
 const exists = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => matchSimple(options, () => core.suspend(() => existsLoop(elements[Symbol.iterator](), 0, f)), () => core.matchEffect(forEachOptions(elements, (a, i) => core.if_(f(a, i), {
-  onTrue: core.fail(_existsParFound),
+  onTrue: core.fail$1(_existsParFound),
   onFalse: core.unit
 }), options), {
-  onFailure: e => e === _existsParFound ? core.succeed(true) : core.fail(e),
+  onFailure: e => e === _existsParFound ? core.succeed(true) : core.fail$1(e),
   onSuccess: () => core.succeed(false)
 })));
 const existsLoop = (iterator, index, f) => {
@@ -2098,13 +2098,13 @@ const existsLoop = (iterator, index, f) => {
   if (next.done) {
     return core.succeed(false);
   }
-  return Function_dist_effectFunction.pipe(core.flatMap(f(next.value, index), b => b ? core.succeed(b) : existsLoop(iterator, index + 1, f)));
+  return Function_dist_effectFunction.pipe(core.flatMap$1(f(next.value, index), b => b ? core.succeed(b) : existsLoop(iterator, index + 1, f)));
 };
 
 /* @internal */
 const filter = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => {
-  const predicate = options?.negate ? (a, i) => core.map(f(a, i), Boolean_dist_effectBoolean.not) : f;
-  return matchSimple(options, () => core.suspend(() => ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).reduceRight((effect, a, i) => core.zipWith(effect, core.suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), core.sync(() => new Array()))), () => core.map(forEachOptions(elements, (a, i) => core.map(predicate(a, i), b => b ? Option_dist_effectOption.some(a) : Option_dist_effectOption.none()), options), ReadonlyArray_dist_effectReadonlyArray.compact));
+  const predicate = options?.negate ? (a, i) => core.map$1(f(a, i), Boolean_dist_effectBoolean.not) : f;
+  return matchSimple(options, () => core.suspend(() => ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).reduceRight((effect, a, i) => core.zipWith(effect, core.suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), core.sync(() => new Array()))), () => core.map$1(forEachOptions(elements, (a, i) => core.map$1(predicate(a, i), b => b ? Option_dist_effectOption.some(a) : Option_dist_effectOption.none()), options), ReadonlyArray_dist_effectReadonlyArray.compact));
 });
 
 // === all
@@ -2128,7 +2128,7 @@ const allValidate = (effects, reconcile, options) => {
   for (const effect of effects) {
     eitherEffects.push(core.either(effect));
   }
-  return core.flatMap(forEachOptions(eitherEffects, Function_dist_effectFunction.identity, {
+  return core.flatMap$1(forEachOptions(eitherEffects, Function_dist_effectFunction.identity, {
     concurrency: options?.concurrency,
     batching: options?.batching
   }), eithers => {
@@ -2148,7 +2148,7 @@ const allValidate = (effects, reconcile, options) => {
       }
     }
     if (errored) {
-      return reconcile._tag === "Some" ? core.fail(reconcile.value(errors)) : core.fail(errors);
+      return reconcile._tag === "Some" ? core.fail$1(reconcile.value(errors)) : core.fail$1(errors);
     } else if (options?.discard) {
       return core.unit;
     }
@@ -2167,7 +2167,7 @@ const allEither = (effects, reconcile, options) => {
       discard: true
     });
   }
-  return core.map(forEachOptions(eitherEffects, Function_dist_effectFunction.identity, {
+  return core.map$1(forEachOptions(eitherEffects, Function_dist_effectFunction.identity, {
     concurrency: options?.concurrency,
     batching: options?.batching
   }), eithers => reconcile._tag === "Some" ? reconcile.value(eithers) : eithers);
@@ -2181,14 +2181,14 @@ const all = (arg, options) => {
   } else if (options?.mode === "either") {
     return allEither(effects, reconcile, options);
   }
-  return reconcile._tag === "Some" ? core.map(forEachOptions(effects, Function_dist_effectFunction.identity, options), reconcile.value) : forEachOptions(effects, Function_dist_effectFunction.identity, options);
+  return reconcile._tag === "Some" ? core.map$1(forEachOptions(effects, Function_dist_effectFunction.identity, options), reconcile.value) : forEachOptions(effects, Function_dist_effectFunction.identity, options);
 };
 
 /* @internal */
 const allWith = options => arg => all(arg, options);
 
 /* @internal */
-const allSuccesses = (elements, options) => core.map(all(ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).map(core.exit), options), ReadonlyArray_dist_effectReadonlyArray.filterMap(exit => core.exitIsSuccess(exit) ? Option_dist_effectOption.some(exit.i0) : Option_dist_effectOption.none()));
+const allSuccesses = (elements, options) => core.map$1(all(ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).map(core.exit), options), ReadonlyArray_dist_effectReadonlyArray.filterMap(exit => core.exitIsSuccess(exit) ? Option_dist_effectOption.some(exit.i0) : Option_dist_effectOption.none()));
 
 /* @internal */
 const replicate = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => Array.from({
@@ -2202,16 +2202,16 @@ const replicateEffect = /*#__PURE__*/Function_dist_effectFunction.dual(args => c
 const forEachOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (self, f, options) => core.withFiberRuntime(r => {
   const requestBatchingEnabled = options?.batching === true || options?.batching === "inherit" && r.getFiberRef(core.currentRequestBatching);
   if (options?.discard) {
-    return match(options, () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.sequential$1)(restore => requestBatchingEnabled ? forEachBatchedDiscard(self, (a, i) => restore(f(a, i))) : core.forEachSequentialDiscard(self, (a, i) => restore(f(a, i)))), () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallel)(restore => forEachParUnboundedDiscard(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallelN(n))(restore => forEachParNDiscard(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
+    return match(options, () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.sequential)(restore => requestBatchingEnabled ? forEachBatchedDiscard(self, (a, i) => restore(f(a, i))) : core.forEachSequentialDiscard(self, (a, i) => restore(f(a, i)))), () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallel)(restore => forEachParUnboundedDiscard(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallelN(n))(restore => forEachParNDiscard(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
   }
-  return match(options, () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.sequential$1)(restore => requestBatchingEnabled ? forEachParN(self, 1, (a, i) => restore(f(a, i)), true) : core.forEachSequential(self, (a, i) => restore(f(a, i)))), () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallel)(restore => forEachParUnbounded(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallelN(n))(restore => forEachParN(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
+  return match(options, () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.sequential)(restore => requestBatchingEnabled ? forEachParN(self, 1, (a, i) => restore(f(a, i)), true) : core.forEachSequential(self, (a, i) => restore(f(a, i)))), () => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallel)(restore => forEachParUnbounded(self, (a, i) => restore(f(a, i)), requestBatchingEnabled)), n => finalizersMask(ExecutionStrategy_dist_effectExecutionStrategy.parallelN(n))(restore => forEachParN(self, n, (a, i) => restore(f(a, i)), requestBatchingEnabled)));
 }));
 
 /* @internal */
 const forEachParUnbounded = (self, f, batching) => core.suspend(() => {
   const as = ReadonlyArray_dist_effectReadonlyArray.fromIterable(self);
   const array = new Array(as.length);
-  const fn = (a, i) => core.flatMap(f(a, i), b => core.sync(() => array[i] = b));
+  const fn = (a, i) => core.flatMap$1(f(a, i), b => core.sync(() => array[i] = b));
   return core.zipRight(forEachParUnboundedDiscard(as, fn, batching), core.succeed(array));
 });
 const forEachBatchedDiscard = (self, f) => core.suspend(() => {
@@ -2238,7 +2238,7 @@ const forEachBatchedDiscard = (self, f) => core.suspend(() => {
       return core.suspend(() => {
         if (blocked.length > 0) {
           const requests = blocked.map(b => b.i0).reduce(core.par);
-          return core.blocked(requests, core.flatMap(forEachBatchedDiscard(blocked.map(b => b.i1), Function_dist_effectFunction.identity), () => s));
+          return core.blocked(requests, core.flatMap$1(forEachBatchedDiscard(blocked.map(b => b.i1), Function_dist_effectFunction.identity), () => s));
         }
         return core.unit;
       });
@@ -2263,7 +2263,7 @@ const forEachParUnboundedDiscard = (self, f, batching) => core.suspend(() => {
     let ref = 0;
     const residual = [];
     const joinOrder = [];
-    const process = core.transplant(graft => core.forEachSequential(as, (a, i) => Function_dist_effectFunction.pipe(graft(Function_dist_effectFunction.pipe(core.suspend(() => restore((batching ? core.step : core.exit)(f(a, i)))), core.flatMap(exit => {
+    const process = core.transplant(graft => core.forEachSequential(as, (a, i) => Function_dist_effectFunction.pipe(graft(Function_dist_effectFunction.pipe(core.suspend(() => restore((batching ? core.step : core.exit)(f(a, i)))), core.flatMap$1(exit => {
       switch (exit._op) {
         case "Failure":
           {
@@ -2296,14 +2296,14 @@ const forEachParUnboundedDiscard = (self, f, batching) => core.suspend(() => {
             return core.unit;
           }
       }
-    }))), forkDaemon, core.map(fiber => {
+    }))), forkDaemon, core.map$1(fiber => {
       fiber.addObserver(() => {
         joinOrder.push(fiber);
       });
       return fiber;
     }))));
-    return core.flatMap(process, fibers => core.matchCauseEffect(restore(core.deferredAwait(deferred)), {
-      onFailure: cause => core.flatMap(forEachParUnbounded(fibers, core.interruptFiber, batching), exits => {
+    return core.flatMap$1(process, fibers => core.matchCauseEffect(restore(core.deferredAwait(deferred)), {
+      onFailure: cause => core.flatMap$1(forEachParUnbounded(fibers, core.interruptFiber, batching), exits => {
         const exit = core.exitCollectAll(exits, {
           parallel: true
         });
@@ -2313,7 +2313,7 @@ const forEachParUnboundedDiscard = (self, f, batching) => core.suspend(() => {
           return core.failCause(core.stripFailures(cause));
         }
       }),
-      onSuccess: rest => core.flatMap(rest, () => core.forEachSequentialDiscard(joinOrder, f => f.inheritAll()))
+      onSuccess: rest => core.flatMap$1(rest, () => core.forEachSequentialDiscard(joinOrder, f => f.inheritAll()))
     }));
   });
 });
@@ -2322,7 +2322,7 @@ const forEachParUnboundedDiscard = (self, f, batching) => core.suspend(() => {
 const forEachParN = (self, n, f, batching) => core.suspend(() => {
   const as = ReadonlyArray_dist_effectReadonlyArray.fromIterable(self);
   const array = new Array(as.length);
-  const fn = (a, i) => core.map(f(a, i), b => array[i] = b);
+  const fn = (a, i) => core.map$1(f(a, i), b => array[i] = b);
   return core.zipRight(forEachParNDiscard(as, n, fn, batching), core.succeed(array));
 });
 
@@ -2331,7 +2331,7 @@ const forEachParNDiscard = (self, n, f, batching) => core.suspend(() => {
   let i = 0;
   const iterator = self[Symbol.iterator]();
   const residual = [];
-  const worker = core.flatMap(core.sync(() => iterator.next()), next => next.done ? core.unit : core.flatMap((batching ? core.step : core.exit)(core.asUnit(f(next.value, i++))), res => {
+  const worker = core.flatMap$1(core.sync(() => iterator.next()), next => next.done ? core.unit : core.flatMap$1((batching ? core.step : core.exit)(core.asUnit(f(next.value, i++))), res => {
     switch (res._op) {
       case "Blocked":
         {
@@ -2350,7 +2350,7 @@ const forEachParNDiscard = (self, n, f, batching) => core.suspend(() => {
   for (let i = 0; i < n; i++) {
     effects.push(worker);
   }
-  return core.flatMap(core.exit(forEachParUnboundedDiscard(effects, Function_dist_effectFunction.identity, batching)), exit => {
+  return core.flatMap$1(core.exit(forEachParUnboundedDiscard(effects, Function_dist_effectFunction.identity, batching)), exit => {
     if (residual.length === 0) {
       return exit;
     }
@@ -2413,16 +2413,16 @@ const unsafeMakeChildFiber = (effect, parentFiber, parentRuntimeFlags, overrideS
 const forkWithScopeOverride = (self, scopeOverride) => core.withFiberRuntime((parentFiber, parentStatus) => core.succeed(unsafeFork(self, parentFiber, parentStatus.runtimeFlags, scopeOverride)));
 
 /* @internal */
-const mergeAll = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).reduce((acc, a, i) => core.zipWith(acc, a, (acc, a) => f(acc, a, i)), core.succeed(zero)), () => core.flatMap(Ref_dist_effectRef.make(zero), acc => core.flatMap(forEachOptions(elements, (effect, i) => core.flatMap(effect, a => Ref_dist_effectRef.update(acc, b => f(b, a, i))), options), () => Ref_dist_effectRef.get(acc)))));
+const mergeAll = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => ReadonlyArray_dist_effectReadonlyArray.fromIterable(elements).reduce((acc, a, i) => core.zipWith(acc, a, (acc, a) => f(acc, a, i)), core.succeed(zero)), () => core.flatMap$1(Ref_dist_effectRef.make(zero), acc => core.flatMap$1(forEachOptions(elements, (effect, i) => core.flatMap$1(effect, a => Ref_dist_effectRef.update(acc, b => f(b, a, i))), options), () => Ref_dist_effectRef.get(acc)))));
 
 /* @internal */
-const partition = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => Function_dist_effectFunction.pipe(forEachOptions(elements, (a, i) => core.either(f(a, i)), options), core.map(chunk => core.partitionMap(chunk, Function_dist_effectFunction.identity))));
+const partition = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => Function_dist_effectFunction.pipe(forEachOptions(elements, (a, i) => core.either(f(a, i)), options), core.map$1(chunk => core.partitionMap(chunk, Function_dist_effectFunction.identity))));
 
 /* @internal */
-const validateAll = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => core.flatMap(partition(elements, f, {
+const validateAll = /*#__PURE__*/Function_dist_effectFunction.dual(args => Predicate_dist_effectPredicate.isIterable(args[0]), (elements, f, options) => core.flatMap$1(partition(elements, f, {
   concurrency: options?.concurrency,
   batching: options?.batching
-}), ([es, bs]) => es.length === 0 ? options?.discard ? core.unit : core.succeed(bs) : core.fail(es)));
+}), ([es, bs]) => es.length === 0 ? options?.discard ? core.unit : core.succeed(bs) : core.fail$1(es)));
 
 /* @internal */
 const raceAll = all => {
@@ -2432,14 +2432,14 @@ const raceAll = all => {
   }
   const self = Chunk_dist_effectChunk.headNonEmpty(list);
   const effects = Chunk_dist_effectChunk.tailNonEmpty(list);
-  const inheritAll = res => Function_dist_effectFunction.pipe(fiber.inheritAll(res[1]), core.as(res[0]));
-  return Function_dist_effectFunction.pipe(core.deferredMake(), core.flatMap(done => Function_dist_effectFunction.pipe(Ref_dist_effectRef.make(effects.length), core.flatMap(fails => core.uninterruptibleMask(restore => Function_dist_effectFunction.pipe(fork(core.interruptible(self)), core.flatMap(head => Function_dist_effectFunction.pipe(effects, core.forEachSequential(effect => fork(core.interruptible(effect))), core.map(Chunk_dist_effectChunk.unsafeFromArray), core.map(tail => Function_dist_effectFunction.pipe(tail, Chunk_dist_effectChunk.prepend(head))), core.tap(fibers => Function_dist_effectFunction.pipe(fibers, ReadonlyArray_dist_effectReadonlyArray.reduce(core.unit, (effect, fiber$1) => Function_dist_effectFunction.pipe(effect, core.zipRight(Function_dist_effectFunction.pipe(fiber._await(fiber$1), core.flatMap(raceAllArbiter(fibers, fiber$1, done, fails)), fork, core.asUnit)))))), core.flatMap(fibers => Function_dist_effectFunction.pipe(restore(Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred["await"](done), core.flatMap(inheritAll))), core.onInterrupt(() => Function_dist_effectFunction.pipe(fibers, ReadonlyArray_dist_effectReadonlyArray.reduce(core.unit, (effect, fiber) => Function_dist_effectFunction.pipe(effect, core.zipLeft(core.interruptFiber(fiber))))))))))))))));
+  const inheritAll = res => Function_dist_effectFunction.pipe(fiber.inheritAll(res[1]), core.as$1(res[0]));
+  return Function_dist_effectFunction.pipe(core.deferredMake(), core.flatMap$1(done => Function_dist_effectFunction.pipe(Ref_dist_effectRef.make(effects.length), core.flatMap$1(fails => core.uninterruptibleMask(restore => Function_dist_effectFunction.pipe(fork(core.interruptible(self)), core.flatMap$1(head => Function_dist_effectFunction.pipe(effects, core.forEachSequential(effect => fork(core.interruptible(effect))), core.map$1(Chunk_dist_effectChunk.unsafeFromArray), core.map$1(tail => Function_dist_effectFunction.pipe(tail, Chunk_dist_effectChunk.prepend(head))), core.tap(fibers => Function_dist_effectFunction.pipe(fibers, ReadonlyArray_dist_effectReadonlyArray.reduce(core.unit, (effect, fiber$1) => Function_dist_effectFunction.pipe(effect, core.zipRight(Function_dist_effectFunction.pipe(fiber._await(fiber$1), core.flatMap$1(raceAllArbiter(fibers, fiber$1, done, fails)), fork, core.asUnit)))))), core.flatMap$1(fibers => Function_dist_effectFunction.pipe(restore(Function_dist_effectFunction.pipe(Deferred_dist_effectDeferred["await"](done), core.flatMap$1(inheritAll))), core.onInterrupt(() => Function_dist_effectFunction.pipe(fibers, ReadonlyArray_dist_effectReadonlyArray.reduce(core.unit, (effect, fiber) => Function_dist_effectFunction.pipe(effect, core.zipLeft(core.interruptFiber(fiber))))))))))))))));
 };
 
 /* @internal */
 const raceAllArbiter = (fibers, winner, deferred, fails) => exit => core.exitMatchEffect(exit, {
-  onFailure: cause => Function_dist_effectFunction.pipe(Ref_dist_effectRef.modify(fails, fails => [fails === 0 ? Function_dist_effectFunction.pipe(core.deferredFailCause(deferred, cause), core.asUnit) : core.unit, fails - 1]), core.flatten),
-  onSuccess: value => Function_dist_effectFunction.pipe(core.deferredSucceed(deferred, [value, winner]), core.flatMap(set => set ? Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.fromIterable(fibers), ReadonlyArray_dist_effectReadonlyArray.reduce(core.unit, (effect, fiber) => fiber === winner ? effect : Function_dist_effectFunction.pipe(effect, core.zipLeft(core.interruptFiber(fiber))))) : core.unit))
+  onFailure: cause => Function_dist_effectFunction.pipe(Ref_dist_effectRef.modify(fails, fails => [fails === 0 ? Function_dist_effectFunction.pipe(core.deferredFailCause(deferred, cause), core.asUnit) : core.unit, fails - 1]), core.flatten$1),
+  onSuccess: value => Function_dist_effectFunction.pipe(core.deferredSucceed(deferred, [value, winner]), core.flatMap$1(set => set ? Function_dist_effectFunction.pipe(Chunk_dist_effectChunk.fromIterable(fibers), ReadonlyArray_dist_effectReadonlyArray.reduce(core.unit, (effect, fiber) => fiber === winner ? effect : Function_dist_effectFunction.pipe(effect, core.zipLeft(core.interruptFiber(fiber))))) : core.unit))
 });
 
 /* @internal */
@@ -2454,7 +2454,7 @@ const reduceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(args => Pred
         return Option_dist_effectOption.some(f(acc.value, elem, i));
       }
   }
-}, options), core.map(option => {
+}, options), core.map$1(option => {
   switch (option._tag) {
     case "None":
       {
@@ -2476,7 +2476,7 @@ const parallelFinalizers = self => core.contextWithEffect(context => Option_dist
         return self;
       case "Sequential":
       case "ParallelN":
-        return core.flatMap(core.scopeFork(scope, ExecutionStrategy_dist_effectExecutionStrategy.parallel), inner => scopeExtend(self, inner));
+        return core.flatMap$1(core.scopeFork(scope, ExecutionStrategy_dist_effectExecutionStrategy.parallel), inner => scopeExtend(self, inner));
     }
   }
 }));
@@ -2488,7 +2488,7 @@ const parallelNFinalizers = parallelism => self => core.contextWithEffect(contex
     if (scope.strategy._tag === "ParallelN" && scope.strategy.parallelism === parallelism) {
       return self;
     }
-    return core.flatMap(core.scopeFork(scope, ExecutionStrategy_dist_effectExecutionStrategy.parallelN(parallelism)), inner => scopeExtend(self, inner));
+    return core.flatMap$1(core.scopeFork(scope, ExecutionStrategy_dist_effectExecutionStrategy.parallelN(parallelism)), inner => scopeExtend(self, inner));
   }
 }));
 
@@ -2509,10 +2509,10 @@ const finalizersMask = strategy => self => core.contextWithEffect(context => Opt
 }));
 
 /* @internal */
-const scopeWith = f => core.flatMap(scopeTag, f);
+const scopeWith = f => core.flatMap$1(scopeTag, f);
 
 /* @internal */
-const scopedEffect = effect => core.flatMap(scopeMake(), scope => scopeUse(scope)(effect));
+const scopedEffect = effect => core.flatMap$1(scopeMake(), scope => scopeUse(scope)(effect));
 
 /* @internal */
 const sequentialFinalizers = self => core.contextWithEffect(context => Option_dist_effectOption.match(Context_dist_effectContext.getOption(context, scopeTag), {
@@ -2523,7 +2523,7 @@ const sequentialFinalizers = self => core.contextWithEffect(context => Option_di
         return self;
       case "Parallel":
       case "ParallelN":
-        return core.flatMap(core.scopeFork(scope, ExecutionStrategy_dist_effectExecutionStrategy.sequential$1), inner => scopeExtend(self, inner));
+        return core.flatMap$1(core.scopeFork(scope, ExecutionStrategy_dist_effectExecutionStrategy.sequential), inner => scopeExtend(self, inner));
     }
   }
 }));
@@ -2538,13 +2538,13 @@ const labelMetricsScoped = labels => labelMetricsScopedSet(HashSet_dist_effectHa
 const labelMetricsScopedSet = labels => fiberRefLocallyScopedWith(core.currentMetricLabels, set => Function_dist_effectFunction.pipe(set, HashSet_dist_effectHashSet.union(labels)));
 
 /* @internal */
-const using = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, use) => core.acquireUseRelease(scopeMake(), scope => core.flatMap(scopeExtend(self, scope), use), (scope, exit) => core.scopeClose(scope, exit)));
+const using = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, use) => core.acquireUseRelease(scopeMake(), scope => core.flatMap$1(scopeExtend(self, scope), use), (scope, exit) => core.scopeClose(scope, exit)));
 
 /** @internal */
 const validate = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, options) => validateWith(self, that, (a, b) => [a, b], options));
 
 /** @internal */
-const validateWith = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, f, options) => core.flatten(zipWithOptions(core.exit(self), core.exit(that), (ea, eb) => core.exitZipWith(ea, eb, {
+const validateWith = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, f, options) => core.flatten$1(zipWithOptions(core.exit(self), core.exit(that), (ea, eb) => core.exitZipWith(ea, eb, {
   onSuccess: f,
   onFailure: (ca, cb) => options?.concurrent ? core.parallel(ca, cb) : core.sequential(ca, cb)
 }), options)));
@@ -2559,7 +2559,7 @@ const withClockScoped = value => fiberRefLocallyScopedWith(defaultServices.curre
 const withConfigProviderScoped = value => fiberRefLocallyScopedWith(defaultServices.currentServices, Context_dist_effectContext.add(configProvider.configProviderTag, value));
 
 /* @internal */
-const withEarlyRelease = self => scopeWith(parent => core.flatMap(core.scopeFork(parent, ExecutionStrategy_dist_effectExecutionStrategy.sequential), child => Function_dist_effectFunction.pipe(self, scopeExtend(child), core.map(value => [core.fiberIdWith(fiberId => core.scopeClose(child, core.exitInterrupt(fiberId))), value]))));
+const withEarlyRelease = self => scopeWith(parent => core.flatMap$1(core.scopeFork(parent, ExecutionStrategy_dist_effectExecutionStrategy.sequential$1), child => Function_dist_effectFunction.pipe(self, scopeExtend(child), core.map$1(value => [core.fiberIdWith(fiberId => core.scopeClose(child, core.exitInterrupt(fiberId))), value]))));
 
 /** @internal */
 const zipOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (a, b) => [a, b], options));
@@ -2571,7 +2571,7 @@ const zipLeftOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => co
 const zipRightOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (_, b) => b, options));
 
 /** @internal */
-const zipWithOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, f, options) => core.map(all([self, that], {
+const zipWithOptions = /*#__PURE__*/Function_dist_effectFunction.dual(args => core.isEffect(args[1]), (self, that, f, options) => core.map$1(all([self, that], {
   concurrency: options?.concurrent ? 2 : 1,
   batching: options?.batching
 }), ([a, a2]) => f(a, a2)));
@@ -2581,7 +2581,7 @@ const withRuntimeFlagsScoped = update => {
   if (update === RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.empty) {
     return core.unit;
   }
-  return Function_dist_effectFunction.pipe(core.runtimeFlags, core.flatMap(runtimeFlags => {
+  return Function_dist_effectFunction.pipe(core.runtimeFlags, core.flatMap$1(runtimeFlags => {
     const updatedRuntimeFlags = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.patch(runtimeFlags, update);
     const revertRuntimeFlags = RuntimeFlagsPatch_dist_effectRuntimeFlagsPatch.diff(updatedRuntimeFlags, runtimeFlags);
     return Function_dist_effectFunction.pipe(core.updateRuntimeFlags(update), core.zipRight(addFinalizer(() => core.updateRuntimeFlags(revertRuntimeFlags))), core.asUnit);
@@ -2608,9 +2608,9 @@ const releaseMapReleaseAll = (strategy, exit) => self => core.suspend(() => {
           exit,
           update
         };
-        return ExecutionStrategy_dist_effectExecutionStrategy.isSequential(strategy) ? Function_dist_effectFunction.pipe(finalizers, core.forEachSequential(fin => core.exit(update(fin)(exit))), core.flatMap(results => Function_dist_effectFunction.pipe(core.exitCollectAll(results), Option_dist_effectOption.map(core.exitAsUnit), Option_dist_effectOption.getOrElse(() => core.exitUnit)))) : ExecutionStrategy_dist_effectExecutionStrategy.isParallel(strategy) ? Function_dist_effectFunction.pipe(forEachParUnbounded(finalizers, fin => core.exit(update(fin)(exit)), false), core.flatMap(results => Function_dist_effectFunction.pipe(core.exitCollectAll(results, {
+        return ExecutionStrategy_dist_effectExecutionStrategy.isSequential(strategy) ? Function_dist_effectFunction.pipe(finalizers, core.forEachSequential(fin => core.exit(update(fin)(exit))), core.flatMap$1(results => Function_dist_effectFunction.pipe(core.exitCollectAll(results), Option_dist_effectOption.map(core.exitAsUnit), Option_dist_effectOption.getOrElse(() => core.exitUnit)))) : ExecutionStrategy_dist_effectExecutionStrategy.isParallel(strategy) ? Function_dist_effectFunction.pipe(forEachParUnbounded(finalizers, fin => core.exit(update(fin)(exit)), false), core.flatMap$1(results => Function_dist_effectFunction.pipe(core.exitCollectAll(results, {
           parallel: true
-        }), Option_dist_effectOption.map(core.exitAsUnit), Option_dist_effectOption.getOrElse(() => core.exitUnit)))) : Function_dist_effectFunction.pipe(forEachParN(finalizers, strategy.parallelism, fin => core.exit(update(fin)(exit)), false), core.flatMap(results => Function_dist_effectFunction.pipe(core.exitCollectAll(results, {
+        }), Option_dist_effectOption.map(core.exitAsUnit), Option_dist_effectOption.getOrElse(() => core.exitUnit)))) : Function_dist_effectFunction.pipe(forEachParN(finalizers, strategy.parallelism, fin => core.exit(update(fin)(exit)), false), core.flatMap$1(results => Function_dist_effectFunction.pipe(core.exitCollectAll(results, {
           parallel: true
         }), Option_dist_effectOption.map(core.exitAsUnit), Option_dist_effectOption.getOrElse(() => core.exitUnit))));
       }
@@ -2626,14 +2626,14 @@ const scopeTag = /*#__PURE__*/Context_dist_effectContext.Tag(core.ScopeTypeId);
 const scope = scopeTag;
 
 /* @internal */
-const scopeMake = (strategy = ExecutionStrategy_dist_effectExecutionStrategy.sequential) => core.map(core.releaseMapMake, rm => ({
+const scopeMake = (strategy = ExecutionStrategy_dist_effectExecutionStrategy.sequential$1) => core.map$1(core.releaseMapMake, rm => ({
   [core.ScopeTypeId]: core.ScopeTypeId,
   [core.CloseableScopeTypeId]: core.CloseableScopeTypeId,
   strategy,
   pipe() {
     return Pipeable_dist_effectPipeable.pipeArguments(this, arguments);
   },
-  fork: strategy => core.uninterruptible(Function_dist_effectFunction.pipe(scopeMake(strategy), core.flatMap(scope => Function_dist_effectFunction.pipe(core.releaseMapAdd(rm, exit => core.scopeClose(scope, exit)), core.tap(fin => core.scopeAddFinalizerExit(scope, fin)), core.as(scope))))),
+  fork: strategy => core.uninterruptible(Function_dist_effectFunction.pipe(scopeMake(strategy), core.flatMap$1(scope => Function_dist_effectFunction.pipe(core.releaseMapAdd(rm, exit => core.scopeClose(scope, exit)), core.tap(fin => core.scopeAddFinalizerExit(scope, fin)), core.as$1(scope))))),
   close: exit => core.asUnit(releaseMapReleaseAll(strategy, exit)(rm)),
   addFinalizer: fin => core.asUnit(core.releaseMapAdd(fin)(rm))
 }));
@@ -2657,7 +2657,7 @@ const fiberRefUnsafeMakeSupervisor = initial => core.fiberRefUnsafeMakePatch(ini
 // circular with FiberRef
 
 /* @internal */
-const fiberRefLocallyScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => core.asUnit(acquireRelease(core.flatMap(core.fiberRefGet(self), oldValue => core.as(core.fiberRefSet(self, value), oldValue)), oldValue => core.fiberRefSet(self, oldValue))));
+const fiberRefLocallyScoped = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, value) => core.asUnit(acquireRelease(core.flatMap$1(core.fiberRefGet(self), oldValue => core.as$1(core.fiberRefSet(self, value), oldValue)), oldValue => core.fiberRefSet(self, oldValue))));
 
 /* @internal */
 const fiberRefLocallyScopedWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.fiberRefGetWith(self, a => fiberRefLocallyScoped(self, f(a))));
@@ -2689,10 +2689,10 @@ const fiberAwaitAll = fibers => core.asUnit(fiber._await(fiberAll(fibers)));
 const fiberAll = fibers => ({
   [fiber.FiberTypeId]: fiber.fiberVariance,
   id: () => ReadonlyArray_dist_effectReadonlyArray.fromIterable(fibers).reduce((id, fiber) => FiberId_dist_effectFiberId.combine(id, fiber.id()), FiberId_dist_effectFiberId.none),
-  await: () => core.exit(forEachParUnbounded(fibers, fiber => core.flatten(fiber.await()), false)),
-  children: () => core.map(forEachParUnbounded(fibers, fiber => fiber.children(), false), ReadonlyArray_dist_effectReadonlyArray.flatten),
+  await: () => core.exit(forEachParUnbounded(fibers, fiber => core.flatten$1(fiber.await()), false)),
+  children: () => core.map$1(forEachParUnbounded(fibers, fiber => fiber.children(), false), ReadonlyArray_dist_effectReadonlyArray.flatten),
   inheritAll: () => core.forEachSequentialDiscard(fibers, fiber => fiber.inheritAll()),
-  poll: () => core.map(core.forEachSequential(fibers, fiber => fiber.poll()), ReadonlyArray_dist_effectReadonlyArray.reduceRight(Option_dist_effectOption.some(core.exitSucceed(new Array())), (optionB, optionA) => {
+  poll: () => core.map$1(core.forEachSequential(fibers, fiber => fiber.poll()), ReadonlyArray_dist_effectReadonlyArray.reduceRight(Option_dist_effectOption.some(core.exitSucceed(new Array())), (optionB, optionA) => {
     switch (optionA._tag) {
       case "None":
         {
@@ -2737,11 +2737,11 @@ const fiberScoped = self => acquireRelease(core.succeed(self), core.interruptFib
 
 /** @internal */
 const raceWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other, options) => raceFibersWith(self, other, {
-  onSelfWin: (winner, loser) => core.flatMap(winner.await(), exit => {
+  onSelfWin: (winner, loser) => core.flatMap$1(winner.await(), exit => {
     switch (exit._tag) {
       case Effectable.OP_SUCCESS:
         {
-          return core.flatMap(winner.inheritAll(), () => options.onSelfDone(exit, loser));
+          return core.flatMap$1(winner.inheritAll(), () => options.onSelfDone(exit, loser));
         }
       case Effectable.OP_FAILURE:
         {
@@ -2749,11 +2749,11 @@ const raceWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other,
         }
     }
   }),
-  onOtherWin: (winner, loser) => core.flatMap(winner.await(), exit => {
+  onOtherWin: (winner, loser) => core.flatMap$1(winner.await(), exit => {
     switch (exit._tag) {
       case Effectable.OP_SUCCESS:
         {
-          return core.flatMap(winner.inheritAll(), () => options.onOtherDone(exit, loser));
+          return core.flatMap$1(winner.inheritAll(), () => options.onOtherDone(exit, loser));
         }
       case Effectable.OP_FAILURE:
         {
@@ -2764,17 +2764,17 @@ const raceWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, other,
 }));
 
 /** @internal */
-const disconnect = self => core.uninterruptibleMask(restore => core.fiberIdWith(fiberId => core.flatMap(forkDaemon(restore(self)), fiber$1 => Function_dist_effectFunction.pipe(restore(fiber.join(fiber$1)), core.onInterrupt(() => Function_dist_effectFunction.pipe(fiber$1, fiber.interruptAsFork(fiberId)))))));
+const disconnect = self => core.uninterruptibleMask(restore => core.fiberIdWith(fiberId => core.flatMap$1(forkDaemon(restore(self)), fiber$1 => Function_dist_effectFunction.pipe(restore(fiber.join(fiber$1)), core.onInterrupt(() => Function_dist_effectFunction.pipe(fiber$1, fiber.interruptAsFork(fiberId)))))));
 
 /** @internal */
 const race = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => core.fiberIdWith(parentFiberId => raceWith(self, that, {
   onSelfDone: (exit, right) => core.exitMatchEffect(exit, {
     onFailure: cause => Function_dist_effectFunction.pipe(fiber.join(right), coreEffect.mapErrorCause(cause2 => core.parallel(cause, cause2))),
-    onSuccess: value => Function_dist_effectFunction.pipe(right, core.interruptAsFiber(parentFiberId), core.as(value))
+    onSuccess: value => Function_dist_effectFunction.pipe(right, core.interruptAsFiber(parentFiberId), core.as$1(value))
   }),
   onOtherDone: (exit, left) => core.exitMatchEffect(exit, {
     onFailure: cause => Function_dist_effectFunction.pipe(fiber.join(left), coreEffect.mapErrorCause(cause2 => core.parallel(cause2, cause))),
-    onSuccess: value => Function_dist_effectFunction.pipe(left, core.interruptAsFiber(parentFiberId), core.as(value))
+    onSuccess: value => Function_dist_effectFunction.pipe(left, core.interruptAsFiber(parentFiberId), core.as$1(value))
   })
 })));
 
@@ -2803,11 +2803,11 @@ const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finali
     onFailure: cause2 => core.failCause(core.sequential(cause1, cause2)),
     onSuccess: () => core.failCause(cause1)
   }),
-  onSuccess: a => core.as(finalizer, a)
+  onSuccess: a => core.as$1(finalizer, a)
 })));
 
 /** @internal */
-const invokeWithInterrupt = (dataSource, all) => core.fiberIdWith(id => core.flatMap(core.flatMap(forkDaemon(core.interruptible(dataSource)), processing => core.async(cb => {
+const invokeWithInterrupt = (dataSource, all) => core.fiberIdWith(id => core.flatMap$1(core.flatMap$1(forkDaemon(core.interruptible(dataSource)), processing => core.async(cb => {
   const counts = all.map(_ => _.listeners.count);
   const checkDone = () => {
     if (counts.every(count => count === 0)) {
@@ -2850,10 +2850,10 @@ const interruptWhenPossible = /*#__PURE__*/Function_dist_effectFunction.dual(2,
 // circular Tracer
 
 /** @internal */
-const useSpanScoped = (name, options) => acquireRelease(coreEffect.makeSpan(name, options), (span, exit) => core.flatMap(coreEffect.currentTimeNanosTracing, endTime => core.sync(() => span.end(endTime, exit))));
+const useSpanScoped = (name, options) => acquireRelease(coreEffect.makeSpan(name, options), (span, exit) => core.flatMap$1(coreEffect.currentTimeNanosTracing, endTime => core.sync(() => span.end(endTime, exit))));
 
 /* @internal */
-const withSpanScoped = (name, options) => core.flatMap(useSpanScoped(name, options), span => fiberRefLocallyScopedWith(core.currentTracerSpan, List_dist_effectList.prepend(span)));
+const withSpanScoped = (name, options) => core.flatMap$1(useSpanScoped(name, options), span => fiberRefLocallyScopedWith(core.currentTracerSpan, List_dist_effectList.prepend(span)));
 
 /* @internal */
 const withTracerScoped = value => fiberRefLocallyScopedWith(defaultServices.currentServices, Context_dist_effectContext.add(defaultServices.tracerTag, value));