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

package/src/unstable/cluster/MessageStorage.ts

@@ -3,15 +3,16 @@
  */
 import * as Arr from "../../Array.ts"
 import { Clock } from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
+import { constFalse, identity } from "../../Function.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
-import type * as Option from "../../Option.ts"
+import * as Option from "../../Option.ts"
 import type { Predicate } from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
 import { EntityNotAssignedToRunner, MalformedMessage, type PersistenceError } from "./ClusterError.ts"
 import * as DeliverAt from "./DeliverAt.ts"
@@ -19,7 +20,7 @@ import type { EntityAddress } from "./EntityAddress.ts"
 import * as Envelope from "./Envelope.ts"
 import * as Message from "./Message.ts"
 import * 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"
 
@@ -27,7 +28,7 @@ import * as Snowflake from "./Snowflake.ts"
  * @since 4.0.0
  * @category context
  */
-export class MessageStorage extends ServiceMap.Service<MessageStorage, {
+export class MessageStorage extends Context.Service<MessageStorage, {
   /**
    * Save the provided message and its associated metadata.
    */
@@ -80,7 +81,7 @@ export class MessageStorage extends ServiceMap.Service<MessageStorage, {
       readonly tag: string
       readonly id: string
     }
-  ) => Effect.Effect<Snowflake.Snowflake | undefined, PersistenceError>
+  ) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError>
 
   /**
    * For locally sent messages, register a handler to process the replies.
@@ -97,7 +98,7 @@ export class MessageStorage extends ServiceMap.Service<MessageStorage, {
   /**
    * Unregister the reply handlers for the specified ShardId.
    */
