effect 4.0.0-beta.42 → 4.0.0-beta.44

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";
@@ -14,7 +15,6 @@ import { hasProperty, isIterable, isString, isTagged } from "../Predicate.js";
 import { currentFiberTypeId, redact } from "../Redactable.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";
@@ -113,7 +113,7 @@ const emptySet = /*#__PURE__*/new Set();
 /** @internal */
 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) => {
@@ -324,9 +324,9 @@ const fiberIdStore = {
 export const getCurrentFiber = () => globalThis[currentFiberTypeId];
 /** @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;
@@ -350,8 +350,8 @@ export class FiberImpl {
   _children;
   _interruptedCause;
   _yielded;
-  // set in setServices
-  services;
+  // set in setContext
+  context;
   currentScheduler;
   currentTracerContext;
   currentSpan;
@@ -366,7 +366,7 @@ export class FiberImpl {
     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) {
@@ -387,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);
@@ -401,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) {
@@ -420,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);
     }
@@ -487,21 +487,21 @@ export class FiberImpl {
   pipe() {
     return pipeArguments(this, arguments);
   }
-  setServices(services) {
-    this.services = services;
+  setContext(context) {
+    this.context = context;
     const scheduler = this.getRef(Scheduler.Scheduler);
     if (scheduler !== this.currentScheduler) {
       this.currentScheduler = scheduler;
       this._dispatcher = undefined;
     }
-    this.currentSpan = services.mapUnsafe.get(Tracer.ParentSpanKey);
+    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.currentPreventYield = this.getRef(Scheduler.PreventSchedulerYield);
-    this.runtimeMetrics = services.mapUnsafe.get(InternalMetric.FiberRuntimeMetricsKey);
-    const currentTracer = services.mapUnsafe.get(Tracer.TracerKey);
+    this.runtimeMetrics = context.mapUnsafe.get(InternalMetric.FiberRuntimeMetricsKey);
+    const currentTracer = context.mapUnsafe.get(Tracer.TracerKey);
     this.currentTracerContext = currentTracer ? currentTracer["context"] : undefined;
   }
   get currentSpanLocal() {
@@ -515,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) {
@@ -594,7 +594,7 @@ export const fiberInterrupt = self => withFiber(fiber => fiberInterruptAs(self,
 /** @internal */
 export const fiberInterruptAs = /*#__PURE__*/dual(args => hasProperty(args[0], FiberTypeId), (self, fiberId, annotations) => withFiber(parent => {
   let ann = fiberStackAnnotations(parent);
-  ann = ann && annotations ? ServiceMap.merge(ann, annotations) : ann ?? annotations;
+  ann = ann && annotations ? Context.merge(ann, annotations) : ann ?? annotations;
   self.interruptUnsafe(fiberId, ann);
   return asVoid(fiberAwait(self));
 }));
@@ -1107,36 +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);
+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, () => {
-    fiber.setServices(prev);
+    fiber.setContext(prevContext);
     return undefined;
   });
 }));
 /** @internal */
