@effect/cluster 0.50.6 → 0.52.0

package/src/Entity.ts

@@ -7,14 +7,13 @@ import * as RpcGroup from "@effect/rpc/RpcGroup"
 import * as RpcServer from "@effect/rpc/RpcServer"
 import * as Arr from "effect/Array"
 import type { Brand } from "effect/Brand"
-import * as Cause from "effect/Cause"
+import type * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Data from "effect/Data"
 import type { DurationInput } from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Equal from "effect/Equal"
 import * as Exit from "effect/Exit"
-import * as FiberId from "effect/FiberId"
 import { identity } from "effect/Function"
 import * as Hash from "effect/Hash"
 import * as Layer from "effect/Layer"
@@ -24,12 +23,7 @@ import * as Predicate from "effect/Predicate"
 import type * as Schedule from "effect/Schedule"
 import { Scope } from "effect/Scope"
 import type * as Stream from "effect/Stream"
-import type {
-  AlreadyProcessingMessage,
-  EntityNotManagedByRunner,
-  MailboxFull,
-  PersistenceError
-} from "./ClusterError.js"
+import type { AlreadyProcessingMessage, MailboxFull, PersistenceError } from "./ClusterError.js"
 import { ShardGroup } from "./ClusterSchema.js"
 import { EntityAddress } from "./EntityAddress.js"
 import type { EntityId } from "./EntityId.js"
@@ -114,7 +108,7 @@ export interface Entity<
       entityId: string
     ) => RpcClient.RpcClient.From<
       Rpcs,
-      MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotManagedByRunner
+      MailboxFull | AlreadyProcessingMessage | PersistenceError
     >,
     never,
     Sharding
@@ -493,18 +487,6 @@ export class Request<Rpc extends Rpc.Any> extends Data.Class<
 
 const shardingTag = Context.GenericTag<Sharding, Sharding["Type"]>("@effect/cluster/Sharding")
 
-/**
- * @since 1.0.0
- * @category Interruption
- */
-export const fiberIdIgnored = FiberId.make(-1, 0)
-
-/**
- * @since 1.0.0
- * @category Interruption
- */
-export const interruptIgnored = Effect.failCause(Cause.interrupt(fiberIdIgnored))
-
 /**
  * @since 1.0.0
  * @category Testing

package/src/EntityAddress.ts

@@ -63,3 +63,13 @@ export class EntityAddress extends Schema.Class<EntityAddress>(SymbolKey)({
 export const EntityAddressFromSelf: Schema.Schema<EntityAddress> = Schema.typeSchema(
   EntityAddress
 )
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const make = (options: {
+  readonly shardId: ShardId
+  readonly entityType: EntityType
+  readonly entityId: EntityId
+}): EntityAddress => new EntityAddress(options, { disableValidation: true })

package/src/EntityId.ts

@@ -14,3 +14,9 @@ export const EntityId = Schema.NonEmptyTrimmedString.pipe(Schema.brand("EntityId
  * @category models
  */
 export type EntityId = typeof EntityId.Type
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make = (id: string): EntityId => id as EntityId

package/src/EntityProxy.ts

@@ -6,14 +6,13 @@ import * as HttpApiGroup from "@effect/platform/HttpApiGroup"
 import * as Rpc from "@effect/rpc/Rpc"
 import * as RpcGroup from "@effect/rpc/RpcGroup"
 import * as Schema from "effect/Schema"
