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

package/src/Layer.ts

@@ -20,6 +20,7 @@
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "./Array.ts"
 import type * as Cause from "./Cause.ts"
 import type * as Channel from "./Channel.ts"
+import * as Context from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import type { Effect } from "./Effect.ts"
 import type * as Exit from "./Exit.ts"
@@ -33,10 +34,10 @@ import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import { CurrentStackFrame } from "./References.ts"
 import * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import type * as Stream from "./Stream.ts"
 import * as Tracer from "./Tracer.ts"
 import type * as Types from "./Types.ts"
+import type * as Unify from "./Unify.ts"
 
 const TypeId = "~effect/Layer"
 
@@ -53,9 +54,31 @@ const TypeId = "~effect/Layer"
  */
 export interface Layer<in ROut, out E = never, out RIn = never> extends Variance<ROut, E, RIn>, Pipeable {
   /** @internal */
-  build(memoMap: MemoMap, scope: Scope.Scope): Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  build(memoMap: MemoMap, scope: Scope.Scope): Effect<Context.Context<ROut>, E, RIn>
+  [Unify.typeSymbol]?: unknown
+  [Unify.unifySymbol]?: LayerUnify<this>
+  [Unify.ignoreSymbol]?: LayerUnifyIgnore
 }
 
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface LayerUnify<A extends { [Unify.typeSymbol]?: any }> {
+  Layer?: () => A[Unify.typeSymbol] extends Layer<any, any, any> | infer _ ? Layer<
+      Success<Extract<A[Unify.typeSymbol], Any>>,
+      Error<Extract<A[Unify.typeSymbol], Any>>,
+      Services<Extract<A[Unify.typeSymbol], Any>>
+    >
+    : never
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface LayerUnifyIgnore {}
+
 /**
  * The variance interface for Layer type parameters.
  *
@@ -119,9 +142,9 @@ const MemoMapTypeId = "~effect/Layer/MemoMap"
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -133,9 +156,9 @@ const MemoMapTypeId = "~effect/Layer/MemoMap"
  *   const dbLayer = Layer.succeed(Database)({
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
- *   const services = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+ *   const context = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
  *
- *   return ServiceMap.get(services, Database)
+ *   return Context.get(context, Database)
  * })
  * ```
  *
@@ -147,8 +170,8 @@ export interface MemoMap {
   readonly getOrElseMemoize: <RIn, E, ROut>(
     layer: Layer<ROut, E, RIn>,
     scope: Scope.Scope,
-    build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
-  ) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+    build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<ROut>, E, RIn>
+  ) => Effect<Context.Context<ROut>, E, RIn>
 }
 
 /**
@@ -156,9 +179,9 @@ export interface MemoMap {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -191,7 +214,7 @@ const fromBuildUnsafe = <ROut, E, RIn>(
   build: (
     memoMap: MemoMap,
     scope: Scope.Scope
-  ) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  ) => Effect<Context.Context<ROut>, E, RIn>
 ): Layer<ROut, E, RIn> => {
   const self = Object.create(LayerProto)
   self.build = build
@@ -206,15 +229,15 @@ const fromBuildUnsafe = <ROut, E, RIn>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * const databaseLayer = Layer.fromBuild(() =>
  *   Effect.sync(() =>
- *     ServiceMap.make(Database, {
+ *     Context.make(Database, {
  *       query: (sql: string) => Effect.succeed("result")
  *     })
  *   )
@@ -228,7 +251,7 @@ export const fromBuild = <ROut, E, RIn>(
   build: (
     memoMap: MemoMap,
     scope: Scope.Scope
-  ) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  ) => Effect<Context.Context<ROut>, E, RIn>
 ): Layer<ROut, E, RIn> =>
   fromBuildUnsafe((memoMap: MemoMap, scope: Scope.Scope) => {
     const layerScope = Scope.forkUnsafe(scope)
@@ -247,15 +270,15 @@ export const fromBuild = <ROut, E, RIn>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * const databaseLayer = Layer.fromBuildMemo(() =>
  *   Effect.sync(() =>
- *     ServiceMap.make(Database, {
+ *     Context.make(Database, {
  *       query: (sql: string) => Effect.succeed("result")
  *     })
  *   )
@@ -269,7 +292,7 @@ export const fromBuildMemo = <ROut, E, RIn>(
   build: (
     memoMap: MemoMap,
     scope: Scope.Scope
-  ) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  ) => Effect<Context.Context<ROut>, E, RIn>
 ): Layer<ROut, E, RIn> => {
   const self: Layer<ROut, E, RIn> = fromBuild((memoMap, scope) => memoMap.getOrElseMemoize(self, scope, build))
   return self
@@ -282,15 +305,15 @@ class MemoMapImpl implements MemoMap {
 
   readonly map = new Map<Layer<any, any, any>, {
     observers: number
-    effect: Effect<ServiceMap.ServiceMap<any>, any>
+    effect: Effect<Context.Context<any>, any>
     readonly finalizer: (exit: Exit.Exit<unknown, unknown>) => Effect<void>
   }>()
 
   getOrElseMemoize<RIn, E, ROut>(
     layer: Layer<ROut, E, RIn>,
     scope: Scope.Scope,
-    build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
-  ): Effect<ServiceMap.ServiceMap<ROut>, E, RIn> {
+    build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<ROut>, E, RIn>
+  ): Effect<Context.Context<ROut>, E, RIn> {
     if (this.map.has(layer)) {
       const entry = this.map.get(layer)!
       entry.observers++
@@ -300,7 +323,7 @@ class MemoMapImpl implements MemoMap {
       )
     }
     const layerScope = Scope.makeUnsafe()
-    const deferred = Deferred.makeUnsafe<ServiceMap.ServiceMap<ROut>, E>()
+    const deferred = Deferred.makeUnsafe<Context.Context<ROut>, E>()
     const entry = {
       observers: 1,
       effect: Deferred.await(deferred),
@@ -330,9 +353,9 @@ class MemoMapImpl implements MemoMap {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -344,9 +367,9 @@ class MemoMapImpl implements MemoMap {
  *   const dbLayer = Layer.succeed(Database)({
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
- *   const services = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+ *   const context = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
  *
- *   return ServiceMap.get(services, Database)
+ *   return Context.get(context, Database)
  * })
  * ```
  *
@@ -360,9 +383,9 @@ export const makeMemoMapUnsafe = (): MemoMap => new MemoMapImpl()
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -374,9 +397,9 @@ export const makeMemoMapUnsafe = (): MemoMap => new MemoMapImpl()
  *   const dbLayer = Layer.succeed(Database)({
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
- *   const services = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+ *   const context = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
  *
- *   return ServiceMap.get(services, Database)
+ *   return Context.get(context, Database)
  * })
  * ```
  *
@@ -394,8 +417,8 @@ export const makeMemoMap: Effect<MemoMap> = internalEffect.sync(makeMemoMapUnsaf
  * @since 3.13.0
  * @category models
  */
-export class CurrentMemoMap extends ServiceMap.Service<CurrentMemoMap, MemoMap>()("effect/Layer/CurrentMemoMap") {
-  static getOrCreate: <Services>(self: ServiceMap.ServiceMap<Services>) => MemoMap = ServiceMap.getOrElse(
+export class CurrentMemoMap extends Context.Service<CurrentMemoMap, MemoMap>()("effect/Layer/CurrentMemoMap") {
+  static getOrCreate: <Services>(self: Context.Context<Services>) => MemoMap = Context.getOrElse(
     this,
     makeMemoMapUnsafe
   )
@@ -407,13 +430,13 @@ export class CurrentMemoMap extends ServiceMap.Service<CurrentMemoMap, MemoMap>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -426,21 +449,21 @@ export class CurrentMemoMap extends ServiceMap.Service<CurrentMemoMap, MemoMap>(
  *   const dbLayer = Layer.succeed(Database)({
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
- *   const dbServices = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+ *   const dbContext = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
  *
  *   // Build logger layer with same memoization (reuses memo if same layer)
  *   const loggerLayer = Layer.succeed(Logger)({
  *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
  *   })
- *   const loggerServices = yield* Layer.buildWithMemoMap(
+ *   const loggerContext = yield* Layer.buildWithMemoMap(
  *     loggerLayer,
  *     memoMap,
  *     scope
  *   )
  *
  *   return {
- *     database: ServiceMap.get(dbServices, Database),
- *     logger: ServiceMap.get(loggerServices, Logger)
+ *     database: Context.get(dbContext, Database),
+ *     logger: Context.get(loggerContext, Logger)
  *   }
  * })
  * ```
@@ -455,13 +478,13 @@ export const buildWithMemoMap: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -474,21 +497,21 @@ export const buildWithMemoMap: {
    *   const dbLayer = Layer.succeed(Database)({
    *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
    *   })
-   *   const dbServices = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+   *   const dbContext = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
    *
    *   // Build logger layer with same memoization (reuses memo if same layer)
    *   const loggerLayer = Layer.succeed(Logger)({
    *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
    *   })
-   *   const loggerServices = yield* Layer.buildWithMemoMap(
+   *   const loggerContext = yield* Layer.buildWithMemoMap(
    *     loggerLayer,
    *     memoMap,
    *     scope
    *   )
    *
    *   return {
-   *     database: ServiceMap.get(dbServices, Database),
-   *     logger: ServiceMap.get(loggerServices, Logger)
+   *     database: Context.get(dbContext, Database),
+   *     logger: Context.get(loggerContext, Logger)
    *   }
    * })
    * ```
@@ -496,20 +519,20 @@ export const buildWithMemoMap: {
    * @since 2.0.0
    * @category memo map
    */
-  (memoMap: MemoMap, scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  (memoMap: MemoMap, scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<Context.Context<ROut>, E, RIn>
   /**
    * Builds a layer into an `Effect` value, using the specified `MemoMap` to memoize
    * the layer construction.
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -522,21 +545,21 @@ export const buildWithMemoMap: {
    *   const dbLayer = Layer.succeed(Database)({
    *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
    *   })
-   *   const dbServices = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+   *   const dbContext = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
    *
    *   // Build logger layer with same memoization (reuses memo if same layer)
    *   const loggerLayer = Layer.succeed(Logger)({
    *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
    *   })
-   *   const loggerServices = yield* Layer.buildWithMemoMap(
+   *   const loggerContext = yield* Layer.buildWithMemoMap(
    *     loggerLayer,
    *     memoMap,
    *     scope
    *   )
    *
    *   return {
-   *     database: ServiceMap.get(dbServices, Database),
-   *     logger: ServiceMap.get(loggerServices, Logger)
+   *     database: Context.get(dbContext, Database),
+   *     logger: Context.get(loggerContext, Logger)
    *   }
    * })
    * ```
@@ -544,14 +567,14 @@ export const buildWithMemoMap: {
    * @since 2.0.0
    * @category memo map
    */
-  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, memoMap: MemoMap, scope: Scope.Scope): Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, memoMap: MemoMap, scope: Scope.Scope): Effect<Context.Context<ROut>, E, RIn>
 } = dual(3, <RIn, E, ROut>(
   self: Layer<ROut, E, RIn>,
   memoMap: MemoMap,
   scope: Scope.Scope
-): Effect<ServiceMap.ServiceMap<ROut>, E, RIn> =>
+): Effect<Context.Context<ROut>, E, RIn> =>
   internalEffect.provideService(
-    internalEffect.map(self.build(memoMap, scope), ServiceMap.add(CurrentMemoMap, memoMap)),
+    internalEffect.map(self.build(memoMap, scope), Context.add(CurrentMemoMap, memoMap)),
     CurrentMemoMap,
     memoMap
   ))
@@ -561,9 +584,9 @@ export const buildWithMemoMap: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -573,11 +596,11 @@ export const buildWithMemoMap: {
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
  *
- *   // Build the layer into ServiceMap - automatically manages scope and memoization
- *   const services = yield* Layer.build(dbLayer)
+ *   // Build the layer into Context - automatically manages scope and memoization
+ *   const context = yield* Layer.build(dbLayer)
  *
  *   // Extract the specific service from the built layer
- *   const database = ServiceMap.get(services, Database)
+ *   const database = Context.get(context, Database)
  *
  *   return yield* database.query("SELECT * FROM users")
  * })
@@ -588,12 +611,12 @@ export const buildWithMemoMap: {
  */
 export const build = <RIn, E, ROut>(
   self: Layer<ROut, E, RIn>
-): Effect<ServiceMap.ServiceMap<ROut>, E, RIn | Scope.Scope> =>
+): Effect<Context.Context<ROut>, E, RIn | Scope.Scope> =>
   core.withFiber((fiber) =>
     buildWithMemoMap(
       self,
-      CurrentMemoMap.getOrCreate(fiber.services),
-      ServiceMap.getUnsafe(fiber.services, Scope.Scope)
+      CurrentMemoMap.getOrCreate(fiber.context),
+      Context.getUnsafe(fiber.context, Scope.Scope)
     )
   )
 
@@ -606,9 +629,9 @@ export const build = <RIn, E, ROut>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, Scope, ServiceMap } from "effect"
+ * import { Effect, Layer, Scope, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -626,8 +649,8 @@ export const build = <RIn, E, ROut>(
  *   }))
  *
  *   // Build with specific scope - resources tied to this scope
- *   const services = yield* Layer.buildWithScope(dbLayer, scope)
- *   const database = ServiceMap.get(services, Database)
+ *   const context = yield* Layer.buildWithScope(dbLayer, scope)
+ *   const database = Context.get(context, Database)
  *
  *   return yield* database.query("SELECT * FROM users")
  *   // Database will be closed when scope is closed
@@ -647,9 +670,9 @@ export const buildWithScope: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, Scope, ServiceMap } from "effect"
+   * import { Effect, Layer, Scope, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -667,8 +690,8 @@ export const buildWithScope: {
    *   }))
    *
    *   // Build with specific scope - resources tied to this scope
