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

package/dist/internal/effect.js

@@ -1,4 +1,5 @@
 import * as Arr from "../Array.js";
+import * as Context from "../Context.js";
 import * as Duration from "../Duration.js";
 import * as Equal from "../Equal.js";
 import * as Filter from "../Filter.js";
@@ -12,15 +13,14 @@ import * as Order from "../Order.js";
 import { pipeArguments } from "../Pipeable.js";
 import { hasProperty, isIterable, isString, isTagged } from "../Predicate.js";
 import { currentFiberTypeId, redact } from "../Redactable.js";
-import { CurrentConcurrency, CurrentLogAnnotations, CurrentLogLevel, CurrentLogSpans, CurrentStackFrame, MinimumLogLevel, TracerEnabled, TracerSpanAnnotations, TracerSpanLinks, TracerTimingEnabled } from "../References.js";
 import * as Result from "../Result.js";
 import * as Scheduler from "../Scheduler.js";
-import * as ServiceMap from "../ServiceMap.js";
 import * as Tracer from "../Tracer.js";
 import { internalCall } from "../Utils.js";
-import { args, causeAnnotate, causeEmpty, causeFromReasons, CauseImpl, constEmptyAnnotations, contA, contAll, contE, Die, evaluate, exitDie, exitFail, exitFailCause, exitSucceed, ExitTypeId, Fail, InterruptorStackTrace, isCause, isDieReason, isEffect, isFailReason, isInterruptReason, isNoSuchElementError, makePrimitive, makePrimitiveProto, NoSuchElementError, ReasonBase, StackTraceKey as CauseStackTrace, TaggedError, withFiber, Yield } from "./core.js";
+import { args, causeAnnotate, causeEmpty, causeFromReasons, CauseImpl, constEmptyAnnotations, contA, contAll, contE, evaluate, exitDie, exitFail, exitFailCause, exitSucceed, ExitTypeId, Fail, InterruptorStackTrace, isCause, isDieReason, isEffect, isFailReason, isInterruptReason, isNoSuchElementError, makePrimitive, makePrimitiveProto, NoSuchElementError, ReasonBase, StackTraceKey as CauseStackTrace, TaggedError, withFiber, Yield } from "./core.js";
 import * as doNotation from "./doNotation.js";
 import * as InternalMetric from "./metric.js";
+import { CurrentConcurrency, CurrentErrorReporters, CurrentLogAnnotations, CurrentLogLevel, CurrentLogSpans, CurrentStackFrame, MinimumLogLevel, TracerEnabled, TracerSpanAnnotations, TracerSpanLinks, TracerTimingEnabled } from "./references.js";
 import { addSpanStackTrace, makeStackCleaner } from "./tracer.js";
 import { version } from "./version.js";
 // ----------------------------------------------------------------------------
@@ -111,9 +111,9 @@ export const causeInterruptors = self => {
 };
 const emptySet = /*#__PURE__*/new Set();
 /** @internal */
-export const hasInterruptsOnly = self => self.reasons.every(isInterruptReason);
+export const hasInterruptsOnly = self => self.reasons.length > 0 && self.reasons.every(isInterruptReason);
 /** @internal */
-export const reasonAnnotations = self => ServiceMap.makeUnsafe(self.annotations);
+export const reasonAnnotations = self => Context.makeUnsafe(self.annotations);
 /** @internal */
 export const causeAnnotations = self => {
   const map = new Map();
@@ -124,7 +124,7 @@ export const causeAnnotations = self => {
       }
     }
   }
