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

package/src/Cause.ts

@@ -77,6 +77,7 @@
  *
  * @since 2.0.0
  */
+import * as Context from "./Context.ts"
 import type * as Effect from "./Effect.ts"
 import type { Equal } from "./Equal.ts"
 import type { Fiber } from "./Fiber.ts"
@@ -87,7 +88,6 @@ import type { Option } from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import type { StackFrame } from "./References.ts"
 import type * as Result from "./Result.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import type * as Types from "./Types.ts"
 
 /**
@@ -319,7 +319,7 @@ export declare namespace Cause {
     readonly [ReasonTypeId]: typeof ReasonTypeId
     readonly _tag: Tag
     readonly annotations: ReadonlyMap<string, unknown>
-    annotate(annotations: ServiceMap.ServiceMap<never> | ReadonlyMap<string, unknown>, options?: {
+    annotate(annotations: Context.Context<never> | ReadonlyMap<string, unknown>, options?: {
       readonly overwrite?: boolean | undefined
     }): this
   }
@@ -1674,7 +1674,7 @@ export const UnknownError: new(cause: unknown, message?: string) => UnknownError
 /**
  * Attaches metadata to every reason in a {@link Cause}.
  *
- * Annotations are stored as a `ServiceMap` on each reason and can be
+ * Annotations are stored as a `Context` on each reason and can be
  * retrieved later via {@link reasonAnnotations} or {@link annotations}.
  * The runtime uses this to attach stack traces and spans.
  *
@@ -1685,10 +1685,10 @@ export const UnknownError: new(cause: unknown, message?: string) => UnknownError
  * **Example** (annotating a cause)
  *
  * ```ts
- * import { Cause, ServiceMap } from "effect"
+ * import { Cause, Context } from "effect"
  *
  * const cause = Cause.fail("error")
- * const annotated = Cause.annotate(cause, ServiceMap.empty())
+ * const annotated = Cause.annotate(cause, Context.empty())
  * ```
  *
  * @see {@link annotations} — read merged annotations from a cause
@@ -1701,7 +1701,7 @@ export const annotate: {
   /**
    * Attaches metadata to every reason in a {@link Cause}.
    *
-   * Annotations are stored as a `ServiceMap` on each reason and can be
+   * Annotations are stored as a `Context` on each reason and can be
    * retrieved later via {@link reasonAnnotations} or {@link annotations}.
    * The runtime uses this to attach stack traces and spans.
    *
@@ -1712,10 +1712,10 @@ export const annotate: {
    * **Example** (annotating a cause)
    *
    * ```ts
-   * import { Cause, ServiceMap } from "effect"
+   * import { Cause, Context } from "effect"
    *
    * const cause = Cause.fail("error")
-   * const annotated = Cause.annotate(cause, ServiceMap.empty())
+   * const annotated = Cause.annotate(cause, Context.empty())
    * ```
    *
    * @see {@link annotations} — read merged annotations from a cause
@@ -1725,13 +1725,13 @@ export const annotate: {
    * @since 4.0.0
    */
   (
-   annotations: ServiceMap.ServiceMap<never>,
+   annotations: Context.Context<never>,
    options?: { readonly overwrite?: boolean | undefined }
   ): <E>(self: Cause<E>) => Cause<E>
   /**
    * Attaches metadata to every reason in a {@link Cause}.
    *
-   * Annotations are stored as a `ServiceMap` on each reason and can be
+   * Annotations are stored as a `Context` on each reason and can be
    * retrieved later via {@link reasonAnnotations} or {@link annotations}.
    * The runtime uses this to attach stack traces and spans.
    *
@@ -1742,10 +1742,10 @@ export const annotate: {
    * **Example** (annotating a cause)
    *
    * ```ts
-   * import { Cause, ServiceMap } from "effect"
+   * import { Cause, Context } from "effect"
    *
    * const cause = Cause.fail("error")
-   * const annotated = Cause.annotate(cause, ServiceMap.empty())
+   * const annotated = Cause.annotate(cause, Context.empty())
    * ```
    *
    * @see {@link annotations} — read merged annotations from a cause
@@ -1756,13 +1756,13 @@ export const annotate: {
    */
   <E>(
    self: Cause<E>,
-   annotations: ServiceMap.ServiceMap<never>,
+   annotations: Context.Context<never>,
    options?: { readonly overwrite?: boolean | undefined }
   ): Cause<E>
 } = core.causeAnnotate
 
 /**
- * Reads the annotations from a single {@link Reason} as a `ServiceMap`.
+ * Reads the annotations from a single {@link Reason} as a `Context`.
  *
  * Use this when you need tracing metadata (e.g. {@link StackTrace}) from
  * a specific reason rather than the whole cause.
@@ -1773,7 +1773,7 @@ export const annotate: {
  * @category annotations
  * @since 4.0.0
  */
