effect 4.0.0-rc.118 → 4.0.1

package/dist/internal/effect.js

@@ -17,7 +17,7 @@ import * as Result from "../Result.js";
 import * as Scheduler from "../Scheduler.js";
 import * as Tracer from "../Tracer.js";
 import { internalCall } from "../Utils.js";
-import { args, causeAnnotate, causeDie, causeEmpty, causeFromReasons, CauseImpl, constEmptyAnnotations, contA, contAll, contE, evaluate, exitDie, exitFail, exitFailCause, exitSucceed, ExitTypeId, Fail, InterruptorStackTrace, isCause, isDieReason, isEffect, isFailReason, isInterruptReason, isNoSuchElementError, makePrimitive, makePrimitiveProto, NoSuchElementError, ReasonBase, StackTraceKey as CauseStackTrace, TaggedError, withFiber, Yield } from "./core.js";
+import { args, causeAnnotate, causeCombine, causeEmpty, causeFromReasons, CauseImpl, constEmptyAnnotations, contA, contAll, contE, evaluate, exitDie, exitFail, exitFailCause, exitSucceed, ExitTypeId, Fail, InterruptorStackTrace, isCause, isDieReason, isEffect, isFailReason, isInterruptReason, isNoSuchElementError, makePrimitive, makePrimitiveProto, NoSuchElementError, ReasonBase, StackTraceKey as CauseStackTrace, TaggedError, withFiber, Yield } from "./core.js";
 import * as doNotation from "./doNotation.js";
 import * as InternalMetric from "./metric.js";
 import * as InternalRecord from "./record.js";
@@ -126,35 +126,6 @@ export const causeAnnotations = self => {
   }
   return Context.makeUnsafe(map);
 };
