effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/unstable/cluster/Runners.ts

@@ -1,15 +1,16 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import * as Queue from "../../Queue.ts"
 import * as RcMap from "../../RcMap.ts"
 import * as Schema from "../../Schema.ts"
 import type { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import * as RpcClient_ from "../rpc/RpcClient.ts"
 import type { RpcClientError } from "../rpc/RpcClientError.ts"
@@ -30,7 +31,7 @@ import * as Snowflake from "./Snowflake.ts"
  * @since 1.0.0
  * @category context
  */
-export class Runners extends ServiceMap.Service<Runners, {
+export class Runners extends Context.Service<Runners, {
   /**
    * Checks if a Runner is responsive.
    */
@@ -80,7 +81,7 @@ export class Runners extends ServiceMap.Service<Runners, {
    */
   readonly notify: <R extends Rpc.Any>(
     options: {
-      readonly address: RunnerAddress | undefined
+      readonly address: Option.Option<RunnerAddress>
       readonly message: Message.Outgoing<R>
       readonly discard: boolean
     }
@@ -131,7 +132,7 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
     afterPersist: (message: Message.Outgoing<any>, isDuplicate: boolean) => Effect.Effect<void, E>
   ): Effect.Effect<void, E | PersistenceError> {
     const rpc = message.rpc as any as Rpc.AnyWithProps
-    const persisted = ServiceMap.get(rpc.annotations, Persisted)
+    const persisted = Context.get(rpc.annotations, Persisted)
     if (!persisted) {
       return Effect.die("Runners.notify only supports persisted messages")
     }
@@ -166,8 +167,8 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
         Duplicate: ({ lastReceivedReply, originalId }) => {
           // If the last received reply is an exit, we can just return it
           // as the response.
-          if (lastReceivedReply && lastReceivedReply._tag === "WithExit") {
-            return message.respond(lastReceivedReply.withRequestId(message.envelope.requestId))
+          if (Option.isSome(lastReceivedReply) && lastReceivedReply.value._tag === "WithExit") {
+            return message.respond(lastReceivedReply.value.withRequestId(message.envelope.requestId))
           }
           requestIdRewrites.set(message.envelope.requestId, originalId)
           return afterPersist(
@@ -341,10 +342,10 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
       return notifyWith(message, (message, duplicate) => {
         if (discard || message._tag === "OutgoingEnvelope") {
           return options.notify(options_)
-        } else if (!duplicate && options_.address) {
+        } else if (!duplicate && Option.isSome(options_.address)) {
           return Effect.catch(
             options.send({
-              address: options_.address,
+              address: options_.address.value,
               message
             }),
             (_) => replyFromStorage(message)
@@ -504,7 +505,7 @@ export const makeRpc: Effect.Effect<
     },
     send({ address, message }) {
       const rpc = message.rpc as any as Rpc.AnyWithProps
-      const isPersisted = ServiceMap.get(rpc.annotations, Persisted)
+      const isPersisted = Context.get(rpc.annotations, Persisted)
       if (message._tag === "OutgoingEnvelope") {
         return RcMap.get(clients, address).pipe(
           Effect.flatMap((client) =>
@@ -532,7 +533,7 @@ export const makeRpc: Effect.Effect<
               Effect.catchTag("RpcClientError", Effect.die),
               Effect.flatMap((reply) =>
                 Schema.decodeEffect(Reply.Reply(message.rpc))(reply).pipe(
-                  Effect.provideServices(message.services),
+                  Effect.provideContext(message.context),
                   Effect.orDie
                 )
               ),
@@ -566,7 +567,7 @@ export const makeRpc: Effect.Effect<
                 Effect.flatMap(message.respond),
                 Effect.forever,
                 Effect.catchTag("RpcClientError", Effect.die),
-                Effect.provideServices(message.services),
+                Effect.provideContext(message.context),
                 Effect.catchTag("Done", (_) => Effect.void),
                 Effect.catchDefect(() => Effect.fail(new RunnerUnavailable({ address })))
               )
@@ -584,15 +585,18 @@ export const makeRpc: Effect.Effect<
       })
     },
     notify({ address, message }) {
-      if (!address) {
+      if (Option.isNone(address)) {
         return Effect.void
       }
       const envelope = message.envelope
-      return RcMap.get(clients, address).pipe(
-        Effect.flatMap((client) => client.Notify({ envelope })),
-        Effect.scoped,
-        Effect.ignore
-      )
+      const encode: Effect.Effect<Envelope.AckChunk | Envelope.Interrupt | Envelope.PartialRequest> =
+        message._tag === "OutgoingRequest" ? Effect.orDie(Message.serializeRequest(message)) : Effect.succeed(envelope)
+      return Effect.flatMap(encode, (envelope) =>
+        RcMap.get(clients, address.value).pipe(
+          Effect.flatMap((client) => client.Notify({ envelope })),
+          Effect.scoped,
+          Effect.ignore
+        ))
     },
     onRunnerUnavailable: (address) => RcMap.invalidate(clients, address)
   })
@@ -614,7 +618,7 @@ export const layerRpc: Layer.Layer<
  * @since 1.0.0
  * @category Client
  */
-export class RpcClientProtocol extends ServiceMap.Service<
+export class RpcClientProtocol extends Context.Service<
   RpcClientProtocol,
   (address: RunnerAddress) => Effect.Effect<RpcClient_.Protocol["Service"], never, Scope>
 >()("effect/cluster/Runners/RpcClientProtocol") {}

package/src/unstable/cluster/ShardId.ts

@@ -3,12 +3,46 @@
  */
 import * as Equal from "../../Equal.ts"
 import * as Hash from "../../Hash.ts"
+import { hasProperty } from "../../Predicate.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import * as S from "../../Schema.ts"
+import * as Getter from "../../SchemaGetter.ts"
 
 const TypeId = "~effect/cluster/ShardId"
 
-const constDisableValidation = { disableValidation: true }
+/**
+ * @since 4.0.0
+ * @category Models
+ */
+export interface ShardId extends Equal.Equal, Hash.Hash, PrimaryKey.PrimaryKey {
+  readonly [TypeId]: typeof TypeId
+  readonly group: string
+  readonly id: number
+}
+
+/**
+ * @since 4.0.0
+ * @category Guards
+ */
+export const isShardId = (u: unknown): u is ShardId => hasProperty(u, TypeId)
+
+/**
+ * @since 4.0.0
+ * @category Schema
+ */
+export const ShardId = S.declare(isShardId, {
+  toCodecJson: () =>
+    S.link<ShardId>()(
+      S.Struct({
+        group: S.String,
+        id: S.Number
+      }),
+      {
+        decode: Getter.transform(({ group, id }) => make(group, id)),
+        encode: Getter.passthrough()
+      }
+    )
+})
 
 /**
  * @since 4.0.0
@@ -18,7 +52,7 @@ export const make = (group: string, id: number): ShardId => {
   const key = `${group}:${id}`
   let shardId = shardIdCache.get(key)
   if (!shardId) {
-    shardId = new ShardId({ group, id }, constDisableValidation)
+    shardId = makeProto(group, id)
     shardIdCache.set(key, shardId)
   }
   return shardId
@@ -26,86 +60,62 @@ export const make = (group: string, id: number): ShardId => {
 
 const shardIdCache = new Map<string, ShardId>()
 
-/**
- * @since 4.0.0
- * @category Models
- */
-export class ShardId extends S.Class<ShardId>(TypeId)({
-  group: S.String,
-  id: S.Int
-}) {
-  /**
-   * @since 4.0.0
-   */
-  static readonly make = make
-
-  /**
-   * @since 4.0.0
-   */
-  readonly [TypeId] = TypeId;
+const makeProto = (group: string, id: number): ShardId => {
+  const self = Object.create(ShardIdProto)
+  self.group = group
+  self.id = id
+  return self
+}
 
-  /**
-   * @since 4.0.0
-   */
-  [Equal.symbol](that: ShardId): boolean {
+const ShardIdProto = {
+  [TypeId]: TypeId,
+  [Equal.symbol](this: ShardId, that: ShardId): boolean {
     return this.group === that.group && this.id === that.id
-  }
-
-  /**
-   * @since 4.0.0
-   */
-  [Hash.symbol](): number {
+  },
+  [Hash.symbol](this: ShardId): number {
     return Hash.string(this.toString())
-  }
-
-  /**
-   * @since 4.0.0
-   */
-  [PrimaryKey.symbol](): string {
+  },
+  [PrimaryKey.symbol](this: ShardId): string {
     return this.toString()
-  }
-
-  /**
-   * @since 4.0.0
-   */
-  override toString(): string {
+  },
+  toString(this: ShardId): string {
     return `${this.group}:${this.id}`
   }
+}
 
-  /**
-   * @since 4.0.0
-   */
-  static override toString(shardId: {
-    readonly group: string
-    readonly id: number
-  }): string {
-    return `${shardId.group}:${shardId.id}`
+/**
+ * @since 4.0.0
+ * @category Conversions
+ */
+export const toString = (shardId: {
+  readonly group: string
+  readonly id: number
+}): string => {
+  return `${shardId.group}:${shardId.id}`
+}
+/**
+ * @since 4.0.0
+ */
+export function fromStringEncoded(s: string): {
+  readonly group: string
+  readonly id: number
+} {
+  const index = s.lastIndexOf(":")
+  if (index === -1) {
+    throw new Error(`Invalid ShardId format`)
   }
-
-  /**
-   * @since 4.0.0
-   */
-  static fromStringEncoded(s: string): {
-    readonly group: string
-    readonly id: number
-  } {
-    const index = s.lastIndexOf(":")
-    if (index === -1) {
-      throw new Error(`Invalid ShardId format`)
-    }
-    const group = s.substring(0, index)
-    const id = Number(s.substring(index + 1))
-    if (isNaN(id)) {
-      throw new Error(`ShardId id must be a number`)
-    }
-    return { group, id }
+  const group = s.substring(0, index)
+  const id = Number(s.substring(index + 1))
+  if (isNaN(id)) {
+    throw new Error(`ShardId id must be a number`)
   }
+  return { group, id }
+}
 
-  /**
-   * @since 4.0.0
-   */
-  static fromString(s: string): ShardId {
-    const encoded = ShardId.fromStringEncoded(s)
-    return make(encoded.group, encoded.id)
-  }
+/**
+ * @since 4.0.0
+ */
+export function fromString(s: string): ShardId {
+  const encoded = fromStringEncoded(s)
+  return make(encoded.group, encoded.id)
 }

package/src/unstable/cluster/Sharding.ts

@@ -4,7 +4,8 @@
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
 import { Clock } from "../../Clock.ts"
-import type { DurationInput } from "../../Duration.ts"
+import * as Context from "../../Context.ts"
+import type { Input } from "../../Duration.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
@@ -25,7 +26,6 @@ import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Scope from "../../Scope.ts"
 import * as Semaphore from "../../Semaphore.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import * as RpcClient from "../rpc/RpcClient.ts"
@@ -65,7 +65,7 @@ import * as Snowflake from "./Snowflake.ts"
  * @since 4.0.0
  * @category models
  */
-export class Sharding extends ServiceMap.Service<Sharding, {
+export class Sharding extends Context.Service<Sharding, {
   /**
    * Returns a stream of events that occur when the runner registers entities or
    * singletons.
@@ -115,7 +115,7 @@ export class Sharding extends ServiceMap.Service<Sharding, {
     entity: Entity<Type, Rpcs>,
     handlers: Effect.Effect<Handlers, never, RX>,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Input | undefined
       readonly concurrency?: number | "unbounded" | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
@@ -199,6 +199,7 @@ interface EntityManagerState {
 
 const make = Effect.gen(function*() {
   const config = yield* ShardingConfig
+  const getRunnerAddress = () => Option.getOrUndefined(config.runnerAddress)
   const clock = yield* Clock
 
   const runnersService = yield* Runners
@@ -206,7 +207,7 @@ const make = Effect.gen(function*() {
   const snowflakeGen = yield* Snowflake.Generator
   const shardingScope = yield* Effect.scope
   const isShutdown = MutableRef.make(false)
-  const services = ServiceMap.omit(Scope.Scope)(yield* Effect.services<ShardingConfig>())
+  const services = Context.omit(Scope.Scope)(yield* Effect.context<ShardingConfig>())
   const runFork = flow(
     Effect.runForkWith(services),
     Fiber.runIn(shardingScope)
@@ -228,7 +229,10 @@ const make = Effect.gen(function*() {
   const events = yield* PubSub.unbounded<ShardingRegistrationEvent>()
   const getRegistrationEvents: Stream.Stream<ShardingRegistrationEvent> = Stream.fromPubSub(events)
 
-  const isLocalRunner = (address: RunnerAddress) => Equal.equals(address, config.runnerAddress)
+  const isLocalRunner = (address: RunnerAddress) => {
+    const runnerAddress = getRunnerAddress()
+    return runnerAddress !== undefined && Equal.equals(address, runnerAddress)
+  }
 
   function getShardId(entityId: EntityId, group: string): ShardId {
     const id = Math.abs(hashString(entityId) % config.shardsPerGroup) + 1
@@ -254,8 +258,9 @@ const make = Effect.gen(function*() {
   // allow them to move to another runner.
 
   const releasingShards = MutableHashSet.empty<ShardId>()
-  if (config.runnerAddress) {
-    const selfAddress = config.runnerAddress
+  const initialRunnerAddress = getRunnerAddress()
+  if (initialRunnerAddress) {
+    const selfAddress = initialRunnerAddress
     yield* Scope.addFinalizerExit(shardingScope, () => {
       // the locks expire over time, so if this fails we ignore it
       return Effect.ignore(runnerStorage.releaseAll(selfAddress))
@@ -352,7 +357,7 @@ const make = Effect.gen(function*() {
           yield* Effect.forkIn(syncSingletons, shardingScope)
 
           // update metrics
-          ClusterMetrics.shards.updateUnsafe(BigInt(MutableHashSet.size(acquiredShards)), ServiceMap.empty())
+          ClusterMetrics.shards.updateUnsafe(BigInt(MutableHashSet.size(acquiredShards)), Context.empty())
         }
         yield* Effect.sleep(1000)
         activeShardsLatch.openUnsafe()
@@ -437,10 +442,10 @@ const make = Effect.gen(function*() {
   const storageReadLock = Semaphore.makeUnsafe(1)
   const withStorageReadLock = storageReadLock.withPermits(1)
 
-  if (storageEnabled && config.runnerAddress) {
-    const selfAddress = config.runnerAddress
+  if (storageEnabled && initialRunnerAddress) {
+    const selfAddress = initialRunnerAddress
     const entityRegistrationTimeoutMillis = Duration.toMillis(
-      Duration.fromDurationInputUnsafe(config.entityRegistrationTimeout)
+      Duration.fromInputUnsafe(config.entityRegistrationTimeout)
     )
     const storageStartMillis = clock.currentTimeMillisUnsafe()
 
@@ -812,10 +817,13 @@ const make = Effect.gen(function*() {
     void,
     MailboxFull | AlreadyProcessingMessage | PersistenceError
   > {
-    return Effect.catchIf(
+    return Effect.catchFilter(
       Effect.suspend(() => {
         const address = message.envelope.address
-        const isPersisted = ServiceMap.get(message.rpc.annotations, Persisted)
+        const isPersisted = Context.get(
+          message._tag === "OutgoingRequest" ? message.annotations : message.rpc.annotations,
+          Persisted
+        )
         if (isPersisted && !storageEnabled) {
           return Effect.die("Sharding.sendOutgoing: Persisted messages require MessageStorage")
         }
@@ -824,7 +832,7 @@ const make = Effect.gen(function*() {
         if (isPersisted) {
           return runnerIsLocal
             ? notifyLocal(message, discard)
-            : runnersService.notify({ address: Option.getOrUndefined(maybeRunner), message, discard })
+            : runnersService.notify({ address: maybeRunner, message, discard })
         } else if (Option.isNone(maybeRunner)) {
           return Effect.fail(new EntityNotAssignedToRunner({ address }))
         }
@@ -860,9 +868,9 @@ const make = Effect.gen(function*() {
   // shard assignments for outgoing messages (they could still be in use by
   // entities that are shutting down).
 
-  const selfRunner = config.runnerAddress ?
+  const selfRunner = initialRunnerAddress ?
     new Runner({
-      address: config.runnerAddress,
+      address: initialRunnerAddress,
       groups: config.shardGroups,
       weight: config.runnerShardWeight
     }) :
@@ -873,8 +881,8 @@ const make = Effect.gen(function*() {
 
   // update metrics
   if (selfRunner) {
-    ClusterMetrics.runners.updateUnsafe(BigInt(1), ServiceMap.empty())
-    ClusterMetrics.runnersHealthy.updateUnsafe(BigInt(1), ServiceMap.empty())
+    ClusterMetrics.runners.updateUnsafe(BigInt(1), Context.empty())
+    ClusterMetrics.runnersHealthy.updateUnsafe(BigInt(1), Context.empty())
   }
 
   yield* Effect.gen(function*() {
@@ -965,7 +973,7 @@ const make = Effect.gen(function*() {
         if (selfRunner) {
           ClusterMetrics.runnersHealthy.updateUnsafe(
             BigInt(MutableHashSet.has(healthyRunners, selfRunner) ? 1 : 0),
-            ServiceMap.empty()
+            Context.empty()
           )
         }
       }
@@ -985,7 +993,7 @@ const make = Effect.gen(function*() {
     Effect.annotateLogs({
       module: "effect/cluster/Sharding",
       fiber: "RunnerStorage sync",
-      runner: config.runnerAddress
+      runner: initialRunnerAddress
     }),
     Effect.forkIn(shardingScope)
   )
@@ -994,7 +1002,8 @@ const make = Effect.gen(function*() {
 
   type ClientRequestEntry = {
     readonly rpc: Rpc.AnyWithProps
-    readonly services: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
+    readonly message: Message.OutgoingRequest<any>
     lastChunkId?: Snowflake.Snowflake
   }
   const clientRequests = new Map<Snowflake.Snowflake, ClientRequestEntry>()
@@ -1009,7 +1018,7 @@ const make = Effect.gen(function*() {
   > = yield* ResourceMap.make(Effect.fnUntraced(function*(entity: Entity<string, any>) {
     const client = yield* RpcClient.makeNoSerialization(entity.protocol, {
       spanPrefix: `${entity.type}.client`,
-      disableTracing: !ServiceMap.get(entity.protocol.annotations, ClusterSchema.ClientTracingEnabled),
+      disableTracing: !Context.get(entity.protocol.annotations, ClusterSchema.ClientTracingEnabled),
       supportsAck: true,
       generateRequestId: () => RequestId(snowflakeGen.nextUnsafe()),
       flatten: true,
@@ -1017,42 +1026,46 @@ const make = Effect.gen(function*() {
         void,
         MailboxFull | AlreadyProcessingMessage | PersistenceError
       > {
-        const address = ServiceMap.getUnsafe(options.context, ClientAddressTag)
+        const address = Context.getUnsafe(options.context, ClientAddressTag)
         switch (options.message._tag) {
           case "Request": {
             const fiber = Fiber.getCurrent()!
             const id = Snowflake.Snowflake(options.message.id)
             const rpc = entity.protocol.requests.get(options.message.tag)!
             let respond: (reply: Reply.Reply<any>) => Effect.Effect<void>
+            const envelope = Envelope.makeRequest<any>({
+              requestId: id,
+              address,
+              tag: options.message.tag,
+              payload: options.message.payload,
+              headers: options.message.headers,
+              traceId: options.message.traceId,
+              spanId: options.message.spanId,
+              sampled: options.message.sampled
+            })
+            const message = new Message.OutgoingRequest({
+              envelope,
+              lastReceivedReply: Option.none(),
+              rpc,
+              context: fiber.context as Context.Context<any>,
+              respond: (reply) => respond(reply),
+              annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
+                rpc.annotations,
+                envelope as any
+              )
+            })
             if (!options.discard) {
               const entry: ClientRequestEntry = {
                 rpc: rpc as any,
-                services: fiber.currentContext
+                context: fiber.currentContext,
+                message
               }
               clientRequests.set(id, entry)
               respond = makeClientRespond(entry, client.write)
             } else {
               respond = clientRespondDiscard
             }
-            return sendOutgoing(
-              new Message.OutgoingRequest({
-                envelope: Envelope.makeRequest({
-                  requestId: id,
-                  address,
-                  tag: options.message.tag,
-                  payload: options.message.payload,
-                  headers: options.message.headers,
-                  traceId: options.message.traceId,
-                  spanId: options.message.spanId,
-                  sampled: options.message.sampled
-                }),
-                lastReceivedReply: undefined,
-                rpc,
-                services: fiber.services as ServiceMap.ServiceMap<any>,
-                respond
-              }),
-              options.discard
-            )
+            return sendOutgoing(message, options.discard)
           }
           case "Ack": {
             const requestId = Snowflake.Snowflake(options.message.requestId)
@@ -1076,14 +1089,14 @@ const make = Effect.gen(function*() {
             const entry = clientRequests.get(requestId)!
             if (!entry) return Effect.void
             clientRequests.delete(requestId)
-            if (ClusterSchema.isUninterruptibleForClient(entry.rpc.annotations)) {
+            if (ClusterSchema.isUninterruptibleForClient(entry.message.annotations)) {
               return Effect.void
             }
             // for durable messages, we ignore interrupts on shutdown or as a
             // result of a shard being resassigned
             const isTransientInterrupt = MutableRef.get(isShutdown) ||
               options.message.interruptors.some((id) => internalInterruptors.has(id))
-            if (isTransientInterrupt && ServiceMap.get(entry.rpc.annotations, Persisted)) {
+            if (isTransientInterrupt && Context.get(entry.message.annotations, Persisted)) {
               return Effect.void
             }
             return Effect.ignore(sendOutgoing(
@@ -1114,15 +1127,15 @@ const make = Effect.gen(function*() {
 
     return (entityId: string) => {
       const id = makeEntityId(entityId)
-      const address = ClientAddressTag.serviceMap(makeEntityAddress({
+      const address = ClientAddressTag.context(makeEntityAddress({
         shardId: getShardId(id, entity.getShardGroup(entityId as EntityId)),
         entityId: id,
         entityType: entity.type
       }))
       const clientFn = function(tag: string, payload: any, options?: {
-        readonly context?: ServiceMap.ServiceMap<never>
+        readonly context?: Context.Context<never>
       }) {
-        const context = options?.context ? ServiceMap.merge(options.context, address) : address
+        const context = options?.context ? Context.merge(options.context, address) : address
         return client.client(tag, payload, {
           ...options,
           context
@@ -1203,12 +1216,12 @@ const make = Effect.gen(function*() {
         return yield* Effect.die(`Singleton '${name}' is already registered`)
       }
 
-      const services = yield* Effect.services<never>()
+      const services = yield* Effect.context<never>()
       const wrappedRun = run.pipe(
         Effect.andThen(Effect.never),
         Effect.scoped,
         Effect.provideService(CurrentLogAnnotations, {}),
-        Effect.provideServices(services),
+        Effect.provideContext(services),
         Effect.orDie,
         Effect.interruptible
       ) as Effect.Effect<never>
@@ -1248,7 +1261,7 @@ const make = Effect.gen(function*() {
     }
     ClusterMetrics.singletons.updateUnsafe(
       BigInt(yield* FiberMap.size(singletonFibers)),
-      ServiceMap.empty()
+      Context.empty()
     )
   }))
 
@@ -1259,7 +1272,8 @@ const make = Effect.gen(function*() {
 
   const registerEntity: Sharding["Service"]["registerEntity"] = Effect.fnUntraced(
     function*(entity, build, options) {
-      if (!config.runnerAddress || entityManagers.has(entity.type)) return
+      const runnerAddress = getRunnerAddress()
+      if (!runnerAddress || entityManagers.has(entity.type)) return
       const scope = yield* Effect.scope
       yield* Scope.addFinalizer(
         scope,
@@ -1270,14 +1284,15 @@ const make = Effect.gen(function*() {
       const manager = yield* EntityManager.make(entity, build, {
         ...options,
         storage,
-        runnerAddress: config.runnerAddress,
+        runnerAddress,
         sharding
       }).pipe(
-        Effect.provideServices(services.pipe(
-          ServiceMap.add(EntityReaper, reaper),
-          ServiceMap.add(Scope.Scope, scope),
-          ServiceMap.add(Snowflake.Generator, snowflakeGen)
-        ))
+        Effect.provideContext(Context.mutate(services, (services) =>
+          services.pipe(
+            Context.add(EntityReaper, reaper),
+            Context.add(Scope.Scope, scope),
+            Context.add(Snowflake.Generator, snowflakeGen)
+          )))
       ) as Effect.Effect<EntityManager.EntityManager>
       const state: EntityManagerState = {
         entity,
@@ -1428,4 +1443,4 @@ export const layer: Layer.Layer<
 
 // Utilities
 
-const ClientAddressTag = ServiceMap.Service<EntityAddress>("effect/cluster/Sharding/ClientAddress")
+const ClientAddressTag = Context.Service<EntityAddress>("effect/cluster/Sharding/ClientAddress")