-export const reasonAnnotations: <E>(self: Reason<E>) => ServiceMap.ServiceMap<never> = effect.reasonAnnotations
+export const reasonAnnotations: <E>(self: Reason<E>) => Context.Context<never> = effect.reasonAnnotations
 
 /**
  * Reads the merged annotations from all reasons in a {@link Cause}.
@@ -1786,22 +1786,22 @@ export const reasonAnnotations: <E>(self: Reason<E>) => ServiceMap.ServiceMap<ne
  * @category annotations
  * @since 4.0.0
  */
-export const annotations: <E>(self: Cause<E>) => ServiceMap.ServiceMap<never> = effect.causeAnnotations
+export const annotations: <E>(self: Cause<E>) => Context.Context<never> = effect.causeAnnotations
 
 /**
- * `ServiceMap` key for the stack frame captured at the point of failure.
+ * `Context` key for the stack frame captured at the point of failure.
  *
  * The runtime annotates every reason with this when a stack frame is
  * available. Retrieve it via
- * `ServiceMap.get(Cause.reasonAnnotations(reason), Cause.StackTrace)`.
+ * `Context.get(Cause.reasonAnnotations(reason), Cause.StackTrace)`.
  *
  * @category annotations
  * @since 4.0.0
  */
-export class StackTrace extends ServiceMap.Service<StackTrace, StackFrame>()("effect/Cause/StackTrace") {}
+export class StackTrace extends Context.Service<StackTrace, StackFrame>()("effect/Cause/StackTrace") {}
 
 /**
- * `ServiceMap` key for the stack frame captured at the point of
+ * `Context` key for the stack frame captured at the point of
  * interruption.
  *
  * Similar to {@link StackTrace} but specific to {@link Interrupt} reasons.
@@ -1810,5 +1810,5 @@ export class StackTrace extends ServiceMap.Service<StackTrace, StackFrame>()("ef
  * @since 4.0.0
  */
 export class InterruptorStackTrace
-  extends ServiceMap.Service<InterruptorStackTrace, StackFrame>()("effect/Cause/InterruptorStackTrace")
+  extends Context.Service<InterruptorStackTrace, StackFrame>()("effect/Cause/InterruptorStackTrace")
 {}

package/src/Channel.ts

@@ -60,6 +60,7 @@
 import * as Arr from "./Array.ts"
 import * as Cause from "./Cause.ts"
 import * as Chunk from "./Chunk.ts"
+import * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
@@ -85,7 +86,6 @@ import * as Result from "./Result.ts"
 import * as Schedule from "./Schedule.ts"
 import * as Scope from "./Scope.ts"
 import * as Semaphore from "./Semaphore.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import * as String from "./String.ts"
 import * as Take from "./Take.ts"
 import { ParentSpan, type SpanOptions } from "./Tracer.ts"
@@ -2092,7 +2092,7 @@ const mapEffectConcurrent = <
       const queue = yield* Queue.bounded<OutElem2, OutErr | EX | Cause.Done<OutDone>>(0)
       yield* Scope.addFinalizer(forkedScope, Queue.shutdown(queue))
 
