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

package/dist/Stream.d.ts

@@ -4,6 +4,7 @@
 import * as Arr from "./Array.ts";
 import * as Cause from "./Cause.ts";
 import * as Channel from "./Channel.ts";
+import * as Context from "./Context.ts";
 import * as Duration from "./Duration.ts";
 import * as Effect from "./Effect.ts";
 import * as ExecutionPlan from "./ExecutionPlan.ts";
@@ -22,7 +23,6 @@ import * as Queue from "./Queue.ts";
 import * as Result from "./Result.ts";
 import * as Schedule from "./Schedule.ts";
 import * as Scope from "./Scope.ts";
-import * as ServiceMap from "./ServiceMap.ts";
 import * as Sink from "./Sink.ts";
 import type * as Take from "./Take.ts";
 import type { ParentSpan, SpanOptions } from "./Tracer.ts";
@@ -307,6 +307,76 @@ export declare const fromChannel: <Arr extends Arr.NonEmptyReadonlyArray<any>, E
  * @category Constructors
  */
 export declare const fromEffect: <A, E, R>(effect: Effect.Effect<A, E, R>) => Stream<A, E, R>;
+/**
+ * Accesses a service from the context and emits it as a single element.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Context, Stream } from "effect"
+ *
+ * class Greeter extends Context.Service<Greeter, {
+ *   readonly greet: (name: string) => string
+ * }>()("Greeter") {}
+ *
+ * const stream = Stream.service(Greeter).pipe(
+ *   Stream.map((greeter) => greeter.greet("World"))
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ *   return yield* stream.pipe(
+ *     Stream.provideService(Greeter, {
+ *       greet: (name) => `Hello, ${name}!`
+ *     }),
+ *     Stream.runCollect
+ *   )
+ * })
+ *
+ * Effect.runPromise(program)
+ * // Output: [ "Hello, World!" ]
+ * ```
+ *
+ * @since 4.0.0
+ * @category Context
+ */
+export declare const service: <I, S>(service: Context.Key<I, S>) => Stream<S, never, I>;
+/**
+ * Optionally accesses a service from the context and emits the result as a
+ * single element.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option, Context, Stream } from "effect"
+ *
+ * class Greeter extends Context.Service<Greeter, {
+ *   readonly greet: (name: string) => string
+ * }>()("Greeter") {}
+ *
+ * const stream = Stream.serviceOption(Greeter).pipe(
+ *   Stream.map((maybeGreeter) =>
+ *     Option.match(maybeGreeter, {
+ *       onNone: () => "No greeter",
+ *       onSome: (greeter) => greeter.greet("World")
+ *     })
+ *   )
+ * )
+ *
+ * const program = Effect.gen(function*() {
+ *   return yield* stream.pipe(
+ *     Stream.provideService(Greeter, {
+ *       greet: (name) => `Hello, ${name}!`
+ *     }),
+ *     Stream.runCollect
+ *   )
+ * })
+ *
+ * Effect.runPromise(program)
+ * // Output: [ "Hello, World!" ]
+ * ```
+ *
+ * @since 4.0.0
+ * @category Context
+ */
+export declare const serviceOption: <I, S>(service: Context.Key<I, S>) => Stream<Option.Option<S>>;
 /**
  * Creates a stream that runs the effect and emits no elements.
  *
@@ -863,9 +933,9 @@ export declare const fromIterable: <A>(iterable: Iterable<A>, options?: {
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class UserRepo extends ServiceMap.Service<UserRepo, {
+ * class UserRepo extends Context.Service<UserRepo, {
  *   readonly list: Effect.Effect<ReadonlyArray<string>>
  * }>()("UserRepo") {}
  *
@@ -7173,9 +7243,9 @@ export declare const retry: {
  *
  * @example
  * ```ts
- * import { Console, Effect, ExecutionPlan, Layer, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, ExecutionPlan, Layer, Context, Stream } from "effect"
  *
- * class Service extends ServiceMap.Service<Service>()("Service", {
+ * class Service extends Context.Service<Service>()("Service", {
  *   make: Effect.succeed({
  *     stream: Stream.fail("A") as Stream.Stream<number, string>
  *   })
@@ -7215,9 +7285,9 @@ export declare const withExecutionPlan: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ExecutionPlan, Layer, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, ExecutionPlan, Layer, Context, Stream } from "effect"
      *
-     * class Service extends ServiceMap.Service<Service>()("Service", {
+     * class Service extends Context.Service<Service>()("Service", {
      *   make: Effect.succeed({
      *     stream: Stream.fail("A") as Stream.Stream<number, string>
      *   })
@@ -7264,9 +7334,9 @@ export declare const withExecutionPlan: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ExecutionPlan, Layer, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, ExecutionPlan, Layer, Context, Stream } from "effect"
      *
-     * class Service extends ServiceMap.Service<Service>()("Service", {
+     * class Service extends Context.Service<Service>()("Service", {
      *   make: Effect.succeed({
      *     stream: Stream.fail("A") as Stream.Stream<number, string>
      *   })
@@ -12016,7 +12086,7 @@ export declare const ensuring: {
     <A, E, R, R2>(self: Stream<A, E, R>, finalizer: Effect.Effect<unknown, never, R2>): Stream<A, E, R | R2>;
 };
 /**
- * Provides a layer or service map to the stream, removing the corresponding
+ * Provides a layer or context to the stream, removing the corresponding
  * service requirements. Use `options.local` to build the layer every time; by
  * default, layers are shared between provide calls.
  *
@@ -12024,9 +12094,9 @@ export declare const ensuring: {
  *
  * @example
  * ```ts
- * import { Console, Effect, Layer, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Layer, Context, Stream } from "effect"
  *
- * class Env extends ServiceMap.Service<Env, { readonly name: string }>()("Env") {}
+ * class Env extends Context.Service<Env, { readonly name: string }>()("Env") {}
  *
  * const layer = Layer.succeed(Env)({ name: "Ada" })
  *
@@ -12053,7 +12123,7 @@ export declare const ensuring: {
  */
 export declare const provide: {
     /**
-     * Provides a layer or service map to the stream, removing the corresponding
+     * Provides a layer or context to the stream, removing the corresponding
      * service requirements. Use `options.local` to build the layer every time; by
      * default, layers are shared between provide calls.
      *
@@ -12061,9 +12131,9 @@ export declare const provide: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Layer, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Layer, Context, Stream } from "effect"
      *
-     * class Env extends ServiceMap.Service<Env, { readonly name: string }>()("Env") {}
+     * class Env extends Context.Service<Env, { readonly name: string }>()("Env") {}
      *
      * const layer = Layer.succeed(Env)({ name: "Ada" })
      *
@@ -12088,11 +12158,11 @@ export declare const provide: {
      * @since 4.0.0
      * @category Services
      */
-    <AL, EL = never, RL = never>(layer: Layer.Layer<AL, EL, RL> | ServiceMap.ServiceMap<AL>, options?: {
+    <AL, EL = never, RL = never>(layer: Layer.Layer<AL, EL, RL> | Context.Context<AL>, options?: {
         readonly local?: boolean | undefined;
     } | undefined): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E | EL, Exclude<R, AL> | RL>;
     /**
-     * Provides a layer or service map to the stream, removing the corresponding
+     * Provides a layer or context to the stream, removing the corresponding
      * service requirements. Use `options.local` to build the layer every time; by
      * default, layers are shared between provide calls.
      *
@@ -12100,9 +12170,9 @@ export declare const provide: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, Layer, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Layer, Context, Stream } from "effect"
      *
-     * class Env extends ServiceMap.Service<Env, { readonly name: string }>()("Env") {}
+     * class Env extends Context.Service<Env, { readonly name: string }>()("Env") {}
      *
      * const layer = Layer.succeed(Env)({ name: "Ada" })
      *
@@ -12127,22 +12197,22 @@ export declare const provide: {
      * @since 4.0.0
      * @category Services
      */
-    <A, E, R, AL, EL = never, RL = never>(self: Stream<A, E, R>, layer: Layer.Layer<AL, EL, RL> | ServiceMap.ServiceMap<AL>, options?: {
+    <A, E, R, AL, EL = never, RL = never>(self: Stream<A, E, R>, layer: Layer.Layer<AL, EL, RL> | Context.Context<AL>, options?: {
         readonly local?: boolean | undefined;
     } | undefined): Stream<A, E | EL, Exclude<R, AL> | RL>;
 };
 /**
- * Provides multiple services to the stream using a service map.
+ * Provides multiple services to the stream using a context.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Config extends ServiceMap.Service<Config, { readonly prefix: string }>()("Config") {}
- * class Greeter extends ServiceMap.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
+ * class Config extends Context.Service<Config, { readonly prefix: string }>()("Config") {}
+ * class Greeter extends Context.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
  *
- * const services = ServiceMap.make(Config, { prefix: "Hello" }).pipe(
- *   ServiceMap.add(Greeter, { greet: (name: string) => `${name}!` })
+ * const context = Context.make(Config, { prefix: "Hello" }).pipe(
+ *   Context.add(Greeter, { greet: (name: string) => `${name}!` })
  * )
  *
  * const stream = Stream.fromEffect(
@@ -12154,7 +12224,7 @@ export declare const provide: {
  * )
  *
  * const program = Effect.gen(function*() {
- *   const result = yield* Stream.runCollect(Stream.provideServices(stream, services))
+ *   const result = yield* Stream.runCollect(Stream.provideContext(stream, context))
  *   yield* Console.log(result)
  * })
  *
@@ -12165,19 +12235,19 @@ export declare const provide: {
  * @since 4.0.0
  * @category Services
  */
-export declare const provideServices: {
+export declare const provideContext: {
     /**
-     * Provides multiple services to the stream using a service map.
+     * Provides multiple services to the stream using a context.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Config extends ServiceMap.Service<Config, { readonly prefix: string }>()("Config") {}
-     * class Greeter extends ServiceMap.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
+     * class Config extends Context.Service<Config, { readonly prefix: string }>()("Config") {}
+     * class Greeter extends Context.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
      *
-     * const services = ServiceMap.make(Config, { prefix: "Hello" }).pipe(
-     *   ServiceMap.add(Greeter, { greet: (name: string) => `${name}!` })
+     * const context = Context.make(Config, { prefix: "Hello" }).pipe(
+     *   Context.add(Greeter, { greet: (name: string) => `${name}!` })
      * )
      *
      * const stream = Stream.fromEffect(
@@ -12189,7 +12259,7 @@ export declare const provideServices: {
      * )
      *
      * const program = Effect.gen(function*() {
-     *   const result = yield* Stream.runCollect(Stream.provideServices(stream, services))
+     *   const result = yield* Stream.runCollect(Stream.provideContext(stream, context))
      *   yield* Console.log(result)
      * })
      *
@@ -12200,19 +12270,19 @@ export declare const provideServices: {
      * @since 4.0.0
      * @category Services
      */
-    <R2>(services: ServiceMap.ServiceMap<R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, R2>>;
+    <R2>(context: Context.Context<R2>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, R2>>;
     /**
-     * Provides multiple services to the stream using a service map.
+     * Provides multiple services to the stream using a context.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Config extends ServiceMap.Service<Config, { readonly prefix: string }>()("Config") {}
-     * class Greeter extends ServiceMap.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
+     * class Config extends Context.Service<Config, { readonly prefix: string }>()("Config") {}
+     * class Greeter extends Context.Service<Greeter, { greet: (name: string) => string }>()("Greeter") {}
      *
-     * const services = ServiceMap.make(Config, { prefix: "Hello" }).pipe(
-     *   ServiceMap.add(Greeter, { greet: (name: string) => `${name}!` })
+     * const context = Context.make(Config, { prefix: "Hello" }).pipe(
+     *   Context.add(Greeter, { greet: (name: string) => `${name}!` })
      * )
      *
      * const stream = Stream.fromEffect(
@@ -12224,7 +12294,7 @@ export declare const provideServices: {
      * )
      *
      * const program = Effect.gen(function*() {
-     *   const result = yield* Stream.runCollect(Stream.provideServices(stream, services))
+     *   const result = yield* Stream.runCollect(Stream.provideContext(stream, context))
      *   yield* Console.log(result)
      * })
      *
@@ -12235,7 +12305,7 @@ export declare const provideServices: {
      * @since 4.0.0
      * @category Services
      */
-    <A, E, R, R2>(self: Stream<A, E, R>, services: ServiceMap.ServiceMap<R2>): Stream<A, E, Exclude<R, R2>>;
+    <A, E, R, R2>(self: Stream<A, E, R>, context: Context.Context<R2>): Stream<A, E, Exclude<R, R2>>;
 };
 /**
  * Provides the stream with a single required service, eliminating that
@@ -12243,9 +12313,9 @@ export declare const provideServices: {
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Greeter extends ServiceMap.Service<Greeter, {
+ * class Greeter extends Context.Service<Greeter, {
  *   greet: (name: string) => string
  * }>()("Greeter") {}
  *
@@ -12280,9 +12350,9 @@ export declare const provideService: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Greeter extends ServiceMap.Service<Greeter, {
+     * class Greeter extends Context.Service<Greeter, {
      *   greet: (name: string) => string
      * }>()("Greeter") {}
      *
@@ -12310,16 +12380,16 @@ export declare const provideService: {
      * @since 4.0.0
      * @category Services
      */
-    <I, S>(key: ServiceMap.Key<I, S>, service: NoInfer<S>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, I>>;
+    <I, S>(key: Context.Key<I, S>, service: NoInfer<S>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, Exclude<R, I>>;
     /**
      * Provides the stream with a single required service, eliminating that
      * requirement from its environment.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Greeter extends ServiceMap.Service<Greeter, {
+     * class Greeter extends Context.Service<Greeter, {
      *   greet: (name: string) => string
      * }>()("Greeter") {}
      *
@@ -12347,16 +12417,16 @@ export declare const provideService: {
      * @since 4.0.0
      * @category Services
      */
-    <A, E, R, I, S>(self: Stream<A, E, R>, key: ServiceMap.Key<I, S>, service: NoInfer<S>): Stream<A, E, Exclude<R, I>>;
+    <A, E, R, I, S>(self: Stream<A, E, R>, key: Context.Key<I, S>, service: NoInfer<S>): Stream<A, E, Exclude<R, I>>;
 };
 /**
  * Provides a service to the stream using an effect, removing the requirement and adding the effect's error and environment.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class ApiConfig extends ServiceMap.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
+ * class ApiConfig extends Context.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
  *
  * const stream = Stream.fromEffect(
  *   Effect.gen(function*() {
@@ -12393,9 +12463,9 @@ export declare const provideServiceEffect: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class ApiConfig extends ServiceMap.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
+     * class ApiConfig extends Context.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
      *
      * const stream = Stream.fromEffect(
      *   Effect.gen(function*() {
@@ -12426,15 +12496,15 @@ export declare const provideServiceEffect: {
      * @since 4.0.0
      * @category Services
      */
-    <I, S, ES, RS>(key: ServiceMap.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E | ES, Exclude<R, I> | RS>;
+    <I, S, ES, RS>(key: Context.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E | ES, Exclude<R, I> | RS>;
     /**
      * Provides a service to the stream using an effect, removing the requirement and adding the effect's error and environment.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class ApiConfig extends ServiceMap.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
+     * class ApiConfig extends Context.Service<ApiConfig, { readonly baseUrl: string }>()("ApiConfig") {}
      *
      * const stream = Stream.fromEffect(
      *   Effect.gen(function*() {
@@ -12465,18 +12535,18 @@ export declare const provideServiceEffect: {
      * @since 4.0.0
      * @category Services
      */
-    <A, E, R, I, S, ES, RS>(self: Stream<A, E, R>, key: ServiceMap.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): Stream<A, E | ES, Exclude<R, I> | RS>;
+    <A, E, R, I, S, ES, RS>(self: Stream<A, E, R>, key: Context.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): Stream<A, E | ES, Exclude<R, I> | RS>;
 };
 /**
- * Transforms the stream's required services by mapping the current service map
+ * Transforms the stream's required services by mapping the current context
  * to a new one.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Logger extends ServiceMap.Service<Logger, { prefix: string }>()("Logger") {}
- * class Config extends ServiceMap.Service<Config, { name: string }>()("Config") {}
+ * class Logger extends Context.Service<Logger, { prefix: string }>()("Logger") {}
+ * class Config extends Context.Service<Config, { name: string }>()("Config") {}
  *
  * const stream = Stream.fromEffect(
  *   Effect.gen(function*() {
@@ -12487,8 +12557,8 @@ export declare const provideServiceEffect: {
  * )
  *
  * const updated = stream.pipe(
- *   Stream.updateServices((services: ServiceMap.ServiceMap<Logger>) =>
- *     ServiceMap.add(services, Config, { name: "World" })
+ *   Stream.updateContext((context: Context.Context<Logger>) =>
+ *     Context.add(context, Config, { name: "World" })
  *   )
  * )
  *
@@ -12506,17 +12576,17 @@ export declare const provideServiceEffect: {
  * @since 2.0.0
  * @category Services
  */
-export declare const updateServices: {
+export declare const updateContext: {
     /**
-     * Transforms the stream's required services by mapping the current service map
+     * Transforms the stream's required services by mapping the current context
      * to a new one.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Logger extends ServiceMap.Service<Logger, { prefix: string }>()("Logger") {}
-     * class Config extends ServiceMap.Service<Config, { name: string }>()("Config") {}
+     * class Logger extends Context.Service<Logger, { prefix: string }>()("Logger") {}
+     * class Config extends Context.Service<Config, { name: string }>()("Config") {}
      *
      * const stream = Stream.fromEffect(
      *   Effect.gen(function*() {
@@ -12527,8 +12597,8 @@ export declare const updateServices: {
      * )
      *
      * const updated = stream.pipe(
-     *   Stream.updateServices((services: ServiceMap.ServiceMap<Logger>) =>
-     *     ServiceMap.add(services, Config, { name: "World" })
+     *   Stream.updateContext((context: Context.Context<Logger>) =>
+     *     Context.add(context, Config, { name: "World" })
      *   )
      * )
      *
@@ -12546,17 +12616,17 @@ export declare const updateServices: {
      * @since 2.0.0
      * @category Services
      */
-    <R, R2>(f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<R>): <A, E>(self: Stream<A, E, R>) => Stream<A, E, R2>;
+    <R, R2>(f: (context: Context.Context<R2>) => Context.Context<R>): <A, E>(self: Stream<A, E, R>) => Stream<A, E, R2>;
     /**
-     * Transforms the stream's required services by mapping the current service map
+     * Transforms the stream's required services by mapping the current context
      * to a new one.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Logger extends ServiceMap.Service<Logger, { prefix: string }>()("Logger") {}
-     * class Config extends ServiceMap.Service<Config, { name: string }>()("Config") {}
+     * class Logger extends Context.Service<Logger, { prefix: string }>()("Logger") {}
+     * class Config extends Context.Service<Config, { name: string }>()("Config") {}
      *
      * const stream = Stream.fromEffect(
      *   Effect.gen(function*() {
@@ -12567,8 +12637,8 @@ export declare const updateServices: {
      * )
      *
      * const updated = stream.pipe(
-     *   Stream.updateServices((services: ServiceMap.ServiceMap<Logger>) =>
-     *     ServiceMap.add(services, Config, { name: "World" })
+     *   Stream.updateContext((context: Context.Context<Logger>) =>
+     *     Context.add(context, Config, { name: "World" })
      *   )
      * )
      *
@@ -12586,16 +12656,16 @@ export declare const updateServices: {
      * @since 2.0.0
      * @category Services
      */
-    <A, E, R, R2>(self: Stream<A, E, R>, f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<R>): Stream<A, E, R2>;
+    <A, E, R, R2>(self: Stream<A, E, R>, f: (context: Context.Context<R2>) => Context.Context<R>): Stream<A, E, R2>;
 };
 /**
  * Updates a single service in the stream environment by applying a function.
  *
  * @example
  * ```ts
- * import { Console, Effect, ServiceMap, Stream } from "effect"
+ * import { Console, Effect, Context, Stream } from "effect"
  *
- * class Counter extends ServiceMap.Service<Counter, { count: number }>()("Counter") {}
+ * class Counter extends Context.Service<Counter, { count: number }>()("Counter") {}
  *
  * const stream = Stream.fromEffect(Effect.service(Counter)).pipe(
  *   Stream.updateService(Counter, (counter) => ({ count: counter.count + 1 }))
@@ -12619,9 +12689,9 @@ export declare const updateService: {
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Counter extends ServiceMap.Service<Counter, { count: number }>()("Counter") {}
+     * class Counter extends Context.Service<Counter, { count: number }>()("Counter") {}
      *
      * const stream = Stream.fromEffect(Effect.service(Counter)).pipe(
      *   Stream.updateService(Counter, (counter) => ({ count: counter.count + 1 }))
@@ -12639,15 +12709,15 @@ export declare const updateService: {
      * @since 2.0.0
      * @category Services
      */
-    <I, S>(key: ServiceMap.Key<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R | I>;
+    <I, S>(key: Context.Key<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(self: Stream<A, E, R>) => Stream<A, E, R | I>;
     /**
      * Updates a single service in the stream environment by applying a function.
      *
      * @example
      * ```ts
-     * import { Console, Effect, ServiceMap, Stream } from "effect"
+     * import { Console, Effect, Context, Stream } from "effect"
      *
-     * class Counter extends ServiceMap.Service<Counter, { count: number }>()("Counter") {}
+     * class Counter extends Context.Service<Counter, { count: number }>()("Counter") {}
      *
      * const stream = Stream.fromEffect(Effect.service(Counter)).pipe(
      *   Stream.updateService(Counter, (counter) => ({ count: counter.count + 1 }))
@@ -12665,7 +12735,7 @@ export declare const updateService: {
      * @since 2.0.0
      * @category Services
      */
-    <A, E, R, I, S>(self: Stream<A, E, R>, key: ServiceMap.Key<I, S>, f: (service: NoInfer<S>) => S): Stream<A, E, R | I>;
+    <A, E, R, I, S>(self: Stream<A, E, R>, key: Context.Key<I, S>, f: (service: NoInfer<S>) => S): Stream<A, E, R | I>;
 };
 /**
  * Wraps the stream with a new span for tracing.
@@ -13640,18 +13710,18 @@ export declare const mkUint8Array: <E, R>(self: Stream<Uint8Array, E, R>) => Eff
  *
  * @example
  * ```ts
- * import { ServiceMap, Stream } from "effect"
+ * import { Context, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2, 3, 4, 5)
- * const readableStream = Stream.toReadableStreamWith(stream, ServiceMap.empty())
+ * const readableStream = Stream.toReadableStreamWith(stream, Context.empty())
  * ```
  *
  * @since 2.0.0
  * @category Destructors
  */
-export declare const toReadableStreamWith: (<A, XR>(services: ServiceMap.ServiceMap<XR>, options?: {
+export declare const toReadableStreamWith: (<A, XR>(context: Context.Context<XR>, options?: {
     readonly strategy?: QueuingStrategy<A> | undefined;
-}) => <E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>) & (<A, E, XR, R extends XR>(self: Stream<A, E, R>, services: ServiceMap.ServiceMap<XR>, options?: {
+}) => <E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>) & (<A, E, XR, R extends XR>(self: Stream<A, E, R>, context: Context.Context<XR>, options?: {
     readonly strategy?: QueuingStrategy<A> | undefined;
 }) => ReadableStream<A>);
 /**
@@ -13789,10 +13859,10 @@ export declare const toReadableStreamEffect: {
  *
  * @example
  * ```ts
- * import { ServiceMap, Stream } from "effect"
+ * import { Context, Stream } from "effect"
  *
  * const stream = Stream.make(1, 2, 3)
- * const iterable = Stream.toAsyncIterableWith(stream, ServiceMap.empty())
+ * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())
  *
  * const collect = async () => {
  *   const results: Array<number> = []
@@ -13812,10 +13882,10 @@ export declare const toAsyncIterableWith: {
      *
      * @example
      * ```ts
-     * import { ServiceMap, Stream } from "effect"
+     * import { Context, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2, 3)
-     * const iterable = Stream.toAsyncIterableWith(stream, ServiceMap.empty())
+     * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())
      *
      * const collect = async () => {
      *   const results: Array<number> = []
@@ -13829,16 +13899,16 @@ export declare const toAsyncIterableWith: {
      * @since 2.0.0
      * @category Destructors
      */
-    <XR>(services: ServiceMap.ServiceMap<XR>): <A, E, R extends XR>(self: Stream<A, E, R>) => AsyncIterable<A>;
+    <XR>(context: Context.Context<XR>): <A, E, R extends XR>(self: Stream<A, E, R>) => AsyncIterable<A>;
     /**
      * Converts the stream to an `AsyncIterable` using the provided services.
      *
      * @example
      * ```ts
-     * import { ServiceMap, Stream } from "effect"
+     * import { Context, Stream } from "effect"
      *
      * const stream = Stream.make(1, 2, 3)
-     * const iterable = Stream.toAsyncIterableWith(stream, ServiceMap.empty())
+     * const iterable = Stream.toAsyncIterableWith(stream, Context.empty())
      *
      * const collect = async () => {
      *   const results: Array<number> = []
@@ -13852,7 +13922,7 @@ export declare const toAsyncIterableWith: {
      * @since 2.0.0
      * @category Destructors
      */
-    <A, E, XR, R extends XR>(self: Stream<A, E, R>, services: ServiceMap.ServiceMap<XR>): AsyncIterable<A>;
+    <A, E, XR, R extends XR>(self: Stream<A, E, R>, context: Context.Context<XR>): AsyncIterable<A>;
 };
 /**
  * Creates an effect that yields an `AsyncIterable` using the current services.
@@ -14198,16 +14268,16 @@ export declare const toPubSubTake: {
     }): Effect.Effect<PubSub.PubSub<Take.Take<A, E>>, never, R | Scope.Scope>;
 };
 /**
- * Converts a stream to a PubSub for concurrent consumption.
+ * Converts a stream to a Queue for concurrent consumption.
  *
  * @example
  * ```ts
- * import { Effect, PubSub, Stream } from "effect"
+ * import { Effect, Queue, Stream } from "effect"
  *
  * const program = Effect.gen(function* () {
- *   const pubSub = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
- *   const subscription = yield* PubSub.subscribe(pubSub)
- *   return subscription
+ *   const queue = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
+ *   const chunk = yield* Queue.takeBetween(queue, 1, 3)
+ *   return chunk
  * })
  * ```
  *
@@ -14216,16 +14286,16 @@ export declare const toPubSubTake: {
  */
 export declare const toQueue: {
     /**
-     * Converts a stream to a PubSub for concurrent consumption.
+     * Converts a stream to a Queue for concurrent consumption.
      *
      * @example
      * ```ts
-     * import { Effect, PubSub, Stream } from "effect"
+     * import { Effect, Queue, Stream } from "effect"
      *
      * const program = Effect.gen(function* () {
-     *   const pubSub = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
-     *   const subscription = yield* PubSub.subscribe(pubSub)
-     *   return subscription
+     *   const queue = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
+     *   const chunk = yield* Queue.takeBetween(queue, 1, 3)
+     *   return chunk
      * })
      * ```
      *
@@ -14239,16 +14309,16 @@ export declare const toQueue: {
         readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
     }): <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Queue.Dequeue<A, E | Cause.Done>, never, R | Scope.Scope>;
     /**
-     * Converts a stream to a PubSub for concurrent consumption.
+     * Converts a stream to a Queue for concurrent consumption.
      *
      * @example
      * ```ts
-     * import { Effect, PubSub, Stream } from "effect"
+     * import { Effect, Queue, Stream } from "effect"
      *
      * const program = Effect.gen(function* () {
-     *   const pubSub = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
-     *   const subscription = yield* PubSub.subscribe(pubSub)
-     *   return subscription
+     *   const queue = yield* Stream.toQueue(Stream.fromIterable([1, 2, 3]), { capacity: 8 })
+     *   const chunk = yield* Queue.takeBetween(queue, 1, 3)
+     *   return chunk
      * })
      * ```
      *
@@ -14260,7 +14330,7 @@ export declare const toQueue: {
     } | {
         readonly capacity: number;
         readonly strategy?: "dropping" | "sliding" | "suspend" | undefined;
-    }): Effect.Effect<PubSub.PubSub<A>, never, R | Scope.Scope>;
+    }): Effect.Effect<Queue.Dequeue<A, E | Cause.Done>, never, R | Scope.Scope>;
 };
 /**
  * Runs the stream, offering each element to the provided queue and ending it