@statewalker/webrun-streams-ws 0.3.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -31,8 +31,9 @@ runs over any other transport that implements the seam.
31
31
  pnpm add @statewalker/webrun-streams-ws @statewalker/webrun-rpc @statewalker/webrun-msgpack
32
32
  ```
33
33
 
34
- The pipe imports nothing from this repository; `@statewalker/webrun-rpc` and
35
- `@statewalker/webrun-msgpack` are what you run over it. No peer dependencies.
34
+ The pipe is built on `newMessagePipe` from `@statewalker/webrun-streams`, its one
35
+ runtime dependency; `@statewalker/webrun-rpc` and `@statewalker/webrun-msgpack` are
36
+ what you run over it. No peer dependencies.
36
37
  One entry point, `.`.
37
38
 
38
39
  - **Browser and worker**: `openWebSocket` uses the global `WebSocket`.
@@ -252,9 +253,9 @@ shared CI hardware is unreliable, and it is excluded from `pnpm test`.
252
253
 
253
254
  ### Dependencies
254
255
 
255
- - None at runtime from this repository: `src/` imports nothing outside the
256
- package, and `messageTargetOverWebSocket` returns a `MessageTarget` by
257
- shape.
256
+ - `@statewalker/webrun-streams` at runtime, for `newMessagePipe`: the pipe module every transport adapter shares (listeners, delivery, life, the byte check, the frame ceiling, drain, close), so a pipe rule is fixed once for all of them (#151). The target is a `MessageTarget` by shape and carries its own `closeSignal` and `maxMessageSize`, so `overPipe(target, { codec, side })` needs nothing else.
257
+ `messageTargetOverWebSocket` takes `maxFrameBytes` and `maxMessageSize`
258
+ options, both unset by default.
258
259
  - `ws`, `@statewalker/webrun-rpc`, `@statewalker/webrun-msgpack` and
259
260
  `@statewalker/webrun-streams-conformance` are dev dependencies used only by
260
261
  the tests; consumers supply their own `webrun-rpc` and codec.
package/dist/index.js CHANGED
@@ -1,3 +1,4 @@
1
+ import { DEFAULT_DRAIN_LOW_WATER, newMessagePipe } from "@statewalker/webrun-streams";
1
2
  //#region src/websocket-like.ts
2
3
  const WS_READY_STATE = {
3
4
  CONNECTING: 0,
@@ -7,15 +8,12 @@ const WS_READY_STATE = {
7
8
  };
8
9
  //#endregion
9
10
  //#region src/message-target.ts
10
- /** How often `whenDrained` looks at `bufferedAmount`: a WebSocket has no drain event. */
11
- const DRAIN_POLL_MS = 5;
12
11
  /**
13
12
  * `whenDrained` resolves once `bufferedAmount` is at most this: the socket can
14
13
  * take more. Waiting for zero would make a sender that waits before every
15
14
  * frame (`overPipe`'s `frameSize`) pause a poll interval per frame.
16
15
  */
17
- const DRAIN_LOW_WATER = 262144;
18
- const encoder = new TextEncoder();
16
+ const DRAIN_LOW_WATER = DEFAULT_DRAIN_LOW_WATER;
19
17
  /**
20
18
  * One open WebSocket as a pipe of messages, for a multiplexer to run over:
21
19
  *
@@ -29,86 +27,39 @@ const encoder = new TextEncoder();
29
27
  * The socket must be `OPEN`. Binary messages arrive as `Uint8Array`, in order:
30
28
  * a browser socket still on the default `binaryType` "blob" is switched to
31
29
  * "arraybuffer", because reading a `Blob` is asynchronous and would let a later
32
- * message overtake it. A text message arrives as its UTF-8 bytes. Messages
33
- * reaching no listener are dropped, as on a `MessagePort`. The adapter imports
34
- * nothing from this repository; the target is a `MessageTarget` by shape.
30
+ * message overtake it. A text message arrives as its UTF-8 bytes; anything
31
+ * else ends the pipe with a `TypeError`. Messages reaching no listener are
32
+ * dropped, as on a `MessagePort`. Built on `newMessagePipe`
33
+ * (`@statewalker/webrun-streams`), which owns the pipe's rules.
35
34
  */
36
- function messageTargetOverWebSocket(ws) {
35
+ function messageTargetOverWebSocket(ws, options = {}) {
37
36
  if (ws.readyState !== WS_READY_STATE.OPEN) throw new Error(`messageTargetOverWebSocket: WebSocket is in readyState ${ws.readyState}, expected OPEN (1)`);
38
37
  if (ws.binaryType !== void 0 && ws.binaryType !== "arraybuffer" && ws.binaryType !== "nodebuffer") ws.binaryType = "arraybuffer";
39
- const listeners = /* @__PURE__ */ new Set();
40
- const life = new AbortController();
41
- const deliver = (data) => {
42
- const event = new MessageEvent("message", { data });
43
- for (const listener of [...listeners]) try {
44
- Promise.resolve(listener(event)).catch(() => void 0);
45
- } catch {}
38
+ const onMessage = (event) => control.deliver(event.data);
39
+ const onClose = (event) => {
40
+ const code = event?.code;
41
+ control.end(/* @__PURE__ */ new Error(`webrun-streams-ws: the WebSocket closed${code ? ` (code ${code})` : ""}`));
46
42
  };
47
- const onMessage = (event) => {
48
- if (life.signal.aborted) return;
49
- const bytes = toBytes(event.data);
50
- if (bytes) deliver(bytes);
51
- else if (typeof event.data === "string") deliver(encoder.encode(event.data));
52
- else {
53
- end(/* @__PURE__ */ new TypeError(`webrun-streams-ws: a message arrived as ${Object.prototype.toString.call(event.data)}; set binaryType to "arraybuffer" or "nodebuffer"`));
54
- try {
43
+ const control = newMessagePipe({
44
+ send: (bytes) => ws.send(bytes),
45
+ canSend: () => ws.readyState === WS_READY_STATE.OPEN,
46
+ bufferedAmount: () => ws.bufferedAmount ?? 0,
47
+ close: (local) => {
48
+ ws.removeEventListener("message", onMessage);
49
+ ws.removeEventListener("close", onClose);
50
+ if (local) try {
55
51
  ws.close();
56
52
  } catch {}
57
53
  }
58
- };
59
- const end = (reason) => {
60
- if (life.signal.aborted) return;
61
- ws.removeEventListener("message", onMessage);
62
- ws.removeEventListener("close", onClose);
63
- life.abort(reason);
64
- };
65
- const onClose = (event) => {
66
- const code = event?.code;
67
- end(/* @__PURE__ */ new Error(`webrun-streams-ws: the WebSocket closed${code ? ` (code ${code})` : ""}`));
68
- };
54
+ }, {
55
+ name: "webrun-streams-ws",
56
+ textAsBytes: true,
57
+ maxFrameBytes: options.maxFrameBytes,
58
+ maxMessageSize: options.maxMessageSize
59
+ });
69
60
  ws.addEventListener("message", onMessage);
70
61
  ws.addEventListener("close", onClose);
71
- return {
72
- signal: life.signal,
73
- target: {
74
- addEventListener: (_type, listener) => {
75
- listeners.add(listener);
76
- },
77
- removeEventListener: (_type, listener) => {
78
- listeners.delete(listener);
79
- },
80
- postMessage(message) {
81
- const bytes = toBytes(message);
82
- if (!bytes) throw new TypeError(`webrun-streams-ws: a byte pipe carries Uint8Array, ArrayBuffer or a view, got ${Object.prototype.toString.call(message)}`);
83
- if (life.signal.aborted || ws.readyState !== WS_READY_STATE.OPEN) return;
84
- ws.send(bytes);
85
- },
86
- async close() {
87
- listeners.clear();
88
- end(/* @__PURE__ */ new Error("webrun-streams-ws: closed locally"));
89
- try {
90
- ws.close();
91
- } catch {}
92
- },
93
- get bufferedAmount() {
94
- return ws.bufferedAmount ?? 0;
95
- },
96
- whenDrained() {
97
- return new Promise((resolve) => {
98
- const check = () => {
99
- if (life.signal.aborted || (ws.bufferedAmount ?? 0) <= 262144) resolve();
100
- else setTimeout(check, DRAIN_POLL_MS).unref?.();
101
- };
102
- check();
103
- });
104
- }
105
- }
106
- };
107
- }
108
- function toBytes(data) {
109
- if (data instanceof Uint8Array) return data;
110
- if (data instanceof ArrayBuffer) return new Uint8Array(data);
111
- if (ArrayBuffer.isView(data)) return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
62
+ return control.pipe;
112
63
  }
113
64
  /** Opens a WebSocket and resolves once it is `OPEN`; rejects if it fails or closes first. */
114
65
  async function openWebSocket(params) {
@@ -1,30 +1,31 @@
1
+ import { type MessagePipe, type MessagePipeTarget } from "@statewalker/webrun-streams";
1
2
  import { type WebSocketLike } from "./websocket-like.js";
2
- type Listener = (event: MessageEvent) => void | Promise<void>;
3
3
  /** What `messageTargetOverWebSocket` gives: a pipe of bytes, and its life. */
4
- export interface WebSocketMessageTarget {
4
+ export interface WebSocketMessageTarget extends MessagePipe {
5
5
  /**
6
6
  * A `MessageTarget` (as `@statewalker/webrun-rpc` defines it) whose messages
7
- * are `Uint8Array`s, one WebSocket message each.
7
+ * are `Uint8Array`s, one WebSocket message each. `bufferedAmount` is the
8
+ * socket's; `whenDrained` resolves once it is at most
9
+ * {@link DRAIN_LOW_WATER}, or the socket has closed.
8
10
  */
9
- target: {
10
- addEventListener(type: "message", listener: Listener): void;
11
- removeEventListener(type: "message", listener: Listener): void;
12
- /** Sends one binary message. Throws `TypeError` for anything but bytes. */
13
- postMessage(message: unknown): void;
14
- /** Closes the socket. */
15
- close(): Promise<void>;
16
- /** The socket's `bufferedAmount`: bytes sent and not yet written out. */
17
- readonly bufferedAmount: number;
18
- /** Resolves once `bufferedAmount` is at most {@link DRAIN_LOW_WATER}, or the socket has closed. */
19
- whenDrained(): Promise<void>;
20
- };
11
+ target: MessagePipeTarget;
21
12
  /**
22
- * Aborts when the socket closes, with an `Error` saying how. Pass it as
23
- * `multiplexPort`'s / `overPipe`'s `signal`, so a dead peer closes the
24
- * multiplexer and every port on it at once instead of leaving them open.
13
+ * Aborts when the socket closes, with an `Error` saying how; the same as
14
+ * `target.closeSignal`. Pass it as `multiplexPort`'s / `overPipe`'s
15
+ * `signal`, so a dead peer closes the multiplexer and every port on it at
16
+ * once instead of leaving them open.
25
17
  */
26
18
  signal: AbortSignal;
27
19
  }
20
+ export interface MessageTargetOverWebSocketOptions {
21
+ /**
22
+ * The largest message posted; past it the pipe ends with a `RangeError`.
23
+ * Default: none, a WebSocket carries messages of any size.
24
+ */
25
+ maxFrameBytes?: number;
26
+ /** The payload ceiling to report, for `overPipe`'s `maxMessageSize`. Default: none. */
27
+ maxMessageSize?: number;
28
+ }
28
29
  /**
29
30
  * `whenDrained` resolves once `bufferedAmount` is at most this: the socket can
30
31
  * take more. Waiting for zero would make a sender that waits before every
@@ -44,11 +45,12 @@ export declare const DRAIN_LOW_WATER: number;
44
45
  * The socket must be `OPEN`. Binary messages arrive as `Uint8Array`, in order:
45
46
  * a browser socket still on the default `binaryType` "blob" is switched to
46
47
  * "arraybuffer", because reading a `Blob` is asynchronous and would let a later
47
- * message overtake it. A text message arrives as its UTF-8 bytes. Messages
48
- * reaching no listener are dropped, as on a `MessagePort`. The adapter imports
49
- * nothing from this repository; the target is a `MessageTarget` by shape.
48
+ * message overtake it. A text message arrives as its UTF-8 bytes; anything
49
+ * else ends the pipe with a `TypeError`. Messages reaching no listener are
50
+ * dropped, as on a `MessagePort`. Built on `newMessagePipe`
51
+ * (`@statewalker/webrun-streams`), which owns the pipe's rules.
50
52
  */
51
- export declare function messageTargetOverWebSocket(ws: WebSocketLike): WebSocketMessageTarget;
53
+ export declare function messageTargetOverWebSocket(ws: WebSocketLike, options?: MessageTargetOverWebSocketOptions): WebSocketMessageTarget;
52
54
  export interface OpenWebSocketParams {
53
55
  /** WebSocket URL (`ws://` or `wss://`). */
