effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/internal/effect.ts

@@ -18,7 +18,6 @@ import * as Iterable from "../Iterable.ts"
 import type * as _Latch from "../Latch.ts"
 import type * as Logger from "../Logger.ts"
 import type * as LogLevel from "../LogLevel.ts"
-import type * as Metric from "../Metric.ts"
 import * as Option from "../Option.ts"
 import * as Order from "../Order.ts"
 import { pipeArguments } from "../Pipeable.ts"
@@ -105,7 +104,7 @@ import { addSpanStackTrace, makeStackCleaner } from "./tracer.ts"
 
 /** @internal */
 export class Interrupt extends ReasonBase<"Interrupt"> implements Cause.Interrupt {
-  readonly fiberId: number | undefined
+  declare readonly fiberId: number | undefined
   constructor(
     fiberId: number | undefined,
     annotations = constEmptyAnnotations
@@ -238,6 +237,29 @@ export const causeAnnotations = <E>(
   return Context.makeUnsafe(map)
 }
 
+const dedupeReasons = <E>(
+  self: ReadonlyArray<Cause.Reason<E>>,
+  that: ReadonlyArray<Cause.Reason<E>>
+): Array<Cause.Reason<E>> => {
+  // 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<number, Array<Cause.Reason<E>>>()
+  const out: Array<Cause.Reason<E>> = []
+  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: {
   <E2>(that: Cause.Cause<E2>): <E>(self: Cause.Cause<E>) => Cause.Cause<E | E2>
@@ -251,7 +273,7 @@ export const causeCombine: {
       return self as Cause.Cause<E | E2>
     }
     const newCause = new CauseImpl<E | E2>(
-      Arr.union(self.reasons, that.reasons)
+      dedupeReasons<E | E2>(self.reasons, that.reasons)
     )
     return Equal.equals(self, newCause) ? self : newCause
   }
@@ -317,7 +339,7 @@ export const causePrettyErrors = <E>(self: Cause.Cause<E>, options?: {
   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") {
@@ -342,7 +364,7 @@ export const causePrettyErrors = <E>(self: Cause.Cause<E>, options?: {
     errors.push(causePrettyError(error, interrupts[0].annotations, options))
   }
 
-  setStackTraceLimit(prevStackLimit)
+  if (prevStackLimit !== 0) setStackTraceLimit(prevStackLimit)
   return errors
 }
 
@@ -513,14 +535,15 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     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)
   }
 
   readonly [FiberTypeId]: Fiber.Fiber.Variance<A, E>
@@ -529,29 +552,22 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   interruptible: boolean
   currentOpCount: number
   readonly _stack: Array<Primitive>
-  readonly _observers: Array<(exit: Exit.Exit<A, E>) => void>
+  _observers: Array<(exit: Exit.Exit<A, E>) => void> | undefined
   _exit: Exit.Exit<A, E> | undefined
   _children: Set<FiberImpl<any, any>> | undefined
   _interruptedCause: Cause.Cause<never> | undefined
   _yielded: Exit.Exit<any, any> | (() => void) | undefined
   _running: boolean
   _deferredInterrupt: boolean
+  _parent: FiberImpl<any, any> | undefined
 
   // set in setContext
   context!: Context.Context<never>
-  currentScheduler!: Scheduler.Scheduler
-  currentTracerContext: Tracer.Tracer["context"]
-  currentSpan: Tracer.AnySpan | undefined
-  currentLogLevel!: LogLevel.LogLevel
-  minimumLogLevel!: LogLevel.LogLevel
-  currentStackFrame: StackFrame | undefined
-  runtimeMetrics: Metric.FiberRuntimeMetricsService | undefined
-  maxOpsBeforeYield!: number
-  currentPreventYield!: boolean
+  cache!: Fiber.Fiber.Cache
 
   _dispatcher: Scheduler.SchedulerDispatcher | undefined = undefined
   get currentDispatcher(): Scheduler.SchedulerDispatcher {
-    return this._dispatcher ??= this.currentScheduler.makeDispatcher()
+    return this._dispatcher ??= this.cache.scheduler.makeDispatcher()
   }
 
   getRef<X>(ref: Context.Reference<X>): X {
@@ -562,9 +578,13 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
       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)
@@ -576,8 +596,8 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
       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)
@@ -617,11 +637,18 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     }
 
     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()
@@ -641,17 +668,19 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
           current = failCause(this._interruptedCause!) as any
         }
         this.currentOpCount++
+        // Refresh the cache because a primitive can replace the fiber context.
+        const cache = this.cache
         if (
           !yielding &&
-          !this.currentPreventYield &&
-          this.currentScheduler.shouldYield(this as any)
+          !cache.preventYield &&
+          cache.scheduler.shouldYield(this as any)
         ) {
           yielding = true
           const prev = current
           current = flatMap(yieldNow, () => prev as any) as any
         }
