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

package/src/unstable/cluster/SqlMessageStorage.ts

@@ -4,18 +4,18 @@
 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 +138,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 +163,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 +185,7 @@ export const make: (options?: {
               entityId: row.entity_id
             }
           },
-          lastSentReply: undefined
+          lastSentReply: Option.none()
         }
       case 2:
         return {
@@ -199,7 +199,7 @@ export const make: (options?: {
               entityId: row.entity_id
             }
           },
-          lastSentReply: undefined
+          lastSentReply: Option.none()
         }
     }
   }
@@ -395,24 +395,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 +458,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 +509,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 +592,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({

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

package/src/unstable/devtools/DevToolsClient.ts

@@ -2,14 +2,15 @@
  * @since 4.0.0
  */
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Deferred from "../../Deferred.ts"
 import * as Effect from "../../Effect.ts"
+import * as Fiber from "../../Fiber.ts"
 import * as Layer from "../../Layer.ts"
 import * as Metric from "../../Metric.ts"
 import * as Queue from "../../Queue.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as Tracer from "../../Tracer.ts"
 import * as Ndjson from "../encoding/Ndjson.ts"
@@ -23,13 +24,18 @@ const ResponseSchema = Schema.toCodecJson(DevToolsSchema.Response)
  * @since 4.0.0
  * @category tags
  */
-export class DevToolsClient extends ServiceMap.Service<DevToolsClient, {
-  readonly sendUnsafe: (_: DevToolsSchema.Span | DevToolsSchema.SpanEvent) => void
-}>()("effect/devtools/DevToolsClient") {}
+export class DevToolsClient extends Context.Service<
+  DevToolsClient,
+  {
+    readonly sendUnsafe: (
+      _: DevToolsSchema.Span | DevToolsSchema.SpanEvent
+    ) => void
+  }
+>()("effect/devtools/DevToolsClient") {}
 
 const makeEffect = Effect.gen(function*() {
   const socket = yield* Socket.Socket
-  const services = yield* Effect.services<never>()
+  const services = yield* Effect.context<never>()
   const requests = yield* Queue.unbounded<DevToolsSchema.Request>()
   const connected = yield* Deferred.make<void>()
 
@@ -37,7 +43,9 @@ const makeEffect = Effect.gen(function*() {
     Queue.offerUnsafe(requests, toMetricsSnapshot(services))
   })
 
-  const handleResponse = (response: DevToolsSchema.Response): Effect.Effect<void> => {
+  const handleResponse = (
+    response: DevToolsSchema.Response
+  ): Effect.Effect<void> => {
     switch (response._tag) {
       case "MetricsRequest": {
         return offerMetricsSnapshot
@@ -48,7 +56,7 @@ const makeEffect = Effect.gen(function*() {
     }
   }
 
-  yield* Stream.fromQueue(requests).pipe(
+  const fiber = yield* Stream.fromQueue(requests).pipe(
     Stream.pipeThroughChannel(
       Ndjson.duplexSchemaString(Socket.toChannelString(socket), {
         inputSchema: RequestSchema,
@@ -57,12 +65,15 @@ const makeEffect = Effect.gen(function*() {
     ),
     Stream.onFirst(() => Deferred.completeWith(connected, Effect.void)),
     Stream.runForEach(handleResponse),
-    Effect.forkScoped
+    Effect.forkDetach
   )
 
   yield* Effect.addFinalizer(() =>
     offerMetricsSnapshot.pipe(
-      Effect.andThen(Effect.flatMap(Effect.fiberId, (id) => Queue.failCause(requests, Cause.interrupt(id))))
+      Effect.andThen(
+        Effect.flatMap(Effect.fiberId, (id) => Queue.failCause(requests, Cause.interrupt(id)))
+      ),
+      Effect.andThen(Fiber.await(fiber))
     )
   )
 
@@ -84,9 +95,11 @@ const makeEffect = Effect.gen(function*() {
   })
 })
 
-const toMetricsSnapshot = (services: ServiceMap.ServiceMap<never>): DevToolsSchema.MetricsSnapshot => ({
+const toMetricsSnapshot = (
+  context: Context.Context<never>
+): DevToolsSchema.MetricsSnapshot => ({
   _tag: "MetricsSnapshot",
-  metrics: Metric.snapshotUnsafe(services)
+  metrics: Metric.snapshotUnsafe(context)
 })
 
 /**
@@ -108,11 +121,7 @@ export const make: Effect.Effect<
  * @since 4.0.0
  * @category layers
  */
-export const layer: Layer.Layer<
-  DevToolsClient,
-  never,
-  Socket.Socket
-> = Layer.effect(DevToolsClient, make)
+export const layer: Layer.Layer<DevToolsClient, never, Socket.Socket> = Layer.effect(DevToolsClient, make)
 
 const makeTracerEffect = Effect.gen(function*() {
   const client = yield* DevToolsClient
@@ -162,10 +171,6 @@ export const makeTracer: Effect.Effect<Tracer.Tracer, never, DevToolsClient> = m
  * @since 4.0.0
  * @category layers
  */
-export const layerTracer: Layer.Layer<
-  never,
-  never,
-  Socket.Socket
-> = Layer.effect(Tracer.Tracer, makeTracer).pipe(
+export const layerTracer: Layer.Layer<never, never, Socket.Socket> = Layer.effect(Tracer.Tracer, makeTracer).pipe(
   Layer.provide(layer)
 )