roxxie-proxy-u-prod 0.1.0

package/source/packages/roxxie-transport/src/connection.ts

@@ -0,0 +1,767 @@
+import {
+	C2SRequestTypes,
+	MAX_CHUNK_SIZE,
+	PROTOCOL_VERSION,
+	S2C_HELLO_ERR,
+	S2C_HELLO_OK,
+	S2CRequestTypes,
+	assertHeaderList,
+	decodeFrame,
+	decodeJSON,
+	decodeText,
+	encodeClientHello,
+	encodeFrame,
+	encodeJSONFrame,
+	type BinaryTransport,
+	type C2SWSOpenPayload,
+	type HeaderList,
+	type HTTPRequestPayload,
+	type HTTPResponsePayload,
+	type PingPayload,
+	type S2CWSOpenPayload,
+	type WSClosePayload,
+	type WSErrorPayload,
+} from "roxxie-transports-adrift-protocol";
+
+export const MAX_PROXY_WEBSOCKET_MESSAGE_BYTES = 16 * 1024 * 1024;
+
+export interface ConnectionResponse {
+	body: ReadableStream<Uint8Array>;
+	headers: [string, string][];
+	status: number;
+	statusText: string;
+}
+
+export interface SocketCallbacks {
+	onopen(protocol: string, extensions: string): void;
+	onmessage(data: ArrayBuffer | string): void;
+	onclose(code: number, reason: string): void;
+	onerror(message: string): void;
+}
+
+export interface MultiplexedSocket {
+	readonly sequence: number;
+	send(data: Blob | ArrayBuffer | string): void;
+	close(code?: number, reason?: string): void;
+}
+
+interface PendingHTTP {
+	resolve: (response: ConnectionResponse) => void;
+	reject: (error: unknown) => void;
+	controller?: ReadableStreamDefaultController<Uint8Array>;
+	responseStarted: boolean;
+	responseSettled: boolean;
+	cancelled: boolean;
+	removeAbort?: () => void;
+}
+
+interface MessageAssembly {
+	kind: "text" | "binary";
+	chunks: Uint8Array[];
+	size: number;
+}
+
+interface PendingSocket {
+	callbacks: SocketCallbacks;
+	assembly?: MessageAssembly;
+	sendQueue: Promise<void>;
+	closing: boolean;
+	closed: boolean;
+}
+
+interface PendingPing {
+	nonce: string;
+	startedAt: number;
+	resolve: (roundTripMs: number) => void;
+	reject: (error: unknown) => void;
+	timer: ReturnType<typeof setTimeout>;
+}
+
+class VirtualSocketError extends Error {
+	constructor(
+		message: string,
+		readonly closeCode: number
+	) {
+		super(message);
+		this.name = "VirtualSocketError";
+	}
+}
+
+function asError(reason: unknown, fallback: string): Error {
+	return reason instanceof Error
+		? reason
+		: new Error(reason === undefined ? fallback : String(reason));
+}
+
+function abortError(): DOMException {
+	return new DOMException("The proxy request was aborted", "AbortError");
+}
+
+function callSafely(callback: () => void): void {
+	try {
+		callback();
+	} catch (error) {
+		console.error("A Roxxie proxy callback threw", error);
+	}
+}
+
+function randomNonce(): string {
+	const bytes = new Uint8Array(16);
+	crypto.getRandomValues(bytes);
+	return Array.from(bytes, (value) => value.toString(16).padStart(2, "0")).join(
+		""
+	);
+}
+
+function validateResponsePayload(value: unknown): HTTPResponsePayload {
+	if (value === null || typeof value !== "object") {
+		throw new Error("Node sent an invalid HTTP response header");
+	}
+	const result = value as Partial<HTTPResponsePayload>;
+	if (
+		typeof result.status !== "number" ||
+		!Number.isInteger(result.status) ||
+		result.status < 100 ||
+		result.status > 999 ||
+		typeof result.statusText !== "string" ||
+		result.headers === undefined
+	) {
+		throw new Error("Node sent an invalid HTTP response header");
+	}
+	assertHeaderList(result.headers);
+	return result as HTTPResponsePayload;
+}
+
+function validateSocketOpen(value: unknown): S2CWSOpenPayload {
+	if (value === null || typeof value !== "object") {
+		throw new Error("Node sent an invalid WebSocket open response");
+	}
+	const result = value as Partial<S2CWSOpenPayload>;
+	if (
+		typeof result.protocol !== "string" ||
+		typeof result.extensions !== "string"
+	) {
+		throw new Error("Node sent an invalid WebSocket open response");
+	}
+	return result as S2CWSOpenPayload;
+}
+
+function validateSocketClose(value: unknown): WSClosePayload {
+	if (value === null || typeof value !== "object") {
+		throw new Error("Node sent an invalid WebSocket close response");
+	}
+	const result = value as Partial<WSClosePayload>;
+	if (
+		typeof result.code !== "number" ||
+		!Number.isInteger(result.code) ||
+		typeof result.reason !== "string"
+	) {
+		throw new Error("Node sent an invalid WebSocket close response");
+	}
+	return result as WSClosePayload;
+}
+
+function concatenate(chunks: readonly Uint8Array[], size: number): Uint8Array {
+	const result = new Uint8Array(size);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return result;
+}
+
+async function bodyByteStream(
+	body: BodyInit
+): Promise<ReadableStream<Uint8Array>> {
+	const stream = new Response(body).body;
+	if (stream === null) throw new Error("Unable to encode proxy request body");
+	return stream;
+}
+
+export class RoxxieConnection {
+	private readonly http = new Map<number, PendingHTTP>();
+	private readonly ignoredHTTP = new Map<number, number>();
+	private readonly sockets = new Map<number, PendingSocket>();
+	private readonly pings = new Map<number, PendingPing>();
+	private sendQueue: Promise<void> = Promise.resolve();
+	private nextSequence = 1;
+	private failed = false;
+	private handshakeComplete = false;
+	private handshakeResolve: (() => void) | undefined;
+	private handshakeReject: ((error: unknown) => void) | undefined;
+	private failureHandler: ((error: Error) => void) | undefined;
+
+	private constructor(private readonly binary: BinaryTransport) {
+		binary.ondata = (data) => this.handleData(data);
+		binary.onclose = (reason) =>
+			this.fail(asError(reason, "Proxy transport closed"));
+	}
+
+	static async create(
+		binary: BinaryTransport,
+		handshakeTimeoutMs = 5_000
+	): Promise<RoxxieConnection> {
+		const connection = new RoxxieConnection(binary);
+		let timer: ReturnType<typeof setTimeout> | undefined;
+		const handshake = new Promise<void>((resolve, reject) => {
+			connection.handshakeResolve = resolve;
+			connection.handshakeReject = reject;
+			timer = setTimeout(
+				() =>
+					reject(
+						new Error(
+							`Protocol handshake timed out after ${handshakeTimeoutMs} ms`
+						)
+					),
+				handshakeTimeoutMs
+			);
+		});
+		try {
+			await connection.sendRaw(encodeClientHello());
+			await handshake;
+			return connection;
+		} catch (error) {
+			connection.close(error);
+			throw error;
+		} finally {
+			if (timer !== undefined) clearTimeout(timer);
+			connection.handshakeResolve = undefined;
+			connection.handshakeReject = undefined;
+		}
+	}
+
+	get ready(): boolean {
+		return this.handshakeComplete && !this.failed;
+	}
+
+	setFailureHandler(handler: (error: Error) => void): void {
+		this.failureHandler = handler;
+	}
+
+	/** Measures an application-level round trip over the active data channel. */
+	async ping(timeoutMs = 3_000): Promise<number> {
+		this.assertReady();
+		if (!Number.isFinite(timeoutMs) || timeoutMs < 1 || timeoutMs > 120_000) {
+			throw new TypeError("Ping timeout must be between 1 and 120000 ms");
+		}
+		const sequence = this.allocateSequence();
+		const nonce = randomNonce();
+		const roundTrip = new Promise<number>((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.fail(new Error(`Protocol ping timed out after ${timeoutMs} ms`));
+			}, timeoutMs);
+			this.pings.set(sequence, {
+				nonce,
+				startedAt: performance.now(),
+				resolve,
+				reject,
+				timer,
+			});
+		});
+
+		try {
+			await this.sendFrame(
+				encodeJSONFrame(sequence, C2SRequestTypes.Ping, { nonce })
+			);
+		} catch (error) {
+			this.fail(error);
+		}
+		return roundTrip;
+	}
+
+	async request(
+		remote: URL,
+		method: string,
+		body: BodyInit | null | undefined,
+		headers: HeaderList,
+		signal?: AbortSignal
+	): Promise<ConnectionResponse> {
+		this.assertReady();
+		if (signal?.aborted === true) throw abortError();
+		assertHeaderList(headers);
+		const sequence = this.allocateSequence();
+		const response = new Promise<ConnectionResponse>((resolve, reject) => {
+			const pending: PendingHTTP = {
+				resolve,
+				reject,
+				responseStarted: false,
+				responseSettled: false,
+				cancelled: false,
+			};
+			if (signal !== undefined) {
+				const onAbort = () => this.cancelRequest(sequence, true);
+				signal.addEventListener("abort", onAbort, { once: true });
+				pending.removeAbort = () =>
+					signal.removeEventListener("abort", onAbort);
+			}
+			this.http.set(sequence, pending);
+		});
+
+		const start: HTTPRequestPayload = {
+			method,
+			requestHeaders: headers,
+			remote: remote.href,
+			hasBody: body != null,
+		};
+		try {
+			await this.sendFrame(
+				encodeJSONFrame(sequence, C2SRequestTypes.HTTPRequestStart, start)
+			);
+		} catch (error) {
+			this.fail(error);
+			return response;
+		}
+
+		void this.sendRequestBody(sequence, body, signal).catch(
+			(error: unknown) => {
+				if (signal?.aborted !== true) this.fail(error);
+			}
+		);
+		return response;
+	}
+
+	openSocket(
+		url: URL,
+		protocols: string[],
+		requestHeaders: HeaderList,
+		callbacks: SocketCallbacks
+	): MultiplexedSocket {
+		this.assertReady();
+		assertHeaderList(requestHeaders);
+		const sequence = this.allocateSequence();
+		const state: PendingSocket = {
+			callbacks,
+			sendQueue: Promise.resolve(),
+			closing: false,
+			closed: false,
+		};
+		this.sockets.set(sequence, state);
+		const payload: C2SWSOpenPayload = {
+			url: url.href,
+			protocols: [...protocols],
+			requestHeaders,
+		};
+		void this.sendFrame(
+			encodeJSONFrame(sequence, C2SRequestTypes.WSOpen, payload)
+		).catch((error: unknown) =>
+			this.socketError(sequence, asError(error, "Unable to open socket"))
+		);
+
+		return {
+			sequence,
+			send: (data) => {
+				if (state.closing || state.closed) {
+					throw new Error("Proxy socket is closed");
+				}
+				state.sendQueue = state.sendQueue
+					.then(async () => this.sendSocketMessage(sequence, data))
+					.catch((error: unknown) => {
+						const resolved = asError(error, "Socket send failed");
+						this.socketError(
+							sequence,
+							resolved,
+							error instanceof VirtualSocketError ? error.closeCode : 1011
+						);
+					});
+			},
+			close: (code = 1000, reason = "") => {
+				if (state.closing || state.closed) return;
+				state.closing = true;
+				const payload: WSClosePayload = { code, reason };
+				state.sendQueue = state.sendQueue
+					.then(async () => {
+						if (this.sockets.get(sequence) !== state || state.closed) return;
+						await this.sendFrame(
+							encodeJSONFrame(sequence, C2SRequestTypes.WSClose, payload)
+						);
+					})
+					.catch((error: unknown) =>
+						this.socketError(sequence, asError(error, "Socket close failed"))
+					);
+			},
+		};
+	}
+
+	close(reason?: unknown): void {
+		if (this.failed) return;
+		this.fail(asError(reason, "Proxy connection closed"));
+	}
+
+	private async sendRequestBody(
+		sequence: number,
+		body: BodyInit | null | undefined,
+		signal?: AbortSignal
+	): Promise<void> {
+		const wasAborted = () => signal?.aborted === true;
+		if (body != null) {
+			const reader = (await bodyByteStream(body)).getReader();
+			const cancelReader = () => {
+				void reader.cancel(abortError()).catch(() => undefined);
+			};
+			signal?.addEventListener("abort", cancelReader, { once: true });
+			try {
+				for (;;) {
+					if (wasAborted()) return;
+					const { done, value } = await reader.read();
+					if (done) break;
+					if (wasAborted()) return;
+					for (
+						let offset = 0;
+						offset < value.byteLength;
+						offset += MAX_CHUNK_SIZE
+					) {
+						const chunk = value.subarray(offset, offset + MAX_CHUNK_SIZE);
+						await this.sendFrame(
+							encodeFrame(sequence, C2SRequestTypes.HTTPRequestChunk, chunk)
+						);
+					}
+				}
+			} finally {
+				signal?.removeEventListener("abort", cancelReader);
+			}
+		}
+		if (wasAborted()) return;
+		await this.sendFrame(encodeFrame(sequence, C2SRequestTypes.HTTPRequestEnd));
+	}
+
+	private cancelRequest(sequence: number, errorStream: boolean): void {
+		const pending = this.http.get(sequence);
+		if (pending === undefined || pending.cancelled) return;
+		pending.cancelled = true;
+		pending.removeAbort?.();
+		const error = abortError();
+		if (!pending.responseSettled) {
+			pending.responseSettled = true;
+			pending.reject(error);
+		} else if (errorStream && pending.controller !== undefined) {
+			try {
+				pending.controller.error(error);
+			} catch {
+				// The consumer may already have closed its side of the stream.
+			}
+		}
+		void this.sendFrame(
+			encodeFrame(sequence, C2SRequestTypes.HTTPRequestAbort)
+		).catch((sendError: unknown) => this.fail(sendError));
+		this.http.delete(sequence);
+		// Frames already queued by the node can still arrive after its abort
+		// handler runs. Quarantine the sequence beyond the node's 60 s upstream
+		// timeout so those frames cannot collide with a newly allocated request.
+		this.ignoredHTTP.set(sequence, Date.now() + 120_000);
+	}
+
+	private async sendSocketMessage(
+		sequence: number,
+		data: Blob | ArrayBuffer | string
+	): Promise<void> {
+		const state = this.sockets.get(sequence);
+		if (state === undefined || state.closed)
+			throw new Error("Proxy socket is closed");
+		const isText = typeof data === "string";
+		const knownSize =
+			typeof data === "string"
+				? data.length
+				: data instanceof Blob
+					? data.size
+					: data.byteLength;
+		if (knownSize > MAX_PROXY_WEBSOCKET_MESSAGE_BYTES) {
+			throw new VirtualSocketError(
+				"Proxied WebSocket message exceeds the 16 MiB limit",
+				1009
+			);
+		}
+		const bytes = isText
+			? new TextEncoder().encode(data)
+			: new Uint8Array(data instanceof Blob ? await data.arrayBuffer() : data);
+		if (bytes.byteLength > MAX_PROXY_WEBSOCKET_MESSAGE_BYTES) {
+			throw new VirtualSocketError(
+				"Proxied WebSocket message exceeds the 16 MiB limit",
+				1009
+			);
+		}
+		if (bytes.byteLength <= MAX_CHUNK_SIZE) {
+			await this.sendFrame(
+				encodeFrame(
+					sequence,
+					isText ? C2SRequestTypes.WSSendText : C2SRequestTypes.WSSendBinary,
+					bytes
+				)
+			);
+			return;
+		}
+
+		await this.sendFrame(
+			encodeFrame(
+				sequence,
+				isText ? C2SRequestTypes.WSTextStart : C2SRequestTypes.WSBinaryStart
+			)
+		);
+		for (let offset = 0; offset < bytes.byteLength; offset += MAX_CHUNK_SIZE) {
+			await this.sendFrame(
+				encodeFrame(
+					sequence,
+					C2SRequestTypes.WSDataChunk,
+					bytes.subarray(offset, offset + MAX_CHUNK_SIZE)
+				)
+			);
+		}
+		await this.sendFrame(encodeFrame(sequence, C2SRequestTypes.WSDataEnd));
+	}
+
+	private handleData(data: ArrayBuffer): void {
+		try {
+			if (!this.handshakeComplete) {
+				const hello = decodeText(data);
+				if (hello === S2C_HELLO_OK) {
+					this.handshakeComplete = true;
+					this.handshakeResolve?.();
+					return;
+				}
+				if (hello.startsWith(S2C_HELLO_ERR)) {
+					throw new Error(
+						`Proxy protocol mismatch; node expects ${hello.slice(S2C_HELLO_ERR.length)}`
+					);
+				}
+				throw new Error("Proxy node sent an invalid protocol handshake");
+			}
+
+			const frame = decodeFrame(data);
+			if (this.pings.has(frame.sequence)) {
+				this.handlePong(frame.sequence, frame.operation, frame.payload);
+			} else if (this.http.has(frame.sequence))
+				this.handleHTTPFrame(frame.sequence, frame.operation, frame.payload);
+			else if (this.sockets.has(frame.sequence)) {
+				this.handleSocketFrame(frame.sequence, frame.operation, frame.payload);
+			} else if (this.ignoredHTTP.has(frame.sequence)) {
+				if (frame.operation === S2CRequestTypes.HTTPResponseEnd) {
+					this.ignoredHTTP.delete(frame.sequence);
+				} else if (
+					frame.operation !== S2CRequestTypes.HTTPResponseStart &&
+					frame.operation !== S2CRequestTypes.HTTPResponseChunk
+				) {
+					throw new Error(
+						`Node sent invalid operation for canceled HTTP sequence`
+					);
+				}
+			} else {
+				throw new Error(
+					`Node sent a frame for unknown sequence ${frame.sequence}`
+				);
+			}
+		} catch (error) {
+			this.handshakeReject?.(error);
+			this.fail(error);
+		}
+	}
+
+	private handlePong(
+		sequence: number,
+		operation: number,
+		payload: ArrayBuffer
+	): void {
+		const pending = this.pings.get(sequence);
+		if (pending === undefined) return;
+		if (operation !== S2CRequestTypes.Pong) {
+			throw new Error(`Node sent invalid ping operation ${operation}`);
+		}
+		const value = decodeJSON<Partial<PingPayload>>(payload);
+		if (typeof value.nonce !== "string" || value.nonce !== pending.nonce) {
+			throw new Error("Node sent an invalid protocol pong");
+		}
+		clearTimeout(pending.timer);
+		this.pings.delete(sequence);
+		pending.resolve(performance.now() - pending.startedAt);
+	}
+
+	private handleHTTPFrame(
+		sequence: number,
+		operation: number,
+		payload: ArrayBuffer
+	): void {
+		const pending = this.http.get(sequence);
+		if (pending === undefined) return;
+		switch (operation) {
+			case S2CRequestTypes.HTTPResponseStart: {
+				if (pending.responseStarted)
+					throw new Error("Node sent duplicate HTTP response headers");
+				const response = validateResponsePayload(decodeJSON(payload));
+				pending.responseStarted = true;
+				const body = new ReadableStream<Uint8Array>({
+					start: (controller) => {
+						pending.controller = controller;
+					},
+					cancel: () => {
+						this.cancelRequest(sequence, false);
+					},
+				});
+				pending.responseSettled = true;
+				pending.resolve({
+					body,
+					headers: response.headers.map(([name, value]) => [name, value]),
+					status: response.status,
+					statusText: response.statusText,
+				});
+				break;
+			}
+			case S2CRequestTypes.HTTPResponseChunk:
+				if (!pending.responseStarted || pending.controller === undefined) {
+					throw new Error("Node sent HTTP body data before response headers");
+				}
+				pending.controller.enqueue(new Uint8Array(payload));
+				break;
+			case S2CRequestTypes.HTTPResponseEnd:
+				if (!pending.responseStarted || pending.controller === undefined) {
+					throw new Error("Node ended HTTP response before response headers");
+				}
+				pending.controller.close();
+				pending.removeAbort?.();
+				this.http.delete(sequence);
+				break;
+			default:
+				throw new Error(`Node sent invalid HTTP operation ${operation}`);
+		}
+	}
+
+	private handleSocketFrame(
+		sequence: number,
+		operation: number,
+		payload: ArrayBuffer
+	): void {
+		const state = this.sockets.get(sequence);
+		if (state === undefined) return;
+		switch (operation) {
+			case S2CRequestTypes.WSOpen: {
+				const open = validateSocketOpen(decodeJSON(payload));
+				callSafely(() =>
+					state.callbacks.onopen(open.protocol, open.extensions)
+				);
+				break;
+			}
+			case S2CRequestTypes.WSClose: {
+				const close = validateSocketClose(decodeJSON(payload));
+				state.closed = true;
+				this.sockets.delete(sequence);
+				callSafely(() => state.callbacks.onclose(close.code, close.reason));
+				break;
+			}
+			case S2CRequestTypes.WSError: {
+				const error = decodeJSON<Partial<WSErrorPayload>>(payload);
+				if (typeof error.message !== "string")
+					throw new Error("Node sent invalid socket error");
+				callSafely(() => state.callbacks.onerror(error.message as string));
+				break;
+			}
+			case S2CRequestTypes.WSTextStart:
+			case S2CRequestTypes.WSBinaryStart:
+				if (state.assembly !== undefined)
+					throw new Error("Node overlapped WebSocket messages");
+				state.assembly = {
+					kind: operation === S2CRequestTypes.WSTextStart ? "text" : "binary",
+					chunks: [],
+					size: 0,
+				};
+				break;
+			case S2CRequestTypes.WSDataChunk: {
+				if (state.assembly === undefined)
+					throw new Error("Node sent an orphan socket chunk");
+				state.assembly.size += payload.byteLength;
+				if (state.assembly.size > MAX_PROXY_WEBSOCKET_MESSAGE_BYTES) {
+					throw new Error(
+						"Node exceeded maximum proxied WebSocket message size"
+					);
+				}
+				state.assembly.chunks.push(new Uint8Array(payload));
+				break;
+			}
+			case S2CRequestTypes.WSDataEnd: {
+				if (state.assembly === undefined)
+					throw new Error("Node ended an absent socket message");
+				const assembly = state.assembly;
+				delete state.assembly;
+				const bytes = concatenate(assembly.chunks, assembly.size);
+				if (assembly.kind === "text") {
+					const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+					callSafely(() => state.callbacks.onmessage(text));
+				} else {
+					callSafely(() =>
+						state.callbacks.onmessage(bytes.slice().buffer as ArrayBuffer)
+					);
+				}
+				break;
+			}
+			default:
+				throw new Error(`Node sent invalid WebSocket operation ${operation}`);
+		}
+	}
+
+	private socketError(sequence: number, error: Error, closeCode = 1011): void {
+		const state = this.sockets.get(sequence);
+		if (state === undefined) return;
+		state.closed = true;
+		this.sockets.delete(sequence);
+		callSafely(() => state.callbacks.onerror(error.message));
+		callSafely(() => state.callbacks.onclose(closeCode, error.message));
+	}
+
+	private allocateSequence(): number {
+		for (let attempts = 0; attempts < 0xffff; attempts += 1) {
+			const candidate = this.nextSequence;
+			this.nextSequence = candidate === 0xffff ? 1 : candidate + 1;
+			const ignoredUntil = this.ignoredHTTP.get(candidate);
+			if (ignoredUntil !== undefined && ignoredUntil <= Date.now()) {
+				this.ignoredHTTP.delete(candidate);
+			}
+			if (
+				!this.http.has(candidate) &&
+				!this.sockets.has(candidate) &&
+				!this.pings.has(candidate) &&
+				!this.ignoredHTTP.has(candidate)
+			) {
+				return candidate;
+			}
+		}
+		throw new Error("Proxy connection exhausted its request sequence space");
+	}
+
+	private sendRaw(data: ArrayBuffer): Promise<void> {
+		const result = this.sendQueue.then(async () => this.binary.send(data));
+		this.sendQueue = result.catch(() => undefined);
+		return result;
+	}
+
+	private sendFrame(data: ArrayBuffer): Promise<void> {
+		this.assertReady();
+		return this.sendRaw(data);
+	}
+
+	private assertReady(): void {
+		if (!this.ready) throw new Error("Proxy connection is not ready");
+	}
+
+	private fail(reason: unknown): void {
+		if (this.failed) return;
+		this.failed = true;
+		const error = asError(reason, "Proxy connection failed");
+		this.handshakeReject?.(error);
+		for (const pending of this.http.values()) {
+			pending.removeAbort?.();
+			if (pending.controller !== undefined) pending.controller.error(error);
+			if (!pending.responseSettled) pending.reject(error);
+		}
+		this.http.clear();
+		this.ignoredHTTP.clear();
+		for (const socket of this.sockets.values()) {
+			callSafely(() => socket.callbacks.onerror(error.message));
+			callSafely(() => socket.callbacks.onclose(1011, error.message));
+		}
+		this.sockets.clear();
+		for (const ping of this.pings.values()) {
+			clearTimeout(ping.timer);
+			ping.reject(error);
+		}
+		this.pings.clear();
+		this.binary.close(1011, error.message.slice(0, 123));
+		this.failureHandler?.(error);
+	}
+}