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

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"
@@ -13,6 +14,7 @@ import * as Fiber from "../../Fiber.ts"
 import * as FiberMap from "../../FiberMap.ts"
 import { constant, flow } from "../../Function.ts"
 import * as HashRing from "../../HashRing.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as MutableHashMap from "../../MutableHashMap.ts"
 import * as MutableHashSet from "../../MutableHashSet.ts"
@@ -23,7 +25,7 @@ import { CurrentLogAnnotations } from "../../References.ts"
 import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import * as RpcClient from "../rpc/RpcClient.ts"
@@ -63,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.
@@ -113,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
@@ -197,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
@@ -204,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)
@@ -221,12 +224,15 @@ const make = Effect.gen(function*() {
 
   // the active shards are the ones that we have acquired the lock for
   const acquiredShards = MutableHashSet.empty<ShardId>()
-  const activeShardsLatch = yield* Effect.makeLatch(false)
+  const activeShardsLatch = yield* Latch.make(false)
 
   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
@@ -252,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))
@@ -350,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()
@@ -429,16 +436,16 @@ const make = Effect.gen(function*() {
   // It should also be shutdown after the entity managers, to ensure interrupt
   // & ack envelopes can still be processed.
 
-  const storageReadLatch = yield* Effect.makeLatch(true)
+  const storageReadLatch = yield* Latch.make(true)
   const openStorageReadLatch = constant(Effect.asVoid(storageReadLatch.open))
 
-  const storageReadLock = Effect.makeSemaphoreUnsafe(1)
+  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()
 
@@ -810,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")
         }
@@ -822,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 }))
         }
@@ -858,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
     }) :
@@ -871,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*() {
@@ -963,7 +973,7 @@ const make = Effect.gen(function*() {
         if (selfRunner) {
           ClusterMetrics.runnersHealthy.updateUnsafe(
             BigInt(MutableHashSet.has(healthyRunners, selfRunner) ? 1 : 0),
-            ServiceMap.empty()
+            Context.empty()
           )
         }
       }
@@ -983,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)
   )
