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

package/src/unstable/rpc/RpcGroup.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import { identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
@@ -9,7 +10,6 @@ import type { Pipeable } from "../../Pipeable.ts"
 import type * as Queue from "../../Queue.ts"
 import type * as Record from "../../Record.ts"
 import type { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type { Headers } from "../http/Headers.ts"
 import * as Rpc from "./Rpc.ts"
@@ -27,7 +27,7 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
 
   readonly [TypeId]: typeof TypeId
   readonly requests: ReadonlyMap<string, R>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 
   /**
    * Add one or more procedures to the group.
@@ -66,7 +66,7 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
       | Handlers
       | Effect.Effect<Handlers, EX, RX>
   ): Effect.Effect<
-    ServiceMap.ServiceMap<Rpc.ToHandler<R>>,
+    Context.Context<Rpc.ToHandler<R>>,
     EX,
     | RX
     | HandlersServices<R, Handlers>
@@ -119,7 +119,7 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
     (
       payload: Rpc.Payload<Extract<R, { readonly _tag: Tag }>>,
       options: {
-        readonly clientId: number
+        readonly client: Rpc.ServerClient
         readonly requestId: RequestId
         readonly headers: Headers
       }
@@ -131,22 +131,22 @@ export interface RpcGroup<in out R extends Rpc.Any> extends Pipeable {
   /**
    * Annotate the group with a value.
    */
-  annotate<I, S>(service: ServiceMap.Key<I, S>, value: S): RpcGroup<R>
+  annotate<I, S>(service: Context.Key<I, S>, value: S): RpcGroup<R>
 
   /**
    * Annotate the Rpc's above this point with a value.
    */
-  annotateRpcs<I, S>(service: ServiceMap.Key<I, S>, value: S): RpcGroup<R>
+  annotateRpcs<I, S>(service: Context.Key<I, S>, value: S): RpcGroup<R>
 
   /**
    * Annotate the group with the provided annotations.
    */
-  annotateMerge<S>(annotations: ServiceMap.ServiceMap<S>): RpcGroup<R>
+  annotateMerge<S>(annotations: Context.Context<S>): RpcGroup<R>
 
   /**
    * Annotate the Rpc's above this point with the provided annotations.
    */
-  annotateRpcsMerge<S>(annotations: ServiceMap.ServiceMap<S>): RpcGroup<R>
+  annotateRpcsMerge<S>(annotations: Context.Context<S>): RpcGroup<R>
 }
 
 /**
@@ -239,7 +239,7 @@ const RpcGroupProto = {
 
     return makeProto({
       requests,
-      annotations: ServiceMap.makeUnsafe(annotations)
+      annotations: Context.makeUnsafe(annotations)
     })
   },
   middleware(this: RpcGroup<any>, middleware: RpcMiddleware.AnyService) {
@@ -256,7 +256,7 @@ const RpcGroupProto = {
     // oxlint-disable-next-line no-this-alias
     const self = this
     return Effect.gen(function*() {
-      const services = yield* Effect.services<never>()
+      const services = yield* Effect.context<never>()
       const handlers = Effect.isEffect(build) ? yield* build : build
       const contextMap = new Map<string, unknown>()
       for (const [tag, handler] of Object.entries(handlers)) {
@@ -264,10 +264,10 @@ const RpcGroupProto = {
         contextMap.set(rpc.key, {
           tag: rpc._tag,
           handler,
-          services
+          context: services
         })
       }
-      return ServiceMap.makeUnsafe(contextMap)
+      return Context.makeUnsafe(contextMap)
     })
   },
   prefix<const Prefix extends string>(this: RpcGroup<any>, prefix: Prefix) {
@@ -282,57 +282,57 @@ const RpcGroupProto = {
     })
   },
   toLayer(this: RpcGroup<any>, build: Effect.Effect<Record<string, (request: any) => any>>) {
-    return Layer.effectServices(this.toHandlers(build))
+    return Layer.effectContext(this.toHandlers(build))
   },
   of: identity,
   toLayerHandler(this: RpcGroup<any>, service: string, build: Effect.Effect<Record<string, (request: any) => any>>) {
     // oxlint-disable-next-line no-this-alias
     const self = this
-    return Layer.effectServices(Effect.gen(function*() {
-      const services = yield* Effect.services<never>()
+    return Layer.effectContext(Effect.gen(function*() {
+      const services = yield* Effect.context<never>()
       const handler = Effect.isEffect(build) ? yield* build : build
       const contextMap = new Map<string, unknown>()
       const rpc = self.requests.get(service)!
       contextMap.set(rpc.key, {
         handler,
-        services
+        context: services
       })
-      return ServiceMap.makeUnsafe(contextMap)
+      return Context.makeUnsafe(contextMap)
     }))
   },
   accessHandler(this: RpcGroup<any>, service: string) {
-    return Effect.servicesWith((parentServices: ServiceMap.ServiceMap<any>) => {
+    return Effect.contextWith((parentContext: Context.Context<any>) => {
       const rpc = this.requests.get(service)!
-      const { handler, services } = parentServices.mapUnsafe.get(rpc.key) as Rpc.Handler<any>
+      const { handler, context } = parentContext.mapUnsafe.get(rpc.key) as Rpc.Handler<any>
       return Effect.succeed((payload: Rpc.Payload<any>, options: any) => {
         options.rpc = rpc
         const result = handler(payload, options)
         const effectOrStream = Rpc.isWrapper(result) ? result.value : result
         return Effect.isEffect(effectOrStream)
-          ? Effect.provide(effectOrStream, services)
-          : Stream.provideServices(effectOrStream, services)
+          ? Effect.provide(effectOrStream, context)
+          : Stream.provideContext(effectOrStream, context)
       })
     })
   },
-  annotate(this: RpcGroup<any>, service: ServiceMap.Key<any, any>, value: any) {
+  annotate(this: RpcGroup<any>, service: Context.Key<any, any>, value: any) {
     return makeProto({
       requests: this.requests,
-      annotations: ServiceMap.add(this.annotations, service, value)
+      annotations: Context.add(this.annotations, service, value)
     })
   },
-  annotateRpcs(this: RpcGroup<any>, service: ServiceMap.Key<any, any>, value: any) {
-    return this.annotateRpcsMerge(ServiceMap.make(service, value))
+  annotateRpcs(this: RpcGroup<any>, service: Context.Key<any, any>, value: any) {
+    return this.annotateRpcsMerge(Context.make(service, value))
   },
-  annotateMerge(this: RpcGroup<any>, context: ServiceMap.ServiceMap<any>) {
+  annotateMerge(this: RpcGroup<any>, context: Context.Context<any>) {
     return makeProto({
       requests: this.requests,
-      annotations: ServiceMap.merge(this.annotations, context)
+      annotations: Context.merge(this.annotations, context)
     })
   },
-  annotateRpcsMerge(this: RpcGroup<any>, serviceMap: ServiceMap.ServiceMap<any>) {
+  annotateRpcsMerge(this: RpcGroup<any>, context: Context.Context<any>) {
     const requests = new Map<string, any>()
     for (const [tag, rpc] of this.requests) {
-      requests.set(tag, rpc.annotateMerge(ServiceMap.merge(serviceMap, rpc.annotations)))
+      requests.set(tag, rpc.annotateMerge(Context.merge(context, rpc.annotations)))
     }
     return makeProto({
       requests,
@@ -343,7 +343,7 @@ const RpcGroupProto = {
 
 const makeProto = <Rpcs extends Rpc.Any>(options: {
   readonly requests: ReadonlyMap<string, Rpcs>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 }): RpcGroup<Rpcs> =>
   Object.assign(function() {}, RpcGroupProto, {
     requests: options.requests,
@@ -359,5 +359,5 @@ export const make = <const Rpcs extends ReadonlyArray<Rpc.Any>>(
 ): RpcGroup<Rpcs[number]> =>
   makeProto({
     requests: new Map(rpcs.map((rpc) => [rpc._tag, rpc])),
-    annotations: ServiceMap.empty()
+    annotations: Context.empty()
   })

package/src/unstable/rpc/RpcMiddleware.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 Schema from "../../Schema.ts"
 import { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { Mutable, unhandled } from "../../Types.ts"
 import type { Headers } from "../http/Headers.ts"
 import type * as Rpc from "./Rpc.ts"
@@ -31,7 +31,7 @@ export interface RpcMiddleware<Provides, E, Requires> {
   (
     effect: Effect.Effect<SuccessValue, E | unhandled, Provides>,
     options: {
-      readonly clientId: number
+      readonly client: Rpc.ServerClient
       readonly requestId: RequestId
       readonly rpc: Rpc.AnyWithProps
       readonly payload: unknown
@@ -77,7 +77,7 @@ export interface Any {
   (
     effect: Effect.Effect<SuccessValue, any, any>,
     options: {
-      readonly clientId: number
+      readonly client: Rpc.ServerClient
       readonly requestId: RequestId
       readonly rpc: Rpc.AnyWithProps
       readonly payload: unknown
@@ -111,8 +111,8 @@ export interface ServiceClass<
   ClientError,
   Requires,
   RequiredForClient extends boolean
-> extends ServiceMap.Service<Self, RpcMiddleware<Provides, E["Type"], Requires>> {
-  new(_: never): ServiceMap.ServiceClass.Shape<Name, RpcMiddleware<Provides, E["Type"], Requires>> & {
+> extends Context.Service<Self, RpcMiddleware<Provides, E["Type"], Requires>> {
+  new(_: never): Context.ServiceClass.Shape<Name, RpcMiddleware<Provides, E["Type"], Requires>> & {
     readonly [TypeId]: {
       readonly error: E
       readonly provides: Provides
@@ -174,7 +174,7 @@ export type ErrorServicesDecode<A> = ErrorSchema<A>["DecodingServices"]
  * @since 4.0.0
  * @category models
  */
-export interface AnyService extends ServiceMap.Key<any, any> {
+export interface AnyService extends Context.Key<any, any> {
   readonly [TypeId]: typeof TypeId
   readonly error: Schema.Top
   readonly requiredForClient: boolean
@@ -185,7 +185,7 @@ export interface AnyService extends ServiceMap.Key<any, any> {
  * @since 4.0.0
  * @category models
  */
-export interface AnyServiceWithProps extends ServiceMap.Key<any, RpcMiddleware<any, any, any>> {
+export interface AnyServiceWithProps extends Context.Key<any, RpcMiddleware<any, any, any>> {
   readonly [TypeId]: typeof TypeId
   readonly error: Schema.Top
   readonly requiredForClient: boolean
@@ -241,7 +241,7 @@ export const Service = <
 
   function ServiceClass() {}
   const ServiceClass_ = ServiceClass as any as Mutable<AnyService>
-  Object.setPrototypeOf(ServiceClass, Object.getPrototypeOf(ServiceMap.Service<Self, any>(id)))
+  Object.setPrototypeOf(ServiceClass, Object.getPrototypeOf(Context.Service<Self, any>(id)))
   ServiceClass.key = id
   Object.defineProperty(ServiceClass, "stack", {
     get() {
@@ -259,23 +259,23 @@ export const Service = <
  * @category client
  */
 export const layerClient = <Id extends AnyId, S, R, EX = never, RX = never>(
-  tag: ServiceMap.Key<Id, S>,
+  tag: Context.Key<Id, S>,
   service:
     | RpcMiddlewareClient<Id[TypeId]["error"]["Type"], Id[TypeId]["clientError"], R>
     | Effect.Effect<RpcMiddlewareClient<Id[TypeId]["error"]["Type"], Id[TypeId]["clientError"], R>, EX, RX>
 ): Layer.Layer<ForClient<Id>, EX, R | Exclude<RX, Scope>> =>
-  Layer.effectServices(Effect.gen(function*() {
-    const services = (yield* Effect.services<R | Scope>()).pipe(
-      ServiceMap.omit(Scope)
-    ) as ServiceMap.ServiceMap<R>
+  Layer.effectContext(Effect.gen(function*() {
+    const services = (yield* Effect.context<R | Scope>()).pipe(
+      Context.omit(Scope)
+    ) as Context.Context<R>
     const middleware = Effect.isEffect(service) ? yield* service : service
-    return ServiceMap.makeUnsafe(
+    return Context.makeUnsafe(
       new Map([[
         `${tag.key}/Client`,
         (options: any) =>
-          Effect.updateServices(
+          Effect.updateContext(
             middleware(options),
-            (requestContext) => ServiceMap.merge(services, requestContext)
+            (requestContext) => Context.merge(services, requestContext)
           )
       ]])
     )

package/src/unstable/rpc/RpcSchema.ts

@@ -2,12 +2,12 @@
  * @since 4.0.0
  */
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import { constUndefined } from "../../Function.ts"
 import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream_ from "../../Stream.ts"
 
 const StreamSchemaTypeId = "~effect/rpc/RpcSchema/StreamSchema"
@@ -67,9 +67,9 @@ export function Stream<A extends Schema.Top, E extends Schema.Top>(success: A, e
  * @since 4.0.0
  * @category Cause annotations
  */
-export class ClientAbort extends ServiceMap.Service<ClientAbort, true>()("effect/rpc/RpcSchema/ClientAbort") {
-  static annotation = this.serviceMap(true).pipe(
-    ServiceMap.add(Cause.StackTrace, {
+export class ClientAbort extends Context.Service<ClientAbort, true>()("effect/rpc/RpcSchema/ClientAbort") {
+  static annotation = this.context(true).pipe(
+    Context.add(Cause.StackTrace, {
       name: "ClientAbort",
       stack: constUndefined,
       parent: undefined

package/src/unstable/rpc/RpcSerialization.ts

@@ -2,17 +2,17 @@
  * @since 4.0.0
  */
 import * as Msgpackr from "msgpackr"
+import * as Context from "../../Context.ts"
 import * as Layer from "../../Layer.ts"
 import * as Predicate from "../../Predicate.ts"
 import { hasProperty } from "../../Predicate.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as RpcMessage from "./RpcMessage.ts"
 
 /**
  * @since 4.0.0
  * @category serialization
  */
-export class RpcSerialization extends ServiceMap.Service<RpcSerialization, {
+export class RpcSerialization extends Context.Service<RpcSerialization, {
   makeUnsafe(): Parser
   readonly contentType: string
   readonly includesFraming: boolean

package/src/unstable/rpc/RpcServer.ts

@@ -3,6 +3,7 @@
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 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 Exit from "../../Exit.ts"
@@ -19,7 +20,6 @@ import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
 import * as Semaphore from "../../Semaphore.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import { Stdio } from "../../Stdio.ts"
 import * as Stream from "../../Stream.ts"
 import * as Tracer from "../../Tracer.ts"
@@ -98,8 +98,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   const spanPrefix = options.spanPrefix ?? "RpcServer"
   const concurrency = options.concurrency ?? "unbounded"
   const disableFatalDefects = options.disableFatalDefects ?? false
-  const services = yield* Effect.services<Rpc.ToHandler<Rpcs> | Scope.Scope>()
-  const scope = ServiceMap.get(services, Scope.Scope)
+  const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Scope.Scope>()
+  const scope = Context.get(services, Scope.Scope)
   const trackFiber = Fiber.runIn(Scope.forkUnsafe(scope, "parallel"))
   const concurrencySemaphore = concurrency === "unbounded"
     ? undefined
@@ -109,6 +109,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     readonly id: number
     readonly latches: Map<RequestId, Latch.Latch>
     readonly fibers: Map<RequestId, Fiber.Fiber<unknown, any>>
+    readonly serverClient: Rpc.ServerClient
     ended: boolean
   }
 
@@ -157,7 +158,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
             id: clientId,
             latches: new Map(),
             fibers: new Map(),
-            ended: false
+            ended: false,
+            serverClient: new Rpc.ServerClient(clientId)
           }
           clients.set(clientId, client)
         } else if (client.ended) {
@@ -236,7 +238,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     const isStream = RpcSchema.isStreamSchema(rpc.successSchema)
     const metadata = {
       rpc,
-      clientId: client.id,
+      client: client.serverClient,
       requestId: request.id,
       headers: request.headers,
       payload: request.payload
@@ -278,7 +280,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       return close ? Effect.ensuring(write, close) : write
     })
     if (enableTracing) {
-      const parentSpan = requestFiber.services.mapUnsafe.get(
+      const parentSpan = requestFiber.context.mapUnsafe.get(
         Tracer.ParentSpan.key
       ) as Tracer.AnySpan | undefined
       effect = Effect.withSpan(effect, `${spanPrefix}.${request.tag}`, {
@@ -304,10 +306,10 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     if (!isFork && concurrencySemaphore) {
       effect = concurrencySemaphore.withPermits(1)(effect)
     }
-    const serviceMap = new Map(entry.services.mapUnsafe)
-    requestFiber.services.mapUnsafe.forEach((value, key) => serviceMap.set(key, value))
-    serviceMap.set(Scope.Scope.key, scope)
-    const runFork = Effect.runForkWith(ServiceMap.makeUnsafe(serviceMap))
+    const context = new Map(entry.context.mapUnsafe)
+    requestFiber.context.mapUnsafe.forEach((value, key) => context.set(key, value))
+    context.set(Scope.Scope.key, scope)
+    const runFork = Effect.runForkWith(Context.makeUnsafe(context))
     const fiber = trackFiber(
       runFork(
         effect,
@@ -406,18 +408,18 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
 })
 
 const applyMiddleware = <A, E, R>(
-  services: ServiceMap.ServiceMap<never>,
+  context: Context.Context<never>,
   handler: Effect.Effect<A, E, R>,
   options: {
     readonly rpc: Rpc.AnyWithProps
-    readonly clientId: number
+    readonly client: Rpc.ServerClient
     readonly requestId: RequestId
     readonly headers: Headers.Headers
     readonly payload: A
   }
 ) => {
   for (const service of options.rpc.middlewares) {
-    const middleware = ServiceMap.getUnsafe(services, service)
+    const middleware = Context.getUnsafe(context, service)
     handler = middleware(handler as any, options) as any
   }
 
@@ -465,7 +467,7 @@ export const make: <Rpcs extends Rpc.Any>(
     supportsSpanPropagation,
     supportsTransferables
   } = yield* Protocol
-  const services = yield* Effect.services<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
+  const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
   const scope = yield* Scope.make()
 
   const server = yield* makeNoSerialization(group, {
@@ -484,7 +486,7 @@ export const make: <Rpcs extends Rpc.Any>(
             response.requestId,
             schemas.encodeDefect,
             schemas.collector,
-            Effect.provideServices(schemas.encodeChunk(response.values), schemas.services),
+            Effect.provideContext(schemas.encodeChunk(response.values), schemas.context),
             (values) => ({ _tag: "Chunk", requestId: String(response.requestId), values })
           )
         }
@@ -497,7 +499,7 @@ export const make: <Rpcs extends Rpc.Any>(
             response.requestId,
             schemas.encodeDefect,
             schemas.collector,
-            Effect.provideServices(schemas.encodeExit(response.exit), schemas.services),
+            Effect.provideContext(schemas.encodeExit(response.exit), schemas.context),
             (exit) => ({ _tag: "Exit", requestId: String(response.requestId), exit })
           )
         }
@@ -533,7 +535,7 @@ export const make: <Rpcs extends Rpc.Any>(
     ) => Effect.Effect<NonEmptyReadonlyArray<unknown>, Schema.SchemaError>
     readonly encodeExit: (u: unknown) => Effect.Effect<ResponseExitEncoded["exit"], Schema.SchemaError>
     readonly encodeDefect: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>
-    readonly services: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
     readonly collector?: Transferable.Collector["Service"] | undefined
   }
 
@@ -552,7 +554,7 @@ export const make: <Rpcs extends Rpc.Any>(
         ) as any,
         encodeExit: Schema.encodeUnknownEffect(Schema.toCodecJson(Rpc.exitSchema(rpc as any))) as any,
         encodeDefect: Schema.encodeUnknownEffect(Schema.toCodecJson(rpc.defectSchema)) as any,
-        services: entry.services
+        context: entry.context
       }
       schemasCache.set(rpc, schemas)
     }
@@ -648,7 +650,7 @@ export const make: <Rpcs extends Rpc.Any>(
         }
         const schemas = getSchemas(rpc as any)
         return Effect.matchEffect(
-          Effect.provideServices(schemas.decode(request.payload), schemas.services),
+          Effect.provideContext(schemas.decode(request.payload), schemas.context),
           {
             onFailure: (error) => sendRequestDefect(client, requestId, schemas.encodeDefect, error.issue.toString()),
             onSuccess: (payload) => {
@@ -761,7 +763,7 @@ export const layerHttp = <Rpcs extends Rpc.Any>(options: {
  * @since 4.0.0
  * @category protocol
  */
-export class Protocol extends ServiceMap.Service<
+export class Protocol extends Context.Service<
   Protocol,
   {
     readonly run: (
@@ -920,8 +922,8 @@ export const makeProtocolWithHttpEffect: Effect.Effect<
     Scope.Scope | HttpServerRequest.HttpServerRequest
   > = Effect.gen(function*() {
     const fiber = Fiber.getCurrent()!
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest.HttpServerRequest)
-    const scope = ServiceMap.getUnsafe(fiber.services, Scope.Scope)
+    const request = Context.getUnsafe(fiber.context, HttpServerRequest.HttpServerRequest)
+    const scope = Context.getUnsafe(fiber.context, Scope.Scope)
     const requestHeaders = Object.entries(request.headers)
     const data = yield* Effect.orDie<string | Uint8Array, any, never>(
       isBinary ? Effect.map(request.arrayBuffer, (buf) => new Uint8Array(buf)) : request.text

package/src/unstable/rpc/RpcWorker.ts

@@ -2,10 +2,10 @@
  * @since 4.0.0
  */
 import type { NoSuchElementError } from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Transferable from "../workers/Transferable.ts"
 import type { Protocol } from "./RpcServer.ts"
 
@@ -13,7 +13,7 @@ import type { Protocol } from "./RpcServer.ts"
  * @since 4.0.0
  * @category initial message
  */
-export class InitialMessage extends ServiceMap.Service<
+export class InitialMessage extends Context.Service<
   InitialMessage,
   Effect.Effect<
     readonly [
@@ -38,7 +38,7 @@ export declare namespace InitialMessage {
   }
 }
 
-const ProtocolTag: typeof Protocol = ServiceMap.Service("@effect/rpc/RpcServer/Protocol") as any
+const ProtocolTag: typeof Protocol = Context.Service("@effect/rpc/RpcServer/Protocol") as any
 
 /**
  * @since 4.0.0
@@ -71,9 +71,9 @@ export const layerInitialMessage = <S extends Schema.Top, R2>(
   build: Effect.Effect<S["Type"], never, R2>
 ): Layer.Layer<InitialMessage, never, S["EncodingServices"] | R2> =>
   Layer.effect(InitialMessage)(
-    Effect.servicesWith((services: ServiceMap.ServiceMap<S["EncodingServices"] | R2>) =>
+    Effect.contextWith((context: Context.Context<S["EncodingServices"] | R2>) =>
       Effect.succeed(
-        Effect.provideServices(Effect.orDie(makeInitialMessage(schema, build)), services)
+        Effect.provideContext(Effect.orDie(makeInitialMessage(schema, build)), context)
       )
     )
   )

package/src/unstable/rpc/Utils.ts

@@ -1,9 +1,11 @@
 /**
  * @since 4.0.0
  */
+import type * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Semaphore from "../../Semaphore.ts"
-import type * as ServiceMap from "../../ServiceMap.ts"
+import type { Protocol } from "./RpcClient.ts"
+import type { FromServerEncoded } from "./RpcMessage.ts"
 
 /**
  * @since 4.0.0
@@ -16,9 +18,9 @@ export const withRun = <
 <EX, RX>(f: (write: Parameters<A["run"]>[0]) => Effect.Effect<Omit<A, "run">, EX, RX>): Effect.Effect<A, EX, RX> =>
   Effect.suspend(() => {
     const semaphore = Semaphore.makeUnsafe(1)
-    let buffer: Array<[Array<any>, ServiceMap.ServiceMap<never>]> = []
+    let buffer: Array<[Array<any>, Context.Context<never>]> = []
     let write = (...args: Array<any>): Effect.Effect<void> =>
-      Effect.servicesWith((context) => {
+      Effect.contextWith((context) => {
         buffer.push([args, context])
         return Effect.void
       })
@@ -30,7 +32,7 @@ export const withRun = <
           write = f
 
           for (const [args, context] of buffer) {
-            yield* Effect.provideServices(Effect.suspend(() => f(...args)), context)
+            yield* Effect.provideContext(Effect.suspend(() => f(...args)), context)
           }
           buffer = []
 
@@ -42,3 +44,60 @@ export const withRun = <
       }
     } as A))
   })
+
+/**
+ * @since 4.0.0
+ */
+export const withRunClient = <EX, RX>(
+  f: (
+    write: (clientId: number, response: FromServerEncoded) => Effect.Effect<void>,
+    clientIds: ReadonlySet<number>
+  ) => Effect.Effect<Omit<Protocol["Service"], "run">, EX, RX>
+): Effect.Effect<Protocol["Service"], EX, RX> =>
+  Effect.suspend(() => {
+    const clientIds = new Set<number>()
+    const clientBuffers = new Map<number, Array<[FromServerEncoded, Context.Context<never>]>>()
+    const clientWrites = new Map<number, (data: FromServerEncoded) => Effect.Effect<void>>()
+    let write = (clientId: number, data: FromServerEncoded): Effect.Effect<void> =>
+      Effect.contextWith((context) => {
+        let buffer = clientBuffers.get(clientId)
+        if (!buffer) {
+          buffer = []
+          clientBuffers.set(clientId, buffer)
+        }
+        buffer.push([data, context])
+        return Effect.void
+      })
+    return Effect.map(
+      f((clientId, data) => {
+        const clientWrite = clientWrites.get(clientId)
+        if (clientWrite) {
+          return clientWrite(data)
+        }
+        return write(clientId, data)
+      }, clientIds),
+      (a) => ({
+        ...a,
+        run(clientId, f) {
+          return Effect.gen(function*() {
+            clientIds.add(clientId)
+            clientWrites.set(clientId, f)
+
+            const buffer = clientBuffers.get(clientId)
+            if (buffer) {
+              clientBuffers.delete(clientId)
+              for (const [args, context] of buffer) {
+                yield* Effect.provideContext(Effect.suspend(() => f(args)), context)
+              }
+            }
+
+            return yield* Effect.onExit(Effect.never, () => {
+              clientIds.delete(clientId)
+              clientWrites.delete(clientId)
+              return Effect.void
+            })
+          })
+        }
+      } satisfies Protocol["Service"])
+    )
+  })