-import { AlreadyProcessingMessage, EntityNotManagedByRunner, MailboxFull, PersistenceError } from "./ClusterError.js"
+import { AlreadyProcessingMessage, MailboxFull, PersistenceError } from "./ClusterError.js"
 import type * as Entity from "./Entity.js"
 
 const clientErrors = [
   MailboxFull,
   AlreadyProcessingMessage,
-  PersistenceError,
-  EntityNotManagedByRunner
+  PersistenceError
 ] as const
 
 /**
@@ -94,12 +93,14 @@ export type ConvertRpcs<Rpcs extends Rpc.Any, Prefix extends string> = Rpcs exte
       }>,
       _Success,
       Schema.Schema<
-        _Error["Type"] | MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotManagedByRunner,
+        | _Error["Type"]
+        | MailboxFull
+        | AlreadyProcessingMessage
+        | PersistenceError
         | _Error["Encoded"]
         | typeof MailboxFull["Encoded"]
         | typeof AlreadyProcessingMessage["Encoded"]
-        | typeof PersistenceError["Encoded"]
-        | typeof EntityNotManagedByRunner["Encoded"],
+        | typeof PersistenceError["Encoded"],
         _Error["Context"]
       >
     >
@@ -113,8 +114,7 @@ export type ConvertRpcs<Rpcs extends Rpc.Any, Prefix extends string> = Rpcs exte
       Schema.Union<[
         typeof MailboxFull,
         typeof AlreadyProcessingMessage,
-        typeof PersistenceError,
-        typeof EntityNotManagedByRunner
+        typeof PersistenceError
       ]>
     >
   : never
@@ -210,7 +210,7 @@ export type ConvertHttpApi<Rpcs extends Rpc.Any> = Rpcs extends Rpc.Rpc<
       _Payload["Type"],
       never,
       _Success["Type"],
-      _Error["Type"] | MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotManagedByRunner,
+      _Error["Type"] | MailboxFull | AlreadyProcessingMessage | PersistenceError,
       _Payload["Context"] | _Success["Context"],
       _Error["Context"]
     >
@@ -222,6 +222,6 @@ export type ConvertHttpApi<Rpcs extends Rpc.Any> = Rpcs extends Rpc.Rpc<
       _Payload["Type"],
       never,
       void,
-      MailboxFull | AlreadyProcessingMessage | PersistenceError | EntityNotManagedByRunner
+      MailboxFull | AlreadyProcessingMessage | PersistenceError
     >
   : never

package/src/HttpRunner.ts

@@ -1,34 +1,116 @@
 /**
  * @since 1.0.0
  */
-import type * as HttpApp from "@effect/platform/HttpApp"
-import type * as HttpClient from "@effect/platform/HttpClient"
-import * as HttpRouter from "@effect/platform/HttpRouter"
-import * as HttpServer from "@effect/platform/HttpServer"
-import type * as Socket from "@effect/platform/Socket"
-import type * as RpcSerialization from "@effect/rpc/RpcSerialization"
+import * as HttpClient from "@effect/platform/HttpClient"
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest"
+import * as HttpRouter from "@effect/platform/HttpLayerRouter"
+import type * as HttpServer from "@effect/platform/HttpServer"
+import type { HttpServerRequest } from "@effect/platform/HttpServerRequest"
+import type { HttpServerResponse } from "@effect/platform/HttpServerResponse"
+import * as Socket from "@effect/platform/Socket"
+import * as RpcClient from "@effect/rpc/RpcClient"
+import * as RpcSerialization from "@effect/rpc/RpcSerialization"
 import * as RpcServer from "@effect/rpc/RpcServer"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import type { Scope } from "effect/Scope"
-import { layerClientProtocolHttp, layerClientProtocolWebsocket } from "./HttpCommon.js"
 import type { MessageStorage } from "./MessageStorage.js"
+import type { RunnerHealth } from "./RunnerHealth.js"
 import * as Runners from "./Runners.js"
+import { RpcClientProtocol } from "./Runners.js"
 import * as RunnerServer from "./RunnerServer.js"
+import type { RunnerStorage } from "./RunnerStorage.js"
 import * as Sharding from "./Sharding.js"
 import type * as ShardingConfig from "./ShardingConfig.js"
