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

package/src/Metric.ts

@@ -138,6 +138,7 @@
  */
 
 import * as Arr from "./Array.ts"
+import * as Context from "./Context.ts"
 import * as Duration from "./Duration.ts"
 import type { Effect } from "./Effect.ts"
 import type { Exit } from "./Exit.ts"
@@ -149,7 +150,6 @@ import * as Order from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import * as _String from "./String.ts"
 import type { Contravariant, Covariant } from "./Types.ts"
 
@@ -235,9 +235,9 @@ export interface Metric<in Input, out State> extends Pipeable {
   readonly type: Metric.Type
   readonly description: string | undefined
   readonly attributes: Metric.AttributeSet | undefined
-  readonly valueUnsafe: (context: ServiceMap.ServiceMap<never>) => State
-  readonly updateUnsafe: (input: Input, context: ServiceMap.ServiceMap<never>) => void
-  readonly modifyUnsafe: (input: Input, context: ServiceMap.ServiceMap<never>) => void
+  readonly valueUnsafe: (context: Context.Context<never>) => State
+  readonly updateUnsafe: (input: Input, context: Context.Context<never>) => void
+  readonly modifyUnsafe: (input: Input, context: Context.Context<never>) => void
 }
 
 /**
@@ -1457,9 +1457,9 @@ export declare namespace Metric {
    * @category interfaces
    */
   export interface Hooks<in Input, out State> {
-    readonly get: (context: ServiceMap.ServiceMap<never>) => State
-    readonly update: (input: Input, context: ServiceMap.ServiceMap<never>) => void
-    readonly modify: (input: Input, context: ServiceMap.ServiceMap<never>) => void
+    readonly get: (context: Context.Context<never>) => State
+    readonly update: (input: Input, context: Context.Context<never>) => void
+    readonly modify: (input: Input, context: Context.Context<never>) => void
   }
 
   /**
@@ -1761,7 +1761,7 @@ export const CurrentMetricAttributesKey = "effect/Metric/CurrentMetricAttributes
  * @since 4.0.0
  * @category References
  */