-   *   const services = yield* Layer.buildWithScope(dbLayer, scope)
-   *   const database = ServiceMap.get(services, Database)
+   *   const context = yield* Layer.buildWithScope(dbLayer, scope)
+   *   const database = Context.get(context, Database)
    *
    *   return yield* database.query("SELECT * FROM users")
    *   // Database will be closed when scope is closed
@@ -678,7 +701,7 @@ export const buildWithScope: {
    * @since 2.0.0
    * @category destructors
    */
-  (scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  (scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<Context.Context<ROut>, E, RIn>
   /**
    * Builds a layer into an `Effect` value. Any resources associated with this
    * layer will be released when the specified scope is closed unless their scope
@@ -688,9 +711,9 @@ export const buildWithScope: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, Scope, ServiceMap } from "effect"
+   * import { Effect, Layer, Scope, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -708,8 +731,8 @@ export const buildWithScope: {
    *   }))
    *
    *   // Build with specific scope - resources tied to this scope
-   *   const services = yield* Layer.buildWithScope(dbLayer, scope)
-   *   const database = ServiceMap.get(services, Database)
+   *   const context = yield* Layer.buildWithScope(dbLayer, scope)
+   *   const database = Context.get(context, Database)
    *
    *   return yield* database.query("SELECT * FROM users")
    *   // Database will be closed when scope is closed
@@ -719,15 +742,15 @@ export const buildWithScope: {
    * @since 2.0.0
    * @category destructors
    */
-  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, scope: Scope.Scope): Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, scope: Scope.Scope): Effect<Context.Context<ROut>, E, RIn>
 } = dual(2, <RIn, E, ROut>(
   self: Layer<ROut, E, RIn>,
   scope: Scope.Scope
-): Effect<ServiceMap.ServiceMap<ROut>, E, RIn> =>
+): Effect<Context.Context<ROut>, E, RIn> =>
   core.withFiber((fiber) =>
     buildWithMemoMap(
       self,
-      CurrentMemoMap.getOrCreate(fiber.services),
+      CurrentMemoMap.getOrCreate(fiber.context),
       scope
     )
   ))
