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

package/src/unstable/cluster/Entity.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
@@ -17,12 +18,12 @@ import * as Predicate from "../../Predicate.ts"
 import * as Queue from "../../Queue.ts"
 import type * as Schedule from "../../Schedule.ts"
 import { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
-import type * as Stream from "../../Stream.ts"
+import * as Stream from "../../Stream.ts"
 import * as Headers from "../http/Headers.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import * as RpcClient from "../rpc/RpcClient.ts"
 import * as RpcGroup from "../rpc/RpcGroup.ts"
+import * as RpcSchema from "../rpc/RpcSchema.ts"
 import * as RpcServer from "../rpc/RpcServer.ts"
 import type { AlreadyProcessingMessage, MailboxFull, PersistenceError } from "./ClusterError.ts"
 import { Persisted, ShardGroup, Uninterruptible } from "./ClusterSchema.ts"
@@ -75,22 +76,22 @@ export interface Entity<
   /**
    * Annotate the entity with a value.
    */
-  annotate<I, S>(key: ServiceMap.Key<I, S>, value: S): Entity<Type, Rpcs>
+  annotate<I, S>(key: Context.Key<I, S>, value: S): Entity<Type, Rpcs>
 
   /**
    * Annotate the Rpc's above this point with a value.
    */
-  annotateRpcs<I, S>(key: ServiceMap.Key<I, S>, value: S): Entity<Type, Rpcs>
+  annotateRpcs<I, S>(key: Context.Key<I, S>, value: S): Entity<Type, Rpcs>
 
   /**
    * Annotate the entity with the given annotations.
    */
-  annotateMerge<S>(annotation: ServiceMap.ServiceMap<S>): Entity<Type, Rpcs>
+  annotateMerge<S>(annotation: Context.Context<S>): Entity<Type, Rpcs>
 
   /**
    * Annotate the Rpc's above this point with a context object.
    */
-  annotateRpcsMerge<S>(context: ServiceMap.ServiceMap<S>): Entity<Type, Rpcs>
+  annotateRpcsMerge<S>(context: Context.Context<S>): Entity<Type, Rpcs>
 
   /**
    * Create a client for this entity.
@@ -207,16 +208,16 @@ const Proto = {
   [Equal.symbol](this: Entity<string, any>, that: Equal.Equal): boolean {
     return isEntity(that) && this.type === that.type
   },
-  annotate<I, S>(this: Entity<string, any>, key: ServiceMap.Key<I, S>, value: S) {
+  annotate<I, S>(this: Entity<string, any>, key: Context.Key<I, S>, value: S) {
     return fromRpcGroup(this.type, this.protocol.annotate(key, value))
   },
-  annotateRpcs<I, S>(this: Entity<string, any>, key: ServiceMap.Key<I, S>, value: S) {
+  annotateRpcs<I, S>(this: Entity<string, any>, key: Context.Key<I, S>, value: S) {
     return fromRpcGroup(this.type, this.protocol.annotateRpcs(key, value))
   },
-  annotateMerge<S>(this: Entity<string, any>, annotations: ServiceMap.ServiceMap<S>) {
+  annotateMerge<S>(this: Entity<string, any>, annotations: Context.Context<S>) {
     return fromRpcGroup(this.type, this.protocol.annotateMerge(annotations))
   },
-  annotateRpcsMerge<S>(this: Entity<string, any>, annotations: ServiceMap.ServiceMap<S>) {
+  annotateRpcsMerge<S>(this: Entity<string, any>, annotations: Context.Context<S>) {
     return fromRpcGroup(this.type, this.protocol.annotateRpcsMerge(annotations))
   },
   getShardId(this: Entity<string, any>, entityId: EntityId) {
@@ -296,15 +297,25 @@ const Proto = {
       const queue = yield* Queue.make<Envelope.Request<Rpcs>>()
 
       // create the rpc handlers for the entity
-      const handler = (envelope: any) => {
-        return Effect.callback<any, any>((resume) => {
+      const handler = (envelope: any) =>
+        Effect.callback<any, any>((resume) => {
           Queue.offerUnsafe(queue, envelope)
           resumes.set(envelope, resume)
         })
-      }
+      const streamHandler = (envelope: any) =>
+        Effect.callback<any, any>((resume) => {
+          Queue.offerUnsafe(queue, envelope)
+          resumes.set(envelope, resume)
+        }).pipe(
+          Effect.map((streamOrQueue) =>
+            Stream.isStream(streamOrQueue) ? streamOrQueue : Stream.fromQueue(streamOrQueue)
+          ),
+          Stream.unwrap
+        )
       const handlers: Record<string, any> = {}
-      for (const rpc of this.protocol.requests.keys()) {
-        handlers[rpc] = handler
+      for (const rpc_ of this.protocol.requests.values()) {
+        const rpc = rpc_ as any as Rpc.AnyWithProps
+        handlers[rpc._tag] = RpcSchema.isStreamSchema(rpc.successSchema) ? streamHandler : handler
       }
 
       // make the Replier for the behaviour
@@ -366,9 +377,9 @@ export const fromRpcGroup = <const Type extends string, Rpcs extends Rpc.Any>(
   protocol: RpcGroup.RpcGroup<Rpcs>
 ): Entity<Type, Rpcs> => {
   const self = Object.create(Proto)
-  self.type = EntityType.makeUnsafe(type)
+  self.type = EntityType.make(type)
   self.protocol = protocol
-  self.getShardGroup = ServiceMap.get(protocol.annotations, ShardGroup)
+  self.getShardGroup = Context.get(protocol.annotations, ShardGroup)
   return self
 }
 
@@ -397,7 +408,7 @@ export const make = <const Type extends string, Rpcs extends ReadonlyArray<Rpc.A
  * @since 4.0.0
  * @category context
  */
-export class CurrentAddress extends ServiceMap.Service<
+export class CurrentAddress extends Context.Service<
   CurrentAddress,
   EntityAddress
 >()("effect/cluster/Entity/EntityAddress") {}
@@ -408,7 +419,7 @@ export class CurrentAddress extends ServiceMap.Service<
  * @since 4.0.0
  * @category context
  */
-export class CurrentRunnerAddress extends ServiceMap.Service<
+export class CurrentRunnerAddress extends Context.Service<
   CurrentRunnerAddress,
   RunnerAddress
 >()("effect/cluster/Entity/RunnerAddress") {}
@@ -449,7 +460,7 @@ export declare namespace Replier {
    * @category Replier
    */
   export type Success<R extends Rpc.Any> = Rpc.Success<R> extends Stream.Stream<infer _A, infer _E, infer _R> ?
-    Stream.Stream<_A, _E | Rpc.Error<R>, _R> | Queue.Dequeue<_A, _E | Rpc.Error<R>>
+    Stream.Stream<_A, _E | Rpc.Error<R>, _R> | Queue.Dequeue<_A, _E | Rpc.Error<R> | Cause.Done>
     : Rpc.Success<R>
 }
 
@@ -480,7 +491,7 @@ export class Request<Rpc extends Rpc.Any> extends Data.Class<
   }
 }
 