-  readonly unregisterShardReplyHandlers: (shardId: ShardId) => Effect.Effect<void>
+  readonly unregisterShardReplyHandlers: (shardId: ShardId.ShardId) => Effect.Effect<void>
 
   /**
    * Retrieves the unprocessed messages for the specified shards.
@@ -110,7 +111,7 @@ export class MessageStorage extends ServiceMap.Service<MessageStorage, {
    * - All Interrupt's for unprocessed requests
    */
   readonly unprocessedMessages: (
-    shardIds: Iterable<ShardId>
+    shardIds: Iterable<ShardId.ShardId>
   ) => Effect.Effect<Array<Message.Incoming<any>>, PersistenceError>
 
   /**
@@ -124,7 +125,7 @@ export class MessageStorage extends ServiceMap.Service<MessageStorage, {
    * Reset the mailbox state for the provided shards.
    */
   readonly resetShards: (
-    shardIds: Iterable<ShardId>
+    shardIds: Iterable<ShardId.ShardId>
   ) => Effect.Effect<void, PersistenceError>
 
   /**
@@ -140,6 +141,13 @@ export class MessageStorage extends ServiceMap.Service<MessageStorage, {
   readonly clearAddress: (
     address: EntityAddress
   ) => Effect.Effect<void, PersistenceError>
+
+  /**
+   * Used to wrap requests with transactions.
+   */
+  readonly withTransaction: <A, E, R>(
+    effect: Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E, R>
 }>()("effect/cluster/MessageStorage") {}
 
 /**
@@ -186,7 +194,7 @@ export declare namespace SaveResult {
   export interface Duplicate<R extends Rpc.Any> {
     readonly _tag: "Duplicate"
     readonly originalId: Snowflake.Snowflake
-    readonly lastReceivedReply: Reply.Reply<R> | undefined
+    readonly lastReceivedReply: Option.Option<Reply.Reply<R>>
   }
 
   /**
@@ -196,7 +204,7 @@ export declare namespace SaveResult {
   export interface DuplicateEncoded {
     readonly _tag: "Duplicate"
     readonly originalId: Snowflake.Snowflake
-    readonly lastReceivedReply: Reply.Encoded | undefined
+    readonly lastReceivedReply: Option.Option<Reply.Encoded>
   }
 
   /**
@@ -239,7 +247,7 @@ export type Encoded = {
    */
   readonly requestIdForPrimaryKey: (
     primaryKey: string
-  ) => Effect.Effect<Snowflake.Snowflake | undefined, PersistenceError>
+  ) => Effect.Effect<Option.Option<Snowflake.Snowflake>, PersistenceError>
 
   /**
    * Retrieves the replies for the specified requests.
@@ -276,7 +284,7 @@ export type Encoded = {
   ) => Effect.Effect<
     Array<{
       readonly envelope: Envelope.Encoded
-      readonly lastSentReply: Reply.Encoded | undefined
+      readonly lastSentReply: Option.Option<Reply.Encoded>
     }>,
     PersistenceError
   >
@@ -290,7 +298,7 @@ export type Encoded = {
   ) => Effect.Effect<
     Array<{
       readonly envelope: Envelope.Encoded
-      readonly lastSentReply: Reply.Encoded | undefined
+      readonly lastSentReply: Option.Option<Reply.Encoded>
     }>,
     PersistenceError
   >
@@ -315,6 +323,13 @@ export type Encoded = {
   readonly resetShards: (
     shardIds: Arr.NonEmptyArray<string>
   ) => Effect.Effect<void, PersistenceError>
+
+  /**
+   * Used to wrap requests with transactions.
+   */
+  readonly withTransaction: <A, E, R>(
+    effect: Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E, R>
 }
 
 /**
@@ -462,18 +477,18 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
           })
         ),
         Effect.flatMap((result) => {
-          if (result._tag === "Success" || result.lastReceivedReply === undefined) {
+          if (result._tag === "Success" || Option.isNone(result.lastReceivedReply)) {
             return Effect.succeed(result as SaveResult<any>)
           }
           const duplicate = result
           const schema = Reply.Reply(message.rpc)
-          return Schema.decodeEffect(schema)(result.lastReceivedReply).pipe(
-            Effect.provideServices(message.services),
+          return Schema.decodeEffect(schema)(result.lastReceivedReply.value).pipe(
+            Effect.provideContext(message.context),
             MalformedMessage.refail,
             Effect.map((reply) =>
               SaveResult.Duplicate({
                 originalId: duplicate.originalId,
-                lastReceivedReply: reply
+                lastReceivedReply: Option.some(reply)
               })
             )
           )
@@ -517,20 +532,22 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
       const primaryKey = Envelope.primaryKeyByAddress(options)
       return encoded.requestIdForPrimaryKey(primaryKey)
     },
-    unprocessedMessages: (shardIds) => {
+    unprocessedMessages(shardIds) {
+      const storage = this as MessageStorage["Service"]
       const shards = Array.from(shardIds, (id) => id.toString())
       if (!Arr.isArrayNonEmpty(shards)) return Effect.succeed([])
       return Effect.flatMap(
         Effect.suspend(() => encoded.unprocessedMessages(shards, clock.currentTimeMillisUnsafe())),
-        decodeMessages
+        (messages) => decodeMessages(storage, messages)
       )
     },
     unprocessedMessagesById(messageIds) {
+      const storage = this as MessageStorage["Service"]
       const ids = Array.from(messageIds)
       if (!Arr.isArrayNonEmpty(ids)) return Effect.succeed([])
       return Effect.flatMap(
         Effect.suspend(() => encoded.unprocessedMessagesById(ids, clock.currentTimeMillisUnsafe())),
-        decodeMessages
+        (messages) => decodeMessages(storage, messages)
       )
     },
     resetAddress: encoded.resetAddress,
@@ -539,13 +556,15 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
       const shards = Array.from(shardIds, (id) => id.toString())
       if (!Arr.isArrayNonEmpty(shards)) return Effect.void
       return encoded.resetShards(shards)
-    }
+    },
+    withTransaction: encoded.withTransaction
   })
 
   const decodeMessages = (
+    storage: MessageStorage["Service"],
     envelopes: Array<{
       readonly envelope: Envelope.Encoded
-      readonly lastSentReply: Reply.Encoded | undefined
+      readonly lastSentReply: Option.Option<Reply.Encoded>
     }>
   ) => {
     const messages: Array<Message.Incoming<any>> = []
@@ -611,7 +630,7 @@ export const makeEncoded: (encoded: Encoded) => Effect.Effect<
         if (!message) return Effect.void
         const schema = Reply.Reply(message.rpc)
         return Schema.decodeEffect(schema)(reply).pipe(
-          Effect.provideServices(message.services)
+          Effect.provideContext(message.context)
         ) as Effect.Effect<Reply.Reply<any>, Schema.SchemaError>
       }),
       (error) => {
@@ -654,12 +673,13 @@ export const noop: MessageStorage["Service"] = Effect.runSync(make({
   clearReplies: () => Effect.void,
   repliesFor: () => Effect.succeed([]),
   repliesForUnfiltered: () => Effect.succeed([]),
-  requestIdForPrimaryKey: () => Effect.undefined,
+  requestIdForPrimaryKey: () => Effect.succeedNone,
   unprocessedMessages: () => Effect.succeed([]),
   unprocessedMessagesById: () => Effect.succeed([]),
   resetAddress: () => Effect.void,
   clearAddress: () => Effect.void,
-  resetShards: () => Effect.void
+  resetShards: () => Effect.void,
+  withTransaction: identity
 }))
 
 /**
@@ -673,11 +693,21 @@ export type MemoryEntry = {
   deliverAt: number | null
 }
 
+/**
+ * Can be used in tests to simulate a transaction.
+ *
+ * @since 4.0.0
+ * @category Memory
+ */
+export const MemoryTransaction = Context.Reference<boolean>("effect/cluster/MessageStorage/MemoryTransaction", {
+  defaultValue: constFalse
+})
+
 /**
  * @since 4.0.0
  * @category Memory
  */
