@effect/platform 0.64.0 → 0.65.0

package/src/HttpClientRequest.ts

@@ -36,7 +36,7 @@ export type TypeId = typeof TypeId
  * @category models
  */
 export interface HttpClientRequest
-  extends Effect.Effect<HttpClientResponse, HttpClientError, HttpClient.Default | Scope>, Inspectable
+  extends Effect.Effect<HttpClientResponse, HttpClientError, HttpClient.Service | Scope>, Inspectable
 {
   readonly [TypeId]: TypeId
   readonly method: HttpMethod
@@ -301,73 +301,73 @@ export const setBody: {
  * @since 1.0.0
  * @category combinators
  */
-export const uint8ArrayBody: {
+export const bodyUint8Array: {
   (body: Uint8Array, contentType?: string): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, body: Uint8Array, contentType?: string): HttpClientRequest
-} = internal.uint8ArrayBody
+} = internal.bodyUint8Array
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const textBody: {
+export const bodyText: {
   (body: string, contentType?: string): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, body: string, contentType?: string): HttpClientRequest
-} = internal.textBody
+} = internal.bodyText
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const jsonBody: {
+export const bodyJson: {
   (body: unknown): (self: HttpClientRequest) => Effect.Effect<HttpClientRequest, Body.HttpBodyError>
   (self: HttpClientRequest, body: unknown): Effect.Effect<HttpClientRequest, Body.HttpBodyError>
-} = internal.jsonBody
+} = internal.bodyJson
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const unsafeJsonBody: {
+export const bodyUnsafeJson: {
   (body: unknown): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, body: unknown): HttpClientRequest
-} = internal.unsafeJsonBody
+} = internal.bodyUnsafeJson
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const schemaBody: <A, I, R>(
+export const schemaBodyJson: <A, I, R>(
   schema: Schema.Schema<A, I, R>,
   options?: ParseOptions | undefined
 ) => {
   (body: A): (self: HttpClientRequest) => Effect.Effect<HttpClientRequest, Body.HttpBodyError, R>
   (self: HttpClientRequest, body: A): Effect.Effect<HttpClientRequest, Body.HttpBodyError, R>
-} = internal.schemaBody
+} = internal.schemaBodyJson
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const urlParamsBody: {
+export const bodyUrlParams: {
   (input: UrlParams.Input): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, input: UrlParams.Input): HttpClientRequest
-} = internal.urlParamsBody
+} = internal.bodyUrlParams
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const formDataBody: {
+export const bodyFormData: {
   (body: FormData): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, body: FormData): HttpClientRequest
-} = internal.formDataBody
+} = internal.bodyFormData
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const streamBody: {
+export const bodyStream: {
   (
     body: Stream.Stream<Uint8Array, unknown>,
     options?: { readonly contentType?: string | undefined; readonly contentLength?: number | undefined } | undefined
@@ -377,13 +377,13 @@ export const streamBody: {
     body: Stream.Stream<Uint8Array, unknown>,
     options?: { readonly contentType?: string | undefined; readonly contentLength?: number | undefined } | undefined
   ): HttpClientRequest
-} = internal.streamBody
+} = internal.bodyStream
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const fileBody: {
+export const bodyFile: {
   (
     path: string,
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
@@ -393,13 +393,13 @@ export const fileBody: {
     path: string,
     options?: FileSystem.StreamOptions & { readonly contentType?: string }
   ): Effect.Effect<HttpClientRequest, PlatformError.PlatformError, FileSystem.FileSystem>
-} = internal.fileBody
+} = internal.bodyFile
 
 /**
  * @since 1.0.0
  * @category combinators
  */
-export const fileWebBody: {
+export const bodyFileWeb: {
   (file: Body.HttpBody.FileLike): (self: HttpClientRequest) => HttpClientRequest
   (self: HttpClientRequest, file: Body.HttpBody.FileLike): HttpClientRequest
-} = internal.fileWebBody
+} = internal.bodyFileWeb

package/src/HttpClientResponse.ts

@@ -7,12 +7,12 @@ import type * as Schema from "@effect/schema/Schema"
 import type * as Effect from "effect/Effect"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
+import type { Unify } from "effect/Unify"
 import type * as Cookies from "./Cookies.js"
 import type * as Error from "./HttpClientError.js"
 import type * as ClientRequest from "./HttpClientRequest.js"
 import type * as IncomingMessage from "./HttpIncomingMessage.js"
 import * as internal from "./internal/httpClientResponse.js"
-import type * as UrlParams from "./UrlParams.js"
 
 export {
   /**
@@ -20,11 +20,6 @@ export {
    * @category schema
    */
   schemaBodyJson,
-  /**
-   * @since 1.0.0
-   * @category schema
-   */
-  schemaBodyJsonScoped,
   /**
    * @since 1.0.0
    * @category schema
@@ -34,17 +29,7 @@ export {
    * @since 1.0.0
    * @category schema
    */
-  schemaBodyUrlParamsScoped,
-  /**
-   * @since 1.0.0
-   * @category schema
-   */
-  schemaHeaders,
-  /**
-   * @since 1.0.0
-   * @category schema
-   */
-  schemaHeadersScoped
+  schemaHeaders
 } from "./HttpIncomingMessage.js"
 
 /**
@@ -111,41 +96,6 @@ export const schemaNoBody: <
   options?: ParseOptions | undefined
 ) => (self: HttpClientResponse) => Effect.Effect<A, ParseResult.ParseError, R> = internal.schemaNoBody
 
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const arrayBuffer: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<ArrayBuffer, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.arrayBuffer
-
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const formData: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<FormData, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.formData
-
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const json: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<unknown, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.json
-
-const void_: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<void, E, Exclude<R, Scope.Scope>> = internal.void_
-export {
-  /**
-   * @since 1.0.0
-   * @category accessors
-   */
-  void_ as void
-}
-
 /**
  * @since 1.0.0
  * @category accessors
@@ -154,64 +104,6 @@ export const stream: <E, R>(
   effect: Effect.Effect<HttpClientResponse, E, R>
 ) => Stream.Stream<Uint8Array, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.stream
 
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const text: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<string, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.text
-
-/**
- * @since 1.0.0
- * @category accessors
- */
-export const urlParamsBody: <E, R>(
-  effect: Effect.Effect<HttpClientResponse, E, R>
-) => Effect.Effect<UrlParams.UrlParams, Error.ResponseError | E, Exclude<R, Scope.Scope>> = internal.urlParamsBody
-
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaJsonScoped: <
-  R,
-  I extends {
-    readonly status?: number | undefined
-    readonly headers?: Readonly<Record<string, string>> | undefined
-    readonly body?: unknown
-  },
-  A
->(
-  schema: Schema.Schema<A, I, R>,
-  options?: ParseOptions | undefined
-) => <E, R2>(
-  effect: Effect.Effect<HttpClientResponse, E, R2>
-) => Effect.Effect<
-  A,
-  E | Error.ResponseError | ParseResult.ParseError,
-  Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>
-> = internal.schemaJsonScoped
-
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaNoBodyScoped: <
-  R,
-  I extends {
-    readonly status?: number | undefined
-    readonly headers?: Readonly<Record<string, string>> | undefined
-  },
-  A
->(
-  schema: Schema.Schema<A, I, R>,
-  options?: ParseOptions | undefined
-) => <E, R2>(
-  effect: Effect.Effect<HttpClientResponse, E, R2>
-) => Effect.Effect<A, E | ParseResult.ParseError, Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>> =
-  internal.schemaNoBodyScoped
-
 /**
  * @since 1.0.0
  * @category pattern matching
@@ -226,7 +118,7 @@ export const matchStatus: {
       readonly "5xx"?: (_: HttpClientResponse) => any
       readonly orElse: (_: HttpClientResponse) => any
     }
-  >(cases: Cases): (self: HttpClientResponse) => Cases[keyof Cases] extends (_: any) => infer R ? R : never
+  >(cases: Cases): (self: HttpClientResponse) => Cases[keyof Cases] extends (_: any) => infer R ? Unify<R> : never
   <
     const Cases extends {
       readonly [status: number]: (_: HttpClientResponse) => any
@@ -236,55 +128,5 @@ export const matchStatus: {
       readonly "5xx"?: (_: HttpClientResponse) => any
       readonly orElse: (_: HttpClientResponse) => any
     }
-  >(self: HttpClientResponse, cases: Cases): Cases[keyof Cases] extends (_: any) => infer R ? R : never
+  >(self: HttpClientResponse, cases: Cases): Cases[keyof Cases] extends (_: any) => infer R ? Unify<R> : never
 } = internal.matchStatus
-
-/**
- * @since 1.0.0
- * @category pattern matching
- */
-export const matchStatusScoped: {
-  <
-    const Cases extends {
-      readonly [status: number]: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "2xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "3xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "4xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "5xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly orElse: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-    }
-  >(
-    cases: Cases
-  ): <E, R>(
-    self: Effect.Effect<HttpClientResponse, E, R>
-  ) => Effect.Effect<
-    Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _A : never,
-    E | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _E : never),
-    Exclude<
-      R | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _R : never),
-      Scope.Scope
-    >
-  >
-  <
-    E,
-    R,
-    const Cases extends {
-      readonly [status: number]: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "2xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "3xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "4xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly "5xx"?: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-      readonly orElse: (_: HttpClientResponse) => Effect.Effect<any, any, any>
-    }
-  >(
-    self: Effect.Effect<HttpClientResponse, E, R>,
-    cases: Cases
-  ): Effect.Effect<
-    Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _A : never,
-    E | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _E : never),
-    Exclude<
-      R | (Cases[keyof Cases] extends (_: any) => Effect.Effect<infer _A, infer _E, infer _R> ? _R : never),
-      Scope.Scope
-    >
-  >
-} = internal.matchStatusScoped