@@ -737,13 +760,13 @@ export const buildWithScope: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -780,13 +803,13 @@ export const succeed: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -817,19 +840,19 @@ export const succeed: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Key<I, S>): (resource: S) => Layer<I>
+  <I, S>(service: Context.Key<I, S>): (resource: S) => Layer<I>
   /**
    * Constructs a layer from the specified value.
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -860,12 +883,12 @@ export const succeed: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Key<I, S>, resource: Types.NoInfer<S>): Layer<I>
+  <I, S>(service: Context.Key<I, S>, resource: Types.NoInfer<S>): Layer<I>
 } = function() {
   if (arguments.length === 1) {
-    return (resource: any) => succeedServices(ServiceMap.make(arguments[0], resource))
+    return (resource: any) => succeedContext(Context.make(arguments[0], resource))
   }
-  return succeedServices(ServiceMap.make(arguments[0], arguments[1]))
+  return succeedContext(Context.make(arguments[0], arguments[1]))
 } as any
 
 /**
@@ -873,40 +896,39 @@ export const succeed: {
  * services.
  *
  * This is a more general version of `succeed` that allows you to provide multiple
- * services at once through a `ServiceMap`.
+ * services at once through a `Context`.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
- * const services = ServiceMap.make(Database, {
+ * const context = Context.make(Database, {
  *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
- * })
- *   .pipe(
- *     ServiceMap.add(Logger, {
- *       log: (msg: string) => Effect.sync(() => console.log(msg))
- *     })
- *   )
+ * }).pipe(
+ *   Context.add(Logger, {
+ *     log: (msg: string) => Effect.sync(() => console.log(msg))
+ *   })
+ * )
  *
- * const layer = Layer.succeedServices(services)
+ * const layer = Layer.succeedContext(context)
  * ```
  *
  * @since 2.0.0
  * @category constructors
  */
