@lesomnus/grpc-dgram 0.0.1

package/dist/transport/port.mjs

@@ -0,0 +1,240 @@
+import { $ as unpack, F as Latch, G as noop, R as abortListener, c as decodeEnvelop, u as encodeEnvelop } from "../wire-BR8KiyRg.mjs";
+import { n as MessageTooLargeError, r as StatusError } from "../status-DZwMDWIn.mjs";
+import { n as Conn } from "../conn-DOmx4nbt.mjs";
+//#region src/transport/port/index.ts
+const DefaultMaxMessageSize = 0;
+const GOODBYE = /* @__PURE__ */ new Uint8Array(0);
+function wire(port, type, fn) {
+	if (typeof port.addEventListener === "function") {
+		port.addEventListener(type, fn);
+		return () => port.removeEventListener?.(type, fn);
+	}
+	if (type === "message") {
+		port.onmessage = fn;
+		return () => {
+			port.onmessage = null;
+		};
+	}
+	if (type === "messageerror") {
+		port.onmessageerror = fn;
+		return () => {
+			port.onmessageerror = null;
+		};
+	}
+	return noop;
+}
+function wakeAll(waiters) {
+	if (waiters.length === 0) return;
+	const ws = waiters.splice(0);
+	for (const w of ws) w();
+}
+var Port = class {
+	port;
+	max;
+	transferable;
+	dead = new Latch();
+	err;
+	closed = false;
+	rx = [];
+	rxWaiters = [];
+	detach = [];
+	constructor(port, o) {
+		this.port = port;
+		this.max = o.maxMessageSize ?? 0;
+		this.transferable = o.transfer ?? true;
+		this.detach.push(wire(port, "message", (ev) => this.onMessage(ev)));
+		this.detach.push(wire(port, "messageerror", noop));
+		this.detach.push(wire(port, "close", () => this.fail(void 0)));
+		port.start?.();
+	}
+	fail(err) {
+		if (!this.dead.tripped && this.err === void 0) this.err = err;
+		this.dead.trip();
+		wakeAll(this.rxWaiters);
+	}
+	closedErr() {
+		const e = new StatusError(14, `port: endpoint closed${causeDetail(this.err)}`);
+		if (this.err !== void 0) e.cause = this.err;
+		return e;
+	}
+	onMessage(ev) {
+		if (this.dead.tripped) return;
+		const data = ev.data;
+		if (data instanceof ArrayBuffer) this.rx.push(new Uint8Array(data));
+		else if (ArrayBuffer.isView(data)) this.rx.push(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+		else return;
+		wakeAll(this.rxWaiters);
+	}
+	async send(frames) {
+		const data = encodeEnvelop(frames);
+		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`port: ${data.length}-byte envelop over the ${this.max}-byte limit`);
+		if (this.dead.tripped) throw this.closedErr();
+		try {
+			this.post(data);
+		} catch (e) {
+			this.fail(e);
+			throw this.closedErr();
+		}
+	}
+	post(data) {
+		if (this.transferable && data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) try {
+			this.port.postMessage(data, [data.buffer]);
+			return;
+		} catch (e) {
+			if (data.byteLength === 0) throw e;
+		}
+		this.port.postMessage(data);
+	}
+	async pump(h, ctx) {
+		const dctl = new AbortController();
+		this.dead.wait().then(() => dctl.abort(this.closedErr()));
+		const dctx = {
+			...ctx,
+			signal: dctl.signal
+		};
+		for (;;) {
+			const data = this.rx.shift();
+			if (data !== void 0) {
+				if (data.length === 0) {
+					this.fail(void 0);
+					return;
+				}
+				let frames;
+				try {
+					frames = decodeEnvelop(data);
+				} catch {
+					continue;
+				}
+				await unpack(frames, h, dctx);
+				continue;
+			}
+			if (this.dead.tripped) return this.err;
+			await Promise.race([this.rxReadable(), this.dead.wait()]);
+		}
+	}
+	rxReadable() {
+		if (this.rx.length > 0) return Promise.resolve();
+		return new Promise((res) => this.rxWaiters.push(res));
+	}
+	close(cause) {
+		if (this.closed) return;
+		this.closed = true;
+		if (!this.dead.tripped) try {
+			this.port.postMessage(GOODBYE);
+		} catch {}
+		this.fail(cause);
+		if (this.port !== globalThis) try {
+			this.port.close?.();
+		} catch {}
+		for (const off of this.detach.splice(0)) off();
+	}
+};
+function causeDetail(err) {
+	if (err === void 0) return "";
+	if (err instanceof Error) return `: ${err.message}`;
+	return `: ${String(err)}`;
+}
+var PortTransport = class {
+	pt;
+	attached = false;
+	constructor(port, opts = {}) {
+		this.pt = new Port(port, opts);
+	}
+	reliable() {
+		return true;
+	}
+	attachConn(conn) {
+		if (this.attached) throw new Error("port: transport already attached to a Conn");
+		this.attached = true;
+		(async () => {
+			const err = await this.pt.pump(conn, {});
+			conn.close(err);
+			this.close();
+		})();
+	}
+	handle(f) {
+		return this.pt.send([f]);
+	}
+	close(cause) {
+		this.pt.close(cause);
+	}
+};
+function dialWorker(worker, opts = {}) {
+	const ch = new MessageChannel();
+	let tx;
+	try {
+		tx = new PortTransport(ch.port1, opts);
+		const conn = new Conn(tx, opts);
+		worker.postMessage(opts.message ?? { drpc: "serve" }, [ch.port2]);
+		return conn;
+	} catch (e) {
+		tx?.close(e);
+		ch.port1.close();
+		ch.port2.close();
+		throw e;
+	}
+}
+var PortGateway = class {
+	o;
+	next = 0;
+	ports = /* @__PURE__ */ new Map();
+	peers = /* @__PURE__ */ new Map();
+	constructor(opts = {}) {
+		this.o = opts;
+	}
+	reliable() {
+		return true;
+	}
+	bind(port) {
+		this.bindPort(port);
+	}
+	bindPort(port) {
+		let b = this.ports.get(port);
+		if (b === void 0) {
+			b = {
+				pt: new Port(port, this.o),
+				key: ++this.next,
+				served: false
+			};
+			this.ports.set(port, b);
+			this.peers.set(b.key, b.pt);
+		}
+		return b;
+	}
+	drop(port, b) {
+		b.pt.close();
+		this.ports.delete(port);
+		this.peers.delete(b.key);
+	}
+	async servePeer(server, port, opts = {}) {
+		const b = this.bindPort(port);
+		if (b.served) throw new Error("port: port already served");
+		b.served = true;
+		let disposeAbort = noop;
+		if (opts.signal !== void 0) if (opts.signal.aborted) b.pt.close();
+		else disposeAbort = abortListener(opts.signal, () => b.pt.close());
+		try {
+			const err = await b.pt.pump(server, {
+				peer: b.key,
+				reliable: true
+			});
+			server.disconnectPeer(b.key, err);
+			return err;
+		} finally {
+			disposeAbort();
+			this.drop(port, b);
+		}
+	}
+	handle(f, ctx = {}) {
+		const key = ctx.peer;
+		if (typeof key !== "number") return Promise.reject(/* @__PURE__ */ new Error(`port: no gateway peer in context (got ${String(key)})`));
+		const pt = this.peers.get(key);
+		if (pt === void 0) return Promise.reject(/* @__PURE__ */ new Error(`port: peer ${key} is disconnected`));
+		return pt.send([f]);
+	}
+	close() {
+		for (const b of [...this.ports.values()]) b.pt.close();
+	}
+};
+//#endregion
+export { DefaultMaxMessageSize, PortGateway, PortTransport, dialWorker };

