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

package/src/Stream.ts

@@ -6,6 +6,7 @@ import * as Arr from "./Array.ts"
 import * as Cause from "./Cause.ts"
 import * as Channel from "./Channel.ts"
 import { Clock } from "./Clock.ts"
+import * as Context from "./Context.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import * as Equal from "./Equal.ts"
@@ -37,7 +38,6 @@ import * as RcRef from "./RcRef.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 { isString } from "./String.ts"
 import type * as Take from "./Take.ts"
@@ -354,6 +354,79 @@ export const fromChannel: <Arr extends Arr.NonEmptyReadonlyArray<any>, E, R>(
 export const fromEffect = <A, E, R>(effect: Effect.Effect<A, E, R>): Stream<A, E, R> =>
   fromChannel(Channel.fromEffect(Effect.map(effect, Arr.of)))
 
+/**
+ * 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 const service = <I, S>(service: Context.Key<I, S>): Stream<S, never, I> => fromEffect(Effect.service(service))
+
+/**
+ * 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 const serviceOption = <I, S>(service: Context.Key<I, S>): Stream<Option.Option<S>> =>
+  fromEffect(Effect.serviceOption(service))
+
 /**
  * Creates a stream that runs the effect and emits no elements.
  *
@@ -1011,9 +1084,9 @@ export const fromIterable = <A>(
  *
  * @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") {}
  *
@@ -9083,9 +9156,9 @@ export 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>
  *   })
@@ -9125,9 +9198,9 @@ export 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>
    *   })
@@ -9170,9 +9243,9 @@ export 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>
    *   })
@@ -9245,9 +9318,9 @@ export 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>
      *   })
@@ -13664,11 +13737,9 @@ export const aggregateWithin: {
     })
 
     // upstream -> buffer
-    let hadChunk = false
     yield* pull.pipe(
       pullLatch.whenOpen,
       Effect.flatMap((arr) => {
-        hadChunk = true
         pullLatch.closeUnsafe()
         return Queue.offer(buffer, arr)
       }),
@@ -13706,10 +13777,11 @@ export const aggregateWithin: {
      */
     B>()
     let leftover: Arr.NonEmptyReadonlyArray<A2> | undefined
+    let sinkHasInput = false
     const step = yield* Schedule.toStepWithSleep(schedule)
     const stepToBuffer = Effect.suspend(function loop(): Pull.Pull<never, E3, void, R3> {
       return step(lastOutput).pipe(
-        Effect.flatMap(() => !hadChunk && leftover === undefined ? loop() : Queue.offer(buffer, scheduleStep)),
+        Effect.flatMap(() => !sinkHasInput ? loop() : Queue.offer(buffer, scheduleStep)),
         Effect.flatMap(() => Effect.never),
         Pull.catchDone(() => Cause.done())
       )
@@ -13720,22 +13792,28 @@ export const aggregateWithin: {
       Arr.NonEmptyReadonlyArray<A>,
       E
     > = Queue.take(buffer).pipe(
-      Effect.flatMap((arr) => arr === scheduleStep ? Cause.done() : Effect.succeed(arr))
+      Effect.flatMap((arr) => {
+        if (arr === scheduleStep) {
+          return Cause.done()
+        }
+        sinkHasInput = true
+        return Effect.succeed(arr)
+      })
     )
 
     const sinkUpstream = Effect.suspend((): Pull.Pull<Arr.NonEmptyReadonlyArray<A | A2>, E> => {
       if (leftover !== undefined) {
         const chunk = leftover
         leftover = undefined
+        sinkHasInput = true
         return Effect.succeed(chunk)
       }
-      hadChunk = false
       pullLatch.openUnsafe()
       return pullFromBuffer
     })
     const catchSinkHalt = Effect.flatMap(([value, leftover_]: Sink.End<B, A2>) => {
       // ignore the last output if the upstream only pulled a halt
-      if (!hadChunk && buffer.state._tag === "Done") return Cause.done()
+      if (!sinkHasInput && buffer.state._tag === "Done") return Cause.done()
       lastOutput = Option.some(value)
       leftover = leftover_
       return Effect.succeed(Arr.of(value))
@@ -13743,9 +13821,10 @@ export const aggregateWithin: {
 
     return Effect.suspend(() => {
       // if the buffer has exited and there is no more data to process
-      if (buffer.state._tag === "Done") {
+      if (buffer.state._tag === "Done" && leftover === undefined) {
         return buffer.state.exit as Exit.Exit<never, Cause.Done<void> | E>
       }
+      sinkHasInput = leftover !== undefined
       return Effect.succeed(Effect.suspend(() => sink.transform(sinkUpstream as any, scope)))
     }).pipe(
       Effect.flatMap((pull) => Effect.raceFirst(catchSinkHalt(pull), stepToBuffer))
@@ -15876,7 +15955,7 @@ export const ensuring: {
 )
 
 /**
- * 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.
  *
@@ -15884,9 +15963,9 @@ export 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" })
  *
@@ -15913,7 +15992,7 @@ export const ensuring: {
  */
 export 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.
    *
@@ -15921,9 +16000,9 @@ export 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" })
    *
@@ -15949,7 +16028,7 @@ export const provide: {
    * @category Services
    */
   <AL, EL = never, RL = never>(
-    layer: Layer.Layer<AL, EL, RL> | ServiceMap.ServiceMap<AL>,
+    layer: Layer.Layer<AL, EL, RL> | Context.Context<AL>,
     options?: {
       readonly local?: boolean | undefined
     } | undefined
@@ -15957,7 +16036,7 @@ export const provide: {
     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.
    *
@@ -15965,9 +16044,9 @@ export 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" })
    *
@@ -15994,31 +16073,31 @@ export const provide: {
    */
   <A, E, R, AL, EL = never, RL = never>(
     self: Stream<A, E, R>,
-    layer: Layer.Layer<AL, EL, RL> | ServiceMap.ServiceMap<AL>,
+    layer: Layer.Layer<AL, EL, RL> | Context.Context<AL>,
     options?: {
       readonly local?: boolean | undefined
     } | undefined
   ): Stream<A, E | EL, Exclude<R, AL> | RL>
 } = dual((args) => isStream(args[0]), <A, E, R, AL, EL = never, RL = never>(
   self: Stream<A, E, R>,
-  layer: Layer.Layer<AL, EL, RL> | ServiceMap.ServiceMap<AL>,
+  layer: Layer.Layer<AL, EL, RL> | Context.Context<AL>,
   options?: {
     readonly local?: boolean | undefined
   } | undefined
 ): Stream<A, E | EL, Exclude<R, AL> | RL> => fromChannel(Channel.provide(self.channel, layer, options)))
 
 /**
- * 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(
@@ -16030,7 +16109,7 @@ export 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)
  * })
  *
@@ -16041,19 +16120,19 @@ export const provide: {
  * @since 4.0.0
  * @category Services
  */
-export const provideServices: {
+export 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(
@@ -16065,7 +16144,7 @@ export 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)
    * })
    *
@@ -16076,19 +16155,19 @@ export 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(
@@ -16100,7 +16179,7 @@ export 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)
    * })
    *
@@ -16111,11 +16190,11 @@ export 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>>
 } = dual(
   2,
-  <A, E, R, R2>(self: Stream<A, E, R>, services: ServiceMap.ServiceMap<R2>): Stream<A, E, Exclude<R, R2>> =>
-    fromChannel(Channel.provideServices(self.channel, services))
+  <A, E, R, R2>(self: Stream<A, E, R>, context: Context.Context<R2>): Stream<A, E, Exclude<R, R2>> =>
+    fromChannel(Channel.provideContext(self.channel, context))
 )
 
 /**
@@ -16124,9 +16203,9 @@ export 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") {}
  *
@@ -16161,9 +16240,9 @@ export 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") {}
    *
@@ -16191,7 +16270,7 @@ export const provideService: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Key<I, S>, service: NoInfer<S>): <A, E, R>(
+  <I, S>(key: Context.Key<I, S>, service: NoInfer<S>): <A, E, R>(
     self: Stream<A, E, R>
   ) => Stream<A, E, Exclude<R, I>>
   /**
@@ -16200,9 +16279,9 @@ export 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") {}
    *
@@ -16230,10 +16309,10 @@ export 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>>
 } = dual(3, <A, E, R, I, S>(
   self: Stream<A, E, R>,
-  key: ServiceMap.Key<I, S>,
+  key: Context.Key<I, S>,
   service: NoInfer<S>
 ): Stream<A, E, Exclude<R, I>> => fromChannel(Channel.provideService(self.channel, key, service)))
 
@@ -16242,9 +16321,9 @@ export const provideService: {
  *
  * @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*() {
@@ -16281,9 +16360,9 @@ export 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*() {
@@ -16314,7 +16393,7 @@ export 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>(
+  <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>
   /**
@@ -16322,9 +16401,9 @@ export 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*() {
@@ -16357,25 +16436,25 @@ export const provideServiceEffect: {
    */
   <A, E, R, I, S, ES, RS>(
     self: Stream<A, E, R>,
-    key: ServiceMap.Key<I, S>,
+    key: Context.Key<I, S>,
     service: Effect.Effect<NoInfer<S>, ES, RS>
   ): Stream<A, E | ES, Exclude<R, I> | RS>
 } = dual(3, <A, E, R, I, S, ES, RS>(
   self: Stream<A, E, R>,
-  key: ServiceMap.Key<I, S>,
+  key: Context.Key<I, S>,
   service: Effect.Effect<NoInfer<S>, ES, RS>
 ): Stream<A, E | ES, Exclude<R, I> | RS> => fromChannel(Channel.provideServiceEffect(self.channel, key, service)))
 
 /**
- * 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*() {
@@ -16386,8 +16465,8 @@ export 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" })
  *   )
  * )
  *
@@ -16405,17 +16484,17 @@ export const provideServiceEffect: {
  * @since 2.0.0
  * @category Services
  */
-export const updateServices: {
+export 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*() {
@@ -16426,8 +16505,8 @@ export 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" })
    *   )
    * )
    *
@@ -16445,19 +16524,19 @@ export const updateServices: {
    * @since 2.0.0
    * @category Services
    */
-  <R, R2>(f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<R>): <A, E>(
+  <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*() {
@@ -16468,8 +16547,8 @@ export 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" })
    *   )
    * )
    *
@@ -16489,21 +16568,21 @@ export const updateServices: {
    */
   <A, E, R, R2>(
     self: Stream<A, E, R>,
-    f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<R>
+    f: (context: Context.Context<R2>) => Context.Context<R>
   ): Stream<A, E, R2>
 } = dual(2, <A, E, R, R2>(
   self: Stream<A, E, R>,
-  f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<R>
-): Stream<A, E, R2> => fromChannel(Channel.updateServices(self.channel, f)))
+  f: (context: Context.Context<R2>) => Context.Context<R>
+): Stream<A, E, R2> => fromChannel(Channel.updateContext(self.channel, f)))
 
 /**
  * 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 }))
@@ -16527,9 +16606,9 @@ export 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 }))
@@ -16547,7 +16626,7 @@ export const updateService: {
    * @since 2.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Key<I, S>, f: (service: NoInfer<S>) => S): <A, E, R>(
+  <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>
   /**
@@ -16555,9 +16634,9 @@ export 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 }))
@@ -16577,19 +16656,19 @@ export const updateService: {
    */
   <A, E, R, I, S>(
     self: Stream<A, E, R>,
-    key: ServiceMap.Key<I, S>,
+    key: Context.Key<I, S>,
     f: (service: NoInfer<S>) => S
   ): Stream<A, E, R | I>
 } = dual(3, <A, E, R, I, S>(
   self: Stream<A, E, R>,
-  service: ServiceMap.Key<I, S>,
+  service: Context.Key<I, S>,
   f: (service: NoInfer<S>) => S
 ): Stream<A, E, R | I> =>
-  updateServices(self, (services) =>
-    ServiceMap.add(
-      services,
+  updateContext(self, (context) =>
+    Context.add(
+      context,
       service,
-      f(ServiceMap.get(services, service))
+      f(Context.get(context, service))
     )))
 
 /**
@@ -17757,10 +17836,10 @@ export const mkUint8Array = <E, R>(self: Stream<Uint8Array, E, R>): Effect.Effec
  *
  * @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
@@ -17774,17 +17853,17 @@ export const toReadableStreamWith = dual<
    *
    * @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
    */
   <A, XR>(
-    services: ServiceMap.ServiceMap<XR>,
+    context: Context.Context<XR>,
     options?: { readonly strategy?: QueuingStrategy<A> | undefined }
   ) => <E, R extends XR>(self: Stream<A, E, R>) => ReadableStream<A>,
   /**
@@ -17794,10 +17873,10 @@ export const toReadableStreamWith = dual<
    *
    * @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
@@ -17805,14 +17884,14 @@ export const toReadableStreamWith = dual<
    */
   <A, E, XR, R extends XR>(
     self: Stream<A, E, R>,
-    services: ServiceMap.ServiceMap<XR>,
+    context: Context.Context<XR>,
     options?: { readonly strategy?: QueuingStrategy<A> | undefined }
   ) => ReadableStream<A>
 >(
   (args) => isStream(args[0]),
   <A, E, XR, R extends XR>(
     self: Stream<A, E, R>,
-    services: ServiceMap.ServiceMap<XR>,
+    context: Context.Context<XR>,
     options?: { readonly strategy?: QueuingStrategy<A> | undefined }
   ): ReadableStream<A> => {
     let currentResolve: (() => void) | undefined = undefined
@@ -17821,7 +17900,7 @@ export const toReadableStreamWith = dual<
 
     return new ReadableStream<A>({
       start(controller) {
-        fiber = Effect.runFork(Effect.provideServices(
+        fiber = Effect.runFork(Effect.provideContext(
           runForEachArray(self, (chunk) =>
             latch.whenOpen(Effect.sync(() => {
               latch.closeUnsafe()
@@ -17831,7 +17910,7 @@ export const toReadableStreamWith = dual<
               currentResolve!()
               currentResolve = undefined
             }))),
-          services
+          context
         ))
         fiber.addObserver((exit) => {
           if (exit._tag === "Failure") {
@@ -17916,7 +17995,7 @@ export const toReadableStream: {
   <A, E>(
     self: Stream<A, E>,
     options?: { readonly strategy?: QueuingStrategy<A> | undefined }
-  ): ReadableStream<A> => toReadableStreamWith(self, ServiceMap.empty(), options)
+  ): ReadableStream<A> => toReadableStreamWith(self, Context.empty(), options)
 )
 
 /**
@@ -18000,7 +18079,7 @@ export const toReadableStreamEffect: {
     options?: { readonly strategy?: QueuingStrategy<A> | undefined }
   ): Effect.Effect<ReadableStream<A>, never, R> =>
     Effect.map(
-      Effect.services</**
+      Effect.context</**
        * Creates an Effect that builds a ReadableStream from the stream.
        *
        * See https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream.
@@ -18032,10 +18111,10 @@ export 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> = []
@@ -18055,10 +18134,10 @@ export 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> = []
@@ -18072,16 +18151,16 @@ export 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> = []
@@ -18095,16 +18174,16 @@ export 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>
 } = dual(
   2,
   <A, E, XR, R extends XR>(
     self: Stream<A, E, R>,
-    services: ServiceMap.ServiceMap<XR>
+    context: Context.Context<XR>
   ): AsyncIterable<A> => ({
     [Symbol.asyncIterator]() {
-      const runPromise = Effect.runPromiseWith(services)
-      const runPromiseExit = Effect.runPromiseExitWith(services)
+      const runPromise = Effect.runPromiseWith(context)
+      const runPromiseExit = Effect.runPromiseExitWith(context)
       const scope = Scope.makeUnsafe()
       let pull: Pull.Pull<Arr.NonEmptyReadonlyArray<A>, E, void, R> | undefined
       let currentIter: Iterator<A> | undefined
@@ -18166,8 +18245,8 @@ export const toAsyncIterableWith: {
  */
 export const toAsyncIterableEffect = <A, E, R>(self: Stream<A, E, R>): Effect.Effect<AsyncIterable<A>, never, R> =>
   Effect.map(
-    Effect.services<R>(),
-    (services) => toAsyncIterableWith(self, services)
+    Effect.context<R>(),
+    (context) => toAsyncIterableWith(self, context)
   )
 
 /**
@@ -18196,7 +18275,7 @@ export const toAsyncIterableEffect = <A, E, R>(self: Stream<A, E, R>): Effect.Ef
  * @category Destructors
  */
 export const toAsyncIterable = <A, E>(self: Stream<A, E>): AsyncIterable<A> =>
-  toAsyncIterableWith(self, ServiceMap.empty())
+  toAsyncIterableWith(self, Context.empty())
 
 /**
  * Runs the stream, publishing elements into the provided PubSub.
@@ -18542,16 +18621,16 @@ export const toPubSubTake: {
 )
 
 /**
- * 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
  * })
  * ```
  *
@@ -18560,16 +18639,16 @@ export const toPubSubTake: {
  */
 export 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
    * })
    * ```
    *
@@ -18585,16 +18664,16 @@ export const toQueue: {
     }
   ): <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
    * })
    * ```
    *
@@ -18609,22 +18688,19 @@ export 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>
 } = dual(
   2,
   <A, E, R>(
     self: Stream<A, E, R>,
     options: {
       readonly capacity: "unbounded"
-      readonly replay?: number | undefined
-      readonly shutdownOnEnd?: boolean | undefined
     } | {
       readonly capacity: number
       readonly strategy?: "dropping" | "sliding" | "suspend" | undefined
-      readonly replay?: number | undefined
-      readonly shutdownOnEnd?: boolean | undefined
     }
-  ): Effect.Effect<PubSub.PubSub<A>, never, R | Scope.Scope> => Channel.toPubSubArray(self.channel, options)
+  ): Effect.Effect<Queue.Dequeue<A, E | Cause.Done>, never, R | Scope.Scope> =>
+    Channel.toQueueArray(self.channel, options)
 )
 
 /**