moonbridge-ts 0.1.0

package/src/moonbridge-ipc/general/message/session_setup.ts

@@ -0,0 +1,25 @@
+/**
+ * IPC 会话构建请求/响应。对应 Flutter lib/general/message/session_setup.dart。
+ */
+export class IpcSessionSetupRequest {
+  constructor(
+    public readonly sourceClient: string,
+    public readonly targetClient: string,
+    public readonly callbackId: string,
+    public readonly autoLaunch: boolean
+  ) { }
+}
+
+export class IpcSessionSetupResponse {
+  static readonly success = 0;
+  static readonly failure = 1;
+
+  constructor(
+    public readonly sourceClient: string,
+    public readonly targetClient: string,
+    public readonly callbackId: string,
+    public readonly result: number,
+    public readonly message?: string,
+    public readonly userInfo?: Record<string, unknown>
+  ) { }
+}

package/src/moonbridge-ipc/general/message/unregistration.ts

@@ -0,0 +1,6 @@
+/**
+ * 客户端注销消息类。对应 Flutter lib/general/message/unregistration.dart Unregistration。
+ */
+export class Unregistration {
+  constructor(public readonly clientName: string) { }
+}

package/src/moonbridge-ipc/general/transport/encode/data_frame_codec.ts

@@ -0,0 +1,148 @@
+/**
+ * 数据帧编解码，与 Flutter lib/general/transport/encode/data_frame_codec.dart 完全一致。
+ * 帧格式：[帧头(1 字节 0x7E) + 数据长度(4 字节 LE) + 数据内容(N 字节 UTF-8) + 校验和(4 字节 LE)]
+ * 若实现不一致则无法与 Flutter 端正常对接与解析。
+ */
+
+const FRAME_HEADER = 0x7e; // 帧头标志，与 Flutter 一致
+const MIN_FRAME_SIZE = 9; // 1 + 4 + 0 + 4
+
+/** 解码结果：解码出的消息与剩余未处理缓冲区，与 Flutter DecodeResult 一致。 */
+export interface DecodeResult {
+  /** 解码出的一条消息；未完成或失败时为 undefined */
+  message: string | undefined;
+  /** 剩余未处理数据，供下次解码使用 */
+  remainingBuffer: number[];
+}
+
+const encoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null;
+const decoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8') : null;
+
+function stringToUtf8Bytes(s: string): number[] {
+  if (encoder) {
+    return Array.from(encoder.encode(s));
+  }
+  const out: number[] = [];
+  for (let i = 0; i < s.length; i++) {
+    let c = s.charCodeAt(i);
+    if (c < 0x80) {
+      out.push(c);
+    } else if (c < 0x800) {
+      out.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+    } else if (c < 0xd800 || c >= 0xe000) {
+      out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+    } else {
+      i++;
+      const c2 = i < s.length ? s.charCodeAt(i) : 0;
+      const u = 0x10000 + ((c & 0x3ff) << 10) + (c2 & 0x3ff);
+      out.push(
+        0xf0 | (u >> 18),
+        0x80 | ((u >> 12) & 0x3f),
+        0x80 | ((u >> 6) & 0x3f),
+        0x80 | (u & 0x3f),
+      );
+    }
+  }
+  return out;
+}
+
+function utf8BytesToString(bytes: number[]): string {
+  if (decoder) {
+    return decoder.decode(new Uint8Array(bytes));
+  }
+  let s = '';
+  for (let i = 0; i < bytes.length; ) {
+    const b = bytes[i];
+    if (b < 0x80) {
+      s += String.fromCharCode(b);
+      i += 1;
+    } else if (b < 0xe0) {
+      s += String.fromCharCode(((b & 0x1f) << 6) | (bytes[i + 1]! & 0x3f));
+      i += 2;
+    } else if (b < 0xf0) {
+      s += String.fromCharCode(
+        ((b & 0x0f) << 12) | ((bytes[i + 1]! & 0x3f) << 6) | (bytes[i + 2]! & 0x3f),
+      );
+      i += 3;
+    } else {
+      const u =
+        0x10000 +
+        (((b & 0x07) << 18) |
+          ((bytes[i + 1]! & 0x3f) << 12) |
+          ((bytes[i + 2]! & 0x3f) << 6) |
+          (bytes[i + 3]! & 0x3f));
+      s += String.fromCharCode(
+        0xd800 + ((u - 0x10000) >> 10),
+        0xdc00 + ((u - 0x10000) & 0x3ff),
+      );
+      i += 4;
+    }
+  }
+  return s;
+}
+
+/**
+ * 编码数据帧。与 Flutter encodeDataFrame(String) 一致。
+ * @param data 字符串消息（将按 UTF-8 编码）
+ * @returns 完整帧的字节数组
+ */
+export function encodeDataFrame(data: string): Uint8Array {
+  const dataBytes = stringToUtf8Bytes(data);
+  const length = dataBytes.length;
+  const checksum = dataBytes.reduce((sum, byte) => sum + byte, 0) >>> 0; // 32-bit
+
+  const frame = new Uint8Array(1 + 4 + length + 4);
+  const view = new DataView(frame.buffer);
+  frame[0] = FRAME_HEADER;
+  view.setUint32(1, length, true); // little-endian
+  frame.set(dataBytes, 5);
+  view.setUint32(5 + length, checksum, true);
+  return frame;
+}
+
+/**
+ * 解码数据帧。与 Flutter decodeDataFrame(List<int>) 一致。
+ * @param buffer 累积的接收缓冲区（可被修改/复用，返回的 remainingBuffer 为新数组）
+ * @returns DecodeResult：message 为解码出的一条消息或 null，remainingBuffer 为剩余数据
+ */
+export function decodeDataFrame(buffer: number[] | Uint8Array): DecodeResult {
+  const arr = Array.isArray(buffer) ? buffer : Array.from(buffer);
+
+  if (arr.length < MIN_FRAME_SIZE) {
+    return { message: undefined, remainingBuffer: arr };
+  }
+
+  if (arr[0] !== FRAME_HEADER) {
+    const nextFrameStart = arr.indexOf(FRAME_HEADER, 1);
+    if (nextFrameStart === -1) {
+      return { message: undefined, remainingBuffer: [] };
+    }
+    return { message: undefined, remainingBuffer: arr.slice(nextFrameStart) };
+  }
+
+  if (arr.length < 5) {
+    return { message: undefined, remainingBuffer: arr };
+  }
+
+  const lenBuf = new Uint8Array(4);
+  lenBuf.set(arr.slice(1, 5), 0);
+  const length = new DataView(lenBuf.buffer).getUint32(0, true);
+
+  if (arr.length < MIN_FRAME_SIZE + length) {
+    return { message: undefined, remainingBuffer: arr };
+  }
+
+  const dataBytes = arr.slice(5, 5 + length);
+  const sumBuf = new Uint8Array(4);
+  sumBuf.set(arr.slice(5 + length, 9 + length), 0);
+  const checksum = new DataView(sumBuf.buffer).getUint32(0, true);
+  const calculatedChecksum = dataBytes.reduce((sum, byte) => sum + byte, 0) >>> 0;
+
+  if (checksum !== calculatedChecksum) {
+    return { message: undefined, remainingBuffer: arr.slice(9 + length) };
+  }
+
+  const message = utf8BytesToString(dataBytes);
+  const remainingBuffer = arr.slice(9 + length);
+  return { message, remainingBuffer };
+}