@@ -992,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>()
@@ -1007,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,
@@ -1015,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)
@@ -1074,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(
@@ -1112,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
@@ -1182,7 +1197,7 @@ const make = Effect.gen(function*() {
 
   const singletons = new Map<ShardId, MutableHashMap.MutableHashMap<SingletonAddress, Effect.Effect<void>>>()
   const singletonFibers = yield* FiberMap.make<SingletonAddress>()
-  const withSingletonLock = Effect.makeSemaphoreUnsafe(1).withPermits(1)
+  const withSingletonLock = Semaphore.makeUnsafe(1).withPermits(1)
 
   const registerSingleton: Sharding["Service"]["registerSingleton"] = Effect.fnUntraced(
     function*(name, run, options) {
@@ -1201,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>
@@ -1246,18 +1261,19 @@ const make = Effect.gen(function*() {
     }
     ClusterMetrics.singletons.updateUnsafe(
       BigInt(yield* FiberMap.size(singletonFibers)),
-      ServiceMap.empty()
+      Context.empty()
     )
   }))
 
   // --- Entities ---
 
   const reaper = yield* EntityReaper
-  const entityManagerLatches = new Map<string, Effect.Latch>()
+  const entityManagerLatches = new Map<string, Latch.Latch>()
 
   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,
@@ -1268,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,
@@ -1310,7 +1327,7 @@ const make = Effect.gen(function*() {
   const waitForEntityManager = (entityType: string) => {
     let latch = entityManagerLatches.get(entityType)
     if (!latch) {
-      latch = Effect.makeLatchUnsafe()
+      latch = Latch.makeUnsafe()
       entityManagerLatches.set(entityType, latch)
     }
     return latch.await
@@ -1426,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,13 +3,12 @@
  */
 import * as Config from "../../Config.ts"
 import * as ConfigProvider from "../../ConfigProvider.ts"
-import type { DurationInput } from "../../Duration.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"
 
 /**
@@ -18,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.
@@ -26,13 +25,13 @@ export class ShardingConfig extends ServiceMap.Service<ShardingConfig, {
    * If `None`, the runner is not part of the cluster and will be in a client-only
    * mode.
    */
-  readonly runnerAddress: RunnerAddress | undefined
+  readonly runnerAddress: Option.Option<RunnerAddress>
   /**
    * The listen address for the current runner.
    *
    * Defaults to the `runnerAddress`.
    */
-  readonly runnerListenAddress: RunnerAddress | undefined
+  readonly runnerListenAddress: Option.Option<RunnerAddress>
   /**
    * A number that determines how many shards this runner will be assigned
    * relative to other runners.
@@ -58,11 +57,11 @@ export class ShardingConfig extends ServiceMap.Service<ShardingConfig, {
   /**
    * Shard lock refresh interval.
    */
-  readonly shardLockRefreshInterval: DurationInput
+  readonly shardLockRefreshInterval: Duration.Input
   /**
    * Shard lock expiration duration.
    */
-  readonly shardLockExpiration: DurationInput
+  readonly shardLockExpiration: Duration.Input
   /**
    * Disable the use of advisory locks for shard locking.
    */
@@ -81,41 +80,41 @@ export class ShardingConfig extends ServiceMap.Service<ShardingConfig, {
    * The maximum duration of inactivity (i.e. without receiving a message)
    * after which an entity will be interrupted.
    */
-  readonly entityMaxIdleTime: DurationInput
+  readonly entityMaxIdleTime: Duration.Input
   /**
    * If an entity does not register itself within this time after a message is
    * sent to it, the message will be marked as failed.
    *
    * Defaults to 1 minute.
    */
-  readonly entityRegistrationTimeout: DurationInput
+  readonly entityRegistrationTimeout: Duration.Input
   /**
    * The maximum duration of time to wait for an entity to terminate.
    *
    * By default this is set to 15 seconds to stay within kubernetes defaults.
    */
-  readonly entityTerminationTimeout: DurationInput
+  readonly entityTerminationTimeout: Duration.Input
   /**
    * The interval at which to poll for unprocessed messages from storage.
    */
-  readonly entityMessagePollInterval: DurationInput
+  readonly entityMessagePollInterval: Duration.Input
   /**
    * The interval at which to poll for client replies from storage.
    */
-  readonly entityReplyPollInterval: DurationInput
+  readonly entityReplyPollInterval: Duration.Input
   /**
    * The interval at which to poll for new runners and refresh shard
    * assignments.
    */
-  readonly refreshAssignmentsInterval: DurationInput
+  readonly refreshAssignmentsInterval: Duration.Input
   /**
    * The interval to retry a send if EntityNotAssignedToRunner is returned.
    */
-  readonly sendRetryInterval: DurationInput
+  readonly sendRetryInterval: Duration.Input
   /**
    * The interval at which to check for unhealthy runners and report them
    */
-  readonly runnerHealthCheckInterval: DurationInput
+  readonly runnerHealthCheckInterval: Duration.Input
   /**
    * Simulate serialization and deserialization to remote runners for local
    * entities.
@@ -123,15 +122,15 @@ 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
  * @category defaults
  */
 export const defaults: ShardingConfig["Service"] = {
-  runnerAddress: defaultRunnerAddress,
-  runnerListenAddress: undefined,
+  runnerAddress: Option.some(defaultRunnerAddress),
+  runnerListenAddress: Option.none(),
   runnerShardWeight: 1,
   shardsPerGroup: 300,
   shardGroups: ["default"],
@@ -171,91 +170,91 @@ export const layerDefaults: Layer.Layer<ShardingConfig> = layer()
 export const config: Config.Config<ShardingConfig["Service"]> = Config.all({
   runnerAddress: Config.all({
     host: Config.string("host").pipe(
-      Config.withDefault(() => defaultRunnerAddress.host)
+      Config.withDefault(defaultRunnerAddress.host)
       // Config.withDescription("The hostname or IP address of the runner.")
     ),
     port: Config.int("port").pipe(
-      Config.withDefault(() => defaultRunnerAddress.port)
+      Config.withDefault(defaultRunnerAddress.port)
       // Config.withDescription("The port used for inter-runner communication.")
     )
-  }).pipe(Config.map((options) => RunnerAddress.makeUnsafe(options)), Config.option, Config.map(Option.getOrUndefined)),
+  }).pipe(Config.map((options) => RunnerAddress.make(options)), Config.option),
   runnerListenAddress: Config.all({
     host: Config.string("listenHost"),
     // Config.withDescription("The host to listen on.")
     port: Config.int("listenPort").pipe(
-      Config.withDefault(() => defaultRunnerAddress.port)
+      Config.withDefault(defaultRunnerAddress.port)
       // Config.withDescription("The port to listen on.")
     )
-  }).pipe(Config.map((options) => RunnerAddress.makeUnsafe(options)), Config.option, Config.map(Option.getOrUndefined)),
+  }).pipe(Config.map((options) => RunnerAddress.make(options)), Config.option),
   runnerShardWeight: Config.int("runnerShardWeight").pipe(
-    Config.withDefault(() => defaults.runnerShardWeight)
+    Config.withDefault(defaults.runnerShardWeight)
     // Config.withDescription("A number that determines how many shards this runner will be assigned relative to other runners.")
   ),
   shardGroups: Config.schema(Schema.Array(Schema.String), "shardGroups").pipe(
-    Config.withDefault(() => ["default"])
+    Config.withDefault(["default"])
     // Config.withDescription("The shard groups that are assigned to this runner.")
   ),
   shardsPerGroup: Config.int("shardsPerGroup").pipe(
-    Config.withDefault(() => defaults.shardsPerGroup)
+    Config.withDefault(defaults.shardsPerGroup)
     // Config.withDescription("The number of shards to allocate per shard group.")
   ),
   shardLockRefreshInterval: Config.duration("shardLockRefreshInterval").pipe(
-    Config.withDefault(() => defaults.shardLockRefreshInterval)
+    Config.withDefault(defaults.shardLockRefreshInterval)
     // Config.withDescription("Shard lock refresh interval.")
   ),
   shardLockExpiration: Config.duration("shardLockExpiration").pipe(
-    Config.withDefault(() => defaults.shardLockExpiration)
+    Config.withDefault(defaults.shardLockExpiration)
     // Config.withDescription("Shard lock expiration duration.")
   ),
   shardLockDisableAdvisory: Config.boolean("shardLockDisableAdvisory").pipe(
-    Config.withDefault(() => defaults.shardLockDisableAdvisory)
+    Config.withDefault(defaults.shardLockDisableAdvisory)
     // Config.withDescription("Disable the use of advisory locks for shard locking.")
   ),
   preemptiveShutdown: Config.boolean("preemptiveShutdown").pipe(
-    Config.withDefault(() => defaults.preemptiveShutdown)
+    Config.withDefault(defaults.preemptiveShutdown)
     // Config.withDescription("Start shutting down as soon as an Entity has started shutting down.")
   ),
   entityMailboxCapacity: Config.int("entityMailboxCapacity").pipe(
-    Config.withDefault(() => defaults.entityMailboxCapacity)
+    Config.withDefault(defaults.entityMailboxCapacity)
     // Config.withDescription("The default capacity of the mailbox for entities.")
   ),
   entityMaxIdleTime: Config.duration("entityMaxIdleTime").pipe(
-    Config.withDefault(() => defaults.entityMaxIdleTime)
+    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(
-    Config.withDefault(() => defaults.entityRegistrationTimeout)
+    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(
-    Config.withDefault(() => defaults.entityTerminationTimeout)
+    Config.withDefault(defaults.entityTerminationTimeout)
     // Config.withDescription("The maximum duration of time to wait for an entity to terminate.")
   ),
   entityMessagePollInterval: Config.duration("entityMessagePollInterval").pipe(
-    Config.withDefault(() => defaults.entityMessagePollInterval)
+    Config.withDefault(defaults.entityMessagePollInterval)
     // Config.withDescription("The interval at which to poll for unprocessed messages from storage.")
   ),
   entityReplyPollInterval: Config.duration("entityReplyPollInterval").pipe(
-    Config.withDefault(() => defaults.entityReplyPollInterval)
+    Config.withDefault(defaults.entityReplyPollInterval)
     // Config.withDescription("The interval at which to poll for client replies from storage.")
   ),
   sendRetryInterval: Config.duration("sendRetryInterval").pipe(
-    Config.withDefault(() => defaults.sendRetryInterval)
+    Config.withDefault(defaults.sendRetryInterval)
     // Config.withDescription("The interval to retry a send if EntityNotManagedByRunner is returned.")
   ),
   refreshAssignmentsInterval: Config.duration("refreshAssignmentsInterval").pipe(
-    Config.withDefault(() => defaults.refreshAssignmentsInterval)
+    Config.withDefault(defaults.refreshAssignmentsInterval)
     // Config.withDescription("The interval at which to refresh shard assignments.")
   ),
   runnerHealthCheckInterval: Config.duration("runnerHealthCheckInterval").pipe(
-    Config.withDefault(() => defaults.runnerHealthCheckInterval)
+    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(
-    Config.withDefault(() => defaults.simulateRemoteSerialization)
+    Config.withDefault(defaults.simulateRemoteSerialization)
     // Config.withDescription("Simulate serialization and deserialization to remote runners for local entities.")
   )
 })

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") {}