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

package/src/Layer.ts

@@ -19,6 +19,8 @@
  */
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "./Array.ts"
 import type * as Cause from "./Cause.ts"
+import type * as Channel from "./Channel.ts"
+import * as Context from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import type { Effect } from "./Effect.ts"
 import type * as Exit from "./Exit.ts"
@@ -32,9 +34,10 @@ import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import { CurrentStackFrame } from "./References.ts"
 import * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
+import type * as Stream from "./Stream.ts"
 import * as Tracer from "./Tracer.ts"
 import type * as Types from "./Types.ts"
+import type * as Unify from "./Unify.ts"
 
 const TypeId = "~effect/Layer"
 
@@ -51,9 +54,31 @@ const TypeId = "~effect/Layer"
  */
 export interface Layer<in ROut, out E = never, out RIn = never> extends Variance<ROut, E, RIn>, Pipeable {
   /** @internal */
-  build(memoMap: MemoMap, scope: Scope.Scope): Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  build(memoMap: MemoMap, scope: Scope.Scope): Effect<Context.Context<ROut>, E, RIn>
+  [Unify.typeSymbol]?: unknown
+  [Unify.unifySymbol]?: LayerUnify<this>
+  [Unify.ignoreSymbol]?: LayerUnifyIgnore
 }
 
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface LayerUnify<A extends { [Unify.typeSymbol]?: any }> {
+  Layer?: () => A[Unify.typeSymbol] extends Layer<any, any, any> | infer _ ? Layer<
+      Success<Extract<A[Unify.typeSymbol], Any>>,
+      Error<Extract<A[Unify.typeSymbol], Any>>,
+      Services<Extract<A[Unify.typeSymbol], Any>>
+    >
+    : never
+}
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface LayerUnifyIgnore {}
+
 /**
  * The variance interface for Layer type parameters.
  *
@@ -117,9 +142,9 @@ const MemoMapTypeId = "~effect/Layer/MemoMap"
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -129,11 +154,11 @@ 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)
  * })
  * ```
  *
@@ -145,8 +170,8 @@ export interface MemoMap {
   readonly getOrElseMemoize: <RIn, E, ROut>(
     layer: Layer<ROut, E, RIn>,
     scope: Scope.Scope,
-    build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
-  ) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+    build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<ROut>, E, RIn>
+  ) => Effect<Context.Context<ROut>, E, RIn>
 }
 
 /**
@@ -154,14 +179,14 @@ export interface MemoMap {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * 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" }
  *
@@ -189,7 +214,7 @@ const fromBuildUnsafe = <ROut, E, RIn>(
   build: (
     memoMap: MemoMap,
     scope: Scope.Scope
-  ) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  ) => Effect<Context.Context<ROut>, E, RIn>
 ): Layer<ROut, E, RIn> => {
   const self = Object.create(LayerProto)
   self.build = build
@@ -204,15 +229,15 @@ const fromBuildUnsafe = <ROut, E, RIn>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * const databaseLayer = Layer.fromBuild(() =>
  *   Effect.sync(() =>
- *     ServiceMap.make(Database, {
+ *     Context.make(Database, {
  *       query: (sql: string) => Effect.succeed("result")
  *     })
  *   )
@@ -226,7 +251,7 @@ export const fromBuild = <ROut, E, RIn>(
   build: (
     memoMap: MemoMap,
     scope: Scope.Scope
-  ) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  ) => Effect<Context.Context<ROut>, E, RIn>
 ): Layer<ROut, E, RIn> =>
   fromBuildUnsafe((memoMap: MemoMap, scope: Scope.Scope) => {
     const layerScope = Scope.forkUnsafe(scope)
@@ -245,15 +270,15 @@ export const fromBuild = <ROut, E, RIn>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * const databaseLayer = Layer.fromBuildMemo(() =>
  *   Effect.sync(() =>
- *     ServiceMap.make(Database, {
+ *     Context.make(Database, {
  *       query: (sql: string) => Effect.succeed("result")
  *     })
  *   )
@@ -267,7 +292,7 @@ export const fromBuildMemo = <ROut, E, RIn>(
   build: (
     memoMap: MemoMap,
     scope: Scope.Scope
-  ) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  ) => Effect<Context.Context<ROut>, E, RIn>
 ): Layer<ROut, E, RIn> => {
   const self: Layer<ROut, E, RIn> = fromBuild((memoMap, scope) => memoMap.getOrElseMemoize(self, scope, build))
   return self
@@ -280,15 +305,15 @@ class MemoMapImpl implements MemoMap {
 
   readonly map = new Map<Layer<any, any, any>, {
     observers: number
-    effect: Effect<ServiceMap.ServiceMap<any>, any>
+    effect: Effect<Context.Context<any>, any>
     readonly finalizer: (exit: Exit.Exit<unknown, unknown>) => Effect<void>
   }>()
 
   getOrElseMemoize<RIn, E, ROut>(
     layer: Layer<ROut, E, RIn>,
     scope: Scope.Scope,
-    build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
-  ): Effect<ServiceMap.ServiceMap<ROut>, E, RIn> {
+    build: (memoMap: MemoMap, scope: Scope.Scope) => Effect<Context.Context<ROut>, E, RIn>
+  ): Effect<Context.Context<ROut>, E, RIn> {
     if (this.map.has(layer)) {
       const entry = this.map.get(layer)!
       entry.observers++
@@ -298,7 +323,7 @@ class MemoMapImpl implements MemoMap {
       )
     }
     const layerScope = Scope.makeUnsafe()
-    const deferred = Deferred.makeUnsafe<ServiceMap.ServiceMap<ROut>, E>()
+    const deferred = Deferred.makeUnsafe<Context.Context<ROut>, E>()
     const entry = {
       observers: 1,
       effect: Deferred.await(deferred),
@@ -328,9 +353,9 @@ class MemoMapImpl implements MemoMap {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -340,11 +365,11 @@ class MemoMapImpl implements 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)
  * })
  * ```
  *
@@ -358,9 +383,9 @@ export const makeMemoMapUnsafe = (): MemoMap => new MemoMapImpl()
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -370,11 +395,11 @@ export const makeMemoMapUnsafe = (): MemoMap => new MemoMapImpl()
  *   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)
  * })
  * ```
  *
@@ -392,8 +417,8 @@ export const makeMemoMap: Effect<MemoMap> = internalEffect.sync(makeMemoMapUnsaf
  * @since 3.13.0
  * @category models
  */
