@aigne/afs-did-space 1.12.0-beta.5

package/dist/packages/session/dist/index.mjs

@@ -0,0 +1,782 @@
+import { makeNsLog } from "@aigne/afs";
+import { joinURL } from "ufo";
+
+//#region ../../../packages/session/dist/index.mjs
+/**
+* Binary sidecar — carry raw bytes alongside a JSON envelope.
+*
+* Wire format for a message that contains a Uint8Array value:
+*   [Binary frame: reqId=N, payload=raw bytes]
+*   [JSON frame:   reqId=N, payload=JSON with {__afs_binary_ref:true,size:N} marker]
+*
+* Ordering: the Binary frame MUST immediately precede the JSON frame with
+* the same reqId. WebSocket preserves message order, so receivers can
+* buffer the last-seen Binary by reqId and splice it in when the matching
+* JSON arrives.
+*
+* Only one binary slot per message is supported today — large reads/writes
+* put the bytes at `result.data.content` / `params.payload.content`. If we
+* ever need multi-slot, extend the marker with an index and have the binary
+* frame carry a length-prefixed table.
+*
+* Marker key is intentionally rare (`__afs_binary_ref`) to avoid colliding
+* with user payload keys. `isBinaryMarker` also requires `size: number` so
+* a stray `{__afs_binary_ref: true}` in user data without a numeric size
+* still won't be mistaken for a marker.
+*/
+const BINARY_MARKER_KEY = "__afs_binary_ref";
+function isBinaryMarker(v) {
+	if (typeof v !== "object" || v === null) return false;
+	const o = v;
+	return o[BINARY_MARKER_KEY] === true && typeof o.size === "number";
+}
+function toUint8(value) {
+	if (value instanceof Uint8Array) return value;
+	if (value instanceof ArrayBuffer) return new Uint8Array(value);
+	return null;
+}
+/**
+* Walk a value and replace the first node for which `replace` returns a
+* non-null value. Identity-preserving: if nothing changed, returns the
+* original reference — so the no-binary path allocates nothing.
+*/
+function walkReplaceFirst(value, replace) {
+	let done = false;
+	const walk = (v) => {
+		if (done) return v;
+		const replaced = replace(v);
+		if (replaced !== null) {
+			done = true;
+			return replaced;
+		}
+		if (Array.isArray(v)) {
+			let changed = false;
+			let out = null;
+			for (let i = 0; i < v.length; i++) {
+				const nv = walk(v[i]);
+				if (nv !== v[i]) {
+					if (!changed) {
+						out = v.slice();
+						changed = true;
+					}
+					out[i] = nv;
+				}
+			}
+			return changed ? out : v;
+		}
+		if (v && typeof v === "object") {
+			let changed = false;
+			let out = null;
+			for (const [k, inner] of Object.entries(v)) {
+				const nv = walk(inner);
+				if (nv !== inner) {
+					if (!changed) {
+						out = { ...v };
+						changed = true;
+					}
+					out[k] = nv;
+				}
+			}
+			return changed ? out : v;
+		}
+		return v;
+	};
+	return walk(value);
+}
+/**
+* Walk a message object and extract the first Uint8Array / ArrayBuffer
+* value found (depth-first, keys in insertion order). Replaces the value
+* with a `{__afs_binary_ref:true,size:N}` marker. Returns the cleaned
+* message plus the extracted bytes (if any).
+*
+* Pure — does not mutate the input.
+*/
+function extractBinary(message) {
+	let extracted;
+	const next = walkReplaceFirst(message, (v) => {
+		const bytes = toUint8(v);
+		if (!bytes) return null;
+		extracted = bytes;
+		return {
+			[BINARY_MARKER_KEY]: true,
+			size: bytes.byteLength
+		};
+	});
+	return extracted ? {
+		message: next,
+		binary: extracted
+	} : { message };
+}
+/**
+* Walk a value and replace the first `{__afs_binary_ref:true,size:N}`
+* marker with the given Uint8Array. Returns a new value if a marker was
+* found, or the original reference if not.
+*/
+function injectBinary(value, binary) {
+	return walkReplaceFirst(value, (v) => isBinaryMarker(v) ? binary : null);
+}
+/**
+* Protocol constants
+*/
+const HEADER_SIZE = 9;
+const MAX_PAYLOAD_SIZE = 16 * 1024 * 1024;
+const CHUNK_SIZE = 64 * 1024;
+const MAX_JSON_DEPTH = 100;
+const MAX_JSON_SIZE = MAX_PAYLOAD_SIZE;
+const MAX_UINT32 = 4294967295;
+/**
+* Frame types
+*/
+let FrameType = /* @__PURE__ */ function(FrameType) {
+	FrameType[FrameType["JSON"] = 1] = "JSON";
+	FrameType[FrameType["Binary"] = 2] = "Binary";
+	return FrameType;
+}({});
+/**
+* Protocol errors
+*/
+var ProtocolError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "ProtocolError";
+	}
+};
+var PayloadTooLargeError = class extends ProtocolError {
+	constructor(size) {
+		super("payload_too_large", `Payload size ${size} exceeds maximum ${MAX_PAYLOAD_SIZE}`);
+		this.name = "PayloadTooLargeError";
+	}
+};
+var InvalidPayloadError = class extends ProtocolError {
+	constructor(message) {
+		super("invalid_payload", message);
+		this.name = "InvalidPayloadError";
+	}
+};
+var InvalidFrameTypeError = class extends ProtocolError {
+	constructor(type) {
+		super("invalid_frame_type", `Invalid frame type: 0x${type.toString(16).padStart(2, "0")}`);
+		this.name = "InvalidFrameTypeError";
+	}
+};
+var InvalidReqIdError = class extends ProtocolError {
+	constructor(reqId) {
+		super("invalid_req_id", `Invalid request ID: ${reqId} (must be 0-${MAX_UINT32})`);
+		this.name = "InvalidReqIdError";
+	}
+};
+var IncompleteFrameError = class extends ProtocolError {
+	constructor(message) {
+		super("incomplete_frame", message);
+		this.name = "IncompleteFrameError";
+	}
+};
+/**
+* Validates frame type.
+*/
+function isValidFrameType(type) {
+	return type === FrameType.JSON || type === FrameType.Binary;
+}
+/**
+* Encodes a frame with the given type, request ID, and payload.
+*
+* Frame structure (big-endian):
+* - Length (4 bytes): payload length
+* - Type (1 byte): frame type
+* - ReqId (4 bytes): request ID
+* - Payload (variable): actual data
+*
+* @param type Frame type (JSON or Binary)
+* @param reqId Request ID (0 for events, >0 for request/response)
+* @param payload The payload data
+* @returns Encoded frame as Uint8Array
+*/
+function encodeFrame(type, reqId, payload) {
+	if (payload == null) throw new InvalidPayloadError("Payload cannot be null or undefined");
+	if (payload.length > MAX_PAYLOAD_SIZE) throw new PayloadTooLargeError(payload.length);
+	if (!isValidFrameType(type)) throw new InvalidFrameTypeError(type);
+	if (reqId < 0 || reqId > MAX_UINT32 || !Number.isInteger(reqId)) throw new InvalidReqIdError(reqId);
+	const frame = new Uint8Array(HEADER_SIZE + payload.length);
+	const view = new DataView(frame.buffer, frame.byteOffset);
+	view.setUint32(0, payload.length);
+	view.setUint8(4, type);
+	view.setUint32(5, reqId);
+	frame.set(payload, HEADER_SIZE);
+	return frame;
+}
+/**
+* Decodes a frame from a buffer.
+*
+* @param buffer The buffer containing the frame data
+* @returns Object containing the decoded frame and any remaining bytes
+* @throws IncompleteFrameError if buffer doesn't contain a complete frame
+* @throws InvalidFrameTypeError if frame type is invalid
+* @throws PayloadTooLargeError if payload length exceeds maximum
+*/
+function decodeFrame(buffer) {
+	if (buffer.length < HEADER_SIZE) throw new IncompleteFrameError(`Buffer too small: ${buffer.length} bytes, need at least ${HEADER_SIZE}`);
+	const view = new DataView(buffer.buffer, buffer.byteOffset);
+	const length = view.getUint32(0);
+	const type = view.getUint8(4);
+	const reqId = view.getUint32(5);
+	if (length > MAX_PAYLOAD_SIZE) throw new PayloadTooLargeError(length);
+	if (!isValidFrameType(type)) throw new InvalidFrameTypeError(type);
+	const totalSize = HEADER_SIZE + length;
+	if (buffer.length < totalSize) throw new IncompleteFrameError(`Incomplete frame: have ${buffer.length} bytes, need ${totalSize}`);
+	const payload = buffer.slice(HEADER_SIZE, totalSize);
+	const remaining = buffer.slice(totalSize);
+	return {
+		frame: {
+			type,
+			reqId,
+			payload
+		},
+		remaining
+	};
+}
+/**
+* Error thrown when pending buffer exceeds maximum size
+*/
+var BufferOverflowError = class extends ProtocolError {
+	constructor(size, maxSize) {
+		super("buffer_overflow", `Pending buffer size ${size} exceeds maximum ${maxSize}`);
+		this.name = "BufferOverflowError";
+	}
+};
+/**
+* Streaming frame decoder that handles:
+* - Partial frames across multiple pushes (拆包)
+* - Multiple frames in single push (粘包)
+* - Buffer overflow protection (security)
+*/
+var FrameDecoder = class {
+	buffer = new Uint8Array(0);
+	maxPendingSize;
+	constructor(options) {
+		this.maxPendingSize = options?.maxPendingSize ?? MAX_PAYLOAD_SIZE + HEADER_SIZE;
+	}
+	/**
+	* Push data into the decoder and return any complete frames.
+	*
+	* @param data New data to append to buffer
+	* @returns Array of complete frames (may be empty)
+	* @throws InvalidFrameTypeError if frame type is invalid
+	* @throws PayloadTooLargeError if payload exceeds maximum
+	* @throws BufferOverflowError if pending buffer exceeds maximum
+	*/
+	push(data) {
+		if (data.length === 0) return [];
+		const newBuffer = new Uint8Array(this.buffer.length + data.length);
+		newBuffer.set(this.buffer, 0);
+		newBuffer.set(data, this.buffer.length);
+		this.buffer = newBuffer;
+		if (this.buffer.length > this.maxPendingSize) throw new BufferOverflowError(this.buffer.length, this.maxPendingSize);
+		const frames = [];
+		while (this.buffer.length >= HEADER_SIZE) {
+			const payloadLength = new DataView(this.buffer.buffer, this.buffer.byteOffset).getUint32(0);
+			if (payloadLength > MAX_PAYLOAD_SIZE) throw new PayloadTooLargeError(payloadLength);
+			const totalFrameSize = HEADER_SIZE + payloadLength;
+			if (this.buffer.length < totalFrameSize) break;
+			const { frame, remaining } = decodeFrame(this.buffer);
+			frames.push(frame);
+			this.buffer = remaining;
+		}
+		return frames;
+	}
+	/**
+	* Reset the decoder state, discarding any buffered data.
+	*/
+	reset() {
+		this.buffer = new Uint8Array(0);
+	}
+	/**
+	* Get the current pending buffer size.
+	*/
+	get pendingSize() {
+		return this.buffer.length;
+	}
+};
+/**
+* Error for invalid message structure
+*/
+var InvalidMessageError = class extends ProtocolError {
+	constructor(message) {
+		super("invalid_message", message);
+		this.name = "InvalidMessageError";
+	}
+};
+/**
+* Error for JSON parsing failures
+*/
+var ParseError = class extends ProtocolError {
+	constructor(message) {
+		super("parse_error", `Parse error: ${message}`);
+		this.name = "ParseError";
+	}
+};
+/**
+* Error for depth limit exceeded
+*/
+var DepthLimitExceededError = class extends ProtocolError {
+	constructor() {
+		super("depth_limit_exceeded", `JSON depth limit exceeded (max ${MAX_JSON_DEPTH})`);
+		this.name = "DepthLimitExceededError";
+	}
+};
+/**
+* Error for message too large
+*/
+var MessageTooLargeError = class extends ProtocolError {
+	constructor(size) {
+		super("message_too_large", `Message too large: ${size} bytes (max ${MAX_JSON_SIZE})`);
+		this.name = "MessageTooLargeError";
+	}
+};
+/**
+* Dangerous keys that should be filtered for security
+*/
+const DANGEROUS_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/**
+* Recursively filter dangerous keys from an object
+*/
+function filterDangerousKeys(obj, depth = 0) {
+	if (depth > MAX_JSON_DEPTH) throw new DepthLimitExceededError();
+	if (obj === null || typeof obj !== "object") return obj;
+	if (Array.isArray(obj)) return obj.map((item) => filterDangerousKeys(item, depth + 1));
+	const filtered = {};
+	for (const [key, value] of Object.entries(obj)) if (!DANGEROUS_KEYS.has(key)) filtered[key] = filterDangerousKeys(value, depth + 1);
+	return filtered;
+}
+/**
+* Calculate depth of a JSON object
+*/
+function calculateDepth(obj, depth = 0) {
+	if (depth > MAX_JSON_DEPTH) return depth;
+	if (obj === null || typeof obj !== "object") return depth;
+	let maxDepth = depth;
+	if (Array.isArray(obj)) for (const item of obj) {
+		maxDepth = Math.max(maxDepth, calculateDepth(item, depth + 1));
+		if (maxDepth > MAX_JSON_DEPTH) return maxDepth;
+	}
+	else for (const value of Object.values(obj)) {
+		maxDepth = Math.max(maxDepth, calculateDepth(value, depth + 1));
+		if (maxDepth > MAX_JSON_DEPTH) return maxDepth;
+	}
+	return maxDepth;
+}
+/**
+* Serialize a message to JSON bytes.
+*
+* @param message The message to serialize
+* @returns UTF-8 encoded JSON bytes
+* @throws InvalidMessageError if message is invalid
+*/
+function serializeMessage(message) {
+	if (!message || typeof message !== "object" || !("type" in message)) throw new InvalidMessageError("Invalid message: missing type");
+	const { type } = message;
+	if (type === "request") {
+		const req = message;
+		if (!req.id) throw new InvalidMessageError("Invalid request: missing id");
+		if (!req.method) throw new InvalidMessageError("Invalid request: missing method");
+	}
+	const clean = {};
+	for (const [key, value] of Object.entries(message)) if (value !== void 0) clean[key] = value;
+	const json = JSON.stringify(clean);
+	return new TextEncoder().encode(json);
+}
+/**
+* Deserialize JSON bytes to a message.
+*
+* @param data UTF-8 encoded JSON bytes
+* @returns Parsed message
+* @throws ParseError if JSON is invalid
+* @throws InvalidMessageError if message structure is invalid
+* @throws DepthLimitExceededError if JSON is too deeply nested
+* @throws MessageTooLargeError if message exceeds size limit
+*/
+function deserializeMessage(data) {
+	if (data.length > MAX_JSON_SIZE) throw new MessageTooLargeError(data.length);
+	let parsed;
+	try {
+		const json = new TextDecoder().decode(data);
+		parsed = JSON.parse(json);
+	} catch (e) {
+		throw new ParseError(e instanceof Error ? e.message : "Invalid JSON");
+	}
+	if (!parsed || typeof parsed !== "object") throw new InvalidMessageError("Invalid message: not an object");
+	if (calculateDepth(parsed) > MAX_JSON_DEPTH) throw new DepthLimitExceededError();
+	const filtered = filterDangerousKeys(parsed);
+	if (!("type" in filtered) || typeof filtered.type !== "string") throw new InvalidMessageError("Invalid message: missing type");
+	const { type } = filtered;
+	if (type !== "request" && type !== "response" && type !== "event") throw new InvalidMessageError(`Invalid message type: ${type}`);
+	return filtered;
+}
+/**
+* Bounded buffer for sidecar Binary frames awaiting their JSON sibling.
+*
+* A single logical binary payload may arrive as multiple consecutive Binary
+* frames (§6.4 chunking: each chunk ≤ 64 KB). All chunks for a reqId are
+* accumulated and concatenated before being handed to the JSON handler.
+*
+* Three failure modes we defend against:
+* 1. Orphaned Binary frames (peer sent Binary but then the connection died,
+*    or the JSON never arrives for some reason) — capped by MAX_PENDING so
+*    a malicious/broken peer can't pin unbounded memory on us.
+* 2. Concurrent inflight requests — up to MAX_PENDING distinct reqIds may
+*    have pending binary chunks at any time; oldest is evicted if exceeded.
+* 3. A single reqId reused to accumulate unbounded bytes (#821). MAX_PENDING
+*    only bounds the number of DISTINCT reqIds, so a peer reusing ONE reqId
+*    could grow a single entry without limit → OOM. maxBytesPerReqId caps the
+*    accumulated bytes per reqId; a logical binary payload must never exceed
+*    MAX_PAYLOAD_SIZE, so once an entry crosses the cap it is evicted whole.
+*/
+const MAX_PENDING = 16;
+var PendingBinaryBuffer = class {
+	map = /* @__PURE__ */ new Map();
+	logger;
+	maxBytesPerReqId;
+	constructor(logger, options) {
+		this.logger = logger;
+		this.maxBytesPerReqId = options?.maxBytesPerReqId ?? MAX_PAYLOAD_SIZE;
+	}
+	set(reqId, payload) {
+		const existing = this.map.get(reqId);
+		if (existing !== void 0) {
+			if (existing.bytes + payload.byteLength > this.maxBytesPerReqId) {
+				this.map.delete(reqId);
+				this.logger?.warn("pendingBinary per-reqId byte cap exceeded — evicted entry", {
+					reqId,
+					attempted: existing.bytes + payload.byteLength,
+					limit: this.maxBytesPerReqId
+				});
+				return;
+			}
+			existing.chunks.push(payload);
+			existing.bytes += payload.byteLength;
+			return;
+		}
+		if (payload.byteLength > this.maxBytesPerReqId) {
+			this.logger?.warn("pendingBinary per-reqId byte cap exceeded — dropped frame", {
+				reqId,
+				attempted: payload.byteLength,
+				limit: this.maxBytesPerReqId
+			});
+			return;
+		}
+		if (this.map.size >= MAX_PENDING) {
+			const oldestKey = this.map.keys().next().value;
+			if (oldestKey !== void 0) {
+				this.map.delete(oldestKey);
+				this.logger?.warn("pendingBinary buffer full — evicted oldest", {
+					evicted: oldestKey,
+					limit: MAX_PENDING
+				});
+			}
+		}
+		this.map.set(reqId, {
+			chunks: [payload],
+			bytes: payload.byteLength
+		});
+	}
+	take(reqId) {
+		const entry = this.map.get(reqId);
+		if (entry === void 0) return void 0;
+		this.map.delete(reqId);
+		const { chunks } = entry;
+		if (chunks.length === 0) return new Uint8Array(0);
+		if (chunks.length === 1) return chunks[0];
+		const result = new Uint8Array(entry.bytes);
+		let offset = 0;
+		for (const chunk of chunks) {
+			result.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return result;
+	}
+	clear() {
+		this.map.clear();
+	}
+	get size() {
+		return this.map.size;
+	}
+};
+/**
+* Bidirectional RPC handler.
+*
+* Manages outgoing requests (send + wait for response) and
+* identifies incoming responses for matching.
+*/
+var RPCHandler = class {
+	nextId;
+	idIncrement;
+	timeout;
+	pending = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.nextId = options.startId ?? 2;
+		this.idIncrement = options.idIncrement ?? 2;
+		this.timeout = options.timeout ?? 3e4;
+	}
+	/**
+	* Send a request via transport and wait for the matching response.
+	*/
+	async sendRequest(transport, method, params) {
+		if (!transport.connected) throw new Error("Transport not connected");
+		const id = String(this.nextId);
+		this.nextId += this.idIncrement;
+		if (this.nextId > 4294967294) this.nextId = this.idIncrement === 2 ? this.nextId % 2 === 0 ? 2 : 1 : 1;
+		const request = {
+			type: "request",
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(/* @__PURE__ */ new Error(`RPC timeout: ${method} (id=${id})`));
+			}, this.timeout);
+			this.pending.set(id, {
+				resolve: (response) => {
+					if (response.error) {
+						const errObj = response.error;
+						const isStructured = typeof errObj === "object" && errObj !== null;
+						const message = isStructured ? errObj.message || JSON.stringify(errObj) : String(errObj);
+						const err = new Error(message);
+						if (isStructured) {
+							const code = errObj.code;
+							const details = errObj.details;
+							if (typeof code === "string") Object.defineProperty(err, "code", {
+								value: code,
+								enumerable: false,
+								configurable: true,
+								writable: false
+							});
+							if (details !== void 0) Object.defineProperty(err, "details", {
+								value: details,
+								enumerable: false,
+								configurable: true,
+								writable: false
+							});
+						}
+						reject(err);
+					} else resolve(response.result);
+				},
+				reject,
+				timer
+			});
+			const reqIdNum = Number.parseInt(id, 10);
+			const { message: cleanRequest, binary } = extractBinary(request);
+			const send = async () => {
+				if (binary) for (let offset = 0; offset < binary.byteLength; offset += CHUNK_SIZE) await transport.send({
+					type: FrameType.Binary,
+					reqId: reqIdNum,
+					payload: binary.subarray(offset, Math.min(offset + CHUNK_SIZE, binary.byteLength))
+				});
+				await transport.send({
+					type: FrameType.JSON,
+					reqId: reqIdNum,
+					payload: serializeMessage(cleanRequest)
+				});
+			};
+			send().catch((err) => {
+				clearTimeout(timer);
+				this.pending.delete(id);
+				reject(err);
+			});
+		});
+	}
+	/**
+	* Try to handle a frame as a response to a pending request.
+	* Returns true if it was a response we were waiting for, false otherwise.
+	*
+	* Callers must splice any sidecar Binary frame into the message before
+	* calling — by the time we see a `Response`, its result is final.
+	*/
+	handleResponse(response) {
+		const pending = this.pending.get(response.id);
+		if (!pending) return false;
+		clearTimeout(pending.timer);
+		this.pending.delete(response.id);
+		pending.resolve(response);
+		return true;
+	}
+	/**
+	* Reject all pending requests (e.g., on disconnect).
+	*/
+	rejectAll(error) {
+		for (const [_id, pending] of this.pending) {
+			clearTimeout(pending.timer);
+			pending.reject(error);
+		}
+		this.pending.clear();
+	}
+	/**
+	* Number of pending requests.
+	*/
+	get pendingCount() {
+		return this.pending.size;
+	}
+};
+/**
+* Protocol version
+*/
+const PROTOCOL_VERSION = "1.0";
+const log$2 = makeNsLog("session");
+const log$1 = makeNsLog("session");
+/**
+* SessionClient — provider-side session participant.
+*
+* Connects to a SessionHost, attaches with a namespace + manifest,
+* and handles incoming AFS requests by routing them to provider instances.
+*/
+const log = makeNsLog("session");
+/**
+* Error for WebSocket operations
+*/
+var WebSocketError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "WebSocketError";
+	}
+};
+/**
+* Encode an auth token for safe transport inside a
+* `Sec-WebSocket-Protocol` subprotocol name. Per RFC 6455, subprotocol
+* names must be RFC 2616 tokens — alphanumerics and a small set of
+* punctuation. Hex encoding guarantees the value survives the wire
+* unchanged regardless of the original token's characters.
+*/
+function encodeBearerToken(raw) {
+	return Buffer.from(raw, "utf8").toString("hex");
+}
+/**
+* WebSocket client transport (uses browser WebSocket API).
+*/
+var ClientWebSocketTransport = class {
+	ws;
+	decoder = new FrameDecoder();
+	handlers = /* @__PURE__ */ new Map();
+	_connected = false;
+	constructor(ws) {
+		this.ws = ws;
+		this._connected = ws.readyState === WebSocket.OPEN;
+		this.setupHandlers();
+	}
+	setupHandlers() {
+		this.ws.onmessage = (event) => {
+			try {
+				const data = event.data instanceof ArrayBuffer ? new Uint8Array(event.data) : typeof event.data === "string" ? new TextEncoder().encode(event.data) : new Uint8Array(event.data);
+				const frames = this.decoder.push(data);
+				for (const frame of frames) this.emit("frame", frame);
+			} catch (error) {
+				this.emit("error", error);
+			}
+		};
+		this.ws.onclose = () => {
+			this._connected = false;
+			this.emit("close");
+		};
+		this.ws.onerror = () => {
+			this.emit("error", /* @__PURE__ */ new Error("WebSocket error"));
+		};
+		this.ws.onopen = () => {
+			this._connected = true;
+		};
+	}
+	async send(frame) {
+		if (!this._connected) throw new WebSocketError("not_connected", "Transport is not connected");
+		const encoded = encodeFrame(frame.type, frame.reqId, frame.payload);
+		this.ws.send(encoded);
+	}
+	async close() {
+		if (this._connected) {
+			this.ws.close();
+			this._connected = false;
+		}
+	}
+	on(event, handler) {
+		if (!this.handlers.has(event)) this.handlers.set(event, /* @__PURE__ */ new Set());
+		this.handlers.get(event).add(handler);
+	}
+	off(event, handler) {
+		this.handlers.get(event)?.delete(handler);
+	}
+	emit(event, ...args) {
+		const handlers = this.handlers.get(event);
+		if (handlers) for (const handler of handlers) handler(...args);
+	}
+	get connected() {
+		return this._connected;
+	}
+};
+/**
+* WebSocket client implementation.
+*/
+var WebSocketClient = class {
+	ws = null;
+	transport = null;
+	host;
+	port;
+	authToken;
+	handlers = /* @__PURE__ */ new Map();
+	constructor(options = {}) {
+		this.host = options.host || "localhost";
+		this.port = options.port || 9999;
+		this.authToken = options.authToken;
+	}
+	async connect() {
+		return new Promise((resolve, reject) => {
+			const url = `ws://${this.host}:${this.port}`;
+			const protocols = this.authToken ? [`bearer.${encodeBearerToken(this.authToken)}`] : void 0;
+			this.ws = protocols ? new WebSocket(url, protocols) : new WebSocket(url);
+			this.ws.binaryType = "arraybuffer";
+			this.ws.onopen = () => {
+				this.transport = new ClientWebSocketTransport(this.ws);
+				this.transport.on("frame", (frame) => this.emit("frame", frame));
+				this.transport.on("error", (error) => this.emit("error", error));
+				this.transport.on("close", () => this.emit("close"));
+				resolve();
+			};
+			this.ws.onerror = () => {
+				reject(new WebSocketError("connection_failed", "Failed to connect"));
+			};
+			this.ws.onclose = (event) => {
+				if (!this.transport) if (event.code === 1002 || event.code === 1008) reject(new WebSocketError("auth_failed", "Authentication failed"));
+				else reject(new WebSocketError("connection_failed", "Connection closed"));
+			};
+		});
+	}
+	async send(frame) {
+		if (!this.transport) throw new WebSocketError("not_connected", "Client is not connected");
+		return this.transport.send(frame);
+	}
+	async close() {
+		if (this.transport) await this.transport.close();
+		this.ws = null;
+		this.transport = null;
+	}
+	on(event, handler) {
+		if (!this.handlers.has(event)) this.handlers.set(event, /* @__PURE__ */ new Set());
+		this.handlers.get(event).add(handler);
+	}
+	off(event, handler) {
+		this.handlers.get(event)?.delete(handler);
+	}
+	emit(event, ...args) {
+		const handlers = this.handlers.get(event);
+		if (handlers) for (const handler of handlers) handler(...args);
+	}
+	get connected() {
+		return this.transport?.connected ?? false;
+	}
+};
+
+//#endregion
+export { FrameType, PROTOCOL_VERSION, PendingBinaryBuffer, RPCHandler, WebSocketClient, deserializeMessage, injectBinary };
+//# sourceMappingURL=index.mjs.map