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

package/src/Effect.ts

@@ -71,6 +71,7 @@
 import type * as Arr from "./Array.ts"
 import type * as Cause from "./Cause.ts"
 import type { Clock } from "./Clock.ts"
+import * as Context from "./Context.ts"
 import * as Duration from "./Duration.ts"
 import type { ExecutionPlan } from "./ExecutionPlan.ts"
 import * as Exit from "./Exit.ts"
@@ -98,7 +99,6 @@ import type * as Result from "./Result.ts"
 import type { Schedule } from "./Schedule.ts"
 import type { Scheduler } from "./Scheduler.ts"
 import type { Scope } from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import type {
   AnySpan,
   ParentSpan,
@@ -6760,6 +6760,7 @@ export declare namespace Retry {
   export type Return<R, E, A, O extends Options<E>> = Effect<
     A,
     | (O extends { schedule: Schedule<infer _O, infer _I, infer _E1, infer _R> } ? E
+      : O extends { times: number } ? E
       : O extends { until: Predicate.Refinement<E, infer E2> } ? E2
       : O extends { while: Predicate.Refinement<E, infer E2> } ? Exclude<E, E2>
       : E)
@@ -7498,9 +7499,9 @@ export const ignoreCause: <
  *
  * @example
  * ```ts
- * import { Effect, ExecutionPlan, Layer, ServiceMap } from "effect"
+ * import { Effect, ExecutionPlan, Layer, Context } from "effect"
  *
- * const Endpoint = ServiceMap.Service<{ url: string }>("Endpoint")
+ * const Endpoint = Context.Service<{ url: string }>("Endpoint")
  *
  * const fetchUrl = Effect.gen(function*() {
  *   const endpoint = yield* Effect.service(Endpoint)
@@ -7532,9 +7533,9 @@ export const withExecutionPlan: {
    *
    * @example
    * ```ts
-   * import { Effect, ExecutionPlan, Layer, ServiceMap } from "effect"
+   * import { Effect, ExecutionPlan, Layer, Context } from "effect"
    *
-   * const Endpoint = ServiceMap.Service<{ url: string }>("Endpoint")
+   * const Endpoint = Context.Service<{ url: string }>("Endpoint")
    *
    * const fetchUrl = Effect.gen(function*() {
    *   const endpoint = yield* Effect.service(Endpoint)
@@ -7570,9 +7571,9 @@ export const withExecutionPlan: {
    *
    * @example
    * ```ts
-   * import { Effect, ExecutionPlan, Layer, ServiceMap } from "effect"
+   * import { Effect, ExecutionPlan, Layer, Context } from "effect"
    *
-   * const Endpoint = ServiceMap.Service<{ url: string }>("Endpoint")
+   * const Endpoint = Context.Service<{ url: string }>("Endpoint")
    *
    * const fetchUrl = Effect.gen(function*() {
    *   const endpoint = yield* Effect.service(Endpoint)
@@ -10501,7 +10502,7 @@ export const isSuccess: <A, E, R>(self: Effect<A, E, R>) => Effect<boolean, neve
 // -----------------------------------------------------------------------------
 
 /**
- * Returns the complete service map from the current context.
+ * Returns the complete context.
  *
  * This function allows you to access all services that are currently available
  * in the effect's environment. This can be useful for debugging, introspection,
@@ -10509,57 +10510,57 @@ export const isSuccess: <A, E, R>(self: Effect<A, E, R>) => Effect<boolean, neve
  *
  * @example
  * ```ts
- * import { Console, Effect, Option, ServiceMap } from "effect"
+ * import { Console, Effect, Option, Context } from "effect"
  *
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
- * const Database = ServiceMap.Service<{
+ * const Database = Context.Service<{
  *   query: (sql: string) => string
  * }>("Database")
  *
  * const program = Effect.gen(function*() {
- *   const allServices = yield* Effect.services()
+ *   const allServices = yield* Effect.context()
  *
  *   // Check if specific services are available
- *   const loggerOption = ServiceMap.getOption(allServices, Logger)
- *   const databaseOption = ServiceMap.getOption(allServices, Database)
+ *   const loggerOption = Context.getOption(allServices, Logger)
+ *   const databaseOption = Context.getOption(allServices, Database)
  *
  *   yield* Console.log(`Logger available: ${Option.isSome(loggerOption)}`)
  *   yield* Console.log(`Database available: ${Option.isSome(databaseOption)}`)
  * })
  *
- * const serviceMap = ServiceMap.make(Logger, { log: console.log })
- *   .pipe(ServiceMap.add(Database, { query: () => "result" }))
+ * const context = Context.make(Logger, { log: console.log })
+ *   .pipe(Context.add(Database, { query: () => "result" }))
  *
- * const provided = Effect.provideServices(program, serviceMap)
+ * const provided = Effect.provideContext(program, context)
  * ```
  *
  * @since 2.0.0
  * @category Environment
  */
-export const services: <R = never>() => Effect<ServiceMap.ServiceMap<R>, never, R> = internal.services
+export const context: <R = never>() => Effect<Context.Context<R>, never, R> = internal.context
 
 /**
- * Transforms the current service map using the provided function.
+ * Transforms the current context using the provided function.
  *
- * This function allows you to access the complete service map and perform
+ * This function allows you to access the complete context and perform
  * computations based on all available services. This is useful when you need
  * to conditionally execute logic based on what services are available.
  *
  * @example
  * ```ts
- * import { Console, Effect, Option, ServiceMap } from "effect"
+ * import { Console, Effect, Option, Context } from "effect"
  *
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
- * const Cache = ServiceMap.Service<{
+ * const Cache = Context.Service<{
  *   get: (key: string) => string | null
  * }>("Cache")
  *
- * const program = Effect.servicesWith((services) => {
- *   const cacheOption = ServiceMap.getOption(services, Cache)
+ * const program = Effect.contextWith((services) => {
+ *   const cacheOption = Context.getOption(services, Cache)
  *   const hasCache = Option.isSome(cacheOption)
  *
  *   if (hasCache) {
@@ -10584,9 +10585,9 @@ export const services: <R = never>() => Effect<ServiceMap.ServiceMap<R>, never,
  * @since 2.0.0
  * @category Environment
  */
-export const servicesWith: <R, A, E, R2>(
-  f: (services: ServiceMap.ServiceMap<R>) => Effect<A, E, R2>
-) => Effect<A, E, R | R2> = internal.servicesWith
+export const contextWith: <R, A, E, R2>(
+  f: (context: Context.Context<R>) => Effect<A, E, R2>
+) => Effect<A, E, R | R2> = internal.contextWith
 
 /**
  * Provides dependencies to an effect using layers or a context. Use `options.local`
@@ -10595,13 +10596,13 @@ export const servicesWith: <R, A, E, R2>(
  *
  * @example
  * ```ts
- * import { Effect, Layer, ServiceMap } from "effect"
+ * import { Effect, Layer, Context } from "effect"
  *
  * interface Database {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }
  *
- * const Database = ServiceMap.Service<Database>("Database")
+ * const Database = Context.Service<Database>("Database")
  *
  * const DatabaseLive = Layer.succeed(Database)({
  *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
@@ -10629,13 +10630,13 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
    * interface Database {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }
    *
-   * const Database = ServiceMap.Service<Database>("Database")
+   * const Database = Context.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
@@ -10674,13 +10675,13 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
    * interface Database {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }
    *
-   * const Database = ServiceMap.Service<Database>("Database")
+   * const Database = Context.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
@@ -10715,13 +10716,13 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
    * interface Database {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }
    *
-   * const Database = ServiceMap.Service<Database>("Database")
+   * const Database = Context.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
@@ -10741,7 +10742,7 @@ export const provide: {
    * @since 2.0.0
    * @category Environment
    */
-  <R2>(context: ServiceMap.ServiceMap<R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, R2>>
+  <R2>(context: Context.Context<R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, R2>>
   /**
    * Provides dependencies to an effect using layers or a context. Use `options.local`
    * to build the layer every time; by default, layers are shared between provide
@@ -10749,13 +10750,13 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
    * interface Database {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }
    *
-   * const Database = ServiceMap.Service<Database>("Database")
+   * const Database = Context.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
@@ -10793,13 +10794,13 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
    * interface Database {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }
    *
-   * const Database = ServiceMap.Service<Database>("Database")
+   * const Database = Context.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
@@ -10833,13 +10834,13 @@ export const provide: {
    *
    * @example
    * ```ts
-   * import { Effect, Layer, ServiceMap } from "effect"
+   * import { Effect, Layer, Context } from "effect"
    *
    * interface Database {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }
    *
-   * const Database = ServiceMap.Service<Database>("Database")
+   * const Database = Context.Service<Database>("Database")
    *
    * const DatabaseLive = Layer.succeed(Database)({
    *   query: Effect.fn("Database.query")((sql: string) => Effect.succeed(`Result for: ${sql}`))
@@ -10859,33 +10860,33 @@ export const provide: {
    * @since 2.0.0
    * @category Environment
    */
-  <A, E, R, R2>(self: Effect<A, E, R>, context: ServiceMap.ServiceMap<R2>): Effect<A, E, Exclude<R, R2>>
+  <A, E, R, R2>(self: Effect<A, E, R>, context: Context.Context<R2>): Effect<A, E, Exclude<R, R2>>
 } = internalLayer.provide
 
 /**
- * Provides a service map to an effect, fulfilling its service requirements.
+ * Provides a context to an effect, fulfilling its service requirements.
  *
  * **Details**
  *
- * This function provides multiple services at once by supplying a service map
+ * This function provides multiple services at once by supplying a context
  * that contains all the required services. It removes the provided services
  * from the effect's requirements, making them available to the effect.
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * // Define service keys
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
- * const Database = ServiceMap.Service<{
+ * const Database = Context.Service<{
  *   query: (sql: string) => string
  * }>("Database")
  *
- * // Create service map with multiple services
- * const serviceMap = ServiceMap.make(Logger, { log: console.log })
- *   .pipe(ServiceMap.add(Database, { query: () => "result" }))
+ * // Create a context with multiple services
+ * const context = Context.make(Logger, { log: console.log })
+ *   .pipe(Context.add(Database, { query: () => "result" }))
  *
  * // An effect that requires both services
  * const program = Effect.gen(function*() {
@@ -10895,37 +10896,37 @@ export const provide: {
  *   return db.query("SELECT * FROM users")
  * })
  *
- * const provided = Effect.provideServices(program, serviceMap)
+ * const provided = Effect.provideContext(program, context)
  * ```
  *
  * @since 2.0.0
  * @category Environment
  */
-export const provideServices: {
+export const provideContext: {
   /**
-   * Provides a service map to an effect, fulfilling its service requirements.
+   * Provides a context to an effect, fulfilling its service requirements.
    *
    * **Details**
    *
-   * This function provides multiple services at once by supplying a service map
+   * This function provides multiple services at once by supplying a context
    * that contains all the required services. It removes the provided services
    * from the effect's requirements, making them available to the effect.
    *
    * @example
    * ```ts
-   * import { Effect, ServiceMap } from "effect"
+   * import { Effect, Context } from "effect"
    *
    * // Define service keys
-   * const Logger = ServiceMap.Service<{
+   * const Logger = Context.Service<{
    *   log: (msg: string) => void
    * }>("Logger")
-   * const Database = ServiceMap.Service<{
+   * const Database = Context.Service<{
    *   query: (sql: string) => string
    * }>("Database")
    *
-   * // Create service map with multiple services
-   * const serviceMap = ServiceMap.make(Logger, { log: console.log })
-   *   .pipe(ServiceMap.add(Database, { query: () => "result" }))
+   * // Create a context with multiple services
+   * const context = Context.make(Logger, { log: console.log })
+   *   .pipe(Context.add(Database, { query: () => "result" }))
    *
    * // An effect that requires both services
    * const program = Effect.gen(function*() {
@@ -10935,37 +10936,37 @@ export const provideServices: {
    *   return db.query("SELECT * FROM users")
    * })
    *
-   * const provided = Effect.provideServices(program, serviceMap)
+   * const provided = Effect.provideContext(program, context)
    * ```
    *
    * @since 2.0.0
    * @category Environment
    */
-  <XR>(context: ServiceMap.ServiceMap<XR>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, XR>>
+  <XR>(context: Context.Context<XR>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, XR>>
   /**
-   * Provides a service map to an effect, fulfilling its service requirements.
+   * Provides a context to an effect, fulfilling its service requirements.
    *
    * **Details**
    *
-   * This function provides multiple services at once by supplying a service map
+   * This function provides multiple services at once by supplying a context
    * that contains all the required services. It removes the provided services
    * from the effect's requirements, making them available to the effect.
    *
    * @example
    * ```ts
-   * import { Effect, ServiceMap } from "effect"
+   * import { Effect, Context } from "effect"
    *
    * // Define service keys
-   * const Logger = ServiceMap.Service<{
+   * const Logger = Context.Service<{
    *   log: (msg: string) => void
    * }>("Logger")
-   * const Database = ServiceMap.Service<{
+   * const Database = Context.Service<{
    *   query: (sql: string) => string
    * }>("Database")
    *
-   * // Create service map with multiple services
-   * const serviceMap = ServiceMap.make(Logger, { log: console.log })
-   *   .pipe(ServiceMap.add(Database, { query: () => "result" }))
+   * // Create a context with multiple services
+   * const context = Context.make(Logger, { log: console.log })
+   *   .pipe(Context.add(Database, { query: () => "result" }))
    *
    * // An effect that requires both services
    * const program = Effect.gen(function*() {
@@ -10975,27 +10976,27 @@ export const provideServices: {
    *   return db.query("SELECT * FROM users")
    * })
    *
-   * const provided = Effect.provideServices(program, serviceMap)
+   * const provided = Effect.provideContext(program, context)
    * ```
    *
    * @since 2.0.0
    * @category Environment
    */
-  <A, E, R, XR>(self: Effect<A, E, R>, context: ServiceMap.ServiceMap<XR>): Effect<A, E, Exclude<R, XR>>
-} = internal.provideServices
+  <A, E, R, XR>(self: Effect<A, E, R>, context: Context.Context<XR>): Effect<A, E, Exclude<R, XR>>
+} = internal.provideContext
 
 /**
  * Accesses a service from the context.
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * interface Database {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }
  *
- * const Database = ServiceMap.Service<Database>("Database")
+ * const Database = Context.Service<Database>("Database")
  *
  * const program = Effect.gen(function*() {
  *   const db = yield* Effect.service(Database)
@@ -11004,9 +11005,9 @@ export const provideServices: {
  * ```
  *
  * @since 4.0.0
- * @category ServiceMap
+ * @category Context
  */
-export const service: <I, S>(service: ServiceMap.Key<I, S>) => Effect<S, never, I> = internal.service
+export const service: <I, S>(service: Context.Key<I, S>) => Effect<S, never, I> = internal.service
 
 /**
  * Optionally accesses a service from the environment.
@@ -11020,10 +11021,10 @@ export const service: <I, S>(service: ServiceMap.Key<I, S>) => Effect<S, never,
  *
  * @example
  * ```ts
- * import { Effect, Option, ServiceMap } from "effect"
+ * import { Effect, Option, Context } from "effect"
  *
  * // Define a service key
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
  *
@@ -11040,9 +11041,9 @@ export const service: <I, S>(service: ServiceMap.Key<I, S>) => Effect<S, never,
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
-export const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<Option<S>> = internal.serviceOption
+export const serviceOption: <I, S>(key: Context.Key<I, S>) => Effect<Option<S>> = internal.serviceOption
 
 /**
  * Provides part of the required context while leaving the rest unchanged.
@@ -11054,13 +11055,13 @@ export const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<Option<S
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * // Define services
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
- * const Config = ServiceMap.Service<{
+ * const Config = Context.Service<{
  *   name: string
  * }>("Config")
  *
@@ -11070,8 +11071,8 @@ export const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<Option<S
  *
  * // Transform services by providing Config while keeping Logger requirement
  * const configured = program.pipe(
- *   Effect.updateServices((services: ServiceMap.ServiceMap<typeof Logger>) =>
- *     ServiceMap.add(services, Config, { name: "World" })
+ *   Effect.updateContext((context: Context.Context<typeof Logger>) =>
+ *     Context.add(context, Config, { name: "World" })
  *   )
  * )
  *
@@ -11082,9 +11083,9 @@ export const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<Option<S
  * ```
  *
  * @since 4.0.0
- * @category ServiceMap
+ * @category Context
  */
-export const updateServices: {
+export const updateContext: {
   /**
    * Provides part of the required context while leaving the rest unchanged.
    *
@@ -11095,13 +11096,13 @@ export const updateServices: {
    *
    * @example
    * ```ts
-   * import { Effect, ServiceMap } from "effect"
+   * import { Effect, Context } from "effect"
    *
    * // Define services
-   * const Logger = ServiceMap.Service<{
+   * const Logger = Context.Service<{
    *   log: (msg: string) => void
    * }>("Logger")
-   * const Config = ServiceMap.Service<{
+   * const Config = Context.Service<{
    *   name: string
    * }>("Config")
    *
@@ -11111,8 +11112,8 @@ export const updateServices: {
    *
    * // Transform services by providing Config while keeping Logger requirement
    * const configured = program.pipe(
-   *   Effect.updateServices((services: ServiceMap.ServiceMap<typeof Logger>) =>
-   *     ServiceMap.add(services, Config, { name: "World" })
+   *   Effect.updateContext((context: Context.Context<typeof Logger>) =>
+   *     Context.add(context, Config, { name: "World" })
    *   )
    * )
    *
@@ -11123,11 +11124,9 @@ export const updateServices: {
    * ```
    *
    * @since 4.0.0
-   * @category ServiceMap
+   * @category Context
    */
-  <R2, R>(
-    f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<NoInfer<R>>
-  ): <A, E>(self: Effect<A, E, R>) => Effect<A, E, R2>
+  <R2, R>(f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>): <A, E>(self: Effect<A, E, R>) => Effect<A, E, R2>
   /**
    * Provides part of the required context while leaving the rest unchanged.
    *
@@ -11138,13 +11137,13 @@ export const updateServices: {
    *
    * @example
    * ```ts
-   * import { Effect, ServiceMap } from "effect"
+   * import { Effect, Context } from "effect"
    *
    * // Define services
-   * const Logger = ServiceMap.Service<{
+   * const Logger = Context.Service<{
    *   log: (msg: string) => void
    * }>("Logger")
-   * const Config = ServiceMap.Service<{
+   * const Config = Context.Service<{
    *   name: string
    * }>("Config")
    *
@@ -11154,8 +11153,8 @@ export const updateServices: {
    *
    * // Transform services by providing Config while keeping Logger requirement
    * const configured = program.pipe(
-   *   Effect.updateServices((services: ServiceMap.ServiceMap<typeof Logger>) =>
-   *     ServiceMap.add(services, Config, { name: "World" })
+   *   Effect.updateContext((context: Context.Context<typeof Logger>) =>
+   *     Context.add(context, Config, { name: "World" })
    *   )
    * )
    *
@@ -11166,23 +11165,23 @@ export const updateServices: {
    * ```
    *
    * @since 4.0.0
-   * @category ServiceMap
+   * @category Context
    */
   <A, E, R, R2>(
     self: Effect<A, E, R>,
-    f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<NoInfer<R>>
+    f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>
   ): Effect<A, E, R2>
-} = internal.updateServices
+} = internal.updateContext
 
 /**
  * Updates the service with the required service entry.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap } from "effect"
+ * import { Console, Effect, Context } from "effect"
  *
  * // Define a counter service
- * const Counter = ServiceMap.Service<{ count: number }>("Counter")
+ * const Counter = Context.Service<{ count: number }>("Counter")
  *
  * const program = Effect.gen(function*() {
  *   const updatedCounter = yield* Effect.service(Counter)
@@ -11200,7 +11199,7 @@ export const updateServices: {
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
 export const updateService: {
   /**
@@ -11208,10 +11207,10 @@ export const updateService: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, ServiceMap } from "effect"
+   * import { Console, Effect, Context } from "effect"
    *
    * // Define a counter service
-   * const Counter = ServiceMap.Service<{ count: number }>("Counter")
+   * const Counter = Context.Service<{ count: number }>("Counter")
    *
    * const program = Effect.gen(function*() {
    *   const updatedCounter = yield* Effect.service(Counter)
@@ -11229,18 +11228,18 @@ export const updateService: {
    * ```
    *
    * @since 2.0.0
-   * @category ServiceMap
+   * @category Context
    */
-  <I, A>(service: ServiceMap.Key<I, A>, f: (value: A) => A): <XA, E, R>(self: Effect<XA, E, R>) => Effect<XA, E, R | I>
+  <I, A>(service: Context.Key<I, A>, f: (value: A) => A): <XA, E, R>(self: Effect<XA, E, R>) => Effect<XA, E, R | I>
   /**
    * Updates the service with the required service entry.
    *
    * @example
    * ```ts
-   * import { Console, Effect, ServiceMap } from "effect"
+   * import { Console, Effect, Context } from "effect"
    *
    * // Define a counter service
-   * const Counter = ServiceMap.Service<{ count: number }>("Counter")
+   * const Counter = Context.Service<{ count: number }>("Counter")
    *
    * const program = Effect.gen(function*() {
    *   const updatedCounter = yield* Effect.service(Counter)
@@ -11258,9 +11257,9 @@ export const updateService: {
    * ```
    *
    * @since 2.0.0
-   * @category ServiceMap
+   * @category Context
    */
-  <XA, E, R, I, A>(self: Effect<XA, E, R>, service: ServiceMap.Key<I, A>, f: (value: A) => A): Effect<XA, E, R | I>
+  <XA, E, R, I, A>(self: Effect<XA, E, R>, service: Context.Key<I, A>, f: (value: A) => A): Effect<XA, E, R | I>
 } = internal.updateService
 
 /**
@@ -11277,10 +11276,10 @@ export const updateService: {
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap } from "effect"
+ * import { Console, Effect, Context } from "effect"
  *
  * // Define a service for configuration
- * const Config = ServiceMap.Service<{
+ * const Config = Context.Service<{
  *   apiUrl: string
  *   timeout: number
  * }>("Config")
@@ -11306,7 +11305,7 @@ export const updateService: {
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
 export const provideService: {
   /**
@@ -11323,10 +11322,10 @@ export const provideService: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, ServiceMap } from "effect"
+   * import { Console, Effect, Context } from "effect"
    *
    * // Define a service for configuration
-   * const Config = ServiceMap.Service<{
+   * const Config = Context.Service<{
    *   apiUrl: string
    *   timeout: number
    * }>("Config")
@@ -11352,9 +11351,9 @@ export const provideService: {
    * ```
    *
    * @since 2.0.0
-   * @category ServiceMap
+   * @category Context
    */
-  <I, S>(service: ServiceMap.Key<I, S>): {
+  <I, S>(service: Context.Key<I, S>): {
     /**
      * The `provideService` function is used to provide an actual
      * implementation for a service in the context of an effect.
@@ -11369,10 +11368,10 @@ export const provideService: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap } from "effect"
+     * import { Console, Effect, Context } from "effect"
      *
      * // Define a service for configuration
-     * const Config = ServiceMap.Service<{
+     * const Config = Context.Service<{
      *   apiUrl: string
      *   timeout: number
      * }>("Config")
@@ -11398,7 +11397,7 @@ export const provideService: {
      * ```
      *
      * @since 2.0.0
-     * @category ServiceMap
+     * @category Context
      */
     (implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>
     /**
@@ -11415,10 +11414,10 @@ export const provideService: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap } from "effect"
+     * import { Console, Effect, Context } from "effect"
      *
      * // Define a service for configuration
-     * const Config = ServiceMap.Service<{
+     * const Config = Context.Service<{
      *   apiUrl: string
      *   timeout: number
      * }>("Config")
@@ -11444,7 +11443,7 @@ export const provideService: {
      * ```
      *
      * @since 2.0.0
-     * @category ServiceMap
+     * @category Context
      */
     <A, E, R>(self: Effect<A, E, R>, implementation: S): Effect<A, E, Exclude<R, I>>
   }
@@ -11462,10 +11461,10 @@ export const provideService: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, ServiceMap } from "effect"
+   * import { Console, Effect, Context } from "effect"
    *
    * // Define a service for configuration
-   * const Config = ServiceMap.Service<{
+   * const Config = Context.Service<{
    *   apiUrl: string
    *   timeout: number
    * }>("Config")
@@ -11491,9 +11490,9 @@ export const provideService: {
    * ```
    *
    * @since 2.0.0
-   * @category ServiceMap
+   * @category Context
    */
-  <I, S>(service: ServiceMap.Key<I, S>, implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>
+  <I, S>(service: Context.Key<I, S>, implementation: S): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, Exclude<R, I>>
   /**
    * The `provideService` function is used to provide an actual
    * implementation for a service in the context of an effect.
@@ -11508,10 +11507,10 @@ export const provideService: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, ServiceMap } from "effect"
+   * import { Console, Effect, Context } from "effect"
    *
    * // Define a service for configuration
-   * const Config = ServiceMap.Service<{
+   * const Config = Context.Service<{
    *   apiUrl: string
    *   timeout: number
    * }>("Config")
@@ -11537,9 +11536,9 @@ export const provideService: {
    * ```
    *
    * @since 2.0.0
-   * @category ServiceMap
+   * @category Context
    */
-  <A, E, R, I, S>(self: Effect<A, E, R>, service: ServiceMap.Key<I, S>, implementation: S): Effect<A, E, Exclude<R, I>>
+  <A, E, R, I, S>(self: Effect<A, E, R>, service: Context.Key<I, S>, implementation: S): Effect<A, E, Exclude<R, I>>
 } = internal.provideService
 
 /**
@@ -11554,13 +11553,13 @@ export const provideService: {
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap } from "effect"
+ * import { Console, Effect, Context } from "effect"
  *
  * // Define a database connection service
  * interface DatabaseConnection {
  *   readonly query: (sql: string) => Effect.Effect<string>
  * }
- * const Database = ServiceMap.Service<DatabaseConnection>("Database")
+ * const Database = Context.Service<DatabaseConnection>("Database")
  *
  * // Effect that creates a database connection
  * const createConnection = Effect.gen(function*() {
@@ -11592,7 +11591,7 @@ export const provideService: {
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
 export const provideServiceEffect: {
   /**
@@ -11607,13 +11606,13 @@ export const provideServiceEffect: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, ServiceMap } from "effect"
+   * import { Console, Effect, Context } from "effect"
    *
    * // Define a database connection service
    * interface DatabaseConnection {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }
-   * const Database = ServiceMap.Service<DatabaseConnection>("Database")
+   * const Database = Context.Service<DatabaseConnection>("Database")
    *
    * // Effect that creates a database connection
    * const createConnection = Effect.gen(function*() {
@@ -11645,9 +11644,9 @@ export const provideServiceEffect: {
    * ```
    *
    * @since 2.0.0
-   * @category ServiceMap
+   * @category Context
    */
-  <I, S, E2, R2>(service: ServiceMap.Key<I, S>, acquire: Effect<S, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, Exclude<R, I> | R2>
+  <I, S, E2, R2>(service: Context.Key<I, S>, acquire: Effect<S, E2, R2>): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E | E2, Exclude<R, I> | R2>
   /**
    * Provides the effect with the single service it requires. If the effect
    * requires more than one service use `provide` instead.
@@ -11660,13 +11659,13 @@ export const provideServiceEffect: {
    *
    * @example
    * ```ts
-   * import { Console, Effect, ServiceMap } from "effect"
+   * import { Console, Effect, Context } from "effect"
    *
    * // Define a database connection service
    * interface DatabaseConnection {
    *   readonly query: (sql: string) => Effect.Effect<string>
    * }
-   * const Database = ServiceMap.Service<DatabaseConnection>("Database")
+   * const Database = Context.Service<DatabaseConnection>("Database")
    *
    * // Effect that creates a database connection
    * const createConnection = Effect.gen(function*() {
@@ -11698,11 +11697,11 @@ export const provideServiceEffect: {
    * ```
    *
    * @since 2.0.0
-   * @category ServiceMap
+   * @category Context
    */
   <A, E, R, I, S, E2, R2>(
     self: Effect<A, E, R>,
-    service: ServiceMap.Key<I, S>,
+    service: Context.Key<I, S>,
     acquire: Effect<S, E2, R2>
   ): Effect<A, E | E2, Exclude<R, I> | R2>
 } = internal.provideServiceEffect
@@ -13372,8 +13371,7 @@ export declare namespace Repeat {
    * ```
    */
   export type Return<R, E, A, O extends Options<A>> = Effect<
-    O extends { schedule: Schedule<infer Out, infer _I, infer _E, infer _R> } ? Out
-      : O extends { until: Predicate.Refinement<A, infer B> } ? B
+    O extends { until: Predicate.Refinement<A, infer B> } ? B
       : O extends { while: Predicate.Refinement<A, infer B> } ? Exclude<A, B>
       : A,
     | E
@@ -15602,7 +15600,7 @@ export const request: {
 
 /**
  * Low-level entry point that registers a request with a resolver and delivers the exit value via `onExit`.
- * Use this when you already have a `ServiceMap` and need to enqueue a request outside an `Effect`.
+ * Use this when you already have a `Context` and need to enqueue a request outside an `Effect`.
  *
  * It returns a canceler that removes the pending request entry.
  *
@@ -15614,7 +15612,7 @@ export const requestUnsafe: <A extends Request.Any>(
   options: {
     readonly resolver: RequestResolver<A>
     readonly onExit: (exit: Exit.Exit<Request.Success<A>, Request.Error<A>>) => void
-    readonly services: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
   }
 ) => () => void = internalRequest.requestUnsafe
 
@@ -16017,15 +16015,15 @@ export const runFork: <A, E>(effect: Effect<A, E, never>, options?: RunOptions |
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * interface Logger {
  *   log: (message: string) => void
  * }
  *
- * const Logger = ServiceMap.Service<Logger>("Logger")
+ * const Logger = Context.Service<Logger>("Logger")
  *
- * const services = ServiceMap.make(Logger, {
+ * const services = Context.make(Logger, {
  *   log: (message) => console.log(message)
  * })
  *
@@ -16042,7 +16040,7 @@ export const runFork: <A, E>(effect: Effect<A, E, never>, options?: RunOptions |
  * @category Running Effects
  */
 export const runForkWith: <R>(
-  services: ServiceMap.ServiceMap<R>
+  context: Context.Context<R>
 ) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Fiber<A, E> = internal.runForkWith
 
 /**
@@ -16052,15 +16050,15 @@ export const runForkWith: <R>(
  *
  * @example
  * ```ts
- * import { Console, Effect, Exit, ServiceMap } from "effect"
+ * import { Console, Effect, Exit, Context } from "effect"
  *
  * interface Logger {
  *   log: (message: string) => Effect.Effect<void>
  * }
  *
- * const Logger = ServiceMap.Service<Logger>("Logger")
+ * const Logger = Context.Service<Logger>("Logger")
  *
- * const services = ServiceMap.make(Logger, {
+ * const services = Context.make(Logger, {
  *   log: (message) => Console.log(message)
  * })
  *
@@ -16086,7 +16084,7 @@ export const runForkWith: <R>(
  * @category Running Effects
  */
 export const runCallbackWith: <R>(
-  services: ServiceMap.ServiceMap<R>
+  context: Context.Context<R>
 ) => <A, E>(
   effect: Effect<A, E, R>,
   options?: (RunOptions & { readonly onExit: (exit: Exit.Exit<A, E>) => void }) | undefined
@@ -16178,15 +16176,15 @@ export const runPromise: <A, E>(
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * interface Config {
  *   apiUrl: string
  * }
  *
- * const Config = ServiceMap.Service<Config>("Config")
+ * const Config = Context.Service<Config>("Config")
  *
- * const services = ServiceMap.make(Config, {
+ * const context = Context.make(Config, {
  *   apiUrl: "https://api.example.com"
  * })
  *
@@ -16195,14 +16193,14 @@ export const runPromise: <A, E>(
  *   return `Connecting to ${config.apiUrl}`
  * })
  *
- * Effect.runPromiseWith(services)(program).then(console.log)
+ * Effect.runPromiseWith(context)(program).then(console.log)
  * ```
  *
  * @since 4.0.0
  * @category Running Effects
  */
 export const runPromiseWith: <R>(
-  services: ServiceMap.ServiceMap<R>
+  context: Context.Context<R>
 ) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Promise<A> = internal.runPromiseWith
 
 /**
@@ -16262,15 +16260,15 @@ export const runPromiseExit: <A, E>(
  *
  * @example
  * ```ts
- * import { Effect, Exit, ServiceMap } from "effect"
+ * import { Effect, Exit, Context } from "effect"
  *
  * interface Database {
  *   query: (sql: string) => string
  * }
  *
- * const Database = ServiceMap.Service<Database>("Database")
+ * const Database = Context.Service<Database>("Database")
  *
- * const services = ServiceMap.make(Database, {
+ * const services = Context.make(Database, {
  *   query: (sql) => `Result for: ${sql}`
  * })
  *
@@ -16290,7 +16288,7 @@ export const runPromiseExit: <A, E>(
  * @category Running Effects
  */
 export const runPromiseExitWith: <R>(
-  services: ServiceMap.ServiceMap<R>
+  context: Context.Context<R>
 ) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Promise<Exit.Exit<A, E>> =
   internal.runPromiseExitWith
 
@@ -16358,15 +16356,15 @@ export const runSync: <A, E>(effect: Effect<A, E>) => A = internal.runSync
  *
  * @example
  * ```ts
- * import { Effect, ServiceMap } from "effect"
+ * import { Effect, Context } from "effect"
  *
  * interface MathService {
  *   add: (a: number, b: number) => number
  * }
  *
- * const MathService = ServiceMap.Service<MathService>("MathService")
+ * const MathService = Context.Service<MathService>("MathService")
  *
- * const services = ServiceMap.make(MathService, {
+ * const context = Context.make(MathService, {
  *   add: (a, b) => a + b
  * })
  *
@@ -16375,7 +16373,7 @@ export const runSync: <A, E>(effect: Effect<A, E>) => A = internal.runSync
  *   return math.add(2, 3)
  * })
  *
- * const result = Effect.runSyncWith(services)(program)
+ * const result = Effect.runSyncWith(context)(program)
  * console.log(result) // 5
  * ```
  *
@@ -16383,7 +16381,7 @@ export const runSync: <A, E>(effect: Effect<A, E>) => A = internal.runSync
  * @category Running Effects
  */
 export const runSyncWith: <R>(
-  services: ServiceMap.ServiceMap<R>
+  context: Context.Context<R>
 ) => <A, E>(effect: Effect<A, E, R>) => A = internal.runSyncWith
 
 /**
@@ -16462,10 +16460,10 @@ export const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E> = inte
  *
  * @example
  * ```ts
- * import { Effect, Exit, ServiceMap } from "effect"
+ * import { Effect, Exit, Context } from "effect"
  *
  * // Define a logger service
- * const Logger = ServiceMap.Service<{
+ * const Logger = Context.Service<{
  *   log: (msg: string) => void
  * }>("Logger")
  *
@@ -16475,12 +16473,12 @@ export const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E> = inte
  *   return 42
  * })
  *
- * // Prepare services
- * const services = ServiceMap.make(Logger, {
+ * // Prepare context
+ * const context = Context.make(Logger, {
  *   log: (msg) => console.log(`[LOG] ${msg}`)
  * })
  *
- * const exit = Effect.runSyncExitWith(services)(program)
+ * const exit = Effect.runSyncExitWith(context)(program)
  *
  * if (Exit.isSuccess(exit)) {
  *   console.log(`Success: ${exit.value}`)
@@ -16496,7 +16494,7 @@ export const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E> = inte
  * @category Running Effects
  */
 export const runSyncExitWith: <R>(
-  services: ServiceMap.ServiceMap<R>
+  context: Context.Context<R>
 ) => <A, E>(effect: Effect<A, E, R>) => Exit.Exit<A, E> = internal.runSyncExitWith
 
 // -----------------------------------------------------------------------------
@@ -22590,7 +22588,7 @@ export const trackDuration: {
  * @since 4.0.0
  * @category Transactions
  */
-export class Transaction extends ServiceMap.Service<
+export class Transaction extends Context.Service<
   Transaction,
   {
     retry: boolean
@@ -22650,7 +22648,7 @@ export const tx = <A, E, R>(
   effect: Effect<A, E, R>
 ): Effect<A, E, Exclude<R, Transaction>> =>
   withFiber((fiber) => {
-    if (fiber.services.mapUnsafe.has(Transaction.key)) {
+    if (fiber.context.mapUnsafe.has(Transaction.key)) {
       return effect as Effect<A, E, Exclude<R, Transaction>>
     }
     // Create transaction state only at the outermost boundary