package/src/HttpIncomingMessage.ts

@@ -10,7 +10,6 @@ import { dual } from "effect/Function"
 import * as Global from "effect/GlobalValue"
 import type { Inspectable } from "effect/Inspectable"
 import * as Option from "effect/Option"
-import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
 import * as FileSystem from "./FileSystem.js"
 import type * as Headers from "./Headers.js"
@@ -53,18 +52,6 @@ export const schemaBodyJson = <A, I, R>(schema: Schema.Schema<A, I, R>, options?
     Effect.flatMap(self.json, parse)
 }
 
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaBodyJsonScoped = <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) => {
-  const decode = schemaBodyJson(schema, options)
-  return <E, E2, R2>(
-    effect: Effect.Effect<HttpIncomingMessage<E>, E2, R2>
-  ): Effect.Effect<A, ParseResult.ParseError | E | E2, Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>> =>
-    Effect.scoped(Effect.flatMap(effect, decode))
-}
-
 /**
  * @since 1.0.0
  * @category schema
@@ -78,21 +65,6 @@ export const schemaBodyUrlParams = <A, I extends Readonly<Record<string, string
     Effect.flatMap(self.urlParamsBody, (_) => parse(Object.fromEntries(_)))
 }
 
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaBodyUrlParamsScoped = <A, I extends Readonly<Record<string, string | undefined>>, R>(
-  schema: Schema.Schema<A, I, R>,
-  options?: ParseOptions | undefined
-) => {
-  const decode = schemaBodyUrlParams(schema, options)
-  return <E, E2, R2>(
-    effect: Effect.Effect<HttpIncomingMessage<E>, E2, R2>
-  ): Effect.Effect<A, ParseResult.ParseError | E | E2, Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>> =>
-    Effect.scoped(Effect.flatMap(effect, decode))
-}
-
 /**
  * @since 1.0.0
  * @category schema
@@ -105,21 +77,6 @@ export const schemaHeaders = <A, I extends Readonly<Record<string, string | unde
   return <E>(self: HttpIncomingMessage<E>): Effect.Effect<A, ParseResult.ParseError, R> => parse(self.headers)
 }
 
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schemaHeadersScoped = <A, I extends Readonly<Record<string, string | undefined>>, R>(
-  schema: Schema.Schema<A, I, R>,
-  options?: ParseOptions | undefined
-) => {
-  const decode = schemaHeaders(schema, options)
-  return <E, E2, R2>(
-    effect: Effect.Effect<HttpIncomingMessage<E>, E2, R2>
-  ): Effect.Effect<A, ParseResult.ParseError | E2, Exclude<R, Scope.Scope> | Exclude<R2, Scope.Scope>> =>
-    Effect.scoped(Effect.flatMap(effect, decode))
-}
-
 /**
  * @since 1.0.0
  * @category fiber refs

package/src/HttpServer.ts

@@ -201,5 +201,5 @@ export const withLogAddress: <A, E, R>(layer: Layer.Layer<A, E, R>) => Layer.Lay
  * @since 1.0.0
  * @category layers
  */