-const shardingTag = ServiceMap.Service<Sharding, Sharding["Service"]>("effect/cluster/Sharding")
+const shardingTag = Context.Service<Sharding, Sharding["Service"]>("effect/cluster/Sharding")
 
 /**
  * @since 4.0.0
@@ -506,12 +517,12 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
   const snowflakeGen = yield* Snowflake.makeGenerator
   const runnerAddress = new RunnerAddress({ host: "localhost", port: 3000 })
   const entityMap = new Map<string, {
-    readonly services: ServiceMap.ServiceMap<
+    readonly context: Context.Context<
       Rpc.ServicesClient<Rpcs> | Rpc.ServicesServer<Rpcs> | Rpc.Middleware<Rpcs> | LR
     >
     readonly concurrency: number | "unbounded"
     readonly build: Effect.Effect<
-      ServiceMap.ServiceMap<Rpc.ToHandler<Rpcs>>,
+      Context.Context<Rpc.ToHandler<Rpcs>>,
       never,
       Scope | CurrentAddress
     >
@@ -519,15 +530,15 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
   const sharding = shardingTag.of({
     ...({} as Sharding["Service"]),
     registerEntity: (entity, handlers, options) =>
-      Effect.servicesWith((services) => {
+      Effect.contextWith((context) => {
         entityMap.set(entity.type, {
-          services: services as any,
+          context: context as any,
           concurrency: options?.concurrency ?? 1,
           build: entity.protocol.toHandlers(handlers as any).pipe(
-            Effect.provideServices(ServiceMap.mutate(services, (services) =>
-              services.pipe(
-                ServiceMap.add(CurrentRunnerAddress, runnerAddress),
-                ServiceMap.omit(Scope)
+            Effect.provideContext(Context.mutate(context, (context) =>
+              context.pipe(
+                Context.add(CurrentRunnerAddress, runnerAddress),
+                Context.omit(Scope)
               )))
           ) as any
         })
@@ -608,9 +619,9 @@ export const keepAlive: (
   olatch.value.closeUnsafe()
   yield* Effect.orDie(sharding.sendOutgoing(
     new Message.OutgoingRequest({
-      annotations: ServiceMap.empty(),
+      annotations: KeepAliveRpc.annotations,
       rpc: KeepAliveRpc,
-      services: ServiceMap.empty() as any,
+      context: Context.empty() as any,
       envelope: Envelope.makeRequest({
         requestId,
         address,
@@ -645,6 +656,6 @@ export const KeepAliveRpc = Rpc.make("Cluster/Entity/keepAlive")
  * @since 4.0.0
  * @category Keep alive
  */