-export const CurrentMetricAttributes = ServiceMap.Reference<Metric.AttributeSet>(CurrentMetricAttributesKey, {
+export const CurrentMetricAttributes = Context.Reference<Metric.AttributeSet>(CurrentMetricAttributesKey, {
   defaultValue: () => ({})
 })
 
@@ -1773,7 +1773,7 @@ const MetricRegistryKey = "~effect/observability/Metric/MetricRegistryKey"
  * @since 4.0.0
  * @category References
  */
-export const MetricRegistry = ServiceMap.Reference<Map<string, Metric.Metadata<any, any>>>(
+export const MetricRegistry = Context.Reference<Map<string, Metric.Metadata<any, any>>>(
   MetricRegistryKey,
   { defaultValue: () => new Map() }
 )
@@ -1805,22 +1805,22 @@ abstract class Metric$<in Input, out State> implements Metric<Input, State> {
     this.attributes = attributes
   }
 
-  valueUnsafe(context: ServiceMap.ServiceMap<never>): State {
+  valueUnsafe(context: Context.Context<never>): State {
     return this.hook(context).get(context)
   }
 
-  modifyUnsafe(input: Input, context: ServiceMap.ServiceMap<never>): void {
+  modifyUnsafe(input: Input, context: Context.Context<never>): void {
     return this.hook(context).modify(input, context)
   }
 
-  updateUnsafe(input: Input, context: ServiceMap.ServiceMap<never>): void {
+  updateUnsafe(input: Input, context: Context.Context<never>): void {
     return this.hook(context).update(input, context)
   }
 
   abstract createHooks(): Metric.Hooks<Input, State>
 
-  hook(context: ServiceMap.ServiceMap<never>): Metric.Hooks<Input, State> {
-    const extraAttributes = ServiceMap.get(context, CurrentMetricAttributes)
+  hook(context: Context.Context<never>): Metric.Hooks<Input, State> {
+    const extraAttributes = Context.get(context, CurrentMetricAttributes)
     if (Object.keys(extraAttributes).length === 0) {
       if (Predicate.isNotUndefined(this.#metadata)) {
         return this.#metadata.hooks
@@ -1839,11 +1839,11 @@ abstract class Metric$<in Input, out State> implements Metric<Input, State> {
   }
 
   getOrCreate(
-    context: ServiceMap.ServiceMap<never>,
+    context: Context.Context<never>,
     attributes: Metric.Attributes | undefined
   ): Metric.Metadata<Input, State> {
     const key = makeKey(this, attributes)
-    const registry = ServiceMap.get(context, MetricRegistry)
+    const registry = Context.get(context, MetricRegistry)
     if (registry.has(key)) {
       return registry.get(key)!
     }
@@ -2107,8 +2107,8 @@ class SummaryMetric extends Metric$<readonly [value: number, timestamp: number],
       }
     }
 
-    const get = (context: ServiceMap.ServiceMap<never>) => {
-      const clock = ServiceMap.get(context, InternalEffect.ClockRef)
+    const get = (context: Context.Context<never>) => {
+      const clock = Context.get(context, InternalEffect.ClockRef)
       const quantiles = snapshot(clock.currentTimeMillisUnsafe())
       return { quantiles, count, min, max, sum }
     }
@@ -2122,15 +2122,15 @@ class SummaryMetric extends Metric$<readonly [value: number, timestamp: number],
 class MetricTransform<in Input, out State, in Input2> extends Metric$<Input2, State> {
   type: Metric.Type
   readonly metric: Metric<Input, State>
-  override readonly valueUnsafe: (context: ServiceMap.ServiceMap<never>) => State
-  override readonly updateUnsafe: (input: Input2, context: ServiceMap.ServiceMap<never>) => void
-  override readonly modifyUnsafe: (input: Input2, context: ServiceMap.ServiceMap<never>) => void
+  override readonly valueUnsafe: (context: Context.Context<never>) => State
+  override readonly updateUnsafe: (input: Input2, context: Context.Context<never>) => void
+  override readonly modifyUnsafe: (input: Input2, context: Context.Context<never>) => void
 
   constructor(
     metric: Metric<Input, State>,
-    valueUnsafe: (context: ServiceMap.ServiceMap<never>) => State,
-    updateUnsafe: (input: Input2, context: ServiceMap.ServiceMap<never>) => void,
-    modifyUnsafe: (input: Input2, context: ServiceMap.ServiceMap<never>) => void
+    valueUnsafe: (context: Context.Context<never>) => State,
+    updateUnsafe: (input: Input2, context: Context.Context<never>) => void,
+    modifyUnsafe: (input: Input2, context: Context.Context<never>) => void
   ) {
     super(metric.id, metric.description, metric.attributes)
     this.metric = metric
@@ -2815,7 +2815,7 @@ export const summary = (name: string, options: {
   mapInput(summaryWithTimestamp(name, options), (input, context) =>
     [
       input,
-      ServiceMap.get(context, InternalEffect.ClockRef).currentTimeMillisUnsafe()
+      Context.get(context, InternalEffect.ClockRef).currentTimeMillisUnsafe()
     ] as [number, number])
 
 /**
@@ -2956,7 +2956,7 @@ export const value = <Input, State>(
   self: Metric<Input, State>
 ): Effect<State> =>
   InternalEffect.flatMap(
-    InternalEffect.services(),
+    InternalEffect.context(),
     (context) => InternalEffect.sync(() => self.valueUnsafe(context))
   )
 
@@ -3168,7 +3168,7 @@ export const modify: {
   <Input, State>(self: Metric<Input, State>, input: Input) => Effect<void>
 >(2, (self, input) =>
   InternalEffect.flatMap(
-    InternalEffect.services(),
+    InternalEffect.context(),
     (context) => InternalEffect.sync(() => self.modifyUnsafe(input, context))
   ))
 
@@ -3426,7 +3426,7 @@ export const update: {
 >(
   2,
   (self, input) =>
-    InternalEffect.servicesWith((services) => InternalEffect.sync(() => self.updateUnsafe(input, services)))
+    InternalEffect.contextWith((services) => InternalEffect.sync(() => self.updateUnsafe(input, services)))
 )
 
 /**
@@ -3506,7 +3506,7 @@ export const mapInput: {
    * @since 2.0.0
    * @category Mapping
    */
-  <Input, Input2 extends Input>(f: (input: Input2, context: ServiceMap.ServiceMap<never>) => Input): <State>(self: Metric<Input, State>) => Metric<Input2, State>
+  <Input, Input2 extends Input>(f: (input: Input2, context: Context.Context<never>) => Input): <State>(self: Metric<Input, State>) => Metric<Input2, State>
   /**
    * Returns a new metric that is powered by this one, but which accepts updates
    * of the specified new type, which must be transformable to the input type of
@@ -3547,7 +3547,7 @@ export const mapInput: {
    */
   <Input, State, Input2>(
     self: Metric<Input, State>,
-    f: (input: Input2, context: ServiceMap.ServiceMap<never>) => Input
+    f: (input: Input2, context: Context.Context<never>) => Input
   ): Metric<Input2, State>
 } = dual<
   /**
@@ -3588,7 +3588,7 @@ export const mapInput: {
    * @since 2.0.0
    * @category Mapping
    */
-  <Input, Input2 extends Input>(f: (input: Input2, context: ServiceMap.ServiceMap<never>) => Input) => <State>(self: Metric<Input, State>) => Metric<Input2, State>,
+  <Input, Input2 extends Input>(f: (input: Input2, context: Context.Context<never>) => Input) => <State>(self: Metric<Input, State>) => Metric<Input2, State>,
   /**
    * Returns a new metric that is powered by this one, but which accepts updates
    * of the specified new type, which must be transformable to the input type of
@@ -3629,11 +3629,11 @@ export const mapInput: {
    */
   <Input, State, Input2>(
     self: Metric<Input, State>,
-    f: (input: Input2, context: ServiceMap.ServiceMap<never>) => Input
+    f: (input: Input2, context: Context.Context<never>) => Input
   ) => Metric<Input2, State>
 >(2, <Input, State, Input2>(
   self: Metric<Input, State>,
-  f: (input: Input2, context: ServiceMap.ServiceMap<never>) => Input
+  f: (input: Input2, context: Context.Context<never>) => Input
 ): Metric<Input2, State> =>
   new MetricTransform(
     self,
@@ -4112,9 +4112,9 @@ export const withAttributes: {
 ): Metric<Input, State> =>
   new MetricTransform(
     self,
-    (context) => self.valueUnsafe(addAttributesToServiceMap(context, attributes)),
-    (input, context) => self.updateUnsafe(input, addAttributesToServiceMap(context, attributes)),
-    (input, context) => self.modifyUnsafe(input, addAttributesToServiceMap(context, attributes))
+    (context) => self.valueUnsafe(addAttributesToContext(context, attributes)),
+    (input, context) => self.updateUnsafe(input, addAttributesToContext(context, attributes)),
+    (input, context) => self.modifyUnsafe(input, addAttributesToContext(context, attributes))
   ))
 
 // Metric Snapshots
@@ -4168,7 +4168,7 @@ export const withAttributes: {
  * @category Snapshotting
  */
 export const snapshot: Effect<ReadonlyArray<Metric.Snapshot>> = InternalEffect.map(
-  InternalEffect.services(),
+  InternalEffect.context(),
   (context) => snapshotUnsafe(context)
 )
 
@@ -4226,7 +4226,7 @@ export const snapshot: Effect<ReadonlyArray<Metric.Snapshot>> = InternalEffect.m
  * @since 2.0.0
  * @category Debugging
  */
-export const dump: Effect<string> = InternalEffect.flatMap(InternalEffect.services(), (context) => {
+export const dump: Effect<string> = InternalEffect.flatMap(InternalEffect.context(), (context) => {
   const metrics = snapshotUnsafe(context)
   if (metrics.length > 0) {
     const maxNameLength = metrics.reduce((max, metric) => {
@@ -4292,7 +4292,7 @@ export const dump: Effect<string> = InternalEffect.flatMap(InternalEffect.servic
  *   yield* Metric.update(responseTime, 150)
  *
  *   // Get services context for unsafe operations
- *   const services = yield* Effect.services()
+ *   const services = yield* Effect.context()
  *
  *   // Use snapshotUnsafe for direct, synchronous access
  *   const snapshots = Metric.snapshotUnsafe(services)
@@ -4321,11 +4321,11 @@ export const dump: Effect<string> = InternalEffect.flatMap(InternalEffect.servic
  * @since 2.0.0
  * @category Snapshotting
  */
-export const snapshotUnsafe = (services: ServiceMap.ServiceMap<never>): ReadonlyArray<Metric.Snapshot> => {
-  const registry = ServiceMap.get(services, MetricRegistry)
+export const snapshotUnsafe = (context: Context.Context<never>): ReadonlyArray<Metric.Snapshot> => {
+  const registry = Context.get(context, MetricRegistry)
   return Array.from(registry.values()).map(({ hooks, ...meta }) => ({
     ...meta,
-    state: hooks.get(services)
+    state: hooks.get(context)
   }))
 }
 
@@ -4629,7 +4629,7 @@ export const FiberRuntimeMetricsKey: "effect/observability/Metric/FiberRuntimeMe
  *
  * @example
  * ```ts
- * import type { ServiceMap } from "effect"
+ * import type { Context } from "effect"
  * import { Data, Effect, Layer, Metric } from "effect"
  * import type { Exit } from "effect/Exit"
  *
@@ -4639,12 +4639,12 @@ export const FiberRuntimeMetricsKey: "effect/observability/Metric/FiberRuntimeMe
  *
  * // Custom implementation of the metrics service
  * const customMetricsService: Metric.FiberRuntimeMetricsService = {
- *   recordFiberStart: (context: ServiceMap.ServiceMap<never>) => {
+ *   recordFiberStart: (context: Context.Context<never>) => {
  *     console.log("Fiber started")
  *     // Custom logic for tracking fiber starts
  *   },
  *   recordFiberEnd: (
- *     context: ServiceMap.ServiceMap<never>,
+ *     context: Context.Context<never>,
  *     exit: Exit<unknown, unknown>
  *   ) => {
  *     console.log("Fiber completed with exit:", exit)
@@ -4664,8 +4664,8 @@ export const FiberRuntimeMetricsKey: "effect/observability/Metric/FiberRuntimeMe
  * @category Runtime Metrics
  */
 export interface FiberRuntimeMetricsService {
-  readonly recordFiberStart: (context: ServiceMap.ServiceMap<never>) => void
-  readonly recordFiberEnd: (context: ServiceMap.ServiceMap<never>, exit: Exit<unknown, unknown>) => void
+  readonly recordFiberStart: (context: Context.Context<never>) => void
+  readonly recordFiberEnd: (context: Context.Context<never>, exit: Exit<unknown, unknown>) => void
 }
 
 /**
@@ -4713,7 +4713,7 @@ export interface FiberRuntimeMetricsService {
  * @since 4.0.0
  * @category Runtime Metrics
  */
-export const FiberRuntimeMetrics = ServiceMap.Reference<FiberRuntimeMetricsService | undefined>(
+export const FiberRuntimeMetrics = Context.Reference<FiberRuntimeMetricsService | undefined>(
   InternalMetric.FiberRuntimeMetricsKey,
   { defaultValue: constUndefined }
 )
@@ -4763,11 +4763,11 @@ export const FiberRuntimeMetrics = ServiceMap.Reference<FiberRuntimeMetricsServi
  * @category Runtime Metrics
  */
 export const FiberRuntimeMetricsImpl: FiberRuntimeMetricsService = {
-  recordFiberStart(context: ServiceMap.ServiceMap<never>) {
+  recordFiberStart(context: Context.Context<never>) {
     fibersStarted.updateUnsafe(1, context)
     fibersActive.modifyUnsafe(1, context)
   },
-  recordFiberEnd(context: ServiceMap.ServiceMap<never>, exit: Exit<unknown, unknown>) {
+  recordFiberEnd(context: Context.Context<never>, exit: Exit<unknown, unknown>) {
     fibersActive.modifyUnsafe(-1, context)
     if (InternalEffect.exitIsSuccess(exit)) {
       fiberSuccesses.updateUnsafe(1, context)
@@ -5102,9 +5102,9 @@ function makeKey<Input, State>(
 }
 
 function makeHooks<Input, State>(
-  get: (context: ServiceMap.ServiceMap<never>) => State,
-  update: (input: Input, context: ServiceMap.ServiceMap<never>) => void,
-  modify?: (input: Input, context: ServiceMap.ServiceMap<never>) => void
+  get: (context: Context.Context<never>) => State,
+  update: (input: Input, context: Context.Context<never>) => void,
+  modify?: (input: Input, context: Context.Context<never>) => void
 ): Metric.Hooks<Input, State> {
   return { get, update, modify: modify ?? update }
 }
@@ -5134,11 +5134,11 @@ function attributesToRecord(attributes?: Metric.Attributes): Metric.AttributeSet
   return attributes as Metric.AttributeSet | undefined
 }
 
-function addAttributesToServiceMap(
-  context: ServiceMap.ServiceMap<never>,
+function addAttributesToContext(
+  context: Context.Context<never>,
   attributes: Metric.Attributes
-): ServiceMap.ServiceMap<never> {
-  const current = ServiceMap.get(context, CurrentMetricAttributes)
+): Context.Context<never> {
+  const current = Context.get(context, CurrentMetricAttributes)
   const updated = mergeAttributes(current, attributes)
-  return ServiceMap.add(context, CurrentMetricAttributes, updated)
+  return Context.add(context, CurrentMetricAttributes, updated)
 }

package/src/Path.ts

@@ -1,11 +1,11 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import { identity } from "./Function.ts"
 import * as Layer from "./Layer.ts"
 import { BadArgument } from "./PlatformError.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 /**
  * @since 4.0.0
@@ -191,7 +191,7 @@ export declare namespace Path {
  * const result = Effect.provide(program, customPathLayer)
  * ```
  */
-export const Path: ServiceMap.Service<Path, Path> = ServiceMap.Service("effect/Path")
+export const Path: Context.Service<Path, Path> = Context.Service("effect/Path")
 
 /**
  * The following functions are adapted from the Node.js source code:

package/src/Pool.ts

@@ -3,6 +3,7 @@
  */
 import type * as Cause from "./Cause.ts"
 import { Clock } from "./Clock.ts"
+import * as Context from "./Context.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import type * as Exit from "./Exit.ts"
@@ -16,7 +17,6 @@ import * as Queue from "./Queue.ts"
 import { UnhandledLogLevel } from "./References.ts"
 import * as Scope from "./Scope.ts"
 import * as Semaphore from "./Semaphore.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/Pool"
 
@@ -195,11 +195,11 @@ export const makeWithStrategy = <A, E, R>(options: {
   readonly strategy: Strategy<A, E>
 }): Effect.Effect<Pool<A, E>, never, Scope.Scope | R> =>
   Effect.uninterruptibleMask(Effect.fnUntraced(function*(restore) {
-    const services = yield* Effect.services<R | Scope.Scope>()
-    const scope = ServiceMap.get(services, Scope.Scope)
-    const acquire = Effect.updateServices(
+    const services = yield* Effect.context<R | Scope.Scope>()
+    const scope = Context.get(services, Scope.Scope)
+    const acquire = Effect.updateContext(
       options.acquire,
-      (input) => ServiceMap.merge(services, input)
+      (input) => Context.merge(services, input)
     ) as Effect.Effect<A, E, Scope.Scope>
     const concurrency = options.concurrency ?? 1
 

package/src/PubSub.ts

@@ -29,6 +29,7 @@
  * @since 2.0.0
  */
 import * as Arr from "./Array.ts"
+import * as Context from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
@@ -41,7 +42,6 @@ import { nextPow2 } from "./Number.ts"
 import * as Option from "./Option.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import type { Covariant, Invariant } from "./Types.ts"
 
 const TypeId = "~effect/PubSub"
@@ -1175,8 +1175,8 @@ export const publishAll: {
  */
 export const subscribe = <A>(self: PubSub<A>): Effect.Effect<Subscription<A>, never, Scope.Scope> =>
   Effect.uninterruptible(
-    Effect.servicesWith((services) => {
-      const localScope = ServiceMap.get(services, Scope.Scope)
+    Effect.contextWith((services) => {
+      const localScope = Context.get(services, Scope.Scope)
       const scope = Scope.forkUnsafe(self.scope)
       const subscription = makeSubscriptionUnsafe(self.pubsub, self.subscribers, self.strategy)
       return Scope.addFinalizer(scope, unsubscribe(subscription)).pipe(

package/src/Random.ts

@@ -21,11 +21,11 @@
  *
  * @since 4.0.0
  */
+import type * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import { dual } from "./Function.ts"
 import * as random from "./internal/random.ts"
 import * as Predicate from "./Predicate.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
 
 /**
  * Represents a service for generating random numbers.
@@ -50,7 +50,7 @@ import type * as ServiceMap from "./ServiceMap.ts"
  * @since 4.0.0
  * @category Random Number Generators
  */
-export const Random: ServiceMap.Reference<{
+export const Random: Context.Reference<{
   nextIntUnsafe(): number
   nextDoubleUnsafe(): number
 }> = random.Random

package/src/RcMap.ts

@@ -3,6 +3,7 @@
  */
 import * as Cause from "./Cause.ts"
 import { Clock } from "./Clock.ts"
+import * as Context from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
@@ -13,7 +14,6 @@ import * as MutableHashMap from "./MutableHashMap.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
 import * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/RcMap"
 
@@ -53,7 +53,7 @@ const TypeId = "~effect/RcMap"
 export interface RcMap<in out K, in out A, in out E = never> extends Pipeable {
   readonly [TypeId]: typeof TypeId
   readonly lookup: (key: K) => Effect.Effect<A, E, Scope.Scope>
-  readonly services: ServiceMap.ServiceMap<never>
+  readonly context: Context.Context<never>
   readonly scope: Scope.Scope
   readonly idleTimeToLive: (key: K) => Duration.Duration
   readonly capacity: number
@@ -196,14 +196,14 @@ export declare namespace State {
 
 const makeUnsafe = <K, A, E>(options: {
   readonly lookup: (key: K) => Effect.Effect<A, E, Scope.Scope>
-  readonly services: ServiceMap.ServiceMap<never>
+  readonly context: Context.Context<never>
   readonly scope: Scope.Scope
   readonly idleTimeToLive: (key: K) => Duration.Duration
   readonly capacity: number
 }): RcMap<K, A, E> => ({
   [TypeId]: TypeId,
   lookup: options.lookup,
-  services: options.services,
+  context: options.context,
   scope: options.scope,
   idleTimeToLive: options.idleTimeToLive,
   capacity: options.capacity,
@@ -345,11 +345,11 @@ export const make: {
   readonly capacity?: number | undefined
 }) =>
   Effect.withFiber<RcMap<K, A, E>, never, R | Scope.Scope>((fiber) => {
-    const services = fiber.services as ServiceMap.ServiceMap<R | Scope.Scope>
-    const scope = ServiceMap.get(services, Scope.Scope)
+    const context = fiber.context as Context.Context<R | Scope.Scope>
+    const scope = Context.get(context, Scope.Scope)
     const self = makeUnsafe<K, A, E>({
       lookup: options.lookup as any,
-      services,
+      context,
       scope,
       idleTimeToLive: typeof options.idleTimeToLive === "function"
         ? flow(options.idleTimeToLive, Duration.fromInputUnsafe)
@@ -489,17 +489,17 @@ export const get: {
         }
         ;(entry as any).finalizer = release(self, key, entry)
         MutableHashMap.set(state.map, key, entry)
-        const services = new Map(self.services.mapUnsafe)
-        parent.services.mapUnsafe.forEach((value, key) => {
-          services.set(key, value)
+        const context = new Map(self.context.mapUnsafe)
+        parent.context.mapUnsafe.forEach((value, key) => {
+          context.set(key, value)
         })
-        services.set(Scope.Scope.key, entry.scope)
+        context.set(Scope.Scope.key, entry.scope)
         self.lookup(key).pipe(
-          Effect.runForkWith(ServiceMap.makeUnsafe(services)),
+          Effect.runForkWith(Context.makeUnsafe(context)),
           Fiber.runIn(entry.scope)
         ).addObserver((exit) => Deferred.doneUnsafe(entry.deferred, exit))
       }
-      const scope = ServiceMap.getUnsafe(parent.services, Scope.Scope)
+      const scope = Context.getUnsafe(parent.context, Scope.Scope)
       return Scope.addFinalizer(scope, entry.finalizer).pipe(
         Effect.andThen(restore(Deferred.await(entry.deferred)))
       )
@@ -541,7 +541,7 @@ const release = <K, A, E>(self: RcMap<K, A, E>, key: K, entry: State.Entry<A, E>
       Effect.ensuring(Effect.sync(() => {
         entry.fiber = undefined
       })),
-      Effect.runForkWith(fiber.services),
+      Effect.runForkWith(fiber.context),
       Fiber.runIn(self.scope)
     )
     return Effect.void