effect 4.0.0-beta.99 → 4.0.0-rc.108

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
@@ -333,7 +333,6 @@ export class FiberImpl {
     this.setContext(context);
     this.id = ++fiberIdStore.id;
     this.currentOpCount = 0;
-    this.currentLoopCount = 0;
     this.interruptible = interruptible;
     this._stack = [];
     this._observers = [];
@@ -341,20 +340,22 @@ export class FiberImpl {
     this._children = undefined;
     this._interruptedCause = undefined;
     this._yielded = undefined;
+    this._running = false;
+    this._deferredInterrupt = false;
     this.runtimeMetrics?.recordFiberStart(this.context);
   }
   [FiberTypeId];
   id;
   interruptible;
   currentOpCount;
-  currentLoopCount;
   _stack;
   _observers;
   _exit;
-  _currentExit;
   _children;
   _interruptedCause;
   _yielded;
+  _running;
+  _deferredInterrupt;
   // set in setContext
   context;
   currentScheduler;
@@ -371,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) {
@@ -399,7 +400,11 @@ export class FiberImpl {
     }
     this._interruptedCause = this._interruptedCause ? causeCombine(this._interruptedCause, cause) : cause;
     if (this.interruptible) {
-      this.evaluate(failCause(this._interruptedCause));
+      if (this._running) {
+        this._deferredInterrupt = true;
+      } else {
+        this.evaluate(failCause(this._interruptedCause));
+      }
     }
   }
   pollUnsafe() {
@@ -429,16 +434,24 @@ export class FiberImpl {
       this._observers[i](exit);
     }
     this._observers.length = 0;
+    this._stack.length = 0;
+    this._children = undefined;
+    this.context = Context.empty();
   }
   runLoop(effect) {
     const prevFiber = globalThis[currentFiberTypeId];
     globalThis[currentFiberTypeId] = this;
+    const prevRunning = this._running;
+    this._running = true;
     let yielding = false;
     let current = effect;
     this.currentOpCount = 0;
-    const currentLoop = ++this.currentLoopCount;
     try {
       while (true) {
+        if (this._deferredInterrupt) {
+          this._deferredInterrupt = false;
+          current = failCause(this._interruptedCause);
+        }
         this.currentOpCount++;
         if (!yielding && !this.currentPreventYield && this.currentScheduler.shouldYield(this)) {
           yielding = true;
@@ -446,14 +459,16 @@ export class FiberImpl {
           current = flatMap(yieldNow, () => prev);
         }
         current = this.currentTracerContext ? this.currentTracerContext(current, this) : current[evaluate](this);
-        if (currentLoop !== this.currentLoopCount) {
-          // another effect has taken over the loop,
-          return Yield;
-        } else if (current === Yield) {
+        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;
         }
@@ -464,11 +479,15 @@ export class FiberImpl {
       }
       return this.runLoop(exitDie(error));
     } finally {
-      ;
+      this._running = prevRunning;
       globalThis[currentFiberTypeId] = prevFiber;
     }
   }
   getCont(symbol) {
+    if (this._deferredInterrupt) {
+      this._deferredInterrupt = false;
+      return deferredInterruptCont;
+    }
     while (true) {
       const op = this._stack.pop();
       if (!op) return undefined;
@@ -492,33 +511,47 @@ 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() {
     return this.currentSpan?._tag === "Span" ? this.currentSpan : undefined;
   }
 }
+const deferredInterruptCont = {
+  [contA](_value, fiber) {
+    return failCause(fiber._interruptedCause);
+  },
+  [contE](_cause, fiber) {
+    return failCause(fiber._interruptedCause);
+  }
+};
 const fiberMiddleware = {
   interruptChildren: undefined
 };
 const fiberStackAnnotations = fiber => {
   if (!fiber.currentStackFrame) return undefined;
   const annotations = new Map();
-  annotations.set(CauseStackTrace.key, fiber.currentStackFrame);
+  annotations.set(InterruptorStackTrace.key, fiber.currentStackFrame);
   return Context.makeUnsafe(annotations);
 };
 const fiberInterruptChildren = fiber => {
@@ -592,6 +625,10 @@ export const fiberJoinAll = self => callback(resume => {
       }
     }));
   }
+  return sync(() => {
+    failed = true;
+    cancels.forEach(cancel => cancel());
+  });
 });
 /** @internal */
 export const fiberInterrupt = self => withFiber(fiber => fiberInterruptAs(self, fiber.id));
