effect 4.0.0-beta.43 → 4.0.0-beta.44

package/src/unstable/cluster/internal/entityManager.ts

@@ -1,6 +1,7 @@
 import * as Arr from "../../../Array.ts"
 import * as Cause from "../../../Cause.ts"
 import { Clock } from "../../../Clock.ts"
+import * as Context from "../../../Context.ts"
 import * as Duration from "../../../Duration.ts"
 import type { Input } from "../../../Duration.ts"
 import * as Effect from "../../../Effect.ts"
@@ -16,7 +17,6 @@ import * as Schedule from "../../../Schedule.ts"
 import * as Schema from "../../../Schema.ts"
 import * as Issue from "../../../SchemaIssue.ts"
 import * as Scope from "../../../Scope.ts"
-import * as ServiceMap from "../../../ServiceMap.ts"
 import type * as Rpc from "../../rpc/Rpc.ts"
 import { RequestId } from "../../rpc/RpcMessage.ts"
 import * as RpcServer from "../../rpc/RpcServer.ts"
@@ -107,10 +107,11 @@ export const make = Effect.fnUntraced(function*<
   const storageEnabled = options.storage !== MessageStorage.noop
   const mailboxCapacity = options.mailboxCapacity ?? config.entityMailboxCapacity
   const clock = yield* Clock
-  const services = yield* Effect.services<Rpc.Services<Rpcs> | Rpc.Middleware<Rpcs> | RX>()
-  const retryDriver = yield* Schedule.toStepWithSleep(
-    options.defectRetryPolicy ? Schedule.andThen(options.defectRetryPolicy, defaultRetryPolicy) : defaultRetryPolicy
-  )
+  const context = yield* Effect.context<Rpc.Services<Rpcs> | Rpc.Middleware<Rpcs> | RX>()
+  const defectRetryPolicy = options.defectRetryPolicy
+    ? Schedule.andThen(options.defectRetryPolicy, defaultRetryPolicy)
+    : defaultRetryPolicy
+  const retryDriver = yield* Schedule.toStepWithSleep(defectRetryPolicy)
   const entityRpcs = new Map(entity.protocol.requests)
 
   // add internal rpcs
@@ -156,14 +157,17 @@ export const make = Effect.fnUntraced(function*<
         // Initiate the behavior for the entity
         const handlers = yield* (entity.protocol.toHandlers(buildHandlers as any).pipe(
           Effect.provideService(CurrentLogAnnotations, {}),
-          Effect.provideServices(ServiceMap.mutate(services, (services) =>
-            services.pipe(
-              ServiceMap.add(CurrentAddress, address),
-              ServiceMap.add(CurrentRunnerAddress, options.runnerAddress),
-              ServiceMap.add(KeepAliveLatch, keepAliveLatch),
-              ServiceMap.add(Scope.Scope, scope)
-            )))
-        ) as Effect.Effect<ServiceMap.ServiceMap<Rpc.ToHandler<Rpcs>>>)
+          Effect.provideContext(Context.mutate(context, (context) =>
+            context.pipe(
+              Context.add(CurrentAddress, address),
+              Context.add(CurrentRunnerAddress, options.runnerAddress),
+              Context.add(KeepAliveLatch, keepAliveLatch),
+              Context.add(Scope.Scope, scope)
+            ))),
+          Effect.sandbox,
+          Effect.tapError((cause) => Effect.logError("Defect building entity handlers", cause)),
+          Effect.retry(defectRetryPolicy)
+        ) as Effect.Effect<Context.Context<Rpc.ToHandler<Rpcs>>>)
 
         const server = yield* RpcServer.makeNoSerialization(entity.protocol, {
           spanPrefix: `${entity.type}(${address.entityId})`,
@@ -188,7 +192,7 @@ export const make = Effect.fnUntraced(function*<
                 // interrupt.
                 if (
                   storageEnabled &&
-                  ServiceMap.get(request.message.annotations, Persisted) &&
+                  Context.get(request.message.annotations, Persisted) &&
                   Exit.hasInterrupts(response.exit) &&
                   (isShuttingDown || isUninterruptibleForServer(request.message.annotations))
                 ) {
@@ -267,7 +271,7 @@ export const make = Effect.fnUntraced(function*<
           }
         }).pipe(
           Scope.provide(scope),
-          Effect.provideServices(handlers)
+          Effect.provideContext(handlers)
         )
 
         yield* Scope.addFinalizer(
@@ -364,7 +368,7 @@ export const make = Effect.fnUntraced(function*<
   }
 
   // update metrics for active servers
-  const typeAttributes = Metric.CurrentMetricAttributes.serviceMap({ type: entity.type })
+  const typeAttributes = Metric.CurrentMetricAttributes.context({ type: entity.type })
   yield* Effect.sync(() => {
     ClusterMetrics.entities.updateUnsafe(BigInt(activeServers.size), typeAttributes)
   }).pipe(
@@ -396,7 +400,7 @@ export const make = Effect.fnUntraced(function*<
               }
 
               const rpc = entityRpcs.get(message.envelope.tag)! as any as Rpc.AnyWithProps
-              if (!storageEnabled && ServiceMap.get(message.annotations, Persisted)) {
+              if (!storageEnabled && Context.get(message.annotations, Persisted)) {
                 return Effect.die(
                   "EntityManager.sendLocal: Cannot process a persisted message without MessageStorage"
                 )
@@ -460,7 +464,7 @@ export const make = Effect.fnUntraced(function*<
                   )
                 })
               })
-              if (ServiceMap.get(message.annotations, WithTransaction)) {
+              if (Context.get(message.annotations, WithTransaction)) {
                 write = options.storage.withTransaction(write)
               }
               return write
@@ -497,7 +501,7 @@ export const make = Effect.fnUntraced(function*<
 
   const decodeMessage = makeMessageDecode(entity, entityRpcs)
 
-  const runFork = Effect.runForkWith(services)
+  const runFork = Effect.runForkWith(context)
 
   return identity<EntityManager>({
     interruptShard: (shardId: ShardId) =>
@@ -549,7 +553,7 @@ export const make = Effect.fnUntraced(function*<
                   exit: Exit.die(new MalformedMessage({ cause }))
                 }),
                 rpc: entityRpcs.get(message.envelope.tag)!,
-                services: services as any
+                context: context as any
               })
             ))
           },
