effect 4.0.0-beta.5 → 4.0.0-beta.51

package/src/unstable/cluster/SqlMessageStorage.ts

@@ -1,21 +1,22 @@
 /**
  * @since 4.0.0
  */
+// eslint-disable effect/no-bigint-literals
 import * as Arr from "../../Array.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import * as Schedule from "../../Schedule.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as Migrator from "../sql/Migrator.ts"
 import * as SqlClient from "../sql/SqlClient.ts"
 import type { Row } from "../sql/SqlConnection.ts"
-import type { SqlError } from "../sql/SqlError.ts"
+import { isSqlError, type SqlError } from "../sql/SqlError.ts"
 import { PersistenceError } from "./ClusterError.ts"
 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"
 
@@ -138,7 +139,7 @@ export const make: (options?: {
 
   const messageFromRow = (row: MessageRow & ReplyJoinRow): {
     readonly envelope: Envelope.Encoded
-    readonly lastSentReply: Reply.Encoded | undefined
+    readonly lastSentReply: Option.Option<Reply.Encoded>
   } => {
     switch (Number(row.kind) as 0 | 1 | 2) {
       case 0:
@@ -163,14 +164,14 @@ export const make: (options?: {
               undefined)
           },
           lastSentReply: row.reply_reply_id ?
-            {
+            Option.some({
               _tag: "Chunk",
               id: String(row.reply_reply_id),
               requestId: String(row.request_id),
               sequence: Number(row.reply_sequence!),
               values: JSON.parse(row.reply_payload!)
-            } :
-            undefined
+            }) :
+            Option.none()
         }
       case 1:
         return {
@@ -185,7 +186,7 @@ export const make: (options?: {
               entityId: row.entity_id
             }
           },
-          lastSentReply: undefined
+          lastSentReply: Option.none()
         }
       case 2:
         return {
@@ -199,7 +200,7 @@ export const make: (options?: {
               entityId: row.entity_id
             }
           },
-          lastSentReply: undefined
+          lastSentReply: Option.none()
         }
     }
   }
@@ -395,24 +396,27 @@ export const make: (options?: {
             }
             const row = rows[0]
             const replyKindNum = typeof row.reply_kind === "bigint" ? Number(row.reply_kind) : row.reply_kind
-            return SaveResultEncoded.Duplicate({
-              originalId: Snowflake.Snowflake(row.id as any),
-              lastReceivedReply: row.reply_id ?
-                replyKindNum === replyKind.WithExit ?
-                  {
+            const lastReceivedReply: Option.Option<Reply.Encoded> = row.reply_id
+              ? Option.some(
+                replyKindNum === replyKind.WithExit
+                  ? {
                     id: String(row.reply_id),
                     requestId: String(row.id),
                     _tag: "WithExit",
                     exit: JSON.parse(row.reply_payload as string)
-                  } :
-                  {
+                  }
+                  : {
                     id: String(row.reply_id),
                     requestId: String(row.id),
                     _tag: "Chunk",
                     sequence: Number(row.reply_sequence),
                     values: JSON.parse(row.reply_payload as string)
-                  } :
-                undefined
+                  }
+              )
+              : Option.none()
+            return SaveResultEncoded.Duplicate({
+              originalId: Snowflake.Snowflake(row.id as any),
+              lastReceivedReply
             })
           })
         )
@@ -455,7 +459,7 @@ export const make: (options?: {
 
     requestIdForPrimaryKey: (primaryKey) =>
       sql<{ id: string | bigint }>`SELECT id FROM ${messagesTableSql} WHERE message_id = ${primaryKey}`.pipe(
-        Effect.map((rows) => UndefinedOr.map(rows[0]?.id, Snowflake.Snowflake)),
+        Effect.map((rows) => Option.map(Option.fromNullishOr(rows[0]?.id), Snowflake.Snowflake)),
         Effect.provideService(SqlClient.SafeIntegers, true),
         PersistenceError.refail,
         withTracerDisabled
@@ -506,7 +510,7 @@ export const make: (options?: {
         }
         const messages: Array<{
           readonly envelope: Envelope.Encoded
-          readonly lastSentReply: Reply.Encoded | undefined
+          readonly lastSentReply: Option.Option<Reply.Encoded>
         }> = new Array(rows.length)
         const ids = new Array<string>(rows.length)
         for (let i = 0; i < rows.length; i++) {
@@ -589,6 +593,11 @@ export const make: (options?: {
         Effect.asVoid,
         PersistenceError.refail,
         withTracerDisabled
+      ),
+
+    withTransaction: (effect) =>
+      sql.withTransaction(effect).pipe(
+        Effect.catchIf(isSqlError, Effect.die)
       )
   })
 }, withTracerDisabled)

package/src/unstable/cluster/SqlRunnerStorage.ts

@@ -166,7 +166,7 @@ export const make = Effect.fnUntraced(function*(options: {
 
   const expiresSeconds = sql.literal(
     Math.ceil(Duration.toSeconds(
-      Duration.fromDurationInputUnsafe(config.shardLockExpiration)
+      Duration.fromInputUnsafe(config.shardLockExpiration)
     )).toString()
   )
   const lockExpiresAt = sql.onDialectOrElse({
@@ -536,7 +536,8 @@ export const make = Effect.fnUntraced(function*(options: {
         shardIds.length > 0 ?
           Effect.andThen(refreshShards(address, shardIds)) :
           Effect.as([]),
-        PersistenceError.refail
+        PersistenceError.refail,
+        withTracerDisabled
       ),
 
     release: sql.onDialectOrElse({
@@ -544,7 +545,8 @@ export const make = Effect.fnUntraced(function*(options: {
         if (disableAdvisoryLocks) {
           return (address: string, shardId: string) =>
             sql`DELETE FROM ${locksTableSql} WHERE address = ${address} AND shard_id = ${shardId}`.pipe(
-              PersistenceError.refail
+              PersistenceError.refail,
+              withTracerDisabled
             )
         }
         return Effect.fnUntraced(
@@ -564,14 +566,16 @@ export const make = Effect.fnUntraced(function*(options: {
           },
           Effect.onError(() => lockConn!.rebuildUnsafe()),
           Effect.asVoid,
-          PersistenceError.refail
+          PersistenceError.refail,
+          withTracerDisabled
         )
       },
       mysql: () => {
         if (disableAdvisoryLocks) {
           return (address: string, shardId: string) =>
             sql`DELETE FROM ${locksTableSql} WHERE address = ${address} AND shard_id = ${shardId}`.pipe(
-              PersistenceError.refail
+              PersistenceError.refail,
+              withTracerDisabled
             )
         }
         return Effect.fnUntraced(
@@ -589,12 +593,14 @@ export const make = Effect.fnUntraced(function*(options: {
           },
           Effect.onError(() => lockConn!.rebuildUnsafe()),
           Effect.asVoid,
-          PersistenceError.refail
+          PersistenceError.refail,
+          withTracerDisabled
         )
       },
       orElse: () => (address, shardId) =>
         sql`DELETE FROM ${locksTableSql} WHERE address = ${address} AND shard_id = ${shardId}`.pipe(
-          PersistenceError.refail
+          PersistenceError.refail,
+          withTracerDisabled
         )
     }),
 

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

@@ -1,13 +1,15 @@
 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 { DurationInput } from "../../../Duration.ts"
+import type { Input } from "../../../Duration.ts"
 import * as Effect from "../../../Effect.ts"
 import * as Equal from "../../../Equal.ts"
 import * as Exit from "../../../Exit.ts"
 import * as Fiber from "../../../Fiber.ts"
 import { identity } from "../../../Function.ts"
+import * as Latch from "../../../Latch.ts"
 import * as Metric from "../../../Metric.ts"
 import * as Option from "../../../Option.ts"
 import { CurrentLogAnnotations } from "../../../References.ts"
@@ -15,14 +17,13 @@ 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 * as UndefinedOr from "../../../UndefinedOr.ts"
 import type * as Rpc from "../../rpc/Rpc.ts"
 import { RequestId } from "../../rpc/RpcMessage.ts"
 import * as RpcServer from "../../rpc/RpcServer.ts"
 import { AlreadyProcessingMessage, EntityNotAssignedToRunner, MailboxFull, MalformedMessage } from "../ClusterError.ts"
 import * as ClusterMetrics from "../ClusterMetrics.ts"
-import { isUninterruptibleForServer, Persisted } from "../ClusterSchema.ts"
+import { isUninterruptibleForServer, Persisted, WithTransaction } from "../ClusterSchema.ts"
+import * as ClusterSchema from "../ClusterSchema.ts"
 import type { Entity, HandlersFrom } from "../Entity.ts"
 import { CurrentAddress, CurrentRunnerAddress, KeepAliveLatch, KeepAliveRpc, Request } from "../Entity.ts"
 import type { EntityAddress } from "../EntityAddress.ts"
@@ -70,12 +71,12 @@ export type EntityState = {
     readonly rpc: Rpc.AnyWithProps
     readonly message: Message.IncomingRequestLocal<any>
     sentReply: boolean
-    lastSentChunk: Reply.Chunk<Rpc.Any> | undefined
+    lastSentChunk: Option.Option<Reply.Chunk<Rpc.Any>>
     sequence: number
   }>
   lastActiveCheck: number
   write: RpcServer.RpcServer<any>["write"]
-  readonly keepAliveLatch: Effect.Latch
+  readonly keepAliveLatch: Latch.Latch
   keepAliveEnabled: boolean
 }
 
@@ -92,7 +93,7 @@ export const make = Effect.fnUntraced(function*<
     readonly sharding: Sharding["Service"]
     readonly storage: MessageStorage.MessageStorage["Service"]
     readonly runnerAddress: RunnerAddress
-    readonly maxIdleTime?: DurationInput | undefined
+    readonly maxIdleTime?: Input | undefined
     readonly concurrency?: number | "unbounded" | undefined
     readonly mailboxCapacity?: number | "unbounded" | undefined
     readonly disableFatalDefects?: boolean | undefined
@@ -106,17 +107,18 @@ 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
   entityRpcs.set(KeepAliveRpc._tag, KeepAliveRpc as any)
 
   const activeServers = new Map<EntityId, EntityState>()
-  const serverCloseLatches = new Map<EntityAddress, Effect.Latch>()
+  const serverCloseLatches = new Map<EntityAddress, Latch.Latch>()
   const processedRequestIds = new Set<Snowflake.Snowflake>()
 
   const entities: ResourceMap<
@@ -129,8 +131,8 @@ export const make = Effect.fnUntraced(function*<
     }
 
     const scope = yield* Effect.scope
-    const endLatch = Effect.makeLatchUnsafe()
-    const keepAliveLatch = Effect.makeLatchUnsafe()
+    const endLatch = Latch.makeUnsafe()
+    const keepAliveLatch = Latch.makeUnsafe()
 
     // on shutdown, reset the storage for the entity
     yield* Scope.addFinalizerExit(
@@ -155,13 +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(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})`,
@@ -186,9 +192,9 @@ export const make = Effect.fnUntraced(function*<
                 // interrupt.
                 if (
                   storageEnabled &&
-                  ServiceMap.get(request.rpc.annotations, Persisted) &&
+                  Context.get(request.message.annotations, Persisted) &&
                   Exit.hasInterrupts(response.exit) &&
-                  (isShuttingDown || isUninterruptibleForServer(request.rpc.annotations))
+                  (isShuttingDown || isUninterruptibleForServer(request.message.annotations))
                 ) {
                   if (!isShuttingDown) {
                     return server.write(0, {
@@ -250,7 +256,7 @@ export const make = Effect.fnUntraced(function*<
                       sequence,
                       values: response.values
                     })
-                    request.lastSentChunk = reply
+                    request.lastSentChunk = Option.some(reply)
                     return request.message.respond(reply)
                   })
                 ))
@@ -265,7 +271,7 @@ export const make = Effect.fnUntraced(function*<
           }
         }).pipe(
           Scope.provide(scope),
-          Effect.provideServices(handlers)
+          Effect.provideContext(handlers)
         )
 
         yield* Scope.addFinalizer(
@@ -336,7 +342,7 @@ export const make = Effect.fnUntraced(function*<
       scope,
       Effect.withFiber((fiber) => {
         activeServers.delete(address.entityId)
-        serverCloseLatches.set(address, Effect.makeLatchUnsafe())
+        serverCloseLatches.set(address, Latch.makeUnsafe())
         internalInterruptors.add(fiber.id)
         return state.write(0, { _tag: "Eof" }).pipe(
           Effect.andThen(Effect.interruptible(endLatch.await)),
@@ -351,7 +357,7 @@ export const make = Effect.fnUntraced(function*<
 
   const reaper = yield* EntityReaper
   const maxIdleTime = Duration.toMillis(
-    Duration.fromDurationInputUnsafe(options.maxIdleTime ?? config.entityMaxIdleTime)
+    Duration.fromInputUnsafe(options.maxIdleTime ?? config.entityMaxIdleTime)
   )
   if (Number.isFinite(maxIdleTime)) {
     yield* reaper.register({
@@ -362,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(
@@ -394,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(rpc.annotations, Persisted)) {
+              if (!storageEnabled && Context.get(message.annotations, Persisted)) {
                 return Effect.die(
                   "EntityManager.sendLocal: Cannot process a persisted message without MessageStorage"
                 )
@@ -437,21 +443,31 @@ export const make = Effect.fnUntraced(function*<
                 rpc,
                 message,
                 sentReply: false,
-                lastSentChunk: message.lastSentReply as Reply.Chunk<Rpc.Any> | undefined,
-                sequence: UndefinedOr.match(message.lastSentReply, {
-                  onUndefined: () => 0,
-                  onDefined: (reply) => reply._tag === "Chunk" ? reply.sequence + 1 : 0
+                lastSentChunk: Option.filter(
+                  message.lastSentReply,
+                  (reply): reply is Reply.Chunk<Rpc.Any> => reply._tag === "Chunk"
+                ),
+                sequence: Option.match(message.lastSentReply, {
+                  onNone: () => 0,
+                  onSome: (reply) => reply._tag === "Chunk" ? reply.sequence + 1 : 0
                 })
               }
               server.activeRequests.set(message.envelope.requestId, entry)
-              return server.write(0, {
+              let write = server.write(0, {
                 ...message.envelope,
                 id: RequestId(message.envelope.requestId),
                 payload: new Request({
                   ...message.envelope,
-                  lastSentChunk: message.lastSentReply as Reply.Chunk<R> | undefined
+                  lastSentChunk: Option.filter(
+                    message.lastSentReply,
+                    (reply): reply is Reply.Chunk<R> => reply._tag === "Chunk"
+                  )
                 })
               })
+              if (Context.get(message.annotations, WithTransaction)) {
+                write = options.storage.withTransaction(write)
+              }
+              return write
             }
             case "IncomingEnvelope": {
               const entry = server.activeRequests.get(message.envelope.requestId)
@@ -459,8 +475,8 @@ export const make = Effect.fnUntraced(function*<
                 return Effect.void
               } else if (
                 message.envelope._tag === "AckChunk" &&
-                entry.lastSentChunk !== undefined &&
-                message.envelope.replyId !== entry.lastSentChunk.id
+                Option.isSome(entry.lastSentChunk) &&
+                message.envelope.replyId !== entry.lastSentChunk.value.id
               ) {
                 return Effect.void
               }
@@ -485,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) =>
@@ -537,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
               })
             ))
           },
@@ -551,6 +567,10 @@ export const make = Effect.fnUntraced(function*<
             const rpc = entityRpcs.get(decoded.envelope.tag)!
             return sendLocal(
               new Message.IncomingRequestLocal({
+                annotations: Context.get(rpc.annotations, ClusterSchema.Dynamic)(
+                  rpc.annotations,
+                  decoded.envelope as any
+                ),
                 envelope: decoded.envelope,
                 lastSentReply: decoded.lastSentReply,
                 respond: (reply) =>
@@ -558,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)
   })
@@ -584,9 +604,9 @@ const makeMessageDecode = <Type extends string, Rpcs extends Rpc.Any>(
     rpc: Rpc.AnyWithProps
   ) {
     const payload = yield* Schema.decodeEffect(Schema.toCodecJson(rpc.payloadSchema))(message.envelope.payload)
-    const lastSentReply = message.lastSentReply !== undefined
-      ? yield* Schema.decodeEffect(Reply.Reply(rpc))(message.lastSentReply)
-      : undefined
+    const lastSentReply = Option.isNone(message.lastSentReply) ?
+      message.lastSentReply :
+      Option.some(yield* Schema.decodeEffect(Reply.Reply(rpc))(message.lastSentReply.value))
     return {
       _tag: "IncomingRequest",
       envelope: {
@@ -601,7 +621,7 @@ const makeMessageDecode = <Type extends string, Rpcs extends Rpc.Any>(
     {
       readonly _tag: "IncomingRequest"
       readonly envelope: Envelope.Request.Any
-      readonly lastSentReply: Reply.Reply<Rpcs> | undefined
+      readonly lastSentReply: Option.Option<Reply.Reply<Rpcs>>
     } | {
       readonly _tag: "IncomingEnvelope"
       readonly envelope: Envelope.AckChunk | Envelope.Interrupt
@@ -626,7 +646,7 @@ const makeMessageDecode = <Type extends string, Rpcs extends Rpc.Any>(
       {
         readonly _tag: "IncomingRequest"
         readonly envelope: Envelope.Request.Any
-        readonly lastSentReply: Reply.Reply<Rpcs> | undefined
+        readonly lastSentReply: Option.Option<Reply.Reply<Rpcs>>
       },
       Schema.SchemaError,
       Rpc.ServicesServer<Rpcs>

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

@@ -1,7 +1,8 @@
 import { Clock } from "../../../Clock.ts"
+import * as Context from "../../../Context.ts"
 import * as Effect from "../../../Effect.ts"
+import * as Latch from "../../../Latch.ts"
 import * as Layer from "../../../Layer.ts"
-import * as ServiceMap from "../../../ServiceMap.ts"
 import type { EntityNotAssignedToRunner } from "../ClusterError.ts"
 import type { EntityAddress } from "../EntityAddress.ts"
 import type { EntityId } from "../EntityId.ts"
@@ -9,7 +10,7 @@ import type { EntityState } from "./entityManager.ts"
 import type { ResourceMap } from "./resourceMap.ts"
 
 /** @internal */
-export class EntityReaper extends ServiceMap.Service<EntityReaper>()("effect/cluster/EntityReaper", {
+export class EntityReaper extends Context.Service<EntityReaper>()("effect/cluster/EntityReaper", {
   make: Effect.gen(function*() {
     let currentResolution = 30_000
     const registered: Array<{
@@ -17,7 +18,7 @@ export class EntityReaper extends ServiceMap.Service<EntityReaper>()("effect/clu
       readonly servers: Map<EntityId, EntityState>
       readonly entities: ResourceMap<EntityAddress, EntityState, EntityNotAssignedToRunner>
     }> = []
-    const latch = yield* Effect.makeLatch()
+    const latch = yield* Latch.make()
 
     const register = (options: {
       readonly maxIdleTime: number

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

@@ -1,3 +1,4 @@
+import * as Context from "../../../Context.ts"
 import * as Deferred from "../../../Deferred.ts"
 import * as Effect from "../../../Effect.ts"
 import * as Exit from "../../../Exit.ts"
@@ -5,7 +6,6 @@ import * as MutableHashMap from "../../../MutableHashMap.ts"
 import * as MutableRef from "../../../MutableRef.ts"
 import * as Option from "../../../Option.ts"
 import * as Scope from "../../../Scope.ts"
-import * as ServiceMap from "../../../ServiceMap.ts"
 
 /** @internal */
 export class ResourceMap<K, A, E> {
@@ -30,7 +30,7 @@ export class ResourceMap<K, A, E> {
 
   static make = Effect.fnUntraced(function*<K, A, E, R>(lookup: (key: K) => Effect.Effect<A, E, R>) {
     const scope = yield* Effect.scope
-    const services = yield* Effect.services<R>()
+    const services = yield* Effect.context<R>()
     const isClosed = MutableRef.make(false)
 
     const entries = MutableHashMap.empty<K, {
@@ -50,7 +50,7 @@ export class ResourceMap<K, A, E> {
     )
 
     return new ResourceMap(
-      (key, scope) => Effect.provide(lookup(key), ServiceMap.add(services, Scope.Scope, scope)),
+      (key, scope) => Effect.provide(lookup(key), Context.add(services, Scope.Scope, scope)),
       entries,
       isClosed
     )

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

@@ -1,5 +1,6 @@
 import * as Effect from "../../../Effect.ts"
 import * as Exit from "../../../Exit.ts"
+import * as Latch from "../../../Latch.ts"
 import * as MutableRef from "../../../MutableRef.ts"
 import * as Option from "../../../Option.ts"
 import * as Scope from "../../../Scope.ts"
@@ -53,7 +54,7 @@ export class ResourceRef<A, E = never> {
     this.acquire = acquire
   }
 
-  latch = Effect.makeLatchUnsafe(true)
+  latch = Latch.makeUnsafe(true)
 
   getUnsafe(): Option.Option<A> {
     if (this.state.current._tag === "Acquired") {