effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/ExecutionPlan.ts

@@ -2,6 +2,7 @@
  * @since 3.16.0
  */
 import type { NonEmptyReadonlyArray } from "./Array.ts"
+import * as Context from "./Context.ts"
 import type * as Effect from "./Effect.ts"
 import { constant } from "./Function.ts"
 import * as effect from "./internal/effect.ts"
@@ -10,7 +11,6 @@ import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import type * as Schedule from "./Schedule.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 /**
  * @since 3.16.0
@@ -84,7 +84,7 @@ export interface ExecutionPlan<
   readonly [TypeId]: TypeId
   readonly steps: NonEmptyReadonlyArray<{
     readonly provide:
-      | ServiceMap.ServiceMap<Config["provides"]>
+      | Context.Context<Config["provides"]>
       | Layer.Layer<Config["provides"], Config["error"], Config["requirements"]>
     readonly attempts?: number | undefined
     readonly while?:
@@ -169,7 +169,7 @@ export const make = <const Steps extends NonEmptyReadonlyArray<make.Step>>(
   provides: make.StepProvides<Steps>
   input: make.StepInput<Steps>
   error:
-    | (Steps[number]["provide"] extends ServiceMap.ServiceMap<infer _P> | Layer.Layer<infer _P, infer E, infer _R> ? E
+    | (Steps[number]["provide"] extends Context.Context<infer _P> | Layer.Layer<infer _P, infer E, infer _R> ? E
       : never)
     | (Steps[number]["while"] extends (input: infer _I) => Effect.Effect<infer _A, infer _E, infer _R> ? _E : never)
   requirements:
@@ -203,7 +203,7 @@ export declare namespace make {
    * @since 3.16.0
    */
   export type Step = {
-    readonly provide: ServiceMap.ServiceMap<any> | ServiceMap.ServiceMap<never> | Layer.Any
+    readonly provide: Context.Context<any> | Context.Context<never> | Layer.Any
     readonly attempts?: number | undefined
     readonly while?: ((input: any) => boolean | Effect.Effect<boolean, any, any>) | undefined
     readonly schedule?: Schedule.Schedule<any, any, any> | undefined
@@ -217,8 +217,7 @@ export declare namespace make {
       Rest,
       & Out
       & (
-        (Step extends { readonly provide: ServiceMap.ServiceMap<infer P> | Layer.Layer<infer P, infer _E, infer _R> } ?
-          P
+        (Step extends { readonly provide: Context.Context<infer P> | Layer.Layer<infer P, infer _E, infer _R> } ? P
           : unknown)
       )
     > :
@@ -259,11 +258,11 @@ const Proto: Omit<ExecutionPlan<any>, "steps"> = {
   [TypeId]: TypeId,
   get withRequirements() {
     const self = this as any as ExecutionPlan<any>
-    return effect.servicesWith((services: ServiceMap.ServiceMap<any>) =>
+    return effect.contextWith((context: Context.Context<any>) =>
       effect.succeed(makeProto(self.steps.map((step) => ({
         ...step,
         provide: Layer.isLayer(step.provide)
-          ? Layer.provide(step.provide, Layer.succeedServices(services))
+          ? Layer.provide(step.provide, Layer.succeedContext(context))
           : step.provide
       })) as any))
     )
@@ -312,7 +311,7 @@ export interface Metadata {
  * @since 4.0.0
  * @category Metadata
  */
-export const CurrentMetadata = ServiceMap.Reference<Metadata>("effect/ExecutionPlan/CurrentMetadata", {
+export const CurrentMetadata = Context.Reference<Metadata>("effect/ExecutionPlan/CurrentMetadata", {
   defaultValue: constant({
     attempt: 0,
     stepIndex: 0

package/src/Exit.ts

@@ -857,10 +857,12 @@ export const map: {
  * **Example** (Mapping over an error)
  *
  * ```ts
- * import { Exit } from "effect"
+ * import { Data, Exit } from "effect"
+ *
+ * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
  *
  * const exit = Exit.fail("bad input")
- * const mapped = Exit.mapError(exit, (e) => new Error(e))
+ * const mapped = Exit.mapError(exit, (e) => new ExitError({ input: e }))
  * console.log(Exit.isFailure(mapped)) // true
  * ```
  *
@@ -884,10 +886,12 @@ export const mapError: {
    * **Example** (Mapping over an error)
    *
    * ```ts
-   * import { Exit } from "effect"
+   * import { Data, Exit } from "effect"
+   *
+   * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
    *
    * const exit = Exit.fail("bad input")
-   * const mapped = Exit.mapError(exit, (e) => new Error(e))
+   * const mapped = Exit.mapError(exit, (e) => new ExitError({ input: e }))
    * console.log(Exit.isFailure(mapped)) // true
    * ```
    *
@@ -911,10 +915,12 @@ export const mapError: {
    * **Example** (Mapping over an error)
    *
    * ```ts
-   * import { Exit } from "effect"
+   * import { Data, Exit } from "effect"
+   *
+   * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
    *
    * const exit = Exit.fail("bad input")
-   * const mapped = Exit.mapError(exit, (e) => new Error(e))
+   * const mapped = Exit.mapError(exit, (e) => new ExitError({ input: e }))
    * console.log(Exit.isFailure(mapped)) // true
    * ```
    *
@@ -941,12 +947,14 @@ export const mapError: {
  * **Example** (Mapping both channels)
  *
  * ```ts
- * import { Exit } from "effect"
+ * import { Data, Exit } from "effect"
+ *
+ * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
  *
  * const exit = Exit.succeed(42)
  * const mapped = Exit.mapBoth(exit, {
  *   onSuccess: (x) => String(x),
- *   onFailure: (e: string) => new Error(e)
+ *   onFailure: (e: string) => new ExitError({ input: e })
  * })
  * console.log(Exit.isSuccess(mapped) && mapped.value) // "42"
  * ```
@@ -972,12 +980,14 @@ export const mapBoth: {
    * **Example** (Mapping both channels)
    *
    * ```ts
-   * import { Exit } from "effect"
+   * import { Data, Exit } from "effect"
+   *
+   * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
    *
    * const exit = Exit.succeed(42)
    * const mapped = Exit.mapBoth(exit, {
    *   onSuccess: (x) => String(x),
-   *   onFailure: (e: string) => new Error(e)
+   *   onFailure: (e: string) => new ExitError({ input: e })
    * })
    * console.log(Exit.isSuccess(mapped) && mapped.value) // "42"
    * ```
@@ -1005,12 +1015,14 @@ export const mapBoth: {
    * **Example** (Mapping both channels)
    *
    * ```ts
-   * import { Exit } from "effect"
+   * import { Data, Exit } from "effect"
+   *
+   * class ExitError extends Data.TaggedError("ExitError")<{ readonly input: string }> {}
    *
    * const exit = Exit.succeed(42)
    * const mapped = Exit.mapBoth(exit, {
    *   onSuccess: (x) => String(x),
-   *   onFailure: (e: string) => new Error(e)
+   *   onFailure: (e: string) => new ExitError({ input: e })
    * })
    * console.log(Exit.isSuccess(mapped) && mapped.value) // "42"
    * ```

package/src/Fiber.ts

@@ -73,6 +73,7 @@
  * @since 2.0.0
  */
 import type * as Arr from "./Array.ts"
+import type * as Context from "./Context.ts"
 import type { Effect } from "./Effect.ts"
 import type { Exit } from "./Exit.ts"
 import * as effect from "./internal/effect.ts"
@@ -81,9 +82,8 @@ import type { LogLevel } from "./LogLevel.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import type { StackFrame } from "./References.ts"
-import type { Scheduler } from "./Scheduler.ts"
+import type { Scheduler, SchedulerDispatcher } from "./Scheduler.ts"
 import type { Scope } from "./Scope.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
 import type { AnySpan } from "./Tracer.ts"
 import type { Covariant } from "./Types.ts"
 
@@ -119,19 +119,21 @@ export interface Fiber<out A, out E = never> extends Pipeable {
 
   readonly id: number
   readonly currentOpCount: number
-  readonly getRef: <A>(ref: ServiceMap.Reference<A>) => A
-  readonly services: ServiceMap.ServiceMap<never>
-  setServices(services: ServiceMap.ServiceMap<never>): void
+  readonly getRef: <A>(ref: Context.Reference<A>) => A
+  readonly context: Context.Context<never>
+  setContext(context: Context.Context<never>): void
   readonly currentScheduler: Scheduler
+  readonly currentDispatcher: SchedulerDispatcher
   readonly currentSpan?: AnySpan | undefined
   readonly currentLogLevel: LogLevel
   readonly minimumLogLevel: LogLevel
   readonly currentStackFrame?: StackFrame | undefined
   readonly maxOpsBeforeYield: number
+  readonly currentPreventYield: boolean
   readonly addObserver: (cb: (exit: Exit<A, E>) => void) => () => void
   readonly interruptUnsafe: (
     fiberId?: number | undefined,
-    annotations?: ServiceMap.ServiceMap<never> | undefined
+    annotations?: Context.Context<never> | undefined
   ) => void
   readonly pollUnsafe: () => Exit<A, E> | undefined
 }
@@ -338,7 +340,10 @@ export const interruptAs: {
    * @since 2.0.0
    * @category interruption
    */
-  (fiberId: number): <A, E>(self: Fiber<A, E>) => Effect<void>
+  (
+    fiberId: number | undefined,
+    annotations?: Context.Context<never> | undefined
+  ): <A, E>(self: Fiber<A, E>) => Effect<void>
   /**
    * Interrupts a fiber with a specific fiber ID as the interruptor. This allows
    * tracking which fiber initiated the interruption.
@@ -361,7 +366,11 @@ export const interruptAs: {
    * @since 2.0.0
    * @category interruption
    */
-  <A, E>(self: Fiber<A, E>, fiberId: number): Effect<void>
+  <A, E>(
+    self: Fiber<A, E>,
+    fiberId: number | undefined,
+    annotations?: Context.Context<never> | undefined
+  ): Effect<void>
 } = effect.fiberInterruptAs
 
 /**

package/src/FiberHandle.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import * as Cause from "./Cause.ts"
+import type { Context } from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
@@ -10,11 +11,11 @@ import * as Filter from "./Filter.ts"
 import { dual } from "./Function.ts"
 import type * as Inspectable from "./Inspectable.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
+import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import type { Scheduler } from "./Scheduler.ts"
 import type * as Scope from "./Scope.ts"
-import type { ServiceMap } from "./ServiceMap.ts"
 
 const TypeId = "~effect/FiberHandle"
 
@@ -467,20 +468,20 @@ export const set: {
  *
  *   // No fiber initially
  *   const emptyFiber = FiberHandle.getUnsafe(handle)
- *   console.log(emptyFiber === undefined) // true
+ *   console.log(emptyFiber._tag === "None") // true
  *
  *   // Add a fiber
  *   yield* FiberHandle.run(handle, Effect.succeed("hello"))
  *   const fiber = FiberHandle.getUnsafe(handle)
- *   console.log(fiber !== undefined) // true
+ *   console.log(fiber._tag === "Some") // true
  * })
  * ```
  *
  * @since 2.0.0
  * @category combinators
  */
-export function getUnsafe<A, E>(self: FiberHandle<A, E>): Fiber.Fiber<A, E> | undefined {
-  return self.state._tag === "Closed" ? undefined : self.state.fiber
+export function getUnsafe<A, E>(self: FiberHandle<A, E>): Option.Option<Fiber.Fiber<A, E>> {
+  return self.state._tag === "Closed" ? Option.none() : Option.fromUndefinedOr(self.state.fiber)
 }
 
 /**
@@ -496,10 +497,10 @@ export function getUnsafe<A, E>(self: FiberHandle<A, E>): Fiber.Fiber<A, E> | un
  *   // Add a fiber
  *   yield* FiberHandle.run(handle, Effect.succeed("hello"))
  *
- *   // Get the fiber (fails if no fiber)
+ *   // Get the current fiber if present
  *   const fiber = yield* FiberHandle.get(handle)
- *   if (fiber) {
- *     const result = yield* Fiber.await(fiber)
+ *   if (fiber._tag === "Some") {
+ *     const result = yield* Fiber.await(fiber.value)
  *     console.log(result) // "hello"
  *   }
  * })
@@ -508,7 +509,7 @@ export function getUnsafe<A, E>(self: FiberHandle<A, E>): Fiber.Fiber<A, E> | un
  * @since 2.0.0
  * @category combinators
  */
-export function get<A, E>(self: FiberHandle<A, E>): Effect.Effect<Fiber.Fiber<A, E> | undefined> {
+export function get<A, E>(self: FiberHandle<A, E>): Effect.Effect<Option.Option<Fiber.Fiber<A, E>>> {
   return Effect.suspend(() => Effect.succeed(getUnsafe(self)))
 }
 
@@ -528,7 +529,7 @@ export function get<A, E>(self: FiberHandle<A, E>): Effect.Effect<Fiber.Fiber<A,
  *
  *   // The handle is now empty
  *   const fiber = FiberHandle.getUnsafe(handle)
- *   console.log(fiber) // undefined
+ *   console.log(fiber) // Option.none()
  * })
  * ```
  *
@@ -680,7 +681,7 @@ const runImpl = <A, E, R, XE extends E, XA extends A>(
     } else if (self.state.fiber !== undefined && options?.onlyIfMissing === true) {
       return Effect.sync(constInterruptedFiber)
     }
-    const fiber = Effect.runForkWith(parent.services as ServiceMap<R>)(effect)
+    const fiber = Effect.runForkWith(parent.context as Context<R>)(effect)
     setUnsafe(self, fiber, options)
     return Effect.succeed(fiber)
   })
@@ -690,12 +691,12 @@ const runImpl = <A, E, R, XE extends E, XA extends A>(
  *
  * @example
  * ```ts
- * import { Effect, FiberHandle, ServiceMap } from "effect"
+ * import { Effect, FiberHandle, Context } from "effect"
  *
  * interface Users {
  *   readonly _: unique symbol
  * }
- * const Users = ServiceMap.Service<Users, {
+ * const Users = Context.Service<Users, {
  *   getAll: Effect.Effect<Array<unknown>>
  * }>("Users")
  *
@@ -734,7 +735,7 @@ export const runtime: <A, E>(
   R
 > = <A, E>(self: FiberHandle<A, E>) => <R>() =>
   Effect.map(
-    Effect.services<R>(),
+    Effect.context<R>(),
     (services) => {
       const runFork = Effect.runForkWith(services)
       return <XE extends E, XA extends A>(

package/src/FiberMap.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import * as Cause from "./Cause.ts"
+import type { Context } from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
@@ -16,7 +17,6 @@ import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import type * as Scope from "./Scope.ts"
-import type { ServiceMap } from "./ServiceMap.ts"
 
 const TypeId = "~effect/FiberMap"
 
@@ -500,8 +500,8 @@ export const set: {
  *
  *   // Retrieve the fiber
  *   const retrieved = FiberMap.getUnsafe(map, "greeting")
- *   if (retrieved) {
- *     const result = yield* Fiber.await(retrieved)
+ *   if (retrieved._tag === "Some") {
+ *     const result = yield* Fiber.await(retrieved.value)
  *     console.log(result) // "Hello"
  *   }
  * })
@@ -527,8 +527,8 @@ export const getUnsafe: {
    *
    *   // Retrieve the fiber
    *   const retrieved = FiberMap.getUnsafe(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -537,7 +537,7 @@ export const getUnsafe: {
    * @since 2.0.0
    * @category combinators
    */
-  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Fiber.Fiber<A, E> | undefined
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Option.Option<Fiber.Fiber<A, E>>
   /**
    * Retrieve a fiber from the FiberMap.
    *
@@ -554,8 +554,8 @@ export const getUnsafe: {
    *
    *   // Retrieve the fiber
    *   const retrieved = FiberMap.getUnsafe(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -564,18 +564,18 @@ export const getUnsafe: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Fiber.Fiber<A, E> | undefined
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Option.Option<Fiber.Fiber<A, E>>
 } = dual(
   2,
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Fiber.Fiber<A, E> | undefined => {
-    return self.state._tag === "Closed" ? undefined : Option.getOrUndefined(MutableHashMap.get(self.state.backing, key))
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Option.Option<Fiber.Fiber<A, E>> => {
+    return self.state._tag === "Closed" ? Option.none() : MutableHashMap.get(self.state.backing, key)
   }
 )
 
 /**
  * Retrieve a fiber from the FiberMap.
  *
- * Returns an Effect that fails with `NoSuchElementError` if the key is not found.
+ * Returns an `Option` wrapped in `Effect`.
  *
  * @example
  * ```ts
@@ -590,8 +590,8 @@ export const getUnsafe: {
  *
  *   // Retrieve the fiber with error handling
  *   const retrieved = yield* FiberMap.get(map, "greeting")
- *   if (retrieved) {
- *     const result = yield* Fiber.await(retrieved)
+ *   if (retrieved._tag === "Some") {
+ *     const result = yield* Fiber.await(retrieved.value)
  *     console.log(result) // "Hello"
  *   }
  * })
@@ -604,7 +604,7 @@ export const get: {
   /**
    * Retrieve a fiber from the FiberMap.
    *
-   * Returns an Effect that fails with `NoSuchElementError` if the key is not found.
+   * Returns an `Option` wrapped in `Effect`.
    *
    * @example
    * ```ts
@@ -619,8 +619,8 @@ export const get: {
    *
    *   // Retrieve the fiber with error handling
    *   const retrieved = yield* FiberMap.get(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -629,11 +629,11 @@ export const get: {
    * @since 2.0.0
    * @category combinators
    */
-  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<Fiber.Fiber<A, E> | undefined>
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<Option.Option<Fiber.Fiber<A, E>>>
   /**
    * Retrieve a fiber from the FiberMap.
    *
-   * Returns an Effect that fails with `NoSuchElementError` if the key is not found.
+   * Returns an `Option` wrapped in `Effect`.
    *
    * @example
    * ```ts
@@ -648,8 +648,8 @@ export const get: {
    *
    *   // Retrieve the fiber with error handling
    *   const retrieved = yield* FiberMap.get(map, "greeting")
-   *   if (retrieved) {
-   *     const result = yield* Fiber.await(retrieved)
+   *   if (retrieved._tag === "Some") {
+   *     const result = yield* Fiber.await(retrieved.value)
    *     console.log(result) // "Hello"
    *   }
    * })
@@ -658,10 +658,10 @@ export const get: {
    * @since 2.0.0
    * @category combinators
    */
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Fiber.Fiber<A, E> | undefined>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Option.Option<Fiber.Fiber<A, E>>>
 } = dual(
   2,
-  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Fiber.Fiber<A, E> | undefined> =>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Option.Option<Fiber.Fiber<A, E>>> =>
     Effect.suspend(() => Effect.succeed(getUnsafe(self, key)))
 )
 
@@ -1147,7 +1147,7 @@ const runImpl = <K, A, E, R, XE extends E, XA extends A>(
     } else if (options?.onlyIfMissing === true && hasUnsafe(self, key)) {
       return Effect.sync(constInterruptedFiber)
     }
-    const fiber = Effect.runForkWith(parent.services as ServiceMap<R>)(effect)
+    const fiber = Effect.runForkWith(parent.context as Context<R>)(effect)
     setUnsafe(self, key, fiber, options)
     return Effect.succeed(fiber)
   })
@@ -1157,12 +1157,12 @@ const runImpl = <K, A, E, R, XE extends E, XA extends A>(
  *
  * @example
  * ```ts
- * import { Effect, FiberMap, ServiceMap } from "effect"
+ * import { Effect, FiberMap, Context } from "effect"
  *
  * interface Users {
  *   readonly _: unique symbol
  * }
- * const Users = ServiceMap.Service<Users, {
+ * const Users = Context.Service<Users, {
  *   getAll: Effect.Effect<Array<unknown>>
  * }>("Users")
  *
@@ -1198,7 +1198,7 @@ export const runtime: <K, A, E>(
   R
 > = <K, A, E>(self: FiberMap<K, A, E>) => <R>() =>
   Effect.map(
-    Effect.services<R>(),
+    Effect.context<R>(),
     (services) => {
       const runFork = Effect.runForkWith(services)
       return <XE extends E, XA extends A>(

package/src/FiberSet.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import * as Cause from "./Cause.ts"
+import type { Context } from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
@@ -14,7 +15,6 @@ import * as Iterable from "./Iterable.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import type * as Scope from "./Scope.ts"
-import type { ServiceMap } from "./ServiceMap.ts"
 
 const TypeId = "~effect/FiberSet"
 
@@ -588,7 +588,7 @@ const runImpl = <A, E, R, XE extends E, XA extends A>(
     if (self.state._tag === "Closed") {
       return Effect.sync(constInterruptedFiber)
     }
-    const fiber = Effect.runForkWith(parent.services as ServiceMap<R>)(effect)
+    const fiber = Effect.runForkWith(parent.context as Context<R>)(effect)
     addUnsafe(self, fiber, options)
     return Effect.succeed(fiber)
   })
@@ -598,12 +598,12 @@ const runImpl = <A, E, R, XE extends E, XA extends A>(
  *
  * @example
  * ```ts
- * import { Effect, FiberSet, ServiceMap } from "effect"
+ * import { Effect, FiberSet, Context } from "effect"
  *
  * interface Users {
  *   readonly _: unique symbol
  * }
- * const Users = ServiceMap.Service<Users, {
+ * const Users = Context.Service<Users, {
  *   getAll: Effect.Effect<Array<unknown>>
  * }>("Users")
  *
@@ -634,7 +634,7 @@ export const runtime: <A, E>(
   R
 > = <A, E>(self: FiberSet<A, E>) => <R>() =>
   Effect.map(
-    Effect.services<R>(),
+    Effect.context<R>(),
     (services) => {
       const runFork = Effect.runForkWith(services)
       return <XE extends E, XA extends A>(