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

package/dist/Layer.js

@@ -1,3 +1,4 @@
+import * as Context from "./Context.js";
 import * as Deferred from "./Deferred.js";
 import { constant, constTrue, constUndefined, dual, identity } from "./Function.js";
 import * as core from "./internal/core.js";
@@ -7,7 +8,6 @@ import { pipeArguments } from "./Pipeable.js";
 import { hasProperty } from "./Predicate.js";
 import { CurrentStackFrame } from "./References.js";
 import * as Scope from "./Scope.js";
-import * as ServiceMap from "./ServiceMap.js";
 import * as Tracer from "./Tracer.js";
 const TypeId = "~effect/Layer";
 const MemoMapTypeId = "~effect/Layer/MemoMap";
@@ -16,9 +16,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") {}
  *
@@ -58,15 +58,15 @@ const fromBuildUnsafe = build => {
  *
  * @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")
  *     })
  *   )
@@ -89,15 +89,15 @@ export const fromBuild = build => fromBuildUnsafe((memoMap, scope) => {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
  * const databaseLayer = Layer.fromBuildMemo(() =>
  *   Effect.sync(() =>
- *     ServiceMap.make(Database, {
+ *     Context.make(Database, {
  *       query: (sql: string) => Effect.succeed("result")
  *     })
  *   )
@@ -148,9 +148,9 @@ class 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") {}
  *
@@ -162,9 +162,9 @@ class MemoMapImpl {
  *   const dbLayer = Layer.succeed(Database)({
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
- *   const services = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+ *   const context = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
  *
- *   return ServiceMap.get(services, Database)
+ *   return Context.get(context, Database)
  * })
  * ```
  *
@@ -177,9 +177,9 @@ export const makeMemoMapUnsafe = () => 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") {}
  *
@@ -191,9 +191,9 @@ export const makeMemoMapUnsafe = () => new MemoMapImpl();
  *   const dbLayer = Layer.succeed(Database)({
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
- *   const services = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+ *   const context = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
  *
- *   return ServiceMap.get(services, Database)
+ *   return Context.get(context, Database)
  * })
  * ```
  *
@@ -210,8 +210,8 @@ export const makeMemoMap = /*#__PURE__*/internalEffect.sync(makeMemoMapUnsafe);
  * @since 3.13.0
  * @category models
  */
-export class CurrentMemoMap extends /*#__PURE__*/ServiceMap.Service()("effect/Layer/CurrentMemoMap") {
-  static getOrCreate = /*#__PURE__*/ServiceMap.getOrElse(this, makeMemoMapUnsafe);
+export class CurrentMemoMap extends /*#__PURE__*/Context.Service()("effect/Layer/CurrentMemoMap") {
+  static getOrCreate = /*#__PURE__*/Context.getOrElse(this, makeMemoMapUnsafe);
 }
 /**
  * Builds a layer into an `Effect` value, using the specified `MemoMap` to memoize
@@ -219,13 +219,13 @@ export class CurrentMemoMap extends /*#__PURE__*/ServiceMap.Service()("effect/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") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -238,21 +238,21 @@ export class CurrentMemoMap extends /*#__PURE__*/ServiceMap.Service()("effect/La
  *   const dbLayer = Layer.succeed(Database)({
  *     query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
  *   })
- *   const dbServices = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
+ *   const dbContext = yield* Layer.buildWithMemoMap(dbLayer, memoMap, scope)
  *
  *   // Build logger layer with same memoization (reuses memo if same layer)
  *   const loggerLayer = Layer.succeed(Logger)({
  *     log: Effect.fn("Logger.log")((msg: string) => Effect.sync(() => console.log(msg)))
  *   })
- *   const loggerServices = yield* Layer.buildWithMemoMap(
+ *   const loggerContext = yield* Layer.buildWithMemoMap(
  *     loggerLayer,
  *     memoMap,
  *     scope
  *   )
  *
  *   return {
- *     database: ServiceMap.get(dbServices, Database),
- *     logger: ServiceMap.get(loggerServices, Logger)
+ *     database: Context.get(dbContext, Database),
+ *     logger: Context.get(loggerContext, Logger)
  *   }
  * })
  * ```
@@ -260,15 +260,15 @@ export class CurrentMemoMap extends /*#__PURE__*/ServiceMap.Service()("effect/La
  * @since 2.0.0
  * @category memo map
  */
-export const buildWithMemoMap = /*#__PURE__*/dual(3, (self, memoMap, scope) => internalEffect.provideService(internalEffect.map(self.build(memoMap, scope), ServiceMap.add(CurrentMemoMap, memoMap)), CurrentMemoMap, memoMap));
+export const buildWithMemoMap = /*#__PURE__*/dual(3, (self, memoMap, scope) => internalEffect.provideService(internalEffect.map(self.build(memoMap, scope), Context.add(CurrentMemoMap, memoMap)), CurrentMemoMap, memoMap));
 /**
  * Builds a layer into a scoped value.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
@@ -278,11 +278,11 @@ export const buildWithMemoMap = /*#__PURE__*/dual(3, (self, memoMap, scope) => i
  *     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")
  * })
@@ -291,7 +291,7 @@ export const buildWithMemoMap = /*#__PURE__*/dual(3, (self, memoMap, scope) => i
  * @since 2.0.0
  * @category destructors
  */
-export const build = self => core.withFiber(fiber => buildWithMemoMap(self, CurrentMemoMap.getOrCreate(fiber.services), ServiceMap.getUnsafe(fiber.services, Scope.Scope)));
+export const build = self => core.withFiber(fiber => buildWithMemoMap(self, CurrentMemoMap.getOrCreate(fiber.context), Context.getUnsafe(fiber.context, Scope.Scope)));
 /**
  * Builds a layer into an `Effect` value. Any resources associated with this
  * layer will be released when the specified scope is closed unless their scope
@@ -301,9 +301,9 @@ export const build = self => core.withFiber(fiber => buildWithMemoMap(self, Curr
  *
  * @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") {}
  *
@@ -321,8 +321,8 @@ export const build = self => core.withFiber(fiber => buildWithMemoMap(self, Curr
  *   }))
  *
  *   // 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
@@ -332,19 +332,19 @@ export const build = self => core.withFiber(fiber => buildWithMemoMap(self, Curr
  * @since 2.0.0
  * @category destructors
  */
-export const buildWithScope = /*#__PURE__*/dual(2, (self, scope) => core.withFiber(fiber => buildWithMemoMap(self, CurrentMemoMap.getOrCreate(fiber.services), scope)));
+export const buildWithScope = /*#__PURE__*/dual(2, (self, scope) => core.withFiber(fiber => buildWithMemoMap(self, CurrentMemoMap.getOrCreate(fiber.context), scope)));
 /**
  * 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") {}
  *
@@ -377,47 +377,46 @@ export const buildWithScope = /*#__PURE__*/dual(2, (self, scope) => core.withFib
  */
 export const succeed = function () {
   if (arguments.length === 1) {
-    return resource => succeedServices(ServiceMap.make(arguments[0], resource));
+    return resource => succeedContext(Context.make(arguments[0], resource));
   }
-  return succeedServices(ServiceMap.make(arguments[0], arguments[1]));
+  return succeedContext(Context.make(arguments[0], arguments[1]));
 };
 /**
  * Constructs a layer from the specified value, which must return one or more
  * services.
  *
  * This is a more general version of `succeed` that allows you to provide multiple
- * services at once through a `ServiceMap`.
+ * services at once through a `Context`.
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
- * const services = ServiceMap.make(Database, {
+ * const context = Context.make(Database, {
  *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed("result"))
- * })
- *   .pipe(
- *     ServiceMap.add(Logger, {
- *       log: (msg: string) => Effect.sync(() => console.log(msg))
- *     })
- *   )
+ * }).pipe(
+ *   Context.add(Logger, {
+ *     log: (msg: string) => Effect.sync(() => console.log(msg))
+ *   })
+ * )
  *
- * const layer = Layer.succeedServices(services)
+ * const layer = Layer.succeedContext(context)
  * ```
  *
  * @since 2.0.0
  * @category constructors
  */
-export const succeedServices = services => fromBuildUnsafe(constant(internalEffect.succeed(services)));
+export const succeedContext = context => 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.
@@ -432,7 +431,7 @@ export const succeedServices = services => fromBuildUnsafe(constant(internalEffe
  * @since 2.0.0
  * @category constructors
  */
-export const empty = /*#__PURE__*/succeedServices(/*#__PURE__*/ServiceMap.empty());
+export const empty = /*#__PURE__*/succeedContext(/*#__PURE__*/Context.empty());
 /**
  * Lazily constructs a layer from the specified value.
  *
@@ -441,9 +440,9 @@ export const empty = /*#__PURE__*/succeedServices(/*#__PURE__*/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") {}
  *
@@ -457,27 +456,27 @@ export const empty = /*#__PURE__*/succeedServices(/*#__PURE__*/ServiceMap.empty(
  */
 export const sync = function () {
   if (arguments.length === 1) {
-    return evaluate => syncServices(() => ServiceMap.make(arguments[0], evaluate()));
+    return evaluate => syncContext(() => Context.make(arguments[0], evaluate()));
   }
-  return syncServices(() => ServiceMap.make(arguments[0], arguments[1]()));
+  return syncContext(() => Context.make(arguments[0], arguments[1]()));
 };
 /**
  * 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}`)
  *   })
  * )
@@ -486,7 +485,7 @@ export const sync = function () {
  * @since 2.0.0
  * @category constructors
  */
-export const syncServices = evaluate => fromBuildMemo(constant(internalEffect.sync(evaluate)));
+export const syncContext = evaluate => fromBuildMemo(constant(internalEffect.sync(evaluate)));
 /**
  * Constructs a layer from the specified scoped effect.
  *
@@ -502,9 +501,9 @@ export const syncServices = evaluate => fromBuildMemo(constant(internalEffect.sy
  *
  * @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") {}
  *
@@ -524,7 +523,7 @@ export const effect = function () {
   }
   return effectImpl(arguments[0], arguments[1]);
 };
-const effectImpl = (service, effect) => effectServices(internalEffect.map(effect, value => ServiceMap.make(service, value)));
+const effectImpl = (service, effect) => effectContext(internalEffect.map(effect, value => Context.make(service, value)));
 /**
  * Constructs a layer from the specified scoped effect, which must return one
  * or more services.
@@ -534,15 +533,15 @@ const effectImpl = (service, effect) => effectServices(internalEffect.map(effect
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<
+ * class Database extends Context.Service<
  *   Database,
  *   { readonly query: (sql: string) => Effect.Effect<string> }
  * >()("Database") {}
  *
- * const layer = Layer.effectServices(
- *   Effect.succeed(ServiceMap.make(Database, {
+ * const layer = Layer.effectContext(
+ *   Effect.succeed(Context.make(Database, {
  *     query: (sql: string) => Effect.succeed(`Query: ${sql}`)
  *   }))
  * )
@@ -551,7 +550,7 @@ const effectImpl = (service, effect) => effectServices(internalEffect.map(effect
  * @since 2.0.0
  * @category constructors
  */
-export const effectServices = effect => fromBuildMemo((_, scope) => Scope.provide(effect, scope));
+export const effectContext = effect => fromBuildMemo((_, scope) => Scope.provide(effect, scope));
 /**
  * Constructs a layer from the specified scoped effect.
  *
@@ -578,7 +577,32 @@ export const effectServices = effect => fromBuildMemo((_, scope) => Scope.provid
  * @since 2.0.0
  * @category constructors
  */
-export const effectDiscard = effect => effectServices(internalEffect.as(effect, ServiceMap.empty()));
+export const effectDiscard = effect => 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 = evaluate => fromBuildMemo((memoMap, scope) => internalEffect.suspend(() => evaluate().build(memoMap, scope)));
 /**
  * Unwraps a Layer from an Effect, flattening the nested structure.
  *
@@ -588,9 +612,9 @@ export const effectDiscard = effect => effectServices(internalEffect.as(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") {}
  *
@@ -605,14 +629,14 @@ export const effectDiscard = effect => effectServices(internalEffect.as(effect,
  * @category utils
  */
 export const unwrap = self => {
-  const service = ServiceMap.Service("effect/Layer/unwrap");
-  return flatMap(effect(service)(self), ServiceMap.get(service));
+  const service = Context.Service("effect/Layer/unwrap");
+  return flatMap(effect(service)(self), Context.get(service));
 };
 const mergeAllEffect = (layers, memoMap, scope) => {
   const parentScope = Scope.forkUnsafe(scope, "parallel");
   return internalEffect.forEach(layers, layer => layer.build(memoMap, Scope.forkUnsafe(parentScope, "sequential")), {
     concurrency: layers.length
-  }).pipe(internalEffect.map(services => ServiceMap.mergeAll(...services)));
+  }).pipe(internalEffect.map(context => Context.mergeAll(...context)));
 };
 /**
  * Combines all the provided layers concurrently, creating a new layer with merged input, error, and output types.
@@ -622,13 +646,13 @@ const mergeAllEffect = (layers, memoMap, scope) => {
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
- * class Database extends ServiceMap.Service<Database, {
+ * class Database extends Context.Service<Database, {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }>()("Database") {}
  *
- * class Logger extends ServiceMap.Service<Logger, {
+ * class Logger extends Context.Service<Logger, {
  *   readonly log: (msg: string) => Effect.Effect<void>
  * }>()("Logger") {}
  *
@@ -654,13 +678,13 @@ export const mergeAll = (...layers) => fromBuild((memoMap, scope) => mergeAllEff
  *
  * @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") {}
  *
@@ -678,7 +702,7 @@ export const mergeAll = (...layers) => fromBuild((memoMap, scope) => mergeAllEff
  * @category zipping
  */
 export const merge = /*#__PURE__*/dual(2, (self, that) => mergeAll(self, ...(Array.isArray(that) ? that : [that])));
-const provideWith = (self, that, f) => fromBuild((memoMap, scope) => internalEffect.flatMap(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), context => self.build(memoMap, scope).pipe(internalEffect.provideServices(context), internalEffect.map(merged => f(merged, context)))));
+const provideWith = (self, that, f) => fromBuild((memoMap, scope) => internalEffect.flatMap(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), context => self.build(memoMap, scope).pipe(internalEffect.provideContext(context), internalEffect.map(merged => f(merged, context)))));
 /**
  * Feeds the output services of this builder into the input of the specified
  * builder, resulting in a new builder with the inputs of this builder as
@@ -686,20 +710,20 @@ const provideWith = (self, that, f) => fromBuild((memoMap, scope) => internalEff
  *
  * @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") {}
  *
@@ -753,17 +777,17 @@ export const provide = /*#__PURE__*/dual(2, (self, that) => provideWith(self, th
  *
  * @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
@@ -818,24 +842,24 @@ export const provide = /*#__PURE__*/dual(2, (self, that) => provideWith(self, th
  * @since 2.0.0
  * @category utils
  */
-export const provideMerge = /*#__PURE__*/dual(2, (self, that) => provideWith(self, that, (self, that) => ServiceMap.merge(that, self)));
+export const provideMerge = /*#__PURE__*/dual(2, (self, that) => provideWith(self, that, (self, that) => Context.merge(that, self)));
 /**
  * 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") {}
  *
@@ -847,8 +871,8 @@ export const provideMerge = /*#__PURE__*/dual(2, (self, that) => provideWith(sel
  *
  * // 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)({
@@ -923,13 +947,13 @@ export const tapCause = /*#__PURE__*/dual(2, (self, f) => fromBuild((memoMap, sc
  *
  * @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") {}
  *
@@ -977,11 +1001,11 @@ catch_ as catch };
  *
  * @example
  * ```ts
- * import { Data, Effect, Layer, ServiceMap } from "effect"
+ * import { Data, Effect, Layer, Context } from "effect"
  *
  * class ConfigError extends Data.TaggedError("ConfigError") {}
  *
- * class Config extends ServiceMap.Service<Config, {
+ * class Config extends Context.Service<Config, {
  *   readonly apiUrl: string
  * }>()("Config") {}
  *
@@ -1003,7 +1027,7 @@ export const catchTag = /*#__PURE__*/dual(3, (self, k, f) => fromBuildUnsafe((me
  *
  * @example
  * ```ts
- * import { Data, Effect, Layer, ServiceMap } from "effect"
+ * import { Data, Effect, Layer, Context } from "effect"
  *
  * class DatabaseError extends Data.TaggedError("DatabaseError")<{
  *   message: string
@@ -1013,11 +1037,11 @@ export const catchTag = /*#__PURE__*/dual(3, (self, k, f) => fromBuildUnsafe((me
  *   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") {}
  *
@@ -1080,9 +1104,9 @@ export const updateService = /*#__PURE__*/dual(3, (layer, service, f) => provide
  *
  * @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") {}
@@ -1133,14 +1157,14 @@ export const fresh = self => fromBuildUnsafe((_, scope) => self.build(makeMemoMa
  *
  * @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") {}
  *
@@ -1189,9 +1213,9 @@ export const launch = self => internalEffect.scoped(internalEffect.andThen(build
  *
  * @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
@@ -1374,9 +1398,9 @@ export const satisfiesServicesType = () => layer => layer;
  *
  * @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") {}
  *
@@ -1423,9 +1447,9 @@ export const span = (name, options) => {
  *
  * @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") {}
  *
@@ -1451,7 +1475,7 @@ export const span = (name, options) => {
  * @since 4.0.0
  * @category tracing
  */
-export const parentSpan = span => succeedServices(Tracer.ParentSpan.serviceMap(span));
+export const parentSpan = span => succeedContext(Tracer.ParentSpan.context(span));
 /**
  * Wraps a Layer with a new tracing span, making all operations in the layer
  * constructor part of the named trace span.
@@ -1462,13 +1486,13 @@ export const parentSpan = span => succeedServices(Tracer.ParentSpan.serviceMap(s
  *
  * @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") {}
  *
@@ -1529,13 +1553,13 @@ export const withSpan = function () {
  *
  * @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") {}
  *
@@ -1564,9 +1588,9 @@ export const withSpan = function () {
  *       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")