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

package/dist/Layer.d.ts

@@ -20,15 +20,16 @@
 import type { 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 type { Effect } from "./Effect.ts";
 import type * as Exit from "./Exit.ts";
 import type { LazyArg } from "./Function.ts";
 import { type Pipeable } from "./Pipeable.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";
 declare const TypeId = "~effect/Layer";
 /**
  * A Layer describes how to build one or more services for dependency injection.
@@ -42,6 +43,24 @@ declare const TypeId = "~effect/Layer";
  * @category models
  */
 export interface Layer<in ROut, out E = never, out RIn = never> extends Variance<ROut, E, RIn>, Pipeable {
+    [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.
@@ -102,9 +121,9 @@ declare 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") {}
  *
@@ -116,9 +135,9 @@ declare 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)
  * })
  * ```
  *
@@ -127,16 +146,16 @@ declare const MemoMapTypeId = "~effect/Layer/MemoMap";
  */
 export interface MemoMap {
     readonly [MemoMapTypeId]: typeof MemoMapTypeId;
-    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>;
+    readonly getOrElseMemoize: <RIn, E, ROut>(layer: Layer<ROut, E, RIn>, scope: Scope.Scope, build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<ROut>, E, RIn>) => Effect<Context.Context<ROut>, E, RIn>;
 }
 /**
  * Returns `true` if the specified value is a `Layer`, `false` otherwise.
  *
  * @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") {}
  *
@@ -161,15 +180,15 @@ export declare const isLayer: (u: unknown) => u is Layer<unknown, unknown, unkno
  *
  * @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")
  *     })
  *   )
@@ -179,7 +198,7 @@ export declare const isLayer: (u: unknown) => u is Layer<unknown, unknown, unkno
  * @since 4.0.0
  * @category constructors
  */
-export declare const fromBuild: <ROut, E, RIn>(build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>) => Layer<ROut, E, RIn>;
+export declare const fromBuild: <ROut, E, RIn>(build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<ROut>, E, RIn>) => Layer<ROut, E, RIn>;
 /**
  * Constructs a Layer from a function that uses a `MemoMap` and `Scope` to build the layer,
  * with automatic memoization.
@@ -189,15 +208,15 @@ export declare const fromBuild: <ROut, E, RIn>(build: (memoMap: MemoMap, scope:
  *
  * @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")
  *     })
  *   )
@@ -207,15 +226,15 @@ export declare const fromBuild: <ROut, E, RIn>(build: (memoMap: MemoMap, scope:
  * @since 4.0.0
  * @category constructors
  */
-export declare const fromBuildMemo: <ROut, E, RIn>(build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>) => Layer<ROut, E, RIn>;
+export declare const fromBuildMemo: <ROut, E, RIn>(build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<ROut>, E, RIn>) => Layer<ROut, E, RIn>;
 /**
  * Constructs a `MemoMap` that can be used to build additional layers.
  *
  * @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") {}
  *
@@ -227,9 +246,9 @@ export declare const fromBuildMemo: <ROut, E, RIn>(build: (memoMap: MemoMap, sco
  *   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)
  * })
  * ```
  *
@@ -242,9 +261,9 @@ export declare const makeMemoMapUnsafe: () => 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") {}
  *
@@ -256,9 +275,9 @@ export declare const makeMemoMapUnsafe: () => 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)
  * })
  * ```
  *
@@ -266,7 +285,7 @@ export declare const makeMemoMapUnsafe: () => MemoMap;
  * @category memo map
  */
 export declare const makeMemoMap: Effect<MemoMap>;
-declare const CurrentMemoMap_base: ServiceMap.ServiceClass<CurrentMemoMap, "effect/Layer/CurrentMemoMap", MemoMap>;
+declare const CurrentMemoMap_base: Context.ServiceClass<CurrentMemoMap, "effect/Layer/CurrentMemoMap", MemoMap>;
 /**
  * A service reference for the current `MemoMap` used in layer construction.
  *
@@ -277,7 +296,7 @@ declare const CurrentMemoMap_base: ServiceMap.ServiceClass<CurrentMemoMap, "effe
  * @category models
  */
 export declare class CurrentMemoMap extends CurrentMemoMap_base {
-    static getOrCreate: <Services>(self: ServiceMap.ServiceMap<Services>) => MemoMap;
+    static getOrCreate: <Services>(self: Context.Context<Services>) => MemoMap;
 }
 /**
  * Builds a layer into an `Effect` value, using the specified `MemoMap` to memoize
@@ -285,13 +304,13 @@ export declare class CurrentMemoMap extends CurrentMemoMap_base {
  *
  * @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") {}
  *
@@ -304,21 +323,21 @@ export declare class CurrentMemoMap extends CurrentMemoMap_base {
  *   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)
  *   }
  * })
  * ```
@@ -333,13 +352,13 @@ export declare 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") {}
      *
@@ -352,21 +371,21 @@ export declare 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)
      *   }
      * })
      * ```
@@ -374,20 +393,20 @@ export declare 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") {}
      *
@@ -400,21 +419,21 @@ export declare 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)
      *   }
      * })
      * ```
