effect 4.0.0-beta.6 → 4.0.0-beta.62

package/dist/Layer.d.ts

@@ -19,14 +19,17 @@
  */
 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.
@@ -40,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.
@@ -100,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") {}
  *
@@ -112,11 +133,11 @@ declare const MemoMapTypeId = "~effect/Layer/MemoMap";
  *   const scope = yield* Effect.scope
  *
  *   const dbLayer = Layer.succeed(Database)({
- *     query: (sql: string) => Effect.succeed("result")
+ *     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)
  * })
  * ```
  *
@@ -125,21 +146,21 @@ 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") {}
  *
  * const dbLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed("result")
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  * })
  * const notALayer = { someProperty: "value" }
  *
@@ -159,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")
  *     })
  *   )
@@ -177,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.
@@ -187,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")
  *     })
  *   )
@@ -205,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") {}
  *
@@ -223,11 +244,11 @@ export declare const fromBuildMemo: <ROut, E, RIn>(build: (memoMap: MemoMap, sco
  *   const scope = yield* Effect.scope
  *
  *   const dbLayer = Layer.succeed(Database)({
- *     query: (sql: string) => Effect.succeed("result")
+ *     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)
  * })
  * ```
  *
@@ -240,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") {}
  *
@@ -252,11 +273,11 @@ export declare const makeMemoMapUnsafe: () => MemoMap;
  *   const scope = yield* Effect.scope
  *
  *   const dbLayer = Layer.succeed(Database)({
- *     query: (sql: string) => Effect.succeed("result")
+ *     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)
  * })
  * ```
  *
@@ -264,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.
  *
@@ -275,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
@@ -283,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") {}
  *
@@ -300,23 +321,23 @@ export declare class CurrentMemoMap extends CurrentMemoMap_base {
  *
  *   // Build database layer with memoization
  *   const dbLayer = Layer.succeed(Database)({
- *     query: (sql: string) => Effect.succeed("result")
+ *     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: (msg: string) => Effect.sync(() => console.log(msg))
+ *     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)
  *   }
  * })
  * ```
@@ -331,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") {}
      *
@@ -348,23 +369,23 @@ export declare const buildWithMemoMap: {
      *
      *   // Build database layer with memoization
      *   const dbLayer = Layer.succeed(Database)({
-     *     query: (sql: string) => Effect.succeed("result")
+     *     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: (msg: string) => Effect.sync(() => console.log(msg))
+     *     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)
      *   }
      * })
      * ```
@@ -372,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") {}
      *
@@ -396,23 +417,23 @@ export declare const buildWithMemoMap: {
      *
      *   // Build database layer with memoization
      *   const dbLayer = Layer.succeed(Database)({
-     *     query: (sql: string) => Effect.succeed("result")
+     *     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: (msg: string) => Effect.sync(() => console.log(msg))
+     *     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)
      *   }
      * })
      * ```
@@ -420,30 +441,30 @@ 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") {}
  *
  * // Build a layer to get its services
  * const program = Effect.gen(function*() {
  *   const dbLayer = Layer.succeed(Database)({
- *     query: (sql: string) => Effect.succeed("result")
+ *     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")
  * })
@@ -452,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
@@ -462,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") {}
  *
@@ -478,12 +499,12 @@ export declare const build: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<
  *       scope,
  *       Effect.sync(() => console.log("Database closed"))
  *     )
- *     return { query: (sql: string) => Effect.succeed(`Result: ${sql}`) }
+ *     return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`)) }
  *   }))
  *
  *   // 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
@@ -503,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") {}
      *
@@ -519,12 +540,12 @@ export declare const buildWithScope: {
      *       scope,
      *       Effect.sync(() => console.log("Database closed"))
      *     )
-     *     return { query: (sql: string) => Effect.succeed(`Result: ${sql}`) }
+     *     return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`)) }
      *   }))
      *
      *   // 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
@@ -534,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
@@ -544,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") {}
      *
@@ -560,12 +581,12 @@ export declare const buildWithScope: {
      *       scope,
      *       Effect.sync(() => console.log("Database closed"))
      *     )
-     *     return { query: (sql: string) => Effect.succeed(`Result: ${sql}`) }
+     *     return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`)) }
      *   }))
      *
      *   // 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
@@ -575,30 +596,30 @@ 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") {}
  *
  * // Create layers from concrete service implementations
  * const databaseLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed(`Query result: ${sql}`)
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Query result: ${sql}`))
  * })
  *
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
  * })
  *
  * // Use the layers in a program
