effect 4.0.0-rc.111 → 4.0.0-rc.113

package/dist/unstable/socket/Socket.js

@@ -1,18 +1,15 @@
 import * as Channel from "../../Channel.js";
 import * as Context from "../../Context.js";
-import * as Deferred from "../../Deferred.js";
 import * as Effect from "../../Effect.js";
 import * as Exit from "../../Exit.js";
-import * as FiberSet from "../../FiberSet.js";
 import { constVoid, dual, flow } from "../../Function.js";
 import * as Latch from "../../Latch.js";
 import * as Layer from "../../Layer.js";
 import * as Predicate from "../../Predicate.js";
 import * as Pull from "../../Pull.js";
-import * as Queue from "../../Queue.js";
-import * as Result from "../../Result.js";
 import * as Schema from "../../Schema.js";
 import * as Scope from "../../Scope.js";
+import * as Stream from "../../Stream.js";
 /**
  * Runtime type identifier attached to `Socket` services.
  *
@@ -40,21 +37,74 @@ export const isSocket = u => Predicate.hasProperty(u, TypeId);
  */
 export const Socket = /*#__PURE__*/Context.Service("effect/socket/Socket");
 /**
- * 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 => 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 = /*#__PURE__*/new TextEncoder();
-const decoder = /*#__PURE__*/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 => 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(chunk.length);
+      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;
+}));
+/**
+ * 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, encoding) => Effect.map(self.reader, ({
+  pull
+}) => {
+  const decoder = new TextDecoder(encoding);
+  return Effect.map(pull, chunk => {
+    const out = new Array(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;
+  });
+});
 const CloseEventTypeId = "~effect/socket/Socket/CloseEvent";
 /**
  * Represents a socket close event value carrying a close code and optional
@@ -163,27 +213,46 @@ export class SocketOpenError extends /*#__PURE__*/Schema.Error("effect/socket/So
   }
 }
 /**
- * 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 /*#__PURE__*/Schema.Error("effect/socket/Socket/SocketCloseError")({
-  _tag: /*#__PURE__*/Schema.tag("SocketCloseError"),
-  code: Schema.Int,
-  closeReason: /*#__PURE__*/Schema.optional(Schema.String)
+export class SocketUpgradeError extends /*#__PURE__*/Schema.Error("effect/socket/Socket/SocketUpgradeError")({
+  _tag: /*#__PURE__*/Schema.tag("SocketUpgradeError"),
+  cause: /*#__PURE__*/Schema.optional(/*#__PURE__*/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) {
-    return function (u) {
-      return SocketError.is(u) && u.reason._tag === "SocketCloseError" && isClean(u.reason.code) ? Result.succeed(u.reason) : Result.fail(u);
-    };
+  static unsupported = () => Effect.fail(new SocketError({
+    reason: new SocketUpgradeError({})
+  }));
+  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 /*#__PURE__*/Schema.Error("effect/socket/Socket/SocketCloseError")({
+  _tag: /*#__PURE__*/Schema.tag("SocketCloseError"),
+  code: Schema.Int,
+  closeReason: /*#__PURE__*/Schema.optional(Schema.String)
+}) {
   get message() {
     if (this.closeReason) {
       return `${this.code}: ${this.closeReason}`;
@@ -197,10 +266,10 @@ export class SocketCloseError extends /*#__PURE__*/Schema.Error("effect/socket/S
  * @category errors
  * @since 4.0.0
  */
-export const SocketErrorReason = /*#__PURE__*/Schema.Union([SocketReadError, SocketWriteError, SocketOpenError, SocketCloseError]);
+export const SocketErrorReason = /*#__PURE__*/Schema.Union([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
@@ -236,60 +305,63 @@ export class SocketError extends /*#__PURE__*/Schema.TaggedError(SocketErrorType
   }
   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 = (self, f) => Channel.fromTransform(Effect.fnUntraced(function* (upstream, scope) {
-  const queue = yield* Queue.make();
+const closeError = (code, closeReason) => new SocketError({
+  reason: new SocketCloseError({
+    code,
+    closeReason
+  })
+});
+const writeChunk = (writer, chunk) => {
+  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);
+};
+const toChannelWithReader = (self, reader) => Channel.fromTransform(Effect.fnUntraced(function* (upstream, scope) {
+  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;
-  let index = 0;
-  const writeChunk = Effect.whileLoop({
-    while: () => index < chunk.length,
-    body: () => write(chunk[index++]),
-    step: constVoid
-  });
-  yield* upstream.pipe(Effect.flatMap(arr => {
-    if (arr.length === 1) return write(arr[0]);
-    chunk = arr;
-    index = 0;
-    return writeChunk;
-  }), Effect.forever({
+  const writer = yield* Scope.provide(self.writer, writeScope);
+  let writeFailure;
+  yield* upstream.pipe(Effect.flatMap(chunk => writeChunk(writer, chunk)), Effect.forever({
     disableYield: true
-  }), Effect.catchCauseFilter(Pull.filterNoDone, cause => Queue.failCause(queue, cause)), 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.catchCauseFilter(Pull.filterNoDone, cause => Effect.suspend(() => {
+    writeFailure = cause;
+    // 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));
   // @effect-diagnostics-next-line returnEffectInGen:off
-  return Queue.takeAll(queue);
+  return Effect.catchCause(Effect.suspend(() => writeFailure !== undefined ? Effect.failCause(writeFailure) : pull), cause => Effect.failCause(writeFailure ?? cause));
 }));
 /**
- * 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 = self => {
-  const encoder = new TextEncoder();
-  return toChannelMap(self, data => typeof data === "string" ? encoder.encode(data) : data);
-};
+export const toChannel = self => toChannelWithReader(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 = /*#__PURE__*/dual(args => isSocket(args[0]), (self, encoding) => {
-  const decoder = new TextDecoder(encoding);
-  return toChannelMap(self, data => typeof data === "string" ? data : decoder.decode(data));
-});
+export const toChannelString = /*#__PURE__*/dual(args => isSocket(args[0]), (self, encoding) => toChannelWithReader(self, readerString(self, encoding)));
 /**
  * Creates a `Socket` to binary `Channel` adapter with a fixed upstream error
  * type.
@@ -299,24 +371,23 @@ export const toChannelString = /*#__PURE__*/dual(args => isSocket(args[0]), (sel
  */
 export const toChannelWith = () => self => toChannel(self);
 /**
- * Creates a binary socket `Channel` from the `Socket` service in the
- * environment.
+ * Converts a `Socket` into a read-only binary `Stream` backed by the socket's
+ * pull, so consumption is backpressured end-to-end.
  *
- * @category constructors
+ * @category combinators
  * @since 4.0.0
  */
-export const makeChannel = () => Channel.unwrap(Effect.map(Socket, toChannelWith()));
+export const toStream = self => Stream.fromChannel(Channel.fromTransform((_, scope) => Scope.provide(readerBytes(self), scope)));
 /**
- * Default close-code classifier that treats every socket close code as an
- * error.
+ * Creates a binary socket `Channel` from the `Socket` service in the
+ * environment.
  *
- * @category predicates
+ * @category constructors
  * @since 4.0.0
  */
-export const defaultCloseCodeIsError = _code => true;
+export const makeChannel = () => Channel.unwrap(Effect.map(Socket, toChannelWith()));
 /**
- * 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
@@ -324,7 +395,7 @@ export const defaultCloseCodeIsError = _code => true;
 export class WebSocket extends /*#__PURE__*/Context.Service()("~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
@@ -336,87 +407,191 @@ export class WebSocketConstructor extends /*#__PURE__*/Context.Service()("@effec
  * @category layers
  * @since 4.0.0
  */
-export const layerWebSocketConstructorGlobal = /*#__PURE__*/Layer.succeed(WebSocketConstructor)((url, protocols) => new globalThis.WebSocket(url, protocols));
+export const layerWebSocketConstructorGlobal = /*#__PURE__*/Layer.succeed(WebSocketConstructor)((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, options) => WebSocketConstructor.use(makeWs => fromWebSocket(Effect.acquireRelease((typeof url === "string" ? Effect.succeed(url) : url).pipe(Effect.map(url => makeWs(url, options?.protocols))), ws => Effect.sync(() => ws.close(1000))), options));
+const isPausable = ws => "pause" in ws && typeof ws.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 = (acquire, options) => Effect.withFiber(fiber => {
   let currentWS;
-  let initial = true;
   const latch = Latch.makeUnsafe(false);
   const acquireContext = fiber.context;
-  const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError;
-  const runRaw = (handler, opts) => Effect.scopedWith(Effect.fnUntraced(function* (scope) {
-    const fiberSet = yield* FiberSet.make().pipe(Scope.provide(scope));
+  const reader = Effect.gen(function* () {
+    const scope = yield* Effect.scope;
     const ws = yield* Scope.provide(acquire, scope);
-    const run = yield* Effect.provideService(FiberSet.runtime(fiberSet)(), WebSocket, ws);
-    let open = false;
+    if ("binaryType" in ws) {
+      ;
+      ws.binaryType = "arraybuffer";
+    }
+    const pausable = isPausable(ws);
+    const highWaterMark = options?.highWaterMark ?? (pausable ? defaultHighWaterMark : undefined);
+    let open = ws.readyState === 1;
+    let paused = pausable && "isPaused" in ws && ws.isPaused === true;
+    let buffer = [];
+    let bufferSize = 0;
+    let error;
+    let waiter;
+    let openWaiter;
+    function pauseWebSocket() {
+      if (!pausable || paused) return;
+      ws.pause();
+      paused = true;
+    }
+    function resumeWebSocket() {
+      if (!pausable || !paused) return;
+      ws.resume();
+      paused = false;
+    }
+    function takeBuffer() {
+      const chunk = buffer;
+      buffer = [];
+      bufferSize = 0;
+      if (error === undefined) resumeWebSocket();
+      return chunk;
+    }
+    function deliver() {
+      if (waiter === undefined || buffer.length === 0) return;
+      const resume = waiter;
+      waiter = undefined;
+      resume(Effect.succeed(takeBuffer()));
+    }
+    function push(data) {
+      buffer.push(data);
+      if (highWaterMark !== undefined) {
+        bufferSize += typeof data === "string" ? encoder.encode(data).byteLength : data.byteLength;
+      }
+      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`)
+          })
+        }));
+      }
+    }
+    function fail(err) {
+      if (error === undefined) error = err;
+      if (openWaiter !== undefined) {
+        const {
+          cleanup,
+          resume
+        } = openWaiter;
+        openWaiter = undefined;
+        cleanup();
+        resume(Effect.fail(error));
+      }
+      if (waiter !== undefined) {
+        const resume = waiter;
+        waiter = undefined;
+        resume(buffer.length > 0 ? Effect.succeed(takeBuffer()) : Effect.fail(error));
+      }
+    }
     function onMessage(event) {
-      if (event.data instanceof Blob) {
-        const effect = Effect.flatMap(Effect.promise(() => event.data.arrayBuffer()), buffer => {
-          const result = handler(new Uint8Array(buffer));
-          return Effect.isEffect(result) ? result : Effect.void;
+      const data = event.data;
+      if (typeof Blob !== "undefined" && data instanceof Blob) {
+        data.arrayBuffer().then(buf => push(new Uint8Array(buf)), cause => {
+          fail(new SocketError({
+            reason: new SocketReadError({
+              cause
+            })
+          }));
         });
-        return run(effect);
-      }
-      const result = handler(event.data instanceof ArrayBuffer ? new Uint8Array(event.data) : event.data);
-      if (Effect.isEffect(result)) {
-        run(result);
+        return;
       }
+      push(data instanceof ArrayBuffer ? new Uint8Array(data) : data);
     }
-    function onError(cause) {
-      ws.removeEventListener("message", onMessage);
-      ws.removeEventListener("close", onClose);
-      Deferred.doneUnsafe(fiberSet.deferred, Effect.fail(new SocketError({
+    function onError(event) {
+      fail(new SocketError({
         reason: open ? new SocketReadError({
-          cause
+          cause: event
         }) : new SocketOpenError({
           kind: "Unknown",
-          cause
+          cause: event
         })
-      })));
+      }));
     }
     function onClose(event) {
-      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
-        })
-      })));
+      fail(closeError(typeof event.code === "number" ? event.code : 1006, event.reason));
     }
-    ws.addEventListener("close", onClose, {
+    ws.addEventListener("message", onMessage);
+    ws.addEventListener("error", onError, {
       once: true
     });
-    ws.addEventListener("error", onError, {
+    ws.addEventListener("close", onClose, {
       once: true
     });
-    ws.addEventListener("message", onMessage);
-    if (ws.readyState !== 1) {
-      const openDeferred = Deferred.makeUnsafe();
-      ws.addEventListener("open", () => {
-        open = true;
-        Deferred.doneUnsafe(openDeferred, Effect.void);
-      }, {
-        once: true
-      });
-      yield* Deferred.await(openDeferred).pipe(Effect.timeoutOrElse({
+    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
+        }
+      }
+      latch.closeUnsafe();
+      currentWS = undefined;
+    }));
+    if (ws.readyState >= 2) {
+      // @effect-diagnostics-next-line unnecessaryFailYieldableError:off
+      return yield* Effect.fail(error ?? closeError(1006));
+    }
+    if (!open) {
+      yield* Effect.callback(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({
@@ -424,24 +599,28 @@ export const fromWebSocket = (acquire, options) => Effect.withFiber(fiber => {
             cause: new Error("timeout waiting for \"open\"")
           })
         }))
-      }), Effect.raceFirst(FiberSet.join(fiberSet)));
+      }));
+      open = true;
     }
-    open = true;
+    if (error === undefined && bufferSize < highWaterMark) resumeWebSocket();
     currentWS = ws;
     latch.openUnsafe();
-    if (initial && options?.onInitialRun) {
-      initial = false;
-      for (const event of options.onInitialRun(ws)) onMessage(event);
-    }
-    if (opts?.onOpen) yield* opts.onOpen;
-    return yield* Effect.catchFilter(FiberSet.join(fiberSet), SocketCloseError.filterClean(_ => !closeCodeIsError(_)), () => Effect.void);
-  })).pipe(Effect.updateContext(input => Context.merge(acquireContext, input)), Effect.ensuring(Effect.sync(() => {
-    latch.closeUnsafe();
-    currentWS = undefined;
-  })));
-  const write = chunk => latch.whenOpen(Effect.suspend(() => {
+    return {
+      pull: Effect.callback(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.merge(acquireContext, input)));
+  const write = chunk => Effect.suspend(() => {
+    const ws = currentWS;
+    if (ws === undefined) return latch.whenOpen(write(chunk));
     try {
-      const ws = currentWS;
       if (isCloseEvent(chunk)) {
         ws.close(chunk.code, chunk.reason);
       } else {
@@ -455,13 +634,33 @@ export const fromWebSocket = (acquire, options) => Effect.withFiber(fiber => {
         })
       }));
     }
-  }));
-  const writer = Effect.succeed(write);
+  });
+  const writeAll = chunks => 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]);
+      }
+      return Effect.void;
+    } catch (cause) {
+      return Effect.fail(new SocketError({
+        reason: new SocketWriteError({
+          cause
+        })
+      }));
+    }
+  });
+  const writer = Effect.succeed({
+    write,
+    writeAll
+  });
   return Effect.succeed(make({
-    runRaw,
+    reader,
     writer
   }));
 });
+const defaultHighWaterMark = 64 * 1024;
 /**
  * Creates a binary `Channel` backed by a WebSocket URL, requiring a
  * `WebSocketConstructor` service.
@@ -479,71 +678,17 @@ export const makeWebSocketChannel = (url, options) => Channel.unwrap(Effect.map(
  */
 export const layerWebSocket = /*#__PURE__*/flow(makeWebSocket, /*#__PURE__*/Layer.effect(Socket));
 /**
- * Context reference for socket send queue capacity, defaulting to `16`.
- *
- * @category services
- * @since 4.0.0
- */
-export const SendQueueCapacity = /*#__PURE__*/Context.Reference("~effect/socket/Socket/SendQueueCapacity", {
-  defaultValue: () => 16
-});
-/**
- * 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 = (acquire, options) => Effect.withFiber(fiber => {
+export const fromTransformStream = acquire => Effect.withFiber(fiber => {
   const latch = Latch.makeUnsafe(false);
   let currentStream;
-  const acquireServices = fiber.context;
-  const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError;
-  const runRaw = (handler, opts) => 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().pipe(Scope.provide(scope));
-    const runFork = yield* FiberSet.runtime(fiberSet)();
-    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.merge(acquireServices, input)), Effect.ensuring(Effect.sync(() => {
-    latch.closeUnsafe();
-    currentStream = undefined;
-  })));
+  const acquireContext = fiber.context;
   const writers = new WeakMap();
   const getWriter = stream => {
     let writer = writers.get(stream);
@@ -553,21 +698,52 @@ export const fromTransformStream = (acquire, options) => Effect.withFiber(fiber
     }
     return writer;
   };
+  const reader = Effect.gen(function* () {
+    const scope = yield* Effect.scope;
+    const stream = yield* Scope.provide(acquire, scope);
+    const readerHandle = stream.readable.getReader();
+    let error;
+    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]));
+      }),
+      upgrade: SocketUpgradeError.unsupported
+    };
+  }).pipe(Effect.updateContext(input => Context.merge(acquireContext, input)));
   const write = chunk => 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
@@ -575,12 +751,29 @@ export const fromTransformStream = (acquire, options) => Effect.withFiber(fiber
       })
     });
   }));
-  const writer = Effect.acquireRelease(Effect.succeed(write), () => Effect.promise(async () => {
+  const writeAll = chunks => 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 = 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,
+    reader,
     writer
   }));
 });