-const dedupeReasons = (self, that) => {
-  // Keep deduplication local so causeCombine does not retain Array.ts in the core bundle.
-  // Snapshot both arrays before invoking user-defined hash or equality methods.
-  const buckets = new Map();
-  const out = [];
-  for (const reason of self.concat(that)) {
-    const hash = Hash.hash(reason);
-    const bucket = buckets.get(hash);
-    if (bucket === undefined) {
-      buckets.set(hash, [reason]);
-    } else if (bucket.some(previous => Equal.equals(previous, reason))) {
-      continue;
-    } else {
-      bucket.push(reason);
-    }
-    out.push(reason);
-  }
-  return out;
-};
-/** @internal */
-export const causeCombine = /*#__PURE__*/dual(2, (self, that) => {
-  if (self.reasons.length === 0) {
-    return that;
-  } else if (that.reasons.length === 0) {
-    return self;
-  }
-  const newCause = new CauseImpl(dedupeReasons(self.reasons, that.reasons));
-  return Equal.equals(self, newCause) ? self : newCause;
-});
 /** @internal */
 export const causeMap = /*#__PURE__*/dual(2, (self, f) => {
   let hasFail = false;
@@ -332,6 +303,14 @@ const fiberVariance = {
 const fiberIdStore = {
   id: 0
 };
+const AsyncResource = /*#__PURE__*/(() => {
+  try {
+    return globalThis.process?.getBuiltinModule?.("node:async_hooks")?.AsyncResource;
+  } catch {
+    return undefined;
+  }
+})();
+const captureAsyncContext = () => AsyncResource === undefined ? undefined : new AsyncResource("effect/Fiber");
 /** @internal */
 export const getCurrentFiber = () => globalThis[currentFiberTypeId];
 /** @internal */
@@ -350,6 +329,7 @@ export class FiberImpl {
     this._running = false;
     this._deferredInterrupt = false;
     this._parent = undefined;
+    this._asyncContext = undefined;
     this.cache.runtimeMetrics?.recordFiberStart(this.context);
   }
   get [FiberTypeId]() {
@@ -406,6 +386,10 @@ export class FiberImpl {
   evaluate(effect) {
     if (this._exit) {
       return;
+    } else if (this._asyncContext !== undefined) {
+      const asyncContext = this._asyncContext;
+      this._asyncContext = undefined;
+      return asyncContext.runInAsyncScope(this.evaluate, this, effect);
     } else if (this._yielded !== undefined) {
       const yielded = this._yielded;
       this._yielded = undefined;
@@ -413,6 +397,7 @@ export class FiberImpl {
     }
     const exit = this.runLoop(effect);
     if (exit === Yield) {
+      this._asyncContext = captureAsyncContext();
       return;
     }
     // the interruptChildren middleware is added in Effect.forkChild, so it can be
@@ -782,17 +767,18 @@ export const tryPromise = options => {
   const f = typeof options === "function" ? options : options.try;
   const catcher = typeof options === "function" ? cause => new UnknownError(cause, "An error occurred in Effect.tryPromise") : options.catch;
   return callbackOptions(function (resume, signal) {
-    const failWithCatch = cause => {
+    // Defer the catcher until the fiber restores its async context.
+    const failWithCatch = cause => suspend(() => {
       try {
-        resume(fail(internalCall(() => catcher(cause))));
+        return fail(internalCall(() => catcher(cause)));
       } catch (err) {
-        resume(die(err));
+        return die(err);
       }
-    };
+    });
     try {
-      f(signal).then(a => resume(succeed(a)), failWithCatch);
+      f(signal).then(a => resume(succeed(a)), e => resume(failWithCatch(e)));
     } catch (err) {
-      failWithCatch(err);
+      resume(failWithCatch(err));
     }
   }, f.length !== 0);
 };
@@ -852,7 +838,7 @@ const asyncFinalizer = /*#__PURE__*/makePrimitive({
     }
   },
   [contE](cause, _fiber) {
-    return hasInterrupts(cause) ? flatMap(this[args](), () => failCause(cause)) : failCause(cause);
+    return hasInterrupts(cause) ? flatMap(combineFinalizerCause(exitFailCause(cause), this[args]()), () => failCause(cause)) : failCause(cause);
   }
 });
 /** @internal */
@@ -1079,73 +1065,75 @@ export const asVoid = self => new ContImpl(self, returnPayload, exitVoid);
 /** @internal */
 export const sandbox = self => catchCause(self, fail);
 /** @internal */
-export const raceAll = (all, options) => withFiber(parent => callback(resume => {
-  const effects = Arr.fromIterable(all);
-  const len = effects.length;
-  let doneCount = 0;
-  let done = false;
+export const raceAll = (all, options) => withFiber(parent => {
   const fibers = new Set();
-  const failures = [];
-  const onExit = (exit, fiber, i) => {
-    doneCount++;
-    if (exit._tag === "Failure") {
-      failures.push(...exit.cause.reasons);
-      if (doneCount >= len) {
-        resume(failCause(causeFromReasons(failures)));
+  // Read fibers on exit to include losers forked after the race settles.
+  onExitUnsafe(parent, () => fibers.size === 0 ? undefined : fiberInterruptAll(fibers));
+  return callback(resume => {
+    const effects = Arr.fromIterable(all);
+    const len = effects.length;
+    let doneCount = 0;
+    let done = false;
+    const failures = [];
+    const onExit = (exit, fiber, i) => {
+      doneCount++;
+      if (exit._tag === "Failure") {
+        failures.push(...exit.cause.reasons);
+        if (doneCount >= len) {
+          resume(failCause(causeFromReasons(failures)));
+        }
+        return;
       }
-      return;
-    }
-    const isWinner = !done;
-    done = true;
-    resume(fibers.size === 0 ? exit : flatMap(uninterruptible(fiberInterruptAll(fibers)), () => exit));
-    if (isWinner && options?.onWinner) {
-      options.onWinner({
-        fiber,
-        index: i,
-        parentFiber: parent
-      });
-    }
-  };
-  for (let i = 0; i < len; i++) {
-    const fiber = forkUnsafe(parent, effects[i], true, true, false);
-    fibers.add(fiber);
-    fiber.addObserver(exit => {
-      fibers.delete(fiber);
-      onExit(exit, fiber, i);
-    });
-    if (done) break;
-  }
-  return fiberInterruptAll(fibers);
-}));
-/** @internal */
-export const raceAllFirst = (all, options) => withFiber(parent => callback(resume => {
-  let done = false;
-  const fibers = new Set();
-  const onExit = exit => {
-    done = true;
-    resume(fibers.size === 0 ? exit : flatMap(uninterruptible(fiberInterruptAll(fibers)), () => exit));
-  };
-  let i = 0;
-  for (const effect of all) {
-    if (done) break;
-    const index = i++;
-    const fiber = forkUnsafe(parent, effect, true, true, false);
-    fibers.add(fiber);
-    fiber.addObserver(exit => {
-      fibers.delete(fiber);
       const isWinner = !done;
-      onExit(exit);
+      done = true;
+      resume(exit);
       if (isWinner && options?.onWinner) {
         options.onWinner({
           fiber,
-          index,
+          index: i,
           parentFiber: parent
         });
       }
-    });
-  }
-  return fiberInterruptAll(fibers);
-}));
+    };
+    for (let i = 0; i < len; i++) {
+      const fiber = forkUnsafe(parent, effects[i], true, true, false);
+      fibers.add(fiber);
+      fiber.addObserver(exit => {
+        fibers.delete(fiber);
+        onExit(exit, fiber, i);
+      });
+      if (done) break;
+    }
+  });
+});
+/** @internal */
+export const raceAllFirst = (all, options) => withFiber(parent => {
+  const fibers = new Set();
+  onExitUnsafe(parent, () => fibers.size === 0 ? undefined : fiberInterruptAll(fibers));
+  return callback(resume => {
+    let done = false;
+    let i = 0;
+    for (const effect of all) {
+      if (done) break;
+      const index = i++;
+      const fiber = forkUnsafe(parent, effect, true, true, false);
+      fibers.add(fiber);
+      fiber.addObserver(exit => {
+        fibers.delete(fiber);
+        const isWinner = !done;
+        done = true;
+        resume(exit);
+        if (isWinner && options?.onWinner) {
+          options.onWinner({
+            fiber,
+            index,
+            parentFiber: parent
+          });
+        }
+      });
+    }
+  });
+});
 /** @internal */
 export const race = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => raceAll([self, that], options));
 /** @internal */
@@ -1930,61 +1918,55 @@ export const acquireDisposable = acquire => acquireRelease(acquire, resource =>
 // Caching
 // ----------------------------------------------------------------------------
 /** @internal */
-export const cachedInvalidateWithTTL = /*#__PURE__*/dual(2, (self, ttl) => sync(() => {
-  const ttlMillis = typeof ttl === "function" ? exit => Duration.toMillis(Duration.fromInputUnsafe(ttl(exit))) : constant(Duration.toMillis(Duration.fromInputUnsafe(ttl)));
-  const latch = makeLatchUnsafe(false);
+export const cachedInvalidateWithTTL = /*#__PURE__*/dual(2, (self, ttl) => sync(() => makeCachedUnsafe(self, typeof ttl === "function" ? exit => Duration.toMillis(Duration.fromInputUnsafe(ttl(exit))) : constant(Duration.toMillis(Duration.fromInputUnsafe(ttl))))));
+const infiniteTTL = /*#__PURE__*/constant(Infinity);
+const makeCachedUnsafe = (self, ttlMillis) => {
   let expiresAt = 0;
-  let running = false;
   let exit;
-  const wait = flatMap(latch.await, () => exit);
+  let current;
+  const join = (fiber, run) => {
+    run.awaiters++;
+    onExitUnsafe(fiber, () => {
+      // Abandon the run once every caller has left, unless it already finished.
+      if (--run.awaiters > 0 || current !== run) return;
+      // Detach it first so new callers start a fresh run instead of joining
+      // one that is being interrupted.
+      current = undefined;
+      return fiberInterrupt(run.fiber);
+    });
+    return fiberJoin(run.fiber);
+  };
   return [withFiber(fiber => {
-    const clock = fiber.getRef(ClockRef);
-    const now = expiresAt === Infinity ? 0 : clock.currentTimeMillisUnsafe();
-    if (running || now < expiresAt) return exit ?? wait;
-    running = true;
-    latch.closeUnsafe();
+    if (current !== undefined) return join(fiber, current);
+    if (exit !== undefined && (expiresAt === Infinity || fiber.getRef(ClockRef).currentTimeMillisUnsafe() < expiresAt)) {
+      return exit;
+    }
     exit = undefined;
-    onExitUnsafe(fiber, exit_ => sync(() => {
-      try {
-        const duration = ttlMillis(exit_);
-        expiresAt = clock.currentTimeMillisUnsafe() + duration;
-        exit = exit_;
-      } catch (error) {
-        const cause = causeDie(error);
-        // Publish the same combined cause that onExit returns to the owner.
-        exit = exitFailCause(exitIsFailure(exit_) ? causeCombine(exit_.cause, cause) : cause);
-        throw error;
-      } finally {
-        running = false;
-        latch.openUnsafe();
-      }
-    }));
-    return self;
+    const clock = fiber.getRef(ClockRef);
+    const run = {
+      fiber: undefined,
+      awaiters: 0
+    };
+    current = run;
+    run.fiber = forkUnsafe(fiber, onExitPrimitive(self, exit_ => {
+      // An abandoned run must not overwrite or clear a replacement run.
+      if (current !== run) return;
+      current = undefined;
+      // Interruption is abandonment, so it is never cached.
+      if (exitHasInterrupts(exit_)) return;
+      const duration = ttlMillis(exit_);
+      expiresAt = duration === Infinity ? Infinity : clock.currentTimeMillisUnsafe() + duration;
+      exit = exit_;
+    }), true, true);
+    return run.fiber._exit ?? join(fiber, run);
   }), sync(() => {
-    expiresAt = 0;
-    latch.closeUnsafe();
     exit = undefined;
   })];
-}));
+};
 /** @internal */
 export const cachedWithTTL = /*#__PURE__*/dual(2, (self, timeToLive) => map(cachedInvalidateWithTTL(self, timeToLive), tuple => tuple[0]));
 /** @internal */
-export const cached = self => sync(() => {
-  const latch = makeLatchUnsafe(false);
-  let started = false;
-  let exit;
-  const wait = flatMap(latch.await, () => exit);
-  return withFiber(fiber => {
-    if (exit !== undefined) return exit;
-    if (started) return wait;
-    started = true;
-    onExitUnsafe(fiber, result => sync(() => {
-      exit = result;
-      latch.openUnsafe();
-    }));
-    return self;
-  });
-});
+export const cached = self => sync(() => makeCachedUnsafe(self, infiniteTTL)[0]);
 // ----------------------------------------------------------------------------
 // interruption
 // ----------------------------------------------------------------------------
@@ -2100,11 +2082,11 @@ export const reduce = /*#__PURE__*/dual(3, (elements, zero, f) => {
 /** @internal */
 export const validate = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, f, options) => flatMap(partition(elements, f, {
   concurrency: options?.concurrency
-}), ([excluded, satisfying]) => {
-  if (Arr.isArrayNonEmpty(excluded)) {
-    return fail(excluded);
+}), ([passes, fails]) => {
+  if (Arr.isArrayNonEmpty(fails)) {
+    return fail(fails);
   }
-  return options?.discard ? void_ : succeed(satisfying);
+  return options?.discard ? void_ : succeed(passes);
 }));
 /** @internal */
 export const findFirst = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, predicate) => suspend(() => {
@@ -2233,26 +2215,22 @@ const iterateConcurrentImpl = options => {
     let parentFiber;
     let fibers;
     let resume;
-    let interrupted = false;
     let terminal;
     let effect;
     const failDefect = error => {
       const defect = exitDie(error);
       terminal = defect;
       done = true;
-      interrupted = true;
-      return fibers && fibers.size > 0 ? flatMap(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => defect) : defect;
+      return fibers && fibers.size > 0 ? flatMap(uninterruptible(fiberInterruptAll(Array.from(fibers))), () => terminal ?? defect) : defect;
     };
     const go = () => {
       let paused = false;
       for (; !terminal && index < end; index++) {
         const item = items[index];
         const eff = effect ?? onItem(state, item, index);
-        // fast case (already an exit)
         if (effectIsExit(eff)) {
           terminal = step(state, item, eff, index);
           if (terminal) break;
-          // We have an effect, so enter "async" mode
         } else if (!parentFiber) {
           return callback(cb => {
             parentFiber = getCurrentFiber();
@@ -2267,14 +2245,12 @@ const iterateConcurrentImpl = options => {
             }
             if (result) return cb(result);
             return suspend(() => {
-              terminal = exitVoid;
-              interrupted = true;
-              return fibers ? fiberInterruptAll(fibers) : void_;
+              terminal ??= exitVoid;
+              return flatMap(fibers ? fiberInterruptAll(fibers) : void_, () => terminal?._tag === "Failure" ? terminal : void_);
             });
           });
-          // Fork the effect with concurrency > 1
         } else {
-          // Clear the temporary effect from capturing the parentFiber
+          // Clear the effect cached before the parent fiber was available.
           effect = undefined;
           const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit");
           if (fiber._exit) {
@@ -2282,27 +2258,23 @@ const iterateConcurrentImpl = options => {
             if (terminal) break;
             continue;
           }
-          // Add the fiber to the Set
           fibers.add(fiber);
           const currentIndex = index;
           fiber.addObserver(exit => {
             fibers.delete(fiber);
             try {
               if (terminal) {
-                if (!interrupted && exit._tag === "Failure") {
-                  for (const reason of exit.cause.reasons) {
-                    if (reason._tag === "Interrupt") continue;else if (terminal._tag === "Failure") {
-                      ;
-                      terminal.cause.reasons.push(reason);
-                    } else {
-                      terminal = exitFailCause(causeFromReasons([reason]));
-                    }
+                if (exit._tag === "Failure") {
+                  const reasons = exit.cause.reasons.filter(reason => reason._tag !== "Interrupt");
+                  if (reasons.length > 0) {
+                    const cause = causeFromReasons(reasons);
+                    terminal = exitFailCause(terminal._tag === "Failure" ? causeCombine(terminal.cause, cause) : cause);
                   }
                 }
               } else {
                 const result = step(state, item, exit, currentIndex);
                 if (result) {
-                  terminal = result._tag === "Failure" ? exitFailCause(causeFromReasons(result.cause.reasons.slice())) : result;
+                  terminal = result;
                   go();
                 }
               }
@@ -2316,7 +2288,6 @@ const iterateConcurrentImpl = options => {
               resume(failDefect(error));
             }
           });
-          // Check if we have reached the concurrency limit
           if (fibers.size < concurrency) continue;
           paused = true;
           index++;
@@ -2436,6 +2407,8 @@ export const forkUnsafe = (parent, effect, immediate = false, daemon = false, un
   if (immediate) {
     child.evaluate(effect);
   } else {
+    // Preserve the fork context rather than the dispatcher's context.
+    child._asyncContext = captureAsyncContext();
     parentRuntime.currentDispatcher.scheduleTask(() => child.evaluate(effect), 0);
   }
   if (!daemon && !child._exit) {