package/dist/transport/protobuf-es.d.mts

@@ -0,0 +1,19 @@
+import { c as ServerStreamingDesc, l as UnaryDesc, r as ClientStreamingDesc, t as BidiDesc } from "../desc-BMF2FBqk.mjs";
+import { DescMessage, DescMethod, MessageShape } from "@bufbuild/protobuf";
+import { GenService, GenServiceMethods } from "@bufbuild/protobuf/codegenv2";
+//#region src/transport/protobuf-es/index.d.ts
+type MethodLike<K extends DescMethod['methodKind'], I extends DescMessage, O extends DescMessage> = {
+  readonly methodKind: K;
+  readonly input: I;
+  readonly output: O;
+  readonly name: string;
+  readonly parent: {
+    readonly typeName: string;
+  };
+};
+type MethodDescFor<M> = M extends MethodLike<infer K, infer I, infer O> ? K extends 'unary' ? UnaryDesc<MessageShape<I>, MessageShape<O>> : K extends 'server_streaming' ? ServerStreamingDesc<MessageShape<I>, MessageShape<O>> : K extends 'client_streaming' ? ClientStreamingDesc<MessageShape<I>, MessageShape<O>> : BidiDesc<MessageShape<I>, MessageShape<O>> : never;
+declare function fromMethod<K extends DescMethod['methodKind'], I extends DescMessage, O extends DescMessage>(method: MethodLike<K, I, O>): MethodDescFor<MethodLike<K, I, O>>;
+type ServiceDescs<S extends GenService<GenServiceMethods>> = { [K in keyof S['method']]: MethodDescFor<S['method'][K]>; };
+declare function fromService<S extends GenService<GenServiceMethods>>(service: S): ServiceDescs<S>;
+//#endregion
+export { ServiceDescs, fromMethod, fromService };