-export const updateService = /*#__PURE__*/dual(3, (self, service, f) => updateServices(self, s => {
-  const prev = ServiceMap.getUnsafe(s, 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 s;
-  return ServiceMap.add(s, service, next);
+  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 () {
@@ -1145,10 +1145,10 @@ export const provideService = function () {
   }
   return dual(3, (self, service, impl) => provideServiceImpl(self, service, impl)).apply(this, arguments);
 };
-const provideServiceImpl = (self, service, implementation) => updateServices(self, s => {
+const provideServiceImpl = (self, service, implementation) => updateContext(self, s => {
   const prev = s.mapUnsafe.get(service.key);
   if (prev === implementation) return s;
-  return ServiceMap.add(s, service, implementation);
+  return Context.add(s, service, implementation);
 });
 /** @internal */
 export const provideServiceEffect = /*#__PURE__*/dual(3, (self, service, acquire) => flatMap(acquire, implementation => provideService(self, service, implementation)));
@@ -1468,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 */
@@ -1572,11 +1572,11 @@ export const scope = /*#__PURE__*/scopeTag.asEffect();
 export const provideScope = /*#__PURE__*/provideService(scopeTag);
 /** @internal */
 export const scoped = self => withFiber(fiber => {
-  const prev = fiber.services;
+  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(prev);
+    fiber.setContext(prev);
     return scopeCloseUnsafe(scope, exit);
   });
 });
@@ -1588,9 +1588,9 @@ export const scopedWith = f => suspend(() => {
   return onExit(f(scope), exit => suspend(() => scopeCloseUnsafe(scope, exit) ?? void_));
 });
 /** @internal */
-export const acquireRelease = (acquire, release, options) => servicesWith(services => uninterruptibleMask(restore => flatMap(scope, scope => tap(options?.interruptible ? restore(acquire) : acquire, a => scopeAddFinalizerExit(scope, exit => provideServices(release(a, exit), services))))));
+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",
@@ -1988,7 +1988,7 @@ 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 {
@@ -2036,8 +2036,8 @@ export const forkScoped = /*#__PURE__*/dual(args => isEffect(args[0]), (self, op
 // execution
 // ----------------------------------------------------------------------------
 /** @internal */
-export const runForkWith = services => (effect, options) => {
-  const fiber = new FiberImpl(options?.scheduler ? ServiceMap.add(services, Scheduler.Scheduler, options.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) {
@@ -2070,10 +2070,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) {
@@ -2085,10 +2085,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 => {
@@ -2097,10 +2097,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);
@@ -2109,10 +2109,10 @@ 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");
@@ -2124,10 +2124,10 @@ export const runSyncExitWith = services => {
   };
 };
 /** @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);
@@ -2135,7 +2135,7 @@ export const runSyncWith = services => {
   };
 };
 /** @internal */
-export const runSync = /*#__PURE__*/runSyncWith(/*#__PURE__*/ServiceMap.empty());
+export const runSync = /*#__PURE__*/runSyncWith(/*#__PURE__*/Context.empty());
 const succeedTrue = /*#__PURE__*/succeed(true);
 const succeedFalse = /*#__PURE__*/succeed(false);
 class Latch {
@@ -2232,18 +2232,18 @@ const NoopSpanProto = {
 export const noopSpan = options => Object.assign(Object.create(NoopSpanProto), options);
 const filterDisablePropagation = span => {
   if (!span) return Option.none();
-  return ServiceMap.get(span.annotations, Tracer.DisablePropagation) ? span._tag === "Span" ? filterDisablePropagation(Option.getOrUndefined(span.parent)) : Option.none() : Option.some(span);
+  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 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);
@@ -2256,7 +2256,7 @@ 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,
       kind: options?.kind ?? "internal",
@@ -2278,7 +2278,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);
@@ -2400,7 +2400,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;
@@ -2523,7 +2523,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
 });
 // ----------------------------------------------------------------------------
@@ -2558,11 +2558,11 @@ 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 */
@@ -2577,8 +2577,8 @@ export const annotateLogsScoped = function () {
       const [key, value] = entries[i];
       next[key] = value;
     }
-    fiber.setServices(ServiceMap.add(fiber.services, CurrentLogAnnotations, next));
-    return scopeAddFinalizerExit(ServiceMap.getUnsafe(fiber.services, scopeTag), _ => {
+    fiber.setContext(Context.add(fiber.context, CurrentLogAnnotations, next));
+    return scopeAddFinalizerExit(Context.getUnsafe(fiber.context, scopeTag), _ => {
       const current = fiber.getRef(CurrentLogAnnotations);
       const next = {
         ...current
@@ -2592,7 +2592,7 @@ export const annotateLogsScoped = function () {
           delete next[key];
         }
       }
-      fiber.setServices(ServiceMap.add(fiber.services, CurrentLogAnnotations, next));
+      fiber.setContext(Context.add(fiber.context, CurrentLogAnnotations, next));
       return void_;
     });
   }));