@@ -625,23 +646,23 @@ 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") {}
      *
      * // Create layers from concrete service implementations
      * const databaseLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed(`Query result: ${sql}`)
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Query result: ${sql}`))
      * })
      *
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
      * })
      *
      * // Use the layers in a program
@@ -662,29 +683,29 @@ export declare const succeed: {
      * @since 2.0.0
      * @category constructors
      */
-    <I, S>(service: ServiceMap.Service<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") {}
      *
      * // Create layers from concrete service implementations
      * const databaseLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed(`Query result: ${sql}`)
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Query result: ${sql}`))
      * })
      *
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
      * })
      *
      * // Use the layers in a program
@@ -705,45 +726,44 @@ export declare const succeed: {
      * @since 2.0.0
      * @category constructors
      */
-    <I, S>(service: ServiceMap.Service<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, {
- *   query: (sql: string) => Effect.succeed("result")
- * })
- *   .pipe(
- *     ServiceMap.add(Logger, {
- *       log: (msg: string) => Effect.sync(() => console.log(msg))
- *     })
- *   )
+ * const context = Context.make(Database, {
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
+ * }).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.
@@ -767,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") {}
  *
@@ -790,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") {}
      *
@@ -804,7 +824,7 @@ export declare const sync: {
      * @since 2.0.0
      * @category constructors
      */
-    <I, S>(service: ServiceMap.Service<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.
      *
@@ -813,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") {}
      *
@@ -827,25 +847,25 @@ export declare const sync: {
      * @since 2.0.0
      * @category constructors
      */
-    <I, S>(service: ServiceMap.Service<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}`)
  *   })
  * )
@@ -854,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.
  *
@@ -870,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") {}
  *
@@ -902,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") {}
      *
@@ -918,7 +938,7 @@ export declare const effect: {
      * @since 2.0.0
      * @category constructors
      */
-    <I, S>(service: ServiceMap.Service<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.
      *
@@ -934,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") {}
      *
@@ -950,7 +970,7 @@ export declare const effect: {
      * @since 2.0.0
      * @category constructors
      */
-    <I, S, E, R>(service: ServiceMap.Service<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
@@ -961,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}`)
  *   }))
  * )
@@ -978,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.
  *
@@ -1006,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.
  *
@@ -1015,14 +1060,14 @@ 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") {}
  *
  * const layerEffect = Effect.succeed(
- *   Layer.succeed(Database)({ query: (sql: string) => Effect.succeed("result") })
+ *   Layer.succeed(Database)({ query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result")) })
  * )
  *
  * const unwrappedLayer = Layer.unwrap(layerEffect)
@@ -1040,21 +1085,21 @@ 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") {}
  *
  * const dbLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed("result")
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  * })
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Effect.sync(() => console.log(msg))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
  * })
  *
  * const mergedLayer = Layer.mergeAll(dbLayer, loggerLayer)
@@ -1072,21 +1117,21 @@ 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") {}
  *
  * const dbLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed("result")
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  * })
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Effect.sync(() => console.log(msg))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
  * })
  *
  * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
@@ -1104,21 +1149,21 @@ 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") {}
      *
      * const dbLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed("result")
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
      * })
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(msg))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
      * })
      *
      * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
@@ -1136,21 +1181,21 @@ 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") {}
      *
      * const dbLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed("result")
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
      * })
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(msg))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
      * })
      *
      * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
@@ -1168,21 +1213,21 @@ 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") {}
      *
      * const dbLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed("result")
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
      * })
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(msg))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
      * })
      *
      * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
@@ -1200,21 +1245,21 @@ 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") {}
      *
      * const dbLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed("result")
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
      * })
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(msg))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
      * })
      *
      * const mergedLayer = Layer.merge(dbLayer, loggerLayer)
@@ -1232,30 +1277,30 @@ 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") {}
  *
  * // Create dependency layers
  * const databaseLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
  * })
  *
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
  * })
  *
  * // UserService depends on Database and Logger
