effect 4.0.0-beta.43 → 4.0.0-beta.45

package/dist/Effect.d.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";
@@ -91,7 +92,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, Span, SpanLink, SpanOptions, SpanOptionsNoTrace, TraceOptions, Tracer } from "./Tracer.ts";
 import type { TxRef } from "./TxRef.ts";
 import type { Concurrency, Covariant, EqualsWith, ExcludeReason, ExcludeTag, ExtractReason, ExtractTag, NarrowReason, NoInfer, OmitReason, ReasonOf, ReasonTags, Simplify, Tags, unassigned } from "./Types.ts";
@@ -6194,6 +6194,8 @@ export declare namespace Retry {
      */
     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 {
@@ -6894,9 +6896,9 @@ export declare const ignoreCause: <Arg extends Effect<any, any, any> | {
  *
  * @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)
@@ -6928,9 +6930,9 @@ export declare 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)
@@ -6967,9 +6969,9 @@ export declare 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)
@@ -9682,7 +9684,7 @@ export declare const isFailure: <A, E, R>(self: Effect<A, E, R>) => Effect<boole
  */
 export declare const isSuccess: <A, E, R>(self: Effect<A, E, R>) => Effect<boolean, never, R>;
 /**
- * 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,
@@ -9690,56 +9692,56 @@ export declare const isSuccess: <A, E, R>(self: Effect<A, E, R>) => Effect<boole
  *
  * @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 declare const services: <R = never>() => Effect<ServiceMap.ServiceMap<R>, never, R>;
+export declare const context: <R = never>() => Effect<Context.Context<R>, never, R>;
 /**
- * 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) {
@@ -9764,7 +9766,7 @@ export declare const services: <R = never>() => Effect<ServiceMap.ServiceMap<R>,
  * @since 2.0.0
  * @category Environment
  */
-export declare const servicesWith: <R, A, E, R2>(f: (services: ServiceMap.ServiceMap<R>) => Effect<A, E, R2>) => Effect<A, E, R | R2>;
+export declare const contextWith: <R, A, E, R2>(f: (context: Context.Context<R>) => Effect<A, E, R2>) => Effect<A, E, 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
@@ -9772,13 +9774,13 @@ export declare const servicesWith: <R, A, E, R2>(f: (services: ServiceMap.Servic
  *
  * @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}`))
@@ -9806,13 +9808,13 @@ export declare 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}`))
@@ -9842,13 +9844,13 @@ export declare 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}`))
@@ -9878,13 +9880,13 @@ export declare 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}`))
@@ -9904,7 +9906,7 @@ export declare 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
@@ -9912,13 +9914,13 @@ export declare 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}`))
@@ -9948,13 +9950,13 @@ export declare 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}`))
@@ -9984,13 +9986,13 @@ export declare 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}`))
@@ -10010,32 +10012,32 @@ export declare 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>>;
 };
 /**
- * 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*() {
@@ -10045,37 +10047,37 @@ export declare 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 declare const provideServices: {
+export declare 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*() {
@@ -10085,37 +10087,37 @@ export declare 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*() {
@@ -10125,26 +10127,26 @@ export declare 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>>;
+    <A, E, R, XR>(self: Effect<A, E, R>, context: Context.Context<XR>): Effect<A, E, Exclude<R, XR>>;
 };
 /**
  * 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)
@@ -10153,9 +10155,9 @@ export declare const provideServices: {
  * ```
  *
  * @since 4.0.0
- * @category ServiceMap
+ * @category Context
  */
-export declare const service: <I, S>(service: ServiceMap.Key<I, S>) => Effect<S, never, I>;
+export declare const service: <I, S>(service: Context.Key<I, S>) => Effect<S, never, I>;
 /**
  * Optionally accesses a service from the environment.
  *
@@ -10168,10 +10170,10 @@ export declare const service: <I, S>(service: ServiceMap.Key<I, S>) => Effect<S,
  *
  * @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")
  *
@@ -10188,9 +10190,9 @@ export declare const service: <I, S>(service: ServiceMap.Key<I, S>) => Effect<S,
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
-export declare const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<Option<S>>;
+export declare const serviceOption: <I, S>(key: Context.Key<I, S>) => Effect<Option<S>>;
 /**
  * Provides part of the required context while leaving the rest unchanged.
  *
@@ -10201,13 +10203,13 @@ export declare const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<
  *
  * @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")
  *
@@ -10217,8 +10219,8 @@ export declare const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<
  *
  * // 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" })
  *   )
  * )
  *
@@ -10229,9 +10231,9 @@ export declare const serviceOption: <I, S>(key: ServiceMap.Key<I, S>) => Effect<
  * ```
  *
  * @since 4.0.0
- * @category ServiceMap
+ * @category Context
  */