package/src/moonbridge-ipc/general/transport/interface/serial_message_channel.ts

@@ -0,0 +1,49 @@
+/**
+ * 串行消息通道抽象，对应 Flutter lib/general/transport/interface/serial_message_channel.dart。
+ * Socket / WebSocket 统一契约，供服务端与上层统一使用。
+ */
+
+/** 消息接收回调 */
+export type MessageReceiver<T> = (value: T) => void;
+
+/** 订阅选项，与 Flutter subscribe 参数对应 */
+export interface SerialMessageChannelSubscribeOptions {
+  onError?: (error: unknown) => void;
+  onDone?: () => void;
+  cancelOnError?: boolean;
+}
+
+/** 取消订阅（与 Flutter StreamSubscription 对应，JS 端可返回清理函数） */
+export type Unsubscribe = () => void;
+
+/** 地址信息（JS 端简化：无 InternetAddress，用 string 表示 host） */
+export interface SocketAddressLike {
+  address: string;
+  port: number;
+  remoteAddress: string;
+  remotePort: number;
+}
+
+/**
+ * 串行消息通道抽象：发送应用层消息（经帧编码）、关闭、销毁、订阅收消息。
+ * 实现类：WebSocketMessageChannel（Socket 在 JS 端不实现，仅占位）。
+ */
+export interface SerialMessageChannel extends SocketAddressLike {
+  /** 发送一条应用层消息（经帧编码后写入底层） */
+  sendMessage(message: string): Promise<boolean>;
+
+  /** 正常关闭连接 */
+  close(): Promise<void>;
+
+  /** 立即销毁连接并释放资源 */
+  destroy(): void;
+
+  /**
+   * 订阅收消息与错误/关闭。
+   * @returns 取消订阅函数（或 void）
+   */
+  subscribe(
+    onMessage: MessageReceiver<string> | undefined,
+    options?: SerialMessageChannelSubscribeOptions,
+  ): Unsubscribe | void;
+}

