effect 3.7.3 → 3.8.0

package/dist/esm/internal/fiberRuntime.js

@@ -4,7 +4,7 @@ import * as Boolean from "../Boolean.js";
 import * as Chunk from "../Chunk.js";
 import * as Context from "../Context.js";
 import * as Deferred from "../Deferred.js";
-import { EffectTypeId } from "../Effectable.js";
+import * as Effectable from "../Effectable.js";
 import * as ExecutionStrategy from "../ExecutionStrategy.js";
 import * as FiberId from "../FiberId.js";
 import * as FiberRefs from "../FiberRefs.js";
@@ -102,8 +102,8 @@ const contOpSuccess = {
     return internalCall(() => cont.effect_instruction_i2(value));
   },
   [OpCodes.OP_REVERT_FLAGS]: (self, cont, value) => {
-    self.patchRuntimeFlags(self._runtimeFlags, cont.patch);
-    if (_runtimeFlags.interruptible(self._runtimeFlags) && self.isInterrupted()) {
+    self.patchRuntimeFlags(self.currentRuntimeFlags, cont.patch);
+    if (_runtimeFlags.interruptible(self.currentRuntimeFlags) && self.isInterrupted()) {
       return core.exitFailCause(self.getInterruptedCause());
     } else {
       return core.exitSucceed(value);
@@ -153,15 +153,11 @@ const runBlockedRequests = self => core.forEachSequentialDiscard(_RequestBlock.f
   })), currentRequestMap, map);
 }, false, false));
 /** @internal */