@@ -1264,8 +1309,7 @@ export declare const merge: {
  *   const logger = yield* Logger
  *
  *   return {
- *     getUser: (id: string) =>
- *       Effect.gen(function*() {
+ *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
  *         yield* logger.log(`Looking up user ${id}`)
  *         const result = yield* database.query(
  *           `SELECT * FROM users WHERE id = ${id}`
@@ -1300,30 +1344,30 @@ 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") {}
      *
      * // Create dependency layers
      * const databaseLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
      * })
      *
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
      * })
      *
      * // UserService depends on Database and Logger
@@ -1332,8 +1376,7 @@ export declare const provide: {
      *   const logger = yield* Logger
      *
      *   return {
-     *     getUser: (id: string) =>
-     *       Effect.gen(function*() {
+     *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
      *         yield* logger.log(`Looking up user ${id}`)
      *         const result = yield* database.query(
      *           `SELECT * FROM users WHERE id = ${id}`
@@ -1368,30 +1411,30 @@ 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") {}
      *
      * // Create dependency layers
      * const databaseLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
      * })
      *
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
      * })
      *
      * // UserService depends on Database and Logger
@@ -1400,8 +1443,7 @@ export declare const provide: {
      *   const logger = yield* Logger
      *
      *   return {
-     *     getUser: (id: string) =>
-     *       Effect.gen(function*() {
+     *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
      *         yield* logger.log(`Looking up user ${id}`)
      *         const result = yield* database.query(
      *           `SELECT * FROM users WHERE id = ${id}`
@@ -1436,30 +1478,30 @@ 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") {}
      *
      * // Create dependency layers
      * const databaseLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
      * })
      *
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
      * })
      *
      * // UserService depends on Database and Logger
@@ -1468,8 +1510,7 @@ export declare const provide: {
      *   const logger = yield* Logger
      *
      *   return {
-     *     getUser: (id: string) =>
-     *       Effect.gen(function*() {
+     *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
      *         yield* logger.log(`Looking up user ${id}`)
      *         const result = yield* database.query(
      *           `SELECT * FROM users WHERE id = ${id}`
@@ -1504,30 +1545,30 @@ 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") {}
      *
      * // Create dependency layers
      * const databaseLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
      * })
      *
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
      * })
      *
      * // UserService depends on Database and Logger
@@ -1536,8 +1577,7 @@ export declare const provide: {
      *   const logger = yield* Logger
      *
      *   return {
-     *     getUser: (id: string) =>
-     *       Effect.gen(function*() {
+     *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
      *         yield* logger.log(`Looking up user ${id}`)
      *         const result = yield* database.query(
      *           `SELECT * FROM users WHERE id = ${id}`
@@ -1573,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
@@ -1592,11 +1632,11 @@ export declare const provide: {
  *
  * // Create dependency layers
  * const databaseLayer = Layer.succeed(Database)({
- *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+ *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
  * })
  *
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
  * })
  *
  * // UserService depends on Database and Logger
@@ -1605,8 +1645,7 @@ export declare const provide: {
  *   const logger = yield* Logger
  *
  *   return {
- *     getUser: (id: string) =>
- *       Effect.gen(function*() {
+ *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
  *         yield* logger.log(`Looking up user ${id}`)
  *         const result = yield* database.query(
  *           `SELECT * FROM users WHERE id = ${id}`
@@ -1647,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
@@ -1666,11 +1705,11 @@ export declare const provideMerge: {
      *
      * // Create dependency layers
      * const databaseLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
      * })
      *
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
      * })
      *
      * // UserService depends on Database and Logger
@@ -1679,8 +1718,7 @@ export declare const provideMerge: {
      *   const logger = yield* Logger
      *
      *   return {
-     *     getUser: (id: string) =>
-     *       Effect.gen(function*() {
+     *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
      *         yield* logger.log(`Looking up user ${id}`)
      *         const result = yield* database.query(
      *           `SELECT * FROM users WHERE id = ${id}`
@@ -1721,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
@@ -1740,11 +1778,11 @@ export declare const provideMerge: {
      *
      * // Create dependency layers
      * const databaseLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
      * })
      *
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
      * })
      *
      * // UserService depends on Database and Logger
@@ -1753,8 +1791,7 @@ export declare const provideMerge: {
      *   const logger = yield* Logger
      *
      *   return {
-     *     getUser: (id: string) =>
-     *       Effect.gen(function*() {
+     *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
      *         yield* logger.log(`Looking up user ${id}`)
      *         const result = yield* database.query(
      *           `SELECT * FROM users WHERE id = ${id}`
@@ -1795,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
@@ -1814,11 +1851,11 @@ export declare const provideMerge: {
      *
      * // Create dependency layers
      * const databaseLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
      * })
      *
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
      * })
      *
      * // UserService depends on Database and Logger
@@ -1827,8 +1864,7 @@ export declare const provideMerge: {
      *   const logger = yield* Logger
      *
      *   return {
-     *     getUser: (id: string) =>
-     *       Effect.gen(function*() {
+     *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
      *         yield* logger.log(`Looking up user ${id}`)
      *         const result = yield* database.query(
      *           `SELECT * FROM users WHERE id = ${id}`
@@ -1869,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
@@ -1888,11 +1924,11 @@ export declare const provideMerge: {
      *
      * // Create dependency layers
      * const databaseLayer = Layer.succeed(Database)({
-     *   query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+     *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
      * })
      *
      * const loggerLayer = Layer.succeed(Logger)({
-     *   log: (msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(`[LOG] ${msg}`)))
      * })
      *
      * // UserService depends on Database and Logger
@@ -1901,8 +1937,7 @@ export declare const provideMerge: {
      *   const logger = yield* Logger
      *
      *   return {
-     *     getUser: (id: string) =>
-     *       Effect.gen(function*() {
+     *     getUser: Effect.fn("UserService.getUser")(function*(id: string) {
      *         yield* logger.log(`Looking up user ${id}`)
      *         const result = yield* database.query(
      *           `SELECT * FROM users WHERE id = ${id}`
@@ -1942,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") {}
  *
@@ -1965,23 +2000,24 @@ 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)({
- *       query: (sql: string) =>
+ *       query: Effect.fn("Database.query")((sql: string) =>
  *         Effect.succeed(
  *           `Querying ${config.dbUrl}: ${sql}`
- *         )
+ *         ))
  *     })
  *
  *     // Create logger layer based on config
  *     const loggerLayer = Layer.succeed(Logger)({
- *       log: (msg: string) =>
+ *       log: Effect.fn("Logger.log")((msg: string) =>
  *         config.logLevel === "debug"
  *           ? Effect.sync(() => console.log(`[DEBUG] ${msg}`))
  *           : Effect.sync(() => console.log(msg))
+ *       )
  *     })
  *
  *     // Return combined layer
@@ -2012,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") {}
      *
@@ -2035,23 +2071,24 @@ 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)({
-     *       query: (sql: string) =>
+     *       query: Effect.fn("Database.query")((sql: string) =>
      *         Effect.succeed(
      *           `Querying ${config.dbUrl}: ${sql}`
-     *         )
+     *         ))
      *     })
      *
      *     // Create logger layer based on config
      *     const loggerLayer = Layer.succeed(Logger)({
-     *       log: (msg: string) =>
+     *       log: Effect.fn("Logger.log")((msg: string) =>
      *         config.logLevel === "debug"
      *           ? Effect.sync(() => console.log(`[DEBUG] ${msg}`))
      *           : Effect.sync(() => console.log(msg))
+     *       )
      *     })
      *
      *     // Return combined layer
@@ -2076,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") {}
      *
@@ -2105,23 +2142,24 @@ 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)({
-     *       query: (sql: string) =>
+     *       query: Effect.fn("Database.query")((sql: string) =>
      *         Effect.succeed(
      *           `Querying ${config.dbUrl}: ${sql}`
-     *         )
+     *         ))
      *     })
      *
      *     // Create logger layer based on config
      *     const loggerLayer = Layer.succeed(Logger)({
-     *       log: (msg: string) =>
+     *       log: Effect.fn("Logger.log")((msg: string) =>
      *         config.logLevel === "debug"
      *           ? Effect.sync(() => console.log(`[DEBUG] ${msg}`))
      *           : Effect.sync(() => console.log(msg))
+     *       )
      *     })
      *
      *     // Return combined layer
@@ -2146,7 +2184,91 @@ 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.
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export declare const tap: {
+    /**
+     * Performs the specified effect if this layer succeeds.
+     *
+     * @since 4.0.0
+     * @category sequencing
+     */
+    <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: Context.Context<XR>) => Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>;
+};
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export declare const tapError: {
+    /**
+     * Performs the specified effect if this layer fails.
+     *
+     * @since 4.0.0
+     * @category sequencing
+     */
+    <E, XE extends E, RIn2, E2, X>(f: (e: XE) => Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>;
+    /**
+     * Performs the specified effect if this layer fails.
+     *
+     * @since 4.0.0
+     * @category sequencing
+     */
+    <RIn, E, XE extends E, ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (e: XE) => Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>;
+};
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * **Previously Known As**
+ *
+ * This API replaces the following from Effect 3.x:
+ *
+ * - `Layer.tapErrorCause`
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export declare const tapCause: {
+    /**
+     * Performs the specified effect if this layer fails.
+     *
+     * **Previously Known As**
+     *
+     * This API replaces the following from Effect 3.x:
+     *
+     * - `Layer.tapErrorCause`
+     *
+     * @since 4.0.0
+     * @category sequencing
+     */
+    <E, XE extends E, RIn2, E2, X>(f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>): <RIn, ROut>(self: Layer<ROut, E, RIn>) => Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>;
+    /**
+     * Performs the specified effect if this layer fails.
+     *
+     * **Previously Known As**
+     *
+     * This API replaces the following from Effect 3.x:
+     *
+     * - `Layer.tapErrorCause`
+     *
+     * @since 4.0.0
+     * @category sequencing
+     */
+    <RIn, E, XE extends E, ROut, RIn2, E2, X>(self: Layer<ROut, E, RIn>, f: (cause: Cause.Cause<XE>) => Effect<X, E2, RIn2>): Layer<ROut, E | E2, RIn | Exclude<RIn2, Scope.Scope>>;
 };
 /**
  * Translates effect failure into death of the fiber, making all failures
@@ -2154,13 +2276,13 @@ export declare const flatMap: {
  *
  * @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") {}
  *
@@ -2169,10 +2291,10 @@ export declare const flatMap: {
  *   // Simulate a database connection that might fail
  *   const shouldFail = Math.random() > 0.5
  *   if (shouldFail) {
- *     yield* Effect.fail(new DatabaseError({ message: "Connection failed" }))
+ *     return yield* new DatabaseError({ message: "Connection failed" })
  *   }
  *
- *   return { query: (sql: string) => Effect.succeed(`Result: ${sql}`) }
+ *   return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`)) }
  * }))
  *
  * // Convert failures to fiber death - removes error from type
@@ -2211,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") {}
  *
@@ -2237,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") {}
      *
@@ -2263,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") {}
      *
@@ -2290,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
@@ -2300,18 +2422,18 @@ 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") {}
  *
  * // Primary database layer that might fail
  * const primaryDatabaseLayer = Layer.effect(Database)(Effect.gen(function*() {
- *   yield* Effect.fail(new DatabaseError({ message: "Primary DB unreachable" }))
- *   return { query: (sql: string) => Effect.succeed(`Primary: ${sql}`) }
+ *   return yield* new DatabaseError({ message: "Primary DB unreachable" })
+ *   return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Primary: ${sql}`)) }
  * }))
  *
  * // Fallback layers for different error causes
@@ -2320,11 +2442,12 @@ export declare const catchTag: {
  *     // For any cause/error, fallback to in-memory database
  *     return Layer.mergeAll(
  *       Layer.succeed(Database)({
- *         query: (sql: string) => Effect.succeed(`Memory: ${sql}`)
+ *         query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Memory: ${sql}`))
  *       }),
  *       Layer.succeed(Logger)({
- *         log: (msg: string) =>
+ *         log: Effect.fn("Logger.log")((msg: string) =>
  *           Effect.sync(() => console.log(`[FALLBACK] ${msg}`))
+ *         )
  *       })
  *     )
  *   })
@@ -2347,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
@@ -2357,18 +2480,18 @@ 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") {}
      *
      * // Primary database layer that might fail
      * const primaryDatabaseLayer = Layer.effect(Database)(Effect.gen(function*() {
-     *   yield* Effect.fail(new DatabaseError({ message: "Primary DB unreachable" }))
-     *   return { query: (sql: string) => Effect.succeed(`Primary: ${sql}`) }
+     *   return yield* new DatabaseError({ message: "Primary DB unreachable" })
+     *   return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Primary: ${sql}`)) }
      * }))
      *
      * // Fallback layers for different error causes
@@ -2377,11 +2500,12 @@ export declare const catchCause: {
      *     // For any cause/error, fallback to in-memory database
      *     return Layer.mergeAll(
      *       Layer.succeed(Database)({
-     *         query: (sql: string) => Effect.succeed(`Memory: ${sql}`)
+     *         query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Memory: ${sql}`))
      *       }),
      *       Layer.succeed(Logger)({
-     *         log: (msg: string) =>
+     *         log: Effect.fn("Logger.log")((msg: string) =>
      *           Effect.sync(() => console.log(`[FALLBACK] ${msg}`))
+     *         )
      *       })
      *     )
      *   })
@@ -2404,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
@@ -2414,18 +2538,18 @@ 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") {}
      *
      * // Primary database layer that might fail
      * const primaryDatabaseLayer = Layer.effect(Database)(Effect.gen(function*() {
-     *   yield* Effect.fail(new DatabaseError({ message: "Primary DB unreachable" }))
-     *   return { query: (sql: string) => Effect.succeed(`Primary: ${sql}`) }
+     *   return yield* new DatabaseError({ message: "Primary DB unreachable" })
+     *   return { query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Primary: ${sql}`)) }
      * }))
      *
      * // Fallback layers for different error causes
@@ -2434,11 +2558,12 @@ export declare const catchCause: {
      *     // For any cause/error, fallback to in-memory database
      *     return Layer.mergeAll(
      *       Layer.succeed(Database)({
-     *         query: (sql: string) => Effect.succeed(`Memory: ${sql}`)
+     *         query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Memory: ${sql}`))
      *       }),
      *       Layer.succeed(Logger)({
-     *         log: (msg: string) =>
+     *         log: Effect.fn("Logger.log")((msg: string) =>
      *           Effect.sync(() => console.log(`[FALLBACK] ${msg}`))
+     *         )
      *       })
      *     )
      *   })
@@ -2494,7 +2619,7 @@ export declare const updateService: {
      * @since 3.13.0
      * @category utils
      */
-    <I, A>(service: ServiceMap.Service<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.
      *
@@ -2513,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.Service<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") {}
@@ -2532,10 +2657,11 @@ export declare const updateService: {
  *   const ref = yield* Ref.make(0)
  *   return {
  *     count: 0,
- *     increment: () =>
+ *     increment: Effect.fn("Counter.increment")(() =>
  *       Ref.update(ref, (n) => n + 1).pipe(
  *         Effect.flatMap(() => Ref.get(ref))
  *       )
+ *     )
  *   }
  * }))
  *
@@ -2572,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") {}
  *
@@ -2588,13 +2714,11 @@ export declare const fresh: <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>;
  *   yield* Console.log("Starting HTTP server...")
  *
  *   return {
- *     start: () =>
- *       Effect.gen(function*() {
+ *     start: Effect.fn("HttpServer.start")(function*() {
  *         yield* Console.log("Server listening on port 3000")
  *         return "Server started"
  *       }),
- *     stop: () =>
- *       Effect.gen(function*() {
+ *     stop: Effect.fn("HttpServer.stop")(function*() {
  *         yield* Console.log("Server stopped gracefully")
  *         return "Server stopped"
  *       })
@@ -2602,7 +2726,7 @@ export declare const fresh: <A, E, R>(self: Layer<A, E, R>) => Layer<A, E, R>;
  * }))
  *
  * const loggerLayer = Layer.succeed(Logger)({
- *   log: (msg: string) => Console.log(`[LOG] ${msg}`)
+ *   log: Effect.fn("Logger.log")((msg: string) => Console.log(`[LOG] ${msg}`))
  * })
  *
  * // Application layer combining all services
@@ -2634,10 +2758,11 @@ export declare const launch: <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect
  * @category Testing
  */
 export type PartialEffectful<A extends object> = Types.Simplify<{
-    [K in keyof A as A[K] extends Effect<any, any, any> | ((...args: any) => Effect<any, any, any>) ? K : never]?: A[K];
+    [K in keyof A as A[K] extends AnyEffectOrStream ? K : never]?: A[K];
 } & {
-    [K in keyof A as A[K] extends Effect<any, any, any> | ((...args: any) => Effect<any, any, any>) ? never : K]: A[K];
+    [K in keyof A as A[K] extends AnyEffectOrStream ? never : K]: A[K];
 }>;
+type AnyEffectOrStream = Effect<any, any, any> | Stream.Stream<any, any, any> | Channel.Channel<any, any, any, any, any, any, any> | ((...args: any) => Effect<any, any, any>) | ((...args: any) => Stream.Stream<any, any, any>) | ((...args: any) => Channel.Channel<any, any, any, any, any, any, any>);
 /**
  * Creates a mock layer for testing purposes. You can provide a partial
  * implementation of the service, and any methods not provided will
@@ -2645,9 +2770,9 @@ export type PartialEffectful<A extends object> = Types.Simplify<{
  *
  * @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
@@ -2660,7 +2785,7 @@ export type PartialEffectful<A extends object> = Types.Simplify<{
  * }>()("UserService") {}
  *
  * // Create a partial mock - only implement what you need for testing
- * const testUserLayer = Layer.mock(UserService)({
+ * const testUserLayer = Layer.mock(UserService, {
  *   config: { apiUrl: "https://test-api.com" }, // Required - non-Effect property
  *   getUser: (id: string) => Effect.succeed({ id, name: "Test User" }) // Mock implementation
  *   // deleteUser and updateUser are omitted - will throw UnimplementedError if called
@@ -2684,7 +2809,102 @@ export type PartialEffectful<A extends object> = Types.Simplify<{
  * @since 4.0.0
  * @category Testing
  */
-export declare const mock: <I, S extends object>(service: ServiceMap.Service<I, S>) => (implementation: PartialEffectful<S>) => Layer<I>;
+export declare const mock: {
+    /**
+     * Creates a mock layer for testing purposes. You can provide a partial
+     * implementation of the service, and any methods not provided will
+     * throw an unimplemented defect when called.
+     *
+     * @example
+     * ```ts
+     * import { Effect, Layer, Context } from "effect"
+     *
+     * class UserService extends Context.Service<UserService, {
+     *   readonly config: { apiUrl: string }
+     *   readonly getUser: (
+     *     id: string
+     *   ) => Effect.Effect<{ id: string; name: string }, Error>
+     *   readonly deleteUser: (id: string) => Effect.Effect<void, Error>
+     *   readonly updateUser: (
+     *     id: string,
+     *     data: object
+     *   ) => Effect.Effect<{ id: string; name: string }, Error>
+     * }>()("UserService") {}
+     *
+     * // Create a partial mock - only implement what you need for testing
+     * const testUserLayer = Layer.mock(UserService, {
+     *   config: { apiUrl: "https://test-api.com" }, // Required - non-Effect property
+     *   getUser: (id: string) => Effect.succeed({ id, name: "Test User" }) // Mock implementation
+     *   // deleteUser and updateUser are omitted - will throw UnimplementedError if called
+     * })
+     *
+     * // Use in tests
+     * const testProgram = Effect.gen(function*() {
+     *   const userService = yield* UserService
+     *
+     *   // This works - we provided an implementation
+     *   const user = yield* userService.getUser("123")
+     *   console.log(user.name) // "Test User"
+     *
+     *   // This would throw - we didn't implement deleteUser
+     *   // yield* userService.deleteUser("123") // UnimplementedError
+     * }).pipe(
+     *   Effect.provide(testUserLayer)
+     * )
+     * ```
+     *
+     * @since 4.0.0
+     * @category Testing
+     */
+    <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
+     * throw an unimplemented defect when called.
+     *
+     * @example
+     * ```ts
+     * import { Effect, Layer, Context } from "effect"
+     *
+     * class UserService extends Context.Service<UserService, {
+     *   readonly config: { apiUrl: string }
+     *   readonly getUser: (
+     *     id: string
+     *   ) => Effect.Effect<{ id: string; name: string }, Error>
+     *   readonly deleteUser: (id: string) => Effect.Effect<void, Error>
+     *   readonly updateUser: (
+     *     id: string,
+     *     data: object
+     *   ) => Effect.Effect<{ id: string; name: string }, Error>
+     * }>()("UserService") {}
+     *
+     * // Create a partial mock - only implement what you need for testing
+     * const testUserLayer = Layer.mock(UserService, {
+     *   config: { apiUrl: "https://test-api.com" }, // Required - non-Effect property
+     *   getUser: (id: string) => Effect.succeed({ id, name: "Test User" }) // Mock implementation
+     *   // deleteUser and updateUser are omitted - will throw UnimplementedError if called
+     * })
+     *
+     * // Use in tests
+     * const testProgram = Effect.gen(function*() {
+     *   const userService = yield* UserService
+     *
+     *   // This works - we provided an implementation
+     *   const user = yield* userService.getUser("123")
+     *   console.log(user.name) // "Test User"
+     *
+     *   // This would throw - we didn't implement deleteUser
+     *   // yield* userService.deleteUser("123") // UnimplementedError
+     * }).pipe(
+     *   Effect.provide(testUserLayer)
+     * )
+     * ```
+     *
+     * @since 4.0.0
+     * @category Testing
+     */
+    <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`.
  *
@@ -2797,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") {}
  *
@@ -2815,7 +3035,7 @@ export interface SpanOptions extends Tracer.SpanOptions {
  *   yield* Console.log((parentSpan as Tracer.Span).name) // "database-init"
  *
  *   return {
- *     query: (sql: string) => Effect.succeed(`Result: ${sql}`)
+ *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
  *   }
  * })).pipe(Layer.provide(Layer.span("database-init")))
  *
@@ -2843,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") {}
  *
@@ -2859,7 +3079,7 @@ export declare const span: (name: string, options?: SpanOptions) => Layer<Tracer
  *     yield* Console.log(parentSpan.spanId) // "42"
  *
  *     return {
- *       query: (sql: string) => Effect.succeed(`Result: ${sql}`)
+ *       query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
  *     }
  *   })
  * ).pipe(Layer.provide(Layer.parentSpan(Tracer.externalSpan({
@@ -2882,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") {}
  *
@@ -2897,14 +3117,14 @@ export declare const parentSpan: (span: Tracer.AnySpan) => Layer<Tracer.ParentSp
  *   yield* Effect.log("Connecting to database")
  *   yield* Effect.sleep("100 millis")
  *   return {
- *     query: (sql: string) => Effect.succeed(`Result: ${sql}`)
+ *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
  *   }
  * })).pipe(Layer.withSpan("database-initialization", {
  *   attributes: { dbType: "postgres" }
  * }))
  *
  * const loggerLayer = Layer.succeed(Logger, {
- *   log: (msg: string) => Effect.sync(() => console.log(msg))
+ *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
  * }).pipe(Layer.withSpan("logger-initialization"))
  *
  * // Combine traced layers
@@ -2941,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") {}
      *
@@ -2956,14 +3176,14 @@ export declare const withSpan: {
      *   yield* Effect.log("Connecting to database")
      *   yield* Effect.sleep("100 millis")
      *   return {
-     *     query: (sql: string) => Effect.succeed(`Result: ${sql}`)
+     *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
      *   }
      * })).pipe(Layer.withSpan("database-initialization", {
      *   attributes: { dbType: "postgres" }
      * }))
      *
      * const loggerLayer = Layer.succeed(Logger, {
-     *   log: (msg: string) => Effect.sync(() => console.log(msg))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
      * }).pipe(Layer.withSpan("logger-initialization"))
      *
      * // Combine traced layers
@@ -3000,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") {}
      *
@@ -3015,14 +3235,14 @@ export declare const withSpan: {
      *   yield* Effect.log("Connecting to database")
      *   yield* Effect.sleep("100 millis")
      *   return {
-     *     query: (sql: string) => Effect.succeed(`Result: ${sql}`)
+     *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result: ${sql}`))
      *   }
      * })).pipe(Layer.withSpan("database-initialization", {
      *   attributes: { dbType: "postgres" }
      * }))
      *
      * const loggerLayer = Layer.succeed(Logger, {
-     *   log: (msg: string) => Effect.sync(() => console.log(msg))
+     *   log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
      * }).pipe(Layer.withSpan("logger-initialization"))
      *
      * // Combine traced layers
@@ -3059,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") {}
  *
@@ -3073,14 +3293,14 @@ export declare const withSpan: {
  * const DatabaseLayer = Layer.effect(Database, Effect.gen(function*() {
  *   yield* Effect.log("Connecting to database")
  *   return {
- *     query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+ *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
  *   }
  * }))
  *
  * const CacheLayer = Layer.effect(Cache, Effect.gen(function*() {
  *   yield* Effect.log("Connecting to cache")
  *   return {
- *     get: (key: string) => Effect.succeed(`Cache: ${key}`)
+ *     get: Effect.fn("Cache.get")((key: string) => Effect.succeed(`Cache: ${key}`))
  *   }
  * }))
  *
@@ -3094,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")
@@ -3119,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") {}
      *
@@ -3133,14 +3353,14 @@ export declare const withParentSpan: {
      * const DatabaseLayer = Layer.effect(Database, Effect.gen(function*() {
      *   yield* Effect.log("Connecting to database")
      *   return {
-     *     query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+     *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
      *   }
      * }))
      *
      * const CacheLayer = Layer.effect(Cache, Effect.gen(function*() {
      *   yield* Effect.log("Connecting to cache")
      *   return {
-     *     get: (key: string) => Effect.succeed(`Cache: ${key}`)
+     *     get: Effect.fn("Cache.get")((key: string) => Effect.succeed(`Cache: ${key}`))
      *   }
      * }))
      *
@@ -3154,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")
@@ -3179,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") {}
      *
@@ -3193,14 +3413,14 @@ export declare const withParentSpan: {
      * const DatabaseLayer = Layer.effect(Database, Effect.gen(function*() {
      *   yield* Effect.log("Connecting to database")
      *   return {
-     *     query: (sql: string) => Effect.succeed(`DB: ${sql}`)
+     *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`DB: ${sql}`))
      *   }
      * }))
      *
      * const CacheLayer = Layer.effect(Cache, Effect.gen(function*() {
      *   yield* Effect.log("Connecting to cache")
      *   return {
-     *     get: (key: string) => Effect.succeed(`Cache: ${key}`)
+     *     get: Effect.fn("Cache.get")((key: string) => Effect.succeed(`Cache: ${key}`))
      *   }
      * }))
      *
@@ -3214,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")