-export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/cluster/MessageStorage/MemoryDriver", {
+export class MemoryDriver extends Context.Service<MemoryDriver>()("effect/cluster/MessageStorage/MemoryDriver", {
   make: Effect.gen(function*() {
     const clock = yield* Clock
     const requests = new Map<string, MemoryEntry>()
@@ -692,7 +722,7 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
     const unprocessedWith = (predicate: Predicate<Envelope.Encoded>) => {
       const messages: Array<{
         readonly envelope: Envelope.Encoded
-        readonly lastSentReply: Reply.Encoded | undefined
+        readonly lastSentReply: Option.Option<Reply.Encoded>
       }> = []
       const now = clock.currentTimeMillisUnsafe()
       for (const envelope of unprocessed) {
@@ -706,19 +736,19 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
           }
           messages.push({
             envelope,
-            lastSentReply: entry?.replies[entry.replies.length - 1]
+            lastSentReply: Option.fromNullishOr(entry?.replies[entry.replies.length - 1])
           })
         } else {
           messages.push({
             envelope,
-            lastSentReply: undefined
+            lastSentReply: Option.none()
           })
         }
       }
       return messages
     }
 
-    const replyLatch = yield* Effect.makeLatch()
+    const replyLatch = yield* Latch.make()
 
     function repliesFor(requestIds: Array<string>) {
       const replies = Arr.empty<Reply.Encoded>()
@@ -750,9 +780,11 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
           if (existing) {
             return SaveResultEncoded.Duplicate({
               originalId: Snowflake.Snowflake(existing.envelope.requestId),
-              lastReceivedReply: existing.replies.length === 1 && existing.replies[0]._tag === "WithExit"
-                ? existing.replies[0]
-                : existing.lastReceivedChunk
+              lastReceivedReply: Option.fromNullishOr(
+                existing.replies.length === 1 && existing.replies[0]._tag === "WithExit"
+                  ? existing.replies[0]
+                  : existing.lastReceivedChunk
+              )
             })
           }
           if (envelope._tag === "Request") {
@@ -796,7 +828,7 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
       requestIdForPrimaryKey: (primaryKey) =>
         Effect.sync(() => {
           const entry = requestsByPrimaryKey.get(primaryKey)
-          return UndefinedOr.map(entry?.envelope.requestId, Snowflake.Snowflake)
+          return Option.map(Option.fromNullishOr(entry?.envelope.requestId), Snowflake.Snowflake)
         }),
       repliesFor: (requestIds) => Effect.sync(() => repliesFor(requestIds)),
       repliesForUnfiltered: (requestIds) =>
@@ -807,11 +839,11 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
           const now = clock.currentTimeMillisUnsafe()
           const messages = Arr.empty<{
             envelope: Envelope.Encoded
-            lastSentReply: Reply.Encoded | undefined
+            lastSentReply: Option.Option<Reply.Encoded>
           }>()
           for (let index = 0; index < journal.length; index++) {
             const envelope = journal[index]
-            const shardId = ShardId.makeUnsafe(envelope.address.shardId)
+            const shardId = ShardId.make(envelope.address.shardId.group, envelope.address.shardId.id)
             if (!unprocessed.has(envelope as any) || !shardIds.includes(shardId.toString())) {
               continue
             }
@@ -822,12 +854,12 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
               }
               messages.push({
                 envelope,
-                lastSentReply: entry.replies[entry.replies.length - 1]
+                lastSentReply: Option.fromNullishOr(entry.replies[entry.replies.length - 1])
               })
             } else {
               messages.push({
                 envelope,
-                lastSentReply: undefined
+                lastSentReply: Option.none()
               })
               unprocessed.delete(envelope)
             }
@@ -857,7 +889,8 @@ export class MemoryDriver extends ServiceMap.Service<MemoryDriver>()("effect/clu
             journal.splice(i, 1)
           }
         }),
-      resetShards: () => Effect.void
+      resetShards: () => Effect.void,
+      withTransaction: Effect.provideService(MemoryTransaction, true)
     }
 
     const storage = yield* makeEncoded(encoded)