-export const succeedServices = <A>(services: ServiceMap.ServiceMap<A>): Layer<A> =>
-  fromBuildUnsafe(constant(internalEffect.succeed(services)))
+export const succeedContext = <A>(context: Context.Context<A>): Layer<A> =>
+  fromBuildUnsafe(constant(internalEffect.succeed(context)))
 
 /**
- * A Layer that constructs an empty ServiceMap.
+ * A Layer that constructs an empty Context.
  *
  * This layer provides no services and can be used as a neutral element
  * in layer composition or as a starting point for building layers.
@@ -921,7 +943,7 @@ export const succeedServices = <A>(services: ServiceMap.ServiceMap<A>): Layer<A>
  * @since 2.0.0
  * @category constructors
  */
-export const empty: Layer<never> = succeedServices(ServiceMap.empty())
+export const empty: Layer<never> = succeedContext(Context.empty())
 
 /**
  * Lazily constructs a layer from the specified value.
@@ -931,9 +953,9 @@ export const empty: Layer<never> = succeedServices(ServiceMap.empty())
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -954,9 +976,9 @@ export const sync: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -968,7 +990,7 @@ export const sync: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Key<I, S>): (evaluate: LazyArg<S>) => Layer<I>
+  <I, S>(service: Context.Key<I, S>): (evaluate: LazyArg<S>) => Layer<I>
   /**
    * Lazily constructs a layer from the specified value.
    *
@@ -977,9 +999,9 @@ export const sync: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -991,31 +1013,31 @@ export const sync: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Key<I, S>, evaluate: LazyArg<S>): Layer<I>
+  <I, S>(service: Context.Key<I, S>, evaluate: LazyArg<Types.NoInfer<S>>): Layer<I>
 } = function() {
   if (arguments.length === 1) {
-    return (evaluate: LazyArg<any>) => syncServices(() => ServiceMap.make(arguments[0], evaluate()))
+    return (evaluate: LazyArg<any>) => syncContext(() => Context.make(arguments[0], evaluate()))
   }
-  return syncServices(() => ServiceMap.make(arguments[0], arguments[1]()))
+  return syncContext(() => Context.make(arguments[0], arguments[1]()))
 } as any
 
 /**
  * Lazily constructs a layer from the specified value, which must return one or more
  * services.
  *
- * This is a lazy version of `succeedServices` where the ServiceMap is computed
+ * This is a lazy version of `succeedContext` where the Context is computed
  * synchronously only when the layer is built.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * const layer = Layer.syncServices(() =>
- *   ServiceMap.make(Database, {
+ * const layer = Layer.syncContext(() =>
+ *   Context.make(Database, {
  *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  *   })
  * )
@@ -1024,7 +1046,7 @@ export const sync: {
  * @since 2.0.0
  * @category constructors
  */
-export const syncServices = <A>(evaluate: LazyArg<ServiceMap.ServiceMap<A>>): Layer<A> =>
+export const syncContext = <A>(evaluate: LazyArg<Context.Context<A>>): Layer<A> =>
   fromBuildMemo(constant(internalEffect.sync(evaluate)))
 
 /**
@@ -1042,9 +1064,9 @@ export const syncServices = <A>(evaluate: LazyArg<ServiceMap.ServiceMap<A>>): La
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -1074,9 +1096,9 @@ export const effect: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -1090,7 +1112,7 @@ export const effect: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Key<I, S>): <E, R>(
+  <I, S>(service: Context.Key<I, S>): <E, R>(
     effect: Effect<S, E, R>
   ) => Layer<I, E, Exclude<R, Scope.Scope>>
   /**
@@ -1108,9 +1130,9 @@ export const effect: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -1124,7 +1146,7 @@ export const effect: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S, E, R>(service: ServiceMap.Key<I, S>, effect: Effect<S, E, R>): Layer<I, E, Exclude<R, Scope.Scope>>
+  <I, S, E, R>(service: Context.Key<I, S>, effect: Effect<Types.NoInfer<S>, E, R>): Layer<I, E, Exclude<R, Scope.Scope>>
 } = function() {
   if (arguments.length === 1) {
     return (effect: any) => effectImpl(arguments[0], effect)
@@ -1133,10 +1155,10 @@ export const effect: {
 } as any
 
 const effectImpl = <I, S, E, R>(
-  service: ServiceMap.Key<I, S>,
+  service: Context.Key<I, S>,
   effect: Effect<S, E, R>
 ): Layer<I, E, Exclude<R, Scope.Scope>> =>
-  effectServices(internalEffect.map(effect, (value) => ServiceMap.make(service, value)))
+  effectContext(internalEffect.map(effect, (value) => Context.make(service, value)))
 
 /**
  * Constructs a layer from the specified scoped effect, which must return one
@@ -1147,15 +1169,15 @@ const effectImpl = <I, S, E, R>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<
+ * class Database extends Context.Service<
  *   Database,
  *   { readonly query: (sql: string) => Effect.Effect<string> }
  * >()("Database") {}
  *
- * const layer = Layer.effectServices(
- *   Effect.succeed(ServiceMap.make(Database, {
+ * const layer = Layer.effectContext(
+ *   Effect.succeed(Context.make(Database, {
  *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  *   }))
  * )
@@ -1164,8 +1186,8 @@ const effectImpl = <I, S, E, R>(
  * @since 2.0.0
  * @category constructors
  */