-import * as ShardManager from "./ShardManager.js"
-import type { ShardStorage } from "./ShardStorage.js"
-import * as SynchronizedClock from "./SynchronizedClock.js"
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerClientProtocolHttp = (options: {
+  readonly path: string
+  readonly https?: boolean | undefined
+}): Layer.Layer<
+  RpcClientProtocol,
+  never,
+  RpcSerialization.RpcSerialization | HttpClient.HttpClient
+> =>
+  Layer.effect(RpcClientProtocol)(
+    Effect.gen(function*() {
+      const serialization = yield* RpcSerialization.RpcSerialization
+      const client = yield* HttpClient.HttpClient
+      const https = options.https ?? false
+      return (address) => {
+        const clientWithUrl = HttpClient.mapRequest(
+          client,
+          HttpClientRequest.prependUrl(`http${https ? "s" : ""}://${address.host}:${address.port}/${options.path}`)
+        )
+        return RpcClient.makeProtocolHttp(clientWithUrl).pipe(
+          Effect.provideService(RpcSerialization.RpcSerialization, serialization)
+        )
+      }
+    })
+  )
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerClientProtocolHttpDefault: Layer.Layer<
+  Runners.RpcClientProtocol,
+  never,
+  RpcSerialization.RpcSerialization | HttpClient.HttpClient
+> = layerClientProtocolHttp({ path: "/" })
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerClientProtocolWebsocket = (options: {
+  readonly path: string
+  readonly https?: boolean | undefined
+}): Layer.Layer<
+  RpcClientProtocol,
+  never,
+  RpcSerialization.RpcSerialization | Socket.WebSocketConstructor
+> =>
+  Layer.effect(RpcClientProtocol)(
+    Effect.gen(function*() {
+      const serialization = yield* RpcSerialization.RpcSerialization
+      const https = options.https ?? false
+      const constructor = yield* Socket.WebSocketConstructor
+      return Effect.fnUntraced(function*(address) {
+        const socket = yield* Socket.makeWebSocket(
+          `ws${https ? "s" : ""}://${address.host}:${address.port}/${options.path}`
+        ).pipe(
+          Effect.provideService(Socket.WebSocketConstructor, constructor)
+        )
+        return yield* RpcClient.makeProtocolSocket().pipe(
+          Effect.provideService(Socket.Socket, socket),
+          Effect.provideService(RpcSerialization.RpcSerialization, serialization)
+        )
+      })
+    })
+  )
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerClientProtocolWebsocketDefault: Layer.Layer<
+  Runners.RpcClientProtocol,
+  never,
+  RpcSerialization.RpcSerialization | Socket.WebSocketConstructor
+> = layerClientProtocolWebsocket({ path: "/" })
 
 /**
  * @since 1.0.0
  * @category Http App
  */
-export const toHttpApp: Effect.Effect<
-  HttpApp.Default<never, Scope>,
+export const toHttpEffect: Effect.Effect<
+  Effect.Effect<HttpServerResponse, never, Scope | HttpServerRequest>,
   never,