@@ -904,15 +937,12 @@ export const layerMemory: Layer.Layer<
 
 const EnvelopeWithReply: Schema.Struct<
   {
-    readonly envelope: Schema.Codec<
-      Envelope.PartialRequest | Envelope.AckChunk | Envelope.Interrupt,
-      unknown
-    >
-    readonly lastSentReply: Schema.UndefinedOr<Schema.Codec<Reply.Encoded>>
+    readonly envelope: Schema.Decoder<Envelope.PartialRequest | Envelope.AckChunk | Envelope.Interrupt>
+    readonly lastSentReply: Schema.Option<Schema.Codec<Reply.Encoded>>
   }
 > = Schema.Struct({
   envelope: Schema.toCodecJson(Envelope.Partial),
-  lastSentReply: Schema.UndefinedOr(Reply.Encoded)
+  lastSentReply: Schema.Option(Reply.Encoded)
 })
 
 const decodeEnvelopeWithReply = Schema.decodeEffect(EnvelopeWithReply)

package/src/unstable/cluster/Reply.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
@@ -11,7 +12,6 @@ import * as Schema from "../../Schema.ts"
 import * as Issue from "../../SchemaIssue.ts"
 import * as Parser from "../../SchemaParser.ts"
 import * as Transformation from "../../SchemaTransformation.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import type * as RpcMessage from "../rpc/RpcMessage.ts"
 import type * as RpcSchema from "../rpc/RpcSchema.ts"