-export const effectServices = <A, E, R>(
-  effect: Effect<ServiceMap.ServiceMap<A>, E, R>
+export const effectContext = <A, E, R>(
+  effect: Effect<Context.Context<A>, E, R>
 ): Layer<A, E, Exclude<R, Scope.Scope>> => fromBuildMemo((_, scope) => Scope.provide(effect, scope))
 
 /**
@@ -1195,7 +1217,34 @@ export const effectServices = <A, E, R>(
  * @category constructors
  */
 export const effectDiscard = <X, E, R>(effect: Effect<X, E, R>): Layer<never, E, Exclude<R, Scope.Scope>> =>
-  effectServices(internalEffect.as(effect, ServiceMap.empty()))
+  effectContext(internalEffect.as(effect, Context.empty()))
+
+/**
+ * Lazily constructs a layer using the specified factory.
+ *
+ * The factory is evaluated only when the suspended layer is first built, and
+ * the result is memoized with normal layer sharing semantics.
+ *
+ * @example
+ * ```ts
+ * import { Layer, Context } from "effect"
+ *
+ * class Config extends Context.Service<Config, string>()("Config") {}
+ *
+ * const useProd = true
+ *
+ * const layer = Layer.suspend(() =>
+ *   useProd
+ *     ? Layer.succeed(Config)("https://api.example.com")
+ *     : Layer.succeed(Config)("http://localhost:3000")
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export const suspend = <A, E, R>(evaluate: LazyArg<Layer<A, E, R>>): Layer<A, E, R> =>
+  fromBuildMemo((memoMap, scope) => internalEffect.suspend(() => evaluate().build(memoMap, scope)))
 
 /**
  * Unwraps a Layer from an Effect, flattening the nested structure.
@@ -1206,9 +1255,9 @@ export const effectDiscard = <X, E, R>(effect: Effect<X, E, R>): Layer<never, E,
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -1225,8 +1274,8 @@ export const effectDiscard = <X, E, R>(effect: Effect<X, E, R>): Layer<never, E,
 export const unwrap = <A, E1, R1, E, R>(
   self: Effect<Layer<A, E1, R1>, E, R>
 ): Layer<A, E | E1, R1 | Exclude<R, Scope.Scope>> => {
-  const service = ServiceMap.Service<Layer<A, E1, R1>>("effect/Layer/unwrap")
-  return flatMap(effect(service)(self), ServiceMap.get(service))
+  const service = Context.Service<Layer<A, E1, R1>>("effect/Layer/unwrap")
+  return flatMap(effect(service)(self), Context.get(service))
 }
 
 const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<never, any, any>>]>(
@@ -1234,7 +1283,7 @@ const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<n
   memoMap: MemoMap,
   scope: Scope.Scope
 ): Effect<
-  ServiceMap.ServiceMap<{ [k in keyof Layers]: Success<Layers[k]> }[number]>,
+  Context.Context<{ [k in keyof Layers]: Success<Layers[k]> }[number]>,
   { [k in keyof Layers]: Error<Layers[k]> }[number],
   { [k in keyof Layers]: Services<Layers[k]> }[number]
 > => {
@@ -1242,7 +1291,7 @@ const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<n
   return internalEffect.forEach(layers, (layer) => layer.build(memoMap, Scope.forkUnsafe(parentScope, "sequential")), {
     concurrency: layers.length
   }).pipe(
-    internalEffect.map((services) => ServiceMap.mergeAll(...(services as any)))
+    internalEffect.map((context) => Context.mergeAll(...(context as any)))
   )
 }
 
@@ -1254,13 +1303,13 @@ const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<n
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -1293,13 +1342,13 @@ export const mergeAll = <Layers extends [Layer<never, any, any>, ...Array<Layer<
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -1325,13 +1374,13 @@ export const merge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -1357,13 +1406,13 @@ export const merge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -1396,13 +1445,13 @@ export const merge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -1428,13 +1477,13 @@ export const merge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -1466,9 +1515,9 @@ const provideWith = (
   self: Layer<any, any, any>,
   that: Layer<any, any, any> | ReadonlyArray<Layer<any, any, any>>,
   f: (
-    selfServices: ServiceMap.ServiceMap<any>,
-    thatServices: ServiceMap.ServiceMap<any>
-  ) => ServiceMap.ServiceMap<any>
+    selfContext: Context.Context<any>,
+    thatContext: Context.Context<any>
+  ) => Context.Context<any>
 ) =>
   fromBuild((memoMap, scope) =>
     internalEffect.flatMap(
@@ -1477,7 +1526,7 @@ const provideWith = (
         : (that as Layer<any, any, any>).build(memoMap, scope),
       (context) =>
         self.build(memoMap, scope).pipe(
-          internalEffect.provideServices(context),
+          internalEffect.provideContext(context),
           internalEffect.map((merged) => f(merged, context))
         )
     )
@@ -1490,20 +1539,20 @@ const provideWith = (
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class UserService extends ServiceMap.Service<UserService, {
+ * class UserService extends Context.Service<UserService, {
  *   readonly getUser: (id: string) => Effect.Effect<{
  *     id: string
  *     name: string
  *   }>
  * }>()("UserService") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -1557,20 +1606,20 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
    *   }>
    * }>()("UserService") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -1624,20 +1673,20 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
    *   }>
    * }>()("UserService") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -1698,20 +1747,20 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
    *   }>
    * }>()("UserService") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -1765,20 +1814,20 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
    *   }>
    * }>()("UserService") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -1842,17 +1891,17 @@ export const provide: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
- * class UserService extends ServiceMap.Service<UserService, {
+ * class UserService extends Context.Service<UserService, {
  *   readonly getUser: (id: string) => Effect.Effect<{
  *     id: string
  *     name: string
@@ -1915,17 +1964,17 @@ export const provideMerge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
@@ -1988,17 +2037,17 @@ export const provideMerge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
@@ -2068,17 +2117,17 @@ export const provideMerge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
@@ -2141,17 +2190,17 @@ export const provideMerge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
@@ -2219,7 +2268,7 @@ export const provideMerge: {
   provideWith(
     self,
     that,
-    (self, that) => ServiceMap.merge(that, self)
+    (self, that) => Context.merge(that, self)
   ))
 
 /**
@@ -2227,18 +2276,18 @@ export const provideMerge: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Config extends ServiceMap.Service<Config, {
+ * class Config extends Context.Service<Config, {
  *   readonly dbUrl: string
  *   readonly logLevel: string
  * }>()("Config") {}
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -2250,8 +2299,8 @@ export const provideMerge: {
  *
  * // Dynamically create services based on config
  * const dynamicServiceLayer = configLayer.pipe(
- *   Layer.flatMap((services) => {
- *     const config = ServiceMap.get(services, Config)
+ *   Layer.flatMap((context) => {
+ *     const config = Context.get(context, Config)
  *
  *     // Create database layer based on config
  *     const dbLayer = Layer.succeed(Database)({
@@ -2298,18 +2347,18 @@ export const flatMap: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Config extends ServiceMap.Service<Config, {
+   * class Config extends Context.Service<Config, {
    *   readonly dbUrl: string
    *   readonly logLevel: string
    * }>()("Config") {}
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -2321,8 +2370,8 @@ export const flatMap: {
    *
    * // Dynamically create services based on config
    * const dynamicServiceLayer = configLayer.pipe(
-   *   Layer.flatMap((services) => {
-   *     const config = ServiceMap.get(services, Config)
+   *   Layer.flatMap((context) => {
+   *     const config = Context.get(context, Config)
    *
    *     // Create database layer based on config
    *     const dbLayer = Layer.succeed(Database)({
@@ -2363,24 +2412,24 @@ export const flatMap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, A2, E2, R2>(f: (context: ServiceMap.ServiceMap<A>) => Layer<A2, E2, R2>): <E, R>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>
+  <A, A2, E2, R2>(f: (context: Context.Context<A>) => Layer<A2, E2, R2>): <E, R>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>
   /**
    * Constructs a layer dynamically based on the output of this layer.
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Config extends ServiceMap.Service<Config, {
+   * class Config extends Context.Service<Config, {
    *   readonly dbUrl: string
    *   readonly logLevel: string
    * }>()("Config") {}
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -2392,8 +2441,8 @@ export const flatMap: {
    *
    * // Dynamically create services based on config
    * const dynamicServiceLayer = configLayer.pipe(
-   *   Layer.flatMap((services) => {
-   *     const config = ServiceMap.get(services, Config)
+   *   Layer.flatMap((context) => {
+   *     const config = Context.get(context, Config)
    *
    *     // Create database layer based on config
    *     const dbLayer = Layer.succeed(Database)({
@@ -2436,11 +2485,11 @@ export const flatMap: {
    */
   <A, E, R, A2, E2, R2>(
     self: Layer<A, E, R>,
-    f: (context: ServiceMap.ServiceMap<A>) => Layer<A2, E2, R2>
+    f: (context: Context.Context<A>) => Layer<A2, E2, R2>
   ): Layer<A2, E | E2, R | R2>
 } = dual(2, <A, E, R, A2, E2, R2>(
   self: Layer<A, E, R>,
-  f: (context: ServiceMap.ServiceMap<A>) => Layer<A2, E2, R2>
+  f: (context: Context.Context<A>) => Layer<A2, E2, R2>
 ): Layer<A2, E | E2, R | R2> =>
   fromBuild((memoMap, scope) =>
     internalEffect.flatMap(
@@ -2462,7 +2511,7 @@ export const tap: {
    * @since 4.0.0
    * @category sequencing
    */
-  <ROut, XR extends ROut, RIn2, E2, X>(f: (context: ServiceMap.ServiceMap<XR>) => Effect<X, E2, RIn2>): <RIn, E>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
+  <ROut, XR extends ROut, RIn2, E2, X>(f: (context: Context.Context<XR>) => Effect<X, E2, RIn2>): <RIn, E>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
   /**
    * Performs the specified effect if this layer succeeds.
    *
@@ -2471,16 +2520,16 @@ export const tap: {
    */
   <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(
     self: Layer<ROut, E, RIn>,
-    f: (context: ServiceMap.ServiceMap<XR>) => Effect<X, E2, RIn2>
+    f: (context: Context.Context<XR>) => Effect<X, E2, RIn2>
   ): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>
 } = dual(2, <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(
   self: Layer<ROut, E, RIn>,
-  f: (context: ServiceMap.ServiceMap<XR>) => Effect<X, E2, RIn2>
+  f: (context: Context.Context<XR>) => Effect<X, E2, RIn2>
 ): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>> =>
   fromBuild((memoMap, scope) =>
     internalEffect.flatMap(
       self.build(memoMap, scope),
-      (context) => Scope.provide(internalEffect.as(f(context as ServiceMap.ServiceMap<XR>), context), scope)
+      (context) => Scope.provide(internalEffect.as(f(context as Context.Context<XR>), context), scope)
     )
   ))
 
@@ -2576,13 +2625,13 @@ export const tapCause: {
  *
  * @example
  * ```ts
- * import { Data, Effect, Layer, ServiceMap } from "effect"
+ * import { Data, Effect, Layer, Context } from "effect"
  *
  * class DatabaseError extends Data.TaggedError("DatabaseError")<{
  *   message: string
  * }> {}
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -2652,11 +2701,11 @@ export {
  *
  * @example
  * ```ts
- * import { Data, Effect, Layer, ServiceMap } from "effect"
+ * import { Data, Effect, Layer, Context } from "effect"
  *
  * class ConfigError extends Data.TaggedError("ConfigError") {}
  *
- * class Config extends ServiceMap.Service<Config, {
+ * class Config extends Context.Service<Config, {
  *   readonly apiUrl: string
  * }>()("Config") {}
  *
@@ -2678,11 +2727,11 @@ export const catchTag: {
    *
    * @example
    * ```ts
-   * import { Data, Effect, Layer, ServiceMap } from "effect"
+   * import { Data, Effect, Layer, Context } from "effect"
    *
    * class ConfigError extends Data.TaggedError("ConfigError") {}
    *
-   * class Config extends ServiceMap.Service<Config, {
+   * class Config extends Context.Service<Config, {
    *   readonly apiUrl: string
    * }>()("Config") {}
    *
@@ -2715,11 +2764,11 @@ export const catchTag: {
    *
    * @example
    * ```ts
-   * import { Data, Effect, Layer, ServiceMap } from "effect"
+   * import { Data, Effect, Layer, Context } from "effect"
    *
    * class ConfigError extends Data.TaggedError("ConfigError") {}
    *
-   * class Config extends ServiceMap.Service<Config, {
+   * class Config extends Context.Service<Config, {
    *   readonly apiUrl: string
    * }>()("Config") {}
    *
@@ -2778,7 +2827,7 @@ export const catchTag: {
  *
  * @example
  * ```ts
- * import { Data, Effect, Layer, ServiceMap } from "effect"
+ * import { Data, Effect, Layer, Context } from "effect"
  *
  * class DatabaseError extends Data.TaggedError("DatabaseError")<{
  *   message: string
@@ -2788,11 +2837,11 @@ export const catchTag: {
  *   reason: string
  * }> {}
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -2836,7 +2885,7 @@ export const catchCause: {
    *
    * @example
    * ```ts
-   * import { Data, Effect, Layer, ServiceMap } from "effect"
+   * import { Data, Effect, Layer, Context } from "effect"
    *
    * class DatabaseError extends Data.TaggedError("DatabaseError")<{
    *   message: string
@@ -2846,11 +2895,11 @@ export const catchCause: {
    *   reason: string
    * }> {}
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -2894,7 +2943,7 @@ export const catchCause: {
    *
    * @example
    * ```ts
-   * import { Data, Effect, Layer, ServiceMap } from "effect"
+   * import { Data, Effect, Layer, Context } from "effect"
    *
    * class DatabaseError extends Data.TaggedError("DatabaseError")<{
    *   message: string
@@ -2904,11 +2953,11 @@ export const catchCause: {
    *   reason: string
    * }> {}
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -2998,7 +3047,7 @@ export const updateService: {
    * @since 3.13.0
    * @category utils
    */
-  <I, A>(service: ServiceMap.Key<I, A>, f: (a: A) => A): <A1, E1, R1>(layer: Layer<A1, E1, R1>) => Layer<A1, E1, I | R1>
+  <I, A>(service: Context.Key<I, A>, f: (a: Types.NoInfer<A>) => A): <A1, E1, R1>(layer: Layer<A1, E1, R1>) => Layer<A1, E1, I | R1>
   /**
    * Updates a service in the context with a new implementation.
    *
@@ -3017,13 +3066,17 @@ export const updateService: {
    * @since 3.13.0
    * @category utils
    */
-  <A1, E1, R1, I, A>(layer: Layer<A1, E1, R1>, service: ServiceMap.Key<I, A>, f: (a: A) => A): Layer<A1, E1, I | R1>
+  <A1, E1, R1, I, A>(
+    layer: Layer<A1, E1, R1>,
+    service: Context.Key<I, A>,
+    f: (a: Types.NoInfer<A>) => A
+  ): Layer<A1, E1, I | R1>
 } = dual(
   3,
   <A1, E1, R1, I, A>(
     layer: Layer<A1, E1, R1>,
-    service: ServiceMap.Key<I, A>,
-    f: (a: A) => A
+    service: Context.Key<I, A>,
+    f: (a: Types.NoInfer<A>) => A
   ): Layer<A1, E1, I | R1> => provide(layer, effect(service, internalEffect.map(service.asEffect(), f)))
 )
 
@@ -3032,9 +3085,9 @@ export const updateService: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, Ref, ServiceMap } from "effect"
+ * import { Effect, Layer, Ref, Context } from "effect"
  *
- * class Counter extends ServiceMap.Service<Counter, {
+ * class Counter extends Context.Service<Counter, {
  *   readonly count: number
  *   readonly increment: () => Effect.Effect<number>
  * }>()("Counter") {}
@@ -3087,14 +3140,14 @@ export const fresh = <A, E, R>(self: Layer<A, E, R>): Layer<A, E, R> =>
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap } from "effect"
+ * import { Console, Effect, Layer, Context } from "effect"
  *
- * class HttpServer extends ServiceMap.Service<HttpServer, {
+ * class HttpServer extends Context.Service<HttpServer, {
  *   readonly start: () => Effect.Effect<string>
  *   readonly stop: () => Effect.Effect<string>
  * }>()("HttpServer") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -3172,9 +3225,9 @@ type AnyEffectOrStream =
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class UserService extends ServiceMap.Service<UserService, {
+ * class UserService extends Context.Service<UserService, {
  *   readonly config: { apiUrl: string }
  *   readonly getUser: (
  *     id: string
@@ -3219,9 +3272,9 @@ export const mock: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly config: { apiUrl: string }
    *   readonly getUser: (
    *     id: string
@@ -3258,7 +3311,7 @@ export const mock: {
    * @since 4.0.0
    * @category Testing
    */
-  <I, S extends object>(service: ServiceMap.Key<I, S>): (implementation: PartialEffectful<S>) => Layer<I>
+  <I, S extends object>(service: Context.Key<I, S>): (implementation: PartialEffectful<S>) => Layer<I>
   /**
    * Creates a mock layer for testing purposes. You can provide a partial
    * implementation of the service, and any methods not provided will
@@ -3266,9 +3319,9 @@ export const mock: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly config: { apiUrl: string }
    *   readonly getUser: (
    *     id: string
@@ -3306,7 +3359,7 @@ export const mock: {
    * @category Testing
    */
   <I, S extends object>(
-    service: ServiceMap.Key<I, S>,
+    service: Context.Key<I, S>,
     implementation: Types.NoInfer<PartialEffectful<S>>
   ): Layer<I>
 } = function() {
@@ -3316,7 +3369,7 @@ export const mock: {
   return mockImpl(arguments[0], arguments[1])
 } as any
 
-const mockImpl = <I, S extends object>(service: ServiceMap.Key<I, S>, implementation: PartialEffectful<S>): Layer<I> =>
+const mockImpl = <I, S extends object>(service: Context.Key<I, S>, implementation: PartialEffectful<S>): Layer<I> =>
   succeed(service)(
     new Proxy({ ...implementation as object } as S, {
       get(target, prop, _receiver) {
@@ -3488,9 +3541,9 @@ export interface SpanOptions extends Tracer.SpanOptions {
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap, type Tracer } from "effect"
+ * import { Console, Effect, Layer, Context, type Tracer } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -3549,9 +3602,9 @@ export const span = (
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap, Tracer } from "effect"
+ * import { Console, Effect, Layer, Context, Tracer } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -3578,7 +3631,7 @@ export const span = (
  * @category tracing
  */
 export const parentSpan = (span: Tracer.AnySpan): Layer<Tracer.ParentSpan> =>
-  succeedServices(Tracer.ParentSpan.serviceMap(span))
+  succeedContext(Tracer.ParentSpan.context(span))
 
 /**
  * Wraps a Layer with a new tracing span, making all operations in the layer
@@ -3590,13 +3643,13 @@ export const parentSpan = (span: Tracer.AnySpan): Layer<Tracer.ParentSpan> =>
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -3649,13 +3702,13 @@ export const withSpan: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -3710,13 +3763,13 @@ export const withSpan: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -3800,13 +3853,13 @@ export const withSpan: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap, Tracer } from "effect"
+ * import { Effect, Layer, Context, Tracer } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Cache extends ServiceMap.Service<Cache, {
+ * class Cache extends Context.Service<Cache, {
  *   readonly get: (key: string) => Effect.Effect<string | null>
  * }>()("Cache") {}
  *
@@ -3835,9 +3888,9 @@ export const withSpan: {
  *       Layer.withParentSpan(parentSpan)
  *     )
  *
- *     const services = yield* Layer.build(AppLayer)
- *     const database = ServiceMap.get(services, Database)
- *     const cache = ServiceMap.get(services, Cache)
+ *     const context = yield* Layer.build(AppLayer)
+ *     const database = Context.get(context, Database)
+ *     const cache = Context.get(context, Cache)
  *
  *     const dbResult = yield* database.query("SELECT * FROM users")
  *     const cacheResult = yield* cache.get("user:123")
@@ -3860,13 +3913,13 @@ export const withParentSpan: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap, Tracer } from "effect"
+   * import { Effect, Layer, Context, Tracer } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Cache extends ServiceMap.Service<Cache, {
+   * class Cache extends Context.Service<Cache, {
    *   readonly get: (key: string) => Effect.Effect<string | null>
    * }>()("Cache") {}
    *
@@ -3895,9 +3948,9 @@ export const withParentSpan: {
    *       Layer.withParentSpan(parentSpan)
    *     )
    *
-   *     const services = yield* Layer.build(AppLayer)
-   *     const database = ServiceMap.get(services, Database)
-   *     const cache = ServiceMap.get(services, Cache)
+   *     const context = yield* Layer.build(AppLayer)
+   *     const database = Context.get(context, Database)
+   *     const cache = Context.get(context, Cache)
    *
    *     const dbResult = yield* database.query("SELECT * FROM users")
    *     const cacheResult = yield* cache.get("user:123")
@@ -3922,13 +3975,13 @@ export const withParentSpan: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap, Tracer } from "effect"
+   * import { Effect, Layer, Context, Tracer } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Cache extends ServiceMap.Service<Cache, {
+   * class Cache extends Context.Service<Cache, {
    *   readonly get: (key: string) => Effect.Effect<string | null>
    * }>()("Cache") {}
    *
@@ -3957,9 +4010,9 @@ export const withParentSpan: {
    *       Layer.withParentSpan(parentSpan)
    *     )
    *
-   *     const services = yield* Layer.build(AppLayer)
-   *     const database = ServiceMap.get(services, Database)
-   *     const cache = ServiceMap.get(services, Cache)
+   *     const context = yield* Layer.build(AppLayer)
+   *     const database = Context.get(context, Database)
+   *     const cache = Context.get(context, Cache)
    *
    *     const dbResult = yield* database.query("SELECT * FROM users")
    *     const cacheResult = yield* cache.get("user:123")