@@ -1150,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 */
@@ -1175,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
 // ----------------------------------------------------------------------------
@@ -1492,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
@@ -1748,13 +1801,15 @@ const setInterruptible = /*#__PURE__*/makePrimitive({
 });
 const setInterruptibleTrue = /*#__PURE__*/setInterruptible(true);
 const setInterruptibleFalse = /*#__PURE__*/setInterruptible(false);
-/** @internal */
-export const interruptible = self => withFiber(fiber => {
-  if (fiber.interruptible) return self;
+const setFiberInterruptible = fiber => {
   fiber.interruptible = true;
   fiber._stack.push(setInterruptibleFalse);
   if (fiber._interruptedCause) return failCause(fiber._interruptedCause);
-  return self;
+};
+/** @internal */
+export const interruptible = self => withFiber(fiber => {
+  if (fiber.interruptible) return self;
+  return setFiberInterruptible(fiber) ?? self;
 });
 /** @internal */
 export const uninterruptibleMask = f => withFiber(fiber => {
@@ -1766,9 +1821,9 @@ export const uninterruptibleMask = f => withFiber(fiber => {
 /** @internal */
 export const interruptibleMask = f => withFiber(fiber => {
   if (fiber.interruptible) return f(identity);
-  fiber.interruptible = true;
-  fiber._stack.push(setInterruptibleFalse);
-  return f(uninterruptible);
+  const interrupted = setFiberInterruptible(fiber);
+  const effect = f(uninterruptible);
+  return interrupted ?? effect;
 });
 /** @internal */
 export const abortSignal = /*#__PURE__*/map(/*#__PURE__*/acquireRelease(/*#__PURE__*/sync(() => new AbortController()), controller => sync(() => controller.abort())), _ => _.signal);
@@ -1785,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
@@ -1795,6 +1850,23 @@ export const all = (arg, options) => {
 /** @internal */
 export const partition = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, f, options) => map(forEach(elements, (a, i) => result(f(a, i)), options), results => Arr.partition(results, identity)));
 /** @internal */
+export const reduce = /*#__PURE__*/dual(3, (elements, zero, f) => {
+  const arr = Arr.fromIterable(elements);
+  if (arr.length === 0) return sync(zero);
+  return suspend(() => {
+    let index = 0;
+    let state = zero();
+    return map(whileLoop({
+      while: () => index < arr.length,
+      body: () => f(state, arr[index], index),
+      step(next) {
+        state = next;
+        index++;
+      }
+    }), () => state);
+  });
+});
+/** @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]) => {
@@ -1861,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);
@@ -1898,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;
@@ -1912,6 +1998,13 @@ const iterateEagerImpl = options => {
     let effect;
     let nextIndex = index;
     const exits = orderedStep ? new Array(end) : undefined;
+    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;
+    };
     const runStep = (item, exit, currentIndex) => {
       if (!orderedStep) return step(state, item, exit, currentIndex);
       if (terminal) return terminal;
@@ -1934,20 +2027,19 @@ 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 => {
             parentFiber = getCurrentFiber();
+            fibers = new Set();
             effect = eff;
             resume = cb;
-            const result = go();
+            let result;
+            try {
+              result = go();
+            } catch (error) {
+              return cb(failDefect(error));
+            }
             if (result) return cb(result);
             return suspend(() => {
               terminal = exitVoid;
@@ -1966,33 +2058,37 @@ const iterateEagerImpl = options => {
             continue;
           }
           // Add the fiber to the Set
-          if (fibers) fibers.add(fiber);else fibers = new Set([fiber]);
+          fibers.add(fiber);
           const currentIndex = index;
           fiber.addObserver(exit => {
             fibers.delete(fiber);
-            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]));
+            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]));
+                    }
                   }
                 }
+              } else {
+                const result = runStep(item, exit, currentIndex);
+                if (result) {
+                  terminal = result._tag === "Failure" ? exitFailCause(causeFromReasons(result.cause.reasons.slice())) : result;
+                  go();
+                }
               }
-            } else {
-              const result = runStep(item, exit, currentIndex);
-              if (result) {
-                terminal = result._tag === "Failure" ? exitFailCause(causeFromReasons(result.cause.reasons.slice())) : result;
-                go();
+              if (paused) {
+                const eff = go();
+                if (eff) resume(eff);
+              } else if (done && fibers.size === 0) {
+                resume(terminal ?? void_);
               }
-            }
-            if (paused) {
-              const eff = go();
-              if (eff) resume(eff);
-            } else if (done && fibers.size === 0) {
-              resume(terminal ?? void_);
+            } catch (error) {
+              resume(failDefect(error));
             }
           });
           // Check if we have reached the concurrency limit
@@ -2109,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;
 };
@@ -2126,13 +2223,13 @@ export const forkUnsafe = (parent, effect, immediate = false, daemon = false, un
 export const forkDetach = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => withFiber(fiber => succeed(forkUnsafe(fiber, self, options?.startImmediately, true, options?.uninterruptible))));
 /** @internal */
 export const awaitAllChildren = self => withFiber(fiber => {
-  const initialChildren = fiber._children && Arr.fromIterable(fiber._children);
+  const initialChildren = fiber._children && new Set(fiber._children);
   return onExit(self, _ => {
     let children = fiber._children;
     if (children === undefined || children.size === 0) {
       return void_;
     } else if (initialChildren) {
-      children = Iterable.filter(children, child => !initialChildren.includes(child));
+      children = Iterable.filter(children, child => !initialChildren.has(child));
     }
     return asVoid(fiberAwaitAll(children));
   });
@@ -2241,7 +2338,7 @@ export const runSyncExitWith = context => {
     const fiber = runFork(effect, {
       scheduler
     });
-    fiber.currentDispatcher?.flush();
+    fiber._dispatcher?.flush();
     return fiber._exit ?? exitDie(new AsyncFiberError(fiber));
   };
 };
@@ -2262,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;
@@ -2301,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);
+        }
       }
     });
   });