-  return ServiceMap.makeUnsafe(map);
+  return Context.makeUnsafe(map);
 };
 /** @internal */
 export const causeCombine = /*#__PURE__*/dual(2, (self, that) => {
@@ -201,7 +201,8 @@ export const causePrettyErrors = self => {
   Error.stackTraceLimit = prevStackLimit;
   return errors;
 };
-const causePrettyError = (original, annotations) => {
+/** @internal */
+export const causePrettyError = (original, annotations) => {
   const kind = typeof original;
   let error;
   if (original && kind === "object") {
@@ -321,28 +322,11 @@ const fiberIdStore = {
 };
 /** @internal */
 export const getCurrentFiber = () => globalThis[currentFiberTypeId];
-const keepAlive = /*#__PURE__*/(() => {
-  let count = 0;
-  let running = 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 {
-  constructor(services, interruptible = true) {
+  constructor(context, interruptible = true) {
     this[FiberTypeId] = fiberVariance;
-    this.setServices(services);
+    this.setContext(context);
     this.id = ++fiberIdStore.id;
     this.currentOpCount = 0;
     this.currentLoopCount = 0;
@@ -366,8 +350,8 @@ export class FiberImpl {
   _children;
   _interruptedCause;
   _yielded;
-  // set in setServices
-  services;
+  // set in setContext
+  context;
   currentScheduler;
   currentTracerContext;
   currentSpan;
@@ -376,8 +360,13 @@ export class FiberImpl {
   currentStackFrame;
   runtimeMetrics;
   maxOpsBeforeYield;
+  currentPreventYield;
+  _dispatcher = undefined;
+  get currentDispatcher() {
+    return this._dispatcher ??= this.currentScheduler.makeDispatcher();
+  }
   getRef(ref) {
-    return ServiceMap.getReferenceUnsafe(this.services, ref);
+    return Context.getReferenceUnsafe(this.context, ref);
   }
   addObserver(cb) {
     if (this._exit) {
@@ -398,7 +387,7 @@ export class FiberImpl {
     }
     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);
@@ -412,7 +401,7 @@ export class FiberImpl {
     return this._exit;
   }
   evaluate(effect) {
-    this.runtimeMetrics?.recordFiberStart(this.services);
+    this.runtimeMetrics?.recordFiberStart(this.context);
     if (this._exit) {
       return;
     } else if (this._yielded !== undefined) {
@@ -431,7 +420,7 @@ export class FiberImpl {
       return this.evaluate(flatMap(interruptChildren, () => exit));
     }
     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);
     }
@@ -447,7 +436,7 @@ export class FiberImpl {
     try {
       while (true) {
         this.currentOpCount++;
-        if (!yielding && this.currentScheduler.shouldYield(this)) {
+        if (!yielding && !this.currentPreventYield && this.currentScheduler.shouldYield(this)) {
           yielding = true;
           const prev = current;
           current = flatMap(yieldNow, () => prev);
@@ -498,16 +487,21 @@ export class FiberImpl {
   pipe() {
     return pipeArguments(this, arguments);
   }
-  setServices(services) {
-    this.services = services;
-    this.currentScheduler = this.getRef(Scheduler.Scheduler);
-    this.currentSpan = services.mapUnsafe.get(Tracer.ParentSpanKey);
+  setContext(context) {
+    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() {
@@ -521,7 +515,7 @@ const fiberStackAnnotations = fiber => {
   if (!fiber.currentStackFrame) return undefined;
   const annotations = new Map();
   annotations.set(CauseStackTrace.key, fiber.currentStackFrame);
-  return ServiceMap.makeUnsafe(annotations);
+  return Context.makeUnsafe(annotations);
 };
 const fiberInterruptChildren = fiber => {
   if (fiber._children === undefined || fiber._children.size === 0) {
@@ -574,6 +568,7 @@ export const fiberJoin = self => {
 /** @internal */
 export const fiberJoinAll = self => callback(resume => {
   const fibers = Array.from(self);
+  if (fibers.length === 0) return resume(succeed(Arr.empty()));
   const out = new Array(fibers.length);
   const cancels = Arr.empty();
   let done = 0;
@@ -597,8 +592,10 @@ export const fiberJoinAll = self => callback(resume => {
 /** @internal */
 export const fiberInterrupt = self => withFiber(fiber => fiberInterruptAs(self, fiber.id));
 /** @internal */
-export const fiberInterruptAs = /*#__PURE__*/dual(2, (self, fiberId) => withFiber(parent => {
-  self.interruptUnsafe(fiberId, fiberStackAnnotations(parent));
+export const fiberInterruptAs = /*#__PURE__*/dual(args => hasProperty(args[0], FiberTypeId), (self, fiberId, annotations) => withFiber(parent => {
+  let ann = fiberStackAnnotations(parent);
+  ann = ann && annotations ? Context.merge(ann, annotations) : ann ?? annotations;
+  self.interruptUnsafe(fiberId, ann);
   return asVoid(fiberAwait(self));
 }));
 /** @internal */
@@ -650,7 +647,7 @@ export const yieldNowWith = /*#__PURE__*/makePrimitive({
   op: "Yield",
   [evaluate](fiber) {
     let resumed = false;
-    fiber.currentScheduler.scheduleTask(() => {
+    fiber.currentDispatcher.scheduleTask(() => {
       if (resumed) return;
       fiber.evaluate(exitVoid);
     }, this[args] ?? 0);
@@ -726,10 +723,8 @@ const callbackOptions = /*#__PURE__*/makePrimitive({
     }, controller?.signal);
     if (yielded !== false) return yielded;
     yielded = true;
-    keepAlive.increment();
     fiber._yielded = () => {
       resumed = true;
-      keepAlive.decrement();
     };
     if (controller === undefined && onCancel === undefined) {
       return Yield;
@@ -762,7 +757,7 @@ export const never = /*#__PURE__*/callback(constVoid);
 export const gen = (...args) => suspend(() => fromIteratorUnsafe(args.length === 1 ? args[0]() : args[1].call(args[0].self)));
 /** @internal */
 export const fnUntraced = (body, ...pipeables) => {
-  return pipeables.length === 0 ? function () {
+  const fn = pipeables.length === 0 ? function () {
     return suspend(() => fromIteratorUnsafe(body.apply(this, arguments)));
   } : function () {
     let effect = suspend(() => fromIteratorUnsafe(body.apply(this, arguments)));
@@ -771,7 +766,12 @@ export const fnUntraced = (body, ...pipeables) => {
     }
     return effect;
   };
+  return defineFunctionLength(body.length, fn);
 };
+const defineFunctionLength = (length, fn) => Object.defineProperty(fn, "length", {
+  value: length,
+  configurable: true
+});
 const fnStackCleaner = /*#__PURE__*/makeStackCleaner(2);
 /** @internal */
 export const fn = function () {
@@ -789,7 +789,7 @@ export const fn = function () {
 };
 const makeFn = (name, bodyOrOptions, defError, pipeables, addSpan, spanOptions) => {
   const body = typeof bodyOrOptions === "function" ? bodyOrOptions : pipeables.pop().bind(bodyOrOptions.self);
-  return function (...args) {
+  return defineFunctionLength(body.length, function (...args) {
     let result = suspend(() => {
       const iter = body.apply(this, arguments);
       return isEffect(iter) ? iter : fromIteratorUnsafe(iter);
@@ -813,10 +813,10 @@ const makeFn = (name, bodyOrOptions, defError, pipeables, addSpan, spanOptions)
         parent: prev
       }
     }));
-  };
+  });
 };
 /** @internal */
-export const fnUntracedEager = (body, ...pipeables) => pipeables.length === 0 ? function () {
+export const fnUntracedEager = (body, ...pipeables) => defineFunctionLength(body.length, pipeables.length === 0 ? function () {
   return fromIteratorEagerUnsafe(() => body.apply(this, arguments));
 } : function () {
   let effect = fromIteratorEagerUnsafe(() => body.apply(this, arguments));
@@ -824,7 +824,7 @@ export const fnUntracedEager = (body, ...pipeables) => pipeables.length === 0 ?
     effect = pipeable(effect);
   }
   return effect;
-};
+});
 const fromIteratorEagerUnsafe = evaluate => {
   try {
     const iterator = evaluate();
@@ -1107,52 +1107,36 @@ export const exitFindErrorOption = self => {
 /** @internal */
 export const service = fromYieldable;
 /** @internal */
-export const serviceOption = service => withFiber(fiber => succeed(ServiceMap.getOption(fiber.services, service)));
+export const serviceOption = service => withFiber(fiber => succeed(Context.getOption(fiber.context, service)));
 /** @internal */
-export const serviceOptional = service => withFiber(fiber => fiber.services.mapUnsafe.has(service.key) ? succeed(ServiceMap.getUnsafe(fiber.services, service)) : fail(new NoSuchElementError()));
+export const serviceOptional = service => withFiber(fiber => fiber.context.mapUnsafe.has(service.key) ? succeed(Context.getUnsafe(fiber.context, service)) : fail(new NoSuchElementError()));
 /** @internal */
-export const updateServices = /*#__PURE__*/dual(2, (self, f) => withFiber(fiber => {
-  const prev = fiber.services;
-  const nextServices = f(prev);
-  if (prev === nextServices) return self;
-  fiber.setServices(nextServices);
-  const newServices = new Map();
-  for (const [key, value] of fiber.services.mapUnsafe) {
-    if (!prev.mapUnsafe.has(key) || value !== prev.mapUnsafe.get(key)) {
-      newServices.set(key, value);
-    }
-  }
+export const updateContext = /*#__PURE__*/dual(2, (self, f) => withFiber(fiber => {
+  const prevContext = fiber.context;
+  const nextContext = f(prevContext);
+  if (prevContext === nextContext) return self;
+  fiber.setContext(nextContext);
   return onExitPrimitive(self, () => {
-    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));
+    fiber.setContext(prevContext);
     return undefined;
   });
 }));
 /** @internal */
-export const updateService = /*#__PURE__*/dual(3, (self, service, f) => withFiber(fiber => {
-  const prev = ServiceMap.getUnsafe(fiber.services, service);
+export const updateService = /*#__PURE__*/dual(3, (self, service, f) => 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 = () => getServiceMap;
-const getServiceMap = /*#__PURE__*/withFiber(fiber => succeed(fiber.services));
+export const context = () => getContext;
+const getContext = /*#__PURE__*/withFiber(fiber => succeed(fiber.context));
 /** @internal */
-export const servicesWith = f => withFiber(fiber => f(fiber.services));
+export const contextWith = f => withFiber(fiber => f(fiber.context));
 /** @internal */
-export const provideServices = /*#__PURE__*/dual(2, (self, services) => {
+export const provideContext = /*#__PURE__*/dual(2, (self, context) => {
   if (effectIsExit(self)) return self;
-  return updateServices(self, ServiceMap.merge(services));
+  return updateContext(self, Context.merge(context));
 });
 /** @internal */
 export const provideService = function () {
@@ -1161,11 +1145,10 @@ export const provideService = function () {
   }
   return dual(3, (self, service, impl) => provideServiceImpl(self, service, impl)).apply(this, arguments);
 };
-const provideServiceImpl = (self, service, implementation) => 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))));
+const provideServiceImpl = (self, service, implementation) => updateContext(self, s => {
+  const prev = s.mapUnsafe.get(service.key);
+  if (prev === implementation) return s;
+  return Context.add(s, service, implementation);
 });
 /** @internal */
 export const provideServiceEffect = /*#__PURE__*/dual(3, (self, service, acquire) => flatMap(acquire, implementation => provideService(self, service, implementation)));
@@ -1186,7 +1169,7 @@ export const zipWith = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that,
 // filtering & conditionals
 // ----------------------------------------------------------------------------
 /* @internal */
-export const filterOrFail = /*#__PURE__*/dual(args => isEffect(args[0]), (self, filter, orFailWith) => filterOrElse(self, filter, orFailWith ? a => fail(orFailWith(a)) : () => fail(new NoSuchElementError())));
+export const filterOrFail = /*#__PURE__*/dual(args => isEffect(args[0]), (self, predicate, orFailWith) => filterOrElse(self, predicate, orFailWith ? a => fail(orFailWith(a)) : () => fail(new NoSuchElementError())));
 /** @internal */
 export const when = /*#__PURE__*/dual(2, (self, condition) => flatMap(condition, pass => pass ? asSome(self) : succeedNone));
 // ----------------------------------------------------------------------------
@@ -1222,40 +1205,61 @@ const OnFailureProto = /*#__PURE__*/makePrimitiveProto({
   }
 });
 /** @internal */
-export const catchCauseIf = /*#__PURE__*/dual(3, (self, filter, f) => catchCause(self, cause => {
-  const eb = Filter.apply(filter, cause);
-  return !Result.isFailure(eb) ? internalCall(() => f(eb.success, cause)) : failCause(eb.failure);
+export const catchCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchCause(self, cause => {
+  if (!predicate(cause)) {
+    return failCause(cause);
+  }
+  return internalCall(() => f(cause));
 }));
 /** @internal */
-export const catch_ = /*#__PURE__*/dual(2, (self, f) => catchCauseIf(self, findError, e => f(e)));
+export const catchCauseFilter = /*#__PURE__*/dual(3, (self, filter, f) => catchCause(self, cause => {
+  const eb = filter(cause);
+  return Result.isFailure(eb) ? failCause(eb.failure) : internalCall(() => f(eb.success, cause));
+}));
+/** @internal */
+export const catch_ = /*#__PURE__*/dual(2, (self, f) => catchCauseFilter(self, findError, e => f(e)));
 /** @internal */
 export const catchNoSuchElement = self => matchEffect(self, {
   onFailure: error => isNoSuchElementError(error) ? succeedNone : fail(error),
   onSuccess: succeedSome
 });
 /** @internal */
-export const catchDefect = /*#__PURE__*/dual(2, (self, f) => catchCauseIf(self, findDefect, f));
+export const catchDefect = /*#__PURE__*/dual(2, (self, f) => catchCauseFilter(self, findDefect, f));
 /** @internal */
 export const tapCause = /*#__PURE__*/dual(2, (self, f) => catchCause(self, cause => andThen(internalCall(() => f(cause)), failCause(cause))));
 /** @internal */
-export const tapCauseIf = /*#__PURE__*/dual(3, (self, filter, f) => catchCauseIf(self, cause => {
-  const result = Filter.apply(filter, cause);
-  return Result.isFailure(result) ? Result.fail(cause) : result;
-}, (failure, cause) => andThen(internalCall(() => f(failure, cause)), failCause(cause))));
+export const tapCauseIf = /*#__PURE__*/dual(3, (self, predicate, f) => catchCauseIf(self, predicate, cause => andThen(internalCall(() => f(cause)), failCause(cause))));
 /** @internal */
-export const tapError = /*#__PURE__*/dual(2, (self, f) => tapCauseIf(self, findError, e => f(e)));
+export const tapCauseFilter = /*#__PURE__*/dual(3, (self, filter, f) => 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 = /*#__PURE__*/dual(2, (self, f) => tapCauseFilter(self, findError, e => f(e)));
 /** @internal */
 export const tapErrorTag = /*#__PURE__*/dual(3, (self, k, f) => {
   const predicate = Array.isArray(k) ? e => hasProperty(e, "_tag") && k.includes(e._tag) : isTagged(k);
   return tapError(self, error => predicate(error) ? f(error) : void_);
 });
 /** @internal */
-export const tapDefect = /*#__PURE__*/dual(2, (self, f) => tapCauseIf(self, findDefect, _ => f(_)));
+export const tapDefect = /*#__PURE__*/dual(2, (self, f) => tapCauseFilter(self, findDefect, _ => f(_)));
+/** @internal */
+export const catchIf = /*#__PURE__*/dual(args => isEffect(args[0]), (self, predicate, f, orElse) => catchCause(self, cause => {
+  const error = findError(cause);
+  if (Result.isFailure(error)) return failCause(error.failure);
+  if (!predicate(error.success)) {
+    return orElse ? internalCall(() => orElse(error.success)) : failCause(cause);
+  }
+  return internalCall(() => f(error.success));
+}));
 /** @internal */
-export const catchIf = /*#__PURE__*/dual(args => isEffect(args[0]), (self, filter, f, orElse) => catchCause(self, cause => {
+export const catchFilter = /*#__PURE__*/dual(args => isEffect(args[0]), (self, filter, f, orElse) => catchCause(self, cause => {
   const error = findError(cause);
   if (Result.isFailure(error)) return failCause(error.failure);
-  const result = Filter.apply(filter, error.success);
+  const result = filter(error.success);
   if (Result.isFailure(result)) {
     return orElse ? internalCall(() => orElse(result.failure)) : failCause(cause);
   }
@@ -1269,7 +1273,7 @@ export const catchTag = /*#__PURE__*/dual(args => isEffect(args[0]), (self, k, f
 /** @internal */
 export const catchTags = /*#__PURE__*/dual(args => isEffect(args[0]), (self, cases, orElse) => {
   let keys;
-  return catchIf(self, e => {
+  return catchFilter(self, e => {
     keys ??= Object.keys(cases);
     return hasProperty(e, "_tag") && isString(e["_tag"]) && keys.includes(e["_tag"]) ? Result.succeed(e) : Result.fail(e);
   }, e => internalCall(() => cases[e["_tag"]](e)), orElse);
@@ -1277,8 +1281,8 @@ export const catchTags = /*#__PURE__*/dual(args => isEffect(args[0]), (self, cas
 /** @internal */
 export const catchReason = /*#__PURE__*/dual(args => isEffect(args[0]), (self, errorTag, reasonTag, f, orElse) => catchIf(self, e => isTagged(e, errorTag) && hasProperty(e, "reason"), e => {
   const reason = e.reason;
-  if (isTagged(reason, reasonTag)) return f(reason);
-  return orElse ? internalCall(() => orElse(reason)) : fail(e);
+  if (isTagged(reason, reasonTag)) return f(reason, e);
+  return orElse ? internalCall(() => orElse(reason, e)) : fail(e);
 }));
 /** @internal */
 export const catchReasons = /*#__PURE__*/dual(args => isEffect(args[0]), (self, errorTag, cases, orElse) => {
@@ -1287,13 +1291,13 @@ export const catchReasons = /*#__PURE__*/dual(args => isEffect(args[0]), (self,
     const reason = e.reason;
     keys ??= Object.keys(cases);
     if (keys.includes(reason._tag)) {
-      return internalCall(() => cases[reason._tag](reason));
+      return internalCall(() => cases[reason._tag](reason, e));
     }
-    return orElse ? internalCall(() => orElse(reason)) : fail(e);
+    return orElse ? internalCall(() => orElse(reason, e)) : fail(e);
   });
 });
 /** @internal */
-export const unwrapReason = /*#__PURE__*/dual(2, (self, errorTag) => catchIf(self, e => {
+export const unwrapReason = /*#__PURE__*/dual(2, (self, errorTag) => catchFilter(self, e => {
   if (isTagged(e, errorTag) && hasProperty(e, "reason")) {
     return Result.succeed(e.reason);
   }
@@ -1326,7 +1330,7 @@ export const ignore = /*#__PURE__*/dual(args => isEffect(args[0]), (self, option
   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_
   });
@@ -1341,7 +1345,7 @@ export const ignoreCause = /*#__PURE__*/dual(args => isEffect(args[0]), (self, o
   }
   const logEffect = logWithLevel(options.log === true ? undefined : options.log);
   return matchCauseEffect(self, {
-    onFailure: logEffect,
+    onFailure: cause => options.message === undefined ? logEffect(cause) : logEffect(options.message, cause),
     onSuccess: _ => void_
   });
 });
@@ -1443,11 +1447,11 @@ export const isSuccess = /*#__PURE__*/matchEager({
 /** @internal */
 export const delay = /*#__PURE__*/dual(2, (self, duration) => andThen(sleep(duration), self));
 /** @internal */
-export const timeoutOrElse = /*#__PURE__*/dual(2, (self, options) => raceFirst(self, flatMap(sleep(options.duration), options.onTimeout)));
+export const timeoutOrElse = /*#__PURE__*/dual(2, (self, options) => raceFirst(self, flatMap(sleep(options.duration), options.orElse)));
 /** @internal */
 export const timeout = /*#__PURE__*/dual(2, (self, duration) => timeoutOrElse(self, {
   duration,
-  onTimeout: () => fail(new TimeoutError())
+  orElse: () => fail(new TimeoutError())
 }));
 /** @internal */
 export const timeoutOption = /*#__PURE__*/dual(2, (self, duration) => raceFirst(asSome(self), as(sleep(duration), Option.none())));
@@ -1464,7 +1468,7 @@ export const ScopeTypeId = "~effect/Scope";
 /** @internal */
 export const ScopeCloseableTypeId = "~effect/Scope/Closeable";
 /** @internal */
-export const scopeTag = /*#__PURE__*/ServiceMap.Service("effect/Scope");
+export const scopeTag = /*#__PURE__*/Context.Service("effect/Scope");
 /** @internal */
 export const scopeClose = (self, exit_) => suspend(() => scopeCloseUnsafe(self, exit_) ?? void_);
 /** @internal */
@@ -1568,11 +1572,11 @@ export const scope = /*#__PURE__*/scopeTag.asEffect();
 export const provideScope = /*#__PURE__*/provideService(scopeTag);
 /** @internal */
 export const scoped = self => 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);
   });
 });
@@ -1584,9 +1588,9 @@ export const scopedWith = f => suspend(() => {
   return onExit(f(scope), exit => suspend(() => scopeCloseUnsafe(scope, exit) ?? void_));
 });
 /** @internal */
-export const acquireRelease = (acquire, release) => uninterruptible(flatMap(scope, scope => tap(acquire, a => scopeAddFinalizerExit(scope, exit => internalCall(() => release(a, exit))))));
+export const acquireRelease = (acquire, release, options) => contextWith(context => uninterruptibleMask(restore => flatMap(scope, scope => tap(options?.interruptible ? restore(acquire) : acquire, a => scopeAddFinalizerExit(scope, exit => provideContext(release(a, exit), context))))));
 /** @internal */
-export const addFinalizer = finalizer => flatMap(scope, scope => servicesWith(services => scopeAddFinalizerExit(scope, exit => provideServices(finalizer(exit), services))));
+export const addFinalizer = finalizer => flatMap(scope, scope => contextWith(context => scopeAddFinalizerExit(scope, exit => provideContext(finalizer(exit), context))));
 /** @internal */
 export const onExitPrimitive = /*#__PURE__*/makePrimitive({
   op: "OnExit",
@@ -1617,19 +1621,36 @@ export const onExit = /*#__PURE__*/dual(2, onExitPrimitive);
 /** @internal */
 export const ensuring = /*#__PURE__*/dual(2, (self, finalizer) => onExit(self, _ => finalizer));
 /** @internal */
-export const onExitIf = /*#__PURE__*/dual(3, (self, filter, f) => onExit(self, exit => {
-  const pass = Filter.apply(filter, exit);
-  return Result.isFailure(pass) ? void_ : f(pass.success, exit);
+export const onExitIf = /*#__PURE__*/dual(3, (self, predicate, f) => onExit(self, exit => {
+  if (!predicate(exit)) {
+    return void_;
+  }
+  return f(exit);
+}));
+/** @internal */
+export const onExitFilter = /*#__PURE__*/dual(3, (self, filter, f) => onExit(self, exit => {
+  const b = filter(exit);
+  return Result.isFailure(b) ? void_ : f(b.success, exit);
 }));
 /** @internal */
-export const onError = /*#__PURE__*/dual(2, (self, f) => onExitIf(self, exitFilterCause, f));
+export const onError = /*#__PURE__*/dual(2, (self, f) => onExitFilter(self, exitFilterCause, f));
 /** @internal */
-export const onErrorIf = /*#__PURE__*/dual(3, (self, filter, f) => onExitIf(self, exit => {
-  if (exit._tag !== "Failure") return Result.fail(exit);
-  return Filter.apply(filter, exit.cause);
-}, (eb, exit) => f(eb, exit.cause)));
+export const onErrorIf = /*#__PURE__*/dual(3, (self, predicate, f) => onExitIf(self, exit => {
+  if (exit._tag !== "Failure") {
+    return false;
+  }
+  return predicate(exit.cause);
+}, exit => f(exit.cause)));
+/** @internal */
+export const onErrorFilter = /*#__PURE__*/dual(3, (self, filter, f) => 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 = /*#__PURE__*/dual(2, (self, finalizer) => onErrorIf(causeFilterInterruptors, finalizer)(self));
+export const onInterrupt = /*#__PURE__*/dual(2, (self, finalizer) => onErrorFilter(causeFilterInterruptors, finalizer)(self));
 /** @internal */
 export const acquireUseRelease = (acquire, use, release) => uninterruptibleMask(restore => flatMap(acquire, a => onExitPrimitive(restore(use(a)), exit => release(a, exit), true)));
 // ----------------------------------------------------------------------------
@@ -1637,7 +1658,7 @@ export const acquireUseRelease = (acquire, use, release) => uninterruptibleMask(
 // ----------------------------------------------------------------------------
 /** @internal */
 export const cachedInvalidateWithTTL = /*#__PURE__*/dual(2, (self, ttl) => 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;
@@ -1645,14 +1666,15 @@ export const cachedInvalidateWithTTL = /*#__PURE__*/dual(2, (self, ttl) => sync(
   let exit;
   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();
     exit = undefined;
     return onExit(self, exit_ => sync(() => {
       running = false;
-      expiresAt = now + ttlMillis;
+      expiresAt = clock.currentTimeMillisUnsafe() + ttlMillis;
       exit = exit_;
       latch.openUnsafe();
     }));
@@ -1732,7 +1754,54 @@ export const all = (arg, options) => {
   });
 };
 /** @internal */
-export const partition = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, f, options) => map(forEach(elements, (a, i) => result(f(a, i)), options), results => Arr.partitionMap(results, identity)));
+export const partition = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, f, options) => map(forEach(elements, (a, i) => result(f(a, i)), options), results => Arr.partition(results, identity)));
+/** @internal */
+export const validate = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, f, options) => 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 = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, predicate) => 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 = (iterator, index, predicate, value) => 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 = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, filter) => 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 = (iterator, index, filter, value) => 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 = /*#__PURE__*/makePrimitive({
   op: "While",
@@ -1765,70 +1834,13 @@ export const forEach = /*#__PURE__*/dual(args => typeof args[1] === "function",
     return options?.discard ? void_ : succeed([]);
   }
   const out = options?.discard ? undefined : new Array(length);
-  let index = 0;
-  const annotations = fiberStackAnnotations(parent);
-  return callback(resume => {
-    const fibers = new Set();
-    const failures = [];
-    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) : succeed(out);
 }));
 const forEachSequential = (iterable, f, options) => suspend(() => {
   const out = options?.discard ? undefined : [];
@@ -1844,31 +1856,151 @@ const forEachSequential = (iterable, f, options) => suspend(() => {
     }
   }), out);
 });
+const iterateEagerImpl = options => {
+  const onItem = options.onItem;
+  const step = options.step;
+  return (state, items, opts) => {
+    let index = opts?.start ?? 0;
+    const end = opts?.end ?? items.length;
+    const concurrency = opts?.concurrency ?? 1;
+    let done = false;
+    let parentFiber;
+    let fibers;
+    let resume;
+    let interrupted = false;
+    let terminal;
+    let effect;
+    const go = () => {
+      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.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 = () => iterateEagerImpl;
+const forEachConcurrent = /*#__PURE__*/iterateEagerImpl({
+  onItem(state, 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 = /*#__PURE__*/dual(3, (self, filter, orElse) => flatMap(self, a => {
-  const result = Filter.apply(filter, a);
+export const filterOrElse = /*#__PURE__*/dual(3, (self, predicate, orElse) => flatMap(self, a => predicate(a) ? succeed(a) : orElse(a)));
+/** @internal */
+export const filterMapOrElse = /*#__PURE__*/dual(3, (self, filter, orElse) => flatMap(self, a => {
+  const result = filter(a);
   return Result.isFailure(result) ? orElse(result.failure) : succeed(result.success);
 }));
+/* @internal */
+export const filterMapOrFail = /*#__PURE__*/dual(args => isEffect(args[0]), (self, filter, orFailWith) => filterMapOrElse(self, filter, orFailWith ? x => fail(orFailWith(x)) : () => fail(new NoSuchElementError())));
 /** @internal */
-export const filter = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, filter, options) => suspend(() => {
+export const filter = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, predicate, options) => suspend(() => {
   const out = [];
   return as(forEach(elements, (a, i) => {
-    const result = filter(a, i);
+    const result = predicate(a, i);
     if (typeof result === "boolean") {
       if (result) out.push(a);
       return void_;
     }
-    if (!isEffect(result)) {
-      if (!Result.isFailure(result)) {
-        out.push(result.success);
-      }
-      return void_;
-    }
-    return map(result, r => {
-      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);
       }
     });
   }, {
@@ -1876,6 +2008,29 @@ export const filter = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect
     concurrency: options?.concurrency
   }), out);
 }));
+/** @internal */
+export const filterMap = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, filter) => suspend(() => {
+  const out = [];
+  for (const a of elements) {
+    const result = filter(a);
+    if (Result.isSuccess(result)) {
+      out.push(result.success);
+    }
+  }
+  return succeed(out);
+}));
+/** @internal */
+export const filterMapEffect = /*#__PURE__*/dual(args => isIterable(args[0]) && !isEffect(args[0]), (elements, filter, options) => suspend(() => {
+  const out = [];
+  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
 // ----------------------------------------------------------------------------
@@ -1900,11 +2055,11 @@ export const forkChild = /*#__PURE__*/dual(args => isEffect(args[0]), (self, opt
 /** @internal */
 export const forkUnsafe = (parent, effect, immediate = false, daemon = false, uninterruptible = false) => {
   const interruptible = uninterruptible === "inherit" ? parent.interruptible : !uninterruptible;
-  const child = new FiberImpl(parent.services, interruptible);
+  const child = new FiberImpl(parent.context, interruptible);
   if (immediate) {
     child.evaluate(effect);
   } else {
-    parent.currentScheduler.scheduleTask(() => child.evaluate(effect), 0);
+    parent.currentDispatcher.scheduleTask(() => child.evaluate(effect), 0);
   }
   if (!daemon && !child._exit) {
     parent.children().add(child);
@@ -1948,9 +2103,8 @@ export const forkScoped = /*#__PURE__*/dual(args => isEffect(args[0]), (self, op
 // execution
 // ----------------------------------------------------------------------------
 /** @internal */
-export const runForkWith = services => (effect, options) => {
-  const scheduler = options?.scheduler || !services.mapUnsafe.has(Scheduler.Scheduler.key) && new Scheduler.MixedScheduler();
-  const fiber = new FiberImpl(scheduler ? ServiceMap.add(services, Scheduler.Scheduler, scheduler) : services, options?.uninterruptible !== true);
+export const runForkWith = context => (effect, options) => {
+  const fiber = new FiberImpl(options?.scheduler ? Context.add(context, Scheduler.Scheduler, options.scheduler) : context, options?.uninterruptible !== true);
   fiber.evaluate(effect);
   if (fiber._exit) return fiber;
   if (options?.signal) {
@@ -1964,6 +2118,9 @@ export const runForkWith = services => (effect, options) => {
       fiber.addObserver(() => options.signal.removeEventListener("abort", abort));
     }
   }
+  if (options?.onFiberStart) {
+    options.onFiberStart(fiber);
+  }
   return fiber;
 };
 /** @internal */
@@ -1980,10 +2137,10 @@ export const fiberRunIn = /*#__PURE__*/dual(2, (self, scope) => {
   return self;
 });
 /** @internal */
-export const runFork = /*#__PURE__*/runForkWith(/*#__PURE__*/ServiceMap.empty());
+export const runFork = /*#__PURE__*/runForkWith(/*#__PURE__*/Context.empty());
 /** @internal */
-export const runCallbackWith = services => {
-  const runFork = runForkWith(services);
+export const runCallbackWith = context => {
+  const runFork = runForkWith(context);
   return (effect, options) => {
     const fiber = runFork(effect, options);
     if (options?.onExit) {
@@ -1995,10 +2152,10 @@ export const runCallbackWith = services => {
   };
 };
 /** @internal */
-export const runCallback = /*#__PURE__*/runCallbackWith(/*#__PURE__*/ServiceMap.empty());
+export const runCallback = /*#__PURE__*/runCallbackWith(/*#__PURE__*/Context.empty());
 /** @internal */
-export const runPromiseExitWith = services => {
-  const runFork = runForkWith(services);
+export const runPromiseExitWith = context => {
+  const runFork = runForkWith(context);
   return (effect, options) => {
     const fiber = runFork(effect, options);
     return new Promise(resolve => {
@@ -2007,10 +2164,10 @@ export const runPromiseExitWith = services => {
   };
 };
 /** @internal */
-export const runPromiseExit = /*#__PURE__*/runPromiseExitWith(/*#__PURE__*/ServiceMap.empty());
+export const runPromiseExit = /*#__PURE__*/runPromiseExitWith(/*#__PURE__*/Context.empty());
 /** @internal */
-export const runPromiseWith = services => {
-  const runPromiseExit = runPromiseExitWith(services);
+export const runPromiseWith = context => {
+  const runPromiseExit = runPromiseExitWith(context);
   return (effect, options) => runPromiseExit(effect, options).then(exit => {
     if (exit._tag === "Failure") {
       throw causeSquash(exit.cause);
@@ -2019,25 +2176,25 @@ export const runPromiseWith = services => {
   });
 };
 /** @internal */
-export const runPromise = /*#__PURE__*/runPromiseWith(/*#__PURE__*/ServiceMap.empty());
+export const runPromise = /*#__PURE__*/runPromiseWith(/*#__PURE__*/Context.empty());
 /** @internal */
-export const runSyncExitWith = services => {
-  const runFork = runForkWith(services);
+export const runSyncExitWith = context => {
+  const runFork = runForkWith(context);
   return effect => {
     if (effectIsExit(effect)) return effect;
     const scheduler = new Scheduler.MixedScheduler("sync");
     const fiber = runFork(effect, {
       scheduler
     });
-    scheduler.flush();
-    return fiber._exit ?? exitDie(fiber);
+    fiber.currentDispatcher?.flush();
+    return fiber._exit ?? exitDie(new AsyncFiberError(fiber));
   };
 };
 /** @internal */
-export const runSyncExit = /*#__PURE__*/runSyncExitWith(/*#__PURE__*/ServiceMap.empty());
+export const runSyncExit = /*#__PURE__*/runSyncExitWith(/*#__PURE__*/Context.empty());
 /** @internal */
-export const runSyncWith = services => {
-  const runSyncExit = runSyncExitWith(services);
+export const runSyncWith = context => {
+  const runSyncExit = runSyncExitWith(context);
   return effect => {
     const exit = runSyncExit(effect);
     if (exit._tag === "Failure") throw causeSquash(exit.cause);
@@ -2045,79 +2202,7 @@ export const runSyncWith = services => {
   };
 };
 /** @internal */
-export const runSync = /*#__PURE__*/runSyncWith(/*#__PURE__*/ServiceMap.empty());
-// ----------------------------------------------------------------------------
-// Semaphore
-// ----------------------------------------------------------------------------
-/** @internal */
-class Semaphore {
-  waiters = /*#__PURE__*/new Set();
-  taken = 0;
-  permits;
-  constructor(permits) {
-    this.permits = permits;
-  }
-  get free() {
-    return this.permits - this.taken;
-  }
-  take = n => callback(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, f) {
-    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) {
-    return withFiber(fiber => this.updateTakenUnsafe(fiber, f));
-  }
-  resize = permits => asVoid(withFiber(fiber => {
-    this.permits = permits;
-    if (this.free < 0) {
-      return void_;
-    }
-    return this.updateTakenUnsafe(fiber, taken => taken);
-  }));
-  release = n => this.updateTaken(taken => taken - n);
-  releaseAll = /*#__PURE__*/this.updateTaken(_ => 0);
-  withPermits = n => self => uninterruptibleMask(restore => flatMap(restore(this.take(n)), permits => ensuring(restore(self), this.release(permits))));
-  withPermit = /*#__PURE__*/this.withPermits(1);
-  withPermitsIfAvailable = n => self => 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 => new Semaphore(permits);
-/** @internal */
-export const makeSemaphore = permits => sync(() => makeSemaphoreUnsafe(permits));
+export const runSync = /*#__PURE__*/runSyncWith(/*#__PURE__*/Context.empty());
 const succeedTrue = /*#__PURE__*/succeed(true);
 const succeedFalse = /*#__PURE__*/succeed(false);
 class Latch {
@@ -2132,7 +2217,7 @@ class Latch {
       return succeedTrue;
     }
     this.scheduled = true;
-    fiber.currentScheduler.scheduleTask(this.flushWaiters, 0);
+    fiber.currentDispatcher.scheduleTask(this.flushWaiters, 0);
     return succeedTrue;
   }
   flushWaiters = () => {
@@ -2173,7 +2258,7 @@ class Latch {
     return true;
   }
   close = /*#__PURE__*/sync(() => this.closeUnsafe());
-  whenOpen = self => andThen(this.await, self);
+  whenOpen = self => flatMap(this.await, () => self);
 }
 /** @internal */
 export const makeLatchUnsafe = open => new Latch(open ?? false);
@@ -2213,20 +2298,19 @@ const NoopSpanProto = {
 /** @internal */
 export const noopSpan = options => Object.assign(Object.create(NoopSpanProto), options);
 const filterDisablePropagation = span => {
-  if (span) {
-    return ServiceMap.get(span.annotations, Tracer.DisablePropagation) ? span._tag === "Span" ? filterDisablePropagation(span.parent) : undefined : span;
-  }
+  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 */
 export const makeSpanUnsafe = (fiber, name, options) => {
-  const disablePropagation = !fiber.getRef(TracerEnabled) || options?.annotations && ServiceMap.get(options.annotations, Tracer.DisablePropagation);
-  const parent = options?.parent ?? (options?.root ? undefined : filterDisablePropagation(fiber.currentSpan));
+  const disablePropagation = !fiber.getRef(TracerEnabled) || options?.annotations && Context.get(options.annotations, Tracer.DisablePropagation);
+  const parent = options?.parent !== undefined ? Option.some(options.parent) : options?.root ? Option.none() : filterDisablePropagation(fiber.currentSpan);
   let span;
   if (disablePropagation) {
     span = noopSpan({
       name,
       parent,
-      annotations: ServiceMap.add(options?.annotations ?? ServiceMap.empty(), Tracer.DisablePropagation, true)
+      annotations: Context.add(options?.annotations ?? Context.empty(), Tracer.DisablePropagation, true)
     });
   } else {
     const tracer = fiber.getRef(Tracer.Tracer);
@@ -2239,12 +2323,12 @@ export const makeSpanUnsafe = (fiber, name, options) => {
     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,
-      sampled: options?.sampled ?? (parent?.sampled === false ? false : !isLogLevelGreaterThan(fiber.getRef(Tracer.MinimumTraceLevel), level))
+      root: options?.root ?? Option.isNone(parent),
+      sampled: options?.sampled ?? (Option.isSome(parent) && parent.value.sampled === false ? false : !isLogLevelGreaterThan(fiber.getRef(Tracer.MinimumTraceLevel), level))
     });
     for (const [key, value] of Object.entries(annotationsFromEnv)) {
       span.attribute(key, value);
@@ -2261,7 +2345,7 @@ export const makeSpanUnsafe = (fiber, name, options) => {
 export const makeSpan = (name, options) => withFiber(fiber => succeed(makeSpanUnsafe(fiber, name, options)));
 /** @internal */
 export const makeSpanScoped = (name, options) => 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);
@@ -2383,7 +2467,7 @@ export const currentParentSpan = /*#__PURE__*/serviceOptional(Tracer.ParentSpan)
 // Clock
 // ----------------------------------------------------------------------------
 /** @internal */
-export const ClockRef = /*#__PURE__*/ServiceMap.Reference("effect/Clock", {
+export const ClockRef = /*#__PURE__*/Context.Reference("effect/Clock", {
   defaultValue: () => new ClockImpl()
 });
 const MAX_TIMER_MILLIS = 2 ** 31 - 1;
@@ -2427,7 +2511,7 @@ const processOrPerformanceNow = /*#__PURE__*/function () {
 /** @internal */
 export const clockWith = f => withFiber(fiber => f(fiber.getRef(ClockRef)));
 /** @internal */
-export const sleep = duration => clockWith(clock => clock.sleep(Duration.fromDurationInputUnsafe(duration)));
+export const sleep = duration => clockWith(clock => clock.sleep(Duration.fromInputUnsafe(duration)));
 /** @internal */
 export const currentTimeMillis = /*#__PURE__*/clockWith(clock => clock.currentTimeMillis);
 /** @internal */
@@ -2475,6 +2559,20 @@ export class ExceededCapacityError extends /*#__PURE__*/TaggedError("ExceededCap
   }
 }
 /** @internal */
+export const AsyncFiberErrorTypeId = "~effect/Cause/AsyncFiberError";
+/** @internal */
+export const isAsyncFiberError = u => hasProperty(u, AsyncFiberErrorTypeId);
+/** @internal */
+export class AsyncFiberError extends /*#__PURE__*/TaggedError("AsyncFiberError") {
+  [AsyncFiberErrorTypeId] = AsyncFiberErrorTypeId;
+  constructor(fiber) {
+    super({
+      message: "An asynchronous Effect was executed with Effect.runSync",
+      fiber
+    });
+  }
+}
+/** @internal */
 export const UnknownErrorTypeId = "~effect/Cause/UnknownError";
 /** @internal */
 export const isUnknownError = u => hasProperty(u, UnknownErrorTypeId);
@@ -2492,7 +2590,7 @@ export class UnknownError extends /*#__PURE__*/TaggedError("UnknownError") {
 // Console
 // ----------------------------------------------------------------------------
 /** @internal */
-export const ConsoleRef = /*#__PURE__*/ServiceMap.Reference("effect/Console/CurrentConsole", {
+export const ConsoleRef = /*#__PURE__*/Context.Reference("effect/Console/CurrentConsole", {
   defaultValue: () => globalThis.console
 });
 // ----------------------------------------------------------------------------
@@ -2527,14 +2625,46 @@ export const isLogLevelGreaterThan = /*#__PURE__*/Order.isGreaterThan(LogLevelOr
 // Logger
 // ----------------------------------------------------------------------------
 /** @internal */
-export const CurrentLoggers = /*#__PURE__*/ServiceMap.Reference("effect/Loggers/CurrentLoggers", {
+export const CurrentLoggers = /*#__PURE__*/Context.Reference("effect/Loggers/CurrentLoggers", {
   defaultValue: () => new Set([defaultLogger, tracerLogger])
 });
 /** @internal */
-export const LogToStderr = /*#__PURE__*/ServiceMap.Reference("effect/Logger/LogToStderr", {
+export const LogToStderr = /*#__PURE__*/Context.Reference("effect/Logger/LogToStderr", {
   defaultValue: constFalse
 });
 /** @internal */
+export const annotateLogsScoped = 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";
 const LoggerProto = {
   [LoggerTypeId]: {
@@ -2684,7 +2814,7 @@ export const consolePretty = options => {
 };
 const prettyLoggerTty = options => {
   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(({
     cause,
     date,
@@ -2693,6 +2823,7 @@ const prettyLoggerTty = options => {
     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_];
     let firstLine = color(`[${options.formatDate(date)}]`, colors.white) + ` ${color(logLevel.toUpperCase(), ...logLevelColors[logLevel])}` + ` (#${fiber.id})`;
@@ -2711,6 +2842,7 @@ const prettyLoggerTty = options => {
       }
     }
     log(firstLine);
+    // oxlint-disable-next-line no-console
     if (!processIsBun) console.group();
     if (cause.reasons.length > 0) {
       log(causePretty(cause));
@@ -2724,6 +2856,7 @@ const prettyLoggerTty = options => {
     for (const [key, value] of Object.entries(annotations)) {
       log(color(`${key}:`, colors.bold, colors.white), redact(value));
     }
+    // oxlint-disable-next-line no-console
     if (!processIsBun) console.groupEnd();
   });
 };
@@ -2764,12 +2897,15 @@ const prettyLoggerBrowser = options => {
         messageIndex++;
       }
     }
+    // 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]));
       }
     }
@@ -2777,11 +2913,14 @@ 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();
   });
 };
@@ -2795,7 +2934,7 @@ export const defaultLogger = /*#__PURE__*/loggerMake(({
 }) => {
   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);
@@ -2808,6 +2947,7 @@ export const defaultLogger = /*#__PURE__*/loggerMake(({
     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_);
 });
@@ -2841,4 +2981,24 @@ export function interruptChildrenPatch() {
 const undefined_ = /*#__PURE__*/succeed(undefined);
 /** @internal */
 export { undefined_ as undefined };
+// ----------------------------------------------------------------------------
+// ErrorReporter
+// ----------------------------------------------------------------------------
+/** @internal */
+export const withErrorReporting = /*#__PURE__*/dual(args => isEffect(args[0]), (self, options) => onError(self, cause => withFiber(fiber => {
+  reportCauseUnsafe(fiber, cause, options?.defectsOnly);
+  return void_;
+})));
+/** @internal */
+export const reportCauseUnsafe = (fiber, cause, defectsOnly) => {
+  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));
+};
 //# sourceMappingURL=effect.js.map