-export declare const updateServices: {
+export declare const updateContext: {
     /**
      * Provides part of the required context while leaving the rest unchanged.
      *
@@ -10242,13 +10244,13 @@ export declare 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")
      *
@@ -10258,8 +10260,8 @@ export declare 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" })
      *   )
      * )
      *
@@ -10270,9 +10272,9 @@ export declare 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.
      *
@@ -10283,13 +10285,13 @@ export declare 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")
      *
@@ -10299,8 +10301,8 @@ export declare 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" })
      *   )
      * )
      *
@@ -10311,19 +10313,19 @@ export declare 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>>): Effect<A, E, R2>;
+    <A, E, R, R2>(self: Effect<A, E, R>, f: (context: Context.Context<R2>) => Context.Context<NoInfer<R>>): Effect<A, E, R2>;
 };
 /**
  * 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)
@@ -10341,7 +10343,7 @@ export declare const updateServices: {
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
 export declare const updateService: {
     /**
@@ -10349,10 +10351,10 @@ export declare 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)
@@ -10370,18 +10372,18 @@ export declare 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)
@@ -10399,9 +10401,9 @@ export declare 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>;
 };
 /**
  * The `provideService` function is used to provide an actual
@@ -10417,10 +10419,10 @@ export declare 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")
@@ -10446,7 +10448,7 @@ export declare const updateService: {
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
 export declare const provideService: {
     /**
@@ -10463,10 +10465,10 @@ export declare 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")
@@ -10492,9 +10494,9 @@ export declare 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.
@@ -10509,10 +10511,10 @@ export declare 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")
@@ -10538,7 +10540,7 @@ export declare 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>>;
         /**
@@ -10555,10 +10557,10 @@ export declare 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")
@@ -10584,7 +10586,7 @@ export declare 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>>;
     };
@@ -10602,10 +10604,10 @@ export declare 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")
@@ -10631,9 +10633,9 @@ export declare 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.
@@ -10648,10 +10650,10 @@ export declare 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")
@@ -10677,9 +10679,9 @@ export declare 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>>;
 };
 /**
  * Provides the effect with the single service it requires. If the effect
@@ -10693,13 +10695,13 @@ export declare 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*() {
@@ -10731,7 +10733,7 @@ export declare const provideService: {
  * ```
  *
  * @since 2.0.0
- * @category ServiceMap
+ * @category Context
  */
 export declare const provideServiceEffect: {
     /**
@@ -10746,13 +10748,13 @@ export declare 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*() {
@@ -10784,9 +10786,9 @@ export declare 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.
@@ -10799,13 +10801,13 @@ export declare 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*() {
@@ -10837,9 +10839,9 @@ export declare 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>, acquire: Effect<S, E2, R2>): Effect<A, E | E2, Exclude<R, I> | R2>;
+    <A, E, R, I, S, E2, R2>(self: Effect<A, E, R>, service: Context.Key<I, S>, acquire: Effect<S, E2, R2>): Effect<A, E | E2, Exclude<R, I> | R2>;
 };
 /**
  * Sets the concurrency level for parallel operations within an effect.
@@ -12392,8 +12394,6 @@ export declare namespace Repeat {
      * ```
      */
     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 {
         while: Predicate.Refinement<A, infer B>;
@@ -14516,7 +14516,7 @@ export declare 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.
  *
@@ -14526,7 +14526,7 @@ export declare const request: {
 export declare const requestUnsafe: <A extends Request.Any>(self: A, 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;
 /**
  * Returns an effect that forks this effect into its own separate fiber,
@@ -14884,15 +14884,15 @@ export declare const runFork: <A, E>(effect: Effect<A, E, never>, options?: RunO
  *
  * @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)
  * })
  *
@@ -14908,7 +14908,7 @@ export declare const runFork: <A, E>(effect: Effect<A, E, never>, options?: RunO
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runForkWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Fiber<A, E>;
+export declare const runForkWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Fiber<A, E>;
 /**
  * Forks an effect with the provided services, registers `onExit` as a fiber observer, and returns an interruptor.
  *
@@ -14916,15 +14916,15 @@ export declare const runForkWith: <R>(services: ServiceMap.ServiceMap<R>) => <A,
  *
  * @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)
  * })
  *
@@ -14949,7 +14949,7 @@ export declare const runForkWith: <R>(services: ServiceMap.ServiceMap<R>) => <A,
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runCallbackWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>, options?: (RunOptions & {
+export declare const runCallbackWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>, options?: (RunOptions & {
     readonly onExit: (exit: Exit.Exit<A, E>) => void;
 }) | undefined) => (interruptor?: number | undefined) => void;
 /**
@@ -15032,15 +15032,15 @@ export declare const runPromise: <A, E>(effect: Effect<A, E>, options?: RunOptio
  *
  * @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"
  * })
  *
@@ -15049,13 +15049,13 @@ export declare const runPromise: <A, E>(effect: Effect<A, E>, options?: RunOptio
  *   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 declare const runPromiseWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Promise<A>;
+export declare const runPromiseWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Promise<A>;
 /**
  * Runs an effect and returns a `Promise` that resolves to an `Exit`, which
  * represents the outcome (success or failure) of the effect.
@@ -15109,15 +15109,15 @@ export declare const runPromiseExit: <A, E>(effect: Effect<A, E>, options?: RunO
  *
  * @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}`
  * })
  *
@@ -15136,7 +15136,7 @@ export declare const runPromiseExit: <A, E>(effect: Effect<A, E>, options?: RunO
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runPromiseExitWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Promise<Exit.Exit<A, E>>;
+export declare const runPromiseExitWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>, options?: RunOptions | undefined) => Promise<Exit.Exit<A, E>>;
 /**
  * Executes an effect synchronously, running it immediately and returning the
  * result.
@@ -15200,15 +15200,15 @@ export declare const runSync: <A, E>(effect: Effect<A, E>) => A;
  *
  * @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
  * })
  *
@@ -15217,14 +15217,14 @@ export declare const runSync: <A, E>(effect: Effect<A, E>) => A;
  *   return math.add(2, 3)
  * })
  *
- * const result = Effect.runSyncWith(services)(program)
+ * const result = Effect.runSyncWith(context)(program)
  * console.log(result) // 5
  * ```
  *
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runSyncWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>) => A;
+export declare const runSyncWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>) => A;
 /**
  * Runs an effect synchronously and returns the result as an `Exit` type, which
  * represents the outcome (success or failure) of the effect.
@@ -15300,10 +15300,10 @@ export declare const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E
  *
  * @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")
  *
@@ -15313,12 +15313,12 @@ export declare const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E
  *   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}`)
@@ -15333,7 +15333,7 @@ export declare const runSyncExit: <A, E>(effect: Effect<A, E>) => Exit.Exit<A, E
  * @since 4.0.0
  * @category Running Effects
  */
-export declare const runSyncExitWith: <R>(services: ServiceMap.ServiceMap<R>) => <A, E>(effect: Effect<A, E, R>) => Exit.Exit<A, E>;
+export declare const runSyncExitWith: <R>(context: Context.Context<R>) => <A, E>(effect: Effect<A, E, R>) => Exit.Exit<A, E>;
 /**
  * Type helpers for functions built with `Effect.fn` and `Effect.fnUntraced`.
  *
@@ -17590,7 +17590,7 @@ export declare const trackDuration: {
      */
     <A, E, R, State>(self: Effect<A, E, R>, metric: Metric.Metric<Duration.Duration, State>): Effect<A, E, R>;
 };
-declare const Transaction_base: ServiceMap.ServiceClass<Transaction, "effect/Effect/Transaction", {
+declare const Transaction_base: Context.ServiceClass<Transaction, "effect/Effect/Transaction", {
     retry: boolean;
     readonly journal: Map<TxRef<any>, {
         readonly version: number;