effect 4.0.0-beta.5 → 4.0.0-beta.51

package/src/internal/effect.ts

@@ -2,6 +2,7 @@ import * as Arr from "../Array.ts"
 import type * as Cause from "../Cause.ts"
 import type * as Clock from "../Clock.ts"
 import type * as Console from "../Console.ts"
+import * as Context from "../Context.ts"
 import * as Duration from "../Duration.ts"
 import type * as Effect from "../Effect.ts"
 import * as Equal from "../Equal.ts"
@@ -14,6 +15,7 @@ import { constant, constFalse, constTrue, constUndefined, constVoid, dual, ident
 import * as Hash from "../Hash.ts"
 import { toJson, toStringUnknown } from "../Inspectable.ts"
 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"
@@ -23,23 +25,10 @@ import { pipeArguments } from "../Pipeable.ts"
 import type * as Predicate from "../Predicate.ts"
 import { hasProperty, isIterable, isString, isTagged } from "../Predicate.ts"
 import { currentFiberTypeId, redact } from "../Redactable.ts"
-import {
-  CurrentConcurrency,
-  CurrentLogAnnotations,
-  CurrentLogLevel,
-  CurrentLogSpans,
-  CurrentStackFrame,
-  MinimumLogLevel,
-  type StackFrame,
-  TracerEnabled,
-  TracerSpanAnnotations,
-  TracerSpanLinks,
-  TracerTimingEnabled
-} from "../References.ts"
+import type { StackFrame } from "../References.ts"
 import * as Result from "../Result.ts"
 import * as Scheduler from "../Scheduler.ts"
 import type * as Scope from "../Scope.ts"
-import * as ServiceMap from "../ServiceMap.ts"
 import * as Tracer from "../Tracer.ts"
 import type {
   Concurrency,
@@ -48,7 +37,9 @@ import type {
   ExcludeTag,
   ExtractReason,
   ExtractTag,
+  NarrowReason,
   NoInfer,
+  OmitReason,
   ReasonOf,
   ReasonTags,
   Simplify,
@@ -67,7 +58,6 @@ import {
   contA,
   contAll,
   contE,
-  Die,
   evaluate,
   exitDie,
   exitFail,
@@ -93,6 +83,19 @@ import {
 } from "./core.ts"
 import * as doNotation from "./doNotation.ts"
 import * as InternalMetric from "./metric.ts"
+import {
+  CurrentConcurrency,
+  CurrentErrorReporters,
+  CurrentLogAnnotations,
+  CurrentLogLevel,
+  CurrentLogSpans,
+  CurrentStackFrame,
+  MinimumLogLevel,
+  TracerEnabled,
+  TracerSpanAnnotations,
+  TracerSpanLinks,
+  TracerTimingEnabled
+} from "./references.ts"
 import { addSpanStackTrace, type ErrorWithStackTraceLimit, makeStackCleaner } from "./tracer.ts"
 import { version } from "./version.ts"
 
@@ -212,17 +215,18 @@ export const causeInterruptors = <E>(self: Cause.Cause<E>): ReadonlySet<number>
 const emptySet = new Set<number>()
 
 /** @internal */
-export const hasInterruptsOnly = <E>(self: Cause.Cause<E>): boolean => self.reasons.every(isInterruptReason)
+export const hasInterruptsOnly = <E>(self: Cause.Cause<E>): boolean =>
+  self.reasons.length > 0 && self.reasons.every(isInterruptReason)
 
 /** @internal */
 export const reasonAnnotations = <E>(
   self: Cause.Reason<E>
-): ServiceMap.ServiceMap<never> => ServiceMap.makeUnsafe(self.annotations)
+): Context.Context<never> => Context.makeUnsafe(self.annotations)
 
 /** @internal */
 export const causeAnnotations = <E>(
   self: Cause.Cause<E>
-): ServiceMap.ServiceMap<never> => {
+): Context.Context<never> => {
   const map = new Map<string, unknown>()
   for (const f of self.reasons) {
     if (f.annotations.size > 0) {
@@ -231,7 +235,7 @@ export const causeAnnotations = <E>(
       }
     }
   }
-  return ServiceMap.makeUnsafe(map)
+  return Context.makeUnsafe(map)
 }
 
 /** @internal */
@@ -340,7 +344,8 @@ export const causePrettyErrors = <E>(self: Cause.Cause<E>): Array<Error> => {
   return errors
 }
 
-const causePrettyError = (
+/** @internal */
+export const causePrettyError = (
   original: Record<string, unknown> | Error,
   annotations?: ReadonlyMap<string, unknown>
 ): Error => {
@@ -488,32 +493,14 @@ const fiberIdStore = { id: 0 }
 /** @internal */
 export const getCurrentFiber = (): Fiber.Fiber<any, any> | undefined => (globalThis as any)[currentFiberTypeId]
 
-const keepAlive = (() => {
-  let count = 0
-  let running: ReturnType<typeof globalThis.setInterval> | undefined = undefined
-  return ({
-    increment() {
-      count++
-      running ??= globalThis.setInterval(constVoid, 2_147_483_647)
-    },
-    decrement() {
-      count--
-      if (count === 0 && running !== undefined) {
-        globalThis.clearInterval(running)
-        running = undefined
-      }
-    }
-  })
-})()
-
 /** @internal */
 export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   constructor(
-    services: ServiceMap.ServiceMap<never>,
+    context: Context.Context<never>,
     interruptible: boolean = true
   ) {
     this[FiberTypeId] = fiberVariance as any
-    this.setServices(services)
+    this.setContext(context)
     this.id = ++fiberIdStore.id
     this.currentOpCount = 0
     this.currentLoopCount = 0
@@ -540,8 +527,8 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   _interruptedCause: Cause.Cause<never> | undefined
   _yielded: Exit.Exit<any, any> | (() => void) | undefined
 
-  // set in setServices
-  services!: ServiceMap.ServiceMap<never>
+  // set in setContext
+  context!: Context.Context<never>
   currentScheduler!: Scheduler.Scheduler
   currentTracerContext: Tracer.Tracer["context"]
   currentSpan: Tracer.AnySpan | undefined
@@ -550,9 +537,15 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   currentStackFrame: StackFrame | undefined
   runtimeMetrics: Metric.FiberRuntimeMetricsService | undefined
   maxOpsBeforeYield!: number
+  currentPreventYield!: boolean
+
+  _dispatcher: Scheduler.SchedulerDispatcher | undefined = undefined
+  get currentDispatcher(): Scheduler.SchedulerDispatcher {
+    return this._dispatcher ??= this.currentScheduler.makeDispatcher()
+  }
 
-  getRef<X>(ref: ServiceMap.Reference<X>): X {
-    return ServiceMap.getReferenceUnsafe(this.services, ref)
+  getRef<X>(ref: Context.Reference<X>): X {
+    return Context.getReferenceUnsafe(this.context, ref)
   }
   addObserver(cb: (exit: Exit.Exit<A, E>) => void): () => void {
     if (this._exit) {
@@ -567,13 +560,13 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
       }
     }
   }
-  interruptUnsafe(fiberId?: number | undefined, annotations?: ServiceMap.ServiceMap<never> | undefined): void {
+  interruptUnsafe(fiberId?: number | undefined, annotations?: Context.Context<never> | undefined): void {
     if (this._exit) {
       return
     }
     let cause = causeInterrupt(fiberId)
     if (this.currentStackFrame) {
-      cause = causeAnnotate(cause, ServiceMap.make(CauseStackTrace, this.currentStackFrame))
+      cause = causeAnnotate(cause, Context.make(CauseStackTrace, this.currentStackFrame))
     }
     if (annotations) {
       cause = causeAnnotate(cause, annotations)
@@ -589,7 +582,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     return this._exit
   }
   evaluate(effect: Primitive): void {
-    this.runtimeMetrics?.recordFiberStart(this.services)
+    this.runtimeMetrics?.recordFiberStart(this.context)
     if (this._exit) {
       return
     } else if (this._yielded !== undefined) {
@@ -610,7 +603,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     }
 
     this._exit = exit
-    this.runtimeMetrics?.recordFiberEnd(this.services, this._exit)
+    this.runtimeMetrics?.recordFiberEnd(this.context, this._exit)
     for (let i = 0; i < this._observers.length; i++) {
       this._observers[i](exit)
     }
@@ -628,6 +621,7 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
         this.currentOpCount++
         if (
           !yielding &&
+          !this.currentPreventYield &&
           this.currentScheduler.shouldYield(this as any)
         ) {
           yielding = true
@@ -683,16 +677,21 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
   pipe() {
     return pipeArguments(this, arguments)
   }
-  setServices(services: ServiceMap.ServiceMap<never>): void {
-    this.services = services
-    this.currentScheduler = this.getRef(Scheduler.Scheduler)
-    this.currentSpan = services.mapUnsafe.get(Tracer.ParentSpanKey)
+  setContext(context: Context.Context<never>): void {
+    this.context = context
+    const scheduler = this.getRef(Scheduler.Scheduler)
+    if (scheduler !== this.currentScheduler) {
+      this.currentScheduler = scheduler
+      this._dispatcher = undefined
+    }
+    this.currentSpan = context.mapUnsafe.get(Tracer.ParentSpanKey)
     this.currentLogLevel = this.getRef(CurrentLogLevel)
     this.minimumLogLevel = this.getRef(MinimumLogLevel)
-    this.currentStackFrame = services.mapUnsafe.get(CurrentStackFrame.key)
+    this.currentStackFrame = context.mapUnsafe.get(CurrentStackFrame.key)
     this.maxOpsBeforeYield = this.getRef(Scheduler.MaxOpsBeforeYield)
-    this.runtimeMetrics = services.mapUnsafe.get(InternalMetric.FiberRuntimeMetricsKey)
-    const currentTracer = services.mapUnsafe.get(Tracer.TracerKey)
+    this.currentPreventYield = this.getRef(Scheduler.PreventSchedulerYield)
+    this.runtimeMetrics = context.mapUnsafe.get(InternalMetric.FiberRuntimeMetricsKey)
+    const currentTracer = context.mapUnsafe.get(Tracer.TracerKey)
     this.currentTracerContext = currentTracer ? currentTracer["context"] : undefined
   }
   get currentSpanLocal(): Tracer.Span | undefined {
@@ -710,7 +709,7 @@ const fiberStackAnnotations = (fiber: Fiber.Fiber<any, any>) => {
   if (!fiber.currentStackFrame) return undefined
   const annotations = new Map<string, unknown>()
   annotations.set(CauseStackTrace.key, fiber.currentStackFrame)
-  return ServiceMap.makeUnsafe(annotations)
+  return Context.makeUnsafe(annotations)
 }
 
 const fiberInterruptChildren = (fiber: FiberImpl) => {
@@ -784,6 +783,7 @@ export const fiberJoinAll = <A extends Iterable<Fiber.Fiber<any, any>>>(self: A)
 > =>
   callback((resume) => {
     const fibers = Array.from(self)
+    if (fibers.length === 0) return resume(succeed(Arr.empty() as any))
     const out = new Array<any>(fibers.length) as Arr.NonEmptyArray<any>
     const cancels = Arr.empty<() => void>()
     let done = 0
@@ -812,13 +812,29 @@ export const fiberInterrupt = <A, E>(
 
 /** @internal */
 export const fiberInterruptAs: {
-  (fiberId: number): <A, E>(self: Fiber.Fiber<A, E>) => Effect.Effect<void>
-  <A, E>(self: Fiber.Fiber<A, E>, fiberId: number): Effect.Effect<void>
-} = dual(2, <A, E>(self: Fiber.Fiber<A, E>, fiberId: number): Effect.Effect<void> =>
-  withFiber((parent) => {
-    self.interruptUnsafe(fiberId, fiberStackAnnotations(parent))
-    return asVoid(fiberAwait(self))
-  }))
+  (
+    fiberId: number | undefined,
+    annotations?: Context.Context<never> | undefined
+  ): <A, E>(self: Fiber.Fiber<A, E>) => Effect.Effect<void>
+  <A, E>(
+    self: Fiber.Fiber<A, E>,
+    fiberId: number | undefined,
+    annotations?: Context.Context<never> | undefined
+  ): Effect.Effect<void>
+} = dual(
+  (args) => hasProperty(args[0], FiberTypeId),
+  <A, E>(
+    self: Fiber.Fiber<A, E>,
+    fiberId: number | undefined,
+    annotations?: Context.Context<never> | undefined
+  ): Effect.Effect<void> =>
+    withFiber((parent) => {
+      let ann = fiberStackAnnotations(parent)
+      ann = ann && annotations ? Context.merge(ann, annotations) : ann ?? annotations
+      self.interruptUnsafe(fiberId, ann)
+      return asVoid(fiberAwait(self))
+    })
+)
 
 /** @internal */
 export const fiberInterruptAll = <A extends Iterable<Fiber.Fiber<any, any>>>(
@@ -895,7 +911,7 @@ export const yieldNowWith: (priority?: number) => Effect.Effect<void> = makePrim
   op: "Yield",
   [evaluate](fiber) {
     let resumed = false
-    fiber.currentScheduler.scheduleTask(() => {
+    fiber.currentDispatcher.scheduleTask(() => {
       if (resumed) return
       fiber.evaluate(exitVoid as any)
     }, this[args] ?? 0)
@@ -1018,10 +1034,8 @@ const callbackOptions: <A, E = never, R = never>(
     }, controller?.signal)
     if (yielded !== false) return yielded
     yielded = true
-    keepAlive.increment()
     fiber._yielded = () => {
       resumed = true
-      keepAlive.decrement()
     }
     if (controller === undefined && onCancel === undefined) {
       return Yield
@@ -1095,7 +1109,7 @@ export const fnUntraced: Effect.fn.Untraced = (
   body: Function,
   ...pipeables: Array<any>
 ) => {
-  return pipeables.length === 0
+  const fn = pipeables.length === 0
     ? function(this: any) {
       return suspend(() => fromIteratorUnsafe(body.apply(this, arguments)))
     }
@@ -1106,8 +1120,15 @@ export const fnUntraced: Effect.fn.Untraced = (
       }
       return effect
     }
+  return defineFunctionLength(body.length, fn)
 }
 
+const defineFunctionLength = <F extends Function>(length: number, fn: F): F =>
+  Object.defineProperty(fn, "length", {
+    value: length,
+    configurable: true
+  })
+
 const fnStackCleaner = makeStackCleaner(2)
 
 /** @internal */
@@ -1148,7 +1169,7 @@ const makeFn = (
     ? bodyOrOptions
     : (pipeables.pop()!).bind(bodyOrOptions.self)
 
-  return function(this: any, ...args: Array<any>) {
+  return defineFunctionLength(body.length, function(this: any, ...args: Array<any>) {
     let result = suspend(() => {
       const iter = body.apply(this, arguments)
       return isEffect(iter) ? iter : fromIteratorUnsafe(iter)
@@ -1178,7 +1199,7 @@ const makeFn = (
         }
       })
     )
-  }
+  })
 }
 
 /** @internal */
@@ -1186,17 +1207,20 @@ export const fnUntracedEager: Effect.fn.Untraced = (
   body: Function,
   ...pipeables: Array<any>
 ) =>
-  pipeables.length === 0
-    ? function(this: any) {
-      return fromIteratorEagerUnsafe(() => body.apply(this, arguments))
-    }
-    : function(this: any) {
-      let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments))
-      for (const pipeable of pipeables) {
-        effect = pipeable(effect)
+  defineFunctionLength(
+    body.length,
+    pipeables.length === 0
+      ? function(this: any) {
+        return fromIteratorEagerUnsafe(() => body.apply(this, arguments))
       }
-      return effect
-    }
+      : function(this: any) {
+        let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments))
+        for (const pipeable of pipeables) {
+          effect = pipeable(effect)
+        }
+        return effect
+      }
+  )
 
 const fromIteratorEagerUnsafe = (
   evaluate: () => Iterator<Effect.Yieldable<any, any, any, any>>
@@ -1945,61 +1969,46 @@ export const exitFindErrorOption = <A, E>(self: Exit.Exit<A, E>): Option.Option<
 
 /** @internal */
 export const service: {
-  <I, S>(service: ServiceMap.Service<I, S>): Effect.Effect<S, never, I>
+  <I, S>(service: Context.Key<I, S>): Effect.Effect<S, never, I>
 } = fromYieldable as any
 
 /** @internal */
 export const serviceOption = <I, S>(
-  service: ServiceMap.Service<I, S>
-): Effect.Effect<Option.Option<S>> => withFiber((fiber) => succeed(ServiceMap.getOption(fiber.services, service)))
+  service: Context.Key<I, S>
+): Effect.Effect<Option.Option<S>> => withFiber((fiber) => succeed(Context.getOption(fiber.context, service)))
 
 /** @internal */
 export const serviceOptional = <I, S>(
-  service: ServiceMap.Service<I, S>
+  service: Context.Key<I, S>
 ): Effect.Effect<S, Cause.NoSuchElementError> =>
   withFiber((fiber) =>
-    fiber.services.mapUnsafe.has(service.key)
-      ? succeed(ServiceMap.getUnsafe(fiber.services, service))
+    fiber.context.mapUnsafe.has(service.key)
+      ? succeed(Context.getUnsafe(fiber.context, service))
       : fail(new NoSuchElementError())
   )
 
 /** @internal */
-export const updateServices: {
+export const updateContext: {
   <R2, R>(
-    f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<NoInfer<R>>
+    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
   ): <A, E>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R2>
   <A, E, R, R2>(
     self: Effect.Effect<A, E, R>,
-    f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<NoInfer<R>>
+    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
   ): Effect.Effect<A, E, R2>
 } = dual(
   2,
   <A, E, R, R2>(
     self: Effect.Effect<A, E, R>,
-    f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<NoInfer<R>>
+    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
   ): Effect.Effect<A, E, R2> =>
     withFiber<A, E, R2>((fiber) => {
-      const prev = fiber.services as ServiceMap.ServiceMap<R2>
-      const nextServices = f(prev)
-      if (prev === nextServices) return self as any
-      fiber.setServices(nextServices)
-      const newServices = new Map<string, unknown>()
-      for (const [key, value] of fiber.services.mapUnsafe) {
-        if (!prev.mapUnsafe.has(key) || value !== prev.mapUnsafe.get(key)) {
-          newServices.set(key, value)
-        }
-      }
-      return onExitPrimitive(self as any, () => {
-        const map = new Map(fiber.services.mapUnsafe)
-        for (const [key, value] of newServices) {
-          if (value !== map.get(key)) continue
-          if (prev.mapUnsafe.has(key)) {
-            map.set(key, prev.mapUnsafe.get(key))
-          } else {
-            map.delete(key)
-          }
-        }
-        fiber.setServices(ServiceMap.makeUnsafe(map))
+      const prevContext = fiber.context as Context.Context<R2>
+      const nextContext = f(prevContext)
+      if (prevContext === nextContext) return self as any
+      fiber.setContext(nextContext)
+      return onExitPrimitive(self, () => {
+        fiber.setContext(prevContext)
         return undefined
       })
     })
@@ -2008,78 +2017,77 @@ export const updateServices: {
 /** @internal */
 export const updateService: {
   <I, A>(
-    service: ServiceMap.Service<I, A>,
+    service: Context.Key<I, A>,
     f: (value: A) => A
   ): <XA, E, R>(self: Effect.Effect<XA, E, R>) => Effect.Effect<XA, E, R | I>
   <XA, E, R, I, A>(
     self: Effect.Effect<XA, E, R>,
-    service: ServiceMap.Service<I, A>,
+    service: Context.Key<I, A>,
     f: (value: A) => A
   ): Effect.Effect<XA, E, R | I>
 } = dual(
   3,
   <XA, E, R, I, A>(
     self: Effect.Effect<XA, E, R>,
-    service: ServiceMap.Service<I, A>,
+    service: Context.Key<I, A>,
     f: (value: A) => A
   ): Effect.Effect<XA, E, R | I> =>
-    withFiber((fiber) => {
-      const prev = ServiceMap.getUnsafe(fiber.services, service)
+    updateContext(self, (s) => {
+      const prev = Context.getUnsafe(s, service)
       const next = f(prev)
-      if (prev === next) return self
-      fiber.setServices(ServiceMap.add(fiber.services, service, next))
-      return onExit(self, () => sync(() => fiber.setServices(ServiceMap.add(fiber.services, service, prev))))
+      if (prev === next) return s
+      return Context.add(s, service, next)
     })
 )
 
 /** @internal */
-export const services = <R = never>(): Effect.Effect<ServiceMap.ServiceMap<R>> => getServiceMap as any
-const getServiceMap = withFiber((fiber) => succeed(fiber.services))
+export const context = <R = never>(): Effect.Effect<Context.Context<R>> => getContext as any
+const getContext = withFiber((fiber) => succeed(fiber.context))
 
 /** @internal */
-export const servicesWith = <R, A, E, R2>(
-  f: (services: ServiceMap.ServiceMap<R>) => Effect.Effect<A, E, R2>
-): Effect.Effect<A, E, R | R2> => withFiber((fiber) => f(fiber.services as ServiceMap.ServiceMap<R>))
+export const contextWith = <R, A, E, R2>(
+  f: (context: Context.Context<R>) => Effect.Effect<A, E, R2>
+): Effect.Effect<A, E, R | R2> => withFiber((fiber) => f(fiber.context as Context.Context<R>))
 
 /** @internal */
-export const provideServices: {
+export const provideContext: {
   <XR>(
-    services: ServiceMap.ServiceMap<XR>
+    context: Context.Context<XR>
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E, Exclude<R, XR>>
   <A, E, R, XR>(
     self: Effect.Effect<A, E, R>,
-    services: ServiceMap.ServiceMap<XR>
+    context: Context.Context<XR>
   ): Effect.Effect<A, E, Exclude<R, XR>>
 } = dual(
   2,
   <A, E, R, XR>(
     self: Effect.Effect<A, E, R>,
-    services: ServiceMap.ServiceMap<XR>
+    context: Context.Context<XR>
   ): Effect.Effect<A, E, Exclude<R, XR>> => {
     if (effectIsExit(self)) return self as any
-    return updateServices(self, ServiceMap.merge(services)) as any
+    return updateContext(self, Context.merge(context)) as any
   }
 )
 
 /** @internal */
 export const provideService: {
   <I, S>(
-    service: ServiceMap.Service<I, S>
+    service: Context.Key<I, S>
   ): {
     (implementation: S): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, I>>
     <A, E, R>(self: Effect.Effect<A, E, R>, implementation: S): Effect.Effect<A, E, Exclude<R, I>>
   }
   <I, S>(
-    key: ServiceMap.Service<I, S>,
+    key: Context.Key<I, S>,
     implementation: S
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E, Exclude<R, I>>
   <A, E, R, I, S>(
     self: Effect.Effect<A, E, R>,
-    service: ServiceMap.Service<I, S>,
+    service: Context.Key<I, S>,
     implementation: S
   ): Effect.Effect<A, E, Exclude<R, I>>
 } = function(this: any) {
@@ -2092,34 +2100,33 @@ export const provideService: {
 
 const provideServiceImpl = <A, E, R, I, S>(
   self: Effect.Effect<A, E, R>,
-  service: ServiceMap.Service<I, S>,
+  service: Context.Key<I, S>,
   implementation: S
 ): Effect.Effect<A, E, Exclude<R, I>> =>
-  withFiber((fiber) => {
-    const prev = ServiceMap.getOption(fiber.services, service)
-    if (prev._tag === "Some" && prev.value === implementation) return self
-    fiber.setServices(ServiceMap.add(fiber.services, service, implementation))
-    return onExit(self, () => sync(() => fiber.setServices(ServiceMap.addOrOmit(fiber.services, service, prev))))
+  updateContext(self, (s) => {
+    const prev = s.mapUnsafe.get(service.key)
+    if (prev === implementation) return s
+    return Context.add(s, service, implementation)
   }) as any
 
 /** @internal */
 export const provideServiceEffect: {
   <I, S, E2, R2>(
-    service: ServiceMap.Service<I, S>,
+    service: Context.Key<I, S>,
     acquire: Effect.Effect<S, E2, R2>
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E | E2, Exclude<R, I> | R2>
   <A, E, R, I, S, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    service: ServiceMap.Service<I, S>,
+    service: Context.Key<I, S>,
     acquire: Effect.Effect<S, E2, R2>
   ): Effect.Effect<A, E | E2, Exclude<R, I> | R2>
 } = dual(
   3,
   <A, E, R, I, S, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    service: ServiceMap.Service<I, S>,
+    service: Context.Key<I, S>,
     acquire: Effect.Effect<S, E2, R2>
   ): Effect.Effect<A, E | E2, Exclude<R, I> | R2> =>
     flatMap(acquire, (implementation) => provideService(self, service, implementation))
@@ -2203,19 +2210,12 @@ export const filterOrFail: {
     predicate: Predicate.Predicate<NoInfer<A>>,
     orFailWith: (a: NoInfer<A>) => E2
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E2 | E, R>
-  <A, B, X, E2>(
-    filter: Filter.Filter<NoInfer<A>, B, X>,
-    orFailWith: (x: X) => E2
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E2 | E, R>
   <A, B extends A>(
     refinement: Predicate.Refinement<NoInfer<A>, B>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementError | E, R>
   <A>(
     predicate: Predicate.Predicate<NoInfer<A>>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, Cause.NoSuchElementError | E, R>
-  <A, B, X>(
-    filter: Filter.Filter<NoInfer<A>, B, X>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementError | E, R>
   <A, E, R, E2, B extends A>(
     self: Effect.Effect<A, E, R>,
     refinement: Predicate.Refinement<NoInfer<A>, B>,
@@ -2226,11 +2226,6 @@ export const filterOrFail: {
     predicate: Predicate.Predicate<NoInfer<A>>,
     orFailWith: (a: NoInfer<A>) => E2
   ): Effect.Effect<A, E2 | E, R>
-  <A, E, R, B, X, E2>(
-    self: Effect.Effect<A, E, R>,
-    filter: Filter.Filter<A, B, X>,
-    orFailWith: (x: X) => E2
-  ): Effect.Effect<B, E2 | E, R>
   <A, E, R, B extends A>(
     self: Effect.Effect<A, E, R>,
     refinement: Predicate.Refinement<NoInfer<A>, B>
@@ -2239,18 +2234,14 @@ export const filterOrFail: {
     self: Effect.Effect<A, E, R>,
     predicate: Predicate.Predicate<NoInfer<A>>
   ): Effect.Effect<A, E | Cause.NoSuchElementError, R>
-  <A, E, R, B, X>(
-    self: Effect.Effect<A, E, R>,
-    filter: Filter.Filter<A, B, X>
-  ): Effect.Effect<B, E | Cause.NoSuchElementError, R>
 } = dual((args) => isEffect(args[0]), <A, E, R, E2>(
   self: Effect.Effect<A, E, R>,
-  filter: Predicate.Predicate<NoInfer<A>> | Filter.Filter<A, any, any>,
+  predicate: Predicate.Predicate<NoInfer<A>>,
   orFailWith?: (a: any) => E2
 ): Effect.Effect<any, E | E2 | Cause.NoSuchElementError, R> =>
   filterOrElse(
     self,
-    filter as any,
+    predicate as any,
     orFailWith ? (a: any) => fail(orFailWith(a)) : () => fail(new NoSuchElementError() as E2)
   ))
 
@@ -2400,27 +2391,55 @@ const OnFailureProto = makePrimitiveProto({
 
 /** @internal */
 export const catchCauseIf: {
-  <E, Result extends Filter.ResultOrBool<Cause.Cause<any>>, B, E2, R2>(
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  <E, B, E2, R2>(
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): <A, R>(
+    self: Effect.Effect<A, E, R>
+  ) => Effect.Effect<A | B, E | E2, R | R2>
+  <A, E, R, B, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A | B, E | E2, R | R2>
+} = dual(
+  3,
+  <A, E, R, B, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A | B, E | E2, R | R2> =>
+    catchCause(self, (cause): Effect.Effect<B, E | E2, R2> => {
+      if (!predicate(cause)) {
+        return failCause(cause) as any
+      }
+      return internalCall(() => f(cause))
+    })
+)
+
+/** @internal */
+export const catchCauseFilter: {
+  <E, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
   ): <A, R>(
     self: Effect.Effect<A, E, R>
-  ) => Effect.Effect<A | B, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2>
-  <A, E, R, B, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(
+  ) => Effect.Effect<A | B, Cause.Cause.Error<X> | E2, R | R2>
+  <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2>
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A | B, Cause.Cause.Error<X> | E2, R | R2>
 } = dual(
   3,
-  <A, E, R, B, E2, R2, Result extends Filter.ResultOrBool<Cause.Cause<any>>>(
-    self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2> =>
-    catchCause(self, (cause): Effect.Effect<B, Cause.Cause.Error<Filter.Fail<Cause.Cause<E>, Result>> | E2, R | R2> => {
-      const eb = Filter.apply(filter as any, cause)
-      return !Result.isFailure(eb) ? internalCall(() => f(eb.success as any, cause)) : failCause(eb.failure as any)
+  <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A | B, Cause.Cause.Error<X> | E2, R | R2> =>
+    catchCause(self, (cause): Effect.Effect<B, Cause.Cause.Error<X> | E2, R2> => {
+      const eb = filter(cause)
+      return Result.isFailure(eb) ? failCause(eb.failure) : internalCall(() => f(eb.success, cause))
     })
 )
 
@@ -2438,7 +2457,7 @@ export const catch_: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (a: NoInfer<E>) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, E2, R | R2> => catchCauseIf(self, findError as any, (e: any) => f(e)) as any
+  ): Effect.Effect<A | B, E2, R | R2> => catchCauseFilter(self, findError as any, (e: any) => f(e)) as any
 )
 
 /** @internal */
@@ -2469,7 +2488,7 @@ export const catchDefect: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (defect: unknown) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A | B, E | E2, R | R2> => catchCauseIf(self, findDefect as any, f as any) as any
+  ): Effect.Effect<A | B, E | E2, R | R2> => catchCauseFilter(self, findDefect as any, f as any) as any
 )
 
 /** @internal */
@@ -2492,32 +2511,56 @@ export const tapCause: {
 
 /** @internal */
 export const tapCauseIf: {
-  <E, Result extends Filter.ResultOrBool, B, E2, R2>(
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (a: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  <E, B, E2, R2>(
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>
-  <A, E, R, Result extends Filter.ResultOrBool, B, E2, R2>(
+  <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (a: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
   ): Effect.Effect<A, E | E2, R | R2>
 } = dual(
   3,
-  <A, E, R, Result extends Filter.ResultOrBool, B, E2, R2>(
+  <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (a: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
   ): Effect.Effect<A, E | E2, R | R2> =>
     catchCauseIf(
       self,
-      ((cause: Cause.Cause<E>) => {
-        const result = Filter.apply(filter as any, cause)
-        return Result.isFailure(result) ? Result.fail(cause) : result
-      }) as any,
-      (failure: any, cause: Cause.Cause<E>) => andThen(internalCall(() => f(failure, cause)), failCause(cause))
+      predicate,
+      (cause) => andThen(internalCall(() => f(cause)), failCause(cause))
     )
 )
 
+/** @internal */
+export const tapCauseFilter: {
+  <E, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (a: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R | R2>
+  <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (a: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A, E | E2, R | R2>
+} = dual(
+  3,
+  <A, E, R, B, E2, R2, EB, X extends Cause.Cause<any>>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (a: EB, cause: Cause.Cause<E>) => Effect.Effect<B, E2, R2>
+  ): Effect.Effect<A, E | E2, R | R2> =>
+    catchCause(self, (cause) => {
+      const result = filter(cause)
+      if (Result.isFailure(result)) {
+        return failCause(cause)
+      }
+      return andThen(internalCall(() => f(result.success, cause)), failCause(cause))
+    })
+)
+
 /** @internal */
 export const tapError: {
   <E, B, E2, R2>(
@@ -2532,7 +2575,7 @@ export const tapError: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (e: NoInfer<E>) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A, E | E2, R | R2> => tapCauseIf(self, findError as any, (e: any) => f(e)) as any
+  ): Effect.Effect<A, E | E2, R | R2> => tapCauseFilter(self, findError as any, (e: any) => f(e)) as any
 )
 
 /** @internal */
@@ -2599,7 +2642,7 @@ export const tapDefect: {
   <A, E, R, B, E2, R2>(
     self: Effect.Effect<A, E, R>,
     f: (defect: unknown) => Effect.Effect<B, E2, R2>
-  ): Effect.Effect<A, E | E2, R | R2> => tapCauseIf(self, findDefect as any, (_: any) => f(_)) as any
+  ): Effect.Effect<A, E | E2, R | R2> => tapCauseFilter(self, findDefect as any, (_: any) => f(_)) as any
 )
 
 /** @internal */
@@ -2609,10 +2652,10 @@ export const catchIf: {
     f: (e: EB) => Effect.Effect<A2, E2, R2>,
     orElse?: ((e: Exclude<E, EB>) => Effect.Effect<A3, E3, R3>) | undefined
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
-  <E, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(
-    filter: Filter.OrPredicate<NoInfer<E>, Result>,
-    f: (e: Filter.Pass<E, Result>) => Effect.Effect<A2, E2, R2>,
-    orElse?: ((e: Filter.Fail<E, Result>) => Effect.Effect<A3, E3, R3>) | undefined
+  <E, A2, E2, R2, A3 = never, E3 = E, R3 = never>(
+    predicate: Predicate.Predicate<NoInfer<E>>,
+    f: (e: NoInfer<E>) => Effect.Effect<A2, E2, R2>,
+    orElse?: ((e: NoInfer<E>) => Effect.Effect<A3, E3, R3>) | undefined
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
   <A, E, R, EB extends E, A2, E2, R2, A3 = never, E3 = Exclude<E, EB>, R3 = never>(
     self: Effect.Effect<A, E, R>,
@@ -2620,28 +2663,59 @@ export const catchIf: {
     f: (e: EB) => Effect.Effect<A2, E2, R2>,
     orElse?: ((e: Exclude<E, EB>) => Effect.Effect<A3, E3, R3>) | undefined
   ): Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
-  <A, E, R, Result extends Filter.ResultOrBool, A2, E2, R2, A3 = never, E3 = Filter.Fail<E, Result>, R3 = never>(
+  <A, E, R, A2, E2, R2, A3 = never, E3 = E, R3 = never>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<E>,
+    f: (e: E) => Effect.Effect<A2, E2, R2>,
+    orElse?: ((e: E) => Effect.Effect<A3, E3, R3>) | undefined
+  ): Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
+} = dual(
+  (args) => isEffect(args[0]),
+  <A, E, R, A2, E2, R2, A3 = never, E3 = E, R3 = never>(
+    self: Effect.Effect<A, E, R>,
+    predicate: Predicate.Predicate<E>,
+    f: (e: E) => Effect.Effect<A2, E2, R2>,
+    orElse?: ((e: E) => Effect.Effect<A3, E3, R3>) | undefined
+  ): Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3> =>
+    catchCause(self, (cause): Effect.Effect<A2 | A3, E2 | E3, R2 | R3> => {
+      const error = findError(cause)
+      if (Result.isFailure(error)) return failCause(error.failure)
+      if (!predicate(error.success)) {
+        return orElse ? internalCall(() => orElse(error.success as any)) : failCause(cause as any as Cause.Cause<E3>)
+      }
+      return internalCall(() => f(error.success as any))
+    })
+)
+
+/** @internal */
+export const catchFilter: {
+  <E, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(
+    filter: Filter.Filter<NoInfer<E>, EB, X>,
+    f: (e: EB) => Effect.Effect<A2, E2, R2>,
+    orElse?: ((e: X) => Effect.Effect<A3, E3, R3>) | undefined
+  ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
+  <A, E, R, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<NoInfer<E>, Result>,
-    f: (e: Filter.Pass<E, Result>) => Effect.Effect<A2, E2, R2>,
-    orElse?: ((e: Filter.Fail<E, Result>) => Effect.Effect<A3, E3, R3>) | undefined
+    filter: Filter.Filter<NoInfer<E>, EB, X>,
+    f: (e: EB) => Effect.Effect<A2, E2, R2>,
+    orElse?: ((e: X) => Effect.Effect<A3, E3, R3>) | undefined
   ): Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3>
 } = dual(
   (args) => isEffect(args[0]),
   <A, E, R, EB, A2, E2, R2, X, A3 = never, E3 = X, R3 = never>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.Filter<NoInfer<E>, EB, X> | Predicate.Predicate<NoInfer<E>>,
+    filter: Filter.Filter<NoInfer<E>, EB, X>,
     f: (e: EB) => Effect.Effect<A2, E2, R2>,
     orElse?: ((e: X) => Effect.Effect<A3, E3, R3>) | undefined
   ): Effect.Effect<A | A2 | A3, E2 | E3, R | R2 | R3> =>
     catchCause(self, (cause): Effect.Effect<A2 | A3, E2 | E3, R2 | R3> => {
       const error = findError(cause)
       if (Result.isFailure(error)) return failCause(error.failure)
-      const result = Filter.apply(filter as any, error.success)
+      const result = filter(error.success)
       if (Result.isFailure(result)) {
         return orElse ? internalCall(() => orElse(result.failure as any)) : failCause(cause as any as Cause.Cause<E3>)
       }
-      return internalCall(() => f(result.success as any))
+      return internalCall(() => f(result.success))
     })
 )
 
@@ -2777,7 +2851,7 @@ export const catchTags: {
   >
 } = dual((args) => isEffect(args[0]), (self: Effect.Effect<any, any, any>, cases: Record<string, any>, orElse: any) => {
   let keys: Array<string>
-  return catchIf(
+  return catchFilter(
     self,
     (e) => {
       keys ??= Object.keys(cases)
@@ -2787,7 +2861,7 @@ export const catchTags: {
     },
     (e: any) => internalCall(() => cases[e["_tag"] as string](e)),
     orElse
-  )
+  ) as any
 })
 
 /** @internal */
@@ -2805,8 +2879,16 @@ export const catchReason: {
   >(
     errorTag: K,
     reasonTag: RK,
-    f: (reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>) => Effect.Effect<A2, E2, R2>,
-    orElse?: ((reasons: ExcludeReason<ExtractTag<NoInfer<E>, K>, RK>) => Effect.Effect<A3, E3, R3>) | undefined
+    f: (
+      reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>,
+      error: NarrowReason<ExtractTag<NoInfer<E>, K>, RK>
+    ) => Effect.Effect<A2, E2, R2>,
+    orElse?:
+      | ((
+        reasons: ExcludeReason<ExtractTag<NoInfer<E>, K>, RK>,
+        error: OmitReason<ExtractTag<NoInfer<E>, K>, RK>
+      ) => Effect.Effect<A3, E3, R3>)
+      | undefined
   ): <A, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<
@@ -2830,8 +2912,16 @@ export const catchReason: {
     self: Effect.Effect<A, E, R>,
     errorTag: K,
     reasonTag: RK,
-    f: (reason: ExtractReason<ExtractTag<E, K>, RK>) => Effect.Effect<A2, E2, R2>,
-    orElse?: ((reasons: ExcludeReason<ExtractTag<E, K>, RK>) => Effect.Effect<A3, E3, R3>) | undefined
+    f: (
+      reason: ExtractReason<ExtractTag<E, K>, RK>,
+      error: NarrowReason<ExtractTag<E, K>, RK>
+    ) => Effect.Effect<A2, E2, R2>,
+    orElse?:
+      | ((
+        reasons: ExcludeReason<ExtractTag<E, K>, RK>,
+        error: OmitReason<ExtractTag<E, K>, RK>
+      ) => Effect.Effect<A3, E3, R3>)
+      | undefined
   ): Effect.Effect<
     A | A2 | Exclude<A3, unassigned>,
     (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3,
@@ -2855,8 +2945,13 @@ export const catchReason: {
     self: Effect.Effect<A, E, R>,
     errorTag: K,
     reasonTag: RK,
-    f: (reason: ExtractReason<ExtractTag<E, K>, RK>) => Effect.Effect<A2, E2, R2>,
-    orElse?: ((reasons: ExcludeReason<ExtractTag<E, K>, RK>) => Effect.Effect<A3, E3, R3>) | undefined
+    f: (reason: ExtractReason<ExtractTag<E, K>, RK>, error: ExtractTag<E, K>) => Effect.Effect<A2, E2, R2>,
+    orElse?:
+      | ((
+        reasons: ExcludeReason<ExtractTag<E, K>, RK>,
+        error: OmitReason<ExtractTag<E, K>, RK>
+      ) => Effect.Effect<A3, E3, R3>)
+      | undefined
   ): Effect.Effect<
     A | A2 | Exclude<A3, unassigned>,
     (A3 extends unassigned ? E : ExcludeTag<E, K>) | E2 | E3,
@@ -2867,8 +2962,8 @@ export const catchReason: {
       ((e: any) => isTagged(e, errorTag) && hasProperty(e, "reason")) 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)
-        return orElse ? internalCall(() => orElse(reason)) : fail(e)
+        if (isTagged(reason, reasonTag)) return f(reason as any, e)
+        return orElse ? internalCall(() => orElse(reason, e)) : fail(e)
       }
     ) as any
 )
@@ -2880,7 +2975,8 @@ export const catchReasons: {
     E,
     Cases extends {
       [RK in ReasonTags<ExtractTag<NoInfer<E>, K>>]+?: (
-        reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>
+        reason: ExtractReason<ExtractTag<NoInfer<E>, K>, RK>,
+        error: NarrowReason<ExtractTag<NoInfer<E>, K>, RK>
       ) => Effect.Effect<any, any, any>
     },
     A2 = unassigned,
@@ -2891,7 +2987,8 @@ export const catchReasons: {
     cases: Cases,
     orElse?:
       | ((
-        reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>
+        reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>,
+        error: OmitReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>
       ) => Effect.Effect<A2, E2, R2>)
       | undefined
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<
@@ -2918,7 +3015,8 @@ export const catchReasons: {
     K extends Tags<E>,
     Cases extends {
       [RK in ReasonTags<ExtractTag<E, K>>]+?: (
-        reason: ExtractReason<ExtractTag<E, K>, RK>
+        reason: ExtractReason<ExtractTag<E, K>, RK>,
+        error: NarrowReason<ExtractTag<E, K>, RK>
       ) => Effect.Effect<any, any, any>
     },
     A2 = unassigned,
@@ -2930,7 +3028,8 @@ export const catchReasons: {
     cases: Cases,
     orElse?:
       | ((
-        reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>
+        reason: ExcludeReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>,
+        error: OmitReason<ExtractTag<NoInfer<E>, K>, Extract<keyof Cases, string>>
       ) => Effect.Effect<A2, E2, R2>)
       | undefined
   ): Effect.Effect<
@@ -2963,9 +3062,9 @@ export const catchReasons: {
       const reason = e.reason
       keys ??= Object.keys(cases)
       if (keys.includes(reason._tag)) {
-        return internalCall(() => (cases as any)[reason._tag](reason))
+        return internalCall(() => (cases as any)[reason._tag](reason, e))
       }
-      return orElse ? internalCall(() => orElse(reason)) : fail(e)
+      return orElse ? internalCall(() => orElse(reason, e)) : fail(e)
     }
   )
 })
@@ -2998,7 +3097,7 @@ export const unwrapReason: {
     self: Effect.Effect<A, E, R>,
     errorTag: K
   ): Effect.Effect<A, ExcludeTag<E, K> | ReasonOf<ExtractTag<E, K>>, R> =>
-    catchIf(
+    catchFilter(
       self,
       (e: any) => {
         if (isTagged(e, errorTag) && hasProperty(e, "reason")) {
@@ -3007,7 +3106,7 @@ export const unwrapReason: {
         return Result.fail(e)
       },
       fail as any
-    )
+    ) as any
 )
 
 /** @internal */
@@ -3091,14 +3190,17 @@ export const eventually = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect
 /** @internal */
 export const ignore: <
   Arg extends Effect.Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   }
 >(
   effectOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   } | undefined
 ) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Effect.Effect<void, never, _R>
   : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, never, R> = dual(
@@ -3106,7 +3208,8 @@ export const ignore: <
     <A, E, R>(
       self: Effect.Effect<A, E, R>,
       options?: {
-        readonly log?: boolean | LogLevel.LogLevel | undefined
+        readonly log?: boolean | LogLevel.Severity | undefined
+        readonly message?: string | undefined
       } | undefined
     ): Effect.Effect<void, never, R> => {
       if (!options?.log) {
@@ -3116,7 +3219,11 @@ export const ignore: <
       return matchCauseEffect(self, {
         onFailure(cause) {
           const failure = findFail(cause)
-          return Result.isFailure(failure) ? failCause(failure.failure) : logEffect(cause)
+          return Result.isFailure(failure)
+            ? failCause(failure.failure)
+            : options.message === undefined
+            ? logEffect(cause)
+            : logEffect(options.message, cause)
         },
         onSuccess: (_) => void_
       })
@@ -3126,14 +3233,17 @@ export const ignore: <
 /** @internal */
 export const ignoreCause: <
   Arg extends Effect.Effect<any, any, any> | {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   } | undefined = {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   }
 >(
   effectOrOptions: Arg,
   options?: {
-    readonly log?: boolean | LogLevel.LogLevel | undefined
+    readonly log?: boolean | LogLevel.Severity | undefined
+    readonly message?: string | undefined
   } | undefined
 ) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Effect.Effect<void, never, _R>
   : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<void, never, R> = dual(
@@ -3141,14 +3251,18 @@ export const ignoreCause: <
     <A, E, R>(
       self: Effect.Effect<A, E, R>,
       options?: {
-        readonly log?: boolean | LogLevel.LogLevel | undefined
+        readonly log?: boolean | LogLevel.Severity | undefined
+        readonly message?: string | undefined
       } | undefined
     ): Effect.Effect<void, never, R> => {
       if (!options?.log) {
         return matchCauseEffect(self, { onFailure: (_) => void_, onSuccess: (_) => void_ })
       }
       const logEffect = logWithLevel(options.log === true ? undefined : options.log)
-      return matchCauseEffect(self, { onFailure: logEffect, onSuccess: (_) => void_ })
+      return matchCauseEffect(self, {
+        onFailure: (cause) => options.message === undefined ? logEffect(cause) : logEffect(options.message, cause),
+        onSuccess: (_) => void_
+      })
     }
   )
 
@@ -3403,33 +3517,33 @@ export const isSuccess: <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect
 /** @internal */
 export const delay: {
   (
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E, R>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E, R> => andThen(sleep(duration), self)
 )
 
 /** @internal */
 export const timeoutOrElse: {
   <A2, E2, R2>(options: {
-    readonly duration: Duration.DurationInput
-    readonly onTimeout: LazyArg<Effect.Effect<A2, E2, R2>>
+    readonly duration: Duration.Input
+    readonly orElse: LazyArg<Effect.Effect<A2, E2, R2>>
   }): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<A | A2, E | E2, R | R2>
   <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
     options: {
-      readonly duration: Duration.DurationInput
-      readonly onTimeout: LazyArg<Effect.Effect<A2, E2, R2>>
+      readonly duration: Duration.Input
+      readonly orElse: LazyArg<Effect.Effect<A2, E2, R2>>
     }
   ): Effect.Effect<A | A2, E | E2, R | R2>
 } = dual(
@@ -3437,55 +3551,55 @@ export const timeoutOrElse: {
   <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
     options: {
-      readonly duration: Duration.DurationInput
-      readonly onTimeout: LazyArg<Effect.Effect<A2, E2, R2>>
+      readonly duration: Duration.Input
+      readonly orElse: LazyArg<Effect.Effect<A2, E2, R2>>
     }
   ): Effect.Effect<A | A2, E | E2, R | R2> =>
     raceFirst(
       self,
-      flatMap(sleep(options.duration), options.onTimeout)
+      flatMap(sleep(options.duration), options.orElse)
     )
 )
 
 /** @internal */
 export const timeout: {
   (
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E | Cause.TimeoutError, R>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E | Cause.TimeoutError, R>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<A, E | TimeoutError, R> =>
     timeoutOrElse(self, {
       duration,
-      onTimeout: () => fail(new TimeoutError())
+      orElse: () => fail(new TimeoutError())
     })
 )
 
 /** @internal */
 export const timeoutOption: {
   (
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<Option.Option<A>, E, R>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<Option.Option<A>, E, R>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    duration: Duration.DurationInput
+    duration: Duration.Input
   ): Effect.Effect<Option.Option<A>, E, R> =>
     raceFirst(
       asSome(self),
@@ -3513,7 +3627,7 @@ export const ScopeTypeId = "~effect/Scope"
 export const ScopeCloseableTypeId = "~effect/Scope/Closeable"
 
 /** @internal */
-export const scopeTag: ServiceMap.Service<Scope.Scope, Scope.Scope> = ServiceMap.Service<Scope.Scope>("effect/Scope")
+export const scopeTag: Context.Service<Scope.Scope, Scope.Scope> = Context.Service<Scope.Scope>("effect/Scope")
 
 /** @internal */
 export const scopeClose = <A, E>(self: Scope.Scope, exit_: Exit.Exit<A, E>) =>
@@ -3646,11 +3760,11 @@ export const provideScope: {
 /** @internal */
 export const scoped = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, Exclude<R, Scope.Scope>> =>
   withFiber((fiber) => {
-    const prev = ServiceMap.getOption(fiber.services, scopeTag)
+    const prev = fiber.context
     const scope = scopeMakeUnsafe()
-    fiber.setServices(ServiceMap.add(fiber.services, scopeTag, scope))
+    fiber.setContext(Context.add(fiber.context, scopeTag, scope))
     return onExitPrimitive(self, (exit) => {
-      fiber.setServices(ServiceMap.addOrOmit(fiber.services, scopeTag, prev))
+      fiber.setContext(prev)
       return scopeCloseUnsafe(scope, exit)
     })
   }) as any
@@ -3677,13 +3791,22 @@ export const scopedWith = <A, E, R>(
   })
 
 /** @internal */
-export const acquireRelease = <A, E, R>(
+export const acquireRelease = <A, E, R, R2>(
   acquire: Effect.Effect<A, E, R>,
-  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown>
-): Effect.Effect<A, E, R | Scope.Scope> =>
-  uninterruptible(
-    flatMap(scope, (scope) =>
-      tap(acquire, (a) => scopeAddFinalizerExit(scope, (exit) => internalCall(() => release(a, exit)))))
+  release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect.Effect<unknown, never, R2>,
+  options?: { readonly interruptible?: boolean }
+): Effect.Effect<A, E, R | R2 | Scope.Scope> =>
+  contextWith((context: Context.Context<R2>) =>
+    uninterruptibleMask((restore) =>
+      flatMap(
+        scope,
+        (scope) =>
+          tap(
+            options?.interruptible ? restore(acquire) : acquire,
+            (a) => scopeAddFinalizerExit(scope, (exit) => provideContext(release(a, exit), context))
+          )
+      )
+    )
   )
 
 /** @internal */
@@ -3693,8 +3816,8 @@ export const addFinalizer = <R>(
   flatMap(
     scope,
     (scope) =>
-      servicesWith((services: ServiceMap.ServiceMap<R>) =>
-        scopeAddFinalizerExit(scope, (exit) => provideServices(finalizer(exit), services))
+      contextWith((context: Context.Context<R>) =>
+        scopeAddFinalizerExit(scope, (exit) => provideContext(finalizer(exit), context))
       )
   )
 
@@ -3758,34 +3881,51 @@ export const ensuring: {
 
 /** @internal */
 export const onExitIf: {
-  <A, E, XE, XR, Result extends Filter.ResultOrBool>(
-    filter: Filter.OrPredicate<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-    f: (
-      pass: Filter.Pass<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-      exit: Exit.Exit<NoInfer<A>, NoInfer<E>>
-    ) => Effect.Effect<void, XE, XR>
+  <A, E, XE, XR>(
+    predicate: Predicate.Predicate<Exit.Exit<NoInfer<A>, NoInfer<E>>>,
+    f: (exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
   ): <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | XE, R | XR>
-  <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(
+  <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-    f: (
-      pass: Filter.Pass<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-      exit: Exit.Exit<NoInfer<A>, NoInfer<E>>
-    ) => Effect.Effect<void, XE, XR>
+    predicate: Predicate.Predicate<Exit.Exit<NoInfer<A>, NoInfer<E>>>,
+    f: (exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
   ): Effect.Effect<A, E | XE, R | XR>
 } = dual(
   3,
-  <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(
+  <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-    f: (
-      pass: Filter.Pass<Exit.Exit<NoInfer<A>, NoInfer<E>>, Result>,
-      exit: Exit.Exit<NoInfer<A>, NoInfer<E>>
-    ) => Effect.Effect<void, XE, XR>
+    predicate: Predicate.Predicate<Exit.Exit<NoInfer<A>, NoInfer<E>>>,
+    f: (exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
+  ): Effect.Effect<A, E | XE, R | XR> =>
+    onExit(self, (exit) => {
+      if (!predicate(exit)) {
+        return void_
+      }
+      return f(exit)
+    })
+)
+
+/** @internal */
+export const onExitFilter: {
+  <A, E, XE, XR, B, X>(
+    filter: Filter.Filter<Exit.Exit<NoInfer<A>, NoInfer<E>>, B, X>,
+    f: (b: B, exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
+  ): <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | XE, R | XR>
+  <A, E, R, XE, XR, B, X>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Exit.Exit<NoInfer<A>, NoInfer<E>>, B, X>,
+    f: (b: B, exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
+  ): Effect.Effect<A, E | XE, R | XR>
+} = dual(
+  3,
+  <A, E, R, XE, XR, B, X>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Exit.Exit<NoInfer<A>, NoInfer<E>>, B, X>,
+    f: (b: B, exit: Exit.Exit<NoInfer<A>, NoInfer<E>>) => Effect.Effect<void, XE, XR>
   ): Effect.Effect<A, E | XE, R | XR> =>
     onExit(self, (exit) => {
-      const pass = Filter.apply(filter, exit)
-      return Result.isFailure(pass) ? void_ : f(pass.success as any, exit)
+      const b = filter(exit)
+      return Result.isFailure(b) ? void_ : f(b.success, exit)
     })
 )
 
@@ -3803,37 +3943,66 @@ export const onError: {
   <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
     f: (cause: Cause.Cause<NoInfer<E>>) => Effect.Effect<void, XE, XR>
-  ): Effect.Effect<A, E | XE, R | XR> => onExitIf(self, exitFilterCause as any, f as any) as any
+  ): Effect.Effect<A, E | XE, R | XR> => onExitFilter(self, exitFilterCause as any, f as any) as any
 )
 
 /** @internal */
 export const onErrorIf: {
-  <E, Result extends Filter.ResultOrBool, XE, XR>(
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+  <E, XE, XR>(
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | XE, R | XR>
-  <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(
+  <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
   ): Effect.Effect<A, E | XE, R | XR>
 } = dual(
   3,
-  <A, E, R, XE, XR, Result extends Filter.ResultOrBool>(
+  <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<Cause.Cause<E>, Result>,
-    f: (failure: Filter.Pass<Cause.Cause<E>, Result>, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+    predicate: Predicate.Predicate<Cause.Cause<E>>,
+    f: (cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
   ): Effect.Effect<A, E | XE, R | XR> =>
     onExitIf(
       self,
-      ((exit: Exit.Exit<any, any>) => {
-        if (exit._tag !== "Failure") return Result.fail(exit)
-        return Filter.apply(filter, exit.cause)
-      }) as any,
-      (eb: any, exit: any) => f(eb, (exit as Exit.Failure<any, any>).cause)
+      (exit): exit is Exit.Failure<A, E> => {
+        if (exit._tag !== "Failure") {
+          return false
+        }
+        return predicate(exit.cause)
+      },
+      (exit) => f((exit as Exit.Failure<A, E>).cause)
     ) as any
 )
 
+/** @internal */
+export const onErrorFilter: {
+  <A, E, EB, X, XE, XR>(
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+  ): <R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | XE, R | XR>
+  <A, E, R, EB, X, XE, XR>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+  ): Effect.Effect<A, E | XE, R | XR>
+} = dual(
+  3,
+  <A, E, R, EB, X, XE, XR>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<Cause.Cause<E>, EB, X>,
+    f: (failure: EB, cause: Cause.Cause<E>) => Effect.Effect<void, XE, XR>
+  ): Effect.Effect<A, E | XE, R | XR> =>
+    onExit(self, (exit) => {
+      if (exit._tag !== "Failure") {
+        return void_
+      }
+      const result = filter(exit.cause)
+      return Result.isFailure(result) ? void_ : f(result.success, exit.cause)
+    })
+)
+
 /** @internal */
 export const onInterrupt: {
   <XE, XR>(
@@ -3848,8 +4017,7 @@ export const onInterrupt: {
   <A, E, R, XE, XR>(
     self: Effect.Effect<A, E, R>,
     finalizer: (interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>
-  ): Effect.Effect<A, E | XE, R | XR> =>
-    onErrorIf<E, Result.Result<Set<number>, Cause.Cause<E>>, XE, XR>(causeFilterInterruptors, finalizer)(self)
+  ): Effect.Effect<A, E | XE, R | XR> => onErrorFilter(causeFilterInterruptors as any, finalizer)(self) as any
 )
 
 /** @internal */
@@ -3873,19 +4041,19 @@ export const acquireUseRelease = <Resource, E, R, A, E2, R2, E3, R3>(
 
 /** @internal */
 export const cachedInvalidateWithTTL: {
-  (timeToLive: Duration.DurationInput): <A, E, R>(
+  (timeToLive: Duration.Input): <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]>
 } = dual(2, <A, E, R>(
   self: Effect.Effect<A, E, R>,
-  ttl: Duration.DurationInput
+  ttl: Duration.Input
 ): Effect.Effect<[Effect.Effect<A, E, R>, Effect.Effect<void>]> =>
   sync(() => {
-    const ttlMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(ttl))
+    const ttlMillis = Duration.toMillis(Duration.fromInputUnsafe(ttl))
     const isFinite = Number.isFinite(ttlMillis)
     const latch = makeLatchUnsafe(false)
     let expiresAt = 0
@@ -3894,7 +4062,8 @@ export const cachedInvalidateWithTTL: {
     const wait = flatMap(latch.await, () => exit!)
     return [
       withFiber((fiber) => {
-        const now = isFinite ? fiber.getRef(ClockRef).currentTimeMillisUnsafe() : 0
+        const clock = fiber.getRef(ClockRef)
+        const now = isFinite ? clock.currentTimeMillisUnsafe() : 0
         if (running || now < expiresAt) return exit ?? wait
         running = true
         latch.closeUnsafe()
@@ -3902,7 +4071,7 @@ export const cachedInvalidateWithTTL: {
         return onExit(self, (exit_) =>
           sync(() => {
             running = false
-            expiresAt = now + ttlMillis
+            expiresAt = clock.currentTimeMillisUnsafe() + ttlMillis
             exit = exit_
             latch.openUnsafe()
           }))
@@ -3918,17 +4087,17 @@ export const cachedInvalidateWithTTL: {
 /** @internal */
 export const cachedWithTTL: {
   (
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Effect.Effect<A, E, R>>
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): Effect.Effect<Effect.Effect<A, E, R>>
 } = dual(
   2,
   <A, E, R>(
     self: Effect.Effect<A, E, R>,
-    timeToLive: Duration.DurationInput
+    timeToLive: Duration.Input
   ): Effect.Effect<Effect.Effect<A, E, R>> => map(cachedInvalidateWithTTL(self, timeToLive), (tuple) => tuple[0])
 )
 
@@ -4074,54 +4243,191 @@ export const partition: {
   ): Effect.Effect<[excluded: Array<E>, satisfying: Array<B>], never, R> =>
     map(
       forEach(elements, (a, i) => result(f(a, i)), options),
-      (results) => Arr.partitionMap(results, identity)
+      (results) => Arr.partition(results, identity)
     )
 )
 
 /** @internal */
-export const whileLoop: <A, E, R>(options: {
-  readonly while: LazyArg<boolean>
-  readonly body: LazyArg<Effect.Effect<A, E, R>>
-  readonly step: (a: A) => void
-}) => Effect.Effect<void, E, R> = makePrimitive({
-  op: "While",
-  [contA](value, fiber) {
-    this[args].step(value)
-    if (this[args].while()) {
-      fiber._stack.push(this)
-      return this[args].body()
-    }
-    return exitVoid
-  },
-  [evaluate](fiber) {
-    if (this[args].while()) {
-      fiber._stack.push(this)
-      return this[args].body()
+export const validate: {
+  <A, B, E, R>(
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: false | undefined
+    } | undefined
+  ): (elements: Iterable<A>) => Effect.Effect<Array<B>, Arr.NonEmptyArray<E>, R>
+  <A, B, E, R>(
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
     }
-    return exitVoid
-  }
-})
-
-/** @internal */
-export const forEach: {
-  <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(
-    f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect.Effect<B, E, R>,
+  ): (elements: Iterable<A>) => Effect.Effect<void, Arr.NonEmptyArray<E>, R>
+  <A, B, E, R>(
+    elements: Iterable<A>,
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
     options?: {
       readonly concurrency?: Concurrency | undefined
-      readonly discard?: Discard | undefined
+      readonly discard?: false | undefined
     } | undefined
-  ): (
-    self: S
-  ) => Effect.Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
-  <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(
-    self: S,
-    f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect.Effect<B, E, R>,
+  ): Effect.Effect<Array<B>, Arr.NonEmptyArray<E>, R>
+  <A, B, E, R>(
+    elements: Iterable<A>,
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
+    options: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard: true
+    }
+  ): Effect.Effect<void, Arr.NonEmptyArray<E>, R>
+} = dual(
+  (args) => isIterable(args[0]) && !isEffect(args[0]),
+  <A, B, E, R>(
+    elements: Iterable<A>,
+    f: (a: A, i: number) => Effect.Effect<B, E, R>,
     options?: {
       readonly concurrency?: Concurrency | undefined
-      readonly discard?: Discard | undefined
+      readonly discard?: boolean | undefined
     } | undefined
-  ): Effect.Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
-} = dual((args) => typeof args[1] === "function", <A, B, E, R>(
+  ): Effect.Effect<Array<B> | void, Arr.NonEmptyArray<E>, R> =>
+    flatMap(
+      partition(elements, f, { concurrency: options?.concurrency }),
+      ([excluded, satisfying]) => {
+        if (Arr.isArrayNonEmpty(excluded)) {
+          return fail(excluded)
+        }
+        return options?.discard ? void_ : succeed(satisfying)
+      }
+    )
+)
+
+/** @internal */
+export const findFirst: {
+  <A, E, R>(
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): (elements: Iterable<A>) => Effect.Effect<Option.Option<A>, E, R>
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Option.Option<A>, E, R>
+} = dual(
+  (args) => isIterable(args[0]) && !isEffect(args[0]),
+  <A, E, R>(
+    elements: Iterable<A>,
+    predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>
+  ): Effect.Effect<Option.Option<A>, E, R> =>
+    suspend(() => {
+      const iterator = elements[Symbol.iterator]()
+      const next = iterator.next()
+      if (!next.done) {
+        return findFirstLoop(iterator, 0, predicate, next.value)
+      }
+      return succeed(Option.none())
+    })
+)
+
+const findFirstLoop = <A, E, R>(
+  iterator: Iterator<A>,
+  index: number,
+  predicate: (a: A, i: number) => Effect.Effect<boolean, E, R>,
+  value: A
+): Effect.Effect<Option.Option<A>, E, R> =>
+  flatMap(predicate(value, index), (keep) => {
+    if (keep) {
+      return succeed(Option.some(value))
+    }
+    const next = iterator.next()
+    if (!next.done) {
+      return findFirstLoop(iterator, index + 1, predicate, next.value)
+    }
+    return succeed(Option.none())
+  })
+
+/** @internal */
+export const findFirstFilter: {
+  <A, B, X, E, R>(
+    filter: (input: NoInfer<A>, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
+  ): (elements: Iterable<A>) => Effect.Effect<Option.Option<B>, E, R>
+  <A, B, X, E, R>(
+    elements: Iterable<A>,
+    filter: (input: NoInfer<A>, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
+  ): Effect.Effect<Option.Option<B>, E, R>
+} = dual(
+  (args) => isIterable(args[0]) && !isEffect(args[0]),
+  <A, B, X, E, R>(
+    elements: Iterable<A>,
+    filter: (input: A, i: number) => Effect.Effect<Result.Result<B, X>, E, R>
+  ): Effect.Effect<Option.Option<B>, E, R> =>
+    suspend(() => {
+      const iterator = elements[Symbol.iterator]()
+      const next = iterator.next()
+      if (!next.done) {
+        return findFirstFilterLoop(iterator, 0, filter, next.value)
+      }
+      return succeed(Option.none())
+    })
+)
+
+const findFirstFilterLoop = <A, B, X, E, R>(
+  iterator: Iterator<A>,
+  index: number,
+  filter: (input: A, i: number) => Effect.Effect<Result.Result<B, X>, E, R>,
+  value: A
+): Effect.Effect<Option.Option<B>, E, R> =>
+  flatMap(filter(value, index), (result) => {
+    if (Result.isSuccess(result)) {
+      return succeed(Option.some(result.success))
+    }
+    const next = iterator.next()
+    if (!next.done) {
+      return findFirstFilterLoop(iterator, index + 1, filter, next.value)
+    }
+    return succeed(Option.none())
+  })
+
+/** @internal */
+export const whileLoop: <A, E, R>(options: {
+  readonly while: LazyArg<boolean>
+  readonly body: LazyArg<Effect.Effect<A, E, R>>
+  readonly step: (a: A) => void
+}) => Effect.Effect<void, E, R> = makePrimitive({
+  op: "While",
+  [contA](value, fiber) {
+    this[args].step(value)
+    if (this[args].while()) {
+      fiber._stack.push(this)
+      return this[args].body()
+    }
+    return exitVoid
+  },
+  [evaluate](fiber) {
+    if (this[args].while()) {
+      fiber._stack.push(this)
+      return this[args].body()
+    }
+    return exitVoid
+  }
+})
+
+/** @internal */
+export const forEach: {
+  <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(
+    f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect.Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: Discard | undefined
+    } | undefined
+  ): (
+    self: S
+  ) => Effect.Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
+  <B, E, R, S extends Iterable<any>, const Discard extends boolean = false>(
+    self: S,
+    f: (a: Arr.ReadonlyArray.Infer<S>, i: number) => Effect.Effect<B, E, R>,
+    options?: {
+      readonly concurrency?: Concurrency | undefined
+      readonly discard?: Discard | undefined
+    } | undefined
+  ): Effect.Effect<Discard extends false ? Arr.ReadonlyArray.With<S, B> : void, E, R>
+} = dual((args) => typeof args[1] === "function", <A, B, E, R>(
   iterable: Iterable<A>,
   f: (a: A, index: number) => Effect.Effect<B, E, R>,
   options?: {
@@ -4150,72 +4456,8 @@ export const forEach: {
     const out: Array<B> | undefined = options?.discard
       ? undefined
       : new Array(length)
-    let index = 0
-    const annotations = fiberStackAnnotations(parent)
-
-    return callback((resume) => {
-      const fibers = new Set<Fiber.Fiber<unknown, unknown>>()
-      const failures: Array<Cause.Reason<E>> = []
-      let failed = false
-      let inProgress = 0
-      let doneCount = 0
-      let pumping = false
-      let interrupted = false
-      function pump() {
-        pumping = true
-        while (inProgress < concurrency && index < length) {
-          const currentIndex = index
-          const item = items[currentIndex]
-          index++
-          inProgress++
-          try {
-            const child = forkUnsafe(parent, f(item, currentIndex), true, true, "inherit")
-            fibers.add(child)
-            child.addObserver((exit) => {
-              if (interrupted) {
-                return
-              }
-              fibers.delete(child)
-              if (exit._tag === "Failure") {
-                if (!failed) {
-                  failed = true
-                  length = index
-                  failures.push(...exit.cause.reasons)
-                  fibers.forEach((fiber) => fiber.interruptUnsafe(parent.id, annotations))
-                } else {
-                  for (const f of exit.cause.reasons) {
-                    if (f._tag === "Interrupt") continue
-                    failures.push(f)
-                  }
-                }
-              } else if (out !== undefined) {
-                out[currentIndex] = exit.value
-              }
-              doneCount++
-              inProgress--
-              if (doneCount === length) {
-                resume(failures.length > 0 ? exitFailCause(causeFromReasons(failures)) : succeed(out))
-              } else if (!pumping && !failed && inProgress < concurrency) {
-                pump()
-              }
-            })
-          } catch (err) {
-            failed = true
-            length = index
-            failures.push(new Die(err))
-            fibers.forEach((fiber) => fiber.interruptUnsafe(parent.id, annotations))
-          }
-        }
-        pumping = false
-      }
-      pump()
-
-      return suspend(() => {
-        interrupted = true
-        index = length
-        return fiberInterruptAll(fibers)
-      })
-    })
+    const eff = forEachConcurrent({ f, out }, items, { concurrency })
+    return eff ? as(eff, out as any) : succeed(out as any)
   }))
 
 const forEachSequential = <A, B, E, R>(
@@ -4243,39 +4485,273 @@ const forEachSequential = <A, B, E, R>(
     )
   })
 
+const iterateEagerImpl = <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?: {
+    readonly concurrency?: number | undefined
+    readonly start?: number | undefined
+    readonly end?: number | undefined
+  }
+) => Effect.Effect<void, E | E2, R> | undefined => {
+  const onItem = options.onItem
+  const step = options.step
+
+  return (
+    state: S,
+    items: ReadonlyArray<A>,
+    opts: {
+      readonly concurrency?: number | undefined
+      readonly start?: number | undefined
+      readonly end?: number | undefined
+    } | undefined
+  ): Effect.Effect<void, E | E2, R> | undefined => {
+    let index = opts?.start ?? 0
+    const end = opts?.end ?? items.length
+    const concurrency = opts?.concurrency ?? 1
+    let done = false
+    let parentFiber: Fiber.Fiber<any, any> | undefined
+    let fibers: Set<Fiber.Fiber<any, any>> | undefined
+    let resume: ((effect: Effect.Effect<void, E | E2, R>) => void) | undefined
+    let interrupted = false
+    let terminal: Exit.Exit<void, E | E2> | void
+    let effect: Effect.Effect<X, E, R> | undefined
+
+    const go = (): Effect.Effect<void, E | E2, R> | undefined => {
+      let paused = false
+      for (; !terminal && index < end; index++) {
+        const item = items[index]
+        const eff = effect ?? onItem(state, item, index)
+
+        // fast case (already an exit)
+        if (effectIsExit(eff)) {
+          terminal = step(state, item, eff, index)
+          if (terminal) break
+
+          // Use flatMap for concurrency of 1
+        } else if (concurrency === 1) {
+          return flatMap(exit(eff), (exit) => {
+            terminal = step(state, item, exit, index)
+            index++
+            return terminal ?? go() ?? void_
+          })
+
+          // We have an effect, so enter "async" mode
+        } else if (!parentFiber) {
+          return callback((cb) => {
+            parentFiber = getCurrentFiber()!
+            effect = eff
+            resume = cb
+            const result = go()
+            if (result) return cb(result)
+            return suspend(() => {
+              terminal = exitVoid
+              interrupted = true
+              return fibers ? fiberInterruptAll(fibers) : void_
+            })
+          })
+
+          // Fork the effect with concurrency > 1
+        } else {
+          // Clear the temporary effect from capturing the parentFiber
+          effect = undefined
+
+          const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit")
+          if (fiber._exit) {
+            terminal = step(state, item, fiber._exit, index)
+            if (terminal) break
+            continue
+          }
+
+          // Add the fiber to the Set
+          if (fibers) fibers.add(fiber)
+          else fibers = new Set([fiber])
+
+          const currentIndex = index
+          fiber.addObserver((exit) => {
+            fibers!.delete(fiber)
+            if (terminal) {
+              if (!interrupted && exit._tag === "Failure") {
+                for (const reason of exit.cause.reasons) {
+                  if (reason._tag === "Interrupt") continue
+                  else if (terminal._tag === "Failure") {
+                    ;(terminal.cause.reasons as Array<any>).push(reason)
+                  } else {
+                    terminal = exitFailCause(causeFromReasons([reason]))
+                  }
+                }
+              }
+            } else {
+              const result = step(state, item, exit, currentIndex)
+              if (result) {
+                terminal = result._tag === "Failure"
+                  ? exitFailCause(causeFromReasons(result.cause.reasons.slice()))
+                  : result
+                go()
+              }
+            }
+
+            if (paused) {
+              const eff = go()
+              if (eff) resume!(eff)
+            } else if (done && fibers!.size === 0) {
+              resume!(terminal ?? void_)
+            }
+          })
+
+          // Check if we have reached the concurrency limit
+          if (fibers.size < concurrency) continue
+          paused = true
+          index++
+          return
+        }
+      }
+
+      done = true
+
+      if (terminal) {
+        if (fibers && fibers.size > 0) {
+          const annotations = fiberStackAnnotations(parentFiber!)
+          fibers.forEach((f) => f.interruptUnsafe(parentFiber!.id, annotations))
+          return
+        }
+        if (resume || terminal._tag === "Failure") {
+          return terminal
+        }
+      } else if (resume) {
+        if (!fibers) {
+          return exitVoid
+        } else if (fibers.size === 0) {
+          resume(void_)
+        }
+      }
+    }
+
+    return go()
+  }
+}
+
+/** @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?: {
+    readonly concurrency?: number | undefined
+    readonly start?: number | undefined
+    readonly end?: number | undefined
+  }
+) => Effect.Effect<void, E | E2, R> | undefined => iterateEagerImpl
+
+const forEachConcurrent = iterateEagerImpl({
+  onItem(
+    state: {
+      readonly f: (a: any, i: number) => Effect.Effect<any, any, any>
+      readonly out: Array<any> | undefined
+    },
+    item,
+    index
+  ) {
+    return state.f(item, index)
+  },
+  step(state, _, exit, index) {
+    if (exit._tag === "Failure") return exit
+    else if (state.out) {
+      state.out[index] = exit.value
+    }
+  }
+})
+
 /* @internal */
 export const filterOrElse: {
   <A, C, E2, R2, B extends A>(
     refinement: Predicate.Refinement<NoInfer<A>, B>,
     orElse: (a: EqualsWith<A, B, NoInfer<A>, Exclude<NoInfer<A>, B>>) => Effect.Effect<C, E2, R2>
   ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B | C, E2 | E, R2 | R>
-  <A, Result extends Filter.ResultOrBool, C, E2, R2>(
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
-    orElse: (a: Filter.Fail<A, Result>) => Effect.Effect<C, E2, R2>
-  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Filter.Pass<A, Result> | C, E2 | E, R2 | R>
+  <A, C, E2, R2>(
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orElse: (a: NoInfer<A>) => Effect.Effect<C, E2, R2>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | C, E2 | E, R2 | R>
   <A, E, R, C, E2, R2, B extends A>(
     self: Effect.Effect<A, E, R>,
     refinement: Predicate.Refinement<A, B>,
     orElse: (a: EqualsWith<A, B, A, Exclude<A, B>>) => Effect.Effect<C, E2, R2>
   ): Effect.Effect<B | C, E | E2, R | R2>
-  <A, E, R, Result extends Filter.ResultOrBool, C, E2, R2>(
+  <A, E, R, C, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    filter: Filter.OrPredicate<NoInfer<A>, Result>,
-    orElse: (a: Filter.Fail<A, Result>) => Effect.Effect<C, E2, R2>
-  ): Effect.Effect<Filter.Pass<A, Result> | C, E | E2, R | R2>
-} = dual(3, <A, E, R, Result extends Filter.ResultOrBool, C, E2, R2>(
+    predicate: Predicate.Predicate<NoInfer<A>>,
+    orElse: (a: NoInfer<A>) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<A | C, E | E2, R | R2>
+} = dual(3, <A, E, R, B, E2, R2>(
   self: Effect.Effect<A, E, R>,
-  filter: Filter.OrPredicate<NoInfer<A>, Result>,
-  orElse: (a: Filter.Fail<A, Result>) => Effect.Effect<C, E2, R2>
-): Effect.Effect<Filter.Pass<A, Result> | C, E | E2, R | R2> =>
+  predicate: Predicate.Predicate<A>,
+  orElse: (a: A) => Effect.Effect<B, E2, R2>
+): Effect.Effect<A | B, E | E2, R | R2> =>
+  flatMap(
+    self,
+    (a) => predicate(a) ? succeed<A | B>(a) : orElse(a)
+  ))
+
+/** @internal */
+export const filterMapOrElse: {
+  <A, B, X, C, E2, R2>(
+    filter: Filter.Filter<NoInfer<A>, B, X>,
+    orElse: (x: X) => Effect.Effect<C, E2, R2>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B | C, E2 | E, R2 | R>
+  <A, E, R, B, X, C, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<NoInfer<A>, B, X>,
+    orElse: (x: X) => Effect.Effect<C, E2, R2>
+  ): Effect.Effect<B | C, E | E2, R | R2>
+} = dual(3, <A, E, R, B, X, C, E2, R2>(
+  self: Effect.Effect<A, E, R>,
+  filter: Filter.Filter<NoInfer<A>, B, X>,
+  orElse: (x: X) => Effect.Effect<C, E2, R2>
+): Effect.Effect<B | C, E | E2, R | R2> =>
   flatMap(
     self,
     (a) => {
-      const result = Filter.apply(filter, a)
-      return Result.isFailure(result) ? orElse(result.failure) : succeed(result.success) as any
+      const result = filter(a)
+      return (Result.isFailure(result)
+        ? orElse(result.failure)
+        : succeed(result.success)) as Effect.Effect<B | C, E2, R2>
     }
   ))
 
+/* @internal */
+export const filterMapOrFail: {
+  <A, B, X, E2>(
+    filter: Filter.Filter<NoInfer<A>, B, X>,
+    orFailWith: (x: X) => E2
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, E2 | E, R>
+  <A, B, X>(
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): <E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<B, Cause.NoSuchElementError | E, R>
+  <A, E, R, B, X, E2>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<NoInfer<A>, B, X>,
+    orFailWith: (x: X) => E2
+  ): Effect.Effect<B, E2 | E, R>
+  <A, E, R, B, X>(
+    self: Effect.Effect<A, E, R>,
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): Effect.Effect<B, Cause.NoSuchElementError | E, R>
+} = dual((args) => isEffect(args[0]), <A, E, R, B, X, E2>(
+  self: Effect.Effect<A, E, R>,
+  filter: Filter.Filter<NoInfer<A>, B, X>,
+  orFailWith?: (x: X) => E2
+): Effect.Effect<B, E2 | Cause.NoSuchElementError | E, R> =>
+  filterMapOrElse(
+    self,
+    filter,
+    orFailWith ? (x: X) => fail(orFailWith(x)) : () => fail(new NoSuchElementError() as E2)
+  ))
+
 /** @internal */
 export const filter: {
   <A, B extends A>(
@@ -4284,13 +4760,6 @@ export const filter: {
   <A>(
     predicate: Predicate.Predicate<NoInfer<A>>
   ): (elements: Iterable<A>) => Effect.Effect<Array<A>>
-  <A, B, X>(
-    filter: Filter.Filter<NoInfer<A>, B, X>
-  ): (elements: Iterable<A>) => Effect.Effect<Array<B>>
-  <A, B, X, E, R>(
-    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
-    options?: { readonly concurrency?: Concurrency | undefined }
-  ): (elements: Iterable<A>) => Effect.Effect<Array<B>, E, R>
   <A, E, R>(
     predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>,
     options?: { readonly concurrency?: Concurrency | undefined }
@@ -4303,15 +4772,6 @@ export const filter: {
     elements: Iterable<A>,
     predicate: Predicate.Predicate<A>
   ): Effect.Effect<Array<A>>
-  <A, B, X>(
-    elements: Iterable<A>,
-    filter: Filter.Filter<NoInfer<A>, B, X>
-  ): Effect.Effect<Array<B>>
-  <A, B, X, E, R>(
-    elements: Iterable<A>,
-    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
-    options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect.Effect<Array<B>, E, R>
   <A, E, R>(
     iterable: Iterable<A>,
     predicate: (a: NoInfer<A>, i: number) => Effect.Effect<boolean, E, R>,
@@ -4319,36 +4779,27 @@ export const filter: {
   ): Effect.Effect<Array<A>, E, R>
 } = dual(
   (args) => isIterable(args[0]) && !isEffect(args[0]),
-  <A, B, X, E, R>(
+  <A, E, R>(
     elements: Iterable<A>,
-    filter:
-      | Filter.FilterEffect<A, B, X, E, R>
+    predicate:
       | Predicate.Predicate<A>
       | ((a: A, i: number) => Effect.Effect<boolean, E, R>),
     options?: { readonly concurrency?: Concurrency | undefined }
-  ): Effect.Effect<Array<B>, E, R> =>
+  ): Effect.Effect<Array<A>, E, R> =>
     suspend(() => {
-      const out: Array<any> = []
+      const out: Array<A> = []
       return as(
         forEach(
           elements,
           (a, i) => {
-            const result = (filter as Function)(a, i)
+            const result = (predicate as Function)(a, i)
             if (typeof result === "boolean") {
               if (result) out.push(a)
               return void_ as any
             }
-            if (!isEffect(result)) {
-              if (!Result.isFailure(result)) {
-                out.push(result.success)
-              }
-              return void_ as any
-            }
-            return map(result, (r: any) => {
-              if (typeof r === "boolean") {
-                if (r) out.push(a)
-              } else if (!Result.isFailure(r)) {
-                out.push(r.success)
+            return map(result, (keep) => {
+              if (keep) {
+                out.push(a)
               }
             })
           },
@@ -4362,6 +4813,72 @@ export const filter: {
     })
 )
 
+/** @internal */
+export const filterMap: {
+  <A, B, X>(
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): (elements: Iterable<A>) => Effect.Effect<Array<B>>
+  <A, B, X>(
+    elements: Iterable<A>,
+    filter: Filter.Filter<NoInfer<A>, B, X>
+  ): Effect.Effect<Array<B>>
+} = dual(
+  (args) => isIterable(args[0]) && !isEffect(args[0]),
+  <A, B, X>(
+    elements: Iterable<A>,
+    filter: Filter.Filter<A, B, X>
+  ): Effect.Effect<Array<B>> =>
+    suspend(() => {
+      const out: Array<B> = []
+      for (const a of elements) {
+        const result = filter(a)
+        if (Result.isSuccess(result)) {
+          out.push(result.success)
+        }
+      }
+      return succeed(out)
+    })
+)
+
+/** @internal */
+export const filterMapEffect: {
+  <A, B, X, E, R>(
+    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
+    options?: { readonly concurrency?: Concurrency | undefined }
+  ): (elements: Iterable<A>) => Effect.Effect<Array<B>, E, R>
+  <A, B, X, E, R>(
+    elements: Iterable<A>,
+    filter: Filter.FilterEffect<NoInfer<A>, B, X, E, R>,
+    options?: { readonly concurrency?: Concurrency | undefined }
+  ): Effect.Effect<Array<B>, E, R>
+} = dual(
+  (args) => isIterable(args[0]) && !isEffect(args[0]),
+  <A, B, X, E, R>(
+    elements: Iterable<A>,
+    filter: Filter.FilterEffect<A, B, X, E, R>,
+    options?: { readonly concurrency?: Concurrency | undefined }
+  ): Effect.Effect<Array<B>, E, R> =>
+    suspend(() => {
+      const out: Array<B> = []
+      return as(
+        forEach(
+          elements,
+          (a) =>
+            map(filter(a), (result) => {
+              if (Result.isSuccess(result)) {
+                out.push(result.success)
+              }
+            }),
+          {
+            discard: true,
+            concurrency: options?.concurrency
+          }
+        ),
+        out
+      )
+    })
+)
+
 // ----------------------------------------------------------------------------
 // do notation
 // ----------------------------------------------------------------------------
@@ -4462,13 +4979,13 @@ export const forkUnsafe = <FA, FE, A, E, R>(
   immediate = false,
   daemon = false,
   uninterruptible: boolean | "inherit" = false
-): Fiber.Fiber<A, E> => {
+): FiberImpl<A, E> => {
   const interruptible = uninterruptible === "inherit" ? parent.interruptible : !uninterruptible
-  const child = new FiberImpl<A, E>(parent.services, interruptible)
+  const child = new FiberImpl<A, E>(parent.context, interruptible)
   if (immediate) {
     child.evaluate(effect as any)
   } else {
-    parent.currentScheduler.scheduleTask(() => child.evaluate(effect as any), 0)
+    parent.currentDispatcher.scheduleTask(() => child.evaluate(effect as any), 0)
   }
   if (!daemon && !child._exit) {
     parent.children().add(child)
@@ -4588,7 +5105,8 @@ export const forkScoped: {
       readonly startImmediately?: boolean | undefined
       readonly uninterruptible?: boolean | "inherit" | undefined
     } | undefined
-  ): [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Effect.Effect<Fiber.Fiber<_A, _E>, never, _R>
+  ): [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ?
+    Effect.Effect<Fiber.Fiber<_A, _E>, never, _R | Scope.Scope>
     : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<Fiber.Fiber<A, E>, never, R | Scope.Scope>
 } = dual((args) => isEffect(args[0]), <A, E, R>(
   self: Effect.Effect<A, E, R>,
@@ -4603,15 +5121,13 @@ export const forkScoped: {
 // ----------------------------------------------------------------------------
 
 /** @internal */
-export const runForkWith = <R>(services: ServiceMap.ServiceMap<R>) =>
+export const runForkWith = <R>(context: Context.Context<R>) =>
 <A, E>(
   effect: Effect.Effect<A, E, R>,
   options?: Effect.RunOptions | undefined
 ): Fiber.Fiber<A, E> => {
-  const scheduler = options?.scheduler ||
-    (!services.mapUnsafe.has(Scheduler.Scheduler.key) && new Scheduler.MixedScheduler())
   const fiber = new FiberImpl<A, E>(
-    scheduler ? ServiceMap.add(services, Scheduler.Scheduler, scheduler) : services,
+    options?.scheduler ? Context.add(context, Scheduler.Scheduler, options.scheduler) : context,
     options?.uninterruptible !== true
   )
   fiber.evaluate(effect as any)
@@ -4626,6 +5142,9 @@ export const runForkWith = <R>(services: ServiceMap.ServiceMap<R>) =>
       fiber.addObserver(() => options.signal!.removeEventListener("abort", abort))
     }
   }
+  if (options?.onFiberStart) {
+    options.onFiberStart(fiber)
+  }
   return fiber
 }
 
@@ -4656,11 +5175,11 @@ export const fiberRunIn: {
 export const runFork: <A, E>(
   effect: Effect.Effect<A, E, never>,
   options?: Effect.RunOptions | undefined
-) => Fiber.Fiber<A, E> = runForkWith(ServiceMap.empty())
+) => Fiber.Fiber<A, E> = runForkWith(Context.empty())
 
 /** @internal */
-export const runCallbackWith = <R>(services: ServiceMap.ServiceMap<R>) => {
-  const runFork = runForkWith(services)
+export const runCallbackWith = <R>(context: Context.Context<R>) => {
+  const runFork = runForkWith(context)
   return <A, E>(
     effect: Effect.Effect<A, E, R>,
     options?:
@@ -4680,11 +5199,11 @@ export const runCallbackWith = <R>(services: ServiceMap.ServiceMap<R>) => {
 }
 
 /** @internal */
-export const runCallback = runCallbackWith(ServiceMap.empty())
+export const runCallback = runCallbackWith(Context.empty())
 
 /** @internal */
-export const runPromiseExitWith = <R>(services: ServiceMap.ServiceMap<R>) => {
-  const runFork = runForkWith(services)
+export const runPromiseExitWith = <R>(context: Context.Context<R>) => {
+  const runFork = runForkWith(context)
   return <A, E>(
     effect: Effect.Effect<A, E, R>,
     options?: Effect.RunOptions | undefined
@@ -4697,11 +5216,11 @@ export const runPromiseExitWith = <R>(services: ServiceMap.ServiceMap<R>) => {
 }
 
 /** @internal */
-export const runPromiseExit = runPromiseExitWith(ServiceMap.empty())
+export const runPromiseExit = runPromiseExitWith(Context.empty())
 
 /** @internal */
-export const runPromiseWith = <R>(services: ServiceMap.ServiceMap<R>) => {
-  const runPromiseExit = runPromiseExitWith(services)
+export const runPromiseWith = <R>(context: Context.Context<R>) => {
+  const runPromiseExit = runPromiseExitWith(context)
   return <A, E>(
     effect: Effect.Effect<A, E, R>,
     options?:
@@ -4722,28 +5241,28 @@ export const runPromise: <A, E>(
   options?:
     | Effect.RunOptions
     | undefined
-) => Promise<A> = runPromiseWith(ServiceMap.empty())
+) => Promise<A> = runPromiseWith(Context.empty())
 
 /** @internal */
-export const runSyncExitWith = <R>(services: ServiceMap.ServiceMap<R>) => {
-  const runFork = runForkWith(services)
+export const runSyncExitWith = <R>(context: Context.Context<R>) => {
+  const runFork = runForkWith(context)
   return <A, E>(effect: Effect.Effect<A, E, R>): Exit.Exit<A, E> => {
     if (effectIsExit(effect)) return effect
     const scheduler = new Scheduler.MixedScheduler("sync")
     const fiber = runFork(effect, { scheduler })
-    scheduler.flush()
-    return (fiber as FiberImpl<A, E>)._exit ?? exitDie(fiber)
+    fiber.currentDispatcher?.flush()
+    return (fiber as FiberImpl<A, E>)._exit ?? exitDie(new AsyncFiberError(fiber))
   }
 }
 
 /** @internal */
 export const runSyncExit: <A, E>(effect: Effect.Effect<A, E>) => Exit.Exit<A, E> = runSyncExitWith(
-  ServiceMap.empty()
+  Context.empty()
 )
 
 /** @internal */
-export const runSyncWith = <R>(services: ServiceMap.ServiceMap<R>) => {
-  const runSyncExit = runSyncExitWith(services)
+export const runSyncWith = <R>(context: Context.Context<R>) => {
+  const runSyncExit = runSyncExitWith(context)
   return <A, E>(effect: Effect.Effect<A, E, R>): A => {
     const exit = runSyncExit(effect)
     if (exit._tag === "Failure") throw causeSquash(exit.cause)
@@ -4752,109 +5271,12 @@ export const runSyncWith = <R>(services: ServiceMap.ServiceMap<R>) => {
 }
 
 /** @internal */
-export const runSync: <A, E>(effect: Effect.Effect<A, E>) => A = runSyncWith(ServiceMap.empty())
-
-// ----------------------------------------------------------------------------
-// Semaphore
-// ----------------------------------------------------------------------------
-
-/** @internal */
-class Semaphore {
-  public waiters = new Set<() => void>()
-  public taken = 0
-  public permits: number
-
-  constructor(permits: number) {
-    this.permits = permits
-  }
-
-  get free() {
-    return this.permits - this.taken
-  }
-
-  readonly take = (n: number): Effect.Effect<number> =>
-    callback<number>((resume) => {
-      if (this.free < n) {
-        const observer = () => {
-          if (this.free < n) {
-            return
-          }
-          this.waiters.delete(observer)
-          this.taken += n
-          resume(succeed(n))
-        }
-        this.waiters.add(observer)
-        return sync(() => {
-          this.waiters.delete(observer)
-        })
-      }
-      this.taken += n
-      return resume(succeed(n))
-    })
-
-  updateTakenUnsafe(fiber: Fiber.Fiber<any, any>, f: (n: number) => number): Effect.Effect<number> {
-    this.taken = f(this.taken)
-    if (this.waiters.size > 0) {
-      fiber.currentScheduler.scheduleTask(() => {
-        const iter = this.waiters.values()
-        let item = iter.next()
-        while (item.done === false && this.free > 0) {
-          item.value()
-          item = iter.next()
-        }
-      }, 0)
-    }
-    return succeed(this.free)
-  }
-
-  updateTaken(f: (n: number) => number): Effect.Effect<number> {
-    return withFiber((fiber) => this.updateTakenUnsafe(fiber, f))
-  }
-
-  readonly resize = (permits: number) =>
-    asVoid(
-      withFiber((fiber) => {
-        this.permits = permits
-        if (this.free < 0) {
-          return void_
-        }
-        return this.updateTakenUnsafe(fiber, (taken) => taken)
-      })
-    )
-
-  readonly release = (n: number): Effect.Effect<number> => this.updateTaken((taken) => taken - n)
-
-  readonly releaseAll: Effect.Effect<number> = this.updateTaken((_) => 0)
-
-  readonly withPermits = (n: number) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    uninterruptibleMask((restore) =>
-      flatMap(restore(this.take(n)), (permits) => ensuring(restore(self), this.release(permits)))
-    )
-
-  readonly withPermit = this.withPermits(1)
-
-  readonly withPermitsIfAvailable = (n: number) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
-    uninterruptibleMask((restore) =>
-      suspend(() => {
-        if (this.free < n) {
-          return succeedNone
-        }
-        this.taken += n
-        return ensuring(restore(asSome(self)), this.release(n))
-      })
-    )
-}
-
-/** @internal */
-export const makeSemaphoreUnsafe = (permits: number): Semaphore => new Semaphore(permits)
-
-/** @internal */
-export const makeSemaphore = (permits: number) => sync(() => makeSemaphoreUnsafe(permits))
+export const runSync: <A, E>(effect: Effect.Effect<A, E>) => A = runSyncWith(Context.empty())
 
 const succeedTrue = succeed(true)
 const succeedFalse = succeed(false)
 
-class Latch implements Effect.Latch {
+class Latch implements _Latch.Latch {
   waiters: Array<(_: Effect.Effect<void>) => void> = []
   scheduled = false
   private isOpen: boolean
@@ -4868,7 +5290,7 @@ class Latch implements Effect.Latch {
       return succeedTrue
     }
     this.scheduled = true
-    fiber.currentScheduler.scheduleTask(this.flushWaiters, 0)
+    fiber.currentDispatcher.scheduleTask(this.flushWaiters, 0)
     return succeedTrue
   }
   private flushWaiters = () => {
@@ -4910,11 +5332,11 @@ class Latch implements Effect.Latch {
     return true
   }
   close = sync(() => this.closeUnsafe())
-  whenOpen = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => andThen(this.await, self)
+  whenOpen = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> => flatMap(this.await, () => self)
 }
 
 /** @internal */
-export const makeLatchUnsafe = (open?: boolean | undefined): Effect.Latch => new Latch(open ?? false)
+export const makeLatchUnsafe = (open?: boolean | undefined): _Latch.Latch => new Latch(open ?? false)
 
 /** @internal */
 export const makeLatch = (open?: boolean | undefined) => sync(() => makeLatchUnsafe(open))
@@ -4973,16 +5395,15 @@ const NoopSpanProto: Omit<Tracer.Span, "parent" | "name" | "annotations" | "leve
 /** @internal */
 export const noopSpan = (options: {
   readonly name: string
-  readonly parent: Tracer.AnySpan | undefined
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly parent: Option.Option<Tracer.AnySpan>
+  readonly annotations: Context.Context<never>
 }): Tracer.Span => Object.assign(Object.create(NoopSpanProto), options)
 
-const filterDisablePropagation = (span: Tracer.AnySpan | undefined): Tracer.AnySpan | undefined => {
-  if (span) {
-    return ServiceMap.get(span.annotations, Tracer.DisablePropagation)
-      ? span._tag === "Span" ? filterDisablePropagation(span.parent) : undefined
-      : span
-  }
+const filterDisablePropagation = (span: Tracer.AnySpan | undefined): Option.Option<Tracer.AnySpan> => {
+  if (!span) return Option.none()
+  return Context.get(span.annotations, Tracer.DisablePropagation)
+    ? span._tag === "Span" ? filterDisablePropagation(Option.getOrUndefined(span.parent)) : Option.none()
+    : Option.some(span)
 }
 
 /** @internal */
@@ -4992,8 +5413,12 @@ export const makeSpanUnsafe = <XA, XE>(
   options: Tracer.SpanOptionsNoTrace | undefined
 ) => {
   const disablePropagation = !fiber.getRef(TracerEnabled) ||
-    (options?.annotations && ServiceMap.get(options.annotations, Tracer.DisablePropagation))
-  const parent = options?.parent ?? (options?.root ? undefined : filterDisablePropagation(fiber.currentSpan))
+    (options?.annotations && Context.get(options.annotations, Tracer.DisablePropagation))
+  const parent = options?.parent !== undefined
+    ? Option.some(options.parent)
+    : options?.root
+    ? Option.none<Tracer.AnySpan>()
+    : filterDisablePropagation(fiber.currentSpan)
 
   let span: Tracer.Span
 
@@ -5001,8 +5426,8 @@ export const makeSpanUnsafe = <XA, XE>(
     span = noopSpan({
       name,
       parent,
-      annotations: ServiceMap.add(
-        options?.annotations ?? ServiceMap.empty(),
+      annotations: Context.add(
+        options?.annotations ?? Context.empty(),
         Tracer.DisablePropagation,
         true
       )
@@ -5022,13 +5447,13 @@ export const makeSpanUnsafe = <XA, XE>(
     span = tracer.span({
       name,
       parent,
-      annotations: options?.annotations ?? ServiceMap.empty(),
+      annotations: options?.annotations ?? Context.empty(),
       links,
-      startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : 0n,
+      startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : BigInt(0),
       kind: options?.kind ?? "internal",
-      root: options?.root ?? options?.parent === undefined,
+      root: options?.root ?? Option.isNone(parent),
       sampled: options?.sampled ??
-        (parent?.sampled === false
+        (Option.isSome(parent) && parent.value.sampled === false
           ? false
           : !isLogLevelGreaterThan(fiber.getRef(Tracer.MinimumTraceLevel), level))
     })
@@ -5059,7 +5484,7 @@ export const makeSpanScoped = (
 ): Effect.Effect<Tracer.Span, never, Scope.Scope> =>
   uninterruptible(
     withFiber((fiber) => {
-      const scope = ServiceMap.getUnsafe(fiber.services, scopeTag)
+      const scope = Context.getUnsafe(fiber.context, scopeTag)
       const span = makeSpanUnsafe(fiber, name, options ?? {})
       const clock = fiber.getRef(ClockRef)
       const timingEnabled = fiber.getRef(TracerTimingEnabled)
@@ -5291,7 +5716,7 @@ export const currentParentSpan: Effect.Effect<Tracer.AnySpan, Cause.NoSuchElemen
 // ----------------------------------------------------------------------------
 
 /** @internal */
-export const ClockRef = ServiceMap.Reference<Clock.Clock>("effect/Clock", {
+export const ClockRef = Context.Reference<Clock.Clock>("effect/Clock", {
   defaultValue: (): Clock.Clock => new ClockImpl()
 })
 
@@ -5344,8 +5769,8 @@ export const clockWith = <A, E, R>(f: (clock: Clock.Clock) => Effect.Effect<A, E
   withFiber((fiber) => f(fiber.getRef(ClockRef)))
 
 /** @internal */
-export const sleep = (duration: Duration.DurationInput): Effect.Effect<void> =>
-  clockWith((clock) => clock.sleep(Duration.fromDurationInputUnsafe(duration)))
+export const sleep = (duration: Duration.Input): Effect.Effect<void> =>
+  clockWith((clock) => clock.sleep(Duration.fromInputUnsafe(duration)))
 
 /** @internal */
 export const currentTimeMillis: Effect.Effect<number> = clockWith((clock) => clock.currentTimeMillis)
@@ -5403,6 +5828,28 @@ export class ExceededCapacityError extends TaggedError("ExceededCapacityError")
   }
 }
 
+/** @internal */
+export const AsyncFiberErrorTypeId = "~effect/Cause/AsyncFiberError"
+
+/** @internal */
+export const isAsyncFiberError = (
+  u: unknown
+): u is Cause.AsyncFiberError => hasProperty(u, AsyncFiberErrorTypeId)
+
+/** @internal */
+export class AsyncFiberError extends TaggedError("AsyncFiberError")<{
+  fiber: Fiber.Fiber<unknown, unknown>
+  message: string
+}> {
+  readonly [AsyncFiberErrorTypeId] = AsyncFiberErrorTypeId
+  constructor(fiber: Fiber.Fiber<unknown, unknown>) {
+    super({
+      message: "An asynchronous Effect was executed with Effect.runSync",
+      fiber
+    })
+  }
+}
+
 /** @internal */
 export const UnknownErrorTypeId = "~effect/Cause/UnknownError"
 
@@ -5412,7 +5859,10 @@ export const isUnknownError = (
 ): u is Cause.UnknownError => hasProperty(u, UnknownErrorTypeId)
 
 /** @internal */
-export class UnknownError extends TaggedError("UnknownError") {
+export class UnknownError extends TaggedError("UnknownError")<{
+  cause: unknown
+  message?: string | undefined
+}> {
   readonly [UnknownErrorTypeId] = UnknownErrorTypeId
   constructor(cause: unknown, message?: string) {
     super({ message, cause } as any)
@@ -5424,7 +5874,7 @@ export class UnknownError extends TaggedError("UnknownError") {
 // ----------------------------------------------------------------------------
 
 /** @internal */
-export const ConsoleRef = ServiceMap.Reference<Console.Console>(
+export const ConsoleRef = Context.Reference<Console.Console>(
   "effect/Console/CurrentConsole",
   { defaultValue: (): Console.Console => globalThis.console }
 )
@@ -5466,17 +5916,51 @@ export const isLogLevelGreaterThan = Order.isGreaterThan(LogLevelOrder)
 // ----------------------------------------------------------------------------
 
 /** @internal */
-export const CurrentLoggers = ServiceMap.Reference<
+export const CurrentLoggers = Context.Reference<
   ReadonlySet<Logger.Logger<unknown, any>>
 >("effect/Loggers/CurrentLoggers", {
   defaultValue: () => new Set([defaultLogger, tracerLogger])
 })
 
 /** @internal */
-export const LogToStderr = ServiceMap.Reference<boolean>("effect/Logger/LogToStderr", {
+export const LogToStderr = Context.Reference<boolean>("effect/Logger/LogToStderr", {
   defaultValue: constFalse
 })
 
+/** @internal */
+export const annotateLogsScoped: {
+  (key: string, value: unknown): Effect.Effect<void, never, Scope.Scope>
+  (values: Record<string, unknown>): Effect.Effect<void, never, Scope.Scope>
+} = function() {
+  const entries = typeof arguments[0] === "string" ?
+    [[arguments[0], arguments[1]]] :
+    Object.entries(arguments[0])
+  return uninterruptible(withFiber((fiber) => {
+    const prev = fiber.getRef(CurrentLogAnnotations)
+    const next = { ...prev }
+    for (let i = 0; i < entries.length; i++) {
+      const [key, value] = entries[i]
+      next[key] = value
+    }
+    fiber.setContext(Context.add(fiber.context, CurrentLogAnnotations, next))
+    return scopeAddFinalizerExit(Context.getUnsafe(fiber.context, scopeTag), (_) => {
+      const current = fiber.getRef(CurrentLogAnnotations)
+      const next = { ...current }
+      for (let i = 0; i < entries.length; i++) {
+        const [key, value] = entries[i]
+        if (current[key] !== value) continue
+        if (key in prev) {
+          next[key] = prev[key]
+        } else {
+          delete next[key]
+        }
+      }
+      fiber.setContext(Context.add(fiber.context, CurrentLogAnnotations, next))
+      return void_
+    })
+  }))
+}
+
 /** @internal */
 export const LoggerTypeId = "~effect/Logger"
 
@@ -5492,7 +5976,7 @@ const LoggerProto = {
 
 /** @internal */
 export const loggerMake = <Message, Output>(
-  log: (options: Logger.Logger.Options<Message>) => Output
+  log: (options: Logger.Options<Message>) => Output
 ): Logger.Logger<Message, Output> => {
   const self = Object.create(LoggerProto)
   self.log = log
@@ -5532,7 +6016,7 @@ export const structuredMessage = (u: unknown): unknown => {
 }
 
 /** @internal */
-export const logWithLevel = (level?: LogLevel.LogLevel) =>
+export const logWithLevel = (level?: LogLevel.Severity) =>
 (
   ...message: ReadonlyArray<any>
 ): Effect.Effect<void> => {
@@ -5651,10 +6135,11 @@ const prettyLoggerTty = (options: {
   readonly formatDate: (date: Date) => string
 }) => {
   const processIsBun = typeof process === "object" && "isBun" in process && process.isBun === true
-  const color = options.colors && processStdoutIsTTY ? withColor : withColorNoop
+  const color = options.colors ? withColor : withColorNoop
   return loggerMake<unknown, void>(
     ({ cause, date, fiber, logLevel, message: message_ }) => {
       const console = fiber.getRef(ConsoleRef)
+      // oxlint-disable-next-line no-console
       const log = fiber.getRef(LogToStderr) ? console.error : console.log
 
       const message = Array.isArray(message_) ? message_.slice() : [message_]
@@ -5680,6 +6165,7 @@ const prettyLoggerTty = (options: {
       }
 
       log(firstLine)
+      // oxlint-disable-next-line no-console
       if (!processIsBun) console.group()
 
       if (cause.reasons.length > 0) {
@@ -5697,6 +6183,7 @@ const prettyLoggerTty = (options: {
         log(color(`${key}:`, colors.bold, colors.white), redact(value))
       }
 
+      // oxlint-disable-next-line no-console
       if (!processIsBun) console.groupEnd()
     }
   )
@@ -5743,14 +6230,17 @@ const prettyLoggerBrowser = (options: {
         }
       }
 
+      // oxlint-disable-next-line no-console
       console.groupCollapsed(firstLine, ...firstParams)
 
       if (cause.reasons.length > 0) {
+        // oxlint-disable-next-line no-console
         console.error(causePretty(cause))
       }
 
       if (messageIndex < message.length) {
         for (; messageIndex < message.length; messageIndex++) {
+          // oxlint-disable-next-line no-console
           console.log(redact(message[messageIndex]))
         }
       }
@@ -5759,12 +6249,15 @@ const prettyLoggerBrowser = (options: {
       for (const [key, value] of Object.entries(annotations)) {
         const redacted = redact(value)
         if (options.colors) {
+          // oxlint-disable-next-line no-console
           console.log(`%c${key}:`, "color:gray", redacted)
         } else {
+          // oxlint-disable-next-line no-console
           console.log(`${key}:`, redacted)
         }
       }
 
+      // oxlint-disable-next-line no-console
       console.groupEnd()
     }
   )
@@ -5774,7 +6267,7 @@ const prettyLoggerBrowser = (options: {
 export const defaultLogger = loggerMake<unknown, void>(({ cause, date, fiber, logLevel, message }) => {
   const message_ = Array.isArray(message) ? message.slice() : [message]
   if (cause.reasons.length > 0) {
-    message_.unshift(causePretty(cause))
+    message_.push(causePretty(cause))
   }
   const now = date.getTime()
   const spans = fiber.getRef(CurrentLogSpans)
@@ -5787,6 +6280,7 @@ export const defaultLogger = loggerMake<unknown, void>(({ cause, date, fiber, lo
     message_.push(annotations)
   }
   const console = fiber.getRef(ConsoleRef)
+  // oxlint-disable-next-line no-console
   const log = fiber.getRef(LogToStderr) ? console.error : console.log
   log(`[${defaultDateFormat(date)}] ${logLevel.toUpperCase()} (#${fiber.id})${spanString}:`, ...message_)
 })
@@ -5823,3 +6317,48 @@ const undefined_ = succeed(undefined)
 
 /** @internal */
 export { undefined_ as undefined }
+
+// ----------------------------------------------------------------------------
+// ErrorReporter
+// ----------------------------------------------------------------------------
+
+/** @internal */
+export const withErrorReporting: <
+  Arg extends Effect.Effect<any, any, any> | {
+    readonly defectsOnly?: boolean | undefined
+  } | undefined = {
+    readonly defectsOnly?: boolean | undefined
+  }
+>(
+  effectOrOptions: Arg,
+  options?: {
+    readonly defectsOnly?: boolean | undefined
+  } | undefined
+) => [Arg] extends [Effect.Effect<infer _A, infer _E, infer _R>] ? Arg
+  : <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R> = dual(
+    (args) => isEffect(args[0]),
+    <A, E, R>(
+      self: Effect.Effect<A, E, R>,
+      options?: {
+        readonly defectsOnly?: boolean | undefined
+      } | undefined
+    ): Effect.Effect<A, E, R> =>
+      onError(self, (cause) =>
+        withFiber((fiber) => {
+          reportCauseUnsafe(fiber, cause, options?.defectsOnly)
+          return void_
+        }))
+  )
+
+/** @internal */
+export const reportCauseUnsafe = (
+  fiber: Fiber.Fiber<unknown, unknown>,
+  cause: Cause.Cause<unknown>,
+  defectsOnly?: boolean
+) => {
+  const reporters = fiber.getRef(CurrentErrorReporters)
+  if (reporters.size === 0) return
+  if (defectsOnly && !hasDies(cause)) return
+  const opts = { cause, fiber, timestamp: fiber.getRef(ClockRef).currentTimeNanosUnsafe() }
+  reporters.forEach((reporter) => reporter.report(opts))
+}