effect 4.0.0-beta.6 → 4.0.0-beta.60

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

@@ -1,8 +1,9 @@
 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"
@@ -16,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"
@@ -71,7 +71,7 @@ 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
@@ -93,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
@@ -107,10 +107,11 @@ export const make = Effect.fnUntraced(function*<
   const storageEnabled = options.storage !== MessageStorage.noop
   const mailboxCapacity = options.mailboxCapacity ?? config.entityMailboxCapacity
   const clock = yield* Clock
-  const services = yield* Effect.services<Rpc.Services<Rpcs> | Rpc.Middleware<Rpcs> | RX>()
-  const retryDriver = yield* Schedule.toStepWithSleep(
-    options.defectRetryPolicy ? Schedule.andThen(options.defectRetryPolicy, defaultRetryPolicy) : defaultRetryPolicy
-  )
+  const context = yield* Effect.context<Rpc.Services<Rpcs> | Rpc.Middleware<Rpcs> | RX>()
+  const defectRetryPolicy = options.defectRetryPolicy
+    ? Schedule.andThen(options.defectRetryPolicy, defaultRetryPolicy)
+    : defaultRetryPolicy
+  const retryDriver = yield* Schedule.toStepWithSleep(defectRetryPolicy)
   const entityRpcs = new Map(entity.protocol.requests)
 
   // add internal rpcs
@@ -156,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})`,
@@ -187,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, {
@@ -251,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)
                   })
                 ))
@@ -266,7 +271,7 @@ export const make = Effect.fnUntraced(function*<
           }
         }).pipe(
           Scope.provide(scope),
-          Effect.provideServices(handlers)
+          Effect.provideContext(handlers)
         )
 
         yield* Scope.addFinalizer(
@@ -352,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({
@@ -363,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(
@@ -395,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"
                 )
@@ -438,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)
@@ -460,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
               }
@@ -486,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) =>
@@ -538,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
               })
             ))
           },
@@ -552,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) =>
@@ -559,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)
   })
@@ -585,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: {
@@ -602,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
@@ -627,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,8 +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"
@@ -10,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<{

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/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)
 )

package/src/unstable/devtools/DevToolsSchema.ts

@@ -1,7 +1,11 @@
 /**
  * @since 4.0.0
  */
+import * as Exit from "../../Exit.ts"
+import { identity } from "../../Function.ts"
+import type * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
+import * as SchemaTransformation from "../../SchemaTransformation.ts"
 
 /**
  * @since 4.0.0
@@ -25,7 +29,16 @@ export type SpanStatusStarted = Schema.Schema.Type<typeof SpanStatusStarted>
 export const SpanStatusEnded = Schema.Struct({
   _tag: Schema.tag("Ended"),
   startTime: Schema.BigInt,
-  endTime: Schema.BigInt
+  endTime: Schema.BigInt,
+  exit: Schema.Exit(Schema.Void, Schema.DefectWithStack, Schema.DefectWithStack).pipe(
+    Schema.decodeTo(
+      Schema.Exit(Schema.Unknown, Schema.Unknown, Schema.Unknown),
+      SchemaTransformation.transform({
+        decode: identity,
+        encode: Exit.asVoid
+      })
+    )
+  )
 })
 
 /**
@@ -80,7 +93,7 @@ export interface Span {
   readonly sampled: boolean
   readonly attributes: ReadonlyMap<string, unknown>
   readonly status: SpanStatus
-  readonly parent: ParentSpan | undefined
+  readonly parent: Option.Option<ParentSpan>
 }
 
 /**
@@ -95,7 +108,7 @@ export const Span: Schema.Codec<Span> = Schema.Struct({
   sampled: Schema.Boolean,
   attributes: Schema.ReadonlyMap(Schema.String, Schema.Any),
   status: SpanStatus,
-  parent: Schema.UndefinedOr(Schema.suspend(() => ParentSpan))
+  parent: Schema.Option(Schema.suspend(() => ParentSpan))
 })
 
 /**

package/src/unstable/encoding/Ndjson.ts

@@ -61,13 +61,13 @@ export const encodeString = <IE = never, Done = unknown>(): Channel.Channel<
  * @category constructors
  */
 export const encode = <IE = never, Done = unknown>(): Channel.Channel<
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   IE | NdjsonError,
   Done,
   Arr.NonEmptyReadonlyArray<unknown>,
   IE,
   Done
-> => Channel.map(encodeString(), Arr.map((_) => encoder.encode(_) as Uint8Array<ArrayBuffer>))
+> => Channel.map(encodeString(), Arr.map((_) => encoder.encode(_)))
 
 /**
  * @since 4.0.0
@@ -77,7 +77,7 @@ export const encodeSchema = <S extends Schema.Top>(
   schema: S
 ) =>
 <IE = never, Done = unknown>(): Channel.Channel<
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   NdjsonError | Schema.SchemaError | IE,
   Done,
   Arr.NonEmptyReadonlyArray<S["Type"]>,
@@ -141,7 +141,7 @@ export const decode = <IE = never, Done = unknown>(options?: {
   Arr.NonEmptyReadonlyArray<unknown>,
   IE | NdjsonError,
   Done,
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   IE,
   Done
 > => {
@@ -161,7 +161,7 @@ export const decodeSchema = <S extends Schema.Top>(
   Arr.NonEmptyReadonlyArray<S["Type"]>,
   Schema.SchemaError | NdjsonError | IE,
   Done,
-  Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+  Arr.NonEmptyReadonlyArray<Uint8Array>,
   IE,
   Done,
   S["DecodingServices"]
@@ -201,10 +201,10 @@ export const duplex: {
     }
   ): <R, IE, OE, OutDone, InDone>(
     self: Channel.Channel<
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       OE,
       OutDone,
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       IE | NdjsonError,
       InDone,
       R
@@ -224,10 +224,10 @@ export const duplex: {
    */
   <R, IE, OE, OutDone, InDone>(
     self: Channel.Channel<
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       OE,
       OutDone,
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       IE | NdjsonError,
       InDone,
       R
@@ -246,10 +246,10 @@ export const duplex: {
   >
 } = dual((args) => Channel.isChannel(args[0]), <R, IE, OE, OutDone, InDone>(
   self: Channel.Channel<
-    Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+    Arr.NonEmptyReadonlyArray<Uint8Array>,
     OE,
     OutDone,
-    Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+    Arr.NonEmptyReadonlyArray<Uint8Array>,
     IE | NdjsonError,
     InDone,
     R
@@ -373,10 +373,10 @@ export const duplexSchema: {
     }
   ): <OutErr, OutDone, InErr, InDone, R>(
     self: Channel.Channel<
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       OutErr,
       OutDone,
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       NdjsonError | Schema.SchemaError | InErr,
       InDone,
       R
@@ -396,10 +396,10 @@ export const duplexSchema: {
    */
   <Out extends Schema.Top, In extends Schema.Top, OutErr, OutDone, InErr, InDone, R>(
     self: Channel.Channel<
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       OutErr,
       OutDone,
-      Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+      Arr.NonEmptyReadonlyArray<Uint8Array>,
       NdjsonError | Schema.SchemaError | InErr,
       InDone,
       R
@@ -420,10 +420,10 @@ export const duplexSchema: {
   >
 } = dual(2, <Out extends Schema.Top, In extends Schema.Top, OutErr, OutDone, InErr, InDone, R>(
   self: Channel.Channel<
-    Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+    Arr.NonEmptyReadonlyArray<Uint8Array>,
     OutErr,
     OutDone,
-    Arr.NonEmptyReadonlyArray<Uint8Array<ArrayBuffer>>,
+    Arr.NonEmptyReadonlyArray<Uint8Array>,
     NdjsonError | Schema.SchemaError | InErr,
     InDone,
     R

package/src/unstable/encoding/Sse.ts

@@ -311,7 +311,7 @@ export const encode = <IE, Done>(): Channel.Channel<
       let done = false
       const pull = upstream.pipe(
         Effect.map(Arr.map(encoder.write)),
-        Effect.catchIf(Retry.filter as any, (retry: any) => {
+        Effect.catchFilter(Retry.filter as any, (retry: any) => {
           done = true
           return Effect.succeed(Arr.of(encoder.write(retry)))
         }),
@@ -326,11 +326,9 @@ export const encode = <IE, Done>(): Channel.Channel<
  * @category Encoding
  */
 export const encodeSchema = <
-  S extends Schema.Codec<
-    any,
+  S extends Schema.Encoder<
     { readonly id?: string | undefined; readonly event: string; readonly data: string },
-    any,
-    any
+    unknown
   >,
   IE,
   Done

package/src/unstable/eventlog/Event.ts

@@ -38,7 +38,6 @@ export interface Event<
 > {
   readonly [TypeId]: TypeId
   readonly tag: Tag
-  readonly key: string
   readonly primaryKey: (payload: Schema.Schema.Type<Payload>) => string
   readonly payload: Payload
   readonly payloadMsgPack: Msgpack.schema<Payload>
@@ -62,7 +61,6 @@ export interface EventHandler<in out Tag extends string> {
 export interface Any {
   readonly [TypeId]: TypeId
   readonly tag: string
-  readonly key: string
   readonly primaryKey: (payload: any) => string
   readonly payload: Schema.Top
   readonly payloadMsgPack: Msgpack.schema<Schema.Top>
@@ -312,7 +310,6 @@ export function make(options: {
   const error = options.error ?? Schema.Never
   return Object.assign(Object.create(Proto), {
     tag: options.tag,
-    key: serviceKey(options.tag),
     primaryKey: options.primaryKey,
     payload,
     payloadMsgPack: Msgpack.schema(payload),
@@ -338,8 +335,3 @@ export function addError(event: Any, error: Schema.Top): Any {
     error: Schema.Union([event.error, error])
   })
 }
-
-/**
- * @since 4.0.0
- */
-export const serviceKey = (tag: string): string => `effect/eventlog/Event/${tag}`

package/src/unstable/eventlog/EventGroup.ts

@@ -37,8 +37,6 @@ export const isEventGroup = (u: unknown): u is Any => Predicate.hasProperty(u, T
 export interface EventGroup<
   out Events extends Event.Any = Event.Any
 > extends Pipeable {
-  readonly _?: symbol
-  readonly __type?: Events | undefined
   readonly [TypeId]: TypeId
   readonly events: Record.ReadonlyRecord<string, Events>
 
@@ -112,8 +110,6 @@ const makeProto = <
   const EventGroupClass = (_: never) => {}
   const group = Object.assign(EventGroupClass, {
     [TypeId]: TypeId,
-    _: Symbol.for("~effect/eventlog/EventGroup"),
-    __type: undefined,
     events: options.events,
     add<
       Tag extends string,