-export const layerTestClient: Layer.Layer<Client.HttpClient.Default, never, Client.HttpClient.Default | HttpServer> =
+export const layerTestClient: Layer.Layer<Client.HttpClient.Service, never, Client.HttpClient.Service | HttpServer> =
   internal.layerTestClient

package/src/Runtime.ts

@@ -63,7 +63,7 @@ const addPrettyLogger = (refs: FiberRefs.FiberRefs, fiberId: FiberId.Runtime) =>
     fiberRef: FiberRef.currentLoggers,
     value: loggers.pipe(
       HashSet.remove(Logger.defaultLogger),
-      HashSet.add(Logger.prettyLogger())
+      HashSet.add(Logger.prettyLoggerDefault)
     )
   })
 }

package/src/Socket.ts

@@ -2,7 +2,7 @@
  * @since 1.0.0
  */
 import * as Channel from "effect/Channel"
-import * as Chunk from "effect/Chunk"
+import type * as Chunk from "effect/Chunk"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
 import type { DurationInput } from "effect/Duration"
@@ -14,6 +14,7 @@ import * as FiberSet from "effect/FiberSet"
 import { dual } from "effect/Function"
 import { globalValue } from "effect/GlobalValue"
 import * as Layer from "effect/Layer"
+import * as Mailbox from "effect/Mailbox"
 import * as Predicate from "effect/Predicate"
 import * as Queue from "effect/Queue"
 import * as Scope from "effect/Scope"