-        current = this.currentTracerContext
-          ? this.currentTracerContext(current as any, this)
+        current = cache.tracerContext
+          ? cache.tracerContext(current as any, this)
           : (current as any)[evaluate](this)
         if (current === Yield) {
           const yielded = this._yielded!
@@ -688,10 +717,13 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     while (true) {
       const op = this._stack.pop()
       if (!op) return undefined
-      const cont = op[contAll] && op[contAll](this)
-      if (cont) {
-        ;(cont as any)[symbol] = cont
-        return cont as any
+      const all = op[contAll]
+      if (all !== undefined) {
+        const cont = all.call(op, this)
+        if (cont) {
+          ;(cont as any)[symbol] = cont
+          return cont as any
+        }
       }
       if (op[symbol]) return op as any
     }
@@ -712,25 +744,38 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     // 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: any = (context as any).cacheRoot
+    const cache: Fiber.Fiber.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<Tracer.Tracer>(context, Tracer.TracerKey)
-    this.currentTracerContext = currentTracer ? currentTracer["context"] : undefined
+    this.cache = cache
   }
   get currentSpanLocal(): Tracer.Span | undefined {
-    return this.currentSpan?._tag === "Span" ? this.currentSpan : undefined
+    const span = this.cache.span
+    return span?._tag === "Span" ? span : undefined
+  }
+}
+
+const makeFiberContextCache = (context: Context.Context<never>): Fiber.Fiber.Cache => {
+  // 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<Tracer.Tracer>(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)
   }
 }
 
@@ -750,9 +795,9 @@ const fiberMiddleware = {
 }
 
 const fiberStackAnnotations = (fiber: Fiber.Fiber<any, any>) => {
-  if (!fiber.currentStackFrame) return undefined
+  if (!fiber.cache.stackFrame) return undefined
   const annotations = new Map<string, unknown>()
-  annotations.set(InterruptorStackTrace.key, fiber.currentStackFrame)
+  annotations.set(InterruptorStackTrace.key, fiber.cache.stackFrame)
   return Context.makeUnsafe(annotations)
 }
 
@@ -1106,41 +1151,50 @@ const callbackOptions: <A, E = never, R = never>(
     signal?: AbortSignal
   ) => void | Effect.Effect<void, never, R>,
   withSignal: boolean