package/src/moonbridge-ipc/general/transport/interface/serial_message_channel_extension.ts

@@ -0,0 +1,45 @@
+/**
+ * SerialMessageChannel 的扩展方法，对应 Flutter lib/general/transport/interface/serial_message_channel_extension.dart。
+ * IPC 服务端发送方法（Socket/WebSocket 通道共用）。JS 以辅助函数形式导出。
+ */
+
+import { IpcMessageEncoder } from '../../encode/ipc_message_encoder';
+import { SerialMessageChannel } from './serial_message_channel';
+import { Response } from '../../message/response';
+import { Request } from '../../message/request';
+import { IpcSessionSetupResponse } from '../../message/session_setup';
+import { Event } from '../../message/event';
+import { Error } from '../../message/error';
+import { Ping } from '../../message/ping';
+import { Handshake } from '../../message/handshake';
+
+export async function sendResponse(channel: SerialMessageChannel, response: Response): Promise<boolean> {
+  return channel.sendMessage(IpcMessageEncoder.encodeResponse(response));
+}
+
+export async function sendRequest(channel: SerialMessageChannel, request: Request): Promise<boolean> {
+  return channel.sendMessage(IpcMessageEncoder.encodeRequest(request));
+}
+
+export async function sendSessionSetupResponse(
+  channel: SerialMessageChannel,
+  response: IpcSessionSetupResponse,
+): Promise<boolean> {
+  return channel.sendMessage(IpcMessageEncoder.encodeSessionSetupResponse(response));
+}
+
+export async function sendEvent(channel: SerialMessageChannel, event: Event): Promise<boolean> {
+  return channel.sendMessage(IpcMessageEncoder.encodeEvent(event));
+}
+
+export async function sendError(channel: SerialMessageChannel, error: Error): Promise<boolean> {
+  return channel.sendMessage(IpcMessageEncoder.encodeError(error));
+}
+
+export async function sendPing(channel: SerialMessageChannel, ping: Ping): Promise<boolean> {
+  return channel.sendMessage(IpcMessageEncoder.encodePing(ping));
+}
+
+export async function sendHandshake(channel: SerialMessageChannel, handshake: Handshake): Promise<boolean> {
+  return channel.sendMessage(IpcMessageEncoder.encodeHandshake(handshake));
+}

package/src/moonbridge-ipc/general/transport/interface/transport_client.ts

@@ -0,0 +1,44 @@
+/**
+ * IPC 传输客户端抽象，对应 Flutter lib/general/transport/interface/transport_client.dart TransportClient。
+ * 对外 API 与 Flutter 一致：connectWithServer、sendData、onMessage、onErrorAndClose、close、isClientConnected。
+ */
+
+/**
+ * IPC 传输客户端抽象
+ */
+export interface TransportClient {
+  /**
+  * 是否已连接到服务器
+  */
+  readonly isClientConnected: boolean;
+
+  /**
+   * 连接到服务器
+   * @returns 是否成功
+   */
+  connectWithServer(): Promise<boolean>;
+  /**
+   * 发送数据
+   * @param data 数据
+   * @returns 是否成功
+   */
+  sendData(data: string): Promise<boolean>;
+  /**
+   * 关闭连接
+   * @returns 是否成功
+   */
+  close(): Promise<void>;
+  /**
+   * 消息接收回调
+   * @param cb 回调函数
+   */
+  onMessage(cb: (data: string) => void): void;
+  /**
+   * 错误和关闭回调
+   * @param callbacks 回调函数
+   */
+  onErrorAndClose(callbacks: {
+    onError?: (err: unknown) => void;
+    onServerClose?: () => void
+  }): void;
+}

