effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/unstable/cluster/Runners.ts

@@ -25,7 +25,8 @@ import * as RpcClient_ from "../rpc/RpcClient.ts"
 import type { RpcClientError } from "../rpc/RpcClientError.ts"
 import * as RpcGroup from "../rpc/RpcGroup.ts"
 import * as RpcSchema from "../rpc/RpcSchema.ts"
-import type { PersistenceError } from "./ClusterError.ts"
+import type * as RpcSerialization from "../rpc/RpcSerialization.ts"
+import type { MalformedMessage, PersistenceError } from "./ClusterError.ts"
 import { AlreadyProcessingMessage, EntityNotAssignedToRunner, MailboxFull, RunnerUnavailable } from "./ClusterError.ts"
 import { Persisted } from "./ClusterSchema.ts"
 import * as Envelope from "./Envelope.ts"
@@ -147,7 +148,7 @@ export class Runners extends Context.Service<Runners, {
  *
  * `make` uses the supplied remote callbacks for runner communication and
  * derives `sendLocal` and `notifyLocal`. Local sends can optionally simulate
- * remote serialization, persisted notifications are saved through
+ * remote serialization with the supplied transport codec, persisted notifications are saved through
  * `MessageStorage`, duplicate requests are resumed from stored replies when
  * possible, and pending replies are polled according to
  * `ShardingConfig.entityReplyPollInterval`.
@@ -158,15 +159,20 @@ export class Runners extends Context.Service<Runners, {
  * @category constructors
  * @since 4.0.0
  */
-export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal">) => Effect.Effect<
+export const make: (
+  options: Omit<Runners["Service"], "sendLocal" | "notifyLocal"> & {
+    readonly codecFor: RpcSerialization.CodecFor
+  }
+) => Effect.Effect<
   Runners["Service"],
   never,
   MessageStorage.MessageStorage | Snowflake.Generator | ShardingConfig | Scope
-> = Effect.fnUntraced(function*(options: Omit<Runners["Service"], "sendLocal" | "notifyLocal">) {
+> = Effect.fnUntraced(function*(options) {
   const storage = yield* MessageStorage.MessageStorage
   const runnersScope = yield* Effect.scope
   const snowflakeGen = yield* Snowflake.Generator
   const config = yield* ShardingConfig
+  const { codecFor, ...serviceOptions } = options
 
   const requestIdRewrites = new Map<Snowflake.Snowflake, Snowflake.Snowflake>()
 
@@ -357,14 +363,14 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
   }
 
   return Runners.of({
-    ...options,
+    ...serviceOptions,
     sendLocal(options) {
       const message = options.message
       if (!options.simulateRemoteSerialization) {
         return options.send(Message.incomingLocalFromOutgoing(message))
       }
-      return Message.serialize(message).pipe(
-        Effect.flatMap((encoded) => Message.deserializeLocal(message, encoded)),
+      return Message.serialize(message, codecFor).pipe(
+        Effect.flatMap((encoded) => Message.deserializeLocal(message, encoded, codecFor)),
         Effect.flatMap(options.send),
         Effect.catchTag("MalformedMessage", (error) => {
           if (message._tag === "OutgoingEnvelope") {
@@ -435,6 +441,7 @@ export const makeNoop: Effect.Effect<
   never,
   MessageStorage.MessageStorage | Snowflake.Generator | ShardingConfig | Scope
 > = make({
+  codecFor: Schema.toCodecJson as RpcSerialization.CodecFor,
   send: ({ message }) => Effect.fail(new EntityNotAssignedToRunner({ address: message.envelope.address })),
   notify: () => Effect.void,
   ping: () => Effect.void,
@@ -541,22 +548,27 @@ export const makeRpc: Effect.Effect<
   never,
   Scope | RpcClientProtocol | MessageStorage.MessageStorage | Snowflake.Generator | ShardingConfig
 > = Effect.gen(function*() {
-  const makeClientProtocol = yield* RpcClientProtocol
+  const clientProtocol = yield* RpcClientProtocol
   const snowflakeGen = yield* Snowflake.Generator
 
   const clients = yield* RcMap.make({
     lookup: (address: RunnerAddress) =>
       Effect.flatMap(
-        makeClientProtocol(address),
-        (protocol) => Effect.provideService(makeRpcClient, RpcClient_.Protocol, protocol)
+        clientProtocol.make(address),
+        (protocol) =>
+          Effect.map(
+            Effect.provideService(makeRpcClient, RpcClient_.Protocol, protocol),
+            (client) => ({ client, codecFor: protocol.codecFor })
+          )
       ),
     idleTimeToLive: "3 minutes"
   })
 
   return yield* make({
+    codecFor: clientProtocol.codecFor,
     ping(address) {
       return RcMap.get(clients, address).pipe(
-        Effect.flatMap((client) => client.Ping()),
+        Effect.flatMap(({ client }) => client.Ping()),
         Effect.catchCause(() =>
           Effect.andThen(
             RcMap.invalidate(clients, address),
@@ -571,7 +583,7 @@ export const makeRpc: Effect.Effect<
       const isPersisted = Context.get(rpc.annotations, Persisted)
       if (message._tag === "OutgoingEnvelope") {
         return RcMap.get(clients, address).pipe(
-          Effect.flatMap((client) =>
+          Effect.flatMap(({ client }) =>
             client.Envelope({
               envelope: message.envelope,
               persisted: isPersisted
@@ -593,70 +605,66 @@ export const makeRpc: Effect.Effect<
               exit: Exit.die(defect)
             })
           )
+      const respondMalformed = (error: MalformedMessage) =>
+        message.respond(
+          new Reply.WithExit({
+            id: snowflakeGen.nextUnsafe(),
+            requestId: message.envelope.requestId,
+            exit: Exit.die(error)
+          })
+        )
       const isStream = RpcSchema.isStreamSchema(rpc.successSchema)
       if (!isStream) {
-        return Effect.matchEffect(Message.serializeRequest(message), {
-          onSuccess: (request) =>
-            RcMap.get(clients, address).pipe(
-              Effect.flatMap((client) =>
+        return RcMap.get(clients, address).pipe(
+          Effect.flatMap(({ client, codecFor }) =>
+            Effect.matchEffect(Message.serializeRequest(message, codecFor), {
+              onSuccess: (request) =>
                 client.Effect({
                   request,
                   persisted: isPersisted
-                })
-              ),
-              Effect.flatMap((reply) =>
-                Schema.decodeEffect(Reply.Reply(message.rpc))(reply).pipe(
-                  Effect.provideContext(message.context),
-                  Effect.orDie
-                )
-              ),
-              Effect.flatMap(message.respond),
-              Effect.scoped,
-              Effect.catchTag("RpcClientError", () => Effect.fail(new RunnerUnavailable({ address }))),
-              Effect.catchDefect(respondDefect)
-            ),
-          onFailure: (error) =>
-            message.respond(
-              new Reply.WithExit({
-                id: snowflakeGen.nextUnsafe(),
-                requestId: message.envelope.requestId,
-                exit: Exit.die(error)
-              })
-            )
-        })
+                }).pipe(
+                  Effect.flatMap((reply) =>
+                    Schema.decodeEffect(Reply.Reply(message.rpc, codecFor))(reply).pipe(
+                      Effect.provideContext(message.context),
+                      Effect.orDie
+                    )
+                  ),
+                  Effect.flatMap(message.respond),
+                  Effect.catchTag("RpcClientError", () => Effect.fail(new RunnerUnavailable({ address }))),
+                  Effect.catchDefect(respondDefect)
+                ),
+              onFailure: respondMalformed
+            })
+          ),
+          Effect.scoped
+        )
       }
-      return Effect.matchEffect(Message.serializeRequest(message), {
-        onSuccess: (request) =>
-          RcMap.get(clients, address).pipe(
-            Effect.flatMap((client) =>
+      return RcMap.get(clients, address).pipe(
+        Effect.flatMap(({ client, codecFor }) =>
+          Effect.matchEffect(Message.serializeRequest(message, codecFor), {
+            onSuccess: (request) =>
               client.Stream({
                 request,
                 persisted: isPersisted
-              }, { asQueue: true })
-            ),
-            Effect.flatMap((queue) => {
-              const decode = Schema.decodeEffect(Reply.Reply(message.rpc))
-              return Queue.take(queue).pipe(
-                Effect.flatMap((reply) => Effect.orDie(decode(reply))),
-                Effect.flatMap(message.respond),
-                Effect.forever,
-                Effect.provideContext(message.context),
-                Effect.catchTag("Done", (_) => Effect.void),
-                Effect.catchTag("RpcClientError", () => Effect.fail(new RunnerUnavailable({ address }))),
-                Effect.catchDefect(respondDefect)
-              )
-            }),
-            Effect.scoped
-          ),
-        onFailure: (error) =>
-          message.respond(
-            new Reply.WithExit({
-              id: snowflakeGen.nextUnsafe(),
-              requestId: message.envelope.requestId,
-              exit: Exit.die(error)
-            })
-          )
-      })
+              }, { asQueue: true }).pipe(
+                Effect.flatMap((queue) => {
+                  const decode = Schema.decodeEffect(Reply.Reply(message.rpc, codecFor))
+                  return Queue.take(queue).pipe(
+                    Effect.flatMap((reply) => Effect.orDie(decode(reply))),
+                    Effect.flatMap(message.respond),
+                    Effect.forever,
+                    Effect.provideContext(message.context),
+                    Effect.catchTag("Done", (_) => Effect.void),
+                    Effect.catchTag("RpcClientError", () => Effect.fail(new RunnerUnavailable({ address }))),
+                    Effect.catchDefect(respondDefect)
+                  )
+                })
+              ),
+            onFailure: respondMalformed
+          })
+        ),
+        Effect.scoped
+      )
     },
     notify({ address, message }) {
       if (Option.isNone(address)) {
@@ -665,19 +673,21 @@ export const makeRpc: Effect.Effect<
       const rpc = message.rpc as any as Rpc.AnyWithProps
       const isPersisted = Context.get(rpc.annotations, Persisted)
       const envelope = message.envelope
-      const encode: Effect.Effect<Envelope.AckChunk | Envelope.Interrupt | Envelope.PartialRequest> =
-        message._tag === "OutgoingRequest" ? Effect.orDie(Message.serializeRequest(message)) : Effect.succeed(envelope)
-      const notify = Effect.flatMap(encode, (envelope) =>
-        RcMap.get(clients, address.value).pipe(
-          Effect.flatMap((client) =>
+      const notify = RcMap.get(clients, address.value).pipe(
+        Effect.flatMap(({ client, codecFor }) => {
+          const encode: Effect.Effect<Envelope.AckChunk | Envelope.Interrupt | Envelope.PartialRequest> =
+            message._tag === "OutgoingRequest"
+              ? Effect.orDie(Message.serializeRequest(message, codecFor))
+              : Effect.succeed(envelope)
+          return Effect.flatMap(encode, (envelope) =>
             client.Notify({
               envelope,
               persisted: isPersisted
-            })
-          ),
-          Effect.scoped,
-          Effect.catchTag("RpcClientError", () => Effect.fail(new RunnerUnavailable({ address: address.value })))
-        ))
+            }))
+        }),
+        Effect.scoped,
+        Effect.catchTag("RpcClientError", () => Effect.fail(new RunnerUnavailable({ address: address.value })))
+      )
       return isPersisted ? Effect.ignore(notify) : notify
     },
     onRunnerUnavailable: (address) => RcMap.invalidate(clients, address)
@@ -700,13 +710,16 @@ export const layerRpc: Layer.Layer<
 )
 
 /**
- * Service that creates an RPC client protocol for communicating with a runner at a
- * given address.
+ * Service that creates RPC client protocols for runner addresses and exposes
+ * the codec shared by those protocols.
  *
  * @category services
  * @since 4.0.0
  */
 export class RpcClientProtocol extends Context.Service<
   RpcClientProtocol,
-  (address: RunnerAddress) => Effect.Effect<RpcClient_.Protocol["Service"], never, Scope>
+  {
+    readonly make: (address: RunnerAddress) => Effect.Effect<RpcClient_.Protocol["Service"], never, Scope>
+    readonly codecFor: RpcSerialization.CodecFor
+  }
 >()("effect/cluster/Runners/RpcClientProtocol") {}

package/src/unstable/cluster/Sharding.ts

@@ -45,16 +45,17 @@ import { AlreadyProcessingMessage, EntityNotAssignedToRunner } from "./ClusterEr
 import * as ClusterMetrics from "./ClusterMetrics.ts"
 import { Persisted } from "./ClusterSchema.ts"
 import * as ClusterSchema from "./ClusterSchema.ts"
-import type { CurrentAddress, CurrentRunnerAddress, Entity, HandlersFrom } from "./Entity.ts"
+import { CurrentAddress, type CurrentRunnerAddress, type Entity, type HandlersFrom } from "./Entity.ts"
 import type { EntityAddress } from "./EntityAddress.ts"
 import { make as makeEntityAddress } from "./EntityAddress.ts"
 import type { EntityId } from "./EntityId.ts"
 import { make as makeEntityId } from "./EntityId.ts"
 import * as Envelope from "./Envelope.ts"
+import * as ClusterAbandon from "./internal/clusterAbandon.ts"
 import * as EntityManager from "./internal/entityManager.ts"
 import { EntityReaper } from "./internal/entityReaper.ts"
 import { hashString } from "./internal/hash.ts"
-import { internalInterruptors } from "./internal/interruptors.ts"
+import * as ActiveTeardown from "./internal/interruptors.ts"
 import { ResourceMap } from "./internal/resourceMap.ts"
 import { effectiveInterval } from "./internal/shardLock.ts"
 import * as Message from "./Message.ts"
@@ -317,7 +318,13 @@ const make = Effect.gen(function*() {
       for (const shardId of shardIds) {
         MutableHashSet.remove(releasingShards, shardId)
         MutableHashSet.remove(forceReleasingShards, shardId)
-        yield* storage.unregisterShardReplyHandlers(shardId)
+        // During shutdown, parked waiters are interrupted: this runner will
+        // never observe the reply. During a rebalance the waiters are resumed
+        // with `EntityNotAssignedToRunner`, and the client falls back to
+        // waiting for the reply via storage while the entity moves.
+        yield* storage.unregisterShardReplyHandlers(shardId, {
+          interrupt: MutableRef.get(isShutdown)
+        })
       }
     })
     const retryShardRelease =
@@ -552,7 +559,7 @@ const make = Effect.gen(function*() {
     const probeShardLocks = runnerStorage.refresh(selfAddress, []).pipe(
       Effect.timeout(shardLockInterval),
       Effect.andThen(markShardLocksHealthy),
-      Effect.catchCause(() => Effect.void)
+      Effect.catchCause((cause) => Effect.logWarning("Shard lock storage is still unhealthy", cause))
     )
 
     // Refresh shard locks at the lease-safe interval, or probe storage while
@@ -1113,7 +1120,13 @@ const make = Effect.gen(function*() {
       return Effect.catchTag(persist, "MalformedMessage", Effect.die).pipe(
         Effect.andThen(
           shouldFail
-            ? Effect.fail(error)
+            // The message is durable, so a transient routing state is never an
+            // error for the caller. The runner is tearing down and can no
+            // longer observe the reply, so interrupt the caller instead: the
+            // request will be served under the next owner.
+            ? message._tag === "OutgoingRequest"
+              ? ClusterAbandon.interrupt
+              : Effect.fail(error)
             : Effect.logWarning("Persisting outgoing message abandoned during shutdown", message.envelope.address)
         )
       )
@@ -1328,6 +1341,13 @@ const make = Effect.gen(function*() {
     never
   > = yield* ResourceMap.make(
     Effect.fnUntraced(function*(entity: Entity<string, any>) {
+      const clientScope = yield* Effect.scope
+      yield* Scope.addFinalizer(
+        clientScope,
+        Effect.sync(() => {
+          ActiveTeardown.releaseEntityType(entity.type)
+        })
+      )
       const client = yield* RpcClient.makeNoSerialization(entity.protocol, {
         spanPrefix: `${entity.type}.client`,
         disableTracing: !Context.get(entity.protocol.annotations, ClusterSchema.ClientTracingEnabled),
@@ -1406,8 +1426,9 @@ const make = Effect.gen(function*() {
               }
               // for durable messages, we ignore interrupts on shutdown or as a
               // result of a shard being resassigned
+              const caller = Context.getOption(entry.context, CurrentAddress).valueOrUndefined
               const isTransientInterrupt = MutableRef.get(isShutdown) ||
-                options.message.interruptors.some((id) => internalInterruptors.has(id))
+                (caller !== undefined && ActiveTeardown.isActive(caller))
               if (isTransientInterrupt && Context.get(entry.message.annotations, Persisted)) {
                 return Effect.void
               }
@@ -1430,10 +1451,9 @@ const make = Effect.gen(function*() {
       })
 
       yield* Scope.addFinalizer(
-        yield* Effect.scope,
-        Effect.withFiber((fiber) => {
-          internalInterruptors.add(fiber.id)
-          return Effect.void
+        clientScope,
+        Effect.sync(() => {
+          ActiveTeardown.acquireEntityType(entity.type)
         })
       )
 
@@ -1567,8 +1587,10 @@ const make = Effect.gen(function*() {
         const shouldBeRunning = MutableHashSet.has(acquiredShards, shardId)
         if (running && !shouldBeRunning) {
           yield* Effect.logDebug("Stopping singleton", address)
-          internalInterruptors.add(yield* Effect.fiberId)
-          yield* FiberMap.remove(singletonFibers, address)
+          yield* ActiveTeardown.aroundShard(
+            address.shardId,
+            FiberMap.remove(singletonFibers, address)
+          )
         } else if (!running && shouldBeRunning) {
           yield* Effect.logDebug("Starting singleton", address)
           yield* FiberMap.run(singletonFibers, address, run)
@@ -1591,6 +1613,7 @@ const make = Effect.gen(function*() {
       const runnerAddress = getRunnerAddress()
       if (!runnerAddress || entityManagers.has(entity.type)) return
       const scope = yield* Effect.scope
+      const registrationContext = yield* Effect.context<never>()
       yield* Scope.addFinalizer(
         scope,
         Effect.sync(() => {
@@ -1605,6 +1628,10 @@ const make = Effect.gen(function*() {
         sharding
       }).pipe(
         Effect.provideContext(services.pipe(
+          // Registration overrides construction fallbacks, except for runner-owned services.
+          Context.merge(registrationContext),
+          Context.add(ShardingConfig, config),
+          Context.add(Clock, clock),
           Context.add(EntityReaper, reaper),
           Context.add(Scope.Scope, scope),
           Context.add(Snowflake.Generator, snowflakeGen)
@@ -1617,12 +1644,12 @@ const make = Effect.gen(function*() {
       }
       yield* Scope.addFinalizer(
         scope,
-        Effect.withFiber((fiber) => {
+        Effect.suspend(() => {
           state.status = "closing"
-          internalInterruptors.add(fiber.id)
-          // if preemptive shutdown is enabled, we start shutting down Sharding
-          // too
-          return config.preemptiveShutdown ? shutdown() : Effect.void
+          return ActiveTeardown.aroundEntityType(
+            entity.type,
+            config.preemptiveShutdown ? shutdown() : Effect.void
+          )
         })
       )
 
@@ -1704,9 +1731,7 @@ const make = Effect.gen(function*() {
       )
     }
 
-    internalInterruptors.add(yield* Effect.fiberId)
     if (isShutdown.current) return
-
     MutableRef.set(isShutdown, true)
     if (selfRunner) {
       yield* Effect.ignore(runnerStorage.unregister(selfRunner.address))

package/src/unstable/cluster/ShardingConfig.ts

@@ -248,56 +248,56 @@ export const layerDefaults: Layer.Layer<ShardingConfig> = layer()
  */
 export const config: Config.Config<ShardingConfig["Service"]> = Config.all({
   runnerAddress: Config.all({
-    host: Config.string("host").pipe(
+    host: Config.String("host").pipe(
       Config.withDefault(defaultRunnerAddress.host)
       // Config.withDescription("The hostname or IP address of the runner.")
     ),
-    port: Config.int("port").pipe(
+    port: Config.Int("port").pipe(
       Config.withDefault(defaultRunnerAddress.port)
       // Config.withDescription("The port used for inter-runner communication.")
     )
   }).pipe(Config.map((options) => RunnerAddress.make(options)), Config.option),
   runnerListenAddress: Config.all({
-    host: Config.string("listenHost"),
+    host: Config.String("listenHost"),
     // Config.withDescription("The host to listen on.")
-    port: Config.int("listenPort").pipe(
+    port: Config.Int("listenPort").pipe(
       Config.withDefault(defaultRunnerAddress.port)
       // Config.withDescription("The port to listen on.")
     )
   }).pipe(Config.map((options) => RunnerAddress.make(options)), Config.option),
-  runnerShardWeight: Config.int("runnerShardWeight").pipe(
+  runnerShardWeight: Config.Int("runnerShardWeight").pipe(
     Config.withDefault(defaults.runnerShardWeight)
     // Config.withDescription("A number that determines how many shards this runner will be assigned relative to other runners.")
   ),
-  availableShardGroups: Config.schema(Config.Array(Schema.String), "availableShardGroups").pipe(
+  availableShardGroups: Config.Array(Schema.String, "availableShardGroups").pipe(
     Config.withDefault(["default"])
     // Config.withDescription("The shard groups available across all runners.")
   ),
-  assignedShardGroups: Config.schema(Config.Array(Schema.String), "shardGroups").pipe(
+  assignedShardGroups: Config.Array(Schema.String, "shardGroups").pipe(
     Config.withDefault(["default"])
     // Config.withDescription("The shard groups that are assigned to this runner.")
   ),
-  shardsPerGroup: Config.int("shardsPerGroup").pipe(
+  shardsPerGroup: Config.Int("shardsPerGroup").pipe(
     Config.withDefault(defaults.shardsPerGroup)
     // Config.withDescription("The number of shards to allocate per shard group.")
   ),
-  shardLockRefreshInterval: Config.duration("shardLockRefreshInterval").pipe(
+  shardLockRefreshInterval: Config.Duration("shardLockRefreshInterval").pipe(
     Config.withDefault(defaults.shardLockRefreshInterval)
     // Config.withDescription("Shard lock refresh interval.")
   ),
-  shardLockExpiration: Config.duration("shardLockExpiration").pipe(
+  shardLockExpiration: Config.Duration("shardLockExpiration").pipe(
     Config.withDefault(defaults.shardLockExpiration)
     // Config.withDescription("Shard lock expiration duration.")
   ),
-  shardLockDisableAdvisory: Config.boolean("shardLockDisableAdvisory").pipe(
+  shardLockDisableAdvisory: Config.Boolean("shardLockDisableAdvisory").pipe(
     Config.withDefault(defaults.shardLockDisableAdvisory)
     // Config.withDescription("Disable the use of advisory locks for shard locking.")
   ),
-  preemptiveShutdown: Config.boolean("preemptiveShutdown").pipe(
+  preemptiveShutdown: Config.Boolean("preemptiveShutdown").pipe(
     Config.withDefault(defaults.preemptiveShutdown)
     // Config.withDescription("Start shutting down as soon as an Entity has started shutting down.")
   ),
-  entityMailboxCapacity: Config.int("entityMailboxCapacity").pipe(
+  entityMailboxCapacity: Config.Int("entityMailboxCapacity").pipe(
     Config.withDefault(defaults.entityMailboxCapacity)
     // Config.withDescription("The default capacity of the mailbox for entities.")
   ),
@@ -315,42 +315,42 @@ export const config: Config.Config<ShardingConfig["Service"]> = Config.all({
     Config.withDefault(defaults.unprocessedMessageBatchSize)
     // Config.withDescription("The maximum number of unprocessed messages read from storage in a single poll.")
   ),
-  entityMaxIdleTime: Config.duration("entityMaxIdleTime").pipe(
+  entityMaxIdleTime: Config.Duration("entityMaxIdleTime").pipe(
     Config.withDefault(defaults.entityMaxIdleTime)
     // Config.withDescription(
     //   "The maximum duration of inactivity (i.e. without receiving a message) after which an entity will be interrupted."
     // )
   ),
-  entityRegistrationTimeout: Config.duration("entityRegistrationTimeout").pipe(
+  entityRegistrationTimeout: Config.Duration("entityRegistrationTimeout").pipe(
     Config.withDefault(defaults.entityRegistrationTimeout)
     // Config.withDescription("If an entity does not register itself within this time after a message is sent to it, the message will be marked as failed.")
   ),
-  entityTerminationTimeout: Config.duration("entityTerminationTimeout").pipe(
+  entityTerminationTimeout: Config.Duration("entityTerminationTimeout").pipe(
     Config.withDefault(defaults.entityTerminationTimeout)
     // Config.withDescription("The maximum duration of time to wait for an entity to terminate.")
   ),
-  entityMessagePollInterval: Config.duration("entityMessagePollInterval").pipe(
+  entityMessagePollInterval: Config.Duration("entityMessagePollInterval").pipe(
     Config.withDefault(defaults.entityMessagePollInterval)
     // Config.withDescription("The interval at which to poll for unprocessed messages from storage.")
   ),
-  entityReplyPollInterval: Config.duration("entityReplyPollInterval").pipe(
+  entityReplyPollInterval: Config.Duration("entityReplyPollInterval").pipe(
     Config.withDefault(defaults.entityReplyPollInterval)
     // Config.withDescription("The interval at which to poll for client replies from storage.")
   ),
-  sendRetryInterval: Config.duration("sendRetryInterval").pipe(
+  sendRetryInterval: Config.Duration("sendRetryInterval").pipe(
     Config.withDefault(defaults.sendRetryInterval)
     // Config.withDescription("The interval to retry a send if EntityNotManagedByRunner is returned.")
   ),
-  refreshAssignmentsInterval: Config.duration("refreshAssignmentsInterval").pipe(
+  refreshAssignmentsInterval: Config.Duration("refreshAssignmentsInterval").pipe(
     Config.withDefault(defaults.refreshAssignmentsInterval)
     // Config.withDescription("The interval at which to refresh shard assignments.")
   ),
-  runnerHealthCheckInterval: Config.duration("runnerHealthCheckInterval").pipe(
+  runnerHealthCheckInterval: Config.Duration("runnerHealthCheckInterval").pipe(
     Config.withDefault(defaults.runnerHealthCheckInterval)
     // Config.withDescription("The interval at which to check for unhealthy runners and report them.")
   ),
-  // unhealthyRunnerReportInterval: Config.duration("unhealthyRunnerReportInterval").pipe(
-  simulateRemoteSerialization: Config.boolean("simulateRemoteSerialization").pipe(
+  // unhealthyRunnerReportInterval: Config.Duration("unhealthyRunnerReportInterval").pipe(
+  simulateRemoteSerialization: Config.Boolean("simulateRemoteSerialization").pipe(
     Config.withDefault(defaults.simulateRemoteSerialization)
     // Config.withDescription("Simulate serialization and deserialization to remote runners for local entities.")
   )

package/src/unstable/cluster/SocketRunner.ts

@@ -11,6 +11,7 @@
  */
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
+import * as NetAddress from "../net/NetAddress.ts"
 import type * as RpcSerialization from "../rpc/RpcSerialization.ts"
 import * as RpcServer from "../rpc/RpcServer.ts"
 import { SocketServer } from "../socket/SocketServer.ts"
@@ -25,9 +26,9 @@ import type { ShardingConfig } from "./ShardingConfig.ts"
 const withLogAddress = <A, E, R>(layer: Layer.Layer<A, E, R>): Layer.Layer<A, E, R | SocketServer> =>
   Layer.effectDiscard(Effect.gen(function*() {
     const server = yield* SocketServer
-    const address = server.address._tag === "UnixAddress"
+    const address = server.address._tag === "UnixPathAddress"
       ? server.address.path
-      : `${server.address.hostname}:${server.address.port}`
+      : NetAddress.formatInet(server.address)
     yield* Effect.annotateLogs(Effect.logInfo(`Listening on: ${address}`), {
       package: "@effect/cluster",
       service: "Runner"
@@ -46,8 +47,8 @@ const withLogAddress = <A, E, R>(layer: Layer.Layer<A, E, R>): Layer.Layer<A, E,
  *
  * **Details**
  *
- * It logs the bound `SocketServer.address` when the layer starts, formatting TCP
- * addresses as `hostname:port` and Unix socket addresses as their filesystem
+ * It logs the bound `SocketServer.address` when the layer starts, formatting internet
+ * addresses as numeric socket addresses and Unix socket addresses as their filesystem
  * path.
  *
  * **Gotchas**

package/src/unstable/cluster/SqlMessageStorage.ts

@@ -666,7 +666,7 @@ export const makeEncoded: (options?: {
     unprocessedMessagesById(ids, now) {
       const idArr = Array.from(ids, (id) => String(id))
       return sql<MessageRow & ReplyJoinRow>`
-        SELECT m.*, r.id as reply_id, r.kind as reply_kind, r.payload as reply_payload, r.sequence as reply_sequence
+        SELECT m.*, r.id as reply_reply_id, r.kind as reply_kind, r.payload as reply_payload, r.sequence as reply_sequence
         FROM ${messagesTableSql} m
         LEFT JOIN ${repliesTableSql} r ON r.id = m.last_reply_id
         WHERE m.id IN (${sql.literal(idArr.join(","))})
@@ -964,13 +964,17 @@ const migrations = (options?: {
             ON ${messagesTableSql} (request_id);
           `.unprepared.pipe(Effect.ignore),
         pg: () =>
-          sql`
-            CREATE INDEX IF NOT EXISTS ${sql(shardLookupIndex)}
-            ON ${messagesTableSql} (shard_id, processed, last_read, deliver_at);
-
-            CREATE INDEX IF NOT EXISTS ${sql(requestIdLookupIndex)}
-            ON ${messagesTableSql} (request_id);
-          `.pipe(
+          Effect.gen(function*() {
+            yield* sql`
+              CREATE INDEX IF NOT EXISTS ${sql(shardLookupIndex)}
+              ON ${messagesTableSql} (shard_id, processed, last_read, deliver_at)
+            `
+            yield* sql`
+              CREATE INDEX IF NOT EXISTS ${sql(requestIdLookupIndex)}
+              ON ${messagesTableSql} (request_id)
+            `
+          }).pipe(
+            sql.withTransaction,
             Effect.tapDefect((error) =>
               Effect.annotateLogs(Effect.logDebug("Failed to create indexes", error), {
                 package: "@effect/cluster",