@abraca/dabra 1.0.2 → 1.0.4

package/dist/abracadabra-provider.cjs

@@ -1908,7 +1908,7 @@ var AbracadabraWS = class extends EventEmitter {
 		if (this.connectionAttempt) this.rejectConnectionAttempt();
 		this.status = WebSocketStatus.Disconnected;
 		this.emit("status", { status: WebSocketStatus.Disconnected });
-		const isRateLimited = event?.code === 4429;
+		const isRateLimited = event?.code === 4429 || event === 4429;
 		this.emit("disconnect", { event });
 		if (isRateLimited) this.emit("rateLimited");
 		if (!this.cancelWebsocketRetry && this.shouldConnect) {
@@ -3365,6 +3365,18 @@ var AbracadabraClient = class {
 	async serverInfo() {
 		return this.request("GET", "/info", { auth: false });
 	}
+	/**
+	* Fetch ICE server configuration for WebRTC peer connections.
+	* Falls back to default Google STUN server if the endpoint is unavailable.
+	* No auth required.
+	*/
+	async getIceServers() {
+		try {
+			return (await this.request("GET", "/ice-servers", { auth: false })).iceServers;
+		} catch {
+			return [{ urls: "stun:stun.l.google.com:19302" }];
+		}
+	}
 	async request(method, path, opts) {
 		const auth = opts?.auth ?? true;
 		const headers = {};
@@ -4163,7 +4175,7 @@ const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(1
 * Convert byte array to hex string. Uses built-in function, when available.
 * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
 */
-function bytesToHex(bytes) {
+function bytesToHex$1(bytes) {
 	abytes(bytes);
 	if (hasHexBuiltin) return bytes.toHex();
 	let hex = "";
@@ -4187,7 +4199,7 @@ function asciiToBase16(ch) {
 * Convert hex string to byte array. Uses built-in function, when available.
 * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
 */
-function hexToBytes(hex) {
+function hexToBytes$1(hex) {
 	if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
 	if (hasHexBuiltin) return Uint8Array.fromHex(hex);
 	const hl = hex.length;
@@ -4682,15 +4694,15 @@ function hexToNumber(hex) {
 	return hex === "" ? _0n$5 : BigInt("0x" + hex);
 }
 function bytesToNumberBE(bytes) {
-	return hexToNumber(bytesToHex(bytes));
+	return hexToNumber(bytesToHex$1(bytes));
 }
 function bytesToNumberLE(bytes) {
-	return hexToNumber(bytesToHex(copyBytes(abytes(bytes)).reverse()));
+	return hexToNumber(bytesToHex$1(copyBytes(abytes(bytes)).reverse()));
 }
 function numberToBytesBE(n, len) {
 	anumber(len);
 	n = abignumber(n);
-	const res = hexToBytes(n.toString(16).padStart(len * 2, "0"));
+	const res = hexToBytes$1(n.toString(16).padStart(len * 2, "0"));
 	if (res.length !== len) throw new Error("number too large");
 	return res;
 }
@@ -5652,7 +5664,7 @@ function edwards(params, extraOpts = {}) {
 			});
 		}
 		static fromHex(hex, zip215 = false) {
-			return Point.fromBytes(hexToBytes(hex), zip215);
+			return Point.fromBytes(hexToBytes$1(hex), zip215);
 		}
 		get x() {
 			return this.toAffine().x;
@@ -5753,7 +5765,7 @@ function edwards(params, extraOpts = {}) {
 			return bytes;
 		}
 		toHex() {
-			return bytesToHex(this.toBytes());
+			return bytesToHex$1(this.toBytes());
 		}
 		toString() {
 			return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
@@ -5799,7 +5811,7 @@ var PrimeEdwardsPoint = class {
 		return this.ep.toAffine(invertedZ);
 	}
 	toHex() {
-		return bytesToHex(this.toBytes());
+		return bytesToHex$1(this.toBytes());
 	}
 	toString() {
 		return this.toHex();
@@ -6832,7 +6844,7 @@ var _RistrettoPoint = class _RistrettoPoint extends PrimeEdwardsPoint {
 	* @param hex Ristretto-encoded 32 bytes. Not every 32-byte string is valid ristretto encoding
 	*/
 	static fromHex(hex) {
-		return _RistrettoPoint.fromBytes(hexToBytes(hex));
+		return _RistrettoPoint.fromBytes(hexToBytes$1(hex));
 	}
 	/**
 	* Encodes ristretto point to Uint8Array.
@@ -8447,17 +8459,1186 @@ var BackgroundSyncManager = class extends EventEmitter {
 	}
 };
 
+//#endregion
+//#region packages/provider/src/webrtc/SignalingSocket.ts
+var SignalingSocket = class extends EventEmitter {
+	constructor(configuration) {
+		super();
+		this.ws = null;
+		this.wsHandlers = {};
+		this.shouldConnect = true;
+		this.connectionAttempt = null;
+		this.localPeerId = null;
+		this.isConnected = false;
+		this.config = {
+			url: configuration.url,
+			token: configuration.token,
+			delay: configuration.delay ?? 1e3,
+			factor: configuration.factor ?? 2,
+			minDelay: configuration.minDelay ?? 1e3,
+			maxDelay: configuration.maxDelay ?? 3e4,
+			jitter: configuration.jitter ?? true,
+			maxAttempts: configuration.maxAttempts ?? 0,
+			WebSocketPolyfill: configuration.WebSocketPolyfill ?? WebSocket
+		};
+		if (configuration.autoConnect !== false) this.connect();
+	}
+	async getToken() {
+		if (typeof this.config.token === "function") return await this.config.token();
+		return this.config.token;
+	}
+	async connect() {
+		if (this.isConnected) return;
+		if (this.cancelRetry) {
+			this.cancelRetry();
+			this.cancelRetry = void 0;
+		}
+		this.shouldConnect = true;
+		let cancelAttempt = false;
+		const retryPromise = (0, _lifeomic_attempt.retry)(() => this.createConnection(), {
+			delay: this.config.delay,
+			initialDelay: 0,
+			factor: this.config.factor,
+			maxAttempts: this.config.maxAttempts,
+			minDelay: this.config.minDelay,
+			maxDelay: this.config.maxDelay,
+			jitter: this.config.jitter,
+			timeout: 0,
+			beforeAttempt: (context) => {
+				if (!this.shouldConnect || cancelAttempt) context.abort();
+			}
+		}).catch((error) => {
+			if (error && error.code !== "ATTEMPT_ABORTED") throw error;
+		});
+		this.cancelRetry = () => {
+			cancelAttempt = true;
+		};
+		return retryPromise;
+	}
+	async createConnection() {
+		this.cleanup();
+		const token = await this.getToken();
+		const separator = this.config.url.includes("?") ? "&" : "?";
+		const url = `${this.config.url}${separator}token=${encodeURIComponent(token)}`;
+		const ws = new this.config.WebSocketPolyfill(url);
+		return new Promise((resolve, reject) => {
+			const onOpen = () => {
+				this.isConnected = true;
+				this.sendRaw({ type: "join" });
+			};
+			const onMessage = (event) => {
+				const data = typeof event === "string" ? event : typeof event.data === "string" ? event.data : null;
+				if (!data) return;
+				let msg;
+				try {
+					msg = JSON.parse(data);
+				} catch {
+					return;
+				}
+				this.handleMessage(msg, resolve);
+			};
+			const onClose = (event) => {
+				const wasConnected = this.isConnected;
+				this.isConnected = false;
+				this.localPeerId = null;
+				if (this.connectionAttempt) {
+					this.connectionAttempt = null;
+					reject(/* @__PURE__ */ new Error(`Signaling WebSocket closed: ${event?.code}`));
+				}
+				this.emit("disconnected");
+				if (!wasConnected) return;
+				if (this.shouldConnect && !this.cancelRetry) setTimeout(() => this.connect(), this.config.delay);
+			};
+			const onError = (err) => {
+				if (this.connectionAttempt) {
+					this.connectionAttempt = null;
+					reject(err);
+				}
+			};
+			this.wsHandlers = {
+				open: onOpen,
+				message: onMessage,
+				close: onClose,
+				error: onError
+			};
+			for (const [name, handler] of Object.entries(this.wsHandlers)) ws.addEventListener(name, handler);
+			this.ws = ws;
+			this.connectionAttempt = {
+				resolve,
+				reject
+			};
+		});
+	}
+	handleMessage(msg, resolveConnection) {
+		switch (msg.type) {
+			case "welcome":
+				this.localPeerId = msg.peer_id;
+				if (this.connectionAttempt) {
+					this.connectionAttempt = null;
+					resolveConnection?.();
+				}
+				this.emit("welcome", {
+					peerId: msg.peer_id,
+					peers: msg.peers
+				});
+				break;
+			case "joined":
+				this.emit("joined", {
+					peerId: msg.peer_id,
+					userId: msg.user_id,
+					muted: msg.muted,
+					video: msg.video,
+					screen: msg.screen,
+					name: msg.name,
+					color: msg.color
+				});
+				break;
+			case "left":
+				this.emit("left", { peerId: msg.peer_id });
+				break;
+			case "offer":
+				this.emit("offer", {
+					from: msg.from,
+					sdp: msg.sdp
+				});
+				break;
+			case "answer":
+				this.emit("answer", {
+					from: msg.from,
+					sdp: msg.sdp
+				});
+				break;
+			case "ice":
+				this.emit("ice", {
+					from: msg.from,
+					candidate: msg.candidate
+				});
+				break;
+			case "mute":
+				this.emit("mute", {
+					peerId: msg.peer_id,
+					muted: msg.muted
+				});
+				break;
+			case "media-state":
+				this.emit("media-state", {
+					peerId: msg.peer_id,
+					video: msg.video,
+					screen: msg.screen
+				});
+				break;
+			case "profile":
+				this.emit("profile", {
+					peerId: msg.peer_id,
+					name: msg.name,
+					color: msg.color
+				});
+				break;
+			case "ping":
+				this.sendRaw({ type: "pong" });
+				break;
+			case "error":
+				this.emit("error", {
+					code: msg.code,
+					message: msg.message
+				});
+				break;
+		}
+	}
+	sendRaw(msg) {
+		if (this.ws?.readyState === 1) this.ws.send(JSON.stringify(msg));
+	}
+	sendOffer(to, sdp) {
+		this.sendRaw({
+			type: "offer",
+			to,
+			sdp
+		});
+	}
+	sendAnswer(to, sdp) {
+		this.sendRaw({
+			type: "answer",
+			to,
+			sdp
+		});
+	}
+	sendIce(to, candidate) {
+		this.sendRaw({
+			type: "ice",
+			to,
+			candidate
+		});
+	}
+	sendMute(muted) {
+		this.sendRaw({
+			type: "mute",
+			muted
+		});
+	}
+	sendMediaState(video, screen) {
+		this.sendRaw({
+			type: "media-state",
+			video,
+			screen
+		});
+	}
+	sendProfile(name, color) {
+		this.sendRaw({
+			type: "profile",
+			name,
+			color
+		});
+	}
+	sendLeave() {
+		this.sendRaw({ type: "leave" });
+	}
+	disconnect() {
+		this.shouldConnect = false;
+		this.sendLeave();
+		if (this.cancelRetry) {
+			this.cancelRetry();
+			this.cancelRetry = void 0;
+		}
+		this.cleanup();
+	}
+	destroy() {
+		this.disconnect();
+		this.removeAllListeners();
+	}
+	cleanup() {
+		if (!this.ws) return;
+		for (const [name, handler] of Object.entries(this.wsHandlers)) this.ws.removeEventListener(name, handler);
+		this.wsHandlers = {};
+		try {
+			if (this.ws.readyState !== 3) this.ws.close();
+		} catch {}
+		this.ws = null;
+		this.isConnected = false;
+		this.localPeerId = null;
+	}
+};
+
+//#endregion
+//#region packages/provider/src/webrtc/types.ts
+/** Data channel file transfer message type discriminators (first byte). */
+const FILE_MSG = {
+	START: 1,
+	CHUNK: 2,
+	COMPLETE: 3,
+	CANCEL: 4
+};
+/** Data channel Y.js message type discriminators (first byte). */
+const YJS_MSG = {
+	SYNC: 0,
+	UPDATE: 1
+};
+const CHANNEL_NAMES = {
+	YJS_SYNC: "yjs-sync",
+	AWARENESS: "awareness",
+	FILE_TRANSFER: "file-transfer",
+	CUSTOM: "custom"
+};
+const DEFAULT_ICE_SERVERS = [{ urls: "stun:stun.l.google.com:19302" }];
+const DEFAULT_FILE_CHUNK_SIZE = 16384;
+/** UUID v4 transfer ID length when encoded as raw bytes. */
+const TRANSFER_ID_BYTES = 16;
+/** SHA-256 hash length in bytes. */
+const SHA256_BYTES = 32;
+
+//#endregion
+//#region packages/provider/src/webrtc/DataChannelRouter.ts
+var DataChannelRouter = class extends EventEmitter {
+	constructor(connection) {
+		super();
+		this.connection = connection;
+		this.channels = /* @__PURE__ */ new Map();
+		this.connection.ondatachannel = (event) => {
+			this.registerChannel(event.channel);
+		};
+	}
+	/** Create a named data channel (initiator side). */
+	createChannel(name, options) {
+		const channel = this.connection.createDataChannel(name, options);
+		this.registerChannel(channel);
+		return channel;
+	}
+	/** Create the standard set of channels for Abracadabra WebRTC. */
+	createDefaultChannels(opts) {
+		if (opts.enableDocSync) this.createChannel(CHANNEL_NAMES.YJS_SYNC, { ordered: true });
+		if (opts.enableAwareness) this.createChannel(CHANNEL_NAMES.AWARENESS, {
+			ordered: false,
+			maxRetransmits: 0
+		});
+		if (opts.enableFileTransfer) this.createChannel(CHANNEL_NAMES.FILE_TRANSFER, { ordered: true });
+	}
+	getChannel(name) {
+		return this.channels.get(name) ?? null;
+	}
+	isOpen(name) {
+		return this.channels.get(name)?.readyState === "open";
+	}
+	registerChannel(channel) {
+		channel.binaryType = "arraybuffer";
+		this.channels.set(channel.label, channel);
+		channel.onopen = () => {
+			this.emit("channelOpen", {
+				name: channel.label,
+				channel
+			});
+		};
+		channel.onclose = () => {
+			this.emit("channelClose", { name: channel.label });
+			this.channels.delete(channel.label);
+		};
+		channel.onmessage = (event) => {
+			this.emit("channelMessage", {
+				name: channel.label,
+				data: event.data
+			});
+		};
+		channel.onerror = (event) => {
+			this.emit("channelError", {
+				name: channel.label,
+				error: event
+			});
+		};
+		if (channel.readyState === "open") this.emit("channelOpen", {
+			name: channel.label,
+			channel
+		});
+	}
+	close() {
+		for (const channel of this.channels.values()) try {
+			channel.close();
+		} catch {}
+		this.channels.clear();
+	}
+	destroy() {
+		this.close();
+		this.connection.ondatachannel = null;
+		this.removeAllListeners();
+	}
+};
+
+//#endregion
+//#region packages/provider/src/webrtc/PeerConnection.ts
+var PeerConnection = class extends EventEmitter {
+	constructor(peerId, iceServers) {
+		super();
+		this.pendingCandidates = [];
+		this.hasRemoteDescription = false;
+		this.peerId = peerId;
+		this.connection = new RTCPeerConnection({ iceServers });
+		this.router = new DataChannelRouter(this.connection);
+		this.connection.onicecandidate = (event) => {
+			if (event.candidate) this.emit("iceCandidate", {
+				peerId: this.peerId,
+				candidate: JSON.stringify(event.candidate.toJSON())
+			});
+		};
+		this.connection.oniceconnectionstatechange = () => {
+			const state = this.connection.iceConnectionState;
+			this.emit("iceStateChange", {
+				peerId: this.peerId,
+				state
+			});
+			if (state === "failed") this.emit("iceFailed", { peerId: this.peerId });
+		};
+		this.connection.onconnectionstatechange = () => {
+			this.emit("connectionStateChange", {
+				peerId: this.peerId,
+				state: this.connection.connectionState
+			});
+		};
+	}
+	get connectionState() {
+		return this.connection.connectionState;
+	}
+	get iceConnectionState() {
+		return this.connection.iceConnectionState;
+	}
+	/** Create an SDP offer (initiator side). */
+	async createOffer(iceRestart = false) {
+		const offer = await this.connection.createOffer(iceRestart ? { iceRestart: true } : void 0);
+		await this.connection.setLocalDescription(offer);
+		return JSON.stringify(this.connection.localDescription?.toJSON());
+	}
+	/** Set a remote offer and create an answer (receiver side). Returns the SDP answer. */
+	async setRemoteOffer(sdp) {
+		const offer = JSON.parse(sdp);
+		await this.connection.setRemoteDescription(new RTCSessionDescription(offer));
+		this.hasRemoteDescription = true;
+		await this.flushPendingCandidates();
+		const answer = await this.connection.createAnswer();
+		await this.connection.setLocalDescription(answer);
+		return JSON.stringify(this.connection.localDescription?.toJSON());
+	}
+	/** Set the remote answer (initiator side). */
+	async setRemoteAnswer(sdp) {
+		const answer = JSON.parse(sdp);
+		await this.connection.setRemoteDescription(new RTCSessionDescription(answer));
+		this.hasRemoteDescription = true;
+		await this.flushPendingCandidates();
+	}
+	/** Add a remote ICE candidate. Queues if remote description not yet set. */
+	async addIceCandidate(candidateJson) {
+		const candidate = JSON.parse(candidateJson);
+		if (!this.hasRemoteDescription) {
+			this.pendingCandidates.push(candidate);
+			return;
+		}
+		await this.connection.addIceCandidate(new RTCIceCandidate(candidate));
+	}
+	async flushPendingCandidates() {
+		for (const candidate of this.pendingCandidates) await this.connection.addIceCandidate(new RTCIceCandidate(candidate));
+		this.pendingCandidates = [];
+	}
+	close() {
+		this.router.close();
+		try {
+			this.connection.close();
+		} catch {}
+	}
+	destroy() {
+		this.router.destroy();
+		this.connection.onicecandidate = null;
+		this.connection.oniceconnectionstatechange = null;
+		this.connection.onconnectionstatechange = null;
+		try {
+			this.connection.close();
+		} catch {}
+		this.removeAllListeners();
+	}
+};
+
+//#endregion
+//#region packages/provider/src/webrtc/YjsDataChannel.ts
+/**
+* Handles Y.js document sync and awareness over WebRTC data channels.
+*
+* Uses the same y-protocols/sync encoding as the WebSocket provider but
+* transported over RTCDataChannel instead. A unique origin is used to
+* prevent echo loops with the server-based provider.
+*/
+var YjsDataChannel = class {
+	constructor(document, awareness, router) {
+		this.document = document;
+		this.awareness = awareness;
+		this.router = router;
+		this.docUpdateHandler = null;
+		this.awarenessUpdateHandler = null;
+		this.channelOpenHandler = null;
+		this.channelMessageHandler = null;
+	}
+	/** Start listening for Y.js updates and data channel messages. */
+	attach() {
+		this.docUpdateHandler = (update, origin) => {
+			if (origin === this) return;
+			const channel = this.router.getChannel(CHANNEL_NAMES.YJS_SYNC);
+			if (!channel || channel.readyState !== "open") return;
+			const encoder = createEncoder();
+			writeVarUint(encoder, YJS_MSG.UPDATE);
+			writeVarUint8Array(encoder, update);
+			channel.send(toUint8Array(encoder));
+		};
+		this.document.on("update", this.docUpdateHandler);
+		if (this.awareness) {
+			this.awarenessUpdateHandler = ({ added, updated, removed }, _origin) => {
+				const channel = this.router.getChannel(CHANNEL_NAMES.AWARENESS);
+				if (!channel || channel.readyState !== "open") return;
+				const changedClients = added.concat(updated).concat(removed);
+				const update = encodeAwarenessUpdate(this.awareness, changedClients);
+				channel.send(update);
+			};
+			this.awareness.on("update", this.awarenessUpdateHandler);
+		}
+		this.channelMessageHandler = ({ name, data }) => {
+			if (name === CHANNEL_NAMES.YJS_SYNC) this.handleSyncMessage(data);
+			else if (name === CHANNEL_NAMES.AWARENESS) this.handleAwarenessMessage(data);
+		};
+		this.router.on("channelMessage", this.channelMessageHandler);
+		this.channelOpenHandler = ({ name }) => {
+			if (name === CHANNEL_NAMES.YJS_SYNC) this.sendSyncStep1();
+			else if (name === CHANNEL_NAMES.AWARENESS && this.awareness) {
+				const channel = this.router.getChannel(CHANNEL_NAMES.AWARENESS);
+				if (channel?.readyState === "open") {
+					const update = encodeAwarenessUpdate(this.awareness, Array.from(this.awareness.getStates().keys()));
+					channel.send(update);
+				}
+			}
+		};
+		this.router.on("channelOpen", this.channelOpenHandler);
+		if (this.router.isOpen(CHANNEL_NAMES.YJS_SYNC)) this.sendSyncStep1();
+		if (this.awareness && this.router.isOpen(CHANNEL_NAMES.AWARENESS)) {
+			const channel = this.router.getChannel(CHANNEL_NAMES.AWARENESS);
+			if (channel?.readyState === "open") {
+				const update = encodeAwarenessUpdate(this.awareness, Array.from(this.awareness.getStates().keys()));
+				channel.send(update);
+			}
+		}
+	}
+	/** Stop listening and clean up handlers. */
+	detach() {
+		if (this.docUpdateHandler) {
+			this.document.off("update", this.docUpdateHandler);
+			this.docUpdateHandler = null;
+		}
+		if (this.awarenessUpdateHandler && this.awareness) {
+			this.awareness.off("update", this.awarenessUpdateHandler);
+			this.awarenessUpdateHandler = null;
+		}
+		if (this.channelMessageHandler) {
+			this.router.off("channelMessage", this.channelMessageHandler);
+			this.channelMessageHandler = null;
+		}
+		if (this.channelOpenHandler) {
+			this.router.off("channelOpen", this.channelOpenHandler);
+			this.channelOpenHandler = null;
+		}
+		this.isSynced = false;
+	}
+	destroy() {
+		this.detach();
+	}
+	sendSyncStep1() {
+		const channel = this.router.getChannel(CHANNEL_NAMES.YJS_SYNC);
+		if (!channel || channel.readyState !== "open") return;
+		const encoder = createEncoder();
+		writeVarUint(encoder, YJS_MSG.SYNC);
+		writeSyncStep1(encoder, this.document);
+		channel.send(toUint8Array(encoder));
+	}
+	handleSyncMessage(data) {
+		const buf = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+		const decoder = createDecoder(buf);
+		const msgType = readVarUint(decoder);
+		if (msgType === YJS_MSG.SYNC) {
+			const encoder = createEncoder();
+			const syncMessageType = readSyncMessage(decoder, encoder, this.document, this);
+			if (length(encoder) > 0) {
+				const responseEncoder = createEncoder();
+				writeVarUint(responseEncoder, YJS_MSG.SYNC);
+				writeUint8Array(responseEncoder, toUint8Array(encoder));
+				const channel = this.router.getChannel(CHANNEL_NAMES.YJS_SYNC);
+				if (channel?.readyState === "open") channel.send(toUint8Array(responseEncoder));
+			}
+			if (syncMessageType === messageYjsSyncStep2) this.isSynced = true;
+		} else if (msgType === YJS_MSG.UPDATE) {
+			const update = readVarUint8Array(decoder);
+			yjs.applyUpdate(this.document, update, this);
+		}
+	}
+	handleAwarenessMessage(data) {
+		if (!this.awareness) return;
+		const buf = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+		applyAwarenessUpdate(this.awareness, buf, this);
+	}
+};
+
+//#endregion
+//#region packages/provider/src/webrtc/FileTransferChannel.ts
+/**
+* Handle for tracking a file transfer in progress.
+*/
+var FileTransferHandle = class extends EventEmitter {
+	constructor(transferId) {
+		super();
+		this.progress = 0;
+		this.status = "pending";
+		this.abortController = new AbortController();
+		this.transferId = transferId;
+	}
+	cancel() {
+		this.status = "cancelled";
+		this.abortController.abort();
+		this.emit("cancelled");
+	}
+	get signal() {
+		return this.abortController.signal;
+	}
+	/** @internal */
+	_setProgress(p) {
+		this.progress = p;
+		this.emit("progress", p);
+	}
+	/** @internal */
+	_setStatus(s) {
+		this.status = s;
+	}
+};
+/**
+* Chunked binary file transfer over a dedicated WebRTC data channel.
+*/
+var FileTransferChannel = class extends EventEmitter {
+	constructor(router, chunkSize) {
+		super();
+		this.router = router;
+		this.receives = /* @__PURE__ */ new Map();
+		this.channelMessageHandler = null;
+		this.chunkSize = chunkSize ?? DEFAULT_FILE_CHUNK_SIZE;
+		this.channelMessageHandler = ({ name, data }) => {
+			if (name === CHANNEL_NAMES.FILE_TRANSFER) this.handleMessage(data);
+		};
+		this.router.on("channelMessage", this.channelMessageHandler);
+	}
+	/** Send a file to a peer. Returns a handle for tracking progress. */
+	async send(file, filename) {
+		const transferId = generateTransferId();
+		const handle = new FileTransferHandle(transferId);
+		const transferIdBytes = hexToBytes(transferId);
+		const totalSize = file.size;
+		const totalChunks = Math.ceil(totalSize / this.chunkSize);
+		const meta = {
+			transferId,
+			filename,
+			mimeType: file instanceof File ? file.type : "application/octet-stream",
+			totalSize,
+			chunkSize: this.chunkSize,
+			totalChunks
+		};
+		const channel = this.router.getChannel(CHANNEL_NAMES.FILE_TRANSFER);
+		if (!channel || channel.readyState !== "open") {
+			handle._setStatus("error");
+			handle.emit("error", /* @__PURE__ */ new Error("File transfer channel not open"));
+			return handle;
+		}
+		const startMsg = new Uint8Array(1 + new TextEncoder().encode(JSON.stringify(meta)).length);
+		startMsg[0] = FILE_MSG.START;
+		startMsg.set(new TextEncoder().encode(JSON.stringify(meta)), 1);
+		channel.send(startMsg);
+		handle._setStatus("sending");
+		const arrayBuffer = await file.arrayBuffer();
+		const fileBytes = new Uint8Array(arrayBuffer);
+		const hashBuffer = await crypto.subtle.digest("SHA-256", fileBytes);
+		const hashBytes = new Uint8Array(hashBuffer);
+		for (let i = 0; i < totalChunks; i++) {
+			if (handle.signal.aborted) {
+				const cancelMsg = new Uint8Array(1 + TRANSFER_ID_BYTES);
+				cancelMsg[0] = FILE_MSG.CANCEL;
+				cancelMsg.set(transferIdBytes, 1);
+				channel.send(cancelMsg);
+				return handle;
+			}
+			const offset = i * this.chunkSize;
+			const chunk = fileBytes.slice(offset, Math.min(offset + this.chunkSize, totalSize));
+			const msg = new Uint8Array(1 + TRANSFER_ID_BYTES + 4 + chunk.length);
+			msg[0] = FILE_MSG.CHUNK;
+			msg.set(transferIdBytes, 1);
+			new DataView(msg.buffer).setUint32(1 + TRANSFER_ID_BYTES, i, false);
+			msg.set(chunk, 1 + TRANSFER_ID_BYTES + 4);
+			while (channel.bufferedAmount > this.chunkSize * 4) {
+				await new Promise((resolve) => setTimeout(resolve, 10));
+				if (handle.signal.aborted) return handle;
+			}
+			channel.send(msg);
+			handle._setProgress((i + 1) / totalChunks);
+		}
+		const completeMsg = new Uint8Array(1 + TRANSFER_ID_BYTES + SHA256_BYTES);
+		completeMsg[0] = FILE_MSG.COMPLETE;
+		completeMsg.set(transferIdBytes, 1);
+		completeMsg.set(hashBytes, 1 + TRANSFER_ID_BYTES);
+		channel.send(completeMsg);
+		handle._setStatus("complete");
+		handle.emit("complete");
+		return handle;
+	}
+	handleMessage(data) {
+		const buf = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+		if (buf.length < 1) return;
+		switch (buf[0]) {
+			case FILE_MSG.START:
+				this.handleStart(buf);
+				break;
+			case FILE_MSG.CHUNK:
+				this.handleChunk(buf);
+				break;
+			case FILE_MSG.COMPLETE:
+				this.handleComplete(buf);
+				break;
+			case FILE_MSG.CANCEL:
+				this.handleCancel(buf);
+				break;
+		}
+	}
+	handleStart(buf) {
+		const json = new TextDecoder().decode(buf.slice(1));
+		let meta;
+		try {
+			meta = JSON.parse(json);
+		} catch {
+			return;
+		}
+		this.receives.set(meta.transferId, {
+			meta,
+			chunks: new Array(meta.totalChunks).fill(null),
+			receivedCount: 0
+		});
+		this.emit("receiveStart", meta);
+	}
+	handleChunk(buf) {
+		if (buf.length < 1 + TRANSFER_ID_BYTES + 4) return;
+		const transferId = bytesToHex(buf.slice(1, 1 + TRANSFER_ID_BYTES));
+		const chunkIndex = new DataView(buf.buffer, buf.byteOffset).getUint32(1 + TRANSFER_ID_BYTES, false);
+		const chunkData = buf.slice(1 + TRANSFER_ID_BYTES + 4);
+		const state = this.receives.get(transferId);
+		if (!state) return;
+		if (chunkIndex < state.chunks.length && !state.chunks[chunkIndex]) {
+			state.chunks[chunkIndex] = chunkData;
+			state.receivedCount++;
+			const progress = state.receivedCount / state.meta.totalChunks;
+			this.emit("receiveProgress", {
+				transferId,
+				received: state.receivedCount,
+				total: state.meta.totalChunks,
+				progress
+			});
+		}
+	}
+	async handleComplete(buf) {
+		if (buf.length < 1 + TRANSFER_ID_BYTES + SHA256_BYTES) return;
+		const transferId = bytesToHex(buf.slice(1, 1 + TRANSFER_ID_BYTES));
+		const expectedHash = buf.slice(1 + TRANSFER_ID_BYTES, 1 + TRANSFER_ID_BYTES + SHA256_BYTES);
+		const state = this.receives.get(transferId);
+		if (!state) return;
+		const totalSize = state.meta.totalSize;
+		const assembled = new Uint8Array(totalSize);
+		let offset = 0;
+		for (let i = 0; i < state.chunks.length; i++) {
+			const chunk = state.chunks[i];
+			if (!chunk) {
+				this.emit("receiveError", {
+					transferId,
+					error: `Missing chunk ${i}`
+				});
+				this.receives.delete(transferId);
+				return;
+			}
+			assembled.set(chunk, offset);
+			offset += chunk.length;
+		}
+		const actualHashBuffer = await crypto.subtle.digest("SHA-256", assembled);
+		if (!constantTimeEqual(expectedHash, new Uint8Array(actualHashBuffer))) {
+			this.emit("receiveError", {
+				transferId,
+				error: "SHA-256 integrity check failed"
+			});
+			this.receives.delete(transferId);
+			return;
+		}
+		const blob = new Blob([assembled], { type: state.meta.mimeType });
+		this.emit("receiveComplete", {
+			transferId,
+			blob,
+			filename: state.meta.filename,
+			mimeType: state.meta.mimeType,
+			size: state.meta.totalSize
+		});
+		this.receives.delete(transferId);
+	}
+	handleCancel(buf) {
+		if (buf.length < 1 + TRANSFER_ID_BYTES) return;
+		const transferId = bytesToHex(buf.slice(1, 1 + TRANSFER_ID_BYTES));
+		this.receives.delete(transferId);
+		this.emit("receiveCancelled", { transferId });
+	}
+	destroy() {
+		if (this.channelMessageHandler) {
+			this.router.off("channelMessage", this.channelMessageHandler);
+			this.channelMessageHandler = null;
+		}
+		this.receives.clear();
+		this.removeAllListeners();
+	}
+};
+function generateTransferId() {
+	const bytes = new Uint8Array(TRANSFER_ID_BYTES);
+	crypto.getRandomValues(bytes);
+	return bytesToHex(bytes);
+}
+function bytesToHex(bytes) {
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(hex) {
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < hex.length; i += 2) bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+	return bytes;
+}
+function constantTimeEqual(a, b) {
+	if (a.length !== b.length) return false;
+	let result = 0;
+	for (let i = 0; i < a.length; i++) result |= a[i] ^ b[i];
+	return result === 0;
+}
+
+//#endregion
+//#region packages/provider/src/webrtc/AbracadabraWebRTC.ts
+const HAS_RTC = typeof globalThis.RTCPeerConnection !== "undefined";
+/**
+* Optional WebRTC provider for peer-to-peer Y.js sync, awareness, and file transfer.
+*
+* Uses the server's signaling endpoint (`/ws/:doc_id/signaling`) for connection
+* negotiation, then establishes direct data channels between peers. Designed to
+* work alongside `AbracadabraProvider` — the server remains the persistence layer,
+* while WebRTC provides low-latency P2P sync.
+*
+* Falls back to a no-op when `RTCPeerConnection` is unavailable (e.g. Node.js).
+*/
+var AbracadabraWebRTC = class AbracadabraWebRTC extends EventEmitter {
+	constructor(configuration) {
+		super();
+		this.signaling = null;
+		this.peerConnections = /* @__PURE__ */ new Map();
+		this.yjsChannels = /* @__PURE__ */ new Map();
+		this.fileChannels = /* @__PURE__ */ new Map();
+		this.peers = /* @__PURE__ */ new Map();
+		this.localPeerId = null;
+		this.isConnected = false;
+		const doc = configuration.document ?? null;
+		const awareness = configuration.awareness ?? null;
+		this.config = {
+			docId: configuration.docId,
+			url: configuration.url,
+			token: configuration.token,
+			document: doc,
+			awareness,
+			iceServers: configuration.iceServers ?? DEFAULT_ICE_SERVERS,
+			displayName: configuration.displayName ?? null,
+			color: configuration.color ?? null,
+			enableDocSync: configuration.enableDocSync ?? !!doc,
+			enableAwarenessSync: configuration.enableAwarenessSync ?? !!awareness,
+			enableFileTransfer: configuration.enableFileTransfer ?? false,
+			fileChunkSize: configuration.fileChunkSize ?? 16384,
+			WebSocketPolyfill: configuration.WebSocketPolyfill
+		};
+		if (configuration.autoConnect !== false && HAS_RTC) this.connect();
+	}
+	/**
+	* Create an AbracadabraWebRTC instance from an existing provider,
+	* reusing its document, awareness, URL, and token.
+	*/
+	static fromProvider(provider, options) {
+		const config = provider.configuration;
+		const httpUrl = (config.websocketProvider?.url ?? config.url ?? "").replace(/^wss:/, "https:").replace(/^ws:/, "http:");
+		return new AbracadabraWebRTC({
+			docId: config.name,
+			url: httpUrl,
+			token: config.token,
+			document: provider.document,
+			awareness: provider.awareness,
+			...options
+		});
+	}
+	async connect() {
+		if (!HAS_RTC) return;
+		if (this.isConnected) return;
+		this.signaling = new SignalingSocket({
+			url: this.buildSignalingUrl(),
+			token: this.config.token,
+			autoConnect: false,
+			WebSocketPolyfill: this.config.WebSocketPolyfill
+		});
+		this.signaling.on("welcome", (data) => {
+			this.localPeerId = data.peerId;
+			this.isConnected = true;
+			this.emit("connected");
+			if (this.config.displayName && this.config.color) this.signaling.sendProfile(this.config.displayName, this.config.color);
+			for (const peer of data.peers) {
+				this.addPeer(peer);
+				if (this.localPeerId < peer.peer_id) this.initiateConnection(peer.peer_id);
+			}
+		});
+		this.signaling.on("joined", (peer) => {
+			this.addPeer(peer);
+			this.emit("peerJoined", peer);
+			if (this.localPeerId < peer.peer_id) this.initiateConnection(peer.peer_id);
+		});
+		this.signaling.on("left", ({ peerId }) => {
+			this.removePeer(peerId);
+			this.emit("peerLeft", { peerId });
+		});
+		this.signaling.on("offer", async ({ from, sdp }) => {
+			await this.handleOffer(from, sdp);
+		});
+		this.signaling.on("answer", async ({ from, sdp }) => {
+			const pc = this.peerConnections.get(from);
+			if (pc) await pc.setRemoteAnswer(sdp);
+		});
+		this.signaling.on("ice", async ({ from, candidate }) => {
+			const pc = this.peerConnections.get(from);
+			if (pc) await pc.addIceCandidate(candidate);
+		});
+		this.signaling.on("mute", ({ peerId, muted }) => {
+			const peer = this.peers.get(peerId);
+			if (peer) {
+				peer.muted = muted;
+				this.emit("peerMuted", {
+					peerId,
+					muted
+				});
+			}
+		});
+		this.signaling.on("media-state", ({ peerId, video, screen }) => {
+			const peer = this.peers.get(peerId);
+			if (peer) {
+				peer.video = video;
+				peer.screen = screen;
+				this.emit("peerMediaState", {
+					peerId,
+					video,
+					screen
+				});
+			}
+		});
+		this.signaling.on("profile", ({ peerId, name, color }) => {
+			const peer = this.peers.get(peerId);
+			if (peer) {
+				peer.name = name;
+				peer.color = color;
+				this.emit("peerProfile", {
+					peerId,
+					name,
+					color
+				});
+			}
+		});
+		this.signaling.on("disconnected", () => {
+			this.isConnected = false;
+			this.localPeerId = null;
+			this.removeAllPeers();
+			this.emit("disconnected");
+		});
+		this.signaling.on("error", (err) => {
+			this.emit("signalingError", err);
+		});
+		await this.signaling.connect();
+	}
+	disconnect() {
+		if (!HAS_RTC) return;
+		this.removeAllPeers();
+		if (this.signaling) {
+			this.signaling.disconnect();
+			this.signaling = null;
+		}
+		this.isConnected = false;
+		this.localPeerId = null;
+	}
+	destroy() {
+		this.disconnect();
+		if (this.signaling) {
+			this.signaling.destroy();
+			this.signaling = null;
+		}
+		this.removeAllListeners();
+	}
+	setMuted(muted) {
+		this.signaling?.sendMute(muted);
+	}
+	setMediaState(video, screen) {
+		this.signaling?.sendMediaState(video, screen);
+	}
+	setProfile(name, color) {
+		this.signaling?.sendProfile(name, color);
+	}
+	/**
+	* Send a file to a specific peer. Returns a handle for tracking progress.
+	*/
+	async sendFile(peerId, file, filename) {
+		const fc = this.fileChannels.get(peerId);
+		if (!fc) return null;
+		return fc.send(file, filename);
+	}
+	/**
+	* Send a file to all connected peers. Returns an array of handles.
+	*/
+	async broadcastFile(file, filename) {
+		const handles = [];
+		for (const [peerId, fc] of this.fileChannels) {
+			const handle = await fc.send(file, filename);
+			handles.push(handle);
+		}
+		return handles;
+	}
+	/**
+	* Send a custom string message to a specific peer via a data channel.
+	*/
+	sendCustomMessage(peerId, payload) {
+		const pc = this.peerConnections.get(peerId);
+		if (!pc) return;
+		let channel = pc.router.getChannel("custom");
+		if (!channel || channel.readyState !== "open") {
+			channel = pc.router.createChannel("custom", { ordered: true });
+			channel.onopen = () => {
+				channel.send(payload);
+			};
+			return;
+		}
+		channel.send(payload);
+	}
+	/**
+	* Send a custom string message to all connected peers.
+	*/
+	broadcastCustomMessage(payload) {
+		for (const peerId of this.peerConnections.keys()) this.sendCustomMessage(peerId, payload);
+	}
+	addPeer(info) {
+		this.peers.set(info.peer_id, {
+			...info,
+			connectionState: "new"
+		});
+	}
+	removePeer(peerId) {
+		this.peers.delete(peerId);
+		const yjs = this.yjsChannels.get(peerId);
+		if (yjs) {
+			yjs.destroy();
+			this.yjsChannels.delete(peerId);
+		}
+		const fc = this.fileChannels.get(peerId);
+		if (fc) {
+			fc.destroy();
+			this.fileChannels.delete(peerId);
+		}
+		const pc = this.peerConnections.get(peerId);
+		if (pc) {
+			pc.destroy();
+			this.peerConnections.delete(peerId);
+		}
+	}
+	removeAllPeers() {
+		for (const peerId of [...this.peers.keys()]) this.removePeer(peerId);
+	}
+	createPeerConnection(peerId) {
+		const pc = new PeerConnection(peerId, this.config.iceServers);
+		pc.on("iceCandidate", ({ peerId, candidate }) => {
+			this.signaling?.sendIce(peerId, candidate);
+		});
+		pc.on("iceFailed", async ({ peerId }) => {
+			try {
+				const sdp = await pc.createOffer(true);
+				this.signaling?.sendOffer(peerId, sdp);
+			} catch {
+				this.removePeer(peerId);
+			}
+		});
+		pc.on("connectionStateChange", ({ peerId, state }) => {
+			const peer = this.peers.get(peerId);
+			if (peer) peer.connectionState = state;
+			if (state === "disconnected" || state === "closed") {}
+			this.emit("peerConnectionState", {
+				peerId,
+				state
+			});
+		});
+		pc.router.on("channelMessage", ({ name, data }) => {
+			if (name === "custom") {
+				const payload = typeof data === "string" ? data : new TextDecoder().decode(data);
+				this.emit("customMessage", {
+					peerId,
+					payload
+				});
+			}
+		});
+		this.peerConnections.set(peerId, pc);
+		this.attachDataHandlers(peerId, pc);
+		return pc;
+	}
+	attachDataHandlers(peerId, pc) {
+		if (this.config.document && this.config.enableDocSync) {
+			const yjs = new YjsDataChannel(this.config.document, this.config.enableAwarenessSync ? this.config.awareness : null, pc.router);
+			yjs.attach();
+			this.yjsChannels.set(peerId, yjs);
+		}
+		if (this.config.enableFileTransfer) {
+			const fc = new FileTransferChannel(pc.router, this.config.fileChunkSize);
+			fc.on("receiveStart", (meta) => {
+				this.emit("fileReceiveStart", {
+					peerId,
+					...meta
+				});
+			});
+			fc.on("receiveProgress", (data) => {
+				this.emit("fileReceiveProgress", {
+					peerId,
+					...data
+				});
+			});
+			fc.on("receiveComplete", (data) => {
+				this.emit("fileReceiveComplete", {
+					peerId,
+					...data
+				});
+			});
+			fc.on("receiveError", (data) => {
+				this.emit("fileReceiveError", {
+					peerId,
+					...data
+				});
+			});
+			fc.on("receiveCancelled", (data) => {
+				this.emit("fileReceiveCancelled", {
+					peerId,
+					...data
+				});
+			});
+			this.fileChannels.set(peerId, fc);
+		}
+	}
+	async initiateConnection(peerId) {
+		const pc = this.createPeerConnection(peerId);
+		pc.router.createDefaultChannels({
+			enableDocSync: this.config.enableDocSync,
+			enableAwareness: this.config.enableAwarenessSync,
+			enableFileTransfer: this.config.enableFileTransfer
+		});
+		try {
+			const sdp = await pc.createOffer();
+			this.signaling?.sendOffer(peerId, sdp);
+		} catch {
+			this.removePeer(peerId);
+		}
+	}
+	async handleOffer(from, sdp) {
+		const existing = this.peerConnections.get(from);
+		if (existing) {
+			existing.destroy();
+			this.yjsChannels.get(from)?.destroy();
+			this.yjsChannels.delete(from);
+			this.fileChannels.get(from)?.destroy();
+			this.fileChannels.delete(from);
+			this.peerConnections.delete(from);
+		}
+		const pc = this.createPeerConnection(from);
+		try {
+			const answerSdp = await pc.setRemoteOffer(sdp);
+			this.signaling?.sendAnswer(from, answerSdp);
+		} catch {
+			this.removePeer(from);
+		}
+	}
+	buildSignalingUrl() {
+		let base = this.config.url;
+		while (base.endsWith("/")) base = base.slice(0, -1);
+		base = base.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+		return `${base}/ws/${encodeURIComponent(this.config.docId)}/signaling`;
+	}
+};
+
 //#endregion
 exports.AbracadabraBaseProvider = AbracadabraBaseProvider;
 exports.AbracadabraClient = AbracadabraClient;
 exports.AbracadabraProvider = AbracadabraProvider;
 exports.AbracadabraWS = AbracadabraWS;
+exports.AbracadabraWebRTC = AbracadabraWebRTC;
 exports.AuthMessageType = AuthMessageType;
 exports.AwarenessError = AwarenessError;
 exports.BackgroundSyncManager = BackgroundSyncManager;
 exports.BackgroundSyncPersistence = BackgroundSyncPersistence;
+exports.CHANNEL_NAMES = CHANNEL_NAMES;
 exports.ConnectionTimeout = ConnectionTimeout;
 exports.CryptoIdentityKeystore = CryptoIdentityKeystore;
+exports.DEFAULT_FILE_CHUNK_SIZE = DEFAULT_FILE_CHUNK_SIZE;
+exports.DEFAULT_ICE_SERVERS = DEFAULT_ICE_SERVERS;
+exports.DataChannelRouter = DataChannelRouter;
 exports.DocKeyManager = DocKeyManager;
 exports.DocumentCache = DocumentCache;
 exports.E2EAbracadabraProvider = E2EAbracadabraProvider;
@@ -8465,18 +9646,23 @@ exports.E2EOfflineStore = E2EOfflineStore;
 exports.EncryptedYMap = EncryptedYMap;
 exports.EncryptedYText = EncryptedYText;
 exports.FileBlobStore = FileBlobStore;
+exports.FileTransferChannel = FileTransferChannel;
+exports.FileTransferHandle = FileTransferHandle;
 exports.Forbidden = Forbidden;
 exports.HocuspocusProvider = HocuspocusProvider;
 exports.HocuspocusProviderWebsocket = HocuspocusProviderWebsocket;
 exports.MessageTooBig = MessageTooBig;
 exports.MessageType = MessageType;
 exports.OfflineStore = OfflineStore;
+exports.PeerConnection = PeerConnection;
 exports.ResetConnection = ResetConnection;
 exports.SearchIndex = SearchIndex;
+exports.SignalingSocket = SignalingSocket;
 exports.SubdocMessage = SubdocMessage;
 exports.Unauthorized = Unauthorized;
 exports.WebSocketStatus = WebSocketStatus;
 exports.WsReadyStates = WsReadyStates;
+exports.YjsDataChannel = YjsDataChannel;
 exports.attachUpdatedAtObserver = attachUpdatedAtObserver;
 exports.awarenessStatesToArray = awarenessStatesToArray;
 exports.decryptField = decryptField;