effect 4.0.0-beta.5 → 4.0.0-beta.50

package/src/unstable/cluster/Entity.ts

@@ -3,25 +3,27 @@
  */
 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 { DurationInput } from "../../Duration.ts"
+import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
 import * as Exit from "../../Exit.ts"
 import { identity } from "../../Function.ts"
 import * as Hash from "../../Hash.ts"
+import type * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 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 UndefinedOr from "../../UndefinedOr.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"
@@ -74,22 +76,22 @@ export interface Entity<
   /**
    * Annotate the entity with a value.
    */
-  annotate<I, S>(key: ServiceMap.Service<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.Service<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.
@@ -116,7 +118,7 @@ export interface Entity<
   >(
     build: Handlers | Effect.Effect<Handlers, never, RX>,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Duration.Input | undefined
       readonly concurrency?: number | "unbounded" | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
@@ -159,7 +161,7 @@ export interface Entity<
         RX
       >,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Duration.Input | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
       readonly defectRetryPolicy?: Schedule.Schedule<any, unknown> | undefined
@@ -189,7 +191,7 @@ export type Any = Entity<string, Rpc.Any>
 export type HandlersFrom<Rpc extends Rpc.Any> = {
   readonly [Current in Rpc as Current["_tag"]]: (
     envelope: Request<Current>
-  ) => Rpc.ResultFrom<Current, any> | Rpc.Wrapper<Rpc.ResultFrom<Current, any>>
+  ) => Rpc.WrapperOr<Rpc.ResultFrom<Current, any>>
 }
 
 /**
@@ -206,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.Service<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.Service<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) {
@@ -234,7 +236,7 @@ const Proto = {
     this: Entity<string, Rpcs>,
     build: Handlers | Effect.Effect<Handlers, never, RX>,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Duration.Input | undefined
       readonly concurrency?: number | "unbounded" | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
@@ -283,7 +285,7 @@ const Proto = {
         RX
       >,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Duration.Input | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
       readonly defectRetryPolicy?: Schedule.Schedule<any, unknown> | undefined
@@ -295,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
@@ -365,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
 }
 
@@ -396,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") {}
@@ -407,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") {}
@@ -448,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>
 }
 
@@ -458,28 +470,28 @@ export declare namespace Replier {
  */
 export class Request<Rpc extends Rpc.Any> extends Data.Class<
   Envelope.Request<Rpc> & {
-    readonly lastSentChunk: Reply.Chunk<Rpc> | undefined
+    readonly lastSentChunk: Option.Option<Reply.Chunk<Rpc>>
   }
 > {
   /**
    * @since 4.0.0
    */
-  get lastSentChunkValue(): Rpc.SuccessChunk<Rpc> | undefined {
-    return UndefinedOr.map(this.lastSentChunk, (chunk) => Arr.lastNonEmpty(chunk.values))
+  get lastSentChunkValue(): Option.Option<Rpc.SuccessChunk<Rpc>> {
+    return Option.map(this.lastSentChunk, (chunk) => Arr.lastNonEmpty(chunk.values))
   }
 
   /**
    * @since 4.0.0
    */
   get nextSequence(): number {
-    if (this.lastSentChunk === undefined) {
+    if (Option.isNone(this.lastSentChunk)) {
       return 0
     }
-    return this.lastSentChunk.sequence + 1
+    return this.lastSentChunk.value.sequence + 1
   }
 }
 
-const shardingTag = ServiceMap.Service<Sharding, Sharding["Service"]>("effect/cluster/Sharding")
+const shardingTag = Context.Service<Sharding, Sharding["Service"]>("effect/cluster/Sharding")
 
 /**
  * @since 4.0.0
@@ -505,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
     >
@@ -518,15 +530,16 @@ 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(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
         })
         return Effect.void
@@ -569,7 +582,7 @@ export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE,
               [Envelope.TypeId]: Envelope.TypeId,
               address,
               requestId: Snowflake.Snowflake(message.id),
-              lastSentChunk: undefined
+              lastSentChunk: Option.none()
             }) as any
           })
         }
@@ -606,8 +619,9 @@ export const keepAlive: (
   olatch.value.closeUnsafe()
   yield* Effect.orDie(sharding.sendOutgoing(
     new Message.OutgoingRequest({
+      annotations: KeepAliveRpc.annotations,
       rpc: KeepAliveRpc,
-      services: ServiceMap.empty() as any,
+      context: Context.empty() as any,
       envelope: Envelope.makeRequest({
         requestId,
         address,
@@ -618,7 +632,7 @@ export const keepAlive: (
         spanId: span.spanId,
         sampled: span.sampled
       }),
-      lastReceivedReply: undefined,
+      lastReceivedReply: Option.none(),
       respond: () => Effect.void
     }),
     true
@@ -642,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, Effect.Latch>()(
+export class KeepAliveLatch extends Context.Service<KeepAliveLatch, Latch.Latch>()(
   "effect/cluster/Entity/KeepAliveLatch"
 ) {}

package/src/unstable/cluster/EntityAddress.ts

@@ -56,4 +56,4 @@ export const make = (options: {
   readonly shardId: ShardId
   readonly entityType: EntityType
   readonly entityId: EntityId
-}): EntityAddress => new EntityAddress(options, { disableValidation: true })
+}): EntityAddress => new EntityAddress(options, { disableChecks: true })

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") {}
@@ -62,14 +62,14 @@ export class CloseScope extends ServiceMap.Service<
  */
 export const make: <A, E, R>(options: {
   readonly acquire: Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly idleTimeToLive?: Duration.Input | undefined
 }) => Effect.Effect<
   EntityResource<A, E>,
   E,
   Scope.Scope | Exclude<R, CloseScope> | Sharding | Entity.CurrentAddress
 > = Effect.fnUntraced(function*<A, E, R>(options: {
   readonly acquire: Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly idleTimeToLive?: Duration.Input | undefined
 }) {
   let shuttingDown = false
 
@@ -116,14 +116,14 @@ export const make: <A, E, R>(options: {
 export const makeK8sPod: (
   spec: v1.Pod,
   options?: {
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   } | undefined
 ) => Effect.Effect<
   EntityResource<K8sHttpClient.PodStatus>,
   never,
   Scope.Scope | Sharding | Entity.CurrentAddress | K8sHttpClient.K8sHttpClient
 > = Effect.fnUntraced(function*(spec: v1.Pod, options?: {
-  readonly idleTimeToLive?: Duration.DurationInput | undefined
+  readonly idleTimeToLive?: Duration.Input | undefined
 }) {
   const createPod = yield* K8sHttpClient.makeCreatePod
   return yield* make({

package/src/unstable/cluster/Envelope.ts

@@ -218,7 +218,7 @@ export const PartialJson: Schema.Codec<
  * @category schemas
  */
 export const PartialArray: Schema.mutable<
-  Schema.Array$<Schema.Codec<AckChunk | Interrupt | PartialRequest, Encoded>>
+  Schema.$Array<Schema.Codec<AckChunk | Interrupt | PartialRequest, Encoded>>
 > = Schema.mutable(Schema.Array(PartialJson))
 
 /**

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") {}
@@ -121,7 +121,7 @@ export const makeCreatePod = Effect.gen(function*() {
         while: (e) => e._tag === "SchemaError",
         schedule: Schedule.spaced("1 seconds")
       }),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404
@@ -133,7 +133,7 @@ export const makeCreatePod = Effect.gen(function*() {
     )
     const isPodFound = readPodRaw.pipe(
       Effect.as(true),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404
@@ -145,7 +145,7 @@ export const makeCreatePod = Effect.gen(function*() {
     const createPod = HttpClientRequest.post(`/v1/namespaces/${namespace}/pods`).pipe(
       HttpClientRequest.bodyJsonUnsafe(spec),
       client.execute,
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 409
@@ -156,10 +156,10 @@ export const makeCreatePod = Effect.gen(function*() {
       Effect.tapCause(Effect.logInfo),
       Effect.orDie
     )
-    const deletePod = HttpClientRequest.del(`/v1/namespaces/${namespace}/pods/${name}`).pipe(
+    const deletePod = HttpClientRequest.delete(`/v1/namespaces/${namespace}/pods/${name}`).pipe(
       client.execute,
       Effect.flatMap((res) => res.json),
-      Effect.catchIf(
+      Effect.catchFilter(
         (err) =>
           HttpClientError.isHttpClientError(err) && err.reason._tag === "StatusCodeError" &&
             err.reason.response.status === 404

package/src/unstable/cluster/Message.ts

@@ -1,13 +1,15 @@
 /**
  * @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 type { ServiceMap } from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import type { PersistenceError } from "./ClusterError.ts"
 import { MalformedMessage } from "./ClusterError.ts"
+import * as ClusterSchema from "./ClusterSchema.ts"
 import type { EntityAddress } from "./EntityAddress.ts"
 import * as Envelope from "./Envelope.ts"
 import type * as Reply from "./Reply.ts"
@@ -34,9 +36,13 @@ export const incomingLocalFromOutgoing = <R extends Rpc.Any>(self: Outgoing<R>):
     return new IncomingEnvelope({ envelope: self.envelope })
   }
   return new IncomingRequestLocal({
+    annotations: Context.get(self.rpc.annotations, ClusterSchema.Dynamic)(
+      self.rpc.annotations,
+      self.envelope as any
+    ),
     envelope: self.envelope,
     respond: self.respond,
-    lastSentReply: undefined
+    lastSentReply: Option.none()
   })
 }
 
@@ -46,7 +52,7 @@ export const incomingLocalFromOutgoing = <R extends Rpc.Any>(self: Outgoing<R>):
  */
 export class IncomingRequest<R extends Rpc.Any> extends Data.TaggedClass("IncomingRequest")<{
   readonly envelope: Envelope.PartialRequest
-  readonly lastSentReply: Reply.Encoded | undefined
+  readonly lastSentReply: Option.Option<Reply.Encoded>
   readonly respond: (reply: Reply.ReplyWithContext<R>) => Effect.Effect<void, MalformedMessage | PersistenceError>
 }> {}
 
@@ -56,8 +62,9 @@ export class IncomingRequest<R extends Rpc.Any> extends Data.TaggedClass("Incomi
  */
 export class IncomingRequestLocal<R extends Rpc.Any> extends Data.TaggedClass("IncomingRequestLocal")<{
   readonly envelope: Envelope.Request<R>
-  readonly lastSentReply: Reply.Reply<R> | undefined
+  readonly lastSentReply: Option.Option<Reply.Reply<R>>
   readonly respond: (reply: Reply.Reply<R>) => Effect.Effect<void, MalformedMessage | PersistenceError>
+  readonly annotations: Context.Context<never>
 }> {}
 
 /**
@@ -81,10 +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<Rpc.Services<R>>
-  readonly lastReceivedReply: Reply.Reply<R> | undefined
+  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: Context.Context<never>
 }> {
   /**
    * @since 4.0.0
@@ -159,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,
@@ -188,17 +196,22 @@ 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) =>
-      new IncomingRequestLocal({
-        envelope: Envelope.makeRequest({
-          ...encoded,
-          payload
-        } as any),
-        lastSentReply: undefined,
-        respond: self.respond
+    Effect.map((payload) => {
+      const envelope = Envelope.makeRequest({
+        ...encoded,
+        payload
+      } as any) as Envelope.Request<Rpc>
+      return new IncomingRequestLocal({
+        envelope,
+        lastSentReply: Option.none(),
+        respond: self.respond,
+        annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
+          rpc.annotations,
+          envelope as any
+        )
       })
-    )
+    })
   ) as Effect.Effect<IncomingRequestLocal<Rpc>, MalformedMessage>
 }