54
56
  url: string;
@@ -64,5 +66,4 @@ export interface OpenWebSocketParams {
64
66
  export declare function openWebSocket(params: OpenWebSocketParams): Promise<WebSocketLike>;
65
67
  /** Resolves once `ws` is `OPEN`; rejects if it fails or closes first. */
66
68
  export declare function waitForOpen(ws: WebSocketLike): Promise<void>;
67
- export {};
68
69
  //# sourceMappingURL=message-target.d.ts.map
@@ -1 +1 @@
1
- {"version":3,"file":"message-target.d.ts","sourceRoot":"","sources":["../src/message-target.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAkB,MAAM,qBAAqB,CAAC;AAEzE,KAAK,QAAQ,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAE9D,8EAA8E;AAC9E,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,MAAM,EAAE;QACN,gBAAgB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;QAC5D,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAAC;QAC/D,2EAA2E;QAC3E,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;QACpC,yBAAyB;QACzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;QACvB,yEAAyE;QACzE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;QAChC,mGAAmG;QACnG,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;KAC9B,CAAC;IACF;;;;OAIG;IACH,MAAM,EAAE,WAAW,CAAC;CACrB;AAID;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAAa,CAAC;AAI1C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,aAAa,GAAG,sBAAsB,CAsGpF;AAUD,MAAM,WAAW,mBAAmB;IAClC,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC9B;;;OAGG;IACH,aAAa,CAAC,EAAE,KACd,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,KAC1B,aAAa,CAAC;CACpB;AAED,6FAA6F;AAC7F,wBAAsB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAUvF;AAED,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAwB5D"}
1
+ {"version":3,"file":"message-target.d.ts","sourceRoot":"","sources":["../src/message-target.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,iBAAiB,EAEvB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,KAAK,aAAa,EAAkB,MAAM,qBAAqB,CAAC;AAEzE,8EAA8E;AAC9E,MAAM,WAAW,sBAAuB,SAAQ,WAAW;IACzD;;;;;OAKG;IACH,MAAM,EAAE,iBAAiB,CAAC;IAC1B;;;;;OAKG;IACH,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,iCAAiC;IAChD;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uFAAuF;IACvF,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;GAIG;AACH,eAAO,MAAM,eAAe,QAA0B,CAAC;AAEvD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,0BAA0B,CACxC,EAAE,EAAE,aAAa,EACjB,OAAO,GAAE,iCAAsC,GAC9C,sBAAsB,CAiDxB;AAED,MAAM,WAAW,mBAAmB;IAClC,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC9B;;;OAGG;IACH,aAAa,CAAC,EAAE,KACd,GAAG,EAAE,MAAM,EACX,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,KAC1B,aAAa,CAAC;CACpB;AAED,6FAA6F;AAC7F,wBAAsB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAUvF;AAED,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAwB5D"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@statewalker/webrun-streams-ws",
3
- "version": "0.3.0",
3
+ "version": "0.5.0",
4
4
  "private": false,
5
5
  "type": "module",
6
6
  "description": "WebSocket-backed Connect/Serve adapter in the webrun-streams-* family",
@@ -29,6 +29,9 @@
29
29
  "dist",
30
30
  "src"
31
31
  ],
32
+ "dependencies": {
33
+ "@statewalker/webrun-streams": "^0.6.0"
34
+ },
32
35
  "devDependencies": {
33
36
  "@biomejs/biome": "^2.5.15",
34
37
  "@types/node": "^26.6.4",
@@ -38,10 +41,9 @@
38
41
  "typescript": "^7.0.2",
39
42
  "vitest": "^5.0.5",
40
43
  "ws": "^8.22.0",
41
- "@statewalker/webrun-streams-conformance": "^0.4.0",
42
- "@statewalker/webrun-msgpack": "^0.10.0",
43
- "@statewalker/webrun-streams": "^0.3.0",
44
- "@statewalker/webrun-rpc": "^0.11.0"
44
+ "@statewalker/webrun-msgpack": "^0.13.0",
45
+ "@statewalker/webrun-rpc": "^0.14.0",
46
+ "@statewalker/webrun-streams-conformance": "^0.7.0"
45
47
  },
46
48
  "sideEffects": false,
47
49
  "publishConfig": {
@@ -1,43 +1,45 @@
1
+ import {
2
+ DEFAULT_DRAIN_LOW_WATER,
3
+ type MessagePipe,
4
+ type MessagePipeTarget,
5
+ newMessagePipe,
6
+ } from "@statewalker/webrun-streams";
1
7
  import { type WebSocketLike, WS_READY_STATE } from "./websocket-like.js";
2
8
 
3
- type Listener = (event: MessageEvent) => void | Promise<void>;
4
-
5
9
  /** What `messageTargetOverWebSocket` gives: a pipe of bytes, and its life. */
6
- export interface WebSocketMessageTarget {
10
+ export interface WebSocketMessageTarget extends MessagePipe {
7
11
  /**
8
12
  * A `MessageTarget` (as `@statewalker/webrun-rpc` defines it) whose messages
9
- * are `Uint8Array`s, one WebSocket message each.
13
+ * are `Uint8Array`s, one WebSocket message each. `bufferedAmount` is the
14
+ * socket's; `whenDrained` resolves once it is at most
15
+ * {@link DRAIN_LOW_WATER}, or the socket has closed.
10
16
  */
11
- target: {
12
- addEventListener(type: "message", listener: Listener): void;
13
- removeEventListener(type: "message", listener: Listener): void;
14
- /** Sends one binary message. Throws `TypeError` for anything but bytes. */
15
- postMessage(message: unknown): void;
16
- /** Closes the socket. */
17
- close(): Promise<void>;
18
- /** The socket's `bufferedAmount`: bytes sent and not yet written out. */
19
- readonly bufferedAmount: number;
20
- /** Resolves once `bufferedAmount` is at most {@link DRAIN_LOW_WATER}, or the socket has closed. */
21
- whenDrained(): Promise<void>;
22
- };
17
+ target: MessagePipeTarget;
23
18
  /**
24
- * Aborts when the socket closes, with an `Error` saying how. Pass it as
25
- * `multiplexPort`'s / `overPipe`'s `signal`, so a dead peer closes the
26
- * multiplexer and every port on it at once instead of leaving them open.
19
+ * Aborts when the socket closes, with an `Error` saying how; the same as
20
+ * `target.closeSignal`. Pass it as `multiplexPort`'s / `overPipe`'s
21
+ * `signal`, so a dead peer closes the multiplexer and every port on it at
22
+ * once instead of leaving them open.
27
23
  */
28
24
  signal: AbortSignal;
29
25
  }
30
26
 
31
- /** How often `whenDrained` looks at `bufferedAmount`: a WebSocket has no drain event. */
32
- const DRAIN_POLL_MS = 5;
27
+ export interface MessageTargetOverWebSocketOptions {
28
+ /**
29
+ * The largest message posted; past it the pipe ends with a `RangeError`.
30
+ * Default: none, a WebSocket carries messages of any size.
31
+ */
32
+ maxFrameBytes?: number;
33
+ /** The payload ceiling to report, for `overPipe`'s `maxMessageSize`. Default: none. */
34
+ maxMessageSize?: number;
35
+ }
36
+
33
37
  /**
34
38
  * `whenDrained` resolves once `bufferedAmount` is at most this: the socket can
35
39
  * take more. Waiting for zero would make a sender that waits before every
36
40
  * frame (`overPipe`'s `frameSize`) pause a poll interval per frame.
37
41
  */
38
- export const DRAIN_LOW_WATER = 256 * 1024;
39
-
40
- const encoder = new TextEncoder();
42
+ export const DRAIN_LOW_WATER = DEFAULT_DRAIN_LOW_WATER;
41
43
 
42
44
  /**
43
45
  * One open WebSocket as a pipe of messages, for a multiplexer to run over:
@@ -52,11 +54,15 @@ const encoder = new TextEncoder();
52
54
  * The socket must be `OPEN`. Binary messages arrive as `Uint8Array`, in order:
53
55
  * a browser socket still on the default `binaryType` "blob" is switched to
54
56
  * "arraybuffer", because reading a `Blob` is asynchronous and would let a later
55
- * message overtake it. A text message arrives as its UTF-8 bytes. Messages
56
- * reaching no listener are dropped, as on a `MessagePort`. The adapter imports
57
- * nothing from this repository; the target is a `MessageTarget` by shape.
57
+ * message overtake it. A text message arrives as its UTF-8 bytes; anything
58
+ * else ends the pipe with a `TypeError`. Messages reaching no listener are
59
+ * dropped, as on a `MessagePort`. Built on `newMessagePipe`
60
+ * (`@statewalker/webrun-streams`), which owns the pipe's rules.
58
61
  */
59
- export function messageTargetOverWebSocket(ws: WebSocketLike): WebSocketMessageTarget {
62
+ export function messageTargetOverWebSocket(
63
+ ws: WebSocketLike,
64
+ options: MessageTargetOverWebSocketOptions = {},
65
+ ): WebSocketMessageTarget {
60
66
  if (ws.readyState !== WS_READY_STATE.OPEN) {
61
67
  throw new Error(
62
68
  `messageTargetOverWebSocket: WebSocket is in readyState ${ws.readyState}, expected OPEN (1)`,
@@ -71,101 +77,40 @@ export function messageTargetOverWebSocket(ws: WebSocketLike): WebSocketMessageT
71
77
  ws.binaryType !== "nodebuffer"
72
78
  )
73
79
  ws.binaryType = "arraybuffer";
74
- const listeners = new Set<Listener>();
75
- const life = new AbortController();
76
80
 
77
- const deliver = (data: Uint8Array): void => {
78
- const event = new MessageEvent("message", { data });
79
- for (const listener of [...listeners]) {
80
- try {
81
- // One listener's fault, thrown or rejected, must not stop delivery.
82
- Promise.resolve(listener(event)).catch(() => undefined);
83
- } catch {}
84
- }
85
- };
86
- const onMessage = (event: MessageEvent): void => {
87
- if (life.signal.aborted) return;
88
- const bytes = toBytes(event.data);
89
- if (bytes) deliver(bytes);
90
- else if (typeof event.data === "string") deliver(encoder.encode(event.data));
91
- else {
92
- // Dropping it would lose a multiplexer envelope and hang its call: fail loudly.
93
- end(
94
- new TypeError(
95
- `webrun-streams-ws: a message arrived as ${Object.prototype.toString.call(event.data)}; set binaryType to "arraybuffer" or "nodebuffer"`,
96
- ),
97
- );
98
- try {
99
- ws.close();
100
- } catch {}
101
- }
102
- };
103
- const end = (reason: Error): void => {
104
- if (life.signal.aborted) return;
105
- ws.removeEventListener("message", onMessage);
106
- ws.removeEventListener("close", onClose);
107
- life.abort(reason);
108
- };
81
+ const onMessage = (event: MessageEvent): void => control.deliver(event.data);
109
82
  const onClose = (event?: unknown): void => {
110
83
  const code = (event as { code?: number } | undefined)?.code;
111
- end(new Error(`webrun-streams-ws: the WebSocket closed${code ? ` (code ${code})` : ""}`));
84
+ control.end(
85
+ new Error(`webrun-streams-ws: the WebSocket closed${code ? ` (code ${code})` : ""}`),
86
+ );
112
87
  };
113
- ws.addEventListener("message", onMessage);
114
- // A failing socket fires `error` and then always `close`: `close` alone ends it.
115
- ws.addEventListener("close", onClose);
116
-
117
- return {
118
- signal: life.signal,
119
- target: {
120
- addEventListener: (_type, listener) => {
121
- listeners.add(listener);
122
- },
123
- removeEventListener: (_type, listener) => {
124
- listeners.delete(listener);
125
- },
126
- postMessage(message) {
127
- const bytes = toBytes(message);
128
- if (!bytes) {
129
- throw new TypeError(
130
- `webrun-streams-ws: a byte pipe carries Uint8Array, ArrayBuffer or a view, got ${Object.prototype.toString.call(message)}`,
131
- );
88
+ const control = newMessagePipe(
89
+ {
90
+ send: (bytes) => ws.send(bytes),
91
+ canSend: () => ws.readyState === WS_READY_STATE.OPEN,
92
+ bufferedAmount: () => ws.bufferedAmount ?? 0,
93
+ close: (local) => {
94
+ ws.removeEventListener("message", onMessage);
95
+ ws.removeEventListener("close", onClose);
96
+ if (local) {
97
+ try {
98
+ ws.close();
99
+ } catch {}
132
100
  }
133
- if (life.signal.aborted || ws.readyState !== WS_READY_STATE.OPEN) return; // `signal` says so
134
- ws.send(bytes);
135
- },
136
- async close() {
137
- listeners.clear();
138
- end(new Error("webrun-streams-ws: closed locally"));
139
- try {
140
- ws.close();
141
- } catch {}
142
- },
143
- get bufferedAmount() {
144
- return ws.bufferedAmount ?? 0;
145
- },
146
- whenDrained() {
147
- return new Promise<void>((resolve) => {
148
- const check = (): void => {
149
- if (life.signal.aborted || (ws.bufferedAmount ?? 0) <= DRAIN_LOW_WATER) resolve();
150
- else {
151
- // A peer that stops reading but never closes must not keep Node alive.
152
- const timer = setTimeout(check, DRAIN_POLL_MS) as { unref?: () => void };
153
- timer.unref?.();
154
- }
155
- };
156
- check();
157
- });
158
101
  },
159
102
  },
160
- };
161
- }
162
-
163
- function toBytes(data: unknown): Uint8Array | undefined {
164
- if (data instanceof Uint8Array) return data;
165
- if (data instanceof ArrayBuffer) return new Uint8Array(data);
166
- if (ArrayBuffer.isView(data))
167
- return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
168
- return undefined;
103
+ {
104
+ name: "webrun-streams-ws",
105
+ textAsBytes: true,
106
+ maxFrameBytes: options.maxFrameBytes,
107
+ maxMessageSize: options.maxMessageSize,
108
+ },
109
+ );
110
+ ws.addEventListener("message", onMessage);
111
+ // A failing socket fires `error` and then always `close`: `close` alone ends it.
112
+ ws.addEventListener("close", onClose);
113
+ return control.pipe as WebSocketMessageTarget;
169
114
  }
170
115
 
171
116
  export interface OpenWebSocketParams {