@@ -422,16 +441,16 @@ export declare 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>;
 };
 /**
  * Builds a layer into a scoped 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") {}
  *
@@ -441,11 +460,11 @@ export declare 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")
  * })
@@ -454,7 +473,7 @@ export declare const buildWithMemoMap: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const build: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn | Scope.Scope>;
+export declare const build: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<Context.Context<ROut>, E, RIn | Scope.Scope>;
 /**
  * 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
@@ -464,9 +483,9 @@ export declare const build: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<
  *
  * @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") {}
  *
@@ -484,8 +503,8 @@ export declare const build: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<
  *   }))
  *
  *   // 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
@@ -505,9 +524,9 @@ export declare 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") {}
      *
@@ -525,8 +544,8 @@ export declare 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
@@ -536,7 +555,7 @@ export declare 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
@@ -546,9 +565,9 @@ export declare 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") {}
      *
@@ -566,8 +585,8 @@ export declare 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
@@ -577,20 +596,20 @@ export declare 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>;
 };
 /**
  * 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") {}
  *
@@ -627,13 +646,13 @@ export declare 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") {}
      *
@@ -664,19 +683,19 @@ export declare 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") {}
      *
@@ -707,45 +726,44 @@ export declare 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>;
 };
 /**
  * Constructs a layer from the specified value, which must return one or more
  * 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 declare const succeedServices: <A>(services: ServiceMap.ServiceMap<A>) => Layer<A>;
+export declare const succeedContext: <A>(context: Context.Context<A>) => Layer<A>;
 /**
- * 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.
@@ -769,9 +787,9 @@ export declare const empty: Layer<never>;
  *
  * @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") {}
  *
@@ -792,9 +810,9 @@ export declare 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") {}
      *
@@ -806,7 +824,7 @@ export declare 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.
      *
@@ -815,9 +833,9 @@ export declare 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") {}
      *
@@ -829,25 +847,25 @@ export declare 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>;
 };
 /**
  * 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}`)
  *   })
  * )
@@ -856,7 +874,7 @@ export declare const sync: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const syncServices: <A>(evaluate: LazyArg<ServiceMap.ServiceMap<A>>) => Layer<A>;
+export declare const syncContext: <A>(evaluate: LazyArg<Context.Context<A>>) => Layer<A>;
 /**
  * Constructs a layer from the specified scoped effect.
  *
@@ -872,9 +890,9 @@ export declare const syncServices: <A>(evaluate: LazyArg<ServiceMap.ServiceMap<A
  *
  * @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") {}
  *
@@ -904,9 +922,9 @@ export declare 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") {}
      *
@@ -920,7 +938,7 @@ export declare const effect: {
      * @since 2.0.0
      * @category constructors
      */
-    <I, S>(service: ServiceMap.Key<I, S>): <E, R>(effect: Effect<S, E, R>) => Layer<I, E, Exclude<R, Scope.Scope>>;
+    <I, S>(service: Context.Key<I, S>): <E, R>(effect: Effect<S, E, R>) => Layer<I, E, Exclude<R, Scope.Scope>>;
     /**
      * Constructs a layer from the specified scoped effect.
      *
@@ -936,9 +954,9 @@ export declare 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") {}
      *
@@ -952,7 +970,7 @@ export declare 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>>;
 };
 /**
  * Constructs a layer from the specified scoped effect, which must return one
@@ -963,15 +981,15 @@ export declare const effect: {
  *
  * @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}`)
  *   }))
  * )
@@ -980,7 +998,7 @@ export declare const effect: {
  * @since 2.0.0
  * @category constructors
  */
-export declare const effectServices: <A, E, R>(effect: Effect<ServiceMap.ServiceMap<A>, E, R>) => Layer<A, E, Exclude<R, Scope.Scope>>;
+export declare const effectContext: <A, E, R>(effect: Effect<Context.Context<A>, E, R>) => Layer<A, E, Exclude<R, Scope.Scope>>;
 /**
  * Constructs a layer from the specified scoped effect.
  *
@@ -1008,6 +1026,31 @@ export declare const effectServices: <A, E, R>(effect: Effect<ServiceMap.Service
  * @category constructors
  */
 export declare const effectDiscard: <X, E, R>(effect: Effect<X, E, R>) => Layer<never, E, Exclude<R, Scope.Scope>>;