@@ -563,7 +567,7 @@ export const make = Effect.fnUntraced(function*<
             const rpc = entityRpcs.get(decoded.envelope.tag)!
             return sendLocal(
               new Message.IncomingRequestLocal({
-                annotations: ServiceMap.get(rpc.annotations, ClusterSchema.Dynamic)(
+                annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
                   rpc.annotations,
                   decoded.envelope as any
                 ),
@@ -574,14 +578,14 @@ export const make = Effect.fnUntraced(function*<
                     new Reply.ReplyWithContext({
                       reply,
                       rpc,
-                      services: services as any
+                      context: context as any
                     })
                   )
               })
             )
           }
         }),
-        Effect.provideServices(services as ServiceMap.ServiceMap<unknown>)
+        Effect.provideContext(context as Context.Context<unknown>)
       ),
     activeEntityCount: Effect.sync(() => activeServers.size)
   })

package/src/unstable/cluster/internal/entityReaper.ts

@@ -1,8 +1,8 @@
 import { Clock } from "../../../Clock.ts"
+import * as Context from "../../../Context.ts"
 import * as Effect from "../../../Effect.ts"
 import * as Latch from "../../../Latch.ts"
 import * as Layer from "../../../Layer.ts"
-import * as ServiceMap from "../../../ServiceMap.ts"
 import type { EntityNotAssignedToRunner } from "../ClusterError.ts"
 import type { EntityAddress } from "../EntityAddress.ts"
 import type { EntityId } from "../EntityId.ts"
@@ -10,7 +10,7 @@ import type { EntityState } from "./entityManager.ts"
 import type { ResourceMap } from "./resourceMap.ts"
 
 /** @internal */
