effect 4.0.0-rc.111 → 4.0.0-rc.113

package/dist/internal/effect.js

@@ -29,7 +29,6 @@ import { addSpanStackTrace, makeStackCleaner } from "./tracer.js";
 // ----------------------------------------------------------------------------
 /** @internal */
 export class Interrupt extends ReasonBase {
-  fiberId;
   constructor(fiberId, annotations = constEmptyAnnotations) {
     super("Interrupt", annotations, "Interrupted");
     this.fiberId = fiberId;
@@ -127,6 +126,25 @@ 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) {
@@ -134,7 +152,7 @@ export const causeCombine = /*#__PURE__*/dual(2, (self, that) => {
   } else if (that.reasons.length === 0) {
     return self;
   }
-  const newCause = new CauseImpl(Arr.union(self.reasons, that.reasons));
+  const newCause = new CauseImpl(dedupeReasons(self.reasons, that.reasons));
   return Equal.equals(self, newCause) ? self : newCause;
 });
 /** @internal */
@@ -179,7 +197,7 @@ export const causePrettyErrors = (self, options) => {
   const interrupts = [];
   if (self.reasons.length === 0) return errors;
   const prevStackLimit = getStackTraceLimit();
-  setStackTraceLimit(1);
+  if (prevStackLimit !== 0) setStackTraceLimit(1);
   for (const failure of self.reasons) {
     if (failure._tag === "Interrupt") {
       interrupts.push(failure);
@@ -198,7 +216,7 @@ export const causePrettyErrors = (self, options) => {
     error.stack = `${error.name}: ${error.message}`;
     errors.push(causePrettyError(error, interrupts[0].annotations, options));
   }
-  setStackTraceLimit(prevStackLimit);
+  if (prevStackLimit !== 0) setStackTraceLimit(prevStackLimit);
   return errors;
 };
 /** @internal */
@@ -335,14 +353,15 @@ export class FiberImpl {
     this.currentOpCount = 0;
     this.interruptible = interruptible;
     this._stack = [];
-    this._observers = [];
+    this._observers = undefined;
     this._exit = undefined;
     this._children = undefined;
     this._interruptedCause = undefined;
     this._yielded = undefined;
     this._running = false;
     this._deferredInterrupt = false;
-    this.runtimeMetrics?.recordFiberStart(this.context);
+    this._parent = undefined;
+    this.cache.runtimeMetrics?.recordFiberStart(this.context);
   }
   [FiberTypeId];
   id;
@@ -356,20 +375,13 @@ export class FiberImpl {
   _yielded;
   _running;
   _deferredInterrupt;
+  _parent;
   // set in setContext
   context;
-  currentScheduler;
-  currentTracerContext;
-  currentSpan;
-  currentLogLevel;
-  minimumLogLevel;
-  currentStackFrame;
-  runtimeMetrics;
-  maxOpsBeforeYield;
-  currentPreventYield;
+  cache;
   _dispatcher = undefined;
   get currentDispatcher() {
-    return this._dispatcher ??= this.currentScheduler.makeDispatcher();
+    return this._dispatcher ??= this.cache.scheduler.makeDispatcher();
   }
   getRef(ref) {
     return Context.get(this.context, ref);
@@ -379,9 +391,13 @@ export class FiberImpl {
       cb(this._exit);
       return constVoid;
     }
-    this._observers.push(cb);
+    if (this._observers === undefined) {
+      this._observers = [cb];
+    } else {
+      this._observers.push(cb);
+    }
     return () => {
-      if (this._exit) return;
+      if (this._exit || this._observers === undefined) return;
       const index = this._observers.indexOf(cb);
       if (index >= 0) {
         this._observers.splice(index, 1);
@@ -393,8 +409,8 @@ export class FiberImpl {
       return;
     }
     let cause = causeInterrupt(fiberId);
-    if (this.currentStackFrame) {
-      cause = causeAnnotate(cause, Context.make(CauseStackTrace, this.currentStackFrame));
+    if (this.cache.stackFrame) {
+      cause = causeAnnotate(cause, Context.make(CauseStackTrace, this.cache.stackFrame));
     }
     if (annotations) {
       cause = causeAnnotate(cause, annotations);
@@ -430,11 +446,18 @@ export class FiberImpl {
       return this.evaluate(flatMap(interruptChildren, () => exit));
     }
     this._exit = exit;
-    this.runtimeMetrics?.recordFiberEnd(this.context, this._exit);
-    for (let i = 0; i < this._observers.length; i++) {
-      this._observers[i](exit);
+    this.cache.runtimeMetrics?.recordFiberEnd(this.context, this._exit);
+    if (this._parent) {
+      this._parent._children?.delete(this);
+      this._parent = undefined;
+    }
+    if (this._observers !== undefined) {
+      const observers = this._observers;
+      this._observers = undefined;
+      for (let i = 0; i < observers.length; i++) {
+        observers[i](exit);
+      }
     }
-    this._observers.length = 0;
     this._stack.length = 0;
     this._children = undefined;
     this.context = Context.empty();
@@ -454,12 +477,14 @@ export class FiberImpl {
           current = failCause(this._interruptedCause);
         }
         this.currentOpCount++;
-        if (!yielding && !this.currentPreventYield && this.currentScheduler.shouldYield(this)) {
+        // 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 = this.currentTracerContext ? this.currentTracerContext(current, this) : current[evaluate](this);
+        current = cache.tracerContext ? cache.tracerContext(current, this) : current[evaluate](this);
         if (current === Yield) {
           const yielded = this._yielded;
           if (ExitTypeId in yielded) {
@@ -492,11 +517,14 @@ export class FiberImpl {
     while (true) {
       const op = this._stack.pop();
       if (!op) return undefined;
-      const cont = op[contAll] && op[contAll](this);
-      if (cont) {
-        ;
-        cont[symbol] = cont;
-        return cont;
+      const all = op[contAll];
+      if (all !== undefined) {
+        const cont = all.call(op, this);
+        if (cont) {
+          ;
+          cont[symbol] = cont;
+          return cont;
+        }
       }
       if (op[symbol]) return op;
     }
@@ -517,27 +545,39 @@ export class FiberImpl {
     // 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;
+    // Contexts sharing a cacheRoot resolve every cached key identically, so
+    // the derived cache object is computed once per root and shared by all
+    // fibers running with that root (forked fibers reuse the parent's).
+    const root = context.cacheRoot;
+    const cache = root._fiberCache ??= makeFiberContextCache(context);
+    if (this.cache !== undefined && this.cache.scheduler !== cache.scheduler) {
       this._dispatcher = undefined;
     }
-    // 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 = this.getRef(CurrentStackFrame);
-    this.maxOpsBeforeYield = this.getRef(Scheduler.MaxOpsBeforeYield);
-    this.currentPreventYield = this.getRef(Scheduler.PreventSchedulerYield);
-    this.runtimeMetrics = Context.getOrUndefinedUnsafe(context, InternalMetric.FiberRuntimeMetricsKey);
-    const currentTracer = Context.getOrUndefinedUnsafe(context, Tracer.TracerKey);
-    this.currentTracerContext = currentTracer ? currentTracer["context"] : undefined;
+    this.cache = cache;
   }
   get currentSpanLocal() {
-    return this.currentSpan?._tag === "Span" ? this.currentSpan : undefined;
+    const span = this.cache.span;
+    return span?._tag === "Span" ? span : undefined;
   }
 }
+const makeFiberContextCache = context => {
+  // The string-keyed lookups keep the Tracer key values (and the native
+  // tracer behind Tracer.Tracer's default) out of every bundle
+  const currentTracer = Context.getOrUndefinedUnsafe(context, Tracer.TracerKey);
+  return {
+    scheduler: Context.get(context, Scheduler.Scheduler),
+    tracer: currentTracer,
+    tracerContext: currentTracer ? currentTracer["context"] : undefined,
+    tracerEnabled: Context.get(context, TracerEnabled),
+    span: Context.getOrUndefinedUnsafe(context, Tracer.ParentSpanKey),
+    logLevel: Context.get(context, CurrentLogLevel),
+    minimumLogLevel: Context.get(context, MinimumLogLevel),
+    stackFrame: Context.get(context, CurrentStackFrame),
+    runtimeMetrics: Context.getOrUndefinedUnsafe(context, InternalMetric.FiberRuntimeMetricsKey),
+    maxOpsBeforeYield: Context.get(context, Scheduler.MaxOpsBeforeYield),
+    preventYield: Context.get(context, Scheduler.PreventSchedulerYield)
+  };
+};
 const deferredInterruptCont = {
   [contA](_value, fiber) {
     return failCause(fiber._interruptedCause);
@@ -550,9 +590,9 @@ const fiberMiddleware = {
   interruptChildren: undefined
 };
 const fiberStackAnnotations = fiber => {
-  if (!fiber.currentStackFrame) return undefined;
+  if (!fiber.cache.stackFrame) return undefined;
   const annotations = new Map();
-  annotations.set(InterruptorStackTrace.key, fiber.currentStackFrame);
+  annotations.set(InterruptorStackTrace.key, fiber.cache.stackFrame);
   return Context.makeUnsafe(annotations);
 };
 const fiberInterruptChildren = fiber => {
@@ -766,39 +806,48 @@ export const withFiberId = f => withFiber(fiber => f(fiber.id));
 export const fiber = /*#__PURE__*/withFiber(succeed);
 /** @internal */
 export const fiberId = /*#__PURE__*/withFiberId(succeed);
-const callbackOptions = /*#__PURE__*/makePrimitive({
-  op: "Async",
-  single: false,
-  [evaluate](fiber) {
-    const register = internalCall(() => this[args][0].bind(fiber.currentScheduler));
-    let resumed = false;
-    let yielded = false;
-    const controller = this[args][1] ? new AbortController() : undefined;
-    const onCancel = register(effect => {
-      if (resumed) return;
-      resumed = true;
-      if (yielded) {
-        fiber.evaluate(effect);
-      } else {
-        yielded = effect;
+const callbackOptions = /*#__PURE__*/function () {
+  const Proto = /*#__PURE__*/makePrimitiveProto({
+    op: "Async",
+    [evaluate](fiber) {
+      const register = internalCall(() => this.register.bind(fiber.cache.scheduler));
+      let resumed = false;
+      let yielded = false;
+      const controller = this.withSignal ? new AbortController() : undefined;
+      const onCancel = register(effect => {
+        if (resumed) return;
+        resumed = true;
+        if (yielded) {
+          fiber.evaluate(effect);
+        } else {
+          yielded = effect;
+        }
+      }, controller?.signal);
+      if (yielded !== false) return yielded;
+      yielded = true;
+      fiber._yielded = () => {
+        resumed = true;
+      };
+      if (controller === undefined && onCancel === undefined) {
+        return Yield;
       }
-    }, controller?.signal);
-    if (yielded !== false) return yielded;
-    yielded = true;
-    fiber._yielded = () => {
-      resumed = true;
-    };
-    if (controller === undefined && onCancel === undefined) {
+      fiber._stack.push(asyncFinalizer(() => {
+        resumed = true;
+        controller?.abort();
+        return onCancel ?? exitVoid;
+      }));
       return Yield;
     }
-    fiber._stack.push(asyncFinalizer(() => {
-      resumed = true;
-      controller?.abort();
-      return onCancel ?? exitVoid;
-    }));
-    return Yield;
-  }
-});
+  });
+  const AsyncImpl = function (register, withSignal) {
+    this.register = register;
+    this.withSignal = withSignal;
+  };
+  AsyncImpl.prototype = Proto;
+  return function (register, withSignal) {
+    return new AsyncImpl(register, withSignal);
+  };
+}();
 const asyncFinalizer = /*#__PURE__*/makePrimitive({
   op: "AsyncFinalizer",
   [contAll](fiber) {
@@ -816,7 +865,14 @@ export const callback = register => callbackOptions(register, register.length >=
 /** @internal */
 export const never = /*#__PURE__*/callback(constVoid);
 /** @internal */
-export const gen = (...args) => suspend(() => fromIteratorUnsafe(args.length === 1 ? args[0]() : args[1].call(args[0].self)));
+export const gen = (...args) => {
+  if (args.length === 1) {
+    const body = args[0];
+    return suspend(() => fromIteratorUnsafe(body()));
+  }
+  const [options, body] = args;
+  return suspend(() => fromIteratorUnsafe(body.call(options.self)));
+};
 /** @internal */
 export const fnUntraced = (body, ...pipeables) => {
   const fn = pipeables.length === 0 ? function () {
@@ -841,9 +897,12 @@ export const fn = function () {
   const name = nameFirst ? arguments[0] : "Effect.fn";
   const spanOptions = nameFirst ? arguments[1] : undefined;
   const prevLimit = getStackTraceLimit();
-  setStackTraceLimit(2);
-  const defError = new globalThis.Error();
-  setStackTraceLimit(prevLimit);
+  let defError;
+  if (prevLimit !== 0) {
+    setStackTraceLimit(2);
+    defError = new globalThis.Error();
+    setStackTraceLimit(prevLimit);
+  }
   if (nameFirst) {
     return (body, ...pipeables) => makeFn(name, body, defError, pipeables, nameFirst, spanOptions);
   }
@@ -863,15 +922,18 @@ const makeFn = (name, bodyOrOptions, defError, pipeables, addSpan, spanOptions)
       return result;
     }
     const prevLimit = getStackTraceLimit();
-    setStackTraceLimit(2);
-    const callError = new globalThis.Error();
-    setStackTraceLimit(prevLimit);
+    let callError;
+    if (prevLimit !== 0) {
+      setStackTraceLimit(2);
+      callError = new globalThis.Error();
+      setStackTraceLimit(prevLimit);
+    }
     return updateService(addSpan ? useSpan(name, spanOptions, span => provideParentSpan(result, span)) : result, CurrentStackFrame, prev => ({
       name,
-      stack: fnStackCleaner(() => callError.stack),
+      stack: callError ? fnStackCleaner(() => callError.stack) : constUndefined,
       parent: {
         name: `${name} (definition)`,
-        stack: fnStackCleaner(() => defError.stack),
+        stack: defError ? fnStackCleaner(() => defError.stack) : constUndefined,
         parent: prev
       }
     }));
@@ -883,7 +945,7 @@ export const fnUntracedEager = (body, ...pipeables) => defineFunctionLength(body
 } : function () {
   let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments));
   for (const pipeable of pipeables) {
-    effect = pipeable(effect);
+    effect = pipeable(effect, ...arguments);
   }
   return effect;
 });
@@ -919,35 +981,82 @@ const fromIteratorEagerUnsafe = evaluate => {
     return die(error);
   }
 };
-const fromIteratorUnsafe = /*#__PURE__*/makePrimitive({
-  op: "Iterator",
-  single: false,
-  [contA](value, fiber) {
-    const iter = this[args][0];
-    while (true) {
-      const state = iter.next(value);
-      if (state.done) return succeed(state.value);
-      if (!effectIsExit(state.value)) {
-        fiber._stack.push(this);
-        return state.value;
-      } else if (state.value._tag === "Failure") {
-        return state.value;
+const fromIteratorUnsafe = /*#__PURE__*/function () {
+  const Proto = /*#__PURE__*/makePrimitiveProto({
+    op: "Iterator",
+    [contA](value, fiber) {
+      const iter = this.iterator;
+      while (true) {
+        const state = iter.next(value);
+        if (state.done) return succeed(state.value);
+        if (!effectIsExit(state.value)) {
+          fiber._stack.push(this);
+          return state.value;
+        } else if (state.value._tag === "Failure") {
+          return state.value;
+        }
+        value = state.value.value;
       }
-      value = state.value.value;
+    },
+    [evaluate](fiber) {
+      return this[contA](this.initial, fiber);
     }
-  },
-  [evaluate](fiber) {
-    return this[contA](this[args][1], fiber);
-  }
-});
+  });
+  const IteratorImpl = function (iterator, initial) {
+    this.iterator = iterator;
+    this.initial = initial;
+  };
+  IteratorImpl.prototype = Proto;
+  return function (iterator, initial) {
+    return new IteratorImpl(iterator, initial);
+  };
+}();
 // ----------------------------------------------------------------------------
 // mapping & sequencing
 // ----------------------------------------------------------------------------
 /** @internal */
-export const as = /*#__PURE__*/dual(2, (self, value) => {
-  const b = succeed(value);
-  return flatMap(self, _ => b);
+export const as = /*#__PURE__*/dual(2, (self, value) => new ContImpl(self, returnPayload, succeed(value)));
+const evaluateCont = function (fiber) {
+  fiber._stack.push(this);
+  return this[args];
+};
+const OnSuccessProto = /*#__PURE__*/makePrimitiveProto({
+  op: "OnSuccess",
+  [evaluate]: evaluateCont
 });
+const OnSuccessImpl = function (self, f) {
+  this[args] = self;
+  this[contA] = f;
+};
+OnSuccessImpl.prototype = OnSuccessProto;
+// A success continuation with an extra payload slot. The stored continuation
+// receives the primitive as `this` and reads `this.payload`, so combinators
+// like map / as / tap / andThen can share module-level continuation functions
+// instead of allocating a closure per call.
+const ContImpl = function (self, cont, payload) {
+  this[args] = self;
+  this[contA] = cont;
+  this.payload = payload;
+};
+ContImpl.prototype = OnSuccessProto;
+const returnPayload = function () {
+  return this.payload;
+};
+const mapCont = function (value) {
+  const f = this.payload;
+  return succeed(internalCall(() => f(value)));
+};
+const andThenCont = function (value) {
+  const f = this.payload;
+  return internalCall(() => f(value));
+};
+const tapCont = function (value) {
+  const f = this.payload;
+  return new ContImpl(internalCall(() => f(value)), returnPayload, exitSucceed(value));
+};
+const tapEffectCont = function (value) {
+  return new ContImpl(this.payload, returnPayload, exitSucceed(value));
+};
 /** @internal */
 export const asSome = self => map(self, Option.some);
 /** @internal */
@@ -956,11 +1065,11 @@ export const flip = self => matchEffect(self, {
   onSuccess: fail
 });
 /** @internal */
-export const andThen = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => isEffect(f) ? f : internalCall(() => f(a))));
+export const andThen = /*#__PURE__*/dual(2, (self, f) => new ContImpl(self, isEffect(f) ? returnPayload : andThenCont, f));
 /** @internal */
-export const tap = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => as(isEffect(f) ? f : internalCall(() => f(a)), a)));
+export const tap = /*#__PURE__*/dual(2, (self, f) => new ContImpl(self, isEffect(f) ? tapEffectCont : tapCont, f));
 /** @internal */
-export const asVoid = self => flatMap(self, _ => exitVoid);
+export const asVoid = self => new ContImpl(self, returnPayload, exitVoid);
 /** @internal */
 export const sandbox = self => catchCause(self, fail);
 /** @internal */
@@ -1036,19 +1145,7 @@ export const race = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, op
 /** @internal */
 export const raceFirst = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => raceAllFirst([self, that], options));
 /** @internal */
-export const flatMap = /*#__PURE__*/dual(2, (self, f) => {
-  const onSuccess = Object.create(OnSuccessProto);
-  onSuccess[args] = self;
-  onSuccess[contA] = f.length !== 1 ? a => f(a) : f;
-  return onSuccess;
-});
-const OnSuccessProto = /*#__PURE__*/makePrimitiveProto({
-  op: "OnSuccess",
-  [evaluate](fiber) {
-    fiber._stack.push(this);
-    return this[args];
-  }
-});
+export const flatMap = /*#__PURE__*/dual(2, (self, f) => new OnSuccessImpl(self, f.length !== 1 ? a => f(a) : f));
 /** @internal */
 export const matchCauseEffectEager = /*#__PURE__*/dual(2, (self, options) => {
   if (effectIsExit(self)) {
@@ -1057,7 +1154,7 @@ export const matchCauseEffectEager = /*#__PURE__*/dual(2, (self, options) => {
   return matchCauseEffect(self, options);
 });
 /** @internal */
-export const effectIsExit = effect => ExitTypeId in effect;
+export const effectIsExit = effect => effect[ExitTypeId] !== undefined;
 /** @internal */
 export const flatMapEager = /*#__PURE__*/dual(2, (self, f) => {
   if (effectIsExit(self)) {
@@ -1071,7 +1168,7 @@ export const flatMapEager = /*#__PURE__*/dual(2, (self, f) => {
 /** @internal */
 export const flatten = self => flatMap(self, identity);
 /** @internal */
-export const map = /*#__PURE__*/dual(2, (self, f) => flatMap(self, a => succeed(internalCall(() => f(a)))));
+export const map = /*#__PURE__*/dual(2, (self, f) => new ContImpl(self, mapCont, f));
 /** @internal */
 export const mapEager = /*#__PURE__*/dual(2, (self, f) => effectIsExit(self) ? exitMap(self, f) : map(self, f));
 /** @internal */
@@ -1193,7 +1290,9 @@ export const updateServiceScoped = (service, update, options) => uninterruptible
   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);
+    const currentOption = Context.getOption(fiber.context, service);
+    if (Option.isNone(currentOption)) return void_;
+    const current = currentOption.value;
     let next;
     if (options?.reset === undefined) {
       if (current !== updated) return void_;
@@ -1241,7 +1340,7 @@ export const zipWith = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that,
 // ----------------------------------------------------------------------------
 // filtering & conditionals
 // ----------------------------------------------------------------------------
-/* @internal */
+/** @internal */
 export const filterOrFail = /*#__PURE__*/dual(args => isEffect(args[0]), (self, predicate, orFailWith) => filterOrElse(self, predicate, orFailWith ? a => fail(orFailWith(a)) : () => fail(new NoSuchElementError())));
 /** @internal */
 export const when = /*#__PURE__*/dual(2, (self, condition) => flatMap(condition, pass => pass ? asSome(self) : succeedNone));
@@ -1264,19 +1363,16 @@ export const forever = /*#__PURE__*/dual(args => isEffect(args[0]), (self, optio
 // error handling
 // ----------------------------------------------------------------------------
 /** @internal */
-export const catchCause = /*#__PURE__*/dual(2, (self, f) => {
-  const onFailure = Object.create(OnFailureProto);
-  onFailure[args] = self;
-  onFailure[contE] = f.length !== 1 ? cause => f(cause) : f;
-  return onFailure;
-});
+export const catchCause = /*#__PURE__*/dual(2, (self, f) => new OnFailureImpl(self, f.length !== 1 ? cause => f(cause) : f));
 const OnFailureProto = /*#__PURE__*/makePrimitiveProto({
   op: "OnFailure",
-  [evaluate](fiber) {
-    fiber._stack.push(this);
-    return this[args];
-  }
+  [evaluate]: evaluateCont
 });
+const OnFailureImpl = function (self, f) {
+  this[args] = self;
+  this[contE] = f;
+};
+OnFailureImpl.prototype = OnFailureProto;
 /** @internal */
 export const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchCause(self, cause => {
   if (!predicate(cause)) {
@@ -1352,7 +1448,7 @@ export const catchTags = /*#__PURE__*/dual(args => isEffect(args[0]), (self, cas
   }, e => internalCall(() => cases[e["_tag"]](e)), orElse);
 });
 /** @internal */
-export const catchReason = /*#__PURE__*/dual(args => isEffect(args[0]), (self, errorTag, reasonTag, f, orElse) => catchIf(self, e => isTagged(e, errorTag) && hasProperty(e, "reason"), e => {
+export const catchReason = /*#__PURE__*/dual(args => isEffect(args[0]), (self, errorTag, reasonTag, f, orElse) => catchIf(self, e => isTagged(e, errorTag) && hasProperty(e, "reason") && (orElse !== undefined || isTagged(e.reason, reasonTag)), e => {
   const reason = e.reason;
   if (isTagged(reason, reasonTag)) return f(reason, e);
   return orElse ? internalCall(() => orElse(reason, e)) : fail(e);
@@ -1360,7 +1456,7 @@ export const catchReason = /*#__PURE__*/dual(args => isEffect(args[0]), (self, e
 /** @internal */
 export const catchReasons = /*#__PURE__*/dual(args => isEffect(args[0]), (self, errorTag, cases, orElse) => {
   let keys;
-  return catchIf(self, e => isTagged(e, errorTag) && hasProperty(e, "reason") && hasProperty(e.reason, "_tag") && isString(e.reason._tag), e => {
+  return catchIf(self, e => isTagged(e, errorTag) && hasProperty(e, "reason") && hasProperty(e.reason, "_tag") && isString(e.reason._tag) && (orElse !== undefined || (keys ??= Object.keys(cases)).includes(e.reason._tag)), e => {
     const reason = e.reason;
     keys ??= Object.keys(cases);
     if (keys.includes(reason._tag)) {
@@ -1378,7 +1474,7 @@ export const unwrapReason = /*#__PURE__*/dual(2, (self, errorTag) => catchFilter
 }, fail));
 /** @internal */
 export const mapError = /*#__PURE__*/dual(2, (self, f) => catch_(self, error => failSync(() => f(error))));
-/* @internal */
+/** @internal */
 export const mapBoth = /*#__PURE__*/dual(2, (self, options) => matchEffect(self, {
   onFailure: e => failSync(() => options.onFailure(e)),
   onSuccess: a => sync(() => options.onSuccess(a))
@@ -1448,20 +1544,17 @@ export const result = self => matchEager(self, {
 // pattern matching
 // ----------------------------------------------------------------------------
 /** @internal */
-export const matchCauseEffect = /*#__PURE__*/dual(2, (self, options) => {
-  const primitive = Object.create(OnSuccessAndFailureProto);
-  primitive[args] = self;
-  primitive[contA] = options.onSuccess.length !== 1 ? a => options.onSuccess(a) : options.onSuccess;
-  primitive[contE] = options.onFailure.length !== 1 ? cause => options.onFailure(cause) : options.onFailure;
-  return primitive;
-});
+export const matchCauseEffect = /*#__PURE__*/dual(2, (self, options) => new OnSuccessAndFailureImpl(self, options.onSuccess.length !== 1 ? a => options.onSuccess(a) : options.onSuccess, options.onFailure.length !== 1 ? cause => options.onFailure(cause) : options.onFailure));
 const OnSuccessAndFailureProto = /*#__PURE__*/makePrimitiveProto({
   op: "OnSuccessAndFailure",
-  [evaluate](fiber) {
-    fiber._stack.push(this);
-    return this[args];
-  }
+  [evaluate]: evaluateCont
 });
+const OnSuccessAndFailureImpl = function (self, onSuccess, onFailure) {
+  this[args] = self;
+  this[contA] = onSuccess;
+  this[contE] = onFailure;
+};
+OnSuccessAndFailureImpl.prototype = OnSuccessAndFailureProto;
 /** @internal */
 export const matchCause = /*#__PURE__*/dual(2, (self, options) => matchCauseEffect(self, {
   onFailure: cause => sync(() => options.onFailure(cause)),
@@ -1532,12 +1625,17 @@ export const isSuccess = /*#__PURE__*/matchEager({
 /** @internal */
 export const delay = /*#__PURE__*/dual(2, (self, duration) => andThen(sleep(duration), self));
 /** @internal */
-export const timeoutOrElse = /*#__PURE__*/dual(2, (self, options) => raceFirst(self, flatMap(sleep(options.duration), options.orElse)));
+export const timeoutOrElse = /*#__PURE__*/dual(2, (self, options) => flatMap(timeoutOption(self, options.duration), option => Option.isNone(option) ? options.orElse() : succeed(option.value)));
 /** @internal */
-export const timeout = /*#__PURE__*/dual(2, (self, duration) => timeoutOrElse(self, {
-  duration,
-  orElse: () => fail(new TimeoutError())
-}));
+const timeoutErrorFromDuration = duration => new TimeoutError(`Operation timed out after '${Duration.format(duration)}'`);
+/** @internal */
+export const timeout = /*#__PURE__*/dual(2, (self, duration) => {
+  const decoded = Duration.fromInputUnsafe(duration);
+  return timeoutOrElse(self, {
+    duration: decoded,
+    orElse: () => fail(timeoutErrorFromDuration(decoded))
+  });
+});
 /** @internal */
 export const timeoutOption = /*#__PURE__*/dual(2, (self, duration) => raceFirst(asSome(self), as(sleep(duration), Option.none())));
 /** @internal */
@@ -1567,11 +1665,13 @@ export const scopeCloseUnsafe = (self, exit_) => {
     self.state = closed;
     return;
   }
-  const {
-    finalizers
-  } = self.state;
+  const state = self.state;
   self.state = closed;
-  if (finalizers.size === 0) {
+  if (state.finalizer !== undefined) {
+    return state.finalizer(exit_);
+  }
+  const finalizers = state.finalizers;
+  if (finalizers === undefined || finalizers.size === 0) {
     return;
   } else if (finalizers.size === 1) {
     return finalizers.values().next().value(exit_);
@@ -1628,19 +1728,40 @@ export const scopeAddFinalizerUnsafe = (scope, key, finalizer) => {
   if (scope.state._tag === "Empty") {
     scope.state = {
       _tag: "Open",
-      finalizers: new Map([[key, finalizer]])
+      finalizerKey: key,
+      finalizer,
+      finalizers: undefined
     };
   } else if (scope.state._tag === "Open") {
-    scope.state.finalizers.set(key, finalizer);
+    const state = scope.state;
+    if (state.finalizer !== undefined) {
+      state.finalizers = new Map([[state.finalizerKey, state.finalizer]]);
+      state.finalizerKey = undefined;
+      state.finalizer = undefined;
+      state.finalizers.set(key, finalizer);
+    } else if (state.finalizers === undefined) {
+      state.finalizerKey = key;
+      state.finalizer = finalizer;
+    } else {
+      state.finalizers.set(key, finalizer);
+    }
   }
 };
 /** @internal */
 export const scopeRemoveFinalizerUnsafe = (scope, key) => {
   if (scope.state._tag === "Open") {
-    scope.state.finalizers.delete(key);
+    const state = scope.state;
+    if (state.finalizerKey === key) {
+      state.finalizerKey = undefined;
+      state.finalizer = undefined;
+    } else if (state.finalizers !== undefined) {
+      state.finalizers.delete(key);
+    }
   }
 };
 /** @internal */
+export const scopeFinalizerCountUnsafe = scope => scope.state._tag !== "Open" ? 0 : scope.state.finalizer !== undefined ? 1 : scope.state.finalizers?.size ?? 0;
+/** @internal */
 export const scopeMakeUnsafe = (finalizerStrategy = "sequential") => ({
   [ScopeCloseableTypeId]: ScopeCloseableTypeId,
   [ScopeTypeId]: ScopeTypeId,
@@ -1678,30 +1799,40 @@ export const acquireRelease = (acquire, release, options) => contextWith(context
 /** @internal */
 export const addFinalizer = finalizer => flatMap(scope, scope => contextWith(context => scopeAddFinalizerExit(scope, exit => provideContext(finalizer(exit), context))));
 /** @internal */
-export const onExitPrimitive = /*#__PURE__*/makePrimitive({
-  op: "OnExit",
-  single: false,
-  [evaluate](fiber) {
-    fiber._stack.push(this);
-    return this[args][0];
-  },
-  [contAll](fiber) {
-    if (fiber.interruptible && this[args][2] !== true) {
-      fiber._stack.push(setInterruptibleTrue);
-      fiber.interruptible = false;
+export const onExitPrimitive = /*#__PURE__*/function () {
+  const Proto = /*#__PURE__*/makePrimitiveProto({
+    op: "OnExit",
+    [evaluate](fiber) {
+      fiber._stack.push(this);
+      return this.effect;
+    },
+    [contAll](fiber) {
+      if (fiber.interruptible && this.interruptible !== true) {
+        fiber._stack.push(setInterruptibleTrue);
+        fiber.interruptible = false;
+      }
+    },
+    [contA](value, _, exit) {
+      exit ??= exitSucceed(value);
+      const eff = this.onExit(exit);
+      return eff ? flatMap(eff, _ => exit) : exit;
+    },
+    [contE](cause, _, exit) {
+      exit ??= exitFailCause(cause);
+      const eff = this.onExit(exit);
+      return eff ? flatMap(combineFinalizerCause(exit, eff), _ => exit) : exit;
     }
-  },
-  [contA](value, _, exit) {
-    exit ??= exitSucceed(value);
-    const eff = this[args][1](exit);
-    return eff ? flatMap(eff, _ => exit) : exit;
-  },
-  [contE](cause, _, exit) {
-    exit ??= exitFailCause(cause);
-    const eff = this[args][1](exit);
-    return eff ? flatMap(combineFinalizerCause(exit, eff), _ => exit) : exit;
-  }
-});
+  });
+  const OnExitImpl = function (effect, onExit, interruptible) {
+    this.effect = effect;
+    this.onExit = onExit;
+    this.interruptible = interruptible;
+  };
+  OnExitImpl.prototype = Proto;
+  return function (effect, onExit, interruptible) {
+    return new OnExitImpl(effect, onExit, interruptible);
+  };
+}();
 /** @internal */
 export const onExit = /*#__PURE__*/dual(2, onExitPrimitive);
 /** @internal */
@@ -1738,7 +1869,7 @@ export const onErrorFilter = /*#__PURE__*/dual(3, (self, filter, f) => onExit(se
 /** @internal */
 export const onInterrupt = /*#__PURE__*/dual(2, (self, finalizer) => onErrorFilter(causeFilterInterruptors, finalizer)(self));
 /** @internal */
-export const acquireUseRelease = (acquire, use, release) => uninterruptibleMask(restore => flatMap(acquire, a => onExitPrimitive(restore(use(a)), exit => release(a, exit), true)));
+export const acquireUseRelease = (acquire, use, release) => uninterruptibleMask(restore => flatMap(acquire, a => onExitPrimitive(suspend(() => restore(use(a))), exit => release(a, exit), true)));
 /** @internal */
 export const acquireDisposable = acquire => acquireRelease(acquire, resource => hasProperty(resource, Symbol.asyncDispose) ? promise(() => resource[Symbol.asyncDispose]()) : sync(() => resource[Symbol.dispose]()));
 // ----------------------------------------------------------------------------
@@ -1775,7 +1906,21 @@ export const cachedInvalidateWithTTL = /*#__PURE__*/dual(2, (self, ttl) => sync(
 /** @internal */
 export const cachedWithTTL = /*#__PURE__*/dual(2, (self, timeToLive) => map(cachedInvalidateWithTTL(self, timeToLive), tuple => tuple[0]));
 /** @internal */
-export const cached = self => cachedWithTTL(self, Duration.infinity);
+export const cached = self => sync(() => {
+  const latch = makeLatchUnsafe(false);
+  let started = false;
+  let exit;
+  const wait = flatMap(latch.await, () => exit);
+  return suspend(() => {
+    if (exit !== undefined) return exit;
+    if (started) return wait;
+    started = true;
+    return onExit(self, result => sync(() => {
+      exit = result;
+      latch.openUnsafe();
+    }));
+  });
+});
 // ----------------------------------------------------------------------------
 // interruption
 // ----------------------------------------------------------------------------
@@ -1804,6 +1949,30 @@ const setFiberInterruptible = fiber => {
   fiber._stack.push(setInterruptibleFalse);
   if (fiber._interruptedCause) return failCause(fiber._interruptedCause);
 };
+/**
+ * Makes the current fiber uninterruptible for the returned effect without an
+ * extra primitive. Call only within `withFiber`.
+ *
+ * @internal
+ */
+export const fiberEnterUninterruptibleUnsafe = fiber => {
+  const impl = fiber;
+  if (!impl.interruptible) return;
+  impl.interruptible = false;
+  impl._stack.push(setInterruptibleTrue);
+};
+/**
+ * Makes the current fiber interruptible for the returned effect without an
+ * extra primitive. Call only within `withFiber` and return any pending
+ * interruption it produces.
+ *
+ * @internal
+ */
+export const fiberEnterInterruptibleUnsafe = fiber => {
+  const impl = fiber;
+  if (impl.interruptible) return undefined;
+  return setFiberInterruptible(impl);
+};
 /** @internal */
 export const interruptible = self => withFiber(fiber => {
   if (fiber.interruptible) return self;
@@ -1932,8 +2101,7 @@ export const whileLoop = /*#__PURE__*/makePrimitive({
 });
 /** @internal */
 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);
+  const concurrency = resolveConcurrency(options?.concurrency);
   if (concurrency === 1) {
     return forEachSequential(iterable, f, options);
   }
@@ -1970,10 +2138,13 @@ const forEachSequential = (iterable, f, options) => suspend(() => {
     }
   }), out);
 });
-const iterateEagerImpl = options => {
+/** @internal */
+export const resolveConcurrency = concurrency => concurrency === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrency ?? 1);
+/** @internal */
+export const iterateEager = () => options => {
   const onItem = options.onItem;
   const step = options.step;
-  const runSequential = (state, items, index, end) => {
+  const runSequential = (state, items, index = 0, end = items.length) => {
     for (; index < end; index++) {
       const item = items[index];
       const effect = onItem(state, item, index);
@@ -1984,14 +2155,15 @@ const iterateEagerImpl = options => {
       if (terminal) return terminal._tag === "Failure" ? terminal : undefined;
     }
   };
+  return runSequential;
+};
+const iterateConcurrentImpl = options => {
+  const onItem = options.onItem;
+  const step = options.step;
   return (state, items, opts) => {
     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;
+    const end = opts.end ?? items.length;
+    const concurrency = opts.concurrency;
     let done = false;
     let parentFiber;
     let fibers;
@@ -1999,8 +2171,6 @@ const iterateEagerImpl = options => {
     let interrupted = false;
     let terminal;
     let effect;
-    let nextIndex = index;
-    const exits = orderedStep ? new Array(end) : undefined;
     const failDefect = error => {
       const defect = exitDie(error);
       terminal = defect;
@@ -2008,19 +2178,6 @@ const iterateEagerImpl = options => {
       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;
-      exits[currentIndex] = exit;
-      while (nextIndex < end) {
-        const nextExit = exits[nextIndex];
-        if (nextExit === undefined) return;
-        exits[nextIndex] = undefined;
-        const index = nextIndex++;
-        const result = step(state, items[index], nextExit, index);
-        if (result) return result;
-      }
-    };
     const go = () => {
       let paused = false;
       for (; !terminal && index < end; index++) {
@@ -2028,7 +2185,7 @@ const iterateEagerImpl = options => {
         const eff = effect ?? onItem(state, item, index);
         // fast case (already an exit)
         if (effectIsExit(eff)) {
-          terminal = runStep(item, eff, index);
+          terminal = step(state, item, eff, index);
           if (terminal) break;
           // We have an effect, so enter "async" mode
         } else if (!parentFiber) {
@@ -2056,7 +2213,7 @@ const iterateEagerImpl = options => {
           effect = undefined;
           const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit");
           if (fiber._exit) {
-            terminal = runStep(item, fiber._exit, index);
+            terminal = step(state, item, fiber._exit, index);
             if (terminal) break;
             continue;
           }
@@ -2078,7 +2235,7 @@ const iterateEagerImpl = options => {
                   }
                 }
               } else {
-                const result = runStep(item, exit, currentIndex);
+                const result = step(state, item, exit, currentIndex);
                 if (result) {
                   terminal = result._tag === "Failure" ? exitFailCause(causeFromReasons(result.cause.reasons.slice())) : result;
                   go();
@@ -2123,8 +2280,8 @@ const iterateEagerImpl = options => {
   };
 };
 /** @internal */
-export const iterateEager = () => iterateEagerImpl;
-const forEachConcurrent = /*#__PURE__*/iterateEagerImpl({
+export const iterateConcurrent = () => options => iterateConcurrentImpl(options);
+const forEachConcurrent = /*#__PURE__*/iterateConcurrentImpl({
   onItem(state, item, index) {
     return state.f(item, index);
   },
@@ -2134,14 +2291,14 @@ const forEachConcurrent = /*#__PURE__*/iterateEagerImpl({
     }
   }
 });
-/* @internal */
+/** @internal */
 export const filterOrElse = /*#__PURE__*/dual(3, (self, predicate, orElse) => flatMap(self, a => predicate(a) ? succeed(a) : orElse(a)));
 /** @internal */
 export const filterMapOrElse = /*#__PURE__*/dual(3, (self, filter, orElse) => flatMap(self, a => {
   const result = filter(a);
   return Result.isFailure(result) ? orElse(result.failure) : succeed(result.success);
 }));
-/* @internal */
+/** @internal */
 export const filterMapOrFail = /*#__PURE__*/dual(args => isEffect(args[0]), (self, filter, orFailWith) => filterMapOrElse(self, filter, orFailWith ? x => fail(orFailWith(x)) : () => fail(new NoSuchElementError())));
 /** @internal */
 export const filter = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, predicate, options) => suspend(() => {
@@ -2218,7 +2375,7 @@ export const forkUnsafe = (parent, effect, immediate = false, daemon = false, un
   }
   if (!daemon && !child._exit) {
     parentRuntime.children().add(child);
-    child.addObserver(() => parentRuntime._children.delete(child));
+    child._parent = parentRuntime;
   }
   return child;
 };
@@ -2485,7 +2642,7 @@ const filterDisablePropagation = span => {
 /** @internal */
 export const makeSpanUnsafe = (fiber, name, options) => {
   const disablePropagation = !fiber.getRef(TracerEnabled) || options?.annotations && Context.get(options.annotations, Tracer.DisablePropagation);
-  const parent = options?.parent !== undefined ? Option.some(options.parent) : options?.root ? Option.none() : filterDisablePropagation(fiber.currentSpan);
+  const parent = options?.parent !== undefined ? Option.some(options.parent) : options?.root ? Option.none() : filterDisablePropagation(fiber.cache.span);
   let span;
   if (disablePropagation) {
     span = noopSpan({
@@ -2506,7 +2663,7 @@ export const makeSpanUnsafe = (fiber, name, options) => {
       parent,
       annotations: options?.annotations ?? Context.empty(),
       links,
-      startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : BigInt(0),
+      startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : bigint0,
       kind: options?.kind ?? "internal",
       root: options?.root ?? Option.isNone(parent),
       sampled: options?.sampled ?? (Option.isSome(parent) && parent.value.sampled === false ? false : !isLogLevelGreaterThan(fiber.getRef(Tracer.MinimumTraceLevel), level))
@@ -2577,7 +2734,7 @@ export const useSpan = (name, ...args) => {
     const span = makeSpanUnsafe(fiber, name, options);
     const clock = fiber.getRef(ClockRef);
     const timingEnabled = fiber.getRef(TracerTimingEnabled);
-    return onExit(internalCall(() => evaluate(span)), exit => endSpan(span, exit, clock, timingEnabled));
+    return onExit(suspend(() => internalCall(() => evaluate(span))), exit => endSpan(span, exit, clock, timingEnabled));
   });
 };
 const provideParentSpan = /*#__PURE__*/provideService(Tracer.ParentSpan);
@@ -2798,7 +2955,7 @@ export class UnknownError extends /*#__PURE__*/TaggedError("UnknownError") {
 // Console
 // ----------------------------------------------------------------------------
 /** @internal */
-export const ConsoleRef = /*#__PURE__*/Context.Reference("effect/Console/CurrentConsole", {
+export const ConsoleRef = /*#__PURE__*/Context.Reference("effect/Console", {
   defaultValue: () => globalThis.console
 });
 // ----------------------------------------------------------------------------
@@ -2833,7 +2990,7 @@ export const isLogLevelGreaterThan = /*#__PURE__*/Order.isGreaterThan(LogLevelOr
 // Logger
 // ----------------------------------------------------------------------------
 /** @internal */
-export const CurrentLoggers = /*#__PURE__*/Context.Reference("effect/Loggers/CurrentLoggers", {
+export const CurrentLoggers = /*#__PURE__*/Context.Reference("effect/Logger/CurrentLoggers", {
   defaultValue: () => new Set([defaultLogger, tracerLogger])
 });
 /** @internal */
@@ -2860,7 +3017,7 @@ export const annotateLogsScoped = function () {
       };
       for (let i = 0; i < entries.length; i++) {
         const [key, value] = entries[i];
-        if (current[key] !== value) continue;
+        if (current[key] !== value && !Object.is(current[key], value)) continue;
         if (Object.hasOwn(prev, key)) {
           InternalRecord.assignProperty(next, key, prev[key]);
         } else {
@@ -2939,8 +3096,8 @@ export const logWithLevel = level => (...message) => {
     cause = causeEmpty;
   }
   return withFiber(fiber => {
-    const logLevel = level ?? fiber.currentLogLevel;
-    if (isLogLevelGreaterThan(fiber.minimumLogLevel, logLevel)) {
+    const logLevel = level ?? fiber.cache.logLevel;
+    if (isLogLevelGreaterThan(fiber.cache.minimumLogLevel, logLevel)) {
       return void_;
     }
     const clock = fiber.getRef(ClockRef);
@@ -3007,24 +3164,22 @@ export const consolePretty = options => {
   // property accesses, which bundlers must retain as possible side effects
   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";
-  const mode = mode_ === "auto" ? hasProcessStdoutOrDeno ? "tty" : "browser" : mode_;
-  const isBrowser = mode === "browser";
-  const showColors = typeof options?.colors === "boolean" ? options.colors : processStdoutIsTTY || isBrowser;
-  const formatDate = options?.formatDate ?? defaultDateFormat;
-  return isBrowser ? prettyLoggerBrowser({
-    colors: showColors,
-    formatDate
-  }) : prettyLoggerTty({
-    colors: showColors,
-    formatDate
-  });
+  const isDeno = "Deno" in globalThis;
+  const mode = options?.mode ?? "auto";
+  const isTtyLogger = mode === "auto" ? hasProcessStdout || isDeno : mode === "tty";
+  return isTtyLogger ? prettyLoggerTty(options) : prettyLoggerBrowser(options);
 };
-const prettyLoggerTty = options => {
-  const processIsBun = globalThis.process?.isBun === true;
-  const color = options.colors ? withColor : withColorNoop;
+/** @internal */
+export const prettyLoggerTty = options => {
+  const formatDate = options?.formatDate ?? defaultDateFormat;
+  // evaluated lazily so the module-level bundle stays free of `process`
+  // property accesses, which bundlers must retain as possible side effects
+  const process = globalThis.process;
+  const hasProcessStdout = typeof process?.stdout === "object" && process.stdout !== null;
+  const processStdoutIsTTY = hasProcessStdout && process.stdout.isTTY === true;
+  const showColors = typeof options?.colors === "boolean" ? options.colors : processStdoutIsTTY;
+  const color = showColors ? withColor : withColorNoop;
+  const processIsBun = process?.isBun === true;
   return loggerMake(({
     cause,
     date,
@@ -3036,7 +3191,7 @@ const prettyLoggerTty = options => {
     // oxlint-disable-next-line no-console
     const log = fiber.getRef(LogToStderr) ? console.error : console.log;
     const message = Array.isArray(message_) ? message_.slice() : [message_];
-    let firstLine = color(`[${options.formatDate(date)}]`, colors.white) + ` ${color(logLevel.toUpperCase(), ...logLevelColors[logLevel])}` + ` (#${fiber.id})`;
+    let firstLine = color(`[${formatDate(date)}]`, colors.white) + ` ${color(logLevel.toUpperCase(), ...logLevelColors[logLevel])}` + ` (#${fiber.id})`;
     const now = date.getTime();
     const spans = fiber.getRef(CurrentLogSpans);
     for (const span of spans) {
@@ -3070,8 +3225,11 @@ const prettyLoggerTty = options => {
     if (!processIsBun) console.groupEnd();
   });
 };
-const prettyLoggerBrowser = options => {
-  const color = options.colors ? "%c" : "";
+/** @internal */
+export const prettyLoggerBrowser = options => {
+  const showColors = options?.colors !== false;
+  const color = showColors ? "%c" : "";
+  const formatDate = options?.formatDate ?? defaultDateFormat;
   return loggerMake(({
     cause,
     date,
@@ -3081,13 +3239,13 @@ const prettyLoggerBrowser = options => {
   }) => {
     const console = fiber.getRef(ConsoleRef);
     const message = Array.isArray(message_) ? message_.slice() : [message_];
-    let firstLine = `${color}[${options.formatDate(date)}]`;
+    let firstLine = `${color}[${formatDate(date)}]`;
     const firstParams = [];
-    if (options.colors) {
+    if (showColors) {
       firstParams.push("color:gray");
     }
     firstLine += ` ${color}${logLevel.toUpperCase()}${color} (#${fiber.id})`;
-    if (options.colors) {
+    if (showColors) {
       firstParams.push(logLevelStyle[logLevel], "");
     }
     const now = date.getTime();
@@ -3101,7 +3259,7 @@ const prettyLoggerBrowser = options => {
       const firstMaybeString = structuredMessage(message[0]);
       if (typeof firstMaybeString === "string") {
         firstLine += ` ${color}${firstMaybeString}`;
-        if (options.colors) {
+        if (showColors) {
           firstParams.push("color:deepskyblue");
         }
         messageIndex++;
@@ -3122,7 +3280,7 @@ const prettyLoggerBrowser = options => {
     const annotations = fiber.getRef(CurrentLogAnnotations);
     for (const [key, value] of Object.entries(annotations)) {
       const redacted = redact(value);
-      if (options.colors) {
+      if (showColors) {
         // oxlint-disable-next-line no-console
         console.log(`%c${key}:`, "color:gray", redacted);
       } else {
@@ -3170,7 +3328,7 @@ export const tracerLogger = /*#__PURE__*/loggerMake(({
 }) => {
   const clock = fiber.getRef(ClockRef);
   const annotations = fiber.getRef(CurrentLogAnnotations);
-  const span = fiber.currentSpan;
+  const span = fiber.cache.span;
   if (span === undefined || span._tag === "ExternalSpan") return;
   const attributes = {};
   for (const [key, value] of Object.entries(annotations)) {