@@ -51,7 +51,7 @@ export const Encoded: Schema.Codec<Encoded> = Schema.Any as any
  */
 export class ReplyWithContext<R extends Rpc.Any> extends Data.TaggedClass("ReplyWithContext")<{
   readonly reply: Reply<R>
-  readonly services: ServiceMap.ServiceMap<Rpc.Services<R>>
+  readonly context: Context.Context<Rpc.Services<R>>
   readonly rpc: R
 }> {
   /**
@@ -68,7 +68,7 @@ export class ReplyWithContext<R extends Rpc.Any> extends Data.TaggedClass("Reply
         id: options.id,
         exit: Exit.die(Schema.encodeSync(Schema.Defect)(options.defect))
       }),
-      services: ServiceMap.empty() as any,
+      context: Context.empty() as any,
       rpc: neverRpc
     })
   }
@@ -85,7 +85,7 @@ export class ReplyWithContext<R extends Rpc.Any> extends Data.TaggedClass("Reply
         id: options.id,
         exit: Exit.interrupt()
       }),
-      services: ServiceMap.empty() as any,
+      context: Context.empty() as any,
       rpc: neverRpc
     })
   }
@@ -339,9 +339,9 @@ export const serialize = <R extends Rpc.Any>(
 ): Effect.Effect<Encoded, MalformedMessage> => {
   const schema = Reply(self.rpc)
   return MalformedMessage.refail(
-    Effect.provideServices(
+    Effect.provideContext(
       Schema.encodeEffect(schema)(self.reply),
-      self.services
+      self.context
     )
   )
 }
@@ -352,12 +352,15 @@ export const serialize = <R extends Rpc.Any>(
  */
 export const serializeLastReceived = <R extends Rpc.Any>(
   self: OutgoingRequest<R>
-): Effect.Effect<Encoded | undefined, MalformedMessage> => {
-  if (self.lastReceivedReply === undefined) {
-    return Effect.undefined
+): Effect.Effect<Option.Option<Encoded>, MalformedMessage> => {
+  const lastReceivedReply = self.lastReceivedReply
+  if (lastReceivedReply._tag === "None") {
+    return Effect.succeedNone
   }
   const schema = Reply(self.rpc)
   return MalformedMessage.refail(
-    Effect.provideServices(Schema.encodeEffect(schema)(self.lastReceivedReply), self.services)
+    Effect.provideContext(Schema.encodeEffect(schema)(lastReceivedReply.value), self.context)
+  ).pipe(
+    Effect.map(Option.some)
   )
 }

package/src/unstable/cluster/Runner.ts

@@ -93,4 +93,4 @@ export const make = (props: {
   readonly address: RunnerAddress
   readonly groups: ReadonlyArray<string>
   readonly weight: number
-}): Runner => new Runner(props, { disableValidation: true })
+}): Runner => new Runner(props, { disableChecks: true })

package/src/unstable/cluster/RunnerAddress.ts

