effect 4.0.0-rc.112 → 4.0.0-rc.113

package/src/unstable/socket/Socket.ts

@@ -1,31 +1,31 @@
 /**
  * Models bidirectional socket connections in Effect.
  *
- * The `Socket` service runs handlers for binary, string, or raw frames and
- * provides a scoped writer for outgoing bytes, text, or close events. This
- * module also includes socket errors, channel adapters, WebSocket layers, and
- * transform-stream-backed sockets.
+ * A `Socket` exposes a pull-based `reader` and a scoped `writer`. Acquiring
+ * the reader dials the connection and returns an `Effect` that yields batches
+ * of incoming frames with end-to-end backpressure: nothing is read from the
+ * transport until the consumer pulls. Every termination, including clean
+ * closes, surfaces as a `SocketError`, so reconnecting is a plain
+ * `Effect.retry` around the scoped consume loop.
  *
  * @since 4.0.0
  */
-import type { NonEmptyReadonlyArray } from "../../Array.ts"
+import type { NonEmptyArray, NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
 import * as Context from "../../Context.ts"
-import * as Deferred from "../../Deferred.ts"
 import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
-import * as FiberSet from "../../FiberSet.ts"
 import { constVoid, dual, flow } from "../../Function.ts"
 import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Pull from "../../Pull.ts"
-import * as Queue from "../../Queue.ts"
-import * as Result from "../../Result.ts"
+import type * as Redacted from "../../Redacted.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
+import * as Stream from "../../Stream.ts"
 
 /**
  * Runtime type identifier attached to `Socket` services.
@@ -57,96 +57,202 @@ export const isSocket = (u: unknown): u is Socket => Predicate.hasProperty(u, Ty
 export const Socket: Context.Service<Socket, Socket> = Context.Service<Socket>("effect/socket/Socket")
 
 /**
- * Effect-based socket abstraction for running string or binary read handlers
- * and obtaining a scoped writer for outgoing frames and close events.
+ * Effect-based socket abstraction exposing a pull-based read side and a
+ * scoped writer.
+ *
+ * **Details**
+ *
+ * Acquiring `reader` establishes the connection; the scope of the acquisition
+ * owns the connection lifecycle. Its `pull` yields non-empty batches of incoming
+ * frames and never completes via `Cause.Done`: every termination, clean close
+ * included, fails with a `SocketError` wrapping the close reason. Code placed
+ * between the acquisition and the first pull runs exactly once per
+ * (re)connection, which makes handshakes plain code placement.
+ *
+ * Closing the acquisition scope must fail a pull that is currently suspended,
+ * rather than leaving it blocked. Consumers such as `toChannel` rely on this
+ * to shut a connection down without racing every pull against a separate
+ * failure signal.
+ *
+ * The writer is detached from any single connection: acquiring it cannot
+ * fail, and writes made while disconnected suspend until the next connection
+ * is established. Releasing the writer scope half-closes the write side
+ * where the transport supports it.
+ *
+ * **Example** (Consuming with automatic reconnect)
+ *
+ * ```ts skip-type-checking
+ * Effect.gen(function*() {
+ *   const { pull } = yield* socket.reader
+ *   while (true) {
+ *     yield* handle(yield* pull)
+ *   }
+ * }).pipe(
+ *   Effect.scoped,
+ *   Effect.retry({ schedule: Schedule.exponential(200) })
+ * )
+ * ```
  *
  * @category models
  * @since 4.0.0
  */
 export interface Socket {
   readonly [TypeId]: typeof TypeId
-  readonly run: <_, E = never, R = never>(
-    handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void,
-    options?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }
-  ) => Effect.Effect<void, SocketError | E, R>
-  readonly runString: <_, E = never, R = never>(
-    handler: (_: string) => Effect.Effect<_, E, R> | void,
-    options?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }
-  ) => Effect.Effect<void, SocketError | E, R>
-  readonly runRaw: <_, E = never, R = never>(
-    handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void,
-    options?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }
-  ) => Effect.Effect<void, SocketError | E, R>
-  readonly writer: Effect.Effect<
-    (chunk: Uint8Array | string | CloseEvent) => Effect.Effect<void, SocketError>,
-    never,
-    Scope.Scope
-  >
+  readonly reader: Effect.Effect<Reader, SocketError, Scope.Scope>
+  readonly writer: Effect.Effect<Writer, never, Scope.Scope>
+}
+
+/**
+ * The read side of a live `Socket` connection.
+ *
+ * **Details**
+ *
+ * `pull` reads the next non-empty batch. `upgrade` wraps this connection with
+ * TLS when the transport supports it. Unsupported readers fail with a
+ * `SocketUpgradeError`. The upgrade also fails with `SocketUpgradeError` when
+ * the selected TLS role requires an identity but `key` and `cert` are not both
+ * provided. Calling `upgrade()` without an options object uses the adapter's
+ * client defaults.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Reader<A extends Uint8Array | string = Uint8Array | string> {
+  readonly pull: Effect.Effect<NonEmptyReadonlyArray<A>, SocketError>
+  readonly upgrade: (options?: TlsUpgradeOptions) => Effect.Effect<void, SocketError>
+}
+
+/**
+ * The write side of a `Socket`.
+ *
+ * **Details**
+ *
+ * `write` sends a single frame or a `CloseEvent`; `writeAll` sends a batch of
+ * frames, allowing transports to coalesce them into a single flush. Both
+ * apply the transport's native backpressure before succeeding.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Writer {
+  readonly write: (chunk: Uint8Array | string | CloseEvent) => Effect.Effect<void, SocketError>
+  readonly writeAll: (chunks: NonEmptyReadonlyArray<Uint8Array | string>) => Effect.Effect<void, SocketError>
+}
+
+/**
+ * TLS credentials and handshake settings used to upgrade a live socket.
+ *
+ * **Details**
+ *
+ * `key` and `cert` are optional for client upgrades that do not present a
+ * client certificate. Server upgrades require both, and providing only one is
+ * invalid. Missing or incomplete credentials fail the upgrade with a
+ * `SocketUpgradeError` when the adapter needs an identity.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface TlsUpgradeOptions {
+  readonly key?:
+    | Redacted.Redacted<string | Uint8Array>
+    | ReadonlyArray<Redacted.Redacted<string | Uint8Array>>
+    | undefined
+  readonly cert?: string | Uint8Array | ReadonlyArray<string | Uint8Array> | undefined
+  readonly ca?: string | Uint8Array | ReadonlyArray<string | Uint8Array> | undefined
+  readonly passphrase?: Redacted.Redacted<string> | undefined
+  readonly alpnProtocols?: ReadonlyArray<string> | undefined
+  readonly requestCert?: boolean | undefined
+  readonly rejectUnauthorized?: boolean | undefined
 }
 
 /**
- * Constructs a `Socket` from a raw read loop and scoped writer, deriving binary
- * and string read loops when they are not provided.
+ * Constructs a `Socket` from a reader acquisition and a scoped writer.
+ *
+ * **Details**
+ *
+ * The reader must fail a suspended pull when its acquisition scope closes; see
+ * `Socket` for why. A reader that leaves a pull blocked forever will hang any
+ * consumer that shuts the socket down by closing that scope.
  *
  * @category constructors
  * @since 4.0.0
  */
 export const make = (options: {
-  readonly runRaw: <_, E, R>(
-    handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void,
-    options?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }
-  ) => Effect.Effect<void, SocketError | E, R>
-  readonly run?: <_, E, R>(
-    handler: (_: Uint8Array) => Effect.Effect<_, E, R> | void,
-    options?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }
-  ) => Effect.Effect<void, SocketError | E, R>
-  readonly runString?: <_, E, R>(
-    handler: (_: string) => Effect.Effect<_, E, R> | void,
-    options?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }
-  ) => Effect.Effect<void, SocketError | E, R>
-  readonly writer: Effect.Effect<
-    (chunk: Uint8Array | string | CloseEvent) => Effect.Effect<void, SocketError>,
-    never,
-    Scope.Scope
-  >
+  readonly reader: Socket["reader"]
+  readonly writer: Socket["writer"]
 }): Socket =>
   Socket.of({
     [TypeId]: TypeId,
-    runRaw: options.runRaw,
-    run: options.run ?? ((handler, opts) =>
-      options.runRaw((data) =>
-        typeof data === "string"
-          ? handler(encoder.encode(data))
-          : data instanceof Uint8Array
-          ? handler(data)
-          : handler(new Uint8Array(data)), opts)),
-    runString: options.runString ??
-      (options.run ?
-        (handler, opts) => options.run!((data) => handler(decoder.decode(data)), opts) :
-        (handler, opts) =>
-          options.runRaw((data) =>
-            typeof data === "string"
-              ? handler(data)
-              : data instanceof Uint8Array
-              ? handler(decoder.decode(data))
-              : handler(decoder.decode(new Uint8Array(data))), opts)),
+    reader: options.reader,
     writer: options.writer
   })
 
 const encoder = new TextEncoder()