package/src/moonbridge-ipc/general/transport/interface/transport_client_extension.ts

@@ -0,0 +1,52 @@
+/**
+ * TransportClient 的扩展方法，对应 Flutter lib/general/transport/interface/transport_client_extension.dart。
+ * 用于 IPC 消息的编码发送（Socket/WebSocket 共用）。JS 无 extension 语法，以辅助函数形式导出。
+ */
+
+import { IpcMessageEncoder } from '../../encode/ipc_message_encoder';
+import { Handshake } from '../../message/handshake';
+import { Registration } from '../../message/registration';
+import { Unregistration } from '../../message/unregistration';
+import { Request } from '../../message/request';
+import { Response } from '../../message/response';
+import { Error } from '../../message/error';
+import { Event } from '../../message/event';
+import { IpcSessionSetupRequest } from '../../message/session_setup';
+import { Ping } from '../../message/ping';
+import { TransportClient } from './transport_client';
+
+export async function registerClient(client: TransportClient, registration: Registration): Promise<boolean> {
+  return client.sendData(IpcMessageEncoder.encodeRegistration(registration));
+}
+
+export async function unregisterClient(client: TransportClient, unregistration: Unregistration): Promise<boolean> {
+  return client.sendData(IpcMessageEncoder.encodeUnregistration(unregistration));
+}
+
+export async function sendRequest(client: TransportClient, request: Request): Promise<boolean> {
+  return client.sendData(IpcMessageEncoder.encodeRequest(request));
+}
+
+export async function sendResponse(client: TransportClient, response: Response): Promise<boolean> {
+  return client.sendData(IpcMessageEncoder.encodeResponse(response));
+}
+
+export async function sendError(client: TransportClient, error: Error): Promise<boolean> {
+  return client.sendData(IpcMessageEncoder.encodeError(error));
+}
+
+export async function postEvent(client: TransportClient, event: Event): Promise<boolean> {
+  return client.sendData(IpcMessageEncoder.encodeEvent(event));
+}
+
+export async function setupSession(client: TransportClient, sessionSetup: IpcSessionSetupRequest): Promise<boolean> {
+  return client.sendData(IpcMessageEncoder.encodeSessionSetupRequest(sessionSetup));
+}
+
+export async function sendPing(client: TransportClient, ping: Ping): Promise<boolean> {
+  return client.sendData(IpcMessageEncoder.encodePing(ping));
+}
+
+export async function sendHandshake(client: TransportClient, handshake: Handshake): Promise<boolean> {
+  return client.sendData(IpcMessageEncoder.encodeHandshake(handshake));
+}

package/src/moonbridge-ipc/general/transport/websocket/websocket_client.ts