@@ -63,4 +63,4 @@ export class RunnerAddress extends Schema.Class<RunnerAddress>(TypeId)({
  * @category constructors
  */
 export const make = (host: string, port: number): RunnerAddress =>
-  new RunnerAddress({ host, port }, { disableValidation: true })
+  new RunnerAddress({ host, port }, { disableChecks: true })

package/src/unstable/cluster/RunnerHealth.ts

@@ -1,11 +1,11 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Schedule from "../../Schedule.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as K8s from "./K8sHttpClient.ts"
 import type { RunnerAddress } from "./RunnerAddress.ts"
 import * as Runners from "./Runners.ts"
@@ -20,7 +20,7 @@ import * as Runners from "./Runners.ts"
  * @since 4.0.0
  * @category models
  */
-export class RunnerHealth extends ServiceMap.Service<
+export class RunnerHealth extends Context.Service<
   RunnerHealth,
   {
     readonly isAlive: (address: RunnerAddress) => Effect.Effect<boolean>

package/src/unstable/cluster/RunnerServer.ts

@@ -6,6 +6,7 @@ import type * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constant } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import * as Queue from "../../Queue.ts"
 import * as RpcServer from "../rpc/RpcServer.ts"
 import type * as ClusterError from "./ClusterError.ts"
@@ -36,23 +37,19 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
           ? new Message.IncomingRequest({
             envelope,
             respond: constVoid,
-            lastSentReply: undefined
+            lastSentReply: Option.none()
           })
           : new Message.IncomingEnvelope({ envelope })
       ),
     Effect: ({ persisted, request }) => {
-      let replyEncoded:
-        | Effect.Effect<
-          Reply.Encoded,
-          ClusterError.EntityNotAssignedToRunner
-        >
-        | undefined = undefined
+      let replyEncoded: Option.Option<Effect.Effect<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>> = Option
+        .none()
       let resume = (reply: Effect.Effect<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>) => {
-        replyEncoded = reply
+        replyEncoded = Option.some(reply)
       }
       const message = new Message.IncomingRequest({
         envelope: request,
-        lastSentReply: undefined,
+        lastSentReply: Option.none(),
         respond(reply) {
           resume(Effect.orDie(Reply.serialize(reply)))
           return Effect.void
@@ -75,7 +72,7 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
               resume(exit as any)
             }
           }
-          const runFork = Effect.runForkWith(parent.services)
+          const runFork = Effect.runForkWith(parent.context)
           const fiber = runFork(storage.registerReplyHandler(message))
           fiber.addObserver(onExit)
           runFork(Effect.catchTag(
@@ -89,8 +86,8 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
       return Effect.andThen(
         sharding.send(message),
         Effect.callback<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>((resume_) => {
-          if (replyEncoded) {
-            resume_(replyEncoded)
+          if (Option.isSome(replyEncoded)) {
+            resume_(replyEncoded.value)
           } else {
             resume = resume_
           }
@@ -103,7 +100,7 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
         (queue) => {
           const message = new Message.IncomingRequest({
             envelope: request,
-            lastSentReply: undefined,
+            lastSentReply: Option.none(),
             respond(reply) {
               return Effect.flatMap(Reply.serialize(reply), (reply) => {
                 Queue.offerUnsafe(queue, reply)
@@ -191,6 +188,6 @@ export const layerClientOnly: Layer.Layer<
   Layer.provide(RunnerHealth.layerNoop),
   Layer.updateService(ShardingConfig, (config) => ({
     ...config,
-    runnerAddress: undefined
+    runnerAddress: Option.none()
   }))
 )

package/src/unstable/cluster/RunnerStorage.ts

@@ -2,15 +2,15 @@
  * @since 4.0.0
  */
 import { isArrayNonEmpty, type NonEmptyArray } from "../../Array.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as MutableHashMap from "../../MutableHashMap.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { PersistenceError } from "./ClusterError.ts"
 import * as MachineId from "./MachineId.ts"
 import { Runner } from "./Runner.ts"
 import type { RunnerAddress } from "./RunnerAddress.ts"
-import { ShardId } from "./ShardId.ts"
+import * as ShardId from "./ShardId.ts"
 
 /**
  * Represents a generic interface to the persistent storage required by the
@@ -19,7 +19,7 @@ import { ShardId } from "./ShardId.ts"
  * @since 4.0.0
  * @category models
  */
-export class RunnerStorage extends ServiceMap.Service<RunnerStorage, {
+export class RunnerStorage extends Context.Service<RunnerStorage, {
   /**
    * Register a new runner with the cluster.
    */
@@ -47,23 +47,23 @@ export class RunnerStorage extends ServiceMap.Service<RunnerStorage, {
    */
   readonly acquire: (
     address: RunnerAddress,
-    shardIds: Iterable<ShardId>
-  ) => Effect.Effect<Array<ShardId>, PersistenceError>
+    shardIds: Iterable<ShardId.ShardId>
+  ) => Effect.Effect<Array<ShardId.ShardId>, PersistenceError>
 
   /**
    * Refresh the locks owned by the given runner.
    */
   readonly refresh: (
     address: RunnerAddress,
-    shardIds: Iterable<ShardId>
-  ) => Effect.Effect<Array<ShardId>, PersistenceError>
+    shardIds: Iterable<ShardId.ShardId>
+  ) => Effect.Effect<Array<ShardId.ShardId>, PersistenceError>
 
   /**
    * Release the given shard ids.
    */
   readonly release: (
     address: RunnerAddress,
-    shardId: ShardId
+    shardId: ShardId.ShardId
   ) => Effect.Effect<void, PersistenceError>
 
   /**
@@ -181,7 +181,7 @@ export const makeEncoded = (encoded: Encoded) =>
  */
 export const makeMemory = Effect.gen(function*() {
   const runners = MutableHashMap.empty<RunnerAddress, Runner>()
-  let acquired: Array<ShardId> = []
+  let acquired: Array<ShardId.ShardId> = []
   let id = 0
 
   return RunnerStorage.of({