-export class KeepAliveLatch extends ServiceMap.Service<KeepAliveLatch, Latch.Latch>()(
+export class KeepAliveLatch extends Context.Service<KeepAliveLatch, Latch.Latch>()(
   "effect/cluster/Entity/KeepAliveLatch"
 ) {}

package/src/unstable/cluster/EntityProxy.ts

@@ -60,11 +60,11 @@ export const toRpcGroup = <Type extends string, Rpcs extends Rpc.Any>(
       entityId: Schema.String,
       payload: parentRpc.payloadSchema
     })
-    const oldMake = payloadSchema.makeUnsafe
-    payloadSchema.makeUnsafe = (input: any, options?: Schema.MakeOptions) => {
+    const oldMake = payloadSchema.make
+    payloadSchema.make = (input: any, options?: Schema.MakeOptions) => {
       return oldMake({
         entityId: input.entityId,
-        payload: parentRpc.payloadSchema.makeUnsafe(input.payload, options)
+        payload: parentRpc.payloadSchema.make(input.payload, options)
       }, options)
     }
     const rpc = Rpc.make(`${entity.type}.${parentRpc._tag}`, {

package/src/unstable/cluster/EntityProxyServer.ts

@@ -1,9 +1,9 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as HttpApi from "../httpapi/HttpApi.ts"
 import * as HttpApiBuilder from "../httpapi/HttpApiBuilder.ts"
 import type * as HttpApiGroup from "../httpapi/HttpApiGroup.ts"
@@ -81,8 +81,8 @@ export const layerRpcHandlers = <
 >(
   entity: Entity.Entity<Type, Rpcs>
 ): Layer.Layer<RpcHandlers<Rpcs, Type>, never, Sharding | Rpc.ServicesServer<Rpcs>> =>
-  Layer.effectServices(Effect.gen(function*() {
-    const services = yield* Effect.services<never>()
+  Layer.effectContext(Effect.gen(function*() {
+    const services = yield* Effect.context<never>()
     const client = yield* entity.client
     const handlers = new Map<string, Rpc.Handler<string>>()
     for (const parentRpc_ of entity.protocol.requests.values()) {
@@ -101,7 +101,7 @@ export const layerRpcHandlers = <
           (client(entityId) as any)[parentRpc._tag](payload, { discard: true }) as any
       } as any)
     }
-    return ServiceMap.makeUnsafe(handlers)
+    return Context.makeUnsafe(handlers)
   }))
 
 /**

package/src/unstable/cluster/EntityResource.ts

@@ -2,12 +2,12 @@
  * @since 4.0.0
  */
 import type * as v1 from "kubernetes-types/core/v1.d.ts"
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import { identity } from "../../Function.ts"
 import * as RcRef from "../../RcRef.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Entity from "./Entity.ts"
 import * as K8sHttpClient from "./K8sHttpClient.ts"
 import type { Sharding } from "./Sharding.ts"
@@ -42,7 +42,7 @@ export interface EntityResource<out A, out E = never> {
  * @since 4.0.0
  * @category Scope
  */
-export class CloseScope extends ServiceMap.Service<
+export class CloseScope extends Context.Service<
   CloseScope,
   Scope.Scope
 >()("effect/cluster/EntityResource/CloseScope") {}

package/src/unstable/cluster/HttpRunner.ts

@@ -116,7 +116,7 @@ export const toHttpEffect: Effect.Effect<
   return yield* RpcServer.toHttpEffect(Runners.Rpcs, {
     spanPrefix: "RunnerServer",
     disableTracing: true
-  }).pipe(Effect.provideServices(handlers))
+  }).pipe(Effect.provideContext(handlers))
 })
 
 /**
@@ -132,7 +132,7 @@ export const toHttpEffectWebsocket: Effect.Effect<
   return yield* RpcServer.toHttpEffectWebsocket(Runners.Rpcs, {
     spanPrefix: "RunnerServer",
     disableTracing: true
-  }).pipe(Effect.provideServices(handlers))
+  }).pipe(Effect.provideContext(handlers))
 })
 
 /**

package/src/unstable/cluster/K8sHttpClient.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import type * as v1 from "kubernetes-types/core/v1.d.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as FileSystem from "../../FileSystem.ts"
 import { identity } from "../../Function.ts"
@@ -10,7 +11,6 @@ import * as Option from "../../Option.ts"
 import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as HttpClient from "../http/HttpClient.ts"
 import * as HttpClientError from "../http/HttpClientError.ts"
 import * as HttpClientRequest from "../http/HttpClientRequest.ts"
@@ -20,7 +20,7 @@ import * as HttpClientResponse from "../http/HttpClientResponse.ts"
  * @since 4.0.0
  * @category Tags
  */
-export class K8sHttpClient extends ServiceMap.Service<
+export class K8sHttpClient extends Context.Service<
   K8sHttpClient,
   HttpClient.HttpClient
 >()("effect/cluster/K8sHttpClient") {}

package/src/unstable/cluster/Message.ts

@@ -1,11 +1,11 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import type { PersistenceError } from "./ClusterError.ts"
 import { MalformedMessage } from "./ClusterError.ts"
@@ -36,7 +36,7 @@ export const incomingLocalFromOutgoing = <R extends Rpc.Any>(self: Outgoing<R>):
     return new IncomingEnvelope({ envelope: self.envelope })
   }
   return new IncomingRequestLocal({
-    annotations: ServiceMap.get(self.rpc.annotations, ClusterSchema.Dynamic)(
+    annotations: Context.get(self.rpc.annotations, ClusterSchema.Dynamic)(
       self.rpc.annotations,
       self.envelope as any
     ),
@@ -64,7 +64,7 @@ export class IncomingRequestLocal<R extends Rpc.Any> extends Data.TaggedClass("I
   readonly envelope: Envelope.Request<R>
   readonly lastSentReply: Option.Option<Reply.Reply<R>>
   readonly respond: (reply: Reply.Reply<R>) => Effect.Effect<void, MalformedMessage | PersistenceError>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 }> {}
 
 /**
@@ -88,11 +88,11 @@ export type Outgoing<R extends Rpc.Any> = OutgoingRequest<R> | OutgoingEnvelope
  */
 export class OutgoingRequest<R extends Rpc.Any> extends Data.TaggedClass("OutgoingRequest")<{
   readonly envelope: Envelope.Request<R>
-  readonly services: ServiceMap.ServiceMap<Rpc.Services<R>>
+  readonly context: Context.Context<Rpc.Services<R>>
   readonly lastReceivedReply: Option.Option<Reply.Reply<R>>
   readonly rpc: R
   readonly respond: (reply: Reply.Reply<R>) => Effect.Effect<void>
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 }> {
   /**
    * @since 4.0.0
@@ -167,7 +167,7 @@ export const serializeRequest = <Rpc extends Rpc.Any>(
 ): Effect.Effect<Envelope.PartialRequest, MalformedMessage> => {
   const rpc = self.rpc as any as Rpc.AnyWithProps
   return Schema.encodeEffect(Schema.toCodecJson(rpc.payloadSchema))(self.envelope.payload).pipe(
-    Effect.provideServices(self.services),
+    Effect.provideContext(self.context),
     MalformedMessage.refail,
     Effect.map((payload) => ({
       ...self.envelope,
@@ -196,7 +196,7 @@ export const deserializeLocal = <Rpc extends Rpc.Any>(
   }
   const rpc = self.rpc as any as Rpc.AnyWithProps
   return Schema.decodeEffect(Schema.toCodecJson(rpc.payloadSchema))(encoded.payload).pipe(
-    Effect.provideServices(self.services),
+    Effect.provideContext(self.context),
     MalformedMessage.refail,
     Effect.map((payload) => {
       const envelope = Envelope.makeRequest({
@@ -207,7 +207,7 @@ export const deserializeLocal = <Rpc extends Rpc.Any>(
         envelope,
         lastSentReply: Option.none(),
         respond: self.respond,
-        annotations: ServiceMap.get(rpc.annotations, ClusterSchema.Dynamic)(
+        annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
           rpc.annotations,
           envelope as any
         )

package/src/unstable/cluster/MessageStorage.ts

@@ -3,6 +3,7 @@
  */
 import * as Arr from "../../Array.ts"
 import { Clock } from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
@@ -12,7 +13,6 @@ import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import type { Predicate } from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import { EntityNotAssignedToRunner, MalformedMessage, type PersistenceError } from "./ClusterError.ts"
 import * as DeliverAt from "./DeliverAt.ts"
@@ -20,7 +20,7 @@ import type { EntityAddress } from "./EntityAddress.ts"
 import * as Envelope from "./Envelope.ts"
 import * as Message from "./Message.ts"
 import * as Reply from "./Reply.ts"
-import { ShardId } from "./ShardId.ts"
+import * as ShardId from "./ShardId.ts"
 import type { ShardingConfig } from "./ShardingConfig.ts"
 import * as Snowflake from "./Snowflake.ts"
 
@@ -28,7 +28,7 @@ import * as Snowflake from "./Snowflake.ts"
  * @since 4.0.0
  * @category context
  */
-export class MessageStorage extends ServiceMap.Service<MessageStorage, {
+export class MessageStorage extends Context.Service<MessageStorage, {
   /**
    * Save the provided message and its associated metadata.
    */
@@ -98,7 +98,7 @@ export class MessageStorage extends ServiceMap.Service<MessageStorage, {
   /**
    * Unregister the reply handlers for the specified ShardId.
    */
-  readonly unregisterShardReplyHandlers: (shardId: ShardId) => Effect.Effect<void>
+  readonly unregisterShardReplyHandlers: (shardId: ShardId.ShardId) => Effect.Effect<void>
 
   /**
    * Retrieves the unprocessed messages for the specified shards.
@@ -111,7 +111,7 @@ export class MessageStorage extends ServiceMap.Service<MessageStorage, {
    * - All Interrupt's for unprocessed requests
    */
   readonly unprocessedMessages: (
-    shardIds: Iterable<ShardId>
+    shardIds: Iterable<ShardId.ShardId>
   ) => Effect.Effect<Array<Message.Incoming<any>>, PersistenceError>
 
   /**
@@ -125,7 +125,7 @@ export class MessageStorage extends ServiceMap.Service<MessageStorage, {
    * Reset the mailbox state for the provided shards.
    */
   readonly resetShards: (
-    shardIds: Iterable<ShardId>
+    shardIds: Iterable<ShardId.ShardId>
   ) => Effect.Effect<void, PersistenceError>
 
   /**
@@ -483,7 +483,7 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
           const duplicate = result
           const schema = Reply.Reply(message.rpc)
           return Schema.decodeEffect(schema)(result.lastReceivedReply.value).pipe(
-            Effect.provideServices(message.services),
+            Effect.provideContext(message.context),
             MalformedMessage.refail,
             Effect.map((reply) =>
               SaveResult.Duplicate({
@@ -630,7 +630,7 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
         if (!message) return Effect.void
         const schema = Reply.Reply(message.rpc)
         return Schema.decodeEffect(schema)(reply).pipe(
-          Effect.provideServices(message.services)
+          Effect.provideContext(message.context)
         ) as Effect.Effect<Reply.Reply<any>, Schema.SchemaError>
       }),
       (error) => {
@@ -699,7 +699,7 @@ export type MemoryEntry = {
  * @since 4.0.0
  * @category Memory
  */
-export const MemoryTransaction = ServiceMap.Reference<boolean>("effect/cluster/MessageStorage/MemoryTransaction", {
+export const MemoryTransaction = Context.Reference<boolean>("effect/cluster/MessageStorage/MemoryTransaction", {
   defaultValue: constFalse
 })
 
@@ -707,7 +707,7 @@ export const MemoryTransaction = ServiceMap.Reference<boolean>("effect/cluster/M
  * @since 4.0.0
  * @category Memory
  */
-export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/cluster/MessageStorage/MemoryDriver", {
+export class MemoryDriver extends Context.Service<MemoryDriver>()("effect/cluster/MessageStorage/MemoryDriver", {
   make: Effect.gen(function*() {
     const clock = yield* Clock
     const requests = new Map<string, MemoryEntry>()
@@ -843,7 +843,7 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
           }>()
           for (let index = 0; index < journal.length; index++) {
             const envelope = journal[index]
-            const shardId = ShardId.makeUnsafe(envelope.address.shardId)
+            const shardId = ShardId.make(envelope.address.shardId.group, envelope.address.shardId.id)
             if (!unprocessed.has(envelope as any) || !shardIds.includes(shardId.toString())) {
               continue
             }

package/src/unstable/cluster/Reply.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
@@ -11,7 +12,6 @@ import * as Schema from "../../Schema.ts"
 import * as Issue from "../../SchemaIssue.ts"
 import * as Parser from "../../SchemaParser.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import type * as RpcMessage from "../rpc/RpcMessage.ts"
 import type * as RpcSchema from "../rpc/RpcSchema.ts"
@@ -51,7 +51,7 @@ export const Encoded: Schema.Codec<Encoded> = Schema.Any as any
  */
 export class ReplyWithContext<R extends Rpc.Any> extends Data.TaggedClass("ReplyWithContext")<{
   readonly reply: Reply<R>
-  readonly services: ServiceMap.ServiceMap<Rpc.Services<R>>
+  readonly context: Context.Context<Rpc.Services<R>>
   readonly rpc: R
 }> {
   /**
@@ -68,7 +68,7 @@ export class ReplyWithContext<R extends Rpc.Any> extends Data.TaggedClass("Reply
         id: options.id,
         exit: Exit.die(Schema.encodeSync(Schema.Defect)(options.defect))
       }),
-      services: ServiceMap.empty() as any,
+      context: Context.empty() as any,
       rpc: neverRpc
     })
   }
@@ -85,7 +85,7 @@ export class ReplyWithContext<R extends Rpc.Any> extends Data.TaggedClass("Reply
         id: options.id,
         exit: Exit.interrupt()
       }),
-      services: ServiceMap.empty() as any,
+      context: Context.empty() as any,
       rpc: neverRpc
     })
   }
@@ -339,9 +339,9 @@ export const serialize = <R extends Rpc.Any>(
 ): Effect.Effect<Encoded, MalformedMessage> => {
   const schema = Reply(self.rpc)
   return MalformedMessage.refail(
-    Effect.provideServices(
+    Effect.provideContext(
       Schema.encodeEffect(schema)(self.reply),
-      self.services
+      self.context
     )
   )
 }
@@ -359,7 +359,7 @@ export const serializeLastReceived = <R extends Rpc.Any>(
   }
   const schema = Reply(self.rpc)
   return MalformedMessage.refail(
-    Effect.provideServices(Schema.encodeEffect(schema)(lastReceivedReply.value), self.services)
+    Effect.provideContext(Schema.encodeEffect(schema)(lastReceivedReply.value), self.context)
   ).pipe(
     Effect.map(Option.some)
   )

package/src/unstable/cluster/RunnerHealth.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 Schedule from "../../Schedule.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as K8s from "./K8sHttpClient.ts"
 import type { RunnerAddress } from "./RunnerAddress.ts"
 import * as Runners from "./Runners.ts"
@@ -20,7 +20,7 @@ import * as Runners from "./Runners.ts"
  * @since 4.0.0
  * @category models
  */
-export class RunnerHealth extends ServiceMap.Service<
+export class RunnerHealth extends Context.Service<
   RunnerHealth,
   {
     readonly isAlive: (address: RunnerAddress) => Effect.Effect<boolean>

package/src/unstable/cluster/RunnerServer.ts

@@ -72,7 +72,7 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
               resume(exit as any)
             }
           }
-          const runFork = Effect.runForkWith(parent.services)
+          const runFork = Effect.runForkWith(parent.context)
           const fiber = runFork(storage.registerReplyHandler(message))
           fiber.addObserver(onExit)
           runFork(Effect.catchTag(

package/src/unstable/cluster/RunnerStorage.ts

@@ -2,15 +2,15 @@
  * @since 4.0.0
  */
 import { isArrayNonEmpty, type NonEmptyArray } from "../../Array.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as MutableHashMap from "../../MutableHashMap.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { PersistenceError } from "./ClusterError.ts"
 import * as MachineId from "./MachineId.ts"
 import { Runner } from "./Runner.ts"
 import type { RunnerAddress } from "./RunnerAddress.ts"
-import { ShardId } from "./ShardId.ts"
+import * as ShardId from "./ShardId.ts"
 
 /**
  * Represents a generic interface to the persistent storage required by the
@@ -19,7 +19,7 @@ import { ShardId } from "./ShardId.ts"
  * @since 4.0.0
  * @category models
  */
-export class RunnerStorage extends ServiceMap.Service<RunnerStorage, {
+export class RunnerStorage extends Context.Service<RunnerStorage, {
   /**
    * Register a new runner with the cluster.
    */
@@ -47,23 +47,23 @@ export class RunnerStorage extends ServiceMap.Service<RunnerStorage, {
    */
   readonly acquire: (
     address: RunnerAddress,
-    shardIds: Iterable<ShardId>
-  ) => Effect.Effect<Array<ShardId>, PersistenceError>
+    shardIds: Iterable<ShardId.ShardId>
+  ) => Effect.Effect<Array<ShardId.ShardId>, PersistenceError>
 
   /**
    * Refresh the locks owned by the given runner.
    */
   readonly refresh: (
     address: RunnerAddress,
-    shardIds: Iterable<ShardId>
-  ) => Effect.Effect<Array<ShardId>, PersistenceError>
+    shardIds: Iterable<ShardId.ShardId>
+  ) => Effect.Effect<Array<ShardId.ShardId>, PersistenceError>
 
   /**
    * Release the given shard ids.
    */
   readonly release: (
     address: RunnerAddress,
-    shardId: ShardId
+    shardId: ShardId.ShardId
   ) => Effect.Effect<void, PersistenceError>
 
   /**
@@ -181,7 +181,7 @@ export const makeEncoded = (encoded: Encoded) =>
  */
 export const makeMemory = Effect.gen(function*() {
   const runners = MutableHashMap.empty<RunnerAddress, Runner>()
-  let acquired: Array<ShardId> = []
+  let acquired: Array<ShardId.ShardId> = []
   let id = 0
 
   return RunnerStorage.of({