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

package/src/unstable/cluster/Runners.ts

@@ -1,6 +1,7 @@
 /**
  * @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"
@@ -10,7 +11,6 @@ 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"
@@ -31,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.
    */
@@ -132,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")
     }
@@ -505,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) =>
@@ -533,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
                 )
               ),
@@ -567,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 })))
               )
@@ -615,7 +615,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 constDisableChecks = { disableChecks: 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 }, constDisableChecks)
+    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,6 +4,7 @@
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
 import { Clock } from "../../Clock.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"
@@ -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.
@@ -207,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)
@@ -357,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()
@@ -820,7 +820,7 @@ const make = Effect.gen(function*() {
     return Effect.catchFilter(
       Effect.suspend(() => {
         const address = message.envelope.address
-        const isPersisted = ServiceMap.get(
+        const isPersisted = Context.get(
           message._tag === "OutgoingRequest" ? message.annotations : message.rpc.annotations,
           Persisted
         )
@@ -881,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*() {
@@ -973,7 +973,7 @@ const make = Effect.gen(function*() {
         if (selfRunner) {
           ClusterMetrics.runnersHealthy.updateUnsafe(
             BigInt(MutableHashSet.has(healthyRunners, selfRunner) ? 1 : 0),
-            ServiceMap.empty()
+            Context.empty()
           )
         }
       }
@@ -1002,7 +1002,7 @@ 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
   }
@@ -1018,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,
@@ -1026,7 +1026,7 @@ 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()!
@@ -1047,9 +1047,9 @@ const make = Effect.gen(function*() {
               envelope,
               lastReceivedReply: Option.none(),
               rpc,
-              services: fiber.services as ServiceMap.ServiceMap<any>,
+              context: fiber.context as Context.Context<any>,
               respond: (reply) => respond(reply),
-              annotations: ServiceMap.get(rpc.annotations, ClusterSchema.Dynamic)(
+              annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
                 rpc.annotations,
                 envelope as any
               )
@@ -1057,7 +1057,7 @@ const make = Effect.gen(function*() {
             if (!options.discard) {
               const entry: ClientRequestEntry = {
                 rpc: rpc as any,
-                services: fiber.currentContext,
+                context: fiber.currentContext,
                 message
               }
               clientRequests.set(id, entry)
@@ -1096,7 +1096,7 @@ const make = Effect.gen(function*() {
             // result of a shard being resassigned
             const isTransientInterrupt = MutableRef.get(isShutdown) ||
               options.message.interruptors.some((id) => internalInterruptors.has(id))
-            if (isTransientInterrupt && ServiceMap.get(entry.message.annotations, Persisted)) {
+            if (isTransientInterrupt && Context.get(entry.message.annotations, Persisted)) {
               return Effect.void
             }
             return Effect.ignore(sendOutgoing(
@@ -1127,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
@@ -1216,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>
@@ -1261,7 +1261,7 @@ const make = Effect.gen(function*() {
     }
     ClusterMetrics.singletons.updateUnsafe(
       BigInt(yield* FiberMap.size(singletonFibers)),
-      ServiceMap.empty()
+      Context.empty()
     )
   }))
 
@@ -1287,11 +1287,11 @@ const make = Effect.gen(function*() {
         runnerAddress,
         sharding
       }).pipe(
-        Effect.provideServices(ServiceMap.mutate(services, (services) =>
+        Effect.provideContext(Context.mutate(services, (services) =>
           services.pipe(
-            ServiceMap.add(EntityReaper, reaper),
-            ServiceMap.add(Scope.Scope, scope),
-            ServiceMap.add(Snowflake.Generator, snowflakeGen)
+            Context.add(EntityReaper, reaper),
+            Context.add(Scope.Scope, scope),
+            Context.add(Snowflake.Generator, snowflakeGen)
           )))
       ) as Effect.Effect<EntityManager.EntityManager>
       const state: EntityManagerState = {
@@ -1443,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")

package/src/unstable/cluster/ShardingConfig.ts

@@ -3,12 +3,12 @@
  */
 import * as Config from "../../Config.ts"
 import * as ConfigProvider from "../../ConfigProvider.ts"
+import * as Context from "../../Context.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import { RunnerAddress } from "./RunnerAddress.ts"
 
 /**
@@ -17,7 +17,7 @@ import { RunnerAddress } from "./RunnerAddress.ts"
  * @since 4.0.0
  * @category models
  */
-export class ShardingConfig extends ServiceMap.Service<ShardingConfig, {
+export class ShardingConfig extends Context.Service<ShardingConfig, {
   /**
    * The address for the current runner that other runners can use to
    * communicate with it.
@@ -122,7 +122,7 @@ export class ShardingConfig extends ServiceMap.Service<ShardingConfig, {
   readonly simulateRemoteSerialization: boolean
 }>()("effect/cluster/ShardingConfig") {}
 
-const defaultRunnerAddress = RunnerAddress.makeUnsafe({ host: "localhost", port: 34431 })
+const defaultRunnerAddress = RunnerAddress.make({ host: "localhost", port: 34431 })
 
 /**
  * @since 4.0.0
@@ -177,7 +177,7 @@ export const config: Config.Config<ShardingConfig["Service"]> = Config.all({
       Config.withDefault(defaultRunnerAddress.port)
       // Config.withDescription("The port used for inter-runner communication.")
     )
-  }).pipe(Config.map((options) => RunnerAddress.makeUnsafe(options)), Config.option),
+  }).pipe(Config.map((options) => RunnerAddress.make(options)), Config.option),
   runnerListenAddress: Config.all({
     host: Config.string("listenHost"),
     // Config.withDescription("The host to listen on.")
@@ -185,7 +185,7 @@ export const config: Config.Config<ShardingConfig["Service"]> = Config.all({
       Config.withDefault(defaultRunnerAddress.port)
       // Config.withDescription("The port to listen on.")
     )
-  }).pipe(Config.map((options) => RunnerAddress.makeUnsafe(options)), Config.option),
+  }).pipe(Config.map((options) => RunnerAddress.make(options)), Config.option),
   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.")

package/src/unstable/cluster/Snowflake.ts

@@ -3,13 +3,13 @@
  */
 import type * as Brand from "../../Brand.ts"
 import { Clock } from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as DateTime from "../../DateTime.ts"
 import * as Effect from "../../Effect.ts"
 import { identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
 import * as Schema from "../../Schema.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { MachineId } from "./MachineId.ts"
 
 /**
@@ -192,7 +192,7 @@ export const makeGenerator: Effect.Effect<Snowflake.Generator> = Effect.gen(func
  * @since 4.0.0
  * @category Generator
  */
-export class Generator extends ServiceMap.Service<
+export class Generator extends Context.Service<
   Generator,
   Snowflake.Generator
 >()("effect/cluster/Snowflake/Generator") {}

package/src/unstable/cluster/SqlMessageStorage.ts

@@ -15,7 +15,7 @@ import type * as Envelope from "./Envelope.ts"
 import * as MessageStorage from "./MessageStorage.ts"
 import { SaveResultEncoded } from "./MessageStorage.ts"
 import type * as Reply from "./Reply.ts"
-import { ShardId } from "./ShardId.ts"
+import * as ShardId from "./ShardId.ts"
 import type { ShardingConfig } from "./ShardingConfig.ts"
 import * as Snowflake from "./Snowflake.ts"
 

package/src/unstable/cluster/internal/entityManager.ts

@@ -1,6 +1,7 @@
 import * as Arr from "../../../Array.ts"
 import * as Cause from "../../../Cause.ts"
 import { Clock } from "../../../Clock.ts"
+import * as Context from "../../../Context.ts"
 import * as Duration from "../../../Duration.ts"
 import type { Input } from "../../../Duration.ts"
 import * as Effect from "../../../Effect.ts"
@@ -16,7 +17,6 @@ import * as Schedule from "../../../Schedule.ts"
 import * as Schema from "../../../Schema.ts"
 import * as Issue from "../../../SchemaIssue.ts"
 import * as Scope from "../../../Scope.ts"
-import * as ServiceMap from "../../../ServiceMap.ts"
 import type * as Rpc from "../../rpc/Rpc.ts"
 import { RequestId } from "../../rpc/RpcMessage.ts"
 import * as RpcServer from "../../rpc/RpcServer.ts"
@@ -107,10 +107,11 @@ export const make = Effect.fnUntraced(function*<
   const storageEnabled = options.storage !== MessageStorage.noop
   const mailboxCapacity = options.mailboxCapacity ?? config.entityMailboxCapacity
   const clock = yield* Clock
-  const services = yield* Effect.services<Rpc.Services<Rpcs> | Rpc.Middleware<Rpcs> | RX>()
-  const retryDriver = yield* Schedule.toStepWithSleep(
-    options.defectRetryPolicy ? Schedule.andThen(options.defectRetryPolicy, defaultRetryPolicy) : defaultRetryPolicy
-  )
+  const context = yield* Effect.context<Rpc.Services<Rpcs> | Rpc.Middleware<Rpcs> | RX>()
+  const defectRetryPolicy = options.defectRetryPolicy
+    ? Schedule.andThen(options.defectRetryPolicy, defaultRetryPolicy)
+    : defaultRetryPolicy
+  const retryDriver = yield* Schedule.toStepWithSleep(defectRetryPolicy)
   const entityRpcs = new Map(entity.protocol.requests)
 
   // add internal rpcs
@@ -156,14 +157,17 @@ export const make = Effect.fnUntraced(function*<
         // Initiate the behavior for the entity
         const handlers = yield* (entity.protocol.toHandlers(buildHandlers as any).pipe(
           Effect.provideService(CurrentLogAnnotations, {}),
-          Effect.provideServices(ServiceMap.mutate(services, (services) =>
-            services.pipe(
-              ServiceMap.add(CurrentAddress, address),
-              ServiceMap.add(CurrentRunnerAddress, options.runnerAddress),
-              ServiceMap.add(KeepAliveLatch, keepAliveLatch),
-              ServiceMap.add(Scope.Scope, scope)
-            )))
-        ) as Effect.Effect<ServiceMap.ServiceMap<Rpc.ToHandler<Rpcs>>>)
+          Effect.provideContext(Context.mutate(context, (context) =>
+            context.pipe(
+              Context.add(CurrentAddress, address),
+              Context.add(CurrentRunnerAddress, options.runnerAddress),
+              Context.add(KeepAliveLatch, keepAliveLatch),
+              Context.add(Scope.Scope, scope)
+            ))),
+          Effect.sandbox,
+          Effect.tapError((cause) => Effect.logError("Defect building entity handlers", cause)),
+          Effect.retry(defectRetryPolicy)
+        ) as Effect.Effect<Context.Context<Rpc.ToHandler<Rpcs>>>)
 
         const server = yield* RpcServer.makeNoSerialization(entity.protocol, {
           spanPrefix: `${entity.type}(${address.entityId})`,
@@ -188,7 +192,7 @@ export const make = Effect.fnUntraced(function*<
                 // interrupt.
                 if (
                   storageEnabled &&
-                  ServiceMap.get(request.message.annotations, Persisted) &&
+                  Context.get(request.message.annotations, Persisted) &&
                   Exit.hasInterrupts(response.exit) &&
                   (isShuttingDown || isUninterruptibleForServer(request.message.annotations))
                 ) {
@@ -267,7 +271,7 @@ export const make = Effect.fnUntraced(function*<
           }
         }).pipe(
           Scope.provide(scope),
-          Effect.provideServices(handlers)
+          Effect.provideContext(handlers)
         )
 
         yield* Scope.addFinalizer(
@@ -364,7 +368,7 @@ export const make = Effect.fnUntraced(function*<
   }
 
   // update metrics for active servers
-  const typeAttributes = Metric.CurrentMetricAttributes.serviceMap({ type: entity.type })
+  const typeAttributes = Metric.CurrentMetricAttributes.context({ type: entity.type })
   yield* Effect.sync(() => {
     ClusterMetrics.entities.updateUnsafe(BigInt(activeServers.size), typeAttributes)
   }).pipe(
@@ -396,7 +400,7 @@ export const make = Effect.fnUntraced(function*<
               }
 
               const rpc = entityRpcs.get(message.envelope.tag)! as any as Rpc.AnyWithProps
-              if (!storageEnabled && ServiceMap.get(message.annotations, Persisted)) {
+              if (!storageEnabled && Context.get(message.annotations, Persisted)) {
                 return Effect.die(
                   "EntityManager.sendLocal: Cannot process a persisted message without MessageStorage"
                 )
@@ -460,7 +464,7 @@ export const make = Effect.fnUntraced(function*<
                   )
                 })
               })
-              if (ServiceMap.get(message.annotations, WithTransaction)) {
+              if (Context.get(message.annotations, WithTransaction)) {
                 write = options.storage.withTransaction(write)
               }
               return write
@@ -497,7 +501,7 @@ export const make = Effect.fnUntraced(function*<
 
   const decodeMessage = makeMessageDecode(entity, entityRpcs)
 
-  const runFork = Effect.runForkWith(services)
+  const runFork = Effect.runForkWith(context)
 
   return identity<EntityManager>({
     interruptShard: (shardId: ShardId) =>
@@ -549,7 +553,7 @@ export const make = Effect.fnUntraced(function*<
                   exit: Exit.die(new MalformedMessage({ cause }))
                 }),
                 rpc: entityRpcs.get(message.envelope.tag)!,
-                services: services as any
+                context: context as any
               })
             ))
           },
@@ -563,7 +567,7 @@ export const make = Effect.fnUntraced(function*<
             const rpc = entityRpcs.get(decoded.envelope.tag)!
             return sendLocal(
               new Message.IncomingRequestLocal({
-                annotations: ServiceMap.get(rpc.annotations, ClusterSchema.Dynamic)(
+                annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
                   rpc.annotations,
                   decoded.envelope as any
                 ),
@@ -574,14 +578,14 @@ export const make = Effect.fnUntraced(function*<
                     new Reply.ReplyWithContext({
                       reply,
                       rpc,
-                      services: services as any
+                      context: context as any
                     })
                   )
               })
             )
           }
         }),
-        Effect.provideServices(services as ServiceMap.ServiceMap<unknown>)
+        Effect.provideContext(context as Context.Context<unknown>)
       ),
     activeEntityCount: Effect.sync(() => activeServers.size)
   })