@@ -52,11 +53,11 @@ export const Socket: Context.Tag<Socket, Socket> = Context.GenericTag<Socket>(
  */
 export interface Socket {
   readonly [TypeId]: TypeId
-  readonly run: <_, E, R>(
-    handler: (_: Uint8Array) => Effect.Effect<_, E, R>
+  readonly run: <_, E = never, R = never>(
+    handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void
   ) => Effect.Effect<void, SocketError | E, R>
-  readonly runRaw: <_, E, R>(
-    handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>
+  readonly runRaw: <_, E = never, R = never>(
+    handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void
   ) => Effect.Effect<void, SocketError | E, R>
   readonly writer: Effect.Effect<
     (chunk: Uint8Array | string | CloseEvent) => Effect.Effect<boolean>,
@@ -190,27 +191,25 @@ export const toChannelMap = <IE, A>(
 > =>
   Effect.scope.pipe(
     Effect.bindTo("scope"),
-    Effect.let("state", () => ({ finished: false, buffer: [] as Array<A> })),
-    Effect.bind("semaphore", () => Effect.makeSemaphore(0)),
+    Effect.bind("mailbox", () => Mailbox.make<A, SocketError | IE>()),
     Effect.bind("writeScope", ({ scope }) => Scope.fork(scope, ExecutionStrategy.sequential)),
     Effect.bind("write", ({ writeScope }) => Scope.extend(self.writer, writeScope)),
-    Effect.bind("deferred", () => Deferred.make<void, SocketError | IE>()),
     Effect.let(
       "input",
       (
-        { deferred, write, writeScope }
+        { mailbox, write, writeScope }
       ): AsyncProducer.AsyncInputProducer<IE, Chunk.Chunk<Uint8Array | string | CloseEvent>, unknown> => ({
         awaitRead: () => Effect.void,
         emit(chunk) {
           return Effect.catchAllCause(
             Effect.forEach(chunk, write, { discard: true }),
-            (cause) => Deferred.failCause(deferred, cause)
+            (cause) => mailbox.failCause(cause)
           )
         },
         error(error) {
           return Effect.zipRight(
             Scope.close(writeScope, Exit.void),
-            Deferred.failCause(deferred, error)
+            mailbox.failCause(error)
           )
         },
         done() {
@@ -218,35 +217,16 @@ export const toChannelMap = <IE, A>(
         }
       })
     ),
-    Effect.tap(({ deferred, scope, semaphore, state }) =>
+    Effect.tap(({ mailbox, scope }) =>
       self.runRaw((data) => {
-        state.buffer.push(f(data))
-        return semaphore.release(1)
+        mailbox.unsafeOffer(f(data))
       }).pipe(
-        Effect.intoDeferred(deferred),
-        Effect.raceFirst(Deferred.await(deferred)),
-        Effect.ensuring(Effect.suspend(() => {
-          state.finished = true
-          return semaphore.release(1)
-        })),
+        Mailbox.into(mailbox),
         Effect.forkIn(scope),
         Effect.interruptible
       )
     ),
-    Effect.map(({ deferred, input, semaphore, state }) => {
-      const loop: Channel.Channel<Chunk.Chunk<A>, unknown, SocketError | IE, unknown, void, unknown> = Channel.flatMap(
-        semaphore.take(1),
-        (_) => {
-          if (state.buffer.length === 0) {
-            return state.finished ? Deferred.await(deferred) : loop
-          }
-          const chunk = Chunk.unsafeFromArray(state.buffer)
-          state.buffer = []
-          return Channel.zipRight(Channel.write(chunk), state.finished ? Deferred.await(deferred) : loop)
-        }
-      )
-      return Channel.embedInput(loop, input)
-    }),
+    Effect.map(({ input, mailbox }) => Channel.embedInput(Mailbox.toChannel(mailbox), input)),
     Channel.unwrapScoped
   )
 
@@ -395,14 +375,7 @@ export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
       (typeof url === "string" ? Effect.succeed(url) : url).pipe(
         Effect.flatMap((url) => Effect.map(WebSocketConstructor, (f) => f(url)))
       ),
-      (ws) =>
-        Effect.sync(() => {
-          ws.onclose = null
-          ws.onerror = null
-          ws.onmessage = null
-          ws.onopen = null
-          return ws.close()
-        })
+      (ws) => Effect.sync(() => ws.close())
     ),
     options
   )
@@ -424,7 +397,7 @@ export const fromWebSocket = <R>(
       (sendQueue) => {
         const acquireContext = fiber.getFiberRef(FiberRef.currentContext) as Context.Context<R>
         const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
-        const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>) =>
+        const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void) =>
           acquire.pipe(
             Effect.bindTo("ws"),
             Effect.bind("fiberSet", () => FiberSet.make<any, E | SocketError>()),
@@ -433,16 +406,29 @@ export const fromWebSocket = <R>(
             Effect.tap(({ fiberSet, run, ws }) => {
               let open = false
 
-              ws.onmessage = (event) => {
-                run(handler(
+              function onMessage(event: MessageEvent) {
+                const result = handler(
                   typeof event.data === "string"
                     ? event.data
                     : event.data instanceof Uint8Array
                     ? event.data
                     : new Uint8Array(event.data)
-                ))
+                )
+                if (Effect.isEffect(result)) {
+                  run(result)
+                }
               }
-              ws.onclose = (event) => {
+              function onError(cause: Event) {
+                ws.removeEventListener("message", onMessage)
+                ws.removeEventListener("close", onClose)
+                Deferred.unsafeDone(
+                  fiberSet.deferred,
+                  Effect.fail(new SocketGenericError({ reason: open ? "Read" : "Open", cause }))
+                )
+              }
+              function onClose(event: globalThis.CloseEvent) {
+                ws.removeEventListener("message", onMessage)
+                ws.removeEventListener("error", onError)
                 Deferred.unsafeDone(
                   fiberSet.deferred,
                   Effect.fail(
@@ -454,19 +440,17 @@ export const fromWebSocket = <R>(
                   )
                 )
               }
-              ws.onerror = (cause) => {
-                Deferred.unsafeDone(
-                  fiberSet.deferred,
-                  Effect.fail(new SocketGenericError({ reason: open ? "Read" : "Open", cause }))
-                )
-              }
+
+              ws.addEventListener("close", onClose, { once: true })
+              ws.addEventListener("error", onError, { once: true })
+              ws.addEventListener("message", onMessage)
 
               if (ws.readyState !== 1) {
                 const openDeferred = Deferred.unsafeMake<void>(fiber.id())
-                ws.onopen = () => {
+                ws.addEventListener("open", () => {
                   open = true
                   Deferred.unsafeDone(openDeferred, Effect.void)
-                }
+                }, { once: true })
                 return Deferred.await(openDeferred).pipe(
                   Effect.timeoutFail({
                     duration: options?.openTimeout ?? 10000,
@@ -514,7 +498,7 @@ export const fromWebSocket = <R>(
           )
 
         const encoder = new TextEncoder()
-        const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R>) =>
+        const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void) =>
           runRaw((data) =>
             typeof data === "string"
               ? handler(encoder.encode(data))
@@ -600,7 +584,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
       (sendQueue) => {
         const acquireContext = fiber.getFiberRef(FiberRef.currentContext) as Context.Context<R>
         const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
-        const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R>) =>
+        const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void) =>
           acquire.pipe(
             Effect.bindTo("stream"),
             Effect.bind("reader", ({ stream }) =>
@@ -681,7 +665,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
           )
 
         const encoder = new TextEncoder()
-        const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R>) =>
+        const run = <_, E, R>(handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void) =>
           runRaw((data) =>
             typeof data === "string"
               ? handler(encoder.encode(data))

package/src/index.ts

@@ -28,6 +28,11 @@ export * as Error from "./Error.js"
  */
 export * as Etag from "./Etag.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as FetchHttpClient from "./FetchHttpClient.js"
+
 /**
  * @since 1.0.0
  */

package/src/internal/command.ts

@@ -241,13 +241,14 @@ export const start = (
 export const stream = (
   command: Command.Command
 ): Stream.Stream<Uint8Array, PlatformError, CommandExecutor.CommandExecutor> =>
-  Stream.flatMap(commandExecutor.CommandExecutor, (process) => process.stream(command))
+  Stream.flatMap(commandExecutor.CommandExecutor, (executor) => executor.stream(command))
 
 /** @internal */
 export const streamLines = (
-  command: Command.Command
+  command: Command.Command,
+  encoding?: string
 ): Stream.Stream<string, PlatformError, CommandExecutor.CommandExecutor> =>
-  Stream.flatMap(commandExecutor.CommandExecutor, (process) => process.streamLines(command))
+  Stream.flatMap(commandExecutor.CommandExecutor, (executor) => executor.streamLines(command, encoding))
 
 /** @internal */
 export const string = dual<