@abraca/dabra 1.0.3 → 1.0.5

package/src/webrtc/YjsDataChannel.ts

@@ -23,11 +23,26 @@ export class YjsDataChannel {
 	private channelOpenHandler: ((data: { name: string; channel: RTCDataChannel }) => void) | null = null;
 	private channelMessageHandler: ((data: { name: string; data: any }) => void) | null = null;
 
+	/** Channel names used for sync and awareness (supports namespaced subdoc channels). */
+	private readonly syncChannelName: string;
+	private readonly awarenessChannelName: string;
+
+	/**
+	 * @param document - The Y.Doc to sync
+	 * @param awareness - Optional Awareness instance
+	 * @param router - DataChannelRouter for the peer connection
+	 * @param channelPrefix - Optional prefix for subdocument channels (e.g. `"{childId}:"`)
+	 */
 	constructor(
 		private readonly document: Y.Doc,
 		private readonly awareness: Awareness | null,
 		private readonly router: DataChannelRouter,
-	) {}
+		channelPrefix?: string,
+	) {
+		const prefix = channelPrefix ?? "";
+		this.syncChannelName = `${prefix}${CHANNEL_NAMES.YJS_SYNC}`;
+		this.awarenessChannelName = `${prefix}${CHANNEL_NAMES.AWARENESS}`;
+	}
 
 	/** Start listening for Y.js updates and data channel messages. */
 	attach(): void {
@@ -36,13 +51,12 @@ export class YjsDataChannel {
 			// Don't echo updates we received from this data channel.
 			if (origin === this) return;
 
-			const channel = this.router.getChannel(CHANNEL_NAMES.YJS_SYNC);
-			if (!channel || channel.readyState !== "open") return;
+			if (!this.router.isOpen(this.syncChannelName)) return;
 
 			const encoder = encoding.createEncoder();
 			encoding.writeVarUint(encoder, YJS_MSG.UPDATE);
 			encoding.writeVarUint8Array(encoder, update);
-			channel.send(encoding.toUint8Array(encoder));
+			this.router.send(this.syncChannelName, encoding.toUint8Array(encoder));
 		};
 		this.document.on("update", this.docUpdateHandler);
 
@@ -52,21 +66,20 @@ export class YjsDataChannel {
 				{ added, updated, removed }: { added: number[]; updated: number[]; removed: number[] },
 				_origin: any,
 			) => {
-				const channel = this.router.getChannel(CHANNEL_NAMES.AWARENESS);
-				if (!channel || channel.readyState !== "open") return;
+				if (!this.router.isOpen(this.awarenessChannelName)) return;
 
 				const changedClients = added.concat(updated).concat(removed);
 				const update = encodeAwarenessUpdate(this.awareness!, changedClients);
-				channel.send(update);
+				this.router.send(this.awarenessChannelName, update);
 			};
 			this.awareness.on("update", this.awarenessUpdateHandler);
 		}
 
 		// Handle incoming data channel messages.
 		this.channelMessageHandler = ({ name, data }: { name: string; data: any }) => {
-			if (name === CHANNEL_NAMES.YJS_SYNC) {
+			if (name === this.syncChannelName) {
 				this.handleSyncMessage(data);
-			} else if (name === CHANNEL_NAMES.AWARENESS) {
+			} else if (name === this.awarenessChannelName) {
 				this.handleAwarenessMessage(data);
 			}
 		};
@@ -74,37 +87,33 @@ export class YjsDataChannel {
 
 		// When sync channel opens, initiate sync handshake.
 		this.channelOpenHandler = ({ name }: { name: string; channel: RTCDataChannel }) => {
-			if (name === CHANNEL_NAMES.YJS_SYNC) {
+			if (name === this.syncChannelName) {
 				this.sendSyncStep1();
-			} else if (name === CHANNEL_NAMES.AWARENESS && this.awareness) {
+			} else if (name === this.awarenessChannelName && this.awareness) {
 				// Send full awareness state on channel open.
-				const channel = this.router.getChannel(CHANNEL_NAMES.AWARENESS);
-				if (channel?.readyState === "open") {
+				if (this.router.isOpen(this.awarenessChannelName)) {
 					const update = encodeAwarenessUpdate(
 						this.awareness,
 						Array.from(this.awareness.getStates().keys()),
 					);
-					channel.send(update);
+					this.router.send(this.awarenessChannelName, update);
 				}
 			}
 		};
 		this.router.on("channelOpen", this.channelOpenHandler);
 
 		// If sync channel is already open, start sync immediately.
-		if (this.router.isOpen(CHANNEL_NAMES.YJS_SYNC)) {
+		if (this.router.isOpen(this.syncChannelName)) {
 			this.sendSyncStep1();
 		}
 
 		// If awareness channel is already open, send state immediately.
-		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);
-			}
+		if (this.awareness && this.router.isOpen(this.awarenessChannelName)) {
+			const update = encodeAwarenessUpdate(
+				this.awareness,
+				Array.from(this.awareness.getStates().keys()),
+			);
+			this.router.send(this.awarenessChannelName, update);
 		}
 	}
 
@@ -138,13 +147,12 @@ export class YjsDataChannel {
 	}
 
 	private sendSyncStep1(): void {
-		const channel = this.router.getChannel(CHANNEL_NAMES.YJS_SYNC);
-		if (!channel || channel.readyState !== "open") return;
+		if (!this.router.isOpen(this.syncChannelName)) return;
 
 		const encoder = encoding.createEncoder();
 		encoding.writeVarUint(encoder, YJS_MSG.SYNC);
 		syncProtocol.writeSyncStep1(encoder, this.document);
-		channel.send(encoding.toUint8Array(encoder));
+		this.router.send(this.syncChannelName, encoding.toUint8Array(encoder));
 	}
 
 	private handleSyncMessage(data: ArrayBuffer | Uint8Array): void {
@@ -170,9 +178,8 @@ export class YjsDataChannel {
 					responseEncoder,
 					encoding.toUint8Array(encoder),
 				);
-				const channel = this.router.getChannel(CHANNEL_NAMES.YJS_SYNC);
-				if (channel?.readyState === "open") {
-					channel.send(encoding.toUint8Array(responseEncoder));
+				if (this.router.isOpen(this.syncChannelName)) {
+					this.router.send(this.syncChannelName, encoding.toUint8Array(responseEncoder));
 				}
 			}
 

package/src/webrtc/index.ts

@@ -1,9 +1,13 @@
 export { AbracadabraWebRTC } from "./AbracadabraWebRTC.ts";
 export { SignalingSocket } from "./SignalingSocket.ts";
 export { PeerConnection } from "./PeerConnection.ts";
-export { DataChannelRouter } from "./DataChannelRouter.ts";
+export { DataChannelRouter, KEY_EXCHANGE_CHANNEL } from "./DataChannelRouter.ts";
 export { YjsDataChannel } from "./YjsDataChannel.ts";
 export { FileTransferChannel, FileTransferHandle } from "./FileTransferChannel.ts";
+export { E2EEChannel } from "./E2EEChannel.ts";
+export type { E2EEIdentity } from "./E2EEChannel.ts";
+export { ManualSignaling } from "./ManualSignaling.ts";
+export type { ManualSignalingBlob } from "./ManualSignaling.ts";
 export type {
 	AbracadabraWebRTCConfiguration,
 	PeerInfo,

package/src/webrtc/types.ts

@@ -98,6 +98,10 @@ export const CHANNEL_NAMES = {
 	CUSTOM: "custom",
 } as const;
 
+// ── E2EE ────────────────────────────────────────────────────────────────────
+
+export type { E2EEIdentity } from "./E2EEChannel.ts";
+
 // ── Configuration ───────────────────────────────────────────────────────────
 
 export interface AbracadabraWebRTCConfiguration {
@@ -107,6 +111,13 @@ export interface AbracadabraWebRTCConfiguration {
 	/** Server base URL (http/https). Signaling URL derived automatically. */
 	url: string;
 
+	/**
+	 * Override the signaling WebSocket URL. When set, signaling connects to
+	 * this server instead of deriving from `url`. Useful for local spaces that
+	 * piggyback a remote server's signaling endpoint.
+	 */
+	signalingUrl?: string;
+
 	/** JWT token or async token factory. */
 	token: string | (() => string) | (() => Promise<string>);
 
@@ -142,6 +153,13 @@ export interface AbracadabraWebRTCConfiguration {
 	/** Auto-connect on construction. Default: true. */
 	autoConnect?: boolean;
 
+	/**
+	 * E2EE identity for application-level encryption on data channels.
+	 * When provided, all data channel messages (except key-exchange) are
+	 * encrypted with AES-256-GCM using X25519 ECDH-derived session keys.
+	 */
+	e2ee?: import("./E2EEChannel.ts").E2EEIdentity;
+
 	/** WebSocket polyfill for signaling (e.g. for Node.js). */
 	WebSocketPolyfill?: any;
 }