-export class FiberRuntime {
+export class FiberRuntime extends Effectable.Class {
   [internalFiber.FiberTypeId] = internalFiber.fiberVariance;
   [internalFiber.RuntimeFiberTypeId] = runtimeFiberVariance;
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
   _fiberRefs;
   _fiberId;
-  _runtimeFlags;
   _queue = /*#__PURE__*/new Array();
   _children = null;
   _observers = /*#__PURE__*/new Array();
@@ -171,23 +167,29 @@ export class FiberRuntime {
   _asyncBlockingOn = null;
   _exitValue = null;
   _steps = [];
-  _supervisor;
-  _scheduler;
-  _tracer;
+  _isYielding = false;
+  currentRuntimeFlags;
   currentOpCount = 0;
-  isYielding = false;
+  currentSupervisor;
+  currentScheduler;
+  currentTracer;
+  currentSpan;
+  currentContext;
+  currentDefaultServices;
   constructor(fiberId, fiberRefs0, runtimeFlags0) {
-    this._runtimeFlags = runtimeFlags0;
+    super();
+    this.currentRuntimeFlags = runtimeFlags0;
     this._fiberId = fiberId;
     this._fiberRefs = fiberRefs0;
-    this._supervisor = this.getFiberRef(currentSupervisor);
-    this._scheduler = this.getFiberRef(currentScheduler);
     if (_runtimeFlags.runtimeMetrics(runtimeFlags0)) {
       const tags = this.getFiberRef(core.currentMetricLabels);
       fiberStarted.unsafeUpdate(1, tags);
       fiberActive.unsafeUpdate(1, tags);
     }
-    this._tracer = Context.get(this.getFiberRef(defaultServices.currentServices), tracer.tracerTag);
+    this.refreshRefCache();
+  }
+  commit() {
+    return internalFiber.join(this);
   }
   /**
    * The identity of the fiber.
@@ -215,7 +217,7 @@ export class FiberRuntime {
   get runtimeFlags() {
     return this.ask((state, status) => {
       if (FiberStatus.isDone(status)) {
-        return state._runtimeFlags;
+        return state.currentRuntimeFlags;
       }
       return status.runtimeFlags;
     });
@@ -369,7 +371,7 @@ export class FiberRuntime {
    * log annotations and log level) may not be up-to-date.
    */
   getFiberRefs() {
-    this.setFiberRef(currentRuntimeFlags, this._runtimeFlags);
+    this.setFiberRef(currentRuntimeFlags, this.currentRuntimeFlags);
     return this._fiberRefs;
   }
   /**
@@ -407,9 +409,12 @@ export class FiberRuntime {
     this.refreshRefCache();
   }
   refreshRefCache() {
-    this._tracer = Context.get(this.getFiberRef(defaultServices.currentServices), tracer.tracerTag);
-    this._supervisor = this.getFiberRef(currentSupervisor);
-    this._scheduler = this.getFiberRef(currentScheduler);
+    this.currentDefaultServices = this.getFiberRef(defaultServices.currentServices);
+    this.currentTracer = this.currentDefaultServices.unsafeMap.get(tracer.tracerTag.key);
+    this.currentSupervisor = this.getFiberRef(currentSupervisor);
+    this.currentScheduler = this.getFiberRef(currentScheduler);
+    this.currentContext = this.getFiberRef(core.currentContext);
+    this.currentSpan = this.currentContext.unsafeMap.get(tracer.spanTag.key);
   }
   /**
    * Wholesale replaces all fiber refs of this fiber.
@@ -483,7 +488,7 @@ export class FiberRuntime {
    * **NOTE**: This method must be invoked by the fiber itself.
    */
   drainQueueLaterOnExecutor() {
-    this._scheduler.scheduleTask(this.run, this.getFiberRef(core.currentSchedulingPriority));
+    this.currentScheduler.scheduleTask(this.run, this.getFiberRef(core.currentSchedulingPriority));
   }
   /**
    * Drains the fiber's message queue while the fiber is actively running,
@@ -581,7 +586,7 @@ export class FiberRuntime {
     return null;
   }
   reportExitValue(exit) {
-    if (_runtimeFlags.runtimeMetrics(this._runtimeFlags)) {
+    if (_runtimeFlags.runtimeMetrics(this.currentRuntimeFlags)) {
       const tags = this.getFiberRef(core.currentMetricLabels);
       const startTimeMillis = this.id().startTimeMillis;
       const endTimeMillis = Date.now();
@@ -675,7 +680,7 @@ export class FiberRuntime {
         }
       case FiberMessage.OP_STATEFUL:
         {
-          message.onFiber(this, this._exitValue !== null ? FiberStatus.done : FiberStatus.suspended(this._runtimeFlags, this._asyncBlockingOn));
+          message.onFiber(this, this._exitValue !== null ? FiberStatus.done : FiberStatus.suspended(this.currentRuntimeFlags, this._asyncBlockingOn));
           return EvaluationSignalContinue;
         }
       default:
@@ -690,9 +695,9 @@ export class FiberRuntime {
    * **NOTE**: This method must be invoked by the fiber itself.
    */
   evaluateEffect(effect0) {
-    this._supervisor.onResume(this);
+    this.currentSupervisor.onResume(this);
     try {
-      let effect = _runtimeFlags.interruptible(this._runtimeFlags) && 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);
@@ -700,7 +705,7 @@ export class FiberRuntime {
           const op = yieldedOpChannel.currentOp;
           yieldedOpChannel.currentOp = null;
           if (op._op === OpCodes.OP_YIELD) {
-            if (_runtimeFlags.cooperativeYielding(this._runtimeFlags)) {
+            if (_runtimeFlags.cooperativeYielding(this.currentRuntimeFlags)) {
               this.tell(FiberMessage.yieldNow());
               this.tell(FiberMessage.resume(core.exitVoid));
               effect = null;
@@ -712,7 +717,7 @@ export class FiberRuntime {
             effect = null;
           }
         } else {
-          this._runtimeFlags = pipe(this._runtimeFlags, _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);
@@ -731,7 +736,7 @@ export class FiberRuntime {
         }
       }
     } finally {
-      this._supervisor.onSuspend(this);
+      this.currentSupervisor.onSuspend(this);
     }
   }
   /**
@@ -783,7 +788,7 @@ export class FiberRuntime {
   patchRuntimeFlags(oldRuntimeFlags, patch) {
     const newRuntimeFlags = _runtimeFlags.patch(oldRuntimeFlags, patch);
     globalThis[internalFiber.currentFiberURI] = this;
-    this._runtimeFlags = newRuntimeFlags;
+    this.currentRuntimeFlags = newRuntimeFlags;
     return newRuntimeFlags;
   }
   /**
@@ -815,7 +820,7 @@ export class FiberRuntime {
     if (cont._op === "OnStep") {
       this._steps.push({
         refs: this.getFiberRefs(),
-        flags: this._runtimeFlags
+        flags: this.currentRuntimeFlags
       });
     }
   }
@@ -848,7 +853,7 @@ export class FiberRuntime {
     }
   }
   [OpCodes.OP_TAG](op) {
-    return core.map(core.fiberRefGet(core.currentContext), context => Context.unsafeGet(context, op));
+    return core.sync(() => Context.unsafeGet(this.currentContext, op));
   }
   ["Left"](op) {
     return core.fail(op.left);
@@ -931,7 +936,7 @@ export class FiberRuntime {
         case OpCodes.OP_ON_FAILURE:
         case OpCodes.OP_ON_SUCCESS_AND_FAILURE:
           {
-            if (!(_runtimeFlags.interruptible(this._runtimeFlags) && this.isInterrupted())) {
+            if (!(_runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
               return internalCall(() => cont.effect_instruction_i1(cause));
             } else {
               return core.exitFailCause(internalCause.stripFailures(cause));
@@ -939,7 +944,7 @@ export class FiberRuntime {
           }
         case "OnStep":
           {
-            if (!(_runtimeFlags.interruptible(this._runtimeFlags) && this.isInterrupted())) {
+            if (!(_runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
               return core.exitSucceed(core.exitFailCause(cause));
             } else {
               return core.exitFailCause(internalCause.stripFailures(cause));
@@ -947,8 +952,8 @@ export class FiberRuntime {
           }
         case OpCodes.OP_REVERT_FLAGS:
           {
-            this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
-            if (_runtimeFlags.interruptible(this._runtimeFlags) && this.isInterrupted()) {
+            this.patchRuntimeFlags(this.currentRuntimeFlags, cont.patch);
+            if (_runtimeFlags.interruptible(this.currentRuntimeFlags) && this.isInterrupted()) {
               return core.exitFailCause(internalCause.sequential(cause, this.getInterruptedCause()));
             } else {
               return core.exitFailCause(cause);
@@ -965,11 +970,11 @@ export class FiberRuntime {
     }
   }
   [OpCodes.OP_WITH_RUNTIME](op) {
-    return internalCall(() => op.effect_instruction_i0(this, FiberStatus.running(this._runtimeFlags)));
+    return internalCall(() => op.effect_instruction_i0(this, FiberStatus.running(this.currentRuntimeFlags)));
   }
   ["Blocked"](op) {
     const refs = this.getFiberRefs();
-    const flags = this._runtimeFlags;
+    const flags = this.currentRuntimeFlags;
     if (this._steps.length > 0) {
       const frames = [];
       const snap = this._steps[this._steps.length - 1];
@@ -979,7 +984,7 @@ export class FiberRuntime {
         frame = this.popStack();
       }
       this.setFiberRefs(snap.refs);
-      this._runtimeFlags = snap.flags;
+      this.currentRuntimeFlags = snap.flags;
       const patchRefs = FiberRefsPatch.diff(snap.refs, refs);
       const patchFlags = _runtimeFlags.diff(snap.flags, flags);
       return core.exitSucceed(core.blocked(op.effect_instruction_i0, core.withFiberRuntime(newFiber => {
@@ -987,7 +992,7 @@ export class FiberRuntime {
           newFiber.pushStack(frames.pop());
         }
         newFiber.setFiberRefs(FiberRefsPatch.patch(newFiber.id(), newFiber.getFiberRefs())(patchRefs));
-        newFiber._runtimeFlags = _runtimeFlags.patch(patchFlags)(newFiber._runtimeFlags);
+        newFiber.currentRuntimeFlags = _runtimeFlags.patch(patchFlags)(newFiber.currentRuntimeFlags);
         return op.effect_instruction_i1;
       })));
     }
@@ -998,7 +1003,7 @@ export class FiberRuntime {
   }
   [OpCodes.OP_UPDATE_RUNTIME_FLAGS](op) {
     const updateFlags = op.effect_instruction_i0;
-    const oldRuntimeFlags = this._runtimeFlags;
+    const oldRuntimeFlags = this.currentRuntimeFlags;
     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
@@ -1008,7 +1013,7 @@ export class FiberRuntime {
       return core.exitFailCause(this.getInterruptedCause());
     } else {
       // Impossible to short circuit, so record the changes
-      this.patchRuntimeFlags(this._runtimeFlags, updateFlags);
+      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);
@@ -1037,12 +1042,12 @@ export class FiberRuntime {
   }
   [OpCodes.OP_ASYNC](op) {
     this._asyncBlockingOn = op.effect_instruction_i1;
-    this.initiateAsync(this._runtimeFlags, op.effect_instruction_i0);
+    this.initiateAsync(this.currentRuntimeFlags, op.effect_instruction_i0);
     yieldedOpChannel.currentOp = op;
     return YieldedOp;
   }
   [OpCodes.OP_YIELD](op) {
-    this.isYielding = false;
+    this._isYielding = false;
     yieldedOpChannel.currentOp = op;
     return YieldedOp;
   }
@@ -1068,17 +1073,17 @@ export class FiberRuntime {
     let cur = effect0;
     this.currentOpCount = 0;
     while (true) {
-      if ((this._runtimeFlags & OpSupervision) !== 0) {
-        this._supervisor.onEffect(this, cur);
+      if ((this.currentRuntimeFlags & OpSupervision) !== 0) {
+        this.currentSupervisor.onEffect(this, cur);
       }
       if (this._queue.length > 0) {
-        cur = this.drainQueueWhileRunning(this._runtimeFlags, cur);
+        cur = this.drainQueueWhileRunning(this.currentRuntimeFlags, cur);
       }
-      if (!this.isYielding) {
+      if (!this._isYielding) {
         this.currentOpCount += 1;
-        const shouldYield = this._scheduler.shouldYield(this);
+        const shouldYield = this.currentScheduler.shouldYield(this);
         if (shouldYield !== false) {
-          this.isYielding = true;
+          this._isYielding = true;
           this.currentOpCount = 0;
           const oldCur = cur;
           cur = core.flatMap(core.yieldNow({
@@ -1092,9 +1097,9 @@ export class FiberRuntime {
           absurd(cur);
         }
         // @ts-expect-error
-        cur = this._tracer.context(() => {
-          if (version.getCurrentVersion() !== cur[EffectTypeId]._V) {
-            return core.dieMessage(`Cannot execute an Effect versioned ${cur[EffectTypeId]._V} with a Runtime of version ${version.getCurrentVersion()}`);
+        cur = this.currentTracer.context(() => {
+          if (version.getCurrentVersion() !== 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
           return this[cur._op](cur);
@@ -1131,6 +1136,26 @@ export const loggerWithConsoleLog = self => internalLogger.makeLogger(opts => {
   Context.get(services, consoleTag).unsafe.log(self.log(opts));
 });
 /** @internal */
+export const loggerWithLeveledLog = self => internalLogger.makeLogger(opts => {
+  const services = FiberRefs.getOrDefault(opts.context, defaultServices.currentServices);
+  const unsafeLogger = Context.get(services, consoleTag).unsafe;
+  switch (opts.logLevel._tag) {
+    case "Debug":
+      return unsafeLogger.debug(self.log(opts));
+    case "Info":
+      return unsafeLogger.info(self.log(opts));
+    case "Trace":
+      return unsafeLogger.trace(self.log(opts));
+    case "Warning":
+      return unsafeLogger.warn(self.log(opts));
+    case "Error":
+    case "Fatal":
+      return unsafeLogger.error(self.log(opts));
+    default:
+      return unsafeLogger.log(self.log(opts));
+  }
+});
+/** @internal */
 export const loggerWithConsoleError = self => internalLogger.makeLogger(opts => {
   const services = FiberRefs.getOrDefault(opts.context, defaultServices.currentServices);
   Context.get(services, consoleTag).unsafe.error(self.log(opts));
@@ -1142,7 +1167,7 @@ export const jsonLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("eff
 /** @internal */
 export const logFmtLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/logFmtLogger"), () => loggerWithConsoleLog(internalLogger.logfmtLogger));
 /** @internal */
-export const prettyLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/prettyLogger"), () => internalLogger.prettyLogger());
+export const prettyLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/prettyLogger"), () => internalLogger.prettyLoggerDefault);
 /** @internal */
 export const structuredLogger = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/Logger/structuredLogger"), () => loggerWithConsoleLog(internalLogger.structuredLogger));
 /** @internal */
@@ -1216,10 +1241,10 @@ export const acquireReleaseInterruptible = /*#__PURE__*/dual(args => core.isEffe
 /* @internal */
 export const addFinalizer = finalizer => core.withFiberRuntime(runtime => {
   const acquireRefs = runtime.getFiberRefs();
-  const acquireFlags = runtime._runtimeFlags;
+  const acquireFlags = runtime.currentRuntimeFlags;
   return core.flatMap(scope, scope => core.scopeAddFinalizerExit(scope, exit => core.withFiberRuntime(runtimeFinalizer => {
     const preRefs = runtimeFinalizer.getFiberRefs();
-    const preFlags = runtimeFinalizer._runtimeFlags;
+    const preFlags = runtimeFinalizer.currentRuntimeFlags;
     const patchRefs = FiberRefsPatch.diff(preRefs, acquireRefs);
     const patchFlags = _runtimeFlags.diff(preFlags, acquireFlags);
     const inverseRefs = FiberRefsPatch.diff(acquireRefs, preRefs);
@@ -1369,7 +1394,7 @@ export const forEachConcurrentDiscard = (self, f, batching, processAll, n) => co
   const fibers = new Set();
   const results = new Array();
   const interruptAll = () => fibers.forEach(fiber => {
-    fiber._scheduler.scheduleTask(() => {
+    fiber.currentScheduler.scheduleTask(() => {
       fiber.unsafeInterruptAsFork(parent.id());
     }, 0);
   });
@@ -1389,8 +1414,8 @@ export const forEachConcurrentDiscard = (self, f, batching, processAll, n) => co
   };
   const runFiber = (eff, interruptImmediately = false) => {
     const runnable = core.uninterruptible(graft(eff));
-    const fiber = unsafeForkUnstarted(runnable, parent, parent._runtimeFlags, fiberScope.globalScope);
-    parent._scheduler.scheduleTask(() => {
+    const fiber = unsafeForkUnstarted(runnable, parent, parent.currentRuntimeFlags, fiberScope.globalScope);
+    parent.currentScheduler.scheduleTask(() => {
       if (interruptImmediately) {
         fiber.unsafeInterruptAsFork(parent.id());
       }
@@ -1444,7 +1469,7 @@ export const forEachConcurrentDiscard = (self, f, batching, processAll, n) => co
         startOrder.push(fiber);
         fibers.add(fiber);
         if (interrupted) {
-          fiber._scheduler.scheduleTask(() => {
+          fiber.currentScheduler.scheduleTask(() => {
             fiber.unsafeInterruptAsFork(parent.id());
           }, 0);
         }
@@ -1552,7 +1577,7 @@ export const unsafeMakeChildFiber = (effect, parentFiber, parentRuntimeFlags, ov
   const childFiberRefs = fiberRefs.forkAs(parentFiberRefs, childId);
   const childFiber = new FiberRuntime(childId, childFiberRefs, parentRuntimeFlags);
   const childContext = fiberRefs.getOrDefault(childFiberRefs, core.currentContext);
-  const supervisor = childFiber._supervisor;
+  const supervisor = childFiber.currentSupervisor;
   supervisor.onStart(childContext, effect, Option.some(parentFiber), childFiber);
   childFiber.addObserver(exit => supervisor.onEnd(exit, childFiber));
   const parentScope = overrideScope !== null ? overrideScope : pipe(parentFiber.getFiberRef(core.currentForkScopeOverride), Option.getOrElse(() => parentFiber.scope()));
@@ -1837,41 +1862,45 @@ export const currentSupervisor = /*#__PURE__*/fiberRefUnsafeMakeSupervisor(super
 /* @internal */
 export const fiberAwaitAll = fibers => forEach(fibers, internalFiber._await);
 /** @internal */
-export const fiberAll = fibers => ({
-  [internalFiber.FiberTypeId]: internalFiber.fiberVariance,
-  id: () => RA.fromIterable(fibers).reduce((id, fiber) => FiberId.combine(id, fiber.id()), FiberId.none),
-  await: core.exit(forEachParUnbounded(fibers, fiber => core.flatten(fiber.await), false)),
-  children: core.map(forEachParUnbounded(fibers, fiber => fiber.children, false), RA.flatten),
-  inheritAll: core.forEachSequentialDiscard(fibers, fiber => fiber.inheritAll),
-  poll: core.map(core.forEachSequential(fibers, fiber => fiber.poll), RA.reduceRight(Option.some(core.exitSucceed(new Array())), (optionB, optionA) => {
-    switch (optionA._tag) {
-      case "None":
-        {
-          return Option.none();
-        }
-      case "Some":
-        {
-          switch (optionB._tag) {
-            case "None":
-              {
-                return Option.none();
-              }
-            case "Some":
-              {
-                return Option.some(core.exitZipWith(optionA.value, optionB.value, {
-                  onSuccess: (a, chunk) => [a, ...chunk],
-                  onFailure: internalCause.parallel
-                }));
-              }
+export const fiberAll = fibers => {
+  const _fiberAll = {
+    ...Effectable.CommitPrototype,
+    commit() {
+      return internalFiber.join(this);
+    },
+    [internalFiber.FiberTypeId]: internalFiber.fiberVariance,
+    id: () => RA.fromIterable(fibers).reduce((id, fiber) => FiberId.combine(id, fiber.id()), FiberId.none),
+    await: core.exit(forEachParUnbounded(fibers, fiber => core.flatten(fiber.await), false)),
+    children: core.map(forEachParUnbounded(fibers, fiber => fiber.children, false), RA.flatten),
+    inheritAll: core.forEachSequentialDiscard(fibers, fiber => fiber.inheritAll),
+    poll: core.map(core.forEachSequential(fibers, fiber => fiber.poll), RA.reduceRight(Option.some(core.exitSucceed(new Array())), (optionB, optionA) => {
+      switch (optionA._tag) {
+        case "None":
+          {
+            return Option.none();
           }
-        }
-    }
-  })),
-  interruptAsFork: fiberId => core.forEachSequentialDiscard(fibers, fiber => fiber.interruptAsFork(fiberId)),
-  pipe() {
-    return pipeArguments(this, arguments);
-  }
-});
+        case "Some":
+          {
+            switch (optionB._tag) {
+              case "None":
+                {
+                  return Option.none();
+                }
+              case "Some":
+                {
+                  return Option.some(core.exitZipWith(optionA.value, optionB.value, {
+                    onSuccess: (a, chunk) => [a, ...chunk],
+                    onFailure: internalCause.parallel
+                  }));
+                }
+            }
+          }
+      }
+    })),
+    interruptAsFork: fiberId => core.forEachSequentialDiscard(fibers, fiber => fiber.interruptAsFork(fiberId))
+  };
+  return _fiberAll;
+};
 /* @internal */
 export const fiberInterruptFork = self => core.asVoid(forkDaemon(core.interruptFiber(self)));
 /* @internal */