@@ -2453,10 +2573,8 @@ export const useSpan = (name, ...args) => {
   return withFiber(fiber => {
     const span = makeSpanUnsafe(fiber, name, options);
     const clock = fiber.getRef(ClockRef);
-    return onExit(internalCall(() => evaluate(span)), exit => sync(() => {
-      if (span.status._tag === "Ended") return;
-      span.end(clock.currentTimeNanosUnsafe(), exit);
-    }));
+    const timingEnabled = fiber.getRef(TracerTimingEnabled);
+    return onExit(internalCall(() => evaluate(span)), exit => endSpan(span, exit, clock, timingEnabled));
   });
 };
 const provideParentSpan = /*#__PURE__*/provideService(Tracer.ParentSpan);
@@ -2490,13 +2608,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;
 }));
@@ -2535,9 +2656,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));
   }
@@ -2550,24 +2675,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)));
@@ -2577,6 +2719,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
 // ----------------------------------------------------------------------------
@@ -2703,7 +2847,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), _ => {
@@ -2714,8 +2858,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];
         }
@@ -2761,7 +2905,6 @@ export const formatLogSpan = (self, now) => {
 /** @internal */
 export const structuredMessage = u => {
   switch (typeof u) {
-    case "bigint":
     case "function":
     case "symbol":
       {
@@ -2859,7 +3002,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";
@@ -2876,7 +3020,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,
@@ -3027,7 +3171,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();