-export class CurrentMemoMap extends ServiceMap.Service<CurrentMemoMap, MemoMap>()("effect/Layer/CurrentMemoMap") {
-  static getOrCreate: <Services>(self: ServiceMap.ServiceMap<Services>) => MemoMap = ServiceMap.getOrElse(
+export class CurrentMemoMap extends Context.Service<CurrentMemoMap, MemoMap>()("effect/Layer/CurrentMemoMap") {
+  static getOrCreate: <Services>(self: Context.Context<Services>) => MemoMap = Context.getOrElse(
     this,
     makeMemoMapUnsafe
   )
@@ -405,13 +430,13 @@ export class CurrentMemoMap extends ServiceMap.Service<CurrentMemoMap, MemoMap>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -422,23 +447,23 @@ export class CurrentMemoMap extends ServiceMap.Service<CurrentMemoMap, MemoMap>(
  *
  *   // 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)
  *   }
  * })
  * ```
@@ -453,13 +478,13 @@ export const buildWithMemoMap: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -470,23 +495,23 @@ export 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)
    *   }
    * })
    * ```
@@ -494,20 +519,20 @@ export const buildWithMemoMap: {
    * @since 2.0.0
    * @category memo map
    */
-  (memoMap: MemoMap, scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  (memoMap: MemoMap, scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<Context.Context<ROut>, E, RIn>
   /**
    * Builds a layer into an `Effect` value, using the specified `MemoMap` to memoize
    * the layer construction.
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -518,23 +543,23 @@ export 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)
    *   }
    * })
    * ```
@@ -542,14 +567,14 @@ export const buildWithMemoMap: {
    * @since 2.0.0
    * @category memo map
    */
-  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, memoMap: MemoMap, scope: Scope.Scope): Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, memoMap: MemoMap, scope: Scope.Scope): Effect<Context.Context<ROut>, E, RIn>
 } = dual(3, <RIn, E, ROut>(
   self: Layer<ROut, E, RIn>,
   memoMap: MemoMap,
   scope: Scope.Scope
-): Effect<ServiceMap.ServiceMap<ROut>, E, RIn> =>
+): Effect<Context.Context<ROut>, E, RIn> =>
   internalEffect.provideService(
-    internalEffect.map(self.build(memoMap, scope), ServiceMap.add(CurrentMemoMap, memoMap)),
+    internalEffect.map(self.build(memoMap, scope), Context.add(CurrentMemoMap, memoMap)),
     CurrentMemoMap,
     memoMap
   ))
@@ -559,23 +584,23 @@ export const buildWithMemoMap: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * // 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")
  * })
@@ -586,12 +611,12 @@ export const buildWithMemoMap: {
  */
 export const build = <RIn, E, ROut>(
   self: Layer<ROut, E, RIn>
-): Effect<ServiceMap.ServiceMap<ROut>, E, RIn | Scope.Scope> =>
+): Effect<Context.Context<ROut>, E, RIn | Scope.Scope> =>
   core.withFiber((fiber) =>
     buildWithMemoMap(
       self,
-      CurrentMemoMap.getOrCreate(fiber.services),
-      ServiceMap.getUnsafe(fiber.services, Scope.Scope)
+      CurrentMemoMap.getOrCreate(fiber.context),
+      Context.getUnsafe(fiber.context, Scope.Scope)
     )
   )
 