-  Scope | Sharding.Sharding | RpcSerialization.RpcSerialization | MessageStorage
+  Scope | RpcSerialization.RpcSerialization | Sharding.Sharding | MessageStorage
 > = Effect.gen(function*() {
   const handlers = yield* Layer.build(RunnerServer.layerHandlers)
   return yield* RpcServer.toHttpApp(Runners.Rpcs, {
@@ -41,18 +123,16 @@ export const toHttpApp: Effect.Effect<
  * @since 1.0.0
  * @category Http App
  */
-export const toHttpAppWebsocket: Effect.Effect<
-  HttpApp.Default<never, Scope>,
+export const toHttpEffectWebsocket: Effect.Effect<
+  Effect.Effect<HttpServerResponse, never, Scope | HttpServerRequest>,
   never,
-  Scope | Sharding.Sharding | RpcSerialization.RpcSerialization | MessageStorage
+  Scope | RpcSerialization.RpcSerialization | Sharding.Sharding | MessageStorage
 > = Effect.gen(function*() {
   const handlers = yield* Layer.build(RunnerServer.layerHandlers)
   return yield* RpcServer.toHttpAppWebsocket(Runners.Rpcs, {
     spanPrefix: "RunnerServer",
     disableTracing: true
-  }).pipe(
-    Effect.provide(handlers)
-  )
+  }).pipe(Effect.provide(handlers))
 })
 
 /**
@@ -62,75 +142,55 @@ export const toHttpAppWebsocket: Effect.Effect<
 export const layerClient: Layer.Layer<
   Sharding.Sharding | Runners.Runners,
   never,
-  ShardingConfig.ShardingConfig | Runners.RpcClientProtocol | MessageStorage | ShardStorage
+  ShardingConfig.ShardingConfig | Runners.RpcClientProtocol | MessageStorage | RunnerStorage | RunnerHealth
 > = Sharding.layer.pipe(
-  Layer.provideMerge(Runners.layerRpc),
-  Layer.provideMerge(SynchronizedClock.layer),
-  Layer.provide(ShardManager.layerClientRpc)
+  Layer.provideMerge(Runners.layerRpc)
 )
 
 /**
  * A HTTP layer for the `Runners` services, that adds a route to the provided
- * `HttpRouter.Tag`.
- *
- * By default, it uses the `HttpRouter.Default` tag.
+ * `HttpRouter`.
  *
  * @since 1.0.0
  * @category Layers
  */
-export const layer = <I = HttpRouter.Default>(options: {
+export const layerHttpOptions = (options: {
   readonly path: HttpRouter.PathInput
-  readonly routerTag?: HttpRouter.HttpRouter.TagClass<I, string, any, any>
-  readonly logAddress?: boolean | undefined
 }): Layer.Layer<
   Sharding.Sharding | Runners.Runners,
   never,
+  | RunnerStorage
+  | RunnerHealth
   | RpcSerialization.RpcSerialization
+  | MessageStorage
   | ShardingConfig.ShardingConfig
   | Runners.RpcClientProtocol
-  | HttpServer.HttpServer
-  | MessageStorage
-  | ShardStorage
-> => {
-  const layer = RunnerServer.layerWithClients.pipe(
+  | HttpRouter.HttpRouter
+> =>
+  RunnerServer.layerWithClients.pipe(
     Layer.provide(RpcServer.layerProtocolHttp(options))
   )
-  return options.logAddress ? withLogAddress(layer) : layer
-}
 
 /**
  * @since 1.0.0
  * @category Layers
  */
-export const layerWebsocketOptions = <I = HttpRouter.Default>(options: {
+export const layerWebsocketOptions = (options: {
   readonly path: HttpRouter.PathInput
-  readonly routerTag?: HttpRouter.HttpRouter.TagClass<I, string, any, any>
-  readonly logAddress?: boolean | undefined
 }): Layer.Layer<
   Sharding.Sharding | Runners.Runners,
   never,
-  | RpcSerialization.RpcSerialization
   | ShardingConfig.ShardingConfig
   | Runners.RpcClientProtocol
-  | HttpServer.HttpServer
   | MessageStorage
-  | ShardStorage
-> => {
-  const layer = RunnerServer.layerWithClients.pipe(
+  | RunnerStorage
+  | RunnerHealth
+  | RpcSerialization.RpcSerialization
+  | HttpRouter.HttpRouter
+> =>
+  RunnerServer.layerWithClients.pipe(
     Layer.provide(RpcServer.layerProtocolWebsocket(options))
   )
-  return options.logAddress ? withLogAddress(layer) : layer
-}
-
-const withLogAddress = <A, E, R>(layer: Layer.Layer<A, E, R>): Layer.Layer<A, E, R | HttpServer.HttpServer> =>
-  Layer.effectDiscard(
-    HttpServer.addressFormattedWith((address) =>
-      Effect.annotateLogs(Effect.logInfo(`Listening on: ${address}`), {
-        package: "@effect/cluster",
-        service: "Runner"
-      })
-    )
-  ).pipe(Layer.provideMerge(layer))
 
 /**
  * @since 1.0.0
@@ -144,10 +204,10 @@ export const layerHttp: Layer.Layer<
   | HttpClient.HttpClient
   | HttpServer.HttpServer
   | MessageStorage
-  | ShardStorage
-> = HttpRouter.Default.serve().pipe(
-  Layer.provideMerge(layer({ path: "/", logAddress: true })),
-  Layer.provide(layerClientProtocolHttp({ path: "/" }))
+  | RunnerStorage
+  | RunnerHealth
+> = HttpRouter.serve(layerHttpOptions({ path: "/" })).pipe(
+  Layer.provide(layerClientProtocolHttpDefault)
 )
 
 /**
@@ -161,8 +221,9 @@ export const layerHttpClientOnly: Layer.Layer<
   | ShardingConfig.ShardingConfig
   | HttpClient.HttpClient
   | MessageStorage
+  | RunnerStorage
 > = RunnerServer.layerClientOnly.pipe(
-  Layer.provide(layerClientProtocolHttp({ path: "/" }))
+  Layer.provide(layerClientProtocolHttpDefault)
 )
 
 /**
@@ -177,10 +238,10 @@ export const layerWebsocket: Layer.Layer<
   | Socket.WebSocketConstructor
   | HttpServer.HttpServer
   | MessageStorage
-  | ShardStorage
-> = HttpRouter.Default.serve().pipe(
-  Layer.provideMerge(layerWebsocketOptions({ path: "/", logAddress: true })),
-  Layer.provide(layerClientProtocolWebsocket({ path: "/" }))
+  | RunnerStorage
+  | RunnerHealth
+> = HttpRouter.serve(layerWebsocketOptions({ path: "/" })).pipe(
+  Layer.provide(layerClientProtocolWebsocketDefault)
 )
 
 /**
@@ -190,7 +251,11 @@ export const layerWebsocket: Layer.Layer<
 export const layerWebsocketClientOnly: Layer.Layer<
   Sharding.Sharding | Runners.Runners,
   never,
-  ShardingConfig.ShardingConfig | MessageStorage | RpcSerialization.RpcSerialization | Socket.WebSocketConstructor
+  | ShardingConfig.ShardingConfig
+  | MessageStorage
+  | RunnerStorage
+  | RpcSerialization.RpcSerialization
+  | Socket.WebSocketConstructor
 > = RunnerServer.layerClientOnly.pipe(
-  Layer.provide(layerClientProtocolWebsocket({ path: "/" }))
+  Layer.provide(layerClientProtocolWebsocketDefault)
 )

package/src/MessageStorage.ts

@@ -15,13 +15,13 @@ import type { ParseError } from "effect/ParseResult"
 import type { Predicate } from "effect/Predicate"
 import * as Schema from "effect/Schema"
 import type { PersistenceError } from "./ClusterError.js"
-import { MalformedMessage } from "./ClusterError.js"
+import { EntityNotAssignedToRunner, MalformedMessage } from "./ClusterError.js"
 import * as DeliverAt from "./DeliverAt.js"
 import type { EntityAddress } from "./EntityAddress.js"
 import * as Envelope from "./Envelope.js"
 import * as Message from "./Message.js"
 import * as Reply from "./Reply.js"
-import { ShardId } from "./ShardId.js"
+import type { ShardId } from "./ShardId.js"
 import type { ShardingConfig } from "./ShardingConfig.js"
 import * as Snowflake from "./Snowflake.js"
 
@@ -88,15 +88,19 @@ export class MessageStorage extends Context.Tag("@effect/cluster/MessageStorage"
    * For locally sent messages, register a handler to process the replies.
    */
   readonly registerReplyHandler: <R extends Rpc.Any>(
-    message: Message.OutgoingRequest<R> | Message.IncomingRequest<R>,
-    onUnregister: Effect.Effect<void>
-  ) => Effect.Effect<void>
+    message: Message.OutgoingRequest<R> | Message.IncomingRequest<R>
+  ) => Effect.Effect<void, EntityNotAssignedToRunner>
 
   /**
    * Unregister the reply handler for the specified message.
    */
   readonly unregisterReplyHandler: (requestId: Snowflake.Snowflake) => Effect.Effect<void>
 
+  /**
+   * Unregister the reply handlers for the specified ShardId.
+   */
+  readonly unregisterShardReplyHandlers: (shardId: ShardId) => Effect.Effect<void>
+
   /**
    * Retrieves the unprocessed messages for the specified shards.
    *
@@ -342,38 +346,98 @@ export type EncodedRepliesOptions<A> = {
  * @category constructors
  */
 export const make = (
-  storage: Omit<MessageStorage["Type"], "registerReplyHandler" | "unregisterReplyHandler">
+  storage: Omit<
+    MessageStorage["Type"],
+    "registerReplyHandler" | "unregisterReplyHandler" | "unregisterShardReplyHandlers"
+  >
 ): Effect.Effect<MessageStorage["Type"]> =>
   Effect.sync(() => {
-    const replyHandlers = new Map<Snowflake.Snowflake, {
+    type ReplyHandler = {
+      readonly message: Message.OutgoingRequest<any> | Message.IncomingRequest<any>
+      readonly shardSet: Set<ReplyHandler>
       readonly respond: (reply: Reply.ReplyWithContext<any>) => Effect.Effect<void, PersistenceError | MalformedMessage>
-      readonly onUnregister: Effect.Effect<void>
-    }>()
+      readonly resume: (effect: Effect.Effect<void, EntityNotAssignedToRunner>) => void
+    }
+    const replyHandlers = new Map<Snowflake.Snowflake, Array<ReplyHandler>>()
+    const replyHandlersShard = new Map<string, Set<ReplyHandler>>()
     return MessageStorage.of({
       ...storage,
-      registerReplyHandler: (message, onUnregister) =>
-        Effect.sync(() => {
-          replyHandlers.set(message.envelope.requestId, {
+      registerReplyHandler: (message) => {
+        const requestId = message.envelope.requestId
+        return Effect.async<void, EntityNotAssignedToRunner>((resume) => {
+          const shardId = message.envelope.address.shardId.toString()
+          let handlers = replyHandlers.get(requestId)
+          if (handlers === undefined) {
+            handlers = []
+            replyHandlers.set(requestId, handlers)
+          }
+          let shardSet = replyHandlersShard.get(shardId)
+          if (!shardSet) {
+            shardSet = new Set()
+            replyHandlersShard.set(shardId, shardSet)
+          }
+          const entry: ReplyHandler = {
+            message,
+            shardSet,
             respond: message._tag === "IncomingRequest" ? message.respond : (reply) => message.respond(reply.reply),
-            onUnregister
+            resume
+          }
+          handlers.push(entry)
+          shardSet.add(entry)
+          return Effect.sync(() => {
+            const index = handlers.indexOf(entry)
+            handlers.splice(index, 1)
+            shardSet.delete(entry)
           })
-        }),
+        })
+      },
       unregisterReplyHandler: (requestId) =>
-        Effect.suspend(() => {
-          const handler = replyHandlers.get(requestId)
-          if (!handler) return Effect.void
+        Effect.sync(() => {
+          const handlers = replyHandlers.get(requestId)
+          if (!handlers) return Effect.void
           replyHandlers.delete(requestId)
-          return handler.onUnregister
+          for (let i = 0; i < handlers.length; i++) {
+            const handler = handlers[i]
+            handler.shardSet.delete(handler)
+            handler.resume(Effect.fail(
+              new EntityNotAssignedToRunner({
+                address: handler.message.envelope.address
+              })
+            ))
+          }
+        }),
+      unregisterShardReplyHandlers: (shardId) =>
+        Effect.sync(() => {
+          const id = shardId.toString()
+          const shardSet = replyHandlersShard.get(id)
+          if (!shardSet) return
+          replyHandlersShard.delete(id)
+          shardSet.forEach((handler) => {
+            replyHandlers.delete(handler.message.envelope.requestId)
+            handler.resume(Effect.fail(
+              new EntityNotAssignedToRunner({
+                address: handler.message.envelope.address
+              })
+            ))
+          })
         }),
       saveReply(reply) {
+        const requestId = reply.reply.requestId
         return Effect.flatMap(storage.saveReply(reply), () => {
-          const handler = replyHandlers.get(reply.reply.requestId)
-          if (!handler) {
+          const handlers = replyHandlers.get(requestId)
+          if (!handlers) {
             return Effect.void
           } else if (reply.reply._tag === "WithExit") {
-            replyHandlers.delete(reply.reply.requestId)
+            replyHandlers.delete(requestId)
+            for (let i = 0; i < handlers.length; i++) {
+              const handler = handlers[i]
+              handler.shardSet.delete(handler)
+              handler.resume(Effect.void)
+            }
           }
-          return handler.respond(reply)
+          return handlers.length === 1
+            ? handlers[0].respond(reply)
+            : Effect.forEach(handlers, (handler) => handler.respond(reply))
         })
       }
     })
@@ -748,8 +812,9 @@ export class MemoryDriver extends Effect.Service<MemoryDriver>()("@effect/cluste
           }>()
           for (let index = 0; index < journal.length; index++) {
             const envelope = journal[index]
-            const shardId = ShardId.make(envelope.address.shardId)
-            if (!unprocessed.has(envelope as any) || !shardIds.includes(shardId.toString())) {
+            const shardId = envelope.address.shardId
+            const shardIdStr = `${shardId.group}:${shardId.id}`
+            if (!unprocessed.has(envelope as any) || !shardIds.includes(shardIdStr)) {
               continue
             }
             if (envelope._tag === "Request") {

package/src/Runner.ts

@@ -38,7 +38,7 @@ export type TypeId = typeof TypeId
 export class Runner extends Schema.Class<Runner>(SymbolKey)({
   address: RunnerAddress,
   groups: Schema.Array(Schema.String),
-  version: Schema.Int
+  weight: Schema.Number
 }) {
   /**
    * @since 1.0.0
@@ -71,14 +71,14 @@ export class Runner extends Schema.Class<Runner>(SymbolKey)({
    * @since 1.0.0
    */
   [Equal.symbol](that: Runner): boolean {
-    return this.address[Equal.symbol](that.address) && this.version === that.version
+    return this.address[Equal.symbol](that.address) && this.weight === that.weight
   }
 
   /**
    * @since 1.0.0
    */
   [Hash.symbol](): number {
-    return Hash.cached(this, Hash.string(`${this.address.toString()}:${this.version}`))
+    return Hash.cached(this, Hash.string(`${this.address.toString()}:${this.weight}`))
   }
 }
 
@@ -98,5 +98,5 @@ export class Runner extends Schema.Class<Runner>(SymbolKey)({
 export const make = (props: {
   readonly address: RunnerAddress
   readonly groups: ReadonlyArray<string>
-  readonly version: number
+  readonly weight: number
 }): Runner => new Runner(props)

package/src/RunnerAddress.ts

@@ -4,6 +4,7 @@
 import * as Equal from "effect/Equal"
 import * as Hash from "effect/Hash"
 import { NodeInspectSymbol } from "effect/Inspectable"
+import * as PrimaryKey from "effect/PrimaryKey"
 import * as Schema from "effect/Schema"
 
 const SymbolKey = "@effect/cluster/RunnerAddress"
@@ -33,6 +34,13 @@ export class RunnerAddress extends Schema.Class<RunnerAddress>(SymbolKey)({
    */
   readonly [TypeId] = TypeId;
 
+  /**
+   * @since 1.0.0
+   */
+  [PrimaryKey.symbol](): string {
+    return `${this.host}:${this.port}`
+  }
+
   /**
    * @since 1.0.0
    */