+/**
+ * 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 declare const suspend: <A, E, R>(evaluate: LazyArg<Layer<A, E, R>>) => Layer<A, E, R>;
 /**
  * Unwraps a Layer from an Effect, flattening the nested structure.
  *
@@ -1017,9 +1060,9 @@ export declare const effectDiscard: <X, E, R>(effect: Effect<X, E, R>) => 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") {}
  *
@@ -1042,13 +1085,13 @@ export declare const unwrap: <A, E1, R1, E, R>(self: Effect<Layer<A, E1, R1>, 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") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -1074,13 +1117,13 @@ export declare const mergeAll: <Layers extends [Layer<never, any, any>, ...Array
  *
  * @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") {}
  *
@@ -1106,13 +1149,13 @@ export declare 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") {}
      *
@@ -1138,13 +1181,13 @@ export declare 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") {}
      *
@@ -1170,13 +1213,13 @@ export declare 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") {}
      *
@@ -1202,13 +1245,13 @@ export declare 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") {}
      *
@@ -1234,20 +1277,20 @@ export declare 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 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") {}
  *
@@ -1301,20 +1344,20 @@ export declare 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") {}
      *
@@ -1368,20 +1411,20 @@ export declare 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") {}
      *
@@ -1435,20 +1478,20 @@ export declare 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") {}
      *
@@ -1502,20 +1545,20 @@ export declare 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") {}
      *
@@ -1570,17 +1613,17 @@ export declare 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
@@ -1643,17 +1686,17 @@ export declare 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
@@ -1716,17 +1759,17 @@ export declare 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
@@ -1789,17 +1832,17 @@ export declare 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
@@ -1862,17 +1905,17 @@ export declare 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
@@ -1934,18 +1977,18 @@ export declare 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") {}
  *
@@ -1957,8 +2000,8 @@ export declare 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)({
@@ -2005,18 +2048,18 @@ export declare 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") {}
      *
@@ -2028,8 +2071,8 @@ export declare 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)({
@@ -2070,24 +2113,24 @@ export declare 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") {}
      *
@@ -2099,8 +2142,8 @@ export declare 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)({
@@ -2141,7 +2184,7 @@ export declare const flatMap: {
      * @since 2.0.0
      * @category sequencing
      */
-    <A, E, R, A2, E2, R2>(self: Layer<A, E, R>, f: (context: ServiceMap.ServiceMap<A>) => Layer<A2, E2, R2>): Layer<A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Layer<A, E, R>, f: (context: Context.Context<A>) => Layer<A2, E2, R2>): Layer<A2, E | E2, R | R2>;
 };
 /**
  * Performs the specified effect if this layer succeeds.
@@ -2156,14 +2199,14 @@ export declare 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.
      *
      * @since 4.0.0
      * @category sequencing
      */
-    <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (context: ServiceMap.ServiceMap<XR>) => Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>;
+    <RIn, E, ROut, XR extends ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (context: Context.Context<XR>) => Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>;
 };
 /**
  * Performs the specified effect if this layer fails.
@@ -2233,13 +2276,13 @@ export declare 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") {}
  *
@@ -2290,11 +2333,11 @@ catch_ as catch };
  *
  * @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") {}
  *
@@ -2316,11 +2359,11 @@ export declare 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") {}
      *
@@ -2342,11 +2385,11 @@ export declare 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") {}
      *
@@ -2369,7 +2412,7 @@ export declare 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
@@ -2379,11 +2422,11 @@ export declare 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") {}
  *
@@ -2427,7 +2470,7 @@ export declare 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
@@ -2437,11 +2480,11 @@ export declare 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") {}
      *
@@ -2485,7 +2528,7 @@ export declare 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
@@ -2495,11 +2538,11 @@ export declare 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") {}
      *
@@ -2576,7 +2619,7 @@ export declare 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.
      *
@@ -2595,16 +2638,16 @@ export declare 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>;
 };
 /**
  * Creates a fresh version of this layer that will not be shared.
  *
  * @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") {}
@@ -2655,14 +2698,14 @@ export declare 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") {}
  *
@@ -2727,9 +2770,9 @@ type AnyEffectOrStream = Effect<any, any, any> | Stream.Stream<any, any, any> |
  *
  * @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
@@ -2774,9 +2817,9 @@ export declare 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
@@ -2813,7 +2856,7 @@ export declare 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
@@ -2821,9 +2864,9 @@ export declare 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
@@ -2860,7 +2903,7 @@ export declare const mock: {
      * @since 4.0.0
      * @category Testing
      */
-    <I, S extends object>(service: ServiceMap.Key<I, S>, implementation: Types.NoInfer<PartialEffectful<S>>): Layer<I>;
+    <I, S extends object>(service: Context.Key<I, S>, implementation: Types.NoInfer<PartialEffectful<S>>): Layer<I>;
 };
 /**
  * Ensures that an layer's success type extends a given type `ROut`.
@@ -2974,9 +3017,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") {}
  *
@@ -3020,9 +3063,9 @@ export declare const span: (name: string, options?: SpanOptions) => Layer<Tracer
  *
  * @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") {}
  *
@@ -3059,13 +3102,13 @@ export declare const parentSpan: (span: Tracer.AnySpan) => Layer<Tracer.ParentSp
  *
  * @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") {}
  *
@@ -3118,13 +3161,13 @@ export declare 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") {}
      *
@@ -3177,13 +3220,13 @@ export declare 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") {}
      *
@@ -3236,13 +3279,13 @@ export declare 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") {}
  *
@@ -3271,9 +3314,9 @@ export declare 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")
@@ -3296,13 +3339,13 @@ export declare 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") {}
      *
@@ -3331,9 +3374,9 @@ export declare 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")
@@ -3356,13 +3399,13 @@ export declare 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") {}
      *
@@ -3391,9 +3434,9 @@ export declare 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")