effect 3.12.0 → 3.12.2

package/dist/esm/internal/fiberRuntime.js

@@ -24,7 +24,7 @@ import * as Ref from "../Ref.js";
 import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js";
 import { currentScheduler } from "../Scheduler.js";
 import { internalCall, yieldWrapGet } from "../Utils.js";
-import * as _RequestBlock from "./blockedRequests.js";
+import * as RequestBlock_ from "./blockedRequests.js";
 import * as internalCause from "./cause.js";
 import * as clock from "./clock.js";
 import { currentRequestMap } from "./completedRequestMap.js";
@@ -46,7 +46,7 @@ import * as metricLabel from "./metric/label.js";
 import * as OpCodes from "./opCodes/effect.js";
 import { randomTag } from "./random.js";
 import { complete } from "./request.js";
-import * as _runtimeFlags from "./runtimeFlags.js";
+import * as runtimeFlags_ from "./runtimeFlags.js";
 import { OpSupervision } from "./runtimeFlags.js";
 import * as supervisor from "./supervisor.js";
 import * as SupervisorPatch from "./supervisor/patch.js";
@@ -103,7 +103,7 @@ const contOpSuccess = {
   },
   [OpCodes.OP_REVERT_FLAGS]: (self, cont, value) => {
     self.patchRuntimeFlags(self.currentRuntimeFlags, cont.patch);
-    if (_runtimeFlags.interruptible(self.currentRuntimeFlags) && self.isInterrupted()) {
+    if (runtimeFlags_.interruptible(self.currentRuntimeFlags) && self.isInterrupted()) {
       return core.exitFailCause(self.getInterruptedCause());
     } else {
       return core.exitSucceed(value);
@@ -128,7 +128,7 @@ const contOpSuccess = {
 const drainQueueWhileRunningTable = {
   [FiberMessage.OP_INTERRUPT_SIGNAL]: (self, runtimeFlags, cur, message) => {
     self.processNewInterruptSignal(message.cause);
-    return _runtimeFlags.interruptible(runtimeFlags) ? core.exitFailCause(message.cause) : cur;
+    return runtimeFlags_.interruptible(runtimeFlags) ? core.exitFailCause(message.cause) : cur;
   },
   [FiberMessage.OP_RESUME]: (_self, _runtimeFlags, _cur, _message) => {
     throw new Error("It is illegal to have multiple concurrent run loops in a single fiber");
@@ -144,7 +144,7 @@ const drainQueueWhileRunningTable = {
 /**
  * Executes all requests, submitting requests to each data source in parallel.
  */
-const runBlockedRequests = self => core.forEachSequentialDiscard(_RequestBlock.flatten(self), requestsByRequestResolver => forEachConcurrentDiscard(_RequestBlock.sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential]) => {
+const runBlockedRequests = self => core.forEachSequentialDiscard(RequestBlock_.flatten(self), requestsByRequestResolver => forEachConcurrentDiscard(RequestBlock_.sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential]) => {
   const map = new Map();
   const arr = [];
   for (const block of sequential) {
@@ -158,6 +158,7 @@ const runBlockedRequests = self => core.forEachSequentialDiscard(_RequestBlock.f
     entry.listeners.interrupted = true;
   })), currentRequestMap, map);
 }, false, false));
+const _version = /*#__PURE__*/version.getCurrentVersion();
 /** @internal */
 export class FiberRuntime extends Effectable.Class {
   [internalFiber.FiberTypeId] = internalFiber.fiberVariance;
@@ -187,7 +188,7 @@ export class FiberRuntime extends Effectable.Class {
     this.currentRuntimeFlags = runtimeFlags0;
     this._fiberId = fiberId;
     this._fiberRefs = fiberRefs0;
-    if (_runtimeFlags.runtimeMetrics(runtimeFlags0)) {
+    if (runtimeFlags_.runtimeMetrics(runtimeFlags0)) {
       const tags = this.getFiberRef(core.currentMetricLabels);
       fiberStarted.unsafeUpdate(1, tags);
       fiberActive.unsafeUpdate(1, tags);
@@ -316,9 +317,9 @@ export class FiberRuntime extends Effectable.Class {
       const updatedFiberRefs = fiberRefs.joinAs(parentFiberRefs, parentFiberId, childFiberRefs);
       parentFiber.setFiberRefs(updatedFiberRefs);
       const updatedRuntimeFlags = parentFiber.getFiberRef(currentRuntimeFlags);
-      const patch = pipe(_runtimeFlags.diff(parentRuntimeFlags, updatedRuntimeFlags),
+      const patch = pipe(runtimeFlags_.diff(parentRuntimeFlags, updatedRuntimeFlags),
       // Do not inherit WindDown or Interruption!
-      RuntimeFlagsPatch.exclude(_runtimeFlags.Interruption), RuntimeFlagsPatch.exclude(_runtimeFlags.WindDown));
+      RuntimeFlagsPatch.exclude(runtimeFlags_.Interruption), RuntimeFlagsPatch.exclude(runtimeFlags_.WindDown));
       return core.updateRuntimeFlags(patch);
     });
   }
@@ -612,7 +613,7 @@ export class FiberRuntime extends Effectable.Class {
     return null;
   }
   reportExitValue(exit) {
-    if (_runtimeFlags.runtimeMetrics(this.currentRuntimeFlags)) {
+    if (runtimeFlags_.runtimeMetrics(this.currentRuntimeFlags)) {
       const tags = this.getFiberRef(core.currentMetricLabels);
       const startTimeMillis = this.id().startTimeMillis;
       const endTimeMillis = Date.now();
@@ -726,7 +727,7 @@ export class FiberRuntime extends Effectable.Class {
   evaluateEffect(effect0) {
     this.currentSupervisor.onResume(this);
     try {
-      let effect = _runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted() ? core.exitFailCause(this.getInterruptedCause()) : effect0;
+      let effect = runtimeFlags_.interruptible(this.currentRuntimeFlags) && this.isInterrupted() ? core.exitFailCause(this.getInterruptedCause()) : effect0;
       while (effect !== null) {
         const eff = effect;
         const exit = this.runLoop(eff);
@@ -734,7 +735,7 @@ export class FiberRuntime extends Effectable.Class {
           const op = yieldedOpChannel.currentOp;
           yieldedOpChannel.currentOp = null;
           if (op._op === OpCodes.OP_YIELD) {
-            if (_runtimeFlags.cooperativeYielding(this.currentRuntimeFlags)) {
+            if (runtimeFlags_.cooperativeYielding(this.currentRuntimeFlags)) {
               this.tell(FiberMessage.yieldNow());
               this.tell(FiberMessage.resume(core.exitVoid));
               effect = null;
@@ -746,7 +747,7 @@ export class FiberRuntime extends Effectable.Class {
             effect = null;
           }
         } else {
-          this.currentRuntimeFlags = pipe(this.currentRuntimeFlags, _runtimeFlags.enable(_runtimeFlags.WindDown));
+          this.currentRuntimeFlags = pipe(this.currentRuntimeFlags, runtimeFlags_.enable(runtimeFlags_.WindDown));
           const interruption = this.interruptAllChildren();
           if (interruption !== null) {
             effect = core.flatMap(interruption, () => exit);
@@ -815,7 +816,7 @@ export class FiberRuntime extends Effectable.Class {
    * **NOTE**: This method must be invoked by the fiber itself.
    */
   patchRuntimeFlags(oldRuntimeFlags, patch) {
-    const newRuntimeFlags = _runtimeFlags.patch(oldRuntimeFlags, patch);
+    const newRuntimeFlags = runtimeFlags_.patch(oldRuntimeFlags, patch);
     globalThis[internalFiber.currentFiberURI] = this;
     this.currentRuntimeFlags = newRuntimeFlags;
     return newRuntimeFlags;
@@ -835,7 +836,7 @@ export class FiberRuntime extends Effectable.Class {
         this.tell(FiberMessage.resume(effect));
       }
     };
-    if (_runtimeFlags.interruptible(runtimeFlags)) {
+    if (runtimeFlags_.interruptible(runtimeFlags)) {
       this._asyncInterruptor = callback;
     }
     try {
@@ -965,7 +966,7 @@ export class FiberRuntime extends Effectable.Class {
         case OpCodes.OP_ON_FAILURE:
         case OpCodes.OP_ON_SUCCESS_AND_FAILURE:
           {
-            if (!(_runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
+            if (!(runtimeFlags_.interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
               return internalCall(() => cont.effect_instruction_i1(cause));
             } else {
               return core.exitFailCause(internalCause.stripFailures(cause));
@@ -973,7 +974,7 @@ export class FiberRuntime extends Effectable.Class {
           }
         case "OnStep":
           {
-            if (!(_runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
+            if (!(runtimeFlags_.interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
               return core.exitSucceed(core.exitFailCause(cause));
             } else {
               return core.exitFailCause(internalCause.stripFailures(cause));
@@ -982,7 +983,7 @@ export class FiberRuntime extends Effectable.Class {
         case OpCodes.OP_REVERT_FLAGS:
           {
             this.patchRuntimeFlags(this.currentRuntimeFlags, cont.patch);
-            if (_runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted()) {
+            if (runtimeFlags_.interruptible(this.currentRuntimeFlags) && this.isInterrupted()) {
               return core.exitFailCause(internalCause.sequential(cause, this.getInterruptedCause()));
             } else {
               return core.exitFailCause(cause);
@@ -1015,13 +1016,13 @@ export class FiberRuntime extends Effectable.Class {
       this.setFiberRefs(snap.refs);
       this.currentRuntimeFlags = snap.flags;
       const patchRefs = FiberRefsPatch.diff(snap.refs, refs);
-      const patchFlags = _runtimeFlags.diff(snap.flags, flags);
+      const patchFlags = runtimeFlags_.diff(snap.flags, flags);
       return core.exitSucceed(core.blocked(op.effect_instruction_i0, core.withFiberRuntime(newFiber => {
         while (frames.length > 0) {
           newFiber.pushStack(frames.pop());
         }
         newFiber.setFiberRefs(FiberRefsPatch.patch(newFiber.id(), newFiber.getFiberRefs())(patchRefs));
-        newFiber.currentRuntimeFlags = _runtimeFlags.patch(patchFlags)(newFiber.currentRuntimeFlags);
+        newFiber.currentRuntimeFlags = runtimeFlags_.patch(patchFlags)(newFiber.currentRuntimeFlags);
         return op.effect_instruction_i1;
       })));
     }
@@ -1033,19 +1034,19 @@ export class FiberRuntime extends Effectable.Class {
   [OpCodes.OP_UPDATE_RUNTIME_FLAGS](op) {
     const updateFlags = op.effect_instruction_i0;
     const oldRuntimeFlags = this.currentRuntimeFlags;
-    const newRuntimeFlags = _runtimeFlags.patch(oldRuntimeFlags, updateFlags);
+    const newRuntimeFlags = runtimeFlags_.patch(oldRuntimeFlags, updateFlags);
     // One more chance to short circuit: if we're immediately going
     // to interrupt. Interruption will cause immediate reversion of
     // the flag, so as long as we "peek ahead", there's no need to
     // set them to begin with.
-    if (_runtimeFlags.interruptible(newRuntimeFlags) && this.isInterrupted()) {
+    if (runtimeFlags_.interruptible(newRuntimeFlags) && this.isInterrupted()) {
       return core.exitFailCause(this.getInterruptedCause());
     } else {
       // Impossible to short circuit, so record the changes
       this.patchRuntimeFlags(this.currentRuntimeFlags, updateFlags);
       if (op.effect_instruction_i1) {
         // Since we updated the flags, we need to revert them
-        const revertFlags = _runtimeFlags.diff(newRuntimeFlags, oldRuntimeFlags);
+        const revertFlags = runtimeFlags_.diff(newRuntimeFlags, oldRuntimeFlags);
         this.pushStack(new core.RevertFlags(revertFlags, op));
         return internalCall(() => op.effect_instruction_i1(oldRuntimeFlags));
       } else {
@@ -1126,7 +1127,7 @@ export class FiberRuntime extends Effectable.Class {
       try {
         // @ts-expect-error
         cur = this.currentTracer.context(() => {
-          if (version.getCurrentVersion() !== cur[core.EffectTypeId]._V) {
+          if (_version !== cur[core.EffectTypeId]._V) {
             return core.dieMessage(`Cannot execute an Effect versioned ${cur[core.EffectTypeId]._V} with a Runtime of version ${version.getCurrentVersion()}`);
           }
           // @ts-expect-error
@@ -1143,8 +1144,6 @@ export class FiberRuntime extends Effectable.Class {
       } catch (e) {
         if (cur !== YieldedOp && !Predicate.hasProperty(cur, "_op") || !(cur._op in this)) {
           cur = core.dieMessage(`Not a valid effect: ${Inspectable.toStringUnknown(cur)}`);
-        } else if (core.isEffectError(e)) {
-          cur = core.exitFailCause(e.cause);
         } else if (core.isInterruptedException(e)) {
           cur = core.exitFailCause(internalCause.sequential(internalCause.die(e), internalCause.interrupt(FiberId.none)));
         } else {
@@ -1281,7 +1280,7 @@ export const addFinalizer = finalizer => core.withFiberRuntime(runtime => {
     const preRefs = runtimeFinalizer.getFiberRefs();
     const preFlags = runtimeFinalizer.currentRuntimeFlags;
     const patchRefs = FiberRefsPatch.diff(preRefs, acquireRefs);
-    const patchFlags = _runtimeFlags.diff(preFlags, acquireFlags);
+    const patchFlags = runtimeFlags_.diff(preFlags, acquireFlags);
     const inverseRefs = FiberRefsPatch.diff(acquireRefs, preRefs);
     runtimeFinalizer.setFiberRefs(FiberRefsPatch.patch(patchRefs, runtimeFinalizer.id(), acquireRefs));
     return ensuring(core.withRuntimeFlags(finalizer(exit), patchFlags), core.sync(() => {
@@ -1339,7 +1338,8 @@ const allValidate = (effects, reconcile, options) => {
   }
   return core.flatMap(forEach(eitherEffects, identity, {
     concurrency: options?.concurrency,
-    batching: options?.batching
+    batching: options?.batching,
+    concurrentFinalizers: options?.concurrentFinalizers
   }), eithers => {
     const none = Option.none();
     const size = eithers.length;
@@ -1373,12 +1373,14 @@ const allEither = (effects, reconcile, options) => {
     return forEach(eitherEffects, identity, {
       concurrency: options?.concurrency,
       batching: options?.batching,
-      discard: true
+      discard: true,
+      concurrentFinalizers: options?.concurrentFinalizers
     });
   }
   return core.map(forEach(eitherEffects, identity, {
     concurrency: options?.concurrency,
-    batching: options?.batching
+    batching: options?.batching,
+    concurrentFinalizers: options?.concurrentFinalizers
   }), eithers => reconcile._tag === "Some" ? reconcile.value(eithers) : eithers);
 };
 /* @internal */
@@ -1523,7 +1525,7 @@ export const forEachConcurrentDiscard = (self, f, batching, processAll, n) => co
               parallel: true
             }), () => core.exitVoid)));
           } else if (residual.length + results.length === target) {
-            const requests = residual.map(blocked => blocked.effect_instruction_i0).reduce(_RequestBlock.par);
+            const requests = residual.map(blocked => blocked.effect_instruction_i0).reduce(RequestBlock_.par);
             resume(core.succeed(core.blocked(requests, forEachConcurrentDiscard([Option.getOrElse(core.exitCollectAll(collectExits(), {
               parallel: true
             }), () => core.exitVoid), ...residual.map(blocked => blocked.effect_instruction_i1)], i => i, batching, true, n))));
@@ -1628,8 +1630,9 @@ export const partition = /*#__PURE__*/dual(args => Predicate.isIterable(args[0])
 /* @internal */
 export const validateAll = /*#__PURE__*/dual(args => Predicate.isIterable(args[0]), (elements, f, options) => core.flatMap(partition(elements, f, {
   concurrency: options?.concurrency,
-  batching: options?.batching
-}), ([es, bs]) => es.length === 0 ? options?.discard ? core.void : core.succeed(bs) : core.fail(es)));
+  batching: options?.batching,
+  concurrentFinalizers: options?.concurrentFinalizers
+}), ([es, bs]) => RA.isNonEmptyArray(es) ? core.fail(es) : options?.discard ? core.void : core.succeed(bs)));
 /* @internal */
 export const raceAll = all => {
   const list = Chunk.fromIterable(all);
@@ -1752,11 +1755,11 @@ export const validateAllParDiscard = /*#__PURE__*/dual(2, (elements, f) => core.
 /* @internal */
 export const validateFirst = /*#__PURE__*/dual(args => Predicate.isIterable(args[0]), (elements, f, options) => core.flip(forEach(elements, (a, i) => core.flip(f(a, i)), options)));
 /* @internal */
-export const withClockScoped = value => fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(clock.clockTag, value));
+export const withClockScoped = c => fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(clock.clockTag, c));
 /* @internal */
 export const withRandomScoped = value => fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(randomTag, value));
 /* @internal */
-export const withConfigProviderScoped = value => fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(configProviderTag, value));
+export const withConfigProviderScoped = provider => fiberRefLocallyScopedWith(defaultServices.currentServices, Context.add(configProviderTag, provider));
 /* @internal */
 export const withEarlyRelease = self => scopeWith(parent => core.flatMap(core.scopeFork(parent, executionStrategy.sequential), child => pipe(self, scopeExtend(child), core.map(value => [core.fiberIdWith(fiberId => core.scopeClose(child, core.exitInterrupt(fiberId))), value]))));
 /** @internal */
@@ -1787,8 +1790,8 @@ export const withRuntimeFlagsScoped = update => {
     return core.void;
   }
   return pipe(core.runtimeFlags, core.flatMap(runtimeFlags => {
-    const updatedRuntimeFlags = _runtimeFlags.patch(runtimeFlags, update);
-    const revertRuntimeFlags = _runtimeFlags.diff(updatedRuntimeFlags, runtimeFlags);
+    const updatedRuntimeFlags = runtimeFlags_.patch(runtimeFlags, update);
+    const revertRuntimeFlags = runtimeFlags_.diff(updatedRuntimeFlags, runtimeFlags);
     return pipe(core.updateRuntimeFlags(update), core.zipRight(addFinalizer(() => core.updateRuntimeFlags(revertRuntimeFlags))), core.asVoid);
   }), core.uninterruptible);
 };
@@ -1892,7 +1895,7 @@ export const fiberRefMakeContext = initial => fiberRefMakeWith(() => core.fiberR
 /* @internal */
 export const fiberRefMakeRuntimeFlags = initial => fiberRefMakeWith(() => core.fiberRefUnsafeMakeRuntimeFlags(initial));
 /** @internal */
-export const currentRuntimeFlags = /*#__PURE__*/core.fiberRefUnsafeMakeRuntimeFlags(_runtimeFlags.none);
+export const currentRuntimeFlags = /*#__PURE__*/core.fiberRefUnsafeMakeRuntimeFlags(runtimeFlags_.none);
 /** @internal */
 export const currentSupervisor = /*#__PURE__*/fiberRefUnsafeMakeSupervisor(supervisor.none);
 // circular with Fiber