package/dist/transport/protobuf-es.mjs

@@ -0,0 +1,27 @@
+import { fromBinary, toBinary } from "@bufbuild/protobuf";
+//#region src/transport/protobuf-es/index.ts
+function codecFor(schema) {
+	return {
+		marshal: (v) => toBinary(schema, v),
+		unmarshal: (b) => fromBinary(schema, b)
+	};
+}
+function fromMethod(method) {
+	const kind = method.methodKind;
+	return {
+		path: `/${method.parent.typeName}/${method.name}`,
+		clientStreams: kind === "client_streaming" || kind === "bidi_streaming",
+		serverStreams: kind === "server_streaming" || kind === "bidi_streaming",
+		request: codecFor(method.input),
+		response: codecFor(method.output),
+		requestSchema: method.input,
+		responseSchema: method.output
+	};
+}
+function fromService(service) {
+	const out = {};
+	for (const key of Object.keys(service.method)) out[key] = fromMethod(service.method[key]);
+	return out;
+}
+//#endregion
+export { fromMethod, fromService };

package/dist/transport/webrtc.d.mts

@@ -0,0 +1,56 @@
+import { O as Frame, h as FrameContext, n as Conn } from "../conn-DTWG9vIx.mjs";
+import { r as Server } from "../server-xIr1mwqq.mjs";
+//#region src/transport/webrtc/index.d.ts
+declare const DefaultMaxMessageSizeUnreliable = 1200;
+declare const DefaultMaxMessageSizeReliable: number;
+declare const DefaultMaxBufferedAmount: number;
+declare const DefaultSendStallTimeoutMs = 30000;
+interface DataChannelLike {
+  readonly readyState: string;
+  readonly ordered: boolean;
+  readonly maxRetransmits?: number | null;
+  readonly maxPacketLifeTime?: number | null;
+  readonly bufferedAmount: number;
+  bufferedAmountLowThreshold: number;
+  binaryType: string;
+  send(data: Uint8Array): void;
+  close(): void;
+  addEventListener?(type: string, listener: (ev: never) => void): void;
+  onopen?: ((ev: unknown) => void) | null;
+  onclose?: ((ev: unknown) => void) | null;
+  onerror?: ((ev: unknown) => void) | null;
+  onmessage?: ((ev: unknown) => void) | null;
+  onbufferedamountlow?: ((ev: unknown) => void) | null;
+}
+interface DataChannelOptions {
+  maxMessageSize?: number;
+  maxBufferedAmount?: number;
+  sendStallTimeoutMs?: number;
+}
+declare function channelReliable(dc: DataChannelLike): boolean;
+declare class DataChannelTransport {
+  private readonly ch;
+  private attached;
+  private closed;
+  constructor(dc: DataChannelLike, opts?: DataChannelOptions);
+  reliable(): boolean;
+  attachConn(conn: Conn): void;
+  handle(f: Frame, ctx?: FrameContext): Promise<void>;
+  close(): void;
+}
+declare class DataChannelGateway {
+  private readonly o;
+  private next;
+  private readonly chans;
+  private readonly peers;
+  constructor(opts?: DataChannelOptions);
+  bind(dc: DataChannelLike): void;
+  private bindChannel;
+  private drop;
+  servePeer(server: Server, dc: DataChannelLike, opts?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  handle(f: Frame, ctx?: FrameContext): Promise<void>;
+}
+//#endregion
+export { DataChannelGateway, DataChannelLike, DataChannelOptions, DataChannelTransport, DefaultMaxBufferedAmount, DefaultMaxMessageSizeReliable, DefaultMaxMessageSizeUnreliable, DefaultSendStallTimeoutMs, channelReliable };

package/dist/transport/webrtc.mjs

@@ -0,0 +1,240 @@
+import { $ as unpack, F as Latch, G as noop, R as abortListener, X as unrefTimer, c as decodeEnvelop, u as encodeEnvelop } from "../wire-BR8KiyRg.mjs";
+import { n as MessageTooLargeError } from "../status-DZwMDWIn.mjs";
+//#region src/transport/webrtc/index.ts
+const DefaultMaxMessageSizeUnreliable = 1200;
+const DefaultMaxMessageSizeReliable = 16 * 1024;
+const DefaultMaxBufferedAmount = 1 << 20;
+const DefaultSendStallTimeoutMs = 3e4;
+function channelReliable(dc) {
+	return dc.ordered && dc.maxRetransmits == null && dc.maxPacketLifeTime == null;
+}
+function wire(dc, type, fn) {
+	if (typeof dc.addEventListener === "function") dc.addEventListener(type, fn);
+	else dc[`on${type}`] = fn;
+}
+var Channel = class {
+	dc;
+	reliable;
+	max;
+	high;
+	stallMs;
+	opened = new Latch();
+	dead = new Latch();
+	err;
+	rx = [];
+	rxWaiters = [];
+	bufLowWaiters = [];
+	constructor(dc, reliable, o) {
+		this.dc = dc;
+		this.reliable = reliable;
+		this.max = o.maxMessageSize ?? (reliable ? 16384 : 1200);
+		this.high = o.maxBufferedAmount ?? 1048576;
+		this.stallMs = o.sendStallTimeoutMs ?? 3e4;
+		dc.binaryType = "arraybuffer";
+		wire(dc, "open", () => this.opened.trip());
+		wire(dc, "error", (ev) => this.fail(ev?.error ?? ev));
+		wire(dc, "close", () => this.fail(void 0));
+		if (this.high > 0) {
+			dc.bufferedAmountLowThreshold = Math.floor(this.high / 2);
+			wire(dc, "bufferedamountlow", () => wakeAll(this.bufLowWaiters));
+		}
+		wire(dc, "message", (ev) => this.onMessage(ev));
+		if (dc.readyState === "open") this.opened.trip();
+		else if (dc.readyState === "closed" || dc.readyState === "closing") this.fail(void 0);
+	}
+	fail(err) {
+		if (!this.dead.tripped && this.err === void 0) this.err = err;
+		this.dead.trip();
+		wakeAll(this.bufLowWaiters);
+		wakeAll(this.rxWaiters);
+	}
+	deathErr() {
+		return this.err;
+	}
+	closedErr() {
+		const e = /* @__PURE__ */ new Error("webrtc: data channel closed");
+		if (this.err !== void 0) e.cause = this.err;
+		return e;
+	}
+	onMessage(ev) {
+		const data = ev.data;
+		if (data instanceof ArrayBuffer) this.rx.push(new Uint8Array(data));
+		else if (data instanceof Uint8Array) this.rx.push(data);
+		else return;
+		wakeAll(this.rxWaiters);
+	}
+	async send(frames, signal) {
+		const data = encodeEnvelop(frames);
+		if (this.max > 0 && data.length > this.max) throw new MessageTooLargeError(`webrtc: ${data.length}-byte envelop over the ${this.max}-byte limit`);
+		const stalled = new Latch();
+		let stallTimer;
+		if (this.stallMs > 0) {
+			stallTimer = setTimeout(() => stalled.trip(), this.stallMs);
+			unrefTimer(stallTimer);
+		}
+		let disposeAbort = noop;
+		const signalAborted = new Latch();
+		if (signal !== void 0) if (signal.aborted) signalAborted.trip();
+		else disposeAbort = abortListener(signal, () => signalAborted.trip());
+		try {
+			while (!this.opened.tripped) {
+				await Promise.race([
+					this.opened.wait(),
+					stalled.wait(),
+					this.dead.wait(),
+					signalAborted.wait()
+				]);
+				if (this.opened.tripped) break;
+				if (this.dead.tripped) throw this.closedErr();
+				if (stalled.tripped) {
+					const err = /* @__PURE__ */ new Error(`webrtc: send stalled: channel not open within ${this.stallMs}ms`);
+					this.fail(err);
+					throw err;
+				}
+				if (signalAborted.tripped) throw new Error("webrtc: send aborted");
+			}
+			while (this.high > 0 && this.dc.bufferedAmount >= this.high) {
+				if (this.dead.tripped) throw this.closedErr();
+				const low = new Promise((res) => this.bufLowWaiters.push(res));
+				await Promise.race([
+					low,
+					stalled.wait(),
+					this.dead.wait(),
+					signalAborted.wait()
+				]);
+				if (this.dead.tripped) throw this.closedErr();
+				if (stalled.tripped) {
+					const err = /* @__PURE__ */ new Error(`webrtc: send stalled at the buffered-amount mark for ${this.stallMs}ms`);
+					this.fail(err);
+					throw err;
+				}
+				if (signalAborted.tripped) throw new Error("webrtc: send aborted");
+			}
+			if (this.dead.tripped) throw this.closedErr();
+			this.dc.send(data);
+		} finally {
+			if (stallTimer !== void 0) clearTimeout(stallTimer);
+			disposeAbort();
+		}
+	}
+	async pump(h, ctx) {
+		const dctl = new AbortController();
+		this.dead.wait().then(() => dctl.abort(this.closedErr()));
+		const dctx = {
+			...ctx,
+			signal: dctl.signal
+		};
+		for (;;) {
+			const data = this.rx.shift();
+			if (data !== void 0) {
+				let frames;
+				try {
+					frames = decodeEnvelop(data);
+				} catch {
+					continue;
+				}
+				await unpack(frames, h, dctx);
+				continue;
+			}
+			if (this.dead.tripped) return this.err;
+			await Promise.race([this.rxReadable(), this.dead.wait()]);
+		}
+	}
+	rxReadable() {
+		if (this.rx.length > 0) return Promise.resolve();
+		return new Promise((res) => this.rxWaiters.push(res));
+	}
+};
+function wakeAll(waiters) {
+	if (waiters.length === 0) return;
+	const ws = waiters.splice(0);
+	for (const w of ws) w();
+}
+var DataChannelTransport = class {
+	ch;
+	attached = false;
+	closed = false;
+	constructor(dc, opts = {}) {
+		this.ch = new Channel(dc, channelReliable(dc), opts);
+	}
+	reliable() {
+		return this.ch.reliable;
+	}
+	attachConn(conn) {
+		if (this.attached) throw new Error("webrtc: transport already attached to a Conn");
+		this.attached = true;
+		(async () => {
+			const err = await this.ch.pump(conn, {});
+			conn.close(err);
+		})();
+	}
+	handle(f, ctx = {}) {
+		return this.ch.send([f], ctx.signal);
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.ch.fail(void 0);
+		try {
+			this.ch.dc.close();
+		} catch {}
+	}
+};
+var DataChannelGateway = class {
+	o;
+	next = 0;
+	chans = /* @__PURE__ */ new Map();
+	peers = /* @__PURE__ */ new Map();
+	constructor(opts = {}) {
+		this.o = opts;
+	}
+	bind(dc) {
+		this.bindChannel(dc);
+	}
+	bindChannel(dc) {
+		let b = this.chans.get(dc);
+		if (b === void 0) {
+			b = {
+				ch: new Channel(dc, channelReliable(dc), this.o),
+				key: ++this.next,
+				served: false
+			};
+			this.chans.set(dc, b);
+			this.peers.set(b.key, b.ch);
+		}
+		return b;
+	}
+	drop(dc, b) {
+		b.ch.fail(void 0);
+		this.chans.delete(dc);
+		this.peers.delete(b.key);
+	}
+	async servePeer(server, dc, opts = {}) {
+		const b = this.bindChannel(dc);
+		if (b.served) throw new Error("webrtc: channel already served");
+		b.served = true;
+		let disposeAbort = noop;
+		if (opts.signal !== void 0) if (opts.signal.aborted) b.ch.fail(void 0);
+		else disposeAbort = abortListener(opts.signal, () => b.ch.fail(void 0));
+		try {
+			const err = await b.ch.pump(server, {
+				peer: b.key,
+				reliable: b.ch.reliable
+			});
+			server.disconnectPeer(b.key, err);
+			return err;
+		} finally {
+			disposeAbort();
+			this.drop(dc, b);
+		}
+	}
+	handle(f, ctx = {}) {
+		const key = ctx.peer;
+		if (typeof key !== "number") return Promise.reject(/* @__PURE__ */ new Error(`webrtc: no gateway peer in context (got ${String(key)})`));
+		const ch = this.peers.get(key);
+		if (ch === void 0) return Promise.reject(/* @__PURE__ */ new Error(`webrtc: peer ${key} is gone`));
+		return ch.send([f], ctx.signal);
+	}
+};
+//#endregion
+export { DataChannelGateway, DataChannelTransport, DefaultMaxBufferedAmount, DefaultMaxMessageSizeReliable, DefaultMaxMessageSizeUnreliable, DefaultSendStallTimeoutMs, channelReliable };

package/dist/transport/websocket.d.mts

@@ -0,0 +1,59 @@
+import { O as Frame, _ as TransportInfo, g as FrameHandler, h as FrameContext, m as ConnAttacher, n as Conn, r as ConnOptions } from "../conn-DTWG9vIx.mjs";
+import { r as Server } from "../server-xIr1mwqq.mjs";
+//#region src/transport/websocket/index.d.ts
+declare const DefaultMaxMessageSize = 0;
+declare const DefaultMaxBufferedAmount: number;
+declare const DefaultKeepaliveIntervalMs = 20000;
+declare const DefaultKeepaliveTimeoutMs = 30000;
+interface WebSocketLike {
+  readonly readyState: number;
+  readonly bufferedAmount: number;
+  binaryType: string;
+  send(data: Uint8Array): void;
+  close(code?: number, reason?: string): void;
+  addEventListener?(type: string, listener: (ev: never) => void): void;
+  onopen?: ((ev: unknown) => void) | null;
+  onclose?: ((ev: unknown) => void) | null;
+  onerror?: ((ev: unknown) => void) | null;
+  onmessage?: ((ev: unknown) => void) | null;
+  ping?(data?: unknown): void;
+  on?(type: string, listener: (...args: never[]) => void): void;
+}
+interface WebSocketOptions {
+  maxMessageSize?: number;
+  maxBufferedAmount?: number;
+  sendStallTimeoutMs?: number;
+  keepaliveIntervalMs?: number;
+  keepaliveTimeoutMs?: number;
+}
+declare class WebSocketTransport implements FrameHandler, TransportInfo, ConnAttacher {
+  private readonly sock;
+  private attached;
+  private closed;
+  constructor(ws: WebSocketLike, opts?: WebSocketOptions);
+  reliable(): boolean;
+  attachConn(conn: Conn): void;
+  handle(f: Frame, ctx?: FrameContext): Promise<void>;
+  close(): void;
+}
+declare class WebSocketGateway implements FrameHandler, TransportInfo {
+  private readonly o;
+  private next;
+  private readonly socks;
+  private readonly peers;
+  constructor(opts?: WebSocketOptions);
+  reliable(): boolean;
+  bind(ws: WebSocketLike): void;
+  private bindSocket;
+  private drop;
+  servePeer(server: Server, ws: WebSocketLike, opts?: {
+    signal?: AbortSignal;
+  }): Promise<unknown>;
+  handle(f: Frame, ctx?: FrameContext): Promise<void>;
+  close(): void;
+}
+declare function dialWebSocket(url: string, opts?: ConnOptions & WebSocketOptions & {
+  protocols?: string | string[];
+}): Conn;
+//#endregion
+export { DefaultKeepaliveIntervalMs, DefaultKeepaliveTimeoutMs, DefaultMaxBufferedAmount, DefaultMaxMessageSize, WebSocketGateway, WebSocketLike, WebSocketOptions, WebSocketTransport, dialWebSocket };