-const decoder = new TextDecoder()
+
+/**
+ * Acquires the socket's binary `pull`, encoding any string frames as UTF-8
+ * bytes.
+ *
+ * **Details**
+ *
+ * When a pulled batch contains no string frames it is returned as-is, so
+ * transports that only emit bytes (TCP) pay no per-chunk cost.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const readerBytes = (
+  self: Socket
+): Effect.Effect<
+  Effect.Effect<NonEmptyReadonlyArray<Uint8Array>, SocketError>,
+  SocketError,
+  Scope.Scope
+> =>
+  Effect.map(self.reader, ({ pull }) =>
+    Effect.map(pull, (chunk) => {
+      for (let i = 0; i < chunk.length; i++) {
+        if (typeof chunk[i] === "string") {
+          const out = new Array<Uint8Array>(chunk.length) as NonEmptyArray<Uint8Array>
+          for (let j = 0; j < chunk.length; j++) {
+            const item = chunk[j]
+            out[j] = typeof item === "string" ? encoder.encode(item) : item
+          }
+          return out
+        }
+      }
+      return chunk as NonEmptyReadonlyArray<Uint8Array>
+    }))
+
+/**
+ * Acquires the socket's string `pull`, decoding binary frames with the optional
+ * text encoding.
+ *
+ * **Details**
+ *
+ * The `TextDecoder` is created once per acquisition.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const readerString = (
+  self: Socket,
+  encoding?: string | undefined
+): Effect.Effect<
+  Effect.Effect<NonEmptyReadonlyArray<string>, SocketError>,
+  SocketError,
+  Scope.Scope
+> =>
+  Effect.map(self.reader, ({ pull }) => {
+    const decoder = new TextDecoder(encoding)
+    return Effect.map(pull, (chunk) => {
+      const out = new Array<string>(chunk.length)
+      for (let i = 0; i < chunk.length; i++) {
+        const item = chunk[i]
+        out[i] = typeof item === "string" ? item : decoder.decode(item)
+      }
+      return out as unknown as NonEmptyReadonlyArray<string>
+    })
+  })
 
 const CloseEventTypeId = "~effect/socket/Socket/CloseEvent"
 
@@ -275,30 +381,51 @@ export class SocketOpenError extends Schema.Error<SocketOpenError>("effect/socke
 }
 
 /**
- * Typed error for a socket close event, carrying the close code and optional
- * close reason.
+ * Typed error for an unsupported or failed in-place TLS upgrade.
  *
  * @category errors
  * @since 4.0.0
  */