@@ -0,0 +1,130 @@
+/**
+ * WebSocket 客户端，对应 Flutter lib/general/transport/websocket/websocket_client.dart WebSocketClient。
+ * 与 SocketClient 保持相同对外 API；内部使用 WebSocketMessageChannel，收发经帧编解码。
+ * Node 环境使用 ws，浏览器环境使用原生 WebSocket（per FR-028-009）。
+ */
+
+import { TransportClient } from '../interface/transport_client';
+import { logger } from '../../../utils/logger';
+import { isNodeEnv } from '../../../utils/env';
+import { WebSocketMessageChannel } from './websocket_message_channel';
+
+/**
+ * WebSocket 客户端
+ */
+export class WebSocketClient implements TransportClient {
+  private readonly _address: string;
+  private readonly _port: number;
+  private readonly _path: string;
+  private readonly _useTls: boolean;
+
+  private _channel: WebSocketMessageChannel | undefined = undefined;
+  private _isClientConnected = false;
+  private readonly _messageCallbacks: Array<(data: string) => void> = [];
+  private readonly _errorCallbacks: Array<(err: unknown) => void> = [];
+  private readonly _closeCallbacks: Array<() => void> = [];
+  private _unsubscribe: (() => void) | void;
+
+  constructor(address: string, port: number, path: string = '/', useTls: boolean = false) {
+    this._address = address;
+    this._port = port;
+    this._path = path;
+    this._useTls = useTls;
+    this._unsubscribe = undefined;
+  }
+
+  async connectWithServer(): Promise<boolean> {
+    if (this._useTls) {
+      logger.error('[WebSocket] wss 模式当前不支持（服务端未实现 TLS），请使用 ws');
+      return false;
+    }
+    const scheme = 'ws';
+    const url = `${scheme}://${this._address}:${this._port}${this._path}`;
+    logger.info('[WebSocket] 正在连接 ' + url);
+    try {
+      const ws = isNodeEnv()
+        ? (() => {
+          // eslint-disable-next-line @typescript-eslint/no-require-imports
+          const WebSocket = require('ws');
+          return new WebSocket(url) as WebSocket;
+        })()
+        : new window.WebSocket(url);
+      ws.binaryType = 'arraybuffer';
+      await new Promise<void>((resolve, reject) => {
+        ws.onopen = () => resolve();
+        ws.onerror = () => reject(new Error('WebSocket connection failed'));
+      });
+      this._channel = new WebSocketMessageChannel(ws, {
+        address: '0.0.0.0',
+        port: 0,
+        remoteAddress: this._address,
+        remotePort: this._port,
+        logger: undefined,
+      });
+      this._isClientConnected = true;
+      this._listen();
+      logger.info('[WebSocket] 已连接 ' + url);
+      return true;
+    } catch (e) {
+      logger.error(`[WebSocket] 连接到服务端异常 url=${url} error=${String(e)}`);
+      return false;
+    }
+  }
+
+  private _listen(): void {
+    if (this._channel == null || !this._isClientConnected) return;
+    this._unsubscribe = this._channel.subscribe(
+      (message: string) => {
+        for (const cb of this._messageCallbacks) {
+          // 解决一旦出现异常，后续消息无法处理的问题
+          try {
+            cb(message);
+          } catch (e) {
+            logger.error('[WebSocket] 消息回调异常，后续消息仍会处理: ' + String(e));
+          }
+        }
+      },
+      {
+        onError: (error) => {
+          logger.error('[WebSocket] 客户端监听到错误: ' + String(error));
+          this._errorCallbacks.forEach((cb) => cb(error));
+        },
+        onDone: () => {
+          this._isClientConnected = false;
+          this._closeCallbacks.forEach((cb) => cb());
+        },
+        cancelOnError: false,
+      },
+    );
+  }
+
+  async sendData(data: string): Promise<boolean> {
+    if (this._channel == null || !this._isClientConnected) {
+      logger.error('[WebSocket] 发送失败，当前与服务端连接已断开');
+      return false;
+    }
+    return this._channel.sendMessage(data);
+  }
+
+  onMessage(onMessage: (data: string) => void): void {
+    this._messageCallbacks.push(onMessage);
+  }
+
+  onErrorAndClose(callbacks: { onError?: (err: unknown) => void; onServerClose?: () => void }): void {
+    if (callbacks.onError) this._errorCallbacks.push(callbacks.onError);
+    if (callbacks.onServerClose) this._closeCallbacks.push(callbacks.onServerClose);
+  }
+
+  async close(): Promise<void> {
+    if (typeof this._unsubscribe === 'function') {
+      this._unsubscribe();
+    }
+    await this._channel?.close();
+    this._channel = undefined;
+    this._isClientConnected = false;
+  }
+
+  get isClientConnected(): boolean {
+    return this._isClientConnected;
+  }
+}

package/src/moonbridge-ipc/general/transport/websocket/websocket_message_channel.ts