-export class EntityReaper extends ServiceMap.Service<EntityReaper>()("effect/cluster/EntityReaper", {
+export class EntityReaper extends Context.Service<EntityReaper>()("effect/cluster/EntityReaper", {
   make: Effect.gen(function*() {
     let currentResolution = 30_000
     const registered: Array<{

package/src/unstable/cluster/internal/resourceMap.ts

@@ -1,3 +1,4 @@
+import * as Context from "../../../Context.ts"
 import * as Deferred from "../../../Deferred.ts"
 import * as Effect from "../../../Effect.ts"
 import * as Exit from "../../../Exit.ts"
@@ -5,7 +6,6 @@ import * as MutableHashMap from "../../../MutableHashMap.ts"
 import * as MutableRef from "../../../MutableRef.ts"
 import * as Option from "../../../Option.ts"
 import * as Scope from "../../../Scope.ts"
-import * as ServiceMap from "../../../ServiceMap.ts"
 
 /** @internal */
 export class ResourceMap<K, A, E> {
@@ -30,7 +30,7 @@ export class ResourceMap<K, A, E> {
 
   static make = Effect.fnUntraced(function*<K, A, E, R>(lookup: (key: K) => Effect.Effect<A, E, R>) {
     const scope = yield* Effect.scope
-    const services = yield* Effect.services<R>()
+    const services = yield* Effect.context<R>()
     const isClosed = MutableRef.make(false)
 
     const entries = MutableHashMap.empty<K, {
@@ -50,7 +50,7 @@ export class ResourceMap<K, A, E> {
     )
 
     return new ResourceMap(
-      (key, scope) => Effect.provide(lookup(key), ServiceMap.add(services, Scope.Scope, scope)),
+      (key, scope) => Effect.provide(lookup(key), Context.add(services, Scope.Scope, scope)),
       entries,
       isClosed
     )

package/src/unstable/devtools/DevToolsClient.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Deferred from "../../Deferred.ts"
 import * as Effect from "../../Effect.ts"
 import * as Fiber from "../../Fiber.ts"
@@ -10,7 +11,6 @@ import * as Metric from "../../Metric.ts"
 import * as Queue from "../../Queue.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as Tracer from "../../Tracer.ts"
 import * as Ndjson from "../encoding/Ndjson.ts"
@@ -24,7 +24,7 @@ const ResponseSchema = Schema.toCodecJson(DevToolsSchema.Response)
  * @since 4.0.0
  * @category tags
  */
-export class DevToolsClient extends ServiceMap.Service<
+export class DevToolsClient extends Context.Service<
   DevToolsClient,
   {
     readonly sendUnsafe: (
@@ -35,7 +35,7 @@ export class DevToolsClient extends ServiceMap.Service<
 
 const makeEffect = Effect.gen(function*() {
   const socket = yield* Socket.Socket
-  const services = yield* Effect.services<never>()
+  const services = yield* Effect.context<never>()
   const requests = yield* Queue.unbounded<DevToolsSchema.Request>()
   const connected = yield* Deferred.make<void>()
 
@@ -96,10 +96,10 @@ const makeEffect = Effect.gen(function*() {
 })
 
 const toMetricsSnapshot = (
-  services: ServiceMap.ServiceMap<never>
+  context: Context.Context<never>
 ): DevToolsSchema.MetricsSnapshot => ({
   _tag: "MetricsSnapshot",
-  metrics: Metric.snapshotUnsafe(services)
+  metrics: Metric.snapshotUnsafe(context)
 })
 
 /**

package/src/unstable/eventlog/EventJournal.ts

@@ -3,6 +3,7 @@
  */
 import * as Uuid from "uuid"
 import type { Brand } from "../../Brand.ts"
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as DateTime from "../../DateTime.ts"
 import * as Effect from "../../Effect.ts"
@@ -10,14 +11,13 @@ import * as Layer from "../../Layer.ts"
 import * as PubSub from "../../PubSub.ts"
 import * as Schema from "../../Schema.ts"
 import type { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Msgpack from "../encoding/Msgpack.ts"
 
 /**
  * @since 4.0.0
  * @category context
  */
-export class EventJournal extends ServiceMap.Service<EventJournal, {
+export class EventJournal extends Context.Service<EventJournal, {
   /**
    * Read all the entries in the journal.
    */

package/src/unstable/eventlog/EventLog.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as FiberMap from "../../FiberMap.ts"
 import { identity } from "../../Function.ts"
@@ -15,7 +16,6 @@ import * as Redacted from "../../Redacted.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
 import * as Semaphore from "../../Semaphore.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { Covariant } from "../../Types.ts"
 import { Reactivity } from "../reactivity/Reactivity.ts"
 import * as ReactivityLayer from "../reactivity/Reactivity.ts"
@@ -100,7 +100,7 @@ export interface Handlers<
   }
   readonly group: EventGroup.AnyWithProps
   readonly handlers: Record.ReadonlyRecord<string, Handlers.Item<R>>
-  readonly services: ServiceMap.ServiceMap<R>
+  readonly context: Context.Context<R>
 
   /**
    * Add the implementation for an `Event` to a `Handlers` group.
@@ -142,7 +142,7 @@ export declare namespace Handlers {
    */
   export type Item<R> = {
     readonly event: Event.AnyWithProps
-    readonly services: ServiceMap.ServiceMap<R>
+    readonly context: Context.Context<R>
     readonly handler: (options: {
       readonly payload: unknown
       readonly entry: Entry
@@ -211,7 +211,7 @@ export declare namespace Handlers {
  * @since 4.0.0
  * @category models
  */
-export class Identity extends ServiceMap.Service<Identity, {
+export class Identity extends Context.Service<Identity, {
   readonly publicKey: string
   readonly privateKey: Redacted.Redacted<Uint8Array>
 }>()("effect/eventlog/EventLog/Identity") {}
@@ -274,12 +274,12 @@ const handlersProto = {
   ): Handlers<any, any> {
     return makeHandlers({
       group: this.group,
-      services: this.services,
+      context: this.context,
       handlers: {
         ...this.handlers,
         [tag]: {
           event: this.group.events[tag],
-          services: this.services,
+          context: this.context,
           handler
         }
       }
@@ -293,7 +293,7 @@ const handlersProto = {
 const makeHandlers = (options: {
   readonly group: EventGroup.AnyWithProps
   readonly handlers: Record.ReadonlyRecord<string, Handlers.Item<any>>
-  readonly services: ServiceMap.ServiceMap<any>
+  readonly context: Context.Context<any>
 }): Handlers<any, any> => Object.assign(Object.create(handlersProto), options)
 
 /**
@@ -304,23 +304,23 @@ export const group = <Events extends Event.Any, Return>(
   group: EventGroup.EventGroup<Events>,
   f: (handlers: Handlers<never, Events>) => Handlers.ValidateReturn<Return>
 ): Layer.Layer<Event.ToService<Events>, Handlers.Error<Return>, Exclude<Handlers.Services<Return>, Scope.Scope>> =>
-  Layer.effectServices(
+  Layer.effectContext(
     Effect.gen(function*() {
-      const services = yield* Effect.services<Handlers.Services<Return>>()
+      const context = yield* Effect.context<Handlers.Services<Return>>()
       const result = f(makeHandlers({
         group: group as EventGroup.AnyWithProps,
         handlers: {},
-        services
+        context
       }) as unknown as Handlers<never, Events>)
       const handlers = Effect.isEffect(result)
         ? (yield* (result as unknown as Effect.Effect<Handlers<any>>))
         : (result as unknown as Handlers<any>)
-      const serviceMap = new Map<string, Handlers.Item<any>>()
+      const contextMap = new Map<string, Handlers.Item<any>>()
       for (const tag in handlers.handlers) {
         const handler = handlers.handlers[tag]
-        serviceMap.set(handler.event.key, handlers.handlers[tag])
+        contextMap.set(handler.event.key, handlers.handlers[tag])
       }
-      return ServiceMap.makeUnsafe(serviceMap)
+      return Context.makeUnsafe(contextMap)
     })
   )
 
@@ -343,7 +343,7 @@ export const groupCompaction = <Events extends Event.Any, R>(
   Layer.effectDiscard(
     Effect.gen(function*() {
       const log = yield* EventLog
-      const services = yield* Effect.services<R | Event.PayloadSchema<Events>["DecodingServices"]>()
+      const services = yield* Effect.context<R | Event.PayloadSchema<Events>["DecodingServices"]>()
 
       yield* log.registerCompaction({
         events: Object.keys(group.events),
@@ -351,7 +351,7 @@ export const groupCompaction = <Events extends Event.Any, R>(
           const isEventTag = (tag: string): tag is Event.Tag<Events> => tag in group.events
           const decodePayload = <Tag extends Event.Tag<Events>>(tag: Tag, payload: Uint8Array) =>
             Schema.decodeUnknownEffect(group.events[tag].payloadMsgPack)(payload).pipe(
-              Effect.updateServices((input) => ServiceMap.merge(services, input)),
+              Effect.updateContext((input) => Context.merge(services, input)),
               Effect.orDie
             ) as unknown as Effect.Effect<Event.PayloadWithTag<Events, Tag>>
           const writePayload = Effect.fnUntraced(function*<Tag extends Event.Tag<Events>>(
@@ -406,7 +406,7 @@ export const groupCompaction = <Events extends Event.Any, R>(
                   return Effect.orDie(writePayload(entries[0].createdAtMillis, tag, payload))
                 }
               }).pipe(
-                Effect.updateServices((input) => ServiceMap.merge(services, input))
+                Effect.updateContext((input) => Context.merge(services, input))
               )
             ) as any
           }
@@ -447,7 +447,7 @@ export const groupReactivity = <Events extends Event.Any>(
  * @since 4.0.0
  * @category tags
  */
-export class EventLog extends ServiceMap.Service<EventLog, {
+export class EventLog extends Context.Service<EventLog, {
   readonly write: <Groups extends EventGroup.Any, Tag extends Event.Tag<EventGroup.Events<Groups>>>(options: {
     readonly schema: EventLogSchema<Groups>
     readonly event: Tag
@@ -472,7 +472,7 @@ export class EventLog extends ServiceMap.Service<EventLog, {
 const make = Effect.gen(function*() {
   const identity = yield* Identity
   const journal = yield* EventJournal
-  const services = yield* Effect.services<never>()
+  const services = yield* Effect.context<never>()
 
   const remotes = yield* FiberMap.make<RemoteId>()
   const compactors = new Map<string, {
@@ -558,7 +558,7 @@ const make = Effect.gen(function*() {
                   decodedConflicts[i] = {
                     entry: conflicts[i],
                     payload: yield* decodePayload(conflicts[i].payload).pipe(
-                      Effect.updateServices((input) => ServiceMap.merge(handler.services, input))
+                      Effect.updateContext((input) => Context.merge(handler.context, input))
                     ) as any
                   }
                 }
@@ -570,7 +570,7 @@ const make = Effect.gen(function*() {
                       conflicts: decodedConflicts
                     })
                   ),
-                  Effect.updateServices((input) => ServiceMap.merge(handler.services, input)),
+                  Effect.updateContext((input) => Context.merge(handler.context, input)),
                   Effect.asVoid
                 ) as any
                 if (reactivityKeys[entry.event]) {
@@ -636,7 +636,7 @@ const make = Effect.gen(function*() {
           entry,
           conflicts: []
         }).pipe(
-          Effect.updateServices((input) => ServiceMap.merge(handler.services, input)),
+          Effect.updateContext((input) => Context.merge(handler.context, input)),
           Effect.tap(() =>
             Effect.sync(() => {
               if (reactivityKeys[entry.event]) {

package/src/unstable/eventlog/EventLogEncryption.ts

@@ -1,11 +1,11 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Redacted from "../../Redacted.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import { Entry, EntryId, RemoteEntry } from "./EventJournal.ts"
 import type { Identity } from "./EventLog.ts"
 
@@ -47,7 +47,7 @@ const toBufferSource = (data: Uint8Array): ArrayBufferView<ArrayBuffer> => new U
  * @since 4.0.0
  * @category services
  */
-export class EventLogEncryption extends ServiceMap.Service<EventLogEncryption, {
+export class EventLogEncryption extends Context.Service<EventLogEncryption, {
   readonly encrypt: (
     identity: Identity["Service"],
     entries: ReadonlyArray<Entry>

package/src/unstable/eventlog/EventLogRemote.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Deferred from "../../Deferred.ts"
 import * as Effect from "../../Effect.ts"
@@ -11,7 +12,6 @@ import * as RcMap from "../../RcMap.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Msgpack from "../encoding/Msgpack.ts"
 import * as Socket from "../socket/Socket.ts"
 import { type Entry, EntryId, RemoteEntry, RemoteId } from "./EventJournal.ts"
@@ -22,7 +22,7 @@ import { EncryptedEntry, EncryptedRemoteEntry, EventLogEncryption, layerSubtle }
  * @since 4.0.0
  * @category models
  */
-export class EventLogRemote extends ServiceMap.Service<EventLogRemote, {
+export class EventLogRemote extends Context.Service<EventLogRemote, {
   readonly id: RemoteId
   readonly changes: (
     identity: Identity["Service"],

package/src/unstable/eventlog/EventLogServer.ts

@@ -3,6 +3,7 @@
  */
 import * as Uuid from "uuid"
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as FiberMap from "../../FiberMap.ts"
 import * as Layer from "../../Layer.ts"
@@ -11,7 +12,6 @@ import * as Queue from "../../Queue.ts"
 import * as RcMap from "../../RcMap.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as HttpServerError from "../http/HttpServerError.ts"
 import * as HttpServerRequest from "../http/HttpServerRequest.ts"
 import * as HttpServerResponse from "../http/HttpServerResponse.ts"
@@ -207,7 +207,7 @@ export class PersistedEntry extends Schema.Class<PersistedEntry>(
  * @since 4.0.0
  * @category storage
  */
-export class Storage extends ServiceMap.Service<Storage, {
+export class Storage extends Context.Service<Storage, {
   readonly getId: Effect.Effect<RemoteId>
   readonly write: (
     publicKey: string,

package/src/unstable/http/Etag.ts

@@ -1,11 +1,11 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Body from "./HttpBody.ts"
 
 /**
@@ -49,7 +49,7 @@ export const toString = (self: Etag): string => {
  * @since 4.0.0
  * @category models
  */
-export class Generator extends ServiceMap.Service<Generator, {
+export class Generator extends Context.Service<Generator, {
   readonly fromFileInfo: (info: FileSystem.File.Info) => Effect.Effect<Etag>
   readonly fromFileWeb: (file: Body.HttpBody.FileLike) => Effect.Effect<Etag>
 }>()("effect/http/Etag/Generator") {}

package/src/unstable/http/FetchHttpClient.ts

@@ -1,9 +1,9 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Layer from "../../Layer.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as Headers from "./Headers.ts"
 import * as HttpClient from "./HttpClient.ts"
@@ -14,7 +14,7 @@ import * as HttpClientResponse from "./HttpClientResponse.ts"
  * @since 4.0.0
  * @category tags
  */
-export const Fetch = ServiceMap.Reference<typeof globalThis.fetch>("effect/http/FetchHttpClient/Fetch", {
+export const Fetch = Context.Reference<typeof globalThis.fetch>("effect/http/FetchHttpClient/Fetch", {
   defaultValue: () => globalThis.fetch
 })
 
@@ -22,13 +22,13 @@ export const Fetch = ServiceMap.Reference<typeof globalThis.fetch>("effect/http/
  * @since 4.0.0
  * @category tags
  */
-export class RequestInit extends ServiceMap.Service<RequestInit, globalThis.RequestInit>()(
+export class RequestInit extends Context.Service<RequestInit, globalThis.RequestInit>()(
   "effect/http/FetchHttpClient/RequestInit"
 ) {}
 
 const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fiber) => {
   const fetch = fiber.getRef(Fetch)
-  const options: globalThis.RequestInit = fiber.services.mapUnsafe.get(RequestInit.key) ?? {}
+  const options: globalThis.RequestInit = fiber.context.mapUnsafe.get(RequestInit.key) ?? {}
   const headers = options.headers ? Headers.merge(Headers.fromInput(options.headers), request.headers) : request.headers
   const send = (body: BodyInit | undefined) =>
     Effect.map(
@@ -68,4 +68,4 @@ const fetch: HttpClient.HttpClient = HttpClient.make((request, url, signal, fibe
  * @since 4.0.0
  * @category layers
  */
-export const layer: Layer.Layer<HttpClient.HttpClient> = HttpClient.layerMergedServices(Effect.succeed(fetch))
+export const layer: Layer.Layer<HttpClient.HttpClient> = HttpClient.layerMergedContext(Effect.succeed(fetch))

package/src/unstable/http/Headers.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Equal from "../../Equal.ts"
 import * as Equ from "../../Equivalence.ts"
 import { dual } from "../../Function.ts"
@@ -13,7 +14,6 @@ import * as Redactable from "../../Redactable.ts"
 import * as Redacted from "../../Redacted.ts"
 import * as Schema from "../../Schema.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { Mutable } from "../../Types.ts"
 
 /**
@@ -52,8 +52,8 @@ Object.defineProperties(Proto, {
     value: TypeId
   },
   [Redactable.symbolRedactable]: {
-    value(this: Headers, context: ServiceMap.ServiceMap<never>): Record<string, string | Redacted.Redacted<string>> {
-      return redact(this, ServiceMap.get(context, CurrentRedactedNames))
+    value(this: Headers, context: Context.Context<never>): Record<string, string | Redacted.Redacted<string>> {
+      return redact(this, Context.get(context, CurrentRedactedNames))
     }
   },
   toJSON: {
@@ -438,7 +438,7 @@ export const redact: {
  * @since 4.0.0
  * @category fiber refs
  */
-export const CurrentRedactedNames = ServiceMap.Reference<
+export const CurrentRedactedNames = Context.Reference<
   ReadonlyArray<string | RegExp>
 >("effect/Headers/CurrentRedactedNames", {
   defaultValue: () => [