-      const runFork = Effect.runForkWith(yield* Effect.services<RX>())
+      const runFork = Effect.runForkWith(yield* Effect.context<RX>())
       const trackFiber = Fiber.runIn(forkedScope)
 
       if (options.unordered) {
@@ -7503,6 +7503,29 @@ export const mergeEffect: {
   ) as any)
 
 /**
+ * Splits upstream string chunks into lines, recognizing `\n`, `\r\n`, and
+ * standalone `\r` as line terminators. The behavior matches
+ * `String.linesIterator` regardless of how the input is chunked.
+ *
+ * A line terminator at the very end of the stream does **not** produce a
+ * trailing empty line (consistent with `String.linesIterator`). Conversely,
+ * if the stream ends without a terminator the final partial line is still
+ * emitted.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Effect, Stream } from "effect"
+ *
+ * Effect.runPromise(Effect.gen(function*() {
+ *   const result = yield* Stream.runCollect(
+ *     Stream.splitLines(Stream.make("hel", "lo\r\nwor", "ld\n"))
+ *   )
+ *   console.log(result)
+ *   // [ 'hello', 'world' ]
+ * }))
+ * ```
+ *
  * @since 2.0.0
  * @category String manipulation
  */
@@ -7516,11 +7539,30 @@ export const splitLines = <Err, Done>(): Channel<
 > =>
   fromTransform((upstream, _scope) =>
     Effect.sync(() => {
+      // Accumulates text that has not yet been terminated by a line break.
+      // Content is carried across chunks until a terminator is found.
       let stringBuilder = ""
+      // Set when a chunk ends with \r so the next chunk can check whether
+      // the following character is \n (completing a \r\n pair) or not
+      // (standalone \r, which is itself a line terminator).
       let midCRLF = false
+      // Remembers the upstream Done value after the first time the upstream
+      // signals completion, so subsequent pulls return Done immediately
+      // without pulling upstream again.
+      let done = Option.none<Done>()
 
-      const splitLinesArray = (chunk: Arr.NonEmptyReadonlyArray<string>): Arr.NonEmptyReadonlyArray<string> | null => {
+      function splitLinesArray(chunk: Arr.NonEmptyReadonlyArray<string>): Arr.NonEmptyReadonlyArray<string> | null {
         const chunkBuilder: Array<string> = []
+
+        function pushLine(segment: string): void {
+          if (stringBuilder.length === 0) {
+            chunkBuilder.push(segment)
+          } else {
+            chunkBuilder.push(stringBuilder + segment)
+            stringBuilder = ""
+          }
+        }
+
         for (let i = 0; i < chunk.length; i++) {
           const str = chunk[i]
           if (str.length !== 0) {
@@ -7529,23 +7571,17 @@ export const splitLines = <Err, Done>(): Channel<
             let indexOfLF = str.indexOf("\n")
             if (midCRLF) {
               if (indexOfLF === 0) {
-                chunkBuilder.push(stringBuilder)
-                stringBuilder = ""
+                pushLine("")
                 from = 1
                 indexOfLF = str.indexOf("\n", from)
               } else {
-                stringBuilder = stringBuilder + "\r"
+                pushLine("")
               }
               midCRLF = false
             }
             while (indexOfCR !== -1 || indexOfLF !== -1) {
               if (indexOfCR === -1 || (indexOfLF !== -1 && indexOfLF < indexOfCR)) {
-                if (stringBuilder.length === 0) {
-                  chunkBuilder.push(str.substring(from, indexOfLF))
-                } else {
-                  chunkBuilder.push(stringBuilder + str.substring(from, indexOfLF))
-                  stringBuilder = ""
-                }
+                pushLine(str.substring(from, indexOfLF))
                 from = indexOfLF + 1
                 indexOfLF = str.indexOf("\n", from)
               } else {
@@ -7553,40 +7589,45 @@ export const splitLines = <Err, Done>(): Channel<
                   midCRLF = true
                   indexOfCR = -1
                 } else {
-                  if (indexOfLF === indexOfCR + 1) {
-                    if (stringBuilder.length === 0) {
-                      chunkBuilder.push(str.substring(from, indexOfCR))
-                    } else {
-                      stringBuilder = stringBuilder + str.substring(from, indexOfCR)
-                      chunkBuilder.push(stringBuilder)
-                      stringBuilder = ""
-                    }
-                    from = indexOfCR + 2
-                    indexOfCR = str.indexOf("\r", from)
-                    indexOfLF = str.indexOf("\n", from)
-                  } else {
-                    indexOfCR = str.indexOf("\r", indexOfCR + 1)
-                  }
+                  pushLine(str.substring(from, indexOfCR))
+                  from = indexOfCR + (indexOfLF === indexOfCR + 1 ? 2 : 1)
+                  indexOfCR = str.indexOf("\r", from)
+                  indexOfLF = str.indexOf("\n", from)
                 }
               }
             }
-            if (midCRLF) {
-              stringBuilder = stringBuilder + str.substring(from, str.length - 1)
-            } else {
-              stringBuilder = stringBuilder + str.substring(from, str.length)
-            }
+            stringBuilder = stringBuilder + str.substring(from, str.length - (midCRLF ? 1 : 0))
           }
         }
         return Arr.isReadonlyArrayNonEmpty(chunkBuilder) ? chunkBuilder : null
       }
 
-      return Effect.flatMap(
-        upstream,
-        function loop(chunk): Pull.Pull<Arr.NonEmptyReadonlyArray<string>, Err, Done> {
-          const lines = splitLinesArray(chunk)
-          return lines !== null ? Effect.succeed(lines) : Effect.flatMap(upstream, loop)
+      const pullOrFlush: Pull.Pull<Arr.NonEmptyReadonlyArray<string>, Err, Done> = Effect.suspend(() => {
+        if (done._tag === "Some") {
+          return Cause.done(done.value)
         }
-      )
+        return Pull.matchEffect(upstream, {
+          onSuccess: loop,
+          onFailure: Effect.failCause,
+          onDone: (leftover) => {
+            done = Option.some(leftover)
+            if (stringBuilder.length > 0 || midCRLF) {
+              const last = stringBuilder
+              stringBuilder = ""
+              midCRLF = false
+              return Effect.succeed([last] as Arr.NonEmptyReadonlyArray<string>)
+            }
+            return Cause.done(leftover)
+          }
+        })
+      })
+
+      function loop(chunk: Arr.NonEmptyReadonlyArray<string>): Pull.Pull<Arr.NonEmptyReadonlyArray<string>, Err, Done> {
+        const lines = splitLinesArray(chunk)
+        return lines !== null ? Effect.succeed(lines) : pullOrFlush
+      }
+
+      return pullOrFlush
     })
   )
 
@@ -8577,35 +8618,35 @@ const runWith = <
  * @since 2.0.0
  * @category Services
  */
-export const servicesWith = <Env, OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>(
-  f: (services: ServiceMap.ServiceMap<Env>) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>
+export const contextWith = <Env, OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>(
+  f: (context: Context.Context<Env>) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env2>
 ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env | Env2> =>
   fromTransform((upstream, scope) =>
-    Effect.servicesWith((services: ServiceMap.ServiceMap<Env>) => toTransform(f(services))(upstream, scope))
+    Effect.contextWith((context: Context.Context<Env>) => toTransform(f(context))(upstream, scope))
   )
 
 /**
- * Provides a layer or service map to the channel, removing the corresponding
+ * Provides a layer or context to the channel, removing the corresponding
  * service requirements. Use `options.local` to build the layer every time; by
  * default, layers are shared between provide calls.
  *
  * @since 4.0.0
  * @category Services
  */
-export const provideServices: {
+export const provideContext: {
   /**
-   * Provides a layer or service map to the channel, removing the corresponding
+   * Provides a layer or context to the channel, removing the corresponding
    * service requirements. Use `options.local` to build the layer every time; by
    * default, layers are shared between provide calls.
    *
    * @since 4.0.0
    * @category Services
    */
-  <R2>(services: ServiceMap.ServiceMap<R2>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <R2>(context: Context.Context<R2>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
   ) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, R2>>
   /**
-   * Provides a layer or service map to the channel, removing the corresponding
+   * Provides a layer or context to the channel, removing the corresponding
    * service requirements. Use `options.local` to build the layer every time; by
    * default, layers are shared between provide calls.
    *
@@ -8614,16 +8655,16 @@ export const provideServices: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, R2>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    services: ServiceMap.ServiceMap<R2>
+    context: Context.Context<R2>
   ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, R2>>
 } = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, R2>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  services: ServiceMap.ServiceMap<R2>
+  context: Context.Context<R2>
 ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, R2>> =>
   fromTransform((upstream, scope) =>
     Effect.map(
-      Effect.provideServices(toTransform(self)(upstream, scope), services),
-      Effect.provideServices(services)
+      Effect.provideContext(toTransform(self)(upstream, scope), context),
+      Effect.provideContext(context)
     )
   ))
 
@@ -8636,7 +8677,7 @@ export const provideService: {
    * @since 4.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Key<I, S>, service: NoInfer<S>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <I, S>(key: Context.Key<I, S>, service: NoInfer<S>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
   ) => Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>>
   /**
@@ -8645,12 +8686,12 @@ export const provideService: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    key: ServiceMap.Key<I, S>,
+    key: Context.Key<I, S>,
     service: NoInfer<S>
   ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>>
 } = dual(3, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  key: ServiceMap.Key<I, S>,
+  key: Context.Key<I, S>,
   service: NoInfer<S>
 ): Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Exclude<Env, I>> =>
   fromTransform((upstream, scope) =>
@@ -8669,7 +8710,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>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <I, S, ES, RS>(key: Context.Key<I, S>, service: Effect.Effect<NoInfer<S>, ES, RS>): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>
   ) => Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS>
   /**
@@ -8678,12 +8719,12 @@ export const provideServiceEffect: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S, ES, RS>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    key: ServiceMap.Key<I, S>,
+    key: Context.Key<I, S>,
     service: Effect.Effect<NoInfer<S>, ES, RS>
   ): Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS>
 } = dual(3, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S, ES, RS>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  key: ServiceMap.Key<I, S>,
+  key: Context.Key<I, S>,
   service: Effect.Effect<NoInfer<S>, ES, RS>
 ): Channel<OutElem, OutErr | ES, OutDone, InElem, InErr, InDone, Exclude<Env, I> | RS> =>
   fromTransform((upstream, scope) =>
@@ -8703,7 +8744,7 @@ export const provide: {
    * @category Services
    */
   <A, E = never, R = never>(
-    layer: Layer.Layer<A, E, R> | ServiceMap.ServiceMap<A>,
+    layer: Layer.Layer<A, E, R> | Context.Context<A>,
     options?: {
       readonly local?: boolean | undefined
     } | undefined
@@ -8716,27 +8757,27 @@ export const provide: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, A, E = never, R = never>(
     self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-    layer: Layer.Layer<A, E, R> | ServiceMap.ServiceMap<A>,
+    layer: Layer.Layer<A, E, R> | Context.Context<A>,
     options?: {
       readonly local?: boolean | undefined
     } | undefined
   ): Channel<OutElem, OutErr | E, OutDone, InElem, InErr, InDone, Exclude<Env, A> | R>
 } = dual((args) => isChannel(args[0]), <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, A, E = never, R = never>(
   self: Channel<OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>,
-  layer: Layer.Layer<A, E, R> | ServiceMap.ServiceMap<A>,
+  layer: Layer.Layer<A, E, R> | Context.Context<A>,
   options?: {
     readonly local?: boolean | undefined
   } | undefined
 ): Channel<OutElem, OutErr | E, OutDone, InElem, InErr, InDone, Exclude<Env, A> | R> =>
-  ServiceMap.isServiceMap(layer) ? provideServices(self, layer) : fromTransform((upstream, scope) =>
+  Context.isContext(layer) ? provideContext(self, layer) : fromTransform((upstream, scope) =>
     Effect.flatMap(
       options?.local
         ? Layer.buildWithMemoMap(layer, Layer.makeMemoMapUnsafe(), scope)
         : Layer.buildWithScope(layer, scope),
-      (services) =>
+      (context) =>
         Effect.map(
-          Effect.provideServices(toTransform(self)(upstream, scope), services),
-          Effect.provideServices(services)
+          Effect.provideContext(toTransform(self)(upstream, scope), context),
+          Effect.provideContext(context)
         )
     )
   ))
@@ -8745,12 +8786,12 @@ export const provide: {
  * @since 2.0.0
  * @category Services
  */
-export const updateServices: {
+export const updateContext: {
   /**
    * @since 2.0.0
    * @category Services
    */
-  <Env, R2>(f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<Env>): <OutElem, OutErr, OutDone, InElem, InErr, InDone>(
+  <Env, R2>(f: (context: Context.Context<R2>) => Context.Context<Env>): <OutElem, OutErr, OutDone, InElem, InErr, InDone>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R2>
   /**
@@ -8759,16 +8800,16 @@ export const updateServices: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, R2>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<Env>
+    f: (context: Context.Context<R2>) => Context.Context<Env>
   ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R2>
 } = dual(2, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, R2>(
   self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (services: ServiceMap.ServiceMap<R2>) => ServiceMap.ServiceMap<Env>
+  f: (context: Context.Context<R2>) => Context.Context<Env>
 ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R2> =>
   fromTransform((upstream, scope) =>
-    Effect.servicesWith((services) => {
-      const toProvide = f(services)
-      return toTransform(provideServices(self, toProvide))(upstream, scope)
+    Effect.contextWith((context) => {
+      const toProvide = f(context)
+      return toTransform(provideContext(self, toProvide))(upstream, scope)
     })
   ))
 
@@ -8781,7 +8822,7 @@ export const updateService: {
    * @since 2.0.0
    * @category Services
    */
-  <I, S>(key: ServiceMap.Key<I, S>, f: (service: NoInfer<S>) => S): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
+  <I, S>(key: Context.Key<I, S>, f: (service: NoInfer<S>) => S): <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I>
   /**
@@ -8790,19 +8831,19 @@ export const updateService: {
    */
   <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
     self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    service: ServiceMap.Key<I, S>,
+    service: Context.Key<I, S>,
     f: (service: NoInfer<S>) => S
   ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I>
 } = dual(3, <OutElem, OutErr, OutDone, InElem, InErr, InDone, Env, I, S>(
   self: Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  service: ServiceMap.Key<I, S>,
+  service: Context.Key<I, S>,
   f: (service: NoInfer<S>) => S
 ): Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env | I> =>
-  updateServices(self, (services) =>
-    ServiceMap.add(
-      services,
+  updateContext(self, (context) =>
+    Context.add(
+      context,
       service,
-      f(ServiceMap.get(services, service))
+      f(Context.get(context, service))
     )))
 
 /**
@@ -9514,11 +9555,11 @@ export const toPull: <OutElem, OutErr, OutDone, Env>(
     self: Channel<OutElem, OutErr, OutDone, unknown, unknown, unknown, Env>
   ) {
     const semaphore = Semaphore.makeUnsafe(1)
-    const context = yield* Effect.services<Env | Scope.Scope>()
-    const scope = ServiceMap.get(context, Scope.Scope)
+    const context = yield* Effect.context<Env | Scope.Scope>()
+    const scope = Context.get(context, Scope.Scope)
     const pull = yield* toTransform(self)(Cause.done(), scope)
     return pull.pipe(
-      Effect.provideServices(context),
+      Effect.provideContext(context),
       semaphore.withPermits(1)
     )
   },

package/src/Clock.ts

@@ -56,10 +56,10 @@
  *
  * @since 2.0.0
  */
+import type * as Context from "./Context.ts"
 import type * as Duration from "./Duration.ts"
 import type { Effect } from "./Effect.ts"
 import * as effect from "./internal/effect.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
 
 /**
  * Represents a time-based clock which provides functionality related to time
@@ -120,7 +120,7 @@ export interface Clock {
  * @category references
  * @since 4.0.0
  */
-export const Clock: ServiceMap.Reference<Clock> = effect.ClockRef
+export const Clock: Context.Reference<Clock> = effect.ClockRef
 
 /**
  * Accesses the current Clock service and uses it to run the provided function.

package/src/Config.ts

@@ -14,7 +14,7 @@
  * - **parse** – instance method on every `Config` that takes a provider and
  *   returns `Effect<T, ConfigError>`.
  * - **Yieldable** – every `Config` can be yielded inside `Effect.gen`. It
- *   automatically resolves the current `ConfigProvider` from the service map.
+ *   automatically resolves the current `ConfigProvider` from the context.
  *
  * ## Common tasks
  *
@@ -153,7 +153,7 @@ export class ConfigError {
  * - `parse(provider)` – runs the config against a specific provider,
  *   returning `Effect<T, ConfigError>`.
  * - Yieldable – can be yielded inside `Effect.gen`, which automatically
- *   resolves the current `ConfigProvider` from the service map.
+ *   resolves the current `ConfigProvider` from the context.
  * - Pipeable – supports `.pipe(Config.map(...))` etc.
  *
  * @see {@link schema} – the main way to create a Config

package/src/ConfigProvider.ts

@@ -12,7 +12,7 @@
  *   (e.g. `["database", "host"]`).
  * - **ConfigProvider** – an object with a `load(path)` method that resolves a
  *   path to a `Node | undefined`. Providers can be composed and transformed.
- * - **ServiceMap.Reference** – `ConfigProvider` is registered as a reference
+ * - **Context.Reference** – `ConfigProvider` is registered as a reference
  *   service that defaults to `fromEnv()`, so it works without explicit
  *   provision.
  * - **SourceError** – the typed error returned when a backing store is
@@ -78,6 +78,7 @@
  * @since 4.0.0
  */
 
+import * as Context from "./Context.ts"
 import * as Data from "./Data.ts"
 import * as Effect from "./Effect.ts"
 import * as FileSystem from "./FileSystem.ts"
@@ -90,7 +91,6 @@ import type { Pipeable } from "./Pipeable.ts"
 import type { PlatformError } from "./PlatformError.ts"
 import * as Predicate from "./Predicate.ts"
 import type { Scope } from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import * as Str from "./String.ts"
 
 /**
@@ -322,10 +322,10 @@ export interface ConfigProvider extends Pipeable {
 }
 
 /**
- * The `ConfigProvider` service reference, registered in the service map with a
+ * The `ConfigProvider` service reference, registered in the context with a
  * default value of `fromEnv()`.
  *
- * Because it is a `ServiceMap.Reference`, it is available without explicit
+ * Because it is a `Context.Reference`, it is available without explicit
  * provision — `Config` schemas automatically resolve it.
  *
  * When to use:
@@ -355,7 +355,7 @@ export interface ConfigProvider extends Pipeable {
  * @category Services
  * @since 4.0.0
  */
-export const ConfigProvider: ServiceMap.Reference<ConfigProvider> = ServiceMap.Reference<ConfigProvider>(
+export const ConfigProvider: Context.Reference<ConfigProvider> = Context.Reference<ConfigProvider>(
   "effect/ConfigProvider",
   { defaultValue: () => fromEnv() }
 )