@@ -0,0 +1,145 @@
+/**
+ * 基于 WebSocket 的 SerialMessageChannel 实现，对应 Flutter lib/general/transport/websocket/websocket_message_channel.dart。
+ * 复用 data_frame_codec 帧格式，以二进制帧收发，与 Flutter 端协议一致。
+ */
+
+import { encodeDataFrame, decodeDataFrame } from '../encode/data_frame_codec';
+import { SerialMessageChannel, SerialMessageChannelSubscribeOptions } from '../interface/serial_message_channel';
+import { AsyncLock } from '../../lock/async_lock';
+
+const FRAME_HEADER = 0x7e;
+
+/** 可选日志接口（与 Flutter Logger 简化对应） */
+export interface ChannelLogger {
+  log(level: string, message: string, meta?: { file?: string; func?: string }): void;
+}
+
+export interface WebSocketMessageChannelOptions {
+  address: string;
+  port: number;
+  remoteAddress: string;
+  remotePort: number;
+  logger?: ChannelLogger;
+}
+
+/**
+ * WebSocket 消息通道
+ */
+export class WebSocketMessageChannel implements SerialMessageChannel {
+  private readonly _ws: WebSocket;
+  private readonly _address: string;
+  private readonly _port: number;
+  private readonly _remoteAddress: string;
+  private readonly _remotePort: number;
+  private readonly _logger: ChannelLogger | undefined;
+  private readonly _lock = new AsyncLock();
+
+  constructor(
+    ws: WebSocket,
+    options: WebSocketMessageChannelOptions,
+  ) {
+    this._ws = ws;
+    this._address = options.address;
+    this._port = options.port;
+    this._remoteAddress = options.remoteAddress;
+    this._remotePort = options.remotePort;
+    this._logger = options.logger;
+  }
+
+  get address(): string {
+    return this._address;
+  }
+  get port(): number {
+    return this._port;
+  }
+  get remoteAddress(): string {
+    return this._remoteAddress;
+  }
+  get remotePort(): number {
+    return this._remotePort;
+  }
+
+  async sendMessage(message: string): Promise<boolean> {
+    await this._lock.lock();
+    try {
+      this._logger?.log('info', `[Send] 准备发送消息: ${message}`, { file: 'websocket_message_channel' });
+      this._ws.send(encodeDataFrame(message));
+      this._logger?.log('info', '[Send] 发送成功', { file: 'websocket_message_channel' });
+      return true;
+    } catch (e) {
+      this._logger?.log('error', `[Send] 发送失败: ${e}`, { file: 'websocket_message_channel' });
+      return false;
+    } finally {
+      this._lock.unlock();
+    }
+  }
+
+  async close(): Promise<void> {
+    this._ws.close();
+  }
+
+  destroy(): void {
+    this._ws.close();
+  }
+
+  subscribe(
+    onMessage: ((value: string) => void) | undefined,
+    options?: SerialMessageChannelSubscribeOptions,
+  ): () => void {
+    const buffer: number[] = [];
+    const onError = options?.onError;
+    const onDone = options?.onDone;
+
+    const onMessageHandler = (ev: MessageEvent): void => {
+      const data = ev.data;
+      this._logger?.log('debug', `[WebSocketMessageChannel] 收到消息 dataType=${typeof data} isBuffer=${typeof Buffer !== 'undefined' && Buffer.isBuffer?.(data)}`, {
+        file: 'websocket_message_channel',
+        func: 'onMessageHandler',
+      });
+      if (typeof data === 'string') {
+        buffer.push(...Array.from(new TextEncoder().encode(data)));
+      } else if (data instanceof ArrayBuffer) {
+        buffer.push(...new Uint8Array(data));
+      } else if (data instanceof Uint8Array || (typeof Buffer !== 'undefined' && Buffer.isBuffer(data))) {
+        buffer.push(...new Uint8Array(data as ArrayBuffer | ArrayLike<number>));
+      }
+      while (buffer.length >= 9) {
+        try {
+          const result = decodeDataFrame(buffer);
+          if (result.message != null) {
+            onMessage?.(result.message);
+            buffer.length = 0;
+            buffer.push(...result.remainingBuffer);
+          } else {
+            break;
+          }
+        } catch (e) {
+          this._logger?.log('fatal', `解码数据帧错误: ${e}`, {
+            file: 'websocket_message_channel',
+            func: 'subscribe',
+          });
+          const nextFrameStart = buffer.indexOf(FRAME_HEADER, 1);
+          if (nextFrameStart === -1) {
+            buffer.length = 0;
+          } else {
+            buffer.splice(0, nextFrameStart);
+          }
+        }
+      }
+    };
+
+    this._ws.addEventListener('message', onMessageHandler);
+    this._ws.addEventListener('error', (ev) => {
+      buffer.length = 0;
+      onError?.(ev);
+    });
+    this._ws.addEventListener('close', () => {
+      buffer.length = 0;
+      onDone?.();
+    });
+
+    return () => {
+      this._ws.removeEventListener('message', onMessageHandler);
+    };
+  }
+}