effect 4.0.0-beta.11 → 4.0.0-beta.12

package/src/unstable/http/HttpClient.ts

@@ -949,13 +949,16 @@ export const retryTransient: {
    * @category error handling
    */
   <
-    B,
     E,
+    B = never,
     ES = never,
     R1 = never,
-    const RetryOn extends "errors-only" | "response-only" | "errors-and-responses" = never,
-    Input = "errors-only" extends RetryOn ? E
-      : "response-only" extends RetryOn ? HttpClientResponse.HttpClientResponse
+    const RetryOn extends "errors-only" | "response-only" | "errors-and-responses" =
+      | "errors-only"
+      | "response-only"
+      | "errors-and-responses",
+    Input = RetryOn extends "errors-only" ? E
+      : RetryOn extends "response-only" ? HttpClientResponse.HttpClientResponse
       : HttpClientResponse.HttpClientResponse | E
   >(
     options: {
@@ -963,7 +966,7 @@ export const retryTransient: {
       readonly while?: Predicate.Predicate<NoInfer<E | ES>>
       readonly schedule?: Schedule.Schedule<B, NoInfer<Input>, ES, R1>
       readonly times?: number
-    } | Schedule.Schedule<B, NoInfer<Input>, ES, R1>
+    }
   ): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E | ES, R1 | R>
   /**
    * Retries common transient errors, such as rate limiting, timeouts or network issues.
@@ -979,12 +982,15 @@ export const retryTransient: {
   <
     E,
     R,
-    B,
+    B = never,
     ES = never,
     R1 = never,
-    const RetryOn extends "errors-only" | "response-only" | "errors-and-responses" = never,
-    Input = "errors-only" extends RetryOn ? E
-      : "response-only" extends RetryOn ? HttpClientResponse.HttpClientResponse
+    const RetryOn extends "errors-only" | "response-only" | "errors-and-responses" =
+      | "errors-only"
+      | "response-only"
+      | "errors-and-responses",
+    Input = RetryOn extends "errors-only" ? E
+      : RetryOn extends "response-only" ? HttpClientResponse.HttpClientResponse
       : HttpClientResponse.HttpClientResponse | E
   >(
     self: HttpClient.With<E, R>,
@@ -993,7 +999,36 @@ export const retryTransient: {
       readonly while?: Predicate.Predicate<NoInfer<E | ES>>
       readonly schedule?: Schedule.Schedule<B, NoInfer<Input>, ES, R1>
       readonly times?: number
-    } | Schedule.Schedule<B, NoInfer<Input>, ES, R1>
+    }
+  ): HttpClient.With<E | ES, R1 | R>
+  /**
+   * Retries common transient errors, such as rate limiting, timeouts or network issues.
+   *
+   * Use `retryOn` to focus on retrying errors, transient responses, or both.
+   *
+   * Specifying a `while` predicate allows you to consider other errors as
+   * transient, and is ignored in "response-only" mode.
+   *
+   * @since 4.0.0
+   * @category error handling
+   */
+  <B, E, ES = never, R1 = never>(
+    options: Schedule.Schedule<B, NoInfer<HttpClientResponse.HttpClientResponse | E>, ES, R1>
+  ): <R>(self: HttpClient.With<E, R>) => HttpClient.With<E | ES, R1 | R>
+  /**
+   * Retries common transient errors, such as rate limiting, timeouts or network issues.
+   *
+   * Use `retryOn` to focus on retrying errors, transient responses, or both.
+   *
+   * Specifying a `while` predicate allows you to consider other errors as
+   * transient, and is ignored in "response-only" mode.
+   *
+   * @since 4.0.0
+   * @category error handling
+   */
+  <E, R, B, ES = never, R1 = never>(
+    self: HttpClient.With<E, R>,
+    options: Schedule.Schedule<B, NoInfer<HttpClientResponse.HttpClientResponse | E>, ES, R1>
   ): HttpClient.With<E | ES, R1 | R>
 } = dual(
   2,

package/src/unstable/http/HttpEffect.ts

@@ -1,7 +1,7 @@
 /**
  * @since 4.0.0
  */
-import type { Cause } from "../../Cause.ts"
+import type * as Cause from "../../Cause.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
@@ -11,14 +11,14 @@ import * as Layer from "../../Layer.ts"
 import * as Scope from "../../Scope.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
-import * as UndefinedOr from "../../UndefinedOr.ts"
 import * as HttpBody from "./HttpBody.ts"
 import { type HttpMiddleware, tracer } from "./HttpMiddleware.ts"
-import { causeResponse, clientAbortFiberId, HttpServerError, InternalError } from "./HttpServerError.ts"
+import { causeResponse, ClientAbort, HttpServerError, InternalError } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as Response from "./HttpServerResponse.ts"
+import { appendPreResponseHandlerUnsafe, requestPreResponseHandlers } from "./internal/preResponseHandler.ts"
 
 /**
  * @since 4.0.0
@@ -32,12 +32,12 @@ export const toHandled = <E, R, EH, RH>(
   ) => Effect.Effect<unknown, EH, RH>,
   middleware?: HttpMiddleware | undefined
 ): Effect.Effect<void, never, Exclude<R | RH | HttpServerRequest, Scope.Scope>> => {
-  const handleCause = (cause: Cause<E | EH | HttpServerError>) =>
+  const handleCause = (cause: Cause.Cause<E | EH | HttpServerError>) =>
     Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
       const fiber = Fiber.getCurrent()!
       reportCauseUnsafe(fiber, cause)
       const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-      const handler = fiber.getRef(PreResponseHandlers)
+      const handler = requestPreResponseHandlers.get(request)
       const cont = cause.reasons.length === 0 ? Effect.succeed(response) : Effect.failCause(cause)
       if (handler === undefined) {
         ;(request as any)[handledSymbol] = true
@@ -60,7 +60,7 @@ export const toHandled = <E, R, EH, RH>(
     onSuccess: (response) => {
       const fiber = Fiber.getCurrent()!
       const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
-      const handler = fiber.getRef(PreResponseHandlers)
+      const handler = requestPreResponseHandlers.get(request)
       if (handler === undefined) {
         ;(request as any)[handledSymbol] = true
         return Effect.mapEager(handleResponse(request, response), () => response)
@@ -145,10 +145,10 @@ const scopeEjected = Symbol.for("effect/http/HttpEffect/scopeEjected")
 const scoped = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
   Effect.withFiber((fiber) => {
     const scope = Scope.makeUnsafe()
-    const prev = ServiceMap.getOption(fiber.services, Scope.Scope)
+    const prevServices = fiber.services
     fiber.setServices(ServiceMap.add(fiber.services, Scope.Scope, scope))
     return Effect.onExitPrimitive(effect, (exit) => {
-      fiber.setServices(ServiceMap.addOrOmit(fiber.services, Scope.Scope, prev))
+      fiber.setServices(prevServices)
       if (scopeEjected in scope) return undefined
       return Scope.closeUnsafe(scope, exit)
     }, true)
@@ -163,27 +163,13 @@ export type PreResponseHandler = (
   response: HttpServerResponse
 ) => Effect.Effect<HttpServerResponse, HttpServerError>
 
-/**
- * @since 4.0.0
- * @category Pre-response handlers
- */
-export const PreResponseHandlers = ServiceMap.Reference<PreResponseHandler | undefined>(
-  "effect/http/HttpEffect/PreResponseHandlers",
-  { defaultValue: () => undefined }
-)
-
 /**
  * @since 4.0.0
  * @category fiber refs
  */
-export const appendPreResponseHandler = (handler: PreResponseHandler): Effect.Effect<void> =>
-  Effect.withFiber((fiber) => {
-    const next = UndefinedOr.match(fiber.getRef(PreResponseHandlers), {
-      onUndefined: () => handler,
-      onDefined: (prev) => (request, response) =>
-        Effect.flatMap(prev(request, response), (response) => handler(request, response))
-    })
-    fiber.setServices(ServiceMap.add(fiber.services, PreResponseHandlers, next))
+export const appendPreResponseHandler = (handler: PreResponseHandler): Effect.Effect<void, never, HttpServerRequest> =>
+  HttpServerRequest.use((request) => {
+    appendPreResponseHandlerUnsafe(request, handler)
     return Effect.void
   })
 
@@ -196,33 +182,28 @@ export const withPreResponseHandler: {
    * @since 4.0.0
    * @category fiber refs
    */
-  (handler: PreResponseHandler): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
+  (handler: PreResponseHandler): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | HttpServerRequest>
   /**
    * @since 4.0.0
    * @category fiber refs
    */
-  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler): Effect.Effect<A, E, R>
+  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler): Effect.Effect<A, E, R | HttpServerRequest>
 } = dual<
   /**
    * @since 4.0.0
    * @category fiber refs
    */
-  (handler: PreResponseHandler) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  (handler: PreResponseHandler) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R | HttpServerRequest>,
   /**
    * @since 4.0.0
    * @category fiber refs
    */
-  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler) => Effect.Effect<A, E, R>
+  <A, E, R>(self: Effect.Effect<A, E, R>, handler: PreResponseHandler) => Effect.Effect<A, E, R | HttpServerRequest>
 >(2, (self, handler) =>
-  Effect.updateService(
-    self,
-    PreResponseHandlers,
-    UndefinedOr.match({
-      onUndefined: () => handler,
-      onDefined: (prev) => (request, response) =>
-        Effect.flatMap(prev(request, response), (response) => handler(request, response))
-    })
-  ))
+  HttpServerRequest.use((request) => {
+    appendPreResponseHandlerUnsafe(request, handler)
+    return self
+  }))
 
 /**
  * @since 4.0.0
@@ -259,7 +240,7 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
       ;(httpServerRequest as any)[resolveSymbol] = resolve
       const fiber = Effect.runForkWith(ServiceMap.makeUnsafe(contextMap))(httpApp as any)
       request.signal?.addEventListener("abort", () => {
-        fiber.interruptUnsafe(clientAbortFiberId)
+        fiber.interruptUnsafe(undefined, ClientAbort.annotation)
       }, { once: true })
     })
 }

package/src/unstable/http/HttpMiddleware.ts

@@ -12,13 +12,13 @@ import { TracerEnabled } from "../../References.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import { ParentSpan } from "../../Tracer.ts"
 import * as Headers from "./Headers.ts"
-import type { PreResponseHandler } from "./HttpEffect.ts"
 import { causeResponseStripped, exitResponse } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import * as Response from "./HttpServerResponse.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as TraceContext from "./HttpTraceContext.ts"
+import { appendPreResponseHandlerUnsafe } from "./internal/preResponseHandler.ts"
 
 /**
  * @since 4.0.0
@@ -142,10 +142,10 @@ export const tracer: <E, R>(
       parent: TraceContext.fromHeaders(request.headers),
       kind: "server"
     })
-    const prevSpan = ServiceMap.getOption(fiber.services, ParentSpan)
+    const prevServices = fiber.services
     fiber.setServices(ServiceMap.add(fiber.services, ParentSpan, span))
     return Effect.onExitPrimitive(httpApp, (exit) => {
-      fiber.setServices(ServiceMap.addOrOmit(fiber.services, ParentSpan, prevSpan))
+      fiber.setServices(prevServices)
       const endTime = fiber.getRef(Clock).currentTimeNanosUnsafe()
       fiber.currentScheduler.scheduleTask(() => {
         const url = Request.toURL(request)
@@ -338,17 +338,7 @@ export const cors = (options?: {
           headers: headersFromRequestOptions(request)
         }))
       }
-      const prev = fiber.getRef(PreResponseHandlers)
-      const next = prev
-        ? ((req: HttpServerRequest, res: HttpServerResponse) =>
-          Effect.flatMap(prev(req, res), (res) => preResponseHandler(req, res)))
-        : preResponseHandler
-      fiber.setServices(ServiceMap.add(fiber.services, PreResponseHandlers, next))
+      appendPreResponseHandlerUnsafe(request, preResponseHandler)
       return httpApp
     })
 }
-
-const PreResponseHandlers = ServiceMap.Reference<PreResponseHandler | undefined>(
-  "effect/http/HttpEffect/PreResponseHandlers",
-  { defaultValue: () => undefined }
-)

package/src/unstable/http/HttpServerError.ts

@@ -6,7 +6,9 @@ import * as Data from "../../Data.ts"
 import * as Effect from "../../Effect.ts"
 import * as ErrorReporter from "../../ErrorReporter.ts"
 import type * as Exit from "../../Exit.ts"
+import { constUndefined } from "../../Function.ts"
 import { hasProperty } from "../../Predicate.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Request from "./HttpServerRequest.ts"
 import * as Respondable from "./HttpServerRespondable.ts"
 import * as Response from "./HttpServerResponse.ts"
@@ -182,16 +184,25 @@ export class ServeError extends Data.TaggedError("ServeError")<{
   readonly cause: unknown
 }> {}
 
+/**
+ * @since 4.0.0
+ * @category Annotations
+ */
+export class ClientAbort extends ServiceMap.Service<ClientAbort, true>()("effect/http/HttpServerError/ClientAbort") {
+  static annotation = this.serviceMap(true).pipe(
+    ServiceMap.add(Cause.StackTrace, {
+      name: "ClientAbort",
+      stack: constUndefined,
+      parent: undefined
+    })
+  )
+}
+
 const formatRequestMessage = (reason: string, description: string | undefined, info: string) => {
   const prefix = `${reason} (${info})`
   return description ? `${prefix}: ${description}` : prefix
 }
 