-) => Effect.Effect<A, E, R> = makePrimitive({
-  op: "Async",
-  single: false,
-  [evaluate](fiber) {
-    const register = internalCall(() => this[args][0].bind(fiber.currentScheduler))
-    let resumed = false
-    let yielded: boolean | Primitive = false
-    const controller = this[args][1] ? new AbortController() : undefined
-    const onCancel = register((effect) => {
-      if (resumed) return
-      resumed = true
-      if (yielded) {
-        fiber.evaluate(effect as any)
-      } else {
-        yielded = effect as any
+) => Effect.Effect<A, E, R> = (function() {
+  const Proto = makePrimitiveProto({
+    op: "Async",
+    [evaluate](this: any, fiber) {
+      const register = internalCall(() => this.register.bind(fiber.cache.scheduler))
+      let resumed = false
+      let yielded: boolean | Primitive = false
+      const controller = this.withSignal ? new AbortController() : undefined
+      const onCancel = register((effect: Effect.Effect<any, any, any>) => {
+        if (resumed) return
+        resumed = true
+        if (yielded) {
+          fiber.evaluate(effect as any)
+        } else {
+          yielded = effect as any
+        }
+      }, controller?.signal)
+      if (yielded !== false) return yielded
+      yielded = true
+      fiber._yielded = () => {
+        resumed = true
       }
-    }, controller?.signal)
-    if (yielded !== false) return yielded
-    yielded = true
-    fiber._yielded = () => {
-      resumed = true
-    }
-    if (controller === undefined && onCancel === undefined) {
+      if (controller === undefined && onCancel === undefined) {
+        return Yield
+      }
+      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(this: any, register: any, withSignal: boolean) {
+    this.register = register
+    this.withSignal = withSignal
+  } as unknown as PrimitiveCtor<[register: any, withSignal: boolean]>
+  AsyncImpl.prototype = Proto
+  return function(register: any, withSignal: boolean) {
+    return new AsyncImpl(register, withSignal)
+  } as any
+})()
 
 const asyncFinalizer: (
   onInterrupt: () => Effect.Effect<void, any, any>
@@ -1188,12 +1242,14 @@ export const gen = <
   [Eff] extends [never] ? never
     : [Eff] extends [Effect.Effect<infer _A, infer _E, infer R>] ? R
     : never
-> =>
-  suspend(() =>
-    fromIteratorUnsafe(
-      args.length === 1 ? args[0]() : (args[1].call(args[0].self) as any)
-    )
-  )
+> => {
+  if (args.length === 1) {
+    const body = args[0]
+    return suspend(() => fromIteratorUnsafe(body()))
+  }
+  const [options, body] = args
+  return suspend(() => fromIteratorUnsafe(body.call(options.self) as any))
+}
 
 /** @internal */
 export const fnUntraced: Effect.fn.Untraced = (
@@ -1229,9 +1285,12 @@ export const fn: typeof Effect.fn = function() {
   const spanOptions = nameFirst ? arguments[1] : undefined
 
   const prevLimit = getStackTraceLimit()
-  setStackTraceLimit(2)
-  const defError = new globalThis.Error()
-  setStackTraceLimit(prevLimit)
+  let defError: Error | undefined
+  if (prevLimit !== 0) {
+    setStackTraceLimit(2)
+    defError = new globalThis.Error()
+    setStackTraceLimit(prevLimit)
+  }
 
   if (nameFirst) {
     return (body: Function | { readonly self: any }, ...pipeables: Array<Function>) =>
@@ -1251,7 +1310,7 @@ export const fn: typeof Effect.fn = function() {
 const makeFn = (
   name: string,
   bodyOrOptions: Function | { readonly self: any },
-  defError: Error,
+  defError: Error | undefined,
   pipeables: Array<Function>,
   addSpan: boolean,
   spanOptions: Tracer.SpanOptionsNoTrace | undefined
@@ -1272,9 +1331,12 @@ const makeFn = (
       return result
     }
     const prevLimit = getStackTraceLimit()
-    setStackTraceLimit(2)
-    const callError = new globalThis.Error()
-    setStackTraceLimit(prevLimit)
+    let callError: Error | undefined
+    if (prevLimit !== 0) {
+      setStackTraceLimit(2)
+      callError = new globalThis.Error()
+      setStackTraceLimit(prevLimit)
+    }
     return updateService(
       addSpan ?
         useSpan(name, spanOptions!, (span) => provideParentSpan(result, span)) :
@@ -1282,10 +1344,10 @@ const makeFn = (
       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
         }
       })
@@ -1307,7 +1369,7 @@ export const fnUntracedEager: Effect.fn.Untraced = (
       : function(this: any) {
         let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments))
         for (const pipeable of pipeables) {
-          effect = pipeable(effect)
+          effect = pipeable(effect, ...arguments)
         }
         return effect
       }
@@ -1356,27 +1418,36 @@ const fromIteratorEagerUnsafe = (
 const fromIteratorUnsafe: (
   iterator: Iterator<Effect.Effect<any, any, any>>,
   initial?: undefined
-) => Effect.Effect<any, any, any> = 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
+) => Effect.Effect<any, any, any> = (function() {
+  const Proto = makePrimitiveProto({
+    op: "Iterator",
+    [contA](this: any, 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](this: any, fiber: FiberImpl) {
+      return this[contA](this.initial, fiber)
     }
-  },
-  [evaluate](this: any, fiber: FiberImpl) {
-    return this[contA](this[args][1], fiber)
-  }
-})
+  })
+  const IteratorImpl = function(this: any, iterator: any, initial: any) {
+    this.iterator = iterator
+    this.initial = initial
+  } as unknown as PrimitiveCtor<[iterator: any, initial: any]>
+  IteratorImpl.prototype = Proto
+  return function(iterator: any, initial?: undefined) {
+    return new IteratorImpl(iterator, initial)
+  } as any
+})()
 
 // ----------------------------------------------------------------------------
 // mapping & sequencing
@@ -1393,12 +1464,71 @@ export const as: {
   <A, E, R, B>(
     self: Effect.Effect<A, E, R>,
     value: B
-  ): Effect.Effect<B, E, R> => {
-    const b = succeed(value)
-    return flatMap(self, (_) => b)
-  }
+  ): Effect.Effect<B, E, R> => new ContImpl(self, returnPayload, succeed(value))
 )
 
+const evaluateCont = function(this: any, fiber: FiberImpl): Primitive {
+  fiber._stack.push(this)
+  return this[args]
+}
+
+interface PrimitiveCtor<Args extends Array<any>> {
+  new(...args: Args): Primitive & Effect.Effect<any, any, any>
+  prototype: any
+}
+
+const OnSuccessProto = makePrimitiveProto({
+  op: "OnSuccess",
+  [evaluate]: evaluateCont
+})
+
+const OnSuccessImpl = function(this: any, self: Effect.Effect<any, any, any>, f: any) {
+  this[args] = self
+  this[contA] = f
+} as unknown as PrimitiveCtor<[self: Effect.Effect<any, any, any>, f: any]>
+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(
+  this: any,
+  self: Effect.Effect<any, any, any>,
+  cont: (this: { readonly payload: any }, value: any, fiber: FiberImpl) => unknown,
+  payload: unknown
+) {
+  this[args] = self
+  this[contA] = cont
+  this.payload = payload
+} as unknown as PrimitiveCtor<
+  [
+    self: Effect.Effect<any, any, any>,
+    cont: (this: { readonly payload: any }, value: any, fiber: FiberImpl) => unknown,
+    payload: unknown
+  ]
+>
+ContImpl.prototype = OnSuccessProto
+
+const returnPayload = function(this: { readonly payload: any }) {
+  return this.payload
+}
+const mapCont = function(this: { readonly payload: any }, value: any) {
+  const f = this.payload
+  return succeed(internalCall(() => f(value)))
+}
+const andThenCont = function(this: { readonly payload: any }, value: any) {
+  const f = this.payload
+  return internalCall(() => f(value))
+}
+const tapCont = function(this: { readonly payload: any }, value: any) {
+  const f = this.payload
+  return new ContImpl(internalCall(() => f(value)), returnPayload, exitSucceed(value))
+}
+const tapEffectCont = function(this: { readonly payload: any }, value: any) {
+  return new ContImpl(this.payload, returnPayload, exitSucceed(value))
+}
+
 /** @internal */
 export const asSome = <A, E, R>(
   self: Effect.Effect<A, E, R>
@@ -1434,8 +1564,7 @@ export const andThen: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: ((a: A) => Effect.Effect<B, E2, R2>) | Effect.Effect<B, E2, R2>
-  ): Effect.Effect<B, E | E2, R | R2> =>
-    flatMap(self, (a) => isEffect(f) ? f : internalCall(() => (f as (a: A) => Effect.Effect<B, E2, R2>)(a)))
+  ): Effect.Effect<B, E | E2, R | R2> => new ContImpl(self, isEffect(f) ? returnPayload : andThenCont, f)
 )
 
 /** @internal */
@@ -1459,14 +1588,13 @@ export const tap: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: ((a: A) => Effect.Effect<B, E2, R2>) | Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A, E | E2, R | R2> =>
-    flatMap(self, (a) => as(isEffect(f) ? f : internalCall(() => (f as (a: A) => Effect.Effect<B, E2, R2>)(a)), a))
+  ): Effect.Effect<A, E | E2, R | R2> => new ContImpl(self, isEffect(f) ? tapEffectCont : tapCont, f)
 )
 
 /** @internal */
 export const asVoid = <A, E, R>(
   self: Effect.Effect<A, E, R>
-): Effect.Effect<void, E, R> => flatMap(self, (_) => exitVoid)
+): Effect.Effect<void, E, R> => new ContImpl(self, returnPayload, exitVoid)
 
 /** @internal */
 export const sandbox = <A, E, R>(
@@ -1673,20 +1801,8 @@ export const flatMap: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (a: A) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<B, E | E2, R | R2> => {
-    const onSuccess = Object.create(OnSuccessProto)
-    onSuccess[args] = self
-    onSuccess[contA] = f.length !== 1 ? (a: A) => f(a) : f
-    return onSuccess
-  }
+  ): Effect.Effect<B, E | E2, R | R2> => new OnSuccessImpl(self, f.length !== 1 ? (a: A) => f(a) : f)
 )
-const OnSuccessProto = makePrimitiveProto({
-  op: "OnSuccess",
-  [evaluate](this: any, fiber: FiberImpl): Primitive {
-    fiber._stack.push(this)
-    return this[args]
-  }
-})
 
 /** @internal */
 export const matchCauseEffectEager: {
@@ -1722,7 +1838,8 @@ export const matchCauseEffectEager: {
 )
 
 /** @internal */
-export const effectIsExit = <A, E, R>(effect: Effect.Effect<A, E, R>): effect is Exit.Exit<A, E> => ExitTypeId in effect
+export const effectIsExit = <A, E, R>(effect: Effect.Effect<A, E, R>): effect is Exit.Exit<A, E> =>
+  (effect as any)[ExitTypeId] !== undefined
 
 /** @internal */
 export const flatMapEager: {
@@ -1769,7 +1886,7 @@ export const map: {
   <A, E, R, B>(
     self: Effect.Effect<A, E, R>,
     f: (a: A) => B
-  ): Effect.Effect<B, E, R> => flatMap(self, (a) => succeed(internalCall(() => f(a))))
+  ): Effect.Effect<B, E, R> => new ContImpl(self, mapCont, f)
 )
 
 /** @internal */
@@ -2135,7 +2252,9 @@ export const updateServiceScoped = <I, A>(
     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: A
       if (options?.reset === undefined) {
         if (current !== updated) return void_
@@ -2311,7 +2430,7 @@ export const zipWith: {
 // filtering & conditionals
 // ----------------------------------------------------------------------------
 
-/* @internal */
+/** @internal */
 export const filterOrFail: {
   <A, E2, B extends A>(
     refinement: Predicate.Refinement<NoInfer<A>, B>,
@@ -2485,20 +2604,18 @@ export const catchCause: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (cause: NoInfer<Cause.Cause<E>>) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, E2, R | R2> => {
-    const onFailure = Object.create(OnFailureProto)
-    onFailure[args] = self
-    onFailure[contE] = f.length !== 1 ? (cause: Cause.Cause<E>) => f(cause) : f
-    return onFailure
-  }
+  ): Effect.Effect<A | B, E2, R | R2> =>
+    new OnFailureImpl(self, f.length !== 1 ? (cause: Cause.Cause<E>) => f(cause) : f)
 )
 const OnFailureProto = makePrimitiveProto({
   op: "OnFailure",
-  [evaluate](this: any, fiber: FiberImpl): Primitive {
-    fiber._stack.push(this as any)
-    return this[args]
-  }
+  [evaluate]: evaluateCont
 })
+const OnFailureImpl = function(this: any, self: Effect.Effect<any, any, any>, f: any) {
+  this[args] = self
+  this[contE] = f
+} as unknown as PrimitiveCtor<[self: Effect.Effect<any, any, any>, f: any]>
+OnFailureImpl.prototype = OnFailureProto
 
 /** @internal */
 export const catchCauseIf: {
@@ -2741,9 +2858,9 @@ export const tapErrorTag: {
 
 /** @internal */
 export const tapDefect: {
-  <E, B, E2, R2>(
+  <B, E2, R2>(
     f: (defect: unknown) => Effect.Effect<B, E2, R2>
-  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>
+  ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (defect: unknown) => Effect.Effect<B, E2, R2>
@@ -3098,7 +3215,10 @@ export const catchReason: {
   > =>
     catchIf(
       self,
-      ((e: any) => isTagged(e, errorTag) && hasProperty(e, "reason")) as any,
+      ((e: any) =>
+        isTagged(e, errorTag) &&
+        hasProperty(e, "reason") &&
+        (orElse !== undefined || isTagged(e.reason, reasonTag))) as any,
       (e: any): Effect.Effect<A2 | A3, E | E2 | E3, R2 | R3> => {
         const reason = e.reason as any
         if (isTagged(reason, reasonTag)) return f(reason as any, e)
@@ -3198,7 +3318,8 @@ export const catchReasons: {
       isTagged(e, errorTag) &&
       hasProperty(e, "reason") &&
       hasProperty(e.reason, "_tag") &&
-      isString(e.reason._tag)) as any,
+      isString(e.reason._tag) &&
+      (orElse !== undefined || (keys ??= Object.keys(cases)).includes(e.reason._tag))) as any,
     (e: any) => {
       const reason = e.reason
       keys ??= Object.keys(cases)
@@ -3267,7 +3388,7 @@ export const mapError: {
   ): Effect.Effect<A, E2, R> => catch_(self, (error) => failSync(() => f(error)))
 )
 
-/* @internal */
+/** @internal */
 export const mapBoth: {
   <E, E2, A, A2>(
     options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
@@ -3446,23 +3567,30 @@ export const matchCauseEffect: {
       readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A2, E2, R2>
       readonly onSuccess: (a: A) => Effect.Effect<A3, E3, R3>
     }
-  ): Effect.Effect<A2 | A3, E2 | E3, R2 | R3 | R> => {
-    const primitive = Object.create(OnSuccessAndFailureProto)
-    primitive[args] = self
-    primitive[contA] = options.onSuccess.length !== 1 ? (a: A) => options.onSuccess(a) : options.onSuccess
-    primitive[contE] = options.onFailure.length !== 1
-      ? (cause: Cause.Cause<E>) => options.onFailure(cause)
-      : options.onFailure
-    return primitive
-  }
+  ): Effect.Effect<A2 | A3, E2 | E3, R2 | R3 | R> =>
+    new OnSuccessAndFailureImpl(
+      self,
+      options.onSuccess.length !== 1 ? (a: A) => options.onSuccess(a) : options.onSuccess,
+      options.onFailure.length !== 1
+        ? (cause: Cause.Cause<E>) => options.onFailure(cause)
+        : options.onFailure
+    )
 )
 const OnSuccessAndFailureProto = makePrimitiveProto({
   op: "OnSuccessAndFailure",
-  [evaluate](this: any, fiber: FiberImpl): Primitive {
-    fiber._stack.push(this)
-    return this[args]
-  }
+  [evaluate]: evaluateCont
 })
+const OnSuccessAndFailureImpl = function(
+  this: any,
+  self: Effect.Effect<any, any, any>,
+  onSuccess: any,
+  onFailure: any
+) {
+  this[args] = self
+  this[contA] = onSuccess
+  this[contE] = onFailure
+} as unknown as PrimitiveCtor<[self: Effect.Effect<any, any, any>, onSuccess: any, onFailure: any]>
+OnSuccessAndFailureImpl.prototype = OnSuccessAndFailureProto
 
 /** @internal */
 export const matchCause: {
@@ -3697,12 +3825,16 @@ export const timeoutOrElse: {
       readonly orElse: LazyArg<Effect.Effect<A2, E2, R2>>
     }
   ): Effect.Effect<A | A2, E | E2, R | R2> =>
-    raceFirst(
-      self,
-      flatMap(sleep(options.duration), options.orElse)
+    flatMap(
+      timeoutOption(self, options.duration),
+      (option): Effect.Effect<A | A2, E2, R2> => Option.isNone(option) ? options.orElse() : succeed(option.value)
     )
 )
 
+/** @internal */
+const timeoutErrorFromDuration = (duration: Duration.Duration): TimeoutError =>
+  new TimeoutError(`Operation timed out after '${Duration.format(duration)}'`)
+
 /** @internal */
 export const timeout: {
   (
@@ -3719,11 +3851,13 @@ export const timeout: {
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
     duration: Duration.Input
-  ): Effect.Effect<A, E | TimeoutError, R> =>
-    timeoutOrElse(self, {
-      duration,
-      orElse: () => fail(new TimeoutError())
+  ): Effect.Effect<A, E | TimeoutError, R> => {
+    const decoded = Duration.fromInputUnsafe(duration)
+    return timeoutOrElse(self, {
+      duration: decoded,
+      orElse: () => fail(timeoutErrorFromDuration(decoded))
     })
+  }
 )
 
 /** @internal */
@@ -4003,30 +4137,40 @@ export const onExitPrimitive: <A, E, R, XE = never, XR = never>(
   self: Effect.Effect<A, E, R>,
   f: (exit: Exit.Exit<A, E>) => Effect.Effect<void, XE, XR> | undefined,
   interruptible?: boolean
-) => Effect.Effect<A, E | XE, R | XR> = makePrimitive({
-  op: "OnExit",
-  single: false,
-  [evaluate](fiber: FiberImpl) {
-    fiber._stack.push(this)
-    return this[args][0]
-  },
-  [contAll](fiber) {
-    if (fiber.interruptible && this[args][2] !== true) {
-      fiber._stack.push(setInterruptibleTrue)
-      fiber.interruptible = false
+) => Effect.Effect<A, E | XE, R | XR> = (function() {
+  const Proto = makePrimitiveProto({
+    op: "OnExit",
+    [evaluate](this: any, fiber: FiberImpl) {
+      fiber._stack.push(this)
+      return this.effect
+    },
+    [contAll](this: any, fiber) {
+      if (fiber.interruptible && this.interruptible !== true) {
+        fiber._stack.push(setInterruptibleTrue)
+        fiber.interruptible = false
+      }
+    },
+    [contA](this: any, value, _, exit) {
+      exit ??= exitSucceed(value)
+      const eff = this.onExit(exit)
+      return eff ? flatMap(eff, (_) => exit) : exit
+    },
+    [contE](this: any, 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(this: any, effect: any, onExit: any, interruptible: any) {
+    this.effect = effect
+    this.onExit = onExit
+    this.interruptible = interruptible
+  } as unknown as PrimitiveCtor<[effect: any, onExit: any, interruptible: any]>
+  OnExitImpl.prototype = Proto
+  return function(effect: any, onExit: any, interruptible?: boolean) {
+    return new OnExitImpl(effect, onExit, interruptible)
+  } as any
+})()
 
 /** @internal */
 export const onExit: {
@@ -4206,7 +4350,7 @@ export const acquireUseRelease = <Resource, E, R, A, E2, R2, E3, R3>(
   uninterruptibleMask((restore) =>
     flatMap(acquire, (a) =>
       onExitPrimitive(
-        restore(use(a)),
+        suspend(() => restore(use(a))),
         (exit) => release(a, exit),
         true
       ))
@@ -4289,7 +4433,22 @@ export const cachedWithTTL: {
 
 /** @internal */
 export const cached = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Effect.Effect<A, E, R>> =>
-  cachedWithTTL(self, Duration.infinity)
+  sync(() => {
+    const latch = makeLatchUnsafe(false)
+    let started = false
+    let exit: Exit.Exit<A, E> | undefined
+    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
@@ -4327,6 +4486,34 @@ const setFiberInterruptible = (fiber: FiberImpl): Effect.Effect<never> | undefin
   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: Fiber.Fiber<unknown, unknown>): void => {
+  const impl = fiber as FiberImpl
+  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: Fiber.Fiber<unknown, unknown>
+): Effect.Effect<never> | undefined => {
+  const impl = fiber as FiberImpl
+  if (impl.interruptible) return undefined
+  return setFiberInterruptible(impl)
+}
+
 /** @internal */
 export const interruptible = <A, E, R>(
   self: Effect.Effect<A, E, R>
@@ -4672,10 +4859,7 @@ export const forEach: {
   }
 ): Effect.Effect<any, E, R> =>
   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)
@@ -4728,19 +4912,22 @@ const forEachSequential = <A, B, E, R>(
     )
   })
 
-type IterateEagerOptions = {
-  readonly concurrency?: number | undefined
-  readonly end?: number | undefined
-  readonly orderedStep?: boolean | undefined
-}
+/** @internal */
+export const resolveConcurrency = (concurrency: Concurrency | undefined): number =>
+  concurrency === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrency ?? 1)
 
-const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
+type IterateOptions<S, A, X, E, R, E2> = {
   readonly onItem: (state: S, item: A, index: number) => Effect.Effect<X, E, R>
   readonly step: (state: NoInfer<S>, item: A, exit: Exit.Exit<X, E>, index: number) => Exit.Exit<void, E2> | void
-}): (
+}
+
+/** @internal */
+export const iterateEager = <S, A>() =>
+<X, E, R, E2>(options: IterateOptions<S, A, X, E, R, E2>): (
   initialState: S,
   items: ReadonlyArray<A>,
-  options?: IterateEagerOptions
+  start?: number,
+  end?: number
 ) => Effect.Effect<void, E | E2, R> | undefined => {
   const onItem = options.onItem
   const step = options.step
@@ -4748,8 +4935,8 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
   const runSequential = (
     state: S,
     items: ReadonlyArray<A>,
-    index: number,
-    end: number
+    index = 0,
+    end = items.length
   ): Effect.Effect<void, E | E2, R> | undefined => {
     for (; index < end; index++) {
       const item = items[index]
@@ -4765,18 +4952,20 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
     }
   }
 
+  return runSequential
+}
+
+const iterateConcurrentImpl = <S, A, X, E, R, E2>(options: IterateOptions<S, A, X, E, R, E2>) => {
+  const onItem = options.onItem
+  const step = options.step
   return (
     state: S,
     items: ReadonlyArray<A>,
-    opts: IterateEagerOptions | undefined
+    opts: { readonly concurrency: number; readonly end?: number | undefined }
   ): Effect.Effect<void, E | E2, R> | undefined => {
     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
+    const end = opts.end ?? items.length
+    const concurrency = opts.concurrency
     let done = false
     let parentFiber: Fiber.Fiber<any, any> | undefined
     let fibers: Set<Fiber.Fiber<any, any>> | undefined
@@ -4784,8 +4973,6 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
     let interrupted = false
     let terminal: Exit.Exit<void, E | E2> | void
     let effect: Effect.Effect<X, E, R> | undefined
-    let nextIndex = index
-    const exits: Array<Exit.Exit<X, E> | undefined> | undefined = orderedStep ? new Array(end) : undefined
 
     const failDefect = (error: unknown): Effect.Effect<void, E | E2, R> => {
       const defect = exitDie(error)
@@ -4797,20 +4984,6 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
         : defect
     }
 
-    const runStep = (item: A, exit: Exit.Exit<X, E>, currentIndex: number): Exit.Exit<void, E | E2> | void => {
-      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 = (): Effect.Effect<void, E | E2, R> | undefined => {
       let paused = false
       for (; !terminal && index < end; index++) {
@@ -4819,7 +4992,7 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
 
         // 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
@@ -4850,7 +5023,7 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
 
           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
           }
@@ -4874,7 +5047,7 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(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()))
@@ -4927,16 +5100,10 @@ const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
 }
 
 /** @internal */
-export const iterateEager = <S, A>(): <X, E, R, E2>(options: {
-  readonly onItem: (state: S, item: A, index: number) => Effect.Effect<X, E, R>
-  readonly step: (state: NoInfer<S>, item: A, exit: Exit.Exit<X, E>, index: number) => Exit.Exit<void, E2> | void
-}) => (
-  initialState: S,
-  items: ReadonlyArray<A>,
-  options?: IterateEagerOptions
-) => Effect.Effect<void, E | E2, R> | undefined => iterateEagerImpl
+export const iterateConcurrent = <S, A>() => <X, E, R, E2>(options: IterateOptions<S, A, X, E, R, E2>) =>
+  iterateConcurrentImpl<S, A, X, E, R, E2>(options)
 
-const forEachConcurrent = iterateEagerImpl({
+const forEachConcurrent = iterateConcurrentImpl({
   onItem(
     state: {
       readonly f: (a: any, i: number) => Effect.Effect<any, any, any>
@@ -4955,7 +5122,7 @@ const forEachConcurrent = iterateEagerImpl({
   }
 })
 
-/* @internal */
+/** @internal */
 export const filterOrElse: {
   <A, C, E2, R2, B extends A>(
     refinement: Predicate.Refinement<NoInfer<A>, B>,
@@ -5011,7 +5178,7 @@ export const filterMapOrElse: {
     }
   ))
 
-/* @internal */
+/** @internal */
 export const filterMapOrFail: {
   <A, B, X, E2>(
     filter: Filter.Filter<NoInfer<A>, B, X>,
@@ -5278,7 +5445,7 @@ export const forkUnsafe = <FA, FE, A, E, R>(
   }
   if (!daemon && !child._exit) {
     parentRuntime.children().add(child)
-    child.addObserver(() => parentRuntime._children!.delete(child))
+    child._parent = parentRuntime
   }
   return child
 }
@@ -5733,7 +5900,7 @@ export const makeSpanUnsafe = <XA, XE>(
     ? Option.some(options.parent)
     : options?.root
     ? Option.none<Tracer.AnySpan>()
-    : filterDisablePropagation(fiber.currentSpan)
+    : filterDisablePropagation(fiber.cache.span)
 
   let span: Tracer.Span
 
@@ -5766,7 +5933,7 @@ export const makeSpanUnsafe = <XA, XE>(
       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 ??
@@ -5910,7 +6077,10 @@ export const useSpan: {
     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)
+    )
   })
 }
 
@@ -6220,7 +6390,7 @@ export class UnknownError extends TaggedError("UnknownError")<{
 
 /** @internal */
 export const ConsoleRef = Context.Reference<Console.Console>(
-  "effect/Console/CurrentConsole",
+  "effect/Console",
   { defaultValue: (): Console.Console => globalThis.console }
 )
 
@@ -6263,7 +6433,7 @@ export const isLogLevelGreaterThan = Order.isGreaterThan(LogLevelOrder)
 /** @internal */
 export const CurrentLoggers = Context.Reference<
   ReadonlySet<Logger.Logger<unknown, any>>
->("effect/Loggers/CurrentLoggers", {
+>("effect/Logger/CurrentLoggers", {
   defaultValue: () => new Set([defaultLogger, tracerLogger])
 })
 
@@ -6293,7 +6463,7 @@ export const annotateLogsScoped: {
       const next = { ...current }
       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 {
@@ -6381,8 +6551,8 @@ export const logWithLevel = (level?: LogLevel.Severity) =>
     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)
@@ -6458,29 +6628,36 @@ 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 process = (globalThis as {
-    readonly process?: { readonly stdout?: { readonly isTTY?: boolean } }
-  }).process
+  const process = (globalThis as { readonly process?: { readonly stdout?: unknown } }).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: {
-  readonly colors: boolean
-  readonly formatDate: (date: Date) => string
+/** @internal */
+export const prettyLoggerTty = (options?: {
+  readonly colors?: "auto" | boolean | undefined
+  readonly formatDate?: ((date: Date) => string) | undefined
 }) => {
-  const processIsBun = (globalThis as { readonly process?: { readonly isBun?: boolean } }).process?.isBun === true
-  const color = options.colors ? withColor : withColorNoop
+  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 as {
+    readonly process?: {
+      readonly stdout?: { readonly isTTY?: unknown }
+      readonly isBun?: boolean
+    }
+  }).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<unknown, void>(
     ({ cause, date, fiber, logLevel, message: message_ }) => {
       const console = fiber.getRef(ConsoleRef)
@@ -6489,7 +6666,7 @@ const prettyLoggerTty = (options: {
 
       const message = Array.isArray(message_) ? message_.slice() : [message_]
 
-      let firstLine = color(`[${options.formatDate(date)}]`, colors.white)
+      let firstLine = color(`[${formatDate(date)}]`, colors.white)
         + ` ${color(logLevel.toUpperCase(), ...logLevelColors[logLevel])}`
         + ` (#${fiber.id})`
 
@@ -6534,24 +6711,27 @@ const prettyLoggerTty = (options: {
   )
 }
 
-const prettyLoggerBrowser = (options: {
-  readonly colors: boolean
-  readonly formatDate: (date: Date) => string
+/** @internal */
+export const prettyLoggerBrowser = (options?: {
+  readonly colors?: "auto" | boolean | undefined
+  readonly formatDate?: ((date: Date) => string) | undefined
 }) => {
-  const color = options.colors ? "%c" : ""
+  const showColors = options?.colors !== false
+  const color = showColors ? "%c" : ""
+  const formatDate = options?.formatDate ?? defaultDateFormat
   return loggerMake<unknown, void>(
     ({ cause, date, fiber, logLevel, message: message_ }) => {
       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], "")
       }
 
@@ -6568,7 +6748,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++
@@ -6593,7 +6773,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 {
@@ -6634,7 +6814,7 @@ export const defaultLogger = loggerMake<unknown, void>(({ cause, date, fiber, lo
 export const tracerLogger = loggerMake<unknown, void>(({ cause, fiber, logLevel, message }) => {
   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: Record<string, unknown> = {}
   for (const [key, value] of Object.entries(annotations)) {
@@ -6679,7 +6859,7 @@ export const withErrorReporting: <
   options?: {
     readonly defectsOnly?: boolean | undefined
   } | undefined
-) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Arg
+) => [Arg] extends [Effect.Effect<infer A, infer E, infer R>] ? Effect.Effect<A, E, R>
   : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> = dual(
     (args) => isEffect(args[0]),
     <A, E, R>(