effect 4.0.0-beta.101 → 4.0.0-beta.103

package/dist/internal/effect.js

@@ -20,10 +20,10 @@ import { internalCall } from "../Utils.js";
 import { args, causeAnnotate, 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 { CurrentConcurrency, CurrentErrorReporters, CurrentLogAnnotations, CurrentLogLevel, CurrentLogSpans, CurrentStackFrame, MinimumLogLevel, TracerEnabled, TracerSpanAnnotations, TracerSpanLinks, TracerTimingEnabled } from "./references.js";
+import * as InternalRecord from "./record.js";
+import { CurrentErrorReporters, CurrentLogAnnotations, CurrentLogLevel, CurrentLogSpans, CurrentStackFrame, MinimumLogLevel, TracerEnabled, TracerSpanAnnotations, TracerSpanLinks, TracerTimingEnabled } from "./references.js";
 import { getStackTraceLimit, setStackTraceLimit } from "./stackTraceLimit.js";
 import { addSpanStackTrace, makeStackCleaner } from "./tracer.js";
-import { version } from "./version.js";
 // ----------------------------------------------------------------------------
 // Cause
 // ----------------------------------------------------------------------------
@@ -143,7 +143,7 @@ export const causeMap = /*#__PURE__*/dual(2, (self, f) => {
   const failures = self.reasons.map(failure => {
     if (isFailReason(failure)) {
       hasFail = true;
-      return new Fail(f(failure.error));
+      return new Fail(f(failure.error), failure.annotations);
     }
     return failure;
   });
@@ -316,7 +316,7 @@ const renderErrorCause = (cause, prefix) => {
 // Fiber
 // ----------------------------------------------------------------------------
 /** @internal */
-export const FiberTypeId = `~effect/Fiber/${version}`;
+export const FiberTypeId = "~effect/Fiber";
 const fiberVariance = {
   _A: identity,
   _E: identity
@@ -372,7 +372,7 @@ export class FiberImpl {
     return this._dispatcher ??= this.currentScheduler.makeDispatcher();
   }
   getRef(ref) {
-    return Context.getReferenceUnsafe(this.context, ref);
+    return Context.get(this.context, ref);
   }
   addObserver(cb) {
     if (this._exit) {
@@ -511,20 +511,26 @@ export class FiberImpl {
     return pipeArguments(this, arguments);
   }
   setContext(context) {
+    const previous = this.context;
     this.context = context;
+    // Every key cached below opts in to Context caching, so contexts related
+    // only by non-caching adds cannot have changed any of them
+    if (previous !== undefined && Context.hasSameCache(previous, context)) return;
     const scheduler = this.getRef(Scheduler.Scheduler);
     if (scheduler !== this.currentScheduler) {
       this.currentScheduler = scheduler;
       this._dispatcher = undefined;
     }
-    this.currentSpan = context.mapUnsafe.get(Tracer.ParentSpanKey);
+    // The string-keyed lookups keep the Tracer key values (and the native
+    // tracer behind Tracer.Tracer's default) out of every bundle
+    this.currentSpan = Context.getOrUndefinedUnsafe(context, Tracer.ParentSpanKey);
     this.currentLogLevel = this.getRef(CurrentLogLevel);
     this.minimumLogLevel = this.getRef(MinimumLogLevel);
-    this.currentStackFrame = context.mapUnsafe.get(CurrentStackFrame.key);
+    this.currentStackFrame = this.getRef(CurrentStackFrame);
     this.maxOpsBeforeYield = this.getRef(Scheduler.MaxOpsBeforeYield);
     this.currentPreventYield = this.getRef(Scheduler.PreventSchedulerYield);
-    this.runtimeMetrics = context.mapUnsafe.get(InternalMetric.FiberRuntimeMetricsKey);
-    const currentTracer = context.mapUnsafe.get(Tracer.TracerKey);
+    this.runtimeMetrics = Context.getOrUndefinedUnsafe(context, InternalMetric.FiberRuntimeMetricsKey);
+    const currentTracer = Context.getOrUndefinedUnsafe(context, Tracer.TracerKey);
     this.currentTracerContext = currentTracer ? currentTracer["context"] : undefined;
   }
   get currentSpanLocal() {
@@ -1181,6 +1187,24 @@ export const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateCo
   return Context.add(s, service, next);
 }));
 /** @internal */
+export const updateServiceScoped = (service, update, options) => uninterruptible(withFiber(fiber => {
+  const original = Context.getUnsafe(fiber.context, service);
+  const updated = update(original);
+  fiber.setContext(Context.add(fiber.context, service, updated));
+  return scopeAddFinalizerExit(Context.getUnsafe(fiber.context, scopeTag), _ => {
+    const current = Context.getUnsafe(fiber.context, service);
+    let next;
+    if (options?.reset === undefined) {
+      if (current !== updated) return void_;
+      next = original;
+    } else {
+      next = options.reset(original, updated, current);
+    }
+    fiber.setContext(Context.add(fiber.context, service, next));
+    return void_;
+  });
+}));
+/** @internal */
 export const context = () => getContext;
 const getContext = /*#__PURE__*/withFiber(fiber => succeed(fiber.context));
 /** @internal */
@@ -1206,8 +1230,6 @@ const provideServiceImpl = (self, service, implementation) => updateContext(self
 });
 /** @internal */
 export const provideServiceEffect = /*#__PURE__*/dual(3, (self, service, acquire) => flatMap(acquire, implementation => provideService(self, service, implementation)));
-/** @internal */
-export const withConcurrency = /*#__PURE__*/provideService(CurrentConcurrency);
 // ----------------------------------------------------------------------------
 // zipping
 // ----------------------------------------------------------------------------
@@ -1523,8 +1545,8 @@ export const timeout = /*#__PURE__*/dual(2, (self, duration) => timeoutOrElse(se
 export const timeoutOption = /*#__PURE__*/dual(2, (self, duration) => raceFirst(asSome(self), as(sleep(duration), Option.none())));
 /** @internal */
 export const timed = self => clockWith(clock => {
-  const start = clock.currentTimeNanosUnsafe();
-  return map(self, a => [Duration.nanos(clock.currentTimeNanosUnsafe() - start), a]);
+  const start = clock.monotonicTimeNanosUnsafe();
+  return map(self, a => [Duration.nanos(clock.monotonicTimeNanosUnsafe() - start), a]);
 });
 // ----------------------------------------------------------------------------
 // resources & finalization
@@ -1818,7 +1840,7 @@ export const all = (arg, options) => {
   return suspend(() => {
     const out = {};
     return as(forEach(Object.entries(arg), ([key, effect]) => map(options?.mode === "result" ? result(effect) : effect, value => {
-      out[key] = value;
+      InternalRecord.assignProperty(out, key, value);
     }), {
       discard: true,
       concurrency: options?.concurrency
@@ -1911,8 +1933,8 @@ export const whileLoop = /*#__PURE__*/makePrimitive({
   }
 });
 /** @internal */
-export const forEach = /*#__PURE__*/dual(args => typeof args[1] === "function", (iterable, f, options) => withFiber(parent => {
-  const concurrencyOption = options?.concurrency === "inherit" ? parent.getRef(CurrentConcurrency) : options?.concurrency ?? 1;
+export const forEach = /*#__PURE__*/dual(args => typeof args[1] === "function", (iterable, f, options) => suspend(() => {
+  const concurrencyOption = options?.concurrency ?? 1;
   const concurrency = concurrencyOption === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrencyOption);
   if (concurrency === 1) {
     return forEachSequential(iterable, f, options);
@@ -1948,10 +1970,24 @@ const forEachSequential = (iterable, f, options) => suspend(() => {
 const iterateEagerImpl = options => {
   const onItem = options.onItem;
   const step = options.step;
+  const runSequential = (state, items, index, end) => {
+    for (; index < end; index++) {
+      const item = items[index];
+      const effect = onItem(state, item, index);
+      if (!effectIsExit(effect)) {
+        return flatMap(exit(effect), itemExit => step(state, item, itemExit, index) ?? runSequential(state, items, index + 1, end) ?? void_);
+      }
+      const terminal = step(state, item, effect, index);
+      if (terminal) return terminal._tag === "Failure" ? terminal : undefined;
+    }
+  };
   return (state, items, opts) => {
-    let index = opts?.start ?? 0;
+    let index = 0;
     const end = opts?.end ?? items.length;
     const concurrency = opts?.concurrency ?? 1;
+    if (concurrency === 1) {
+      return runSequential(state, items, 0, end);
+    }
     const orderedStep = opts?.orderedStep === true && concurrency > 1;
     let done = false;
     let parentFiber;
@@ -1991,13 +2027,6 @@ const iterateEagerImpl = options => {
         if (effectIsExit(eff)) {
           terminal = runStep(item, eff, index);
           if (terminal) break;
-          // Use flatMap for concurrency of 1
-        } else if (concurrency === 1) {
-          return flatMap(exit(eff), exit => {
-            terminal = runStep(item, exit, index);
-            index++;
-            return terminal ?? go() ?? void_;
-          });
           // We have an effect, so enter "async" mode
         } else if (!parentFiber) {
           return callback(cb => {
@@ -2176,16 +2205,17 @@ export const forkChild = /*#__PURE__*/dual(args => isEffect(args[0]), (self, opt
 }));
 /** @internal */
 export const forkUnsafe = (parent, effect, immediate = false, daemon = false, uninterruptible = false) => {
-  const interruptible = uninterruptible === "inherit" ? parent.interruptible : !uninterruptible;
-  const child = new FiberImpl(parent.context, interruptible);
+  const parentRuntime = parent;
+  const interruptible = uninterruptible === "inherit" ? parentRuntime.interruptible : !uninterruptible;
+  const child = new FiberImpl(parentRuntime.context, interruptible);
   if (immediate) {
     child.evaluate(effect);
   } else {
-    parent.currentDispatcher.scheduleTask(() => child.evaluate(effect), 0);
+    parentRuntime.currentDispatcher.scheduleTask(() => child.evaluate(effect), 0);
   }
   if (!daemon && !child._exit) {
-    parent.children().add(child);
-    child.addObserver(() => parent._children.delete(child));
+    parentRuntime.children().add(child);
+    child.addObserver(() => parentRuntime._children.delete(child));
   }
   return child;
 };
@@ -2329,27 +2359,45 @@ const succeedTrue = /*#__PURE__*/succeed(true);
 const succeedFalse = /*#__PURE__*/succeed(false);
 class Latch {
   waiters = [];
-  scheduled = false;
+  scheduled = undefined;
   _isOpen;
   constructor(isOpen) {
     this._isOpen = isOpen;
   }
   scheduleUnsafe(fiber) {
-    if (this.scheduled || this.waiters.length === 0) {
+    if (this.waiters.length === 0) {
       return succeedTrue;
     }
-    this.scheduled = true;
-    fiber.currentDispatcher.scheduleTask(this.flushWaiters, 0);
+    if (this.scheduled === undefined) {
+      this.scheduled = this.waiters;
+      fiber.currentDispatcher.scheduleTask(this.flushScheduled, 0);
+    } else {
+      for (let i = 0; i < this.waiters.length; i++) {
+        this.scheduled.push(this.waiters[i]);
+      }
+    }
+    this.waiters = [];
     return succeedTrue;
   }
-  flushWaiters = () => {
-    this.scheduled = false;
+  flushScheduled = () => {
+    if (this.scheduled === undefined) return;
+    const waiters = this.scheduled;
+    this.scheduled = undefined;
+    for (let i = 0; i < waiters.length; i++) {
+      waiters[i](exitVoid);
+    }
+  };
+  flushWaiters() {
+    // swap both arrays out before any resume runs: a resumed waiter can
+    // reentrantly close the latch and register new waiters, which must not
+    // be drained by this flush
     const waiters = this.waiters;
     this.waiters = [];
+    this.flushScheduled();
     for (let i = 0; i < waiters.length; i++) {
       waiters[i](exitVoid);
     }
-  };
+  }
   open = /*#__PURE__*/withFiber(fiber => {
     if (this._isOpen) return succeedFalse;
     this._isOpen = true;
@@ -2368,9 +2416,14 @@ class Latch {
     }
     this.waiters.push(resume);
     return sync(() => {
-      const index = this.waiters.indexOf(resume);
+      let index = this.waiters.indexOf(resume);
       if (index !== -1) {
         this.waiters.splice(index, 1);
+      } else if (this.scheduled !== undefined) {
+        index = this.scheduled.indexOf(resume);
+        if (index !== -1) {
+          this.scheduled.splice(index, 1);
+        }
       }
     });
   });
@@ -2557,13 +2610,16 @@ export const withSpan = function () {
 };
 /** @internal */
 export const annotateSpans = /*#__PURE__*/dual(args => isEffect(args[0]), (effect, ...args) => updateService(effect, TracerSpanAnnotations, annotations => {
-  const newAnnotations = {
+  const newAnnotations = args.length === 1 ? {
+    ...annotations,
+    ...args[0]
+  } : {
     ...annotations
   };
   if (args.length === 1) {
-    Object.assign(newAnnotations, args[0]);
+    return newAnnotations;
   } else {
-    newAnnotations[args[0]] = args[1];
+    InternalRecord.assignProperty(newAnnotations, args[0], args[1]);
   }
   return newAnnotations;
 }));
@@ -2602,9 +2658,13 @@ class ClockImpl {
   }
   currentTimeMillis = /*#__PURE__*/sync(() => this.currentTimeMillisUnsafe());
   currentTimeNanosUnsafe() {
-    return processOrPerformanceNow();
+    return wallTimeNanos();
   }
   currentTimeNanos = /*#__PURE__*/sync(() => this.currentTimeNanosUnsafe());
+  monotonicTimeNanosUnsafe() {
+    return monotonicNowNanos();
+  }
+  monotonicTimeNanos = /*#__PURE__*/sync(() => this.monotonicTimeNanosUnsafe());
   sleep(duration) {
     return this.sleepMillis(Duration.toMillis(duration));
   }
@@ -2617,24 +2677,41 @@ class ClockImpl {
     });
   }
 }
-const performanceNowNanos = /*#__PURE__*/function () {
-  const bigint1e6 = /*#__PURE__*/BigInt(1_000_000);
-  if (typeof performance === "undefined" || typeof performance.now === "undefined") {
-    return () => BigInt(Date.now()) * bigint1e6;
+const nanosPerMilli = /*#__PURE__*/BigInt(1_000_000);
+const monotonicNowNanos = /*#__PURE__*/function () {
+  const processHrtime = globalThis.process?.hrtime;
+  if (typeof processHrtime?.bigint === "function") {
+    return () => processHrtime.bigint();
   }
-  let origin;
+  if (typeof performance !== "undefined" && typeof performance.now === "function") {
+    return () => BigInt(Math.round(performance.now() * 1_000_000));
+  }
+  let previous = /*#__PURE__*/BigInt(0);
   return () => {
-    origin ??= BigInt(Date.now()) * bigint1e6 - BigInt(Math.round(performance.now() * 1_000_000));
-    return origin + BigInt(Math.round(performance.now() * 1_000_000));
+    const current = BigInt(Date.now()) * nanosPerMilli;
+    if (current > previous) {
+      previous = current;
+    }
+    return previous;
   };
 }();
-const processOrPerformanceNow = /*#__PURE__*/function () {
-  const processHrtime = typeof process === "object" && "hrtime" in process && typeof process.hrtime.bigint === "function" ? process.hrtime : undefined;
-  if (!processHrtime) {
-    return performanceNowNanos;
-  }
-  const origin = /*#__PURE__*/BigInt(/*#__PURE__*/Date.now()) * /*#__PURE__*/BigInt(1e6) - /*#__PURE__*/processHrtime.bigint();
-  return () => origin + processHrtime.bigint();
+const wallTimeNanos = /*#__PURE__*/function () {
+  const reanchorThresholdNanos = /*#__PURE__*/BigInt(1_000_000_000);
+  let origin;
+  return () => {
+    const monotonic = monotonicNowNanos();
+    const wall = BigInt(Date.now()) * nanosPerMilli;
+    if (origin === undefined) {
+      origin = wall - monotonic;
+    } else {
+      const projected = origin + monotonic;
+      const skew = wall > projected ? wall - projected : projected - wall;
+      if (skew > reanchorThresholdNanos) {
+        origin = wall - monotonic;
+      }
+    }
+    return origin + monotonic;
+  };
 }();
 /** @internal */
 export const clockWith = f => withFiber(fiber => f(fiber.getRef(ClockRef)));
@@ -2644,6 +2721,8 @@ export const sleep = duration => clockWith(clock => clock.sleep(Duration.fromInp
 export const currentTimeMillis = /*#__PURE__*/clockWith(clock => clock.currentTimeMillis);
 /** @internal */
 export const currentTimeNanos = /*#__PURE__*/clockWith(clock => clock.currentTimeNanos);
+/** @internal */
+export const monotonicTimeNanos = /*#__PURE__*/clockWith(clock => clock.monotonicTimeNanos);
 // ----------------------------------------------------------------------------
 // Errors
 // ----------------------------------------------------------------------------
@@ -2770,7 +2849,7 @@ export const annotateLogsScoped = function () {
     };
     for (let i = 0; i < entries.length; i++) {
       const [key, value] = entries[i];
-      next[key] = value;
+      InternalRecord.assignProperty(next, key, value);
     }
     fiber.setContext(Context.add(fiber.context, CurrentLogAnnotations, next));
     return scopeAddFinalizerExit(Context.getUnsafe(fiber.context, scopeTag), _ => {
@@ -2781,8 +2860,8 @@ export const annotateLogsScoped = function () {
       for (let i = 0; i < entries.length; i++) {
         const [key, value] = entries[i];
         if (current[key] !== value) continue;
-        if (key in prev) {
-          next[key] = prev[key];
+        if (Object.hasOwn(prev, key)) {
+          InternalRecord.assignProperty(next, key, prev[key]);
         } else {
           delete next[key];
         }
@@ -2926,7 +3005,8 @@ const defaultDateFormat = date => `${date.getHours().toString().padStart(2, "0")
 export const consolePretty = options => {
   // evaluated lazily so the module-level bundle stays free of `process`
   // property accesses, which bundlers must retain as possible side effects
-  const hasProcessStdout = typeof process === "object" && process !== null && typeof process.stdout === "object" && process.stdout !== null;
+  const process = globalThis.process;
+  const hasProcessStdout = typeof process?.stdout === "object" && process.stdout !== null;
   const processStdoutIsTTY = hasProcessStdout && process.stdout.isTTY === true;
   const hasProcessStdoutOrDeno = hasProcessStdout || "Deno" in globalThis;
   const mode_ = options?.mode ?? "auto";
@@ -2943,7 +3023,7 @@ export const consolePretty = options => {
   });
 };
 const prettyLoggerTty = options => {
-  const processIsBun = typeof process === "object" && "isBun" in process && process.isBun === true;
+  const processIsBun = globalThis.process?.isBun === true;
   const color = options.colors ? withColor : withColorNoop;
   return loggerMake(({
     cause,
@@ -3094,7 +3174,7 @@ export const tracerLogger = /*#__PURE__*/loggerMake(({
   if (span === undefined || span._tag === "ExternalSpan") return;
   const attributes = {};
   for (const [key, value] of Object.entries(annotations)) {
-    attributes[key] = value;
+    InternalRecord.assignProperty(attributes, key, value);
   }
   attributes["effect.fiberId"] = fiber.id;
   attributes["effect.logLevel"] = logLevel.toUpperCase();