-/**
- * @since 4.0.0
- */
-export const clientAbortFiberId = -499
-
 /**
  * @since 4.0.0
  */
@@ -201,37 +212,37 @@ export const causeResponse = <E>(
   let response: Response.HttpServerResponse | undefined
   let effect = succeedInternalServerError
   const failures: Array<Cause.Reason<E>> = []
-  let interrupt: Cause.Interrupt | undefined
+  let interrupts: Array<Cause.Interrupt> = []
   let isClientInterrupt = false
   for (let i = 0; i < cause.reasons.length; i++) {
-    const f = cause.reasons[i]
-    switch (f._tag) {
+    const reason = cause.reasons[i]
+    switch (reason._tag) {
       case "Fail": {
-        effect = Respondable.toResponseOrElse(f.error, internalServerError)
-        failures.push(f)
+        effect = Respondable.toResponseOrElse(reason.error, internalServerError)
+        failures.push(reason)
         break
       }
       case "Die": {
-        if (Response.isHttpServerResponse(f.defect)) {
-          response = f.defect
+        if (Response.isHttpServerResponse(reason.defect)) {
+          response = reason.defect
         } else {
-          effect = Respondable.toResponseOrElseDefect(f.defect, internalServerError)
-          failures.push(f)
+          effect = Respondable.toResponseOrElseDefect(reason.defect, internalServerError)
+          failures.push(reason)
         }
         break
       }
       case "Interrupt": {
-        isClientInterrupt = isClientInterrupt || f.fiberId === clientAbortFiberId
+        isClientInterrupt = reason.annotations.has(ClientAbort.key)
         if (failures.length > 0) break
-        interrupt = f
+        interrupts.push(reason)
         break
       }
     }
   }
   if (response) {
     return Effect.succeed([response, Cause.fromReasons(failures)] as const)
-  } else if (interrupt && failures.length === 0) {
-    failures.push(isClientInterrupt ? Cause.makeInterruptReason(clientAbortFiberId) : interrupt)
+  } else if (interrupts.length > 0 && failures.length === 0) {
+    failures.push(...interrupts)
     effect = isClientInterrupt ? clientAbortError : serverAbortError
   }
   return Effect.mapEager(effect, (response) => {

package/src/unstable/http/internal/preResponseHandler.ts

@@ -0,0 +1,15 @@
+import * as Effect from "../../../Effect.ts"
+import type { PreResponseHandler } from "../HttpEffect.ts"
+import type { HttpServerRequest } from "../HttpServerRequest.ts"
+
+/** @internal */
+export const requestPreResponseHandlers = new WeakMap<HttpServerRequest, PreResponseHandler>()
+
+/** @internal */
+export const appendPreResponseHandlerUnsafe = (request: HttpServerRequest, handler: PreResponseHandler): void => {
+  const prev = requestPreResponseHandlers.get(request)
+  const next: PreResponseHandler = prev ?
+    (request, response) => Effect.flatMap(prev(request, response), (response) => handler(request, response))
+    : handler
+  requestPreResponseHandlers.set(request, next)
+}

package/src/unstable/httpapi/HttpApiBuilder.ts

@@ -356,7 +356,7 @@ export const securitySetCookie = (
   self: HttpApiSecurity.ApiKey,
   value: string | Redacted.Redacted,
   options?: Cookie["options"]
-): Effect.Effect<void> =>
+): Effect.Effect<void, never, HttpServerRequest> =>
   HttpEffect.appendPreResponseHandler((_req, response) =>
     Effect.orDie(
       Response.setCookie(response, self.key, stringOrRedacted(value), {

package/src/unstable/reactivity/Atom.ts

@@ -2070,7 +2070,7 @@ export const searchParam = <S extends Schema.Codec<any, string> = never>(name: s
         window.removeEventListener("pushstate", handleUpdate)
       })
       const value = new URLSearchParams(window.location.search).get(name) || ""
-      return decode ? Exit.findErrorOption(decode(value)) : value as any
+      return decode ? Exit.getSuccess(decode(value)) : value as any
     },
     (ctx, value: any) => {
       if (typeof window === "undefined") {

package/src/unstable/rpc/RpcSchema.ts

@@ -1,9 +1,12 @@
 /**
  * @since 4.0.0
  */
+import * as Cause from "../../Cause.ts"
+import { constUndefined } from "../../Function.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
+import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream_ from "../../Stream.ts"
 
 const StreamSchemaTypeId = "~effect/rpc/RpcSchema/StreamSchema"
@@ -58,3 +61,17 @@ const schema = Schema.declare(Stream_.isStream)
 export function Stream<A extends Schema.Top, E extends Schema.Top>(success: A, error: E): Stream<A, E> {
   return Schema.make(schema.ast, { [StreamSchemaTypeId]: StreamSchemaTypeId, success, error })
 }
+
+/**
+ * @since 4.0.0
+ * @category Cause annotations
+ */
+export class ClientAbort extends ServiceMap.Service<ClientAbort, true>()("effect/rpc/RpcSchema/ClientAbort") {
+  static annotation = this.serviceMap(true).pipe(
+    ServiceMap.add(Cause.StackTrace, {
+      name: "ClientAbort",
+      stack: constUndefined,
+      parent: undefined
+    })
+  )
+}

package/src/unstable/rpc/RpcSerialization.ts

@@ -107,11 +107,7 @@ export const jsonRpc = (options?: {
           return decodeJsonRpcRaw(decoded, batches)
         },
         encode: (response) => {
-          if (Array.isArray(response)) {
-            if (response.length === 0) return undefined
-            return JSON.stringify(response.map(encodeJsonRpcMessage))
-          }
-          const encoded = encodeJsonRpcRaw(response as any, batches)
+          const encoded = encodeJsonRpcResponse(response as any, batches)
           return encoded && JSON.stringify(encoded)
         }
       }
@@ -146,10 +142,7 @@ export const ndJsonRpc = (options?: {
           return messages
         },
         encode: (response) => {
-          if (Array.isArray(response)) {
-            return parser.encode(response.map(encodeJsonRpcMessage))
-          }
-          const encoded = encodeJsonRpcRaw(response as any, batches)
+          const encoded = encodeJsonRpcResponse(response as any, batches)
           return encoded && parser.encode(encoded)
         }
       })
@@ -171,6 +164,7 @@ function decodeJsonRpcRaw(
     const messages: Array<RpcMessage.FromClientEncoded | RpcMessage.FromServerEncoded> = []
     for (let i = 0; i < decoded.length; i++) {
       const message = decodeJsonRpcMessage(decoded[i])
+      messages.push(message)
       if (message._tag === "Request") {
         batch.size++
         batches.set(message.id, batch)
@@ -263,6 +257,47 @@ function encodeJsonRpcRaw(
   return encodeJsonRpcMessage(response)
 }
 
+function encodeJsonRpcResponse(
+  response:
+    | RpcMessage.FromServerEncoded
+    | RpcMessage.FromClientEncoded
+    | Array<RpcMessage.FromServerEncoded | RpcMessage.FromClientEncoded>,
+  batches: Map<string, {
+    readonly size: number
+    readonly responses: Map<string, RpcMessage.FromServerEncoded>
+  }>
+) {
+  if (Array.isArray(response) === false) {
+    return encodeJsonRpcRaw(response, batches)
+  }
+  if (response.length === 0) {
+    return undefined
+  }
+  const encoded: Array<JsonRpcMessage | Array<JsonRpcMessage>> = []
+  for (let i = 0; i < response.length; i++) {
+    const current = encodeJsonRpcRaw(response[i], batches)
+    if (current !== undefined) {
+      encoded.push(current)
+    }
+  }
+  if (encoded.length === 0) {
+    return undefined
+  }
+  if (encoded.length === 1) {
+    return encoded[0]
+  }
+  const messages: Array<JsonRpcMessage> = []
+  for (let i = 0; i < encoded.length; i++) {
+    const current = encoded[i]
+    if (Array.isArray(current)) {
+      messages.push(...current)
+    } else {
+      messages.push(current)
+    }
+  }
+  return messages
+}
+
 function encodeJsonRpcMessage(response: RpcMessage.FromServerEncoded | RpcMessage.FromClientEncoded): JsonRpcMessage {
   switch (response._tag) {
     case "Request":

package/src/unstable/rpc/RpcServer.ts

@@ -175,17 +175,16 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
           }
           case "Interrupt": {
             const fiber = client.fibers.get(message.requestId)
-            return fiber
-              ? Effect.forkDetach(
-                Fiber.interruptAs(fiber, fiberIdClientInterrupt),
-                { startImmediately: true }
-              )
-              : options.onFromServer({
-                _tag: "Exit",
-                clientId,
-                requestId: message.requestId,
-                exit: Exit.interrupt()
-              })
+            if (fiber) {
+              fiber.interruptUnsafe(requestFiber.id, RpcSchema.ClientAbort.annotation)
+              return Effect.void
+            }
+            return options.onFromServer({
+              _tag: "Exit",
+              clientId,
+              requestId: message.requestId,
+              exit: Exit.interrupt()
+            })
           }
           case "Eof": {
             client.ended = true
@@ -1282,14 +1281,6 @@ export const layerProtocolWorkerRunner: Layer.Layer<
   WorkerRunner.WorkerRunnerPlatform
 > = Layer.effect(Protocol)(makeProtocolWorkerRunner)
 
-/**
- * Fiber id used to indicate client induced interrupts
- *
- * @since 4.0.0
- * @category Interruption
- */
-export const fiberIdClientInterrupt = -499
-
 // internal
 
 const makeSocketProtocol: Effect.Effect<