effect 4.0.0 → 4.0.2

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;
@@ -237,6 +208,8 @@ export const causePrettyError = (original, annotations, options) => {
     }
   } else {
     error = new globalThis.Error(!original ? `Unknown error: ${original}` : kind === "string" ? original : formatJson(original));
+    const stack = `${error.name}: ${error.message}`;
+    error.stack = annotations ? addStackAnnotations(stack, annotations) : stack;
   }
   return error;
 };
@@ -332,6 +305,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 +331,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 +388,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 +399,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
@@ -448,38 +435,40 @@ export class FiberImpl {
     this.currentOpCount = 0;
     try {
       while (true) {
-        if (this._deferredInterrupt) {
-          this._deferredInterrupt = false;
-          current = failCause(this._interruptedCause);
-        }
-        this.currentOpCount++;
-        // Refresh the cache because a primitive can replace the fiber context.
-        const cache = this.cache;
-        if (!yielding && !cache.preventYield && cache.scheduler.shouldYield(this)) {
-          yielding = true;
-          const prev = current;
-          current = flatMap(yieldNow, () => prev);
-        }
-        current = cache.tracerContext ? cache.tracerContext(current, this) : current[evaluate](this);
-        if (current === Yield) {
-          const yielded = this._yielded;
-          if (ExitTypeId in yielded) {
+        try {
+          if (this._deferredInterrupt) {
             this._deferredInterrupt = false;
-            this._yielded = undefined;
-            return yielded;
-          } else if (this._deferredInterrupt) {
-            this._yielded = undefined;
-            yielded();
-            continue;
+            current = failCause(this._interruptedCause);
+          }
+          this.currentOpCount++;
+          // Refresh the cache because a primitive can replace the fiber context.
+          const cache = this.cache;
+          if (!yielding && !cache.preventYield && cache.scheduler.shouldYield(this)) {
+            yielding = true;
+            const prev = current;
+            current = flatMap(yieldNow, () => prev);
+          }
+          current = cache.tracerContext ? cache.tracerContext(current, this) : current[evaluate](this);
+          if (current === Yield) {
+            const yielded = this._yielded;
+            if (ExitTypeId in yielded) {
+              this._deferredInterrupt = false;
+              this._yielded = undefined;
+              return yielded;
+            } else if (this._deferredInterrupt) {
+              this._yielded = undefined;
+              yielded();
+              continue;
+            }
+            return Yield;
+          }
+        } catch (error) {
+          if (!hasProperty(current, evaluate)) {
+            return exitDie(`Fiber.runLoop: Not a valid effect: ${String(current)}`);
           }
-          return Yield;
+          current = exitDie(error);
         }
       }
-    } catch (error) {
-      if (!hasProperty(current, evaluate)) {
-        return exitDie(`Fiber.runLoop: Not a valid effect: ${String(current)}`);
-      }
-      return this.runLoop(exitDie(error));
     } finally {
       this._running = prevRunning;
       globalThis[currentFiberTypeId] = prevFiber;
@@ -782,17 +771,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);
 };
@@ -1687,10 +1677,8 @@ export const ScopeCloseableTypeId = "~effect/Scope/Closeable";
 export const scopeTag = /*#__PURE__*/Context.Service("effect/Scope");
 /** @internal */
 export const scopeClose = (self, exit_) => withFiber(fiber => {
-  const close = scopeCloseUnsafe(self, exit_);
-  if (close === undefined) return void_;
   fiberEnterUninterruptibleUnsafe(fiber);
-  return close;
+  return scopeCloseUnsafe(self, exit_) ?? void_;
 });
 /** @internal */
 export const scopeCloseUnsafe = (self, exit_) => {
@@ -1932,61 +1920,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
 // ----------------------------------------------------------------------------
@@ -2424,15 +2406,17 @@ export const forkUnsafe = (parent, effect, immediate = false, daemon = false, un
   const parentRuntime = parent;
   const interruptible = uninterruptible === "inherit" ? parentRuntime.interruptible : !uninterruptible;
   const child = new FiberImpl(parentRuntime.context, interruptible);
+  if (!daemon) {
+    parentRuntime.children().add(child);
+    child._parent = parentRuntime;
+  }
   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) {
-    parentRuntime.children().add(child);
-    child._parent = parentRuntime;
-  }
   return child;
 };
 /** @internal */
@@ -2501,9 +2485,9 @@ export const fiberRunIn = /*#__PURE__*/dual(2, (self, scope) => {
     self.interruptUnsafe(self.id);
     return self;
   }
-  const key = {};
-  scopeAddFinalizerUnsafe(scope, key, () => fiberInterrupt(self));
-  self.addObserver(() => scopeRemoveFinalizerUnsafe(scope, key));
+  scopeRemoveFinalizerUnsafe(scope, self);
+  scopeAddFinalizerUnsafe(scope, self, () => fiberInterrupt(self));
+  self.addObserver(() => scopeRemoveFinalizerUnsafe(scope, self));
   return self;
 });
 /** @internal */
@@ -2724,7 +2708,7 @@ export const makeSpanUnsafe = (fiber, name, options) => {
       links,
       startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : bigint0,
       kind: options?.kind ?? "internal",
-      root: options?.root ?? Option.isNone(parent),
+      root: options?.root ?? false,
       sampled: options?.sampled ?? (Option.isSome(parent) && parent.value.sampled === false ? false : !isLogLevelGreaterThan(fiber.getRef(Tracer.MinimumTraceLevel), level))
     });
     for (const key in annotationsFromEnv) {