-export class SocketCloseError extends Schema.Error<SocketCloseError>("effect/socket/Socket/SocketCloseError")({
-  _tag: Schema.tag("SocketCloseError"),
-  code: Schema.Int,
-  closeReason: Schema.optional(Schema.String)
+export class SocketUpgradeError extends Schema.Error<SocketUpgradeError>(
+  "effect/socket/Socket/SocketUpgradeError"
+)({
+  _tag: Schema.tag("SocketUpgradeError"),
+  cause: Schema.optional(Schema.Defect())
 }) {
   /**
-   * Separates clean socket close errors from errors that should remain failures.
+   * An upgrade implementation for transports that cannot wrap the connection
+   * with TLS.
    *
    * @since 4.0.0
    */
-  static filterClean(isClean: (code: number) => boolean): <E>(u: E) => Result.Result<SocketCloseError, E> {
-    return function<E>(u: E) {
-      return SocketError.is(u) && u.reason._tag === "SocketCloseError" && isClean(u.reason.code)
-        ? Result.succeed(u.reason)
-        : Result.fail(u)
-    }
+  static readonly unsupported: Reader["upgrade"] = () =>
+    Effect.fail(new SocketError({ reason: new SocketUpgradeError({}) }))
+
+  override get message() {
+    return this.cause === undefined
+      ? `Socket does not support TLS upgrade`
+      : `An error occurred during TLS upgrade`
   }
+}
 
+/**
+ * Typed error for a socket close, carrying the close code and optional close
+ * reason.
+ *
+ * **Details**
+ *
+ * Sockets never classify closes: any close, whatever the code, fails the
+ * reader with a `SocketError` wrapping this reason. Consumers that treat a
+ * close as normal catch it.
+ *
+ * @category errors
+ * @since 4.0.0
+ */
+export class SocketCloseError extends Schema.Error<SocketCloseError>("effect/socket/Socket/SocketCloseError")({
+  _tag: Schema.tag("SocketCloseError"),
+  code: Schema.Int,
+  closeReason: Schema.optional(Schema.String)
+}) {
   override get message() {
     if (this.closeReason) {
       return `${this.code}: ${this.closeReason}`
@@ -317,11 +444,12 @@ export const SocketErrorReason = Schema.Union([
   SocketReadError,
   SocketWriteError,
   SocketOpenError,
+  SocketUpgradeError,
   SocketCloseError
 ])
 
 /**
- * Union of socket-specific read, write, open, and close error reasons.
+ * Union of socket-specific read, write, open, upgrade, and close error reasons.
  *
  * @category errors
  * @since 4.0.0
@@ -330,11 +458,12 @@ export type SocketErrorReason =
   | SocketReadError
   | SocketWriteError
   | SocketOpenError
+  | SocketUpgradeError
   | SocketCloseError
 
 /**
- * Tagged error that wraps socket read, write, open, and close failures while
- * preserving the underlying reason.
+ * Tagged error that wraps socket read, write, open, upgrade, and close failures
+ * while preserving the underlying reason.
  *
  * @category errors
  * @since 4.0.0
@@ -345,7 +474,7 @@ export class SocketError extends Schema.TaggedError<SocketError>(SocketErrorType
 }) {
   // @effect-diagnostics-next-line overriddenSchemaConstructor:off
   constructor(props: {
-    readonly reason: SocketReadError | SocketWriteError | SocketOpenError | SocketCloseError
+    readonly reason: SocketReadError | SocketWriteError | SocketOpenError | SocketUpgradeError | SocketCloseError
   }) {
     if ("cause" in props.reason) {
       super({
@@ -376,16 +505,32 @@ export class SocketError extends Schema.TaggedError<SocketError>(SocketErrorType
   override readonly message = this.reason.message
 }
 
-/**
- * Converts a `Socket` into a bidirectional `Channel`, mapping incoming string
- * or binary frames and writing outgoing frame batches to the socket.
- *
- * @category combinators
- * @since 4.0.0
- */
-export const toChannelMap = <IE, A>(
+const closeError = (code: number, closeReason?: string | undefined) =>
+  new SocketError({ reason: new SocketCloseError({ code, closeReason }) })
+
+const writeChunk = (
+  writer: Writer,
+  chunk: NonEmptyReadonlyArray<Uint8Array | string | CloseEvent>
+): Effect.Effect<void, SocketError> => {
+  for (let i = 0; i < chunk.length; i++) {
+    if (isCloseEvent(chunk[i])) {
+      return Effect.gen(function*() {
+        for (let index = 0; index <= i; index++) {
+          yield* writer.write(chunk[index])
+        }
+      })
+    }
+  }
+  return writer.writeAll(chunk as NonEmptyReadonlyArray<Uint8Array | string>)
+}
+
+const toChannelWithReader = <A extends Uint8Array | string, IE>(
   self: Socket,
-  f: (data: Uint8Array | string) => A
+  reader: Effect.Effect<
+    Effect.Effect<NonEmptyReadonlyArray<A>, SocketError>,
+    SocketError,
+    Scope.Scope
+  >
 ): Channel.Channel<
   NonEmptyReadonlyArray<A>,
   SocketError | IE,
@@ -394,54 +539,57 @@ export const toChannelMap = <IE, A>(
   IE
 > =>
   Channel.fromTransform(Effect.fnUntraced(function*(upstream, scope) {
-    const queue = yield* Queue.make<A, SocketError | IE | Cause.Done>()
-
+    const readScope = yield* Scope.fork(scope)
+    const pull = yield* Scope.provide(reader, readScope)
     const writeScope = yield* Scope.fork(scope)
-    const write = yield* Scope.provide(self.writer, writeScope)
-
-    let chunk: NonEmptyReadonlyArray<Uint8Array | string | CloseEvent> | undefined
-    let index = 0
-    const writeChunk = Effect.whileLoop({
-      while: () => index < chunk!.length,
-      body: () => write(chunk![index++]),
-      step: constVoid
-    })
+    const writer = yield* Scope.provide(self.writer, writeScope)
+
+    let writeFailure: Cause.Cause<SocketError | IE> | undefined
 
     yield* upstream.pipe(
-      Effect.flatMap((arr) => {
-        if (arr.length === 1) return write(arr[0])
-        chunk = arr
-        index = 0
-        return writeChunk
-      }),
+      Effect.flatMap((chunk) => writeChunk(writer, chunk)),
       Effect.forever({ disableYield: true }),
       Effect.catchCauseFilter(
         Pull.filterNoDone,
-        (cause) => Queue.failCause(queue, cause)
+        (cause) =>
+          Effect.suspend(() => {
+            writeFailure = cause as Cause.Cause<SocketError | IE>
+            // closing the read scope fails a suspended pull, which is the
+            // reader contract, so the read side needs no per-pull failure race
+            return Scope.close(readScope, Exit.void)
+          })
       ),
       Effect.ensuring(Scope.close(writeScope, Exit.void)),
       Effect.forkIn(scope)
     )
 
-    yield* self.runRaw((data) => {
-      Queue.offerUnsafe(queue, f(data))
-    }).pipe(
-      Queue.into(queue),
-      Effect.forkIn(scope)
-    )
-
     // @effect-diagnostics-next-line returnEffectInGen:off
-    return Queue.takeAll(queue)
+    return Effect.catchCause(
+      Effect.suspend(
+        (): Pull.Pull<NonEmptyReadonlyArray<A>, SocketError | IE> =>
+          writeFailure !== undefined ? Effect.failCause(writeFailure) : pull
+      ),
+      (cause) =>
+        Effect.failCause(
+          (writeFailure ?? cause) as Cause.Cause<SocketError | IE | Cause.Done<void>>
+        )
+    )
   }))
 
 /**
- * Converts a `Socket` into a binary `Channel`, encoding incoming string frames
- * as UTF-8 bytes.
+ * Converts a `Socket` into a bidirectional binary `Channel`, encoding
+ * incoming string frames as UTF-8 bytes and writing outgoing frame batches to
+ * the socket.
+ *
+ * **Details**
+ *
+ * The read side is the socket's pull, so the channel is backpressured
+ * end-to-end.
  *
  * @category combinators
  * @since 4.0.0
  */
-export const toChannel = <IE>(
+export const toChannel = <IE = never>(
   self: Socket
 ): Channel.Channel<
   NonEmptyReadonlyArray<Uint8Array>,
@@ -449,22 +597,19 @@ export const toChannel = <IE>(
   void,
   NonEmptyReadonlyArray<Uint8Array | string | CloseEvent>,
   IE
-> => {
-  const encoder = new TextEncoder()
-  return toChannelMap(self, (data) => typeof data === "string" ? encoder.encode(data) : data)
-}
+> => toChannelWithReader<Uint8Array, IE>(self, readerBytes(self))
 
 /**
- * Converts a `Socket` into a string `Channel`, decoding binary frames with the
- * optional text encoding.
+ * Converts a `Socket` into a bidirectional string `Channel`, decoding binary
+ * frames with the optional text encoding.
  *
  * @category combinators
  * @since 4.0.0
  */
 export const toChannelString: {
   /**
-   * Converts a `Socket` into a string `Channel`, decoding binary frames with the
-   * optional text encoding.
+   * Converts a `Socket` into a bidirectional string `Channel`, decoding binary
+   * frames with the optional text encoding.
    *
    * @category combinators
    * @since 4.0.0
@@ -477,8 +622,8 @@ export const toChannelString: {
     IE
   >
   /**
-   * Converts a `Socket` into a string `Channel`, decoding binary frames with the
-   * optional text encoding.
+   * Converts a `Socket` into a bidirectional string `Channel`, decoding binary
+   * frames with the optional text encoding.
    *
    * @category combinators
    * @since 4.0.0
@@ -499,10 +644,21 @@ export const toChannelString: {
   void,
   NonEmptyReadonlyArray<Uint8Array | string | CloseEvent>,
   IE
-> => {
-  const decoder = new TextDecoder(encoding)
-  return toChannelMap(self, (data) => typeof data === "string" ? data : decoder.decode(data))
-})
+> => toChannelWithReader</**
+ * Converts a `Socket` into a bidirectional string `Channel`, decoding binary
+ * frames with the optional text encoding.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+string, /**
+ * Converts a `Socket` into a bidirectional string `Channel`, decoding binary
+ * frames with the optional text encoding.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+IE>(self, readerString(self, encoding)))
 
 /**
  * Creates a `Socket` to binary `Channel` adapter with a fixed upstream error
@@ -522,6 +678,18 @@ export const toChannelWith = <IE = never>() =>
   IE
 > => toChannel(self)
 
+/**
+ * Converts a `Socket` into a read-only binary `Stream` backed by the socket's
+ * pull, so consumption is backpressured end-to-end.
+ *
+ * @category combinators
+ * @since 4.0.0
+ */
+export const toStream = (self: Socket): Stream.Stream<Uint8Array, SocketError> =>
+  Stream.fromChannel(
+    Channel.fromTransform((_, scope) => Scope.provide(readerBytes(self), scope))
+  )
+
 /**
  * Creates a binary socket `Channel` from the `Socket` service in the
  * environment.
@@ -540,35 +708,104 @@ export const makeChannel = <IE = never>(): Channel.Channel<
 > => Channel.unwrap(Effect.map(Socket, toChannelWith<IE>()))
 
 /**
- * Default close-code classifier that treats every socket close code as an
- * error.
+ * Event payload exposed by a WebSocket implementation.
+ *
+ * **Details**
+ *
+ * The socket adapter only reads `data`, `code`, and `reason`; implementations
+ * may expose additional fields.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface WebSocketEvent {
+  readonly type?: string
+  readonly data?: unknown
+  readonly code?: number
+  readonly reason?: string
+}
+
+/**
+ * The subset of the WebSocket API required by `Socket`.
+ *
+ * **Details**
+ *
+ * This structural interface is intentionally independent of the DOM
+ * `WebSocket` type. Node implementations such as `ws` expose the same
+ * event-target methods, but are not assignable to `globalThis.WebSocket`
+ * because their event payload types are runtime-specific.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface WebSocketLike {
+  readonly readyState: number
+  addEventListener(
+    type: "open" | "message" | "error" | "close",
+    listener: (event: WebSocketEvent) => void,
+    options?: {
+      readonly once?: boolean
+    }
+  ): void
+  removeEventListener(
+    type: "open" | "message" | "error" | "close",
+    listener: (event: WebSocketEvent) => void
+  ): void
+  close(code?: number, reason?: string): void
+  send(data: string | Uint8Array<ArrayBuffer>): void
+}
+
+/**
+ * Common options understood by a WebSocket client implementation.
  *
- * @category predicates
+ * @category models
+ * @since 4.0.0
+ */
+export interface WebSocketClientOptions {
+  /**
+   * Headers to include in the opening handshake.
+   *
+   * **Details**
+   *
+   * This is supported by Node and Bun WebSocket clients. Browser constructors
+   * cannot set arbitrary handshake headers and must reject this option.
+   */
+  readonly headers?: Readonly<Record<string, string>> | undefined
+}
+
+/**
+ * Options accepted by a `WebSocketConstructor`.
+ *
+ * **Details**
+ *
+ * Browser-compatible constructors accept a protocol string or list. Node and
+ * Bun constructors additionally accept `WebSocketClientOptions`.
+ *
+ * @category models
  * @since 4.0.0
  */
-export const defaultCloseCodeIsError = (_code: number) => true
+export type WebSocketConstructorOptions = string | Array<string> | WebSocketClientOptions
 
 /**
- * Context service for the active `WebSocket` instance available while a
- * WebSocket-backed socket run is handling events.
+ * Context service for the active `WebSocket` instance.
  *
  * @category services
  * @since 4.0.0
  */
-export class WebSocket extends Context.Service<WebSocket, globalThis.WebSocket>()(
+export class WebSocket extends Context.Service<WebSocket, WebSocketLike>()(
   "~effect/socket/Socket/WebSocket"
 ) {}
 
 /**
  * Context service for constructing `WebSocket` instances from a URL and
- * optional protocols.
+ * optional protocols or platform-specific options.
  *
  * @category services
  * @since 4.0.0
  */
 export class WebSocketConstructor extends Context.Service<
   WebSocketConstructor,
-  (url: string, protocols?: string | Array<string> | undefined) => globalThis.WebSocket
+  (url: string, options?: WebSocketConstructorOptions | undefined) => WebSocketLike
 >()("@effect/platform/Socket/WebSocketConstructor") {}
 
 /**
@@ -578,21 +815,25 @@ export class WebSocketConstructor extends Context.Service<
  * @since 4.0.0
  */
 export const layerWebSocketConstructorGlobal: Layer.Layer<WebSocketConstructor> = Layer.succeed(WebSocketConstructor)(
-  (url, protocols) => new globalThis.WebSocket(url, protocols)
+  (url, options) => {
+    if (options !== undefined && typeof options !== "string" && !Array.isArray(options)) {
+      throw new TypeError("WebSocket client options are not supported by the global WebSocket constructor")
+    }
+    return new globalThis.WebSocket(url, options)
+  }
 )
 
 /**
- * Creates a `Socket` backed by a `WebSocketConstructor`, acquiring the
- * WebSocket for each run and using the close-code classifier to decide which
- * closes fail the run.
+ * Creates a `Socket` backed by a `WebSocketConstructor`, dialing the
+ * WebSocket for each reader acquisition.
  *
  * @category constructors
  * @since 4.0.0
  */
 export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
-  readonly closeCodeIsError?: ((code: number) => boolean) | undefined
   readonly openTimeout?: Duration.Input | undefined
   readonly protocols?: string | Array<string> | undefined
+  readonly highWaterMark?: number | undefined
 }): Effect.Effect<Socket, never, WebSocketConstructor> =>
   WebSocketConstructor.use((makeWs) =>
     fromWebSocket(
@@ -606,170 +847,271 @@ export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
     )
   )
 
+interface Pausable {
+  pause(): void
+  resume(): void
+}
+
+const isPausable = (ws: WebSocketLike): ws is WebSocketLike & Pausable =>
+  "pause" in ws && typeof (ws as any).pause === "function"
+
 /**
- * Builds a `Socket` from a scoped WebSocket acquisition effect, waiting for the
- * socket to open, dispatching message handlers in fibers, and translating
- * open, read, and close events into `SocketError` values.
+ * Builds a `Socket` from a scoped WebSocket acquisition effect.
+ *
+ * **Details**
+ *
+ * Reader acquisition runs `acquire`, attaches event listeners, then waits for
+ * the socket to open. Implementations exposing `pause`/`resume` (the `ws`
+ * package) remain flowing until buffered frames reach the configured
+ * `highWaterMark` (64 KiB by default). Draining the buffer resumes the
+ * transport. Incoming frames that arrive in the same tick are coalesced into
+ * one batch. Implementations without pause (browsers) buffer incoming frames,
+ * optionally failing the socket with a `SocketReadError` when `highWaterMark`
+ * bytes are exceeded (default unbounded). Message boundaries survive: each
+ * pulled batch contains one element per frame.
  *
  * @category constructors
  * @since 4.0.0
  */
-export const fromWebSocket = <RO>(
-  acquire: Effect.Effect<globalThis.WebSocket, SocketError, RO>,
+export const fromWebSocket = <RO, WS extends WebSocketLike>(
+  acquire: Effect.Effect<WS, SocketError, RO>,
   options?: {
-    readonly closeCodeIsError?: ((code: number) => boolean) | undefined
     readonly openTimeout?: Duration.Input | undefined
-    /**
-     * Replays buffered events on the first run after the socket opens and before
-     * the run's `onOpen` effect.
-     *
-     * @category options
-     * @since 4.0.0
-     */
-    readonly onInitialRun?: ((ws: globalThis.WebSocket) => ReadonlyArray<MessageEvent>) | undefined
+    readonly highWaterMark?: number | undefined
   } | undefined
 ): Effect.Effect<Socket, never, Exclude<RO, Scope.Scope>> =>
   Effect.withFiber((fiber) => {
-    let currentWS: globalThis.WebSocket | undefined
-    let initial = true
+    let currentWS: WebSocketLike | undefined
     const latch = Latch.makeUnsafe(false)
     const acquireContext = fiber.context as Context.Context<RO>
-    const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
-
-    const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }) =>
-      Effect.scopedWith(Effect.fnUntraced(function*(scope) {
-        const fiberSet = yield* FiberSet.make<any, E | SocketError>().pipe(
-          Scope.provide(scope)
-        )
-        const ws = yield* Scope.provide(acquire, scope)
-        const run = yield* Effect.provideService(FiberSet.runtime(fiberSet)<R>(), WebSocket, ws)
-        let open = false
-
-        function onMessage(event: MessageEvent) {
-          if (event.data instanceof Blob) {
-            const effect = Effect.flatMap(
-              Effect.promise(() => event.data.arrayBuffer() as Promise<ArrayBuffer>),
-              (buffer) => {
-                const result = handler(new Uint8Array(buffer))
-                return Effect.isEffect(result) ? result : Effect.void
-              }
-            )
-            return run(effect)
-          }
-          const result = handler(event.data instanceof ArrayBuffer ? new Uint8Array(event.data) : event.data)
-          if (Effect.isEffect(result)) {
-            run(result)
-          }
+
+    const reader: Socket["reader"] = Effect.gen(function*() {
+      const scope = yield* Effect.scope
+      const ws = yield* Scope.provide(acquire, scope)
+      if ("binaryType" in ws) {
+        ;(ws as { binaryType: string }).binaryType = "arraybuffer"
+      }
+      const pausable = isPausable(ws)
+      const highWaterMark = options?.highWaterMark ?? (pausable ? defaultHighWaterMark : undefined)
+
+      type ReadResume = (
+        effect: Effect.Effect<NonEmptyReadonlyArray<Uint8Array | string>, SocketError>
+      ) => void
+
+      let open = ws.readyState === 1
+      let paused = pausable && "isPaused" in ws && ws.isPaused === true
+      let buffer: Array<Uint8Array | string> = []
+      let bufferSize = 0
+      let error: SocketError | undefined
+      let waiter: ReadResume | undefined
+      let openWaiter:
+        | {
+          readonly resume: (effect: Effect.Effect<void, SocketError>) => void
+          readonly cleanup: () => void
         }
-        function onError(cause: Event) {
-          ws.removeEventListener("message", onMessage)
-          ws.removeEventListener("close", onClose)
-          Deferred.doneUnsafe(
-            fiberSet.deferred,
-            Effect.fail(
-              new SocketError({
-                reason: open ?
-                  new SocketReadError({
-                    cause
-                  }) :
-                  new SocketOpenError({
-                    kind: "Unknown",
-                    cause
-                  })
-              })
-            )
-          )
+        | undefined
+
+      function pauseWebSocket() {
+        if (!pausable || paused) return
+        ws.pause()
+        paused = true
+      }
+
+      function resumeWebSocket() {
+        if (!pausable || !paused) return
+        ws.resume()
+        paused = false
+      }
+
+      function takeBuffer(): NonEmptyReadonlyArray<Uint8Array | string> {
+        const chunk = buffer
+        buffer = []
+        bufferSize = 0
+        if (error === undefined) resumeWebSocket()
+        return chunk as unknown as NonEmptyReadonlyArray<Uint8Array | string>
+      }
+
+      function deliver() {
+        if (waiter === undefined || buffer.length === 0) return
+        const resume = waiter
+        waiter = undefined
+        resume(Effect.succeed(takeBuffer()))
+      }
+
+      function push(data: Uint8Array | string) {
+        buffer.push(data)
+        if (highWaterMark !== undefined) {
+          bufferSize += typeof data === "string" ? encoder.encode(data).byteLength : data.byteLength
         }
-        function onClose(event: globalThis.CloseEvent) {
-          const code = typeof event.code === "number" ? event.code : 1001
-          ws.removeEventListener("message", onMessage)
-          ws.removeEventListener("error", onError)
-          Deferred.doneUnsafe(
-            fiberSet.deferred,
-            Effect.fail(
-              new SocketError({
-                reason: new SocketCloseError({
-                  code,
-                  closeReason: event.reason
-                })
+        if (waiter !== undefined) deliver()
+        if (pausable && bufferSize >= highWaterMark!) {
+          pauseWebSocket()
+        } else if (!pausable && !waiter && highWaterMark !== undefined && bufferSize > highWaterMark) {
+          fail(
+            new SocketError({
+              reason: new SocketReadError({
+                cause: new Error(`Socket highWaterMark of ${highWaterMark} bytes exceeded`)
               })
-            )
+            })
           )
         }
+      }
 
-        ws.addEventListener("close", onClose, { once: true })
-        ws.addEventListener("error", onError, { once: true })
-        ws.addEventListener("message", onMessage)
-
-        if (ws.readyState !== 1) {
-          const openDeferred = Deferred.makeUnsafe<void>()
-          ws.addEventListener("open", () => {
-            open = true
-            Deferred.doneUnsafe(openDeferred, Effect.void)
-          }, { once: true })
-          yield* Deferred.await(openDeferred).pipe(
-            Effect.timeoutOrElse({
-              duration: options?.openTimeout ?? 10000,
-              orElse: () =>
-                Effect.fail(
-                  new SocketError({
-                    reason: new SocketOpenError({
-                      kind: "Timeout",
-                      cause: new Error("timeout waiting for \"open\"")
-                    })
-                  })
-                )
-            }),
-            Effect.raceFirst(FiberSet.join(fiberSet))
-          )
+      function fail(err: SocketError) {
+        if (error === undefined) error = err
+        if (openWaiter !== undefined) {
+          const { cleanup, resume } = openWaiter
+          openWaiter = undefined
+          cleanup()
+          resume(Effect.fail(error))
         }
-        open = true
-        currentWS = ws
-        latch.openUnsafe()
-        if (initial && options?.onInitialRun) {
-          initial = false
-          for (const event of options.onInitialRun(ws)) onMessage(event)
+        if (waiter !== undefined) {
+          const resume = waiter
+          waiter = undefined
+          resume(buffer.length > 0 ? Effect.succeed(takeBuffer()) : Effect.fail(error))
+        }
+      }
+
+      function onMessage(event: WebSocketEvent) {
+        const data = event.data as Uint8Array | ArrayBuffer | Blob | string
+        if (typeof Blob !== "undefined" && data instanceof Blob) {
+          data.arrayBuffer().then((buf) => push(new Uint8Array(buf)), (cause) => {
+            fail(new SocketError({ reason: new SocketReadError({ cause }) }))
+          })
+          return
         }
-        if (opts?.onOpen) yield* opts.onOpen
-        return yield* Effect.catchFilter(
-          FiberSet.join(fiberSet),
-          SocketCloseError.filterClean((_) => !closeCodeIsError(_)),
-          () => Effect.void
+        push(data instanceof ArrayBuffer ? new Uint8Array(data) : data as Uint8Array | string)
+      }
+      function onError(event: WebSocketEvent) {
+        fail(
+          new SocketError({
+            reason: open
+              ? new SocketReadError({ cause: event })
+              : new SocketOpenError({ kind: "Unknown", cause: event })
+          })
         )
-      })).pipe(
-        Effect.updateContext((input: Context.Context<R>) => Context.merge(acquireContext, input)),
-        Effect.ensuring(Effect.sync(() => {
-          latch.closeUnsafe()
-          currentWS = undefined
-        }))
-      )
+      }
+      function onClose(event: WebSocketEvent) {
+        fail(closeError(typeof event.code === "number" ? event.code : 1006, event.reason))
+      }
 
-    const write = (chunk: Uint8Array | string | CloseEvent) =>
-      latch.whenOpen(
-        Effect.suspend(() => {
-          try {
-            const ws = currentWS!
-            if (isCloseEvent(chunk)) {
-              ws.close(chunk.code, chunk.reason)
-            } else {
-              ws.send(chunk as string | Uint8Array<ArrayBuffer>)
+      ws.addEventListener("message", onMessage)
+      ws.addEventListener("error", onError, { once: true })
+      ws.addEventListener("close", onClose, { once: true })
+      yield* Scope.addFinalizer(
+        scope,
+        Effect.sync(() => {
+          // resume a pull blocked in another fiber before detaching
+          fail(closeError(1006))
+          ws.removeEventListener("message", onMessage)
+          ws.removeEventListener("error", onError)
+          ws.removeEventListener("close", onClose)
+          // let the close handshake proceed once nothing is pulling
+          if (pausable) {
+            try {
+              resumeWebSocket()
+            } catch {
+              // the underlying stream may already be gone
             }
-            return Effect.void
-          } catch (cause) {
-            return Effect.fail(new SocketError({ reason: new SocketWriteError({ cause }) }))
           }
+          latch.closeUnsafe()
+          currentWS = undefined
         })
       )
-    const writer = Effect.succeed(write)
 
-    return Effect.succeed(make({
-      runRaw,
-      writer
-    }))
+      if (ws.readyState >= 2) {
+        // @effect-diagnostics-next-line unnecessaryFailYieldableError:off
+        return yield* Effect.fail(error ?? closeError(1006))
+      }
+
+      if (!open) {
+        yield* Effect.callback<void, SocketError>((resume) => {
+          const onOpen = () => {
+            if (openWaiter?.resume !== resume) return
+            openWaiter = undefined
+            ws.removeEventListener("open", onOpen)
+            resume(Effect.void)
+          }
+          const cleanup = () => ws.removeEventListener("open", onOpen)
+          openWaiter = { resume, cleanup }
+          ws.addEventListener("open", onOpen, { once: true })
+          return Effect.sync(() => {
+            if (openWaiter?.resume === resume) openWaiter = undefined
+            cleanup()
+          })
+        }).pipe(
+          Effect.timeoutOrElse({
+            duration: options?.openTimeout ?? 10000,
+            orElse: () =>
+              Effect.fail(
+                new SocketError({
+                  reason: new SocketOpenError({
+                    kind: "Timeout",
+                    cause: new Error("timeout waiting for \"open\"")
+                  })
+                })
+              )
+          })
+        )
+        open = true
+      }
+
+      if (error === undefined && bufferSize < highWaterMark!) resumeWebSocket()
+      currentWS = ws
+      latch.openUnsafe()
+
+      return {
+        pull: Effect.callback<NonEmptyReadonlyArray<Uint8Array | string>, SocketError>((resume) => {
+          if (buffer.length > 0) return resume(Effect.succeed(takeBuffer()))
+          if (error !== undefined) return resume(Effect.fail(error))
+          waiter = resume
+          return Effect.sync(() => {
+            if (waiter === resume) waiter = undefined
+          })
+        }),
+        upgrade: SocketUpgradeError.unsupported
+      }
+    }).pipe(
+      Effect.updateContext((input: Context.Context<Scope.Scope>) => Context.merge(acquireContext, input))
+    ) as Socket["reader"]
+
+    const write = (chunk: Uint8Array | string | CloseEvent): Effect.Effect<void, SocketError> =>
+      Effect.suspend(() => {
+        const ws = currentWS
+        if (ws === undefined) return latch.whenOpen(write(chunk))
+        try {
+          if (isCloseEvent(chunk)) {
+            ws.close(chunk.code, chunk.reason)
+          } else {
+            ws.send(chunk as string | Uint8Array<ArrayBuffer>)
+          }
+          return Effect.void
+        } catch (cause) {
+          return Effect.fail(new SocketError({ reason: new SocketWriteError({ cause }) }))
+        }
+      })
+    const writeAll = (
+      chunks: NonEmptyReadonlyArray<Uint8Array | string>
+    ): Effect.Effect<void, SocketError> =>
+      Effect.suspend(() => {
+        const ws = currentWS
+        if (ws === undefined) return latch.whenOpen(writeAll(chunks))
+        try {
+          for (let i = 0; i < chunks.length; i++) {
+            ws.send(chunks[i] as string | Uint8Array<ArrayBuffer>)
+          }
+          return Effect.void
+        } catch (cause) {
+          return Effect.fail(new SocketError({ reason: new SocketWriteError({ cause }) }))
+        }
+      })
+    const writer: Socket["writer"] = Effect.succeed({ write, writeAll })
+
+    return Effect.succeed(make({ reader, writer }))
   })
 
+const defaultHighWaterMark = 64 * 1024
+
 /**
  * Creates a binary `Channel` backed by a WebSocket URL, requiring a
  * `WebSocketConstructor` service.
@@ -780,7 +1122,9 @@ export const fromWebSocket = <RO>(
 export const makeWebSocketChannel = <IE = never>(
   url: string,
   options?: {
-    readonly closeCodeIsError?: (code: number) => boolean
+    readonly openTimeout?: Duration.Input | undefined
+    readonly protocols?: string | Array<string> | undefined
+    readonly highWaterMark?: number | undefined
   }
 ): Channel.Channel<
   NonEmptyReadonlyArray<Uint8Array>,
@@ -805,22 +1149,12 @@ export const makeWebSocketChannel = <IE = never>(
 export const layerWebSocket: (
   url: string | Effect.Effect<string>,
   options?: {
-    readonly closeCodeIsError?: ((code: number) => boolean) | undefined
     readonly openTimeout?: Duration.Input | undefined
     readonly protocols?: string | Array<string> | undefined
+    readonly highWaterMark?: number | undefined
   } | undefined
 ) => Layer.Layer<Socket, never, WebSocketConstructor> = flow(makeWebSocket, Layer.effect(Socket))
 
-/**
- * Context reference for socket send queue capacity, defaulting to `16`.
- *
- * @category services
- * @since 4.0.0
- */
-export const SendQueueCapacity = Context.Reference<number>("~effect/socket/Socket/SendQueueCapacity", {
-  defaultValue: () => 16
-})
-
 /**
  * Readable and writable stream pair used to adapt transform-style streams into
  * a `Socket`.
@@ -834,75 +1168,23 @@ export interface InputTransformStream {
 }
 
 /**
- * Builds a `Socket` from a scoped `InputTransformStream`, reading incoming
- * chunks through socket handlers and writing outgoing chunks to the writable
- * stream, encoding strings as UTF-8 and using close-code classification for
- * `CloseEvent` values.
+ * Builds a `Socket` from a scoped `InputTransformStream`, pulling incoming
+ * chunks from the readable side and writing outgoing chunks to the writable
+ * stream, encoding strings as UTF-8.
  *
  * @category constructors
  * @since 4.0.0
  */
-export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStream, SocketError, R>, options?: {
-  readonly closeCodeIsError?: (code: number) => boolean
-}): Effect.Effect<Socket, never, Exclude<R, Scope.Scope>> =>
+export const fromTransformStream = <R>(
+  acquire: Effect.Effect<InputTransformStream, SocketError, R>
+): Effect.Effect<Socket, never, Exclude<R, Scope.Scope>> =>
   Effect.withFiber((fiber) => {
     const latch = Latch.makeUnsafe(false)
     let currentStream: {
       readonly stream: InputTransformStream
-      readonly fiberSet: FiberSet.FiberSet<any, any>
+      readonly fail: (error: SocketError) => void
     } | undefined
-    const acquireServices = fiber.context as Context.Context<R>
-    const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
-    const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
-      readonly onOpen?: Effect.Effect<void> | undefined
-    }) =>
-      Effect.scopedWith(Effect.fnUntraced(function*(scope) {
-        const stream = yield* Scope.provide(acquire, scope)
-        const reader = stream.readable.getReader()
-        yield* Scope.addFinalizer(scope, Effect.promise(() => reader.cancel()))
-        const fiberSet = yield* FiberSet.make<any, E | SocketError>().pipe(
-          Scope.provide(scope)
-        )
-        const runFork = yield* FiberSet.runtime(fiberSet)<R>()
-
-        yield* Effect.tryPromise({
-          try: async () => {
-            while (true) {
-              const { done, value } = await reader.read()
-              if (done) {
-                throw new SocketError({ reason: new SocketCloseError({ code: 1000 }) })
-              }
-              const result = handler(value)
-              if (Effect.isEffect(result)) {
-                runFork(result)
-              }
-            }
-          },
-          catch: (cause) =>
-            isSocketError(cause) ? cause : new SocketError({
-              reason: new SocketReadError({ cause })
-            })
-        }).pipe(
-          FiberSet.run(fiberSet)
-        )
-
-        currentStream = { stream, fiberSet }
-        yield* latch.open
-        if (opts?.onOpen) yield* opts.onOpen
-
-        return yield* Effect.catchFilter(
-          FiberSet.join(fiberSet),
-          SocketCloseError.filterClean((_) => !closeCodeIsError(_)),
-          () => Effect.void
-        )
-      })).pipe(
-        (_) => _,
-        Effect.updateContext((input: Context.Context<R>) => Context.merge(acquireServices, input)),
-        Effect.ensuring(Effect.sync(() => {
-          latch.closeUnsafe()
-          currentStream = undefined
-        }))
-      )
+    const acquireContext = fiber.context as Context.Context<R>
 
     const writers = new WeakMap<InputTransformStream, WritableStreamDefaultWriter<Uint8Array>>()
     const getWriter = (stream: InputTransformStream) => {
@@ -913,33 +1195,82 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
       }
       return writer
     }
+
+    const reader: Socket["reader"] = Effect.gen(function*() {
+      const scope = yield* Effect.scope
+      const stream = yield* Scope.provide(acquire, scope)
+      const readerHandle = (stream.readable as ReadableStream<Uint8Array | string>).getReader()
+      let error: SocketError | undefined
+      yield* Scope.addFinalizer(
+        scope,
+        Effect.suspend(() => {
+          latch.closeUnsafe()
+          currentStream = undefined
+          return Effect.promise(() => readerHandle.cancel().catch(constVoid))
+        })
+      )
+      currentStream = {
+        stream,
+        fail(err) {
+          if (error === undefined) error = err
+          readerHandle.cancel().catch(constVoid)
+        }
+      }
+      latch.openUnsafe()
+
+      const read = Effect.tryPromise({
+        try: () => readerHandle.read(),
+        catch: (cause) =>
+          error ?? new SocketError({
+            reason: new SocketReadError({ cause })
+          })
+      })
+      return {
+        pull: Effect.suspend(() => {
+          if (error !== undefined) return Effect.fail(error)
+          return Effect.flatMap(read, ({ done, value }) =>
+            done
+              ? Effect.fail(error ?? closeError(1000))
+              : Effect.succeed([value] as unknown as NonEmptyReadonlyArray<Uint8Array | string>))
+        }),
+        upgrade: SocketUpgradeError.unsupported
+      }
+    }).pipe(
+      Effect.updateContext((input: Context.Context<Scope.Scope>) => Context.merge(acquireContext, input))
+    ) as Socket["reader"]
+
     const write = (chunk: Uint8Array | string | CloseEvent) =>
       latch.whenOpen(Effect.suspend(() => {
-        const { fiberSet, stream } = currentStream!
+        const current = currentStream!
         if (isCloseEvent(chunk)) {
-          return Deferred.fail(
-            fiberSet.deferred,
-            new SocketError({
-              reason: new SocketCloseError({ code: chunk.code, closeReason: chunk.reason })
-            })
-          )
+          return Effect.sync(() => {
+            current.fail(closeError(chunk.code, chunk.reason))
+          })
         }
         return Effect.tryPromise({
-          try: () => getWriter(stream).write(typeof chunk === "string" ? encoder.encode(chunk) : chunk),
+          try: () => getWriter(current.stream).write(typeof chunk === "string" ? encoder.encode(chunk) : chunk),
           catch: (cause) => new SocketError({ reason: new SocketWriteError({ cause }) })
         })
       }))
-    const writer = Effect.acquireRelease(
-      Effect.succeed(write),
+    const writeAll = (chunks: NonEmptyReadonlyArray<Uint8Array | string>) =>
+      latch.whenOpen(Effect.tryPromise({
+        try: async () => {
+          const writer = getWriter(currentStream!.stream)
+          for (let i = 0; i < chunks.length; i++) {
+            const chunk = chunks[i]
+            await writer.write(typeof chunk === "string" ? encoder.encode(chunk) : chunk)
+          }
+        },
+        catch: (cause) => new SocketError({ reason: new SocketWriteError({ cause }) })
+      }))
+    const writer: Socket["writer"] = Effect.acquireRelease(
+      Effect.succeed({ write, writeAll }),
       () =>
         Effect.promise(async () => {
           if (!currentStream) return
-          await getWriter(currentStream.stream).close()
+          await getWriter(currentStream.stream).close().catch(constVoid)
         })
     )
 
-    return Effect.succeed(make({
-      runRaw,
-      writer
-    }))
+    return Effect.succeed(make({ reader, writer }))
   })