@@ -604,9 +629,9 @@ export const build = <RIn, E, ROut>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, Scope, ServiceMap } from "effect"
+ * import { Effect, Layer, Scope, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -620,12 +645,12 @@ export const build = <RIn, E, ROut>(
  *       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
@@ -645,9 +670,9 @@ export const buildWithScope: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, Scope, ServiceMap } from "effect"
+   * import { Effect, Layer, Scope, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -661,12 +686,12 @@ export 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
@@ -676,7 +701,7 @@ export const buildWithScope: {
    * @since 2.0.0
    * @category destructors
    */
-  (scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  (scope: Scope.Scope): <RIn, E, ROut>(self: Layer<ROut, E, RIn>) => Effect<Context.Context<ROut>, E, RIn>
   /**
    * Builds a layer into an `Effect` value. Any resources associated with this
    * layer will be released when the specified scope is closed unless their scope
@@ -686,9 +711,9 @@ export const buildWithScope: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, Scope, ServiceMap } from "effect"
+   * import { Effect, Layer, Scope, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -702,12 +727,12 @@ export 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
@@ -717,15 +742,15 @@ export const buildWithScope: {
    * @since 2.0.0
    * @category destructors
    */
-  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, scope: Scope.Scope): Effect<ServiceMap.ServiceMap<ROut>, E, RIn>
+  <RIn, E, ROut>(self: Layer<ROut, E, RIn>, scope: Scope.Scope): Effect<Context.Context<ROut>, E, RIn>
 } = dual(2, <RIn, E, ROut>(
   self: Layer<ROut, E, RIn>,
   scope: Scope.Scope
-): Effect<ServiceMap.ServiceMap<ROut>, E, RIn> =>
+): Effect<Context.Context<ROut>, E, RIn> =>
   core.withFiber((fiber) =>
     buildWithMemoMap(
       self,
-      CurrentMemoMap.getOrCreate(fiber.services),
+      CurrentMemoMap.getOrCreate(fiber.context),
       scope
     )
   ))
@@ -735,23 +760,23 @@ export const buildWithScope: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
  * // 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
@@ -778,23 +803,23 @@ export const succeed: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * // 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
@@ -815,29 +840,29 @@ export 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
@@ -858,12 +883,12 @@ export 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>
 } = function() {
   if (arguments.length === 1) {
-    return (resource: any) => succeedServices(ServiceMap.make(arguments[0], resource))
+    return (resource: any) => succeedContext(Context.make(arguments[0], resource))
   }
-  return succeedServices(ServiceMap.make(arguments[0], arguments[1]))
+  return succeedContext(Context.make(arguments[0], arguments[1]))
 } as any
 
 /**
@@ -871,40 +896,39 @@ export const succeed: {
  * services.
  *
  * This is a more general version of `succeed` that allows you to provide multiple
- * services at once through a `ServiceMap`.
+ * services at once through a `Context`.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
- * const services = ServiceMap.make(Database, {
- *   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 const succeedServices = <A>(services: ServiceMap.ServiceMap<A>): Layer<A> =>
-  fromBuildUnsafe(constant(internalEffect.succeed(services)))
+export const succeedContext = <A>(context: Context.Context<A>): Layer<A> =>
+  fromBuildUnsafe(constant(internalEffect.succeed(context)))
 
 /**
- * A Layer that constructs an empty ServiceMap.
+ * A Layer that constructs an empty Context.
  *
  * This layer provides no services and can be used as a neutral element
  * in layer composition or as a starting point for building layers.
@@ -919,7 +943,7 @@ export const succeedServices = <A>(services: ServiceMap.ServiceMap<A>): Layer<A>
  * @since 2.0.0
  * @category constructors
  */
-export const empty: Layer<never> = succeedServices(ServiceMap.empty())
+export const empty: Layer<never> = succeedContext(Context.empty())
 
 /**
  * Lazily constructs a layer from the specified value.
@@ -929,9 +953,9 @@ export const empty: Layer<never> = succeedServices(ServiceMap.empty())
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -952,9 +976,9 @@ export const sync: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -966,7 +990,7 @@ export 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.
    *
@@ -975,9 +999,9 @@ export const sync: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -989,31 +1013,31 @@ export 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>
 } = function() {
   if (arguments.length === 1) {
-    return (evaluate: LazyArg<any>) => syncServices(() => ServiceMap.make(arguments[0], evaluate()))
+    return (evaluate: LazyArg<any>) => syncContext(() => Context.make(arguments[0], evaluate()))
   }
-  return syncServices(() => ServiceMap.make(arguments[0], arguments[1]()))
+  return syncContext(() => Context.make(arguments[0], arguments[1]()))
 } as any
 
 /**
  * Lazily constructs a layer from the specified value, which must return one or more
  * services.
  *
- * This is a lazy version of `succeedServices` where the ServiceMap is computed
+ * This is a lazy version of `succeedContext` where the Context is computed
  * synchronously only when the layer is built.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * const layer = Layer.syncServices(() =>
- *   ServiceMap.make(Database, {
+ * const layer = Layer.syncContext(() =>
+ *   Context.make(Database, {
  *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  *   })
  * )
@@ -1022,7 +1046,7 @@ export const sync: {
  * @since 2.0.0
  * @category constructors
  */
-export const syncServices = <A>(evaluate: LazyArg<ServiceMap.ServiceMap<A>>): Layer<A> =>
+export const syncContext = <A>(evaluate: LazyArg<Context.Context<A>>): Layer<A> =>
   fromBuildMemo(constant(internalEffect.sync(evaluate)))
 
 /**
@@ -1040,9 +1064,9 @@ export const syncServices = <A>(evaluate: LazyArg<ServiceMap.ServiceMap<A>>): La
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -1072,9 +1096,9 @@ export const effect: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -1088,7 +1112,7 @@ export const effect: {
    * @since 2.0.0
    * @category constructors
    */
-  <I, S>(service: ServiceMap.Service<I, S>): <E, R>(
+  <I, S>(service: Context.Key<I, S>): <E, R>(
     effect: Effect<S, E, R>
   ) => Layer<I, E, Exclude<R, Scope.Scope>>
   /**
@@ -1106,9 +1130,9 @@ export const effect: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
@@ -1122,7 +1146,7 @@ export 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>>
 } = function() {
   if (arguments.length === 1) {
     return (effect: any) => effectImpl(arguments[0], effect)
@@ -1131,10 +1155,10 @@ export const effect: {
 } as any
 
 const effectImpl = <I, S, E, R>(
-  service: ServiceMap.Service<I, S>,
+  service: Context.Key<I, S>,
   effect: Effect<S, E, R>
 ): Layer<I, E, Exclude<R, Scope.Scope>> =>
-  effectServices(internalEffect.map(effect, (value) => ServiceMap.make(service, value)))
+  effectContext(internalEffect.map(effect, (value) => Context.make(service, value)))
 
 /**
  * Constructs a layer from the specified scoped effect, which must return one
@@ -1145,15 +1169,15 @@ const effectImpl = <I, S, E, R>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<
+ * class Database extends Context.Service<
  *   Database,
  *   { readonly query: (sql: string) => Effect.Effect<string> }
  * >()("Database") {}
  *
- * const layer = Layer.effectServices(
- *   Effect.succeed(ServiceMap.make(Database, {
+ * const layer = Layer.effectContext(
+ *   Effect.succeed(Context.make(Database, {
  *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  *   }))
  * )
@@ -1162,8 +1186,8 @@ const effectImpl = <I, S, E, R>(
  * @since 2.0.0
  * @category constructors
  */
-export const effectServices = <A, E, R>(
-  effect: Effect<ServiceMap.ServiceMap<A>, E, R>
+export const effectContext = <A, E, R>(
+  effect: Effect<Context.Context<A>, E, R>
 ): Layer<A, E, Exclude<R, Scope.Scope>> => fromBuildMemo((_, scope) => Scope.provide(effect, scope))
 
 /**
@@ -1193,7 +1217,34 @@ export const effectServices = <A, E, R>(
  * @category constructors
  */
 export const effectDiscard = <X, E, R>(effect: Effect<X, E, R>): Layer<never, E, Exclude<R, Scope.Scope>> =>
-  effectServices(internalEffect.as(effect, ServiceMap.empty()))
+  effectContext(internalEffect.as(effect, Context.empty()))
+
+/**
+ * Lazily constructs a layer using the specified factory.
+ *
+ * The factory is evaluated only when the suspended layer is first built, and
+ * the result is memoized with normal layer sharing semantics.
+ *
+ * @example
+ * ```ts
+ * import { Layer, Context } from "effect"
+ *
+ * class Config extends Context.Service<Config, string>()("Config") {}
+ *
+ * const useProd = true
+ *
+ * const layer = Layer.suspend(() =>
+ *   useProd
+ *     ? Layer.succeed(Config)("https://api.example.com")
+ *     : Layer.succeed(Config)("http://localhost:3000")
+ * )
+ * ```
+ *
+ * @since 4.0.0
+ * @category constructors
+ */
+export const suspend = <A, E, R>(evaluate: LazyArg<Layer<A, E, R>>): Layer<A, E, R> =>
+  fromBuildMemo((memoMap, scope) => internalEffect.suspend(() => evaluate().build(memoMap, scope)))
 
 /**
  * Unwraps a Layer from an Effect, flattening the nested structure.
@@ -1204,14 +1255,14 @@ export const effectDiscard = <X, E, R>(effect: Effect<X, E, R>): Layer<never, E,
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * 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)
@@ -1223,8 +1274,8 @@ export const effectDiscard = <X, E, R>(effect: Effect<X, E, R>): Layer<never, E,
 export const unwrap = <A, E1, R1, E, R>(
   self: Effect<Layer<A, E1, R1>, E, R>
 ): Layer<A, E | E1, R1 | Exclude<R, Scope.Scope>> => {
-  const service = ServiceMap.Service<Layer<A, E1, R1>>("effect/Layer/unwrap")
-  return flatMap(effect(service)(self), ServiceMap.get(service))
+  const service = Context.Service<Layer<A, E1, R1>>("effect/Layer/unwrap")
+  return flatMap(effect(service)(self), Context.get(service))
 }
 
 const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<never, any, any>>]>(
@@ -1232,7 +1283,7 @@ const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<n
   memoMap: MemoMap,
   scope: Scope.Scope
 ): Effect<
-  ServiceMap.ServiceMap<{ [k in keyof Layers]: Success<Layers[k]> }[number]>,
+  Context.Context<{ [k in keyof Layers]: Success<Layers[k]> }[number]>,
   { [k in keyof Layers]: Error<Layers[k]> }[number],
   { [k in keyof Layers]: Services<Layers[k]> }[number]
 > => {
@@ -1240,7 +1291,7 @@ const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<n
   return internalEffect.forEach(layers, (layer) => layer.build(memoMap, Scope.forkUnsafe(parentScope, "sequential")), {
     concurrency: layers.length
   }).pipe(
-    internalEffect.map((services) => ServiceMap.mergeAll(...(services as any)))
+    internalEffect.map((context) => Context.mergeAll(...(context as any)))
   )
 }
 
@@ -1252,21 +1303,21 @@ const mergeAllEffect = <Layers extends [Layer<never, any, any>, ...Array<Layer<n
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
  * 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)
@@ -1291,21 +1342,21 @@ export const mergeAll = <Layers extends [Layer<never, any, any>, ...Array<Layer<
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
  * 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)
@@ -1323,21 +1374,21 @@ export const merge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * 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)
@@ -1355,21 +1406,21 @@ export const merge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * 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)
@@ -1394,21 +1445,21 @@ export const merge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * 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)
@@ -1426,21 +1477,21 @@ export const merge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * 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)
@@ -1464,9 +1515,9 @@ const provideWith = (
   self: Layer<any, any, any>,
   that: Layer<any, any, any> | ReadonlyArray<Layer<any, any, any>>,
   f: (
-    selfServices: ServiceMap.ServiceMap<any>,
-    thatServices: ServiceMap.ServiceMap<any>
-  ) => ServiceMap.ServiceMap<any>
+    selfContext: Context.Context<any>,
+    thatContext: Context.Context<any>
+  ) => Context.Context<any>
 ) =>
   fromBuild((memoMap, scope) =>
     internalEffect.flatMap(
@@ -1475,7 +1526,7 @@ const provideWith = (
         : (that as Layer<any, any, any>).build(memoMap, scope),
       (context) =>
         self.build(memoMap, scope).pipe(
-          internalEffect.provideServices(context),
+          internalEffect.provideContext(context),
           internalEffect.map((merged) => f(merged, context))
         )
     )
@@ -1488,30 +1539,30 @@ const provideWith = (
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class UserService extends ServiceMap.Service<UserService, {
+ * class UserService extends Context.Service<UserService, {
  *   readonly getUser: (id: string) => Effect.Effect<{
  *     id: string
  *     name: string
  *   }>
  * }>()("UserService") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
  * // 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
@@ -1520,8 +1571,7 @@ const provideWith = (
  *   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}`
@@ -1556,30 +1606,30 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
    *   }>
    * }>()("UserService") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * // 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
@@ -1588,8 +1638,7 @@ export 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}`
@@ -1624,30 +1673,30 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
    *   }>
    * }>()("UserService") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * // 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
@@ -1656,8 +1705,7 @@ export 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}`
@@ -1699,30 +1747,30 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
    *   }>
    * }>()("UserService") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * // 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
@@ -1731,8 +1779,7 @@ export 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}`
@@ -1767,30 +1814,30 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
    *   }>
    * }>()("UserService") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * // 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
@@ -1799,8 +1846,7 @@ export 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}`
@@ -1845,17 +1891,17 @@ export const provide: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
- * class UserService extends ServiceMap.Service<UserService, {
+ * class UserService extends Context.Service<UserService, {
  *   readonly getUser: (id: string) => Effect.Effect<{
  *     id: string
  *     name: string
@@ -1864,11 +1910,11 @@ export 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
@@ -1877,8 +1923,7 @@ export 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}`
@@ -1919,17 +1964,17 @@ export const provideMerge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
@@ -1938,11 +1983,11 @@ export 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
@@ -1951,8 +1996,7 @@ export 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}`
@@ -1993,17 +2037,17 @@ export const provideMerge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
@@ -2012,11 +2056,11 @@ export 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
@@ -2025,8 +2069,7 @@ export 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}`
@@ -2074,17 +2117,17 @@ export const provideMerge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
@@ -2093,11 +2136,11 @@ export 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
@@ -2106,8 +2149,7 @@ export 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}`
@@ -2148,17 +2190,17 @@ export const provideMerge: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
-   * class UserService extends ServiceMap.Service<UserService, {
+   * class UserService extends Context.Service<UserService, {
    *   readonly getUser: (id: string) => Effect.Effect<{
    *     id: string
    *     name: string
@@ -2167,11 +2209,11 @@ export 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
@@ -2180,8 +2222,7 @@ export 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}`
@@ -2227,7 +2268,7 @@ export const provideMerge: {
   provideWith(
     self,
     that,
-    (self, that) => ServiceMap.merge(that, self)
+    (self, that) => Context.merge(that, self)
   ))
 
 /**
@@ -2235,18 +2276,18 @@ export const provideMerge: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Config extends ServiceMap.Service<Config, {
+ * class Config extends Context.Service<Config, {
  *   readonly dbUrl: string
  *   readonly logLevel: string
  * }>()("Config") {}
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -2258,23 +2299,24 @@ export const provideMerge: {
  *
  * // Dynamically create services based on config
  * const dynamicServiceLayer = configLayer.pipe(
- *   Layer.flatMap((services) => {
- *     const config = ServiceMap.get(services, Config)
+ *   Layer.flatMap((context) => {
+ *     const config = Context.get(context, Config)
  *
  *     // Create database layer based on config
  *     const dbLayer = Layer.succeed(Database)({
- *       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
@@ -2305,18 +2347,18 @@ export const flatMap: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Config extends ServiceMap.Service<Config, {
+   * class Config extends Context.Service<Config, {
    *   readonly dbUrl: string
    *   readonly logLevel: string
    * }>()("Config") {}
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -2328,23 +2370,24 @@ export const flatMap: {
    *
    * // Dynamically create services based on config
    * const dynamicServiceLayer = configLayer.pipe(
-   *   Layer.flatMap((services) => {
-   *     const config = ServiceMap.get(services, Config)
+   *   Layer.flatMap((context) => {
+   *     const config = Context.get(context, Config)
    *
    *     // Create database layer based on config
    *     const dbLayer = Layer.succeed(Database)({
-   *       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
@@ -2369,24 +2412,24 @@ export const flatMap: {
    * @since 2.0.0
    * @category sequencing
    */
-  <A, A2, E2, R2>(f: (context: ServiceMap.ServiceMap<A>) => Layer<A2, E2, R2>): <E, R>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>
+  <A, A2, E2, R2>(f: (context: Context.Context<A>) => Layer<A2, E2, R2>): <E, R>(self: Layer<A, E, R>) => Layer<A2, E2 | E, R2 | R>
   /**
    * Constructs a layer dynamically based on the output of this layer.
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Config extends ServiceMap.Service<Config, {
+   * class Config extends Context.Service<Config, {
    *   readonly dbUrl: string
    *   readonly logLevel: string
    * }>()("Config") {}
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -2398,23 +2441,24 @@ export const flatMap: {
    *
    * // Dynamically create services based on config
    * const dynamicServiceLayer = configLayer.pipe(
-   *   Layer.flatMap((services) => {
-   *     const config = ServiceMap.get(services, Config)
+   *   Layer.flatMap((context) => {
+   *     const config = Context.get(context, Config)
    *
    *     // Create database layer based on config
    *     const dbLayer = Layer.succeed(Database)({
-   *       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
@@ -2441,11 +2485,11 @@ export const flatMap: {
    */
   <A, E, R, A2, E2, R2>(
     self: Layer<A, E, R>,
-    f: (context: ServiceMap.ServiceMap<A>) => Layer<A2, E2, R2>
+    f: (context: Context.Context<A>) => Layer<A2, E2, R2>
   ): Layer<A2, E | E2, R | R2>
 } = dual(2, <A, E, R, A2, E2, R2>(
   self: Layer<A, E, R>,
-  f: (context: ServiceMap.ServiceMap<A>) => Layer<A2, E2, R2>
+  f: (context: Context.Context<A>) => Layer<A2, E2, R2>
 ): Layer<A2, E | E2, R | R2> =>
   fromBuild((memoMap, scope) =>
     internalEffect.flatMap(
@@ -2454,19 +2498,140 @@ export const flatMap: {
     )
   ))
 
+/**
+ * Performs the specified effect if this layer succeeds.
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export 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>>
+} = dual(2, <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>> =>
+  fromBuild((memoMap, scope) =>
+    internalEffect.flatMap(
+      self.build(memoMap, scope),
+      (context) => Scope.provide(internalEffect.as(f(context as Context.Context<XR>), context), scope)
+    )
+  ))
+
+/**
+ * Performs the specified effect if this layer fails.
+ *
+ * @since 4.0.0
+ * @category sequencing
+ */
+export 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>>
+} = dual(2, <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>> =>
+  fromBuild((memoMap, scope) =>
+    internalEffect.catch_(
+      self.build(memoMap, scope),
+      (error) => Scope.provide(internalEffect.andThen(f(error as XE), internalEffect.fail(error)), 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 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>>
+} = dual(2, <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>> =>
+  fromBuild((memoMap, scope) =>
+    internalEffect.catchCause(
+      self.build(memoMap, scope),
+      (cause) =>
+        Scope.provide(internalEffect.andThen(f(cause as Cause.Cause<XE>), internalEffect.failCause(cause)), scope)
+    )
+  ))
+
 /**
  * Translates effect failure into death of the fiber, making all failures
  * unchecked and not a part of the type of the layer.
  *
  * @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") {}
  *
@@ -2475,10 +2640,10 @@ export 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
@@ -2536,11 +2701,11 @@ export {
  *
  * @example
  * ```ts
- * import { Data, Effect, Layer, ServiceMap } from "effect"
+ * import { Data, Effect, Layer, Context } from "effect"
  *
  * class ConfigError extends Data.TaggedError("ConfigError") {}
  *
- * class Config extends ServiceMap.Service<Config, {
+ * class Config extends Context.Service<Config, {
  *   readonly apiUrl: string
  * }>()("Config") {}
  *
@@ -2562,11 +2727,11 @@ export const catchTag: {
    *
    * @example
    * ```ts
-   * import { Data, Effect, Layer, ServiceMap } from "effect"
+   * import { Data, Effect, Layer, Context } from "effect"
    *
    * class ConfigError extends Data.TaggedError("ConfigError") {}
    *
-   * class Config extends ServiceMap.Service<Config, {
+   * class Config extends Context.Service<Config, {
    *   readonly apiUrl: string
    * }>()("Config") {}
    *
@@ -2599,11 +2764,11 @@ export const catchTag: {
    *
    * @example
    * ```ts
-   * import { Data, Effect, Layer, ServiceMap } from "effect"
+   * import { Data, Effect, Layer, Context } from "effect"
    *
    * class ConfigError extends Data.TaggedError("ConfigError") {}
    *
-   * class Config extends ServiceMap.Service<Config, {
+   * class Config extends Context.Service<Config, {
    *   readonly apiUrl: string
    * }>()("Config") {}
    *
@@ -2662,7 +2827,7 @@ export const catchTag: {
  *
  * @example
  * ```ts
- * import { Data, Effect, Layer, ServiceMap } from "effect"
+ * import { Data, Effect, Layer, Context } from "effect"
  *
  * class DatabaseError extends Data.TaggedError("DatabaseError")<{
  *   message: string
@@ -2672,18 +2837,18 @@ export const catchTag: {
  *   reason: string
  * }> {}
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
  * // 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
@@ -2692,11 +2857,12 @@ export 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}`))
+ *         )
  *       })
  *     )
  *   })
@@ -2719,7 +2885,7 @@ export const catchCause: {
    *
    * @example
    * ```ts
-   * import { Data, Effect, Layer, ServiceMap } from "effect"
+   * import { Data, Effect, Layer, Context } from "effect"
    *
    * class DatabaseError extends Data.TaggedError("DatabaseError")<{
    *   message: string
@@ -2729,18 +2895,18 @@ export const catchCause: {
    *   reason: string
    * }> {}
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * // 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
@@ -2749,11 +2915,12 @@ export 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}`))
+   *         )
    *       })
    *     )
    *   })
@@ -2776,7 +2943,7 @@ export const catchCause: {
    *
    * @example
    * ```ts
-   * import { Data, Effect, Layer, ServiceMap } from "effect"
+   * import { Data, Effect, Layer, Context } from "effect"
    *
    * class DatabaseError extends Data.TaggedError("DatabaseError")<{
    *   message: string
@@ -2786,18 +2953,18 @@ export const catchCause: {
    *   reason: string
    * }> {}
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
    * // 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
@@ -2806,11 +2973,12 @@ export 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}`))
+   *         )
    *       })
    *     )
    *   })
@@ -2879,7 +3047,7 @@ export 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.
    *
@@ -2900,16 +3068,16 @@ export const updateService: {
    */
   <A1, E1, R1, I, A>(
     layer: Layer<A1, E1, R1>,
-    service: ServiceMap.Service<I, A>,
-    f: (a: A) => A
+    service: Context.Key<I, A>,
+    f: (a: Types.NoInfer<A>) => A
   ): Layer<A1, E1, I | R1>
 } = dual(
   3,
   <A1, E1, R1, I, A>(
     layer: Layer<A1, E1, R1>,
-    service: ServiceMap.Service<I, A>,
-    f: (a: A) => A
-  ): Layer<A1, E1, I | R1> => provide(layer, effect(service)(internalEffect.map(service.asEffect(), f)))
+    service: Context.Key<I, A>,
+    f: (a: Types.NoInfer<A>) => A
+  ): Layer<A1, E1, I | R1> => provide(layer, effect(service, internalEffect.map(service.asEffect(), f)))
 )
 
 /**
@@ -2917,9 +3085,9 @@ export const updateService: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, Ref, ServiceMap } from "effect"
+ * import { Effect, Layer, Ref, Context } from "effect"
  *
- * class Counter extends ServiceMap.Service<Counter, {
+ * class Counter extends Context.Service<Counter, {
  *   readonly count: number
  *   readonly increment: () => Effect.Effect<number>
  * }>()("Counter") {}
@@ -2929,10 +3097,11 @@ export 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))
  *       )
+ *     )
  *   }
  * }))
  *
@@ -2971,14 +3140,14 @@ export const fresh = <A, E, R>(self: Layer<A, E, R>): Layer<A, E, R> =>
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap } from "effect"
+ * import { Console, Effect, Layer, Context } from "effect"
  *
- * class HttpServer extends ServiceMap.Service<HttpServer, {
+ * class HttpServer extends Context.Service<HttpServer, {
  *   readonly start: () => Effect.Effect<string>
  *   readonly stop: () => Effect.Effect<string>
  * }>()("HttpServer") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -2987,13 +3156,11 @@ export 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"
  *       })
@@ -3001,7 +3168,7 @@ export 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
@@ -3036,19 +3203,21 @@ export const launch = <RIn, E, ROut>(self: Layer<ROut, E, RIn>): Effect<never, E
  */
 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
@@ -3056,9 +3225,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
@@ -3071,7 +3240,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
@@ -3095,27 +3264,142 @@ export type PartialEffectful<A extends object> = Types.Simplify<
  * @since 4.0.0
  * @category Testing
  */
-export const mock =
-  <I, S extends object>(service: ServiceMap.Service<I, S>) => (implementation: PartialEffectful<S>): Layer<I> =>
-    succeed(service)(
-      new Proxy({ ...implementation as object } as S, {
-        get(target, prop, _receiver) {
-          if (prop in target) {
-            return target[prop as keyof S]
-          }
-          const prevLimit = (Error as ErrorWithStackTraceLimit).stackTraceLimit
-          ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = 2
-          const error = new Error(`${service.key}: Unimplemented method "${prop.toString()}"`)
-          ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = prevLimit
-          error.name = "UnimplementedError"
-          return makeUnimplemented(error)
-        },
-        has: constTrue
-      })
-    )
+export 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>
+} = function() {
+  if (arguments.length === 1) {
+    return (implementation: any) => mockImpl(arguments[0], implementation)
+  }
+  return mockImpl(arguments[0], arguments[1])
+} as any
+
+const mockImpl = <I, S extends object>(service: Context.Key<I, S>, implementation: PartialEffectful<S>): Layer<I> =>
+  succeed(service)(
+    new Proxy({ ...implementation as object } as S, {
+      get(target, prop, _receiver) {
+        if (prop in target) {
+          return target[prop as keyof S]
+        }
+        const prevLimit = (Error as ErrorWithStackTraceLimit).stackTraceLimit
+        ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = 2
+        const error = new Error(`${service.key}: Unimplemented method "${prop.toString()}"`)
+        ;(Error as ErrorWithStackTraceLimit).stackTraceLimit = prevLimit
+        error.name = "UnimplementedError"
+        return makeUnimplemented(error)
+      },
+      has: constTrue
+    })
+  )
 
 const makeUnimplemented = (error: globalThis.Error) => {
-  const dead = internalEffect.die(error)
+  const dead = Object.assign(internalEffect.die(error), {
+    [StreamTypeId]: StreamTypeId,
+    channel: {
+      [ChannelTypeId]: ChannelTypeId,
+      transform: () => internalEffect.succeed(dead),
+      pipe() {
+        return pipeArguments(this, arguments)
+      }
+    },
+    [ChannelTypeId]: ChannelTypeId,
+    transform: () => internalEffect.succeed(dead)
+  })
   function unimplemented() {
     return dead
   }
@@ -3125,6 +3409,9 @@ const makeUnimplemented = (error: globalThis.Error) => {
   return unimplemented
 }
 
+const StreamTypeId: Stream.TypeId = "~effect/Stream"
+const ChannelTypeId: Channel.TypeId = "~effect/Channel"
+
 // -----------------------------------------------------------------------------
 // Type constraints
 // -----------------------------------------------------------------------------
@@ -3254,9 +3541,9 @@ export interface SpanOptions extends Tracer.SpanOptions {
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap, type Tracer } from "effect"
+ * import { Console, Effect, Layer, Context, type Tracer } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -3272,7 +3559,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")))
  *
@@ -3315,9 +3602,9 @@ export const span = (
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap, Tracer } from "effect"
+ * import { Console, Effect, Layer, Context, Tracer } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -3331,7 +3618,7 @@ export const span = (
  *     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({
@@ -3344,7 +3631,7 @@ export const span = (
  * @category tracing
  */
 export const parentSpan = (span: Tracer.AnySpan): Layer<Tracer.ParentSpan> =>
-  succeedServices(Tracer.ParentSpan.serviceMap(span))
+  succeedContext(Tracer.ParentSpan.context(span))
 
 /**
  * Wraps a Layer with a new tracing span, making all operations in the layer
@@ -3356,13 +3643,13 @@ export const parentSpan = (span: Tracer.AnySpan): Layer<Tracer.ParentSpan> =>
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -3371,14 +3658,14 @@ export const parentSpan = (span: Tracer.AnySpan): Layer<Tracer.ParentSpan> =>
  *   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
@@ -3415,13 +3702,13 @@ export const withSpan: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -3430,14 +3717,14 @@ export 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
@@ -3476,13 +3763,13 @@ export const withSpan: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Logger extends ServiceMap.Service<Logger, {
+   * class Logger extends Context.Service<Logger, {
    *   readonly log: (msg: string) => Effect.Effect<void>
    * }>()("Logger") {}
    *
@@ -3491,14 +3778,14 @@ export 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
@@ -3566,13 +3853,13 @@ export const withSpan: {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap, Tracer } from "effect"
+ * import { Effect, Layer, Context, Tracer } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Cache extends ServiceMap.Service<Cache, {
+ * class Cache extends Context.Service<Cache, {
  *   readonly get: (key: string) => Effect.Effect<string | null>
  * }>()("Cache") {}
  *
@@ -3580,14 +3867,14 @@ export 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}`))
  *   }
  * }))
  *
@@ -3601,9 +3888,9 @@ export const withSpan: {
  *       Layer.withParentSpan(parentSpan)
  *     )
  *
- *     const services = yield* Layer.build(AppLayer)
- *     const database = ServiceMap.get(services, Database)
- *     const cache = ServiceMap.get(services, Cache)
+ *     const context = yield* Layer.build(AppLayer)
+ *     const database = Context.get(context, Database)
+ *     const cache = Context.get(context, Cache)
  *
  *     const dbResult = yield* database.query("SELECT * FROM users")
  *     const cacheResult = yield* cache.get("user:123")
@@ -3626,13 +3913,13 @@ export const withParentSpan: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap, Tracer } from "effect"
+   * import { Effect, Layer, Context, Tracer } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Cache extends ServiceMap.Service<Cache, {
+   * class Cache extends Context.Service<Cache, {
    *   readonly get: (key: string) => Effect.Effect<string | null>
    * }>()("Cache") {}
    *
@@ -3640,14 +3927,14 @@ export 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}`))
    *   }
    * }))
    *
@@ -3661,9 +3948,9 @@ export const withParentSpan: {
    *       Layer.withParentSpan(parentSpan)
    *     )
    *
-   *     const services = yield* Layer.build(AppLayer)
-   *     const database = ServiceMap.get(services, Database)
-   *     const cache = ServiceMap.get(services, Cache)
+   *     const context = yield* Layer.build(AppLayer)
+   *     const database = Context.get(context, Database)
+   *     const cache = Context.get(context, Cache)
    *
    *     const dbResult = yield* database.query("SELECT * FROM users")
    *     const cacheResult = yield* cache.get("user:123")
@@ -3688,13 +3975,13 @@ export const withParentSpan: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap, Tracer } from "effect"
+   * import { Effect, Layer, Context, Tracer } from "effect"
    *
-   * class Database extends ServiceMap.Service<Database, {
+   * class Database extends Context.Service<Database, {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }>()("Database") {}
    *
-   * class Cache extends ServiceMap.Service<Cache, {
+   * class Cache extends Context.Service<Cache, {
    *   readonly get: (key: string) => Effect.Effect<string | null>
    * }>()("Cache") {}
    *
@@ -3702,14 +3989,14 @@ export 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}`))
    *   }
    * }))
    *
@@ -3723,9 +4010,9 @@ export const withParentSpan: {
    *       Layer.withParentSpan(parentSpan)
    *     )
    *
-   *     const services = yield* Layer.build(AppLayer)
-   *     const database = ServiceMap.get(services, Database)
-   *     const cache = ServiceMap.get(services, Cache)
+   *     const context = yield* Layer.build(AppLayer)
+   *     const database = Context.get(context, Database)
+   *     const cache = Context.get(context, Cache)
    *
    *     const dbResult = yield* database.query("SELECT * FROM users")
    *     const cacheResult = yield* cache.get("user:123")