openrtc 0.1.0

package/dist/core/transports/WasmSignaling.js

@@ -0,0 +1,522 @@
+import { getAuthHost } from '../../auth/host';
+export class WasmSignalingBackend {
+    constructor(options) {
+        this.authListeners = [];
+        // To be injected/set once WASM boots
+        this.wasmClient = null;
+        this.missingWasmWarnings = new Set();
+        this.wasmReadyWarningDelayMs = 15000;
+        this.deviceListeners = new Map();
+        this.nextDeviceListenerId = 1;
+        this.deviceReader = null;
+        this.devicesById = new Map();
+        this.activeDeviceUserId = null;
+        this.deviceSubscriptionCancelled = false;
+        this.deviceSubscriptionTask = null;
+        this.authContext = null;
+        if (!options.tag)
+            throw new Error("Signaling requires a 'tag' option.");
+        this.tag = options.tag;
+        this.options = options;
+        const authHost = getAuthHost();
+        this.app = authHost.getApp();
+        this.auth = authHost.getAuth();
+        this.persistenceReady = Promise.resolve();
+        authHost.onAuthStateChanged((user) => {
+            if (this.authContext) {
+                return;
+            }
+            const nextUserId = user?.uid ?? null;
+            if (this.activeDeviceUserId && this.activeDeviceUserId !== nextUserId) {
+                void this.stopDeviceSubscription();
+                this.devicesById.clear();
+            }
+            this.authListeners.forEach(cb => cb(this.toRuntimeIdentity(user)));
+        });
+    }
+    getDeviceIdentityStorageKey() {
+        const suffix = this.options.storagePrefix ? this.options.storagePrefix.replace(/_$/, '') : 'default';
+        return `${WasmSignalingBackend.WEB_DEVICE_ID_STORAGE_PREFIX}_${suffix}`;
+    }
+    getNodeIdPersistenceMode() {
+        return this.options.nodeIdPersistence ?? 'persistent';
+    }
+    createRandomDeviceId() {
+        if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+            return crypto.randomUUID();
+        }
+        return `web-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+    }
+    resolveWebLogicalDeviceId() {
+        const mode = this.getNodeIdPersistenceMode();
+        if (typeof localStorage === 'undefined') {
+            return this.createRandomDeviceId();
+        }
+        const key = this.getDeviceIdentityStorageKey();
+        const now = Date.now();
+        let stored = null;
+        try {
+            const raw = localStorage.getItem(key);
+            stored = raw ? JSON.parse(raw) : null;
+        }
+        catch {
+            stored = null;
+        }
+        const storedDeviceId = typeof stored?.deviceId === 'string' ? stored.deviceId.trim() : '';
+        const storedExpiry = typeof stored?.expiresAt === 'number' ? stored.expiresAt : undefined;
+        if (mode === 'persistent') {
+            const nextDeviceId = storedDeviceId || this.createRandomDeviceId();
+            localStorage.setItem(key, JSON.stringify({ deviceId: nextDeviceId }));
+            return nextDeviceId;
+        }
+        if (storedDeviceId && typeof storedExpiry === 'number' && storedExpiry > now) {
+            const refreshedExpiry = now + WasmSignalingBackend.EPHEMERAL_DEVICE_ID_TTL_MS;
+            localStorage.setItem(key, JSON.stringify({ deviceId: storedDeviceId, expiresAt: refreshedExpiry }));
+            return storedDeviceId;
+        }
+        const nextDeviceId = this.createRandomDeviceId();
+        const expiresAt = now + WasmSignalingBackend.EPHEMERAL_DEVICE_ID_TTL_MS;
+        localStorage.setItem(key, JSON.stringify({ deviceId: nextDeviceId, expiresAt }));
+        return nextDeviceId;
+    }
+    withWebPresenceMetadata(metadata, localDeviceId) {
+        if (!metadata || !metadata.trim()) {
+            return JSON.stringify({ deviceId: localDeviceId });
+        }
+        try {
+            const parsed = JSON.parse(metadata);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                return JSON.stringify({
+                    ...parsed,
+                    deviceId: localDeviceId,
+                });
+            }
+        }
+        catch {
+            // fall through to opaque metadata wrapper
+        }
+        return JSON.stringify({
+            deviceId: localDeviceId,
+            metadata,
+        });
+    }
+    setAuthContext(context) {
+        this.authContext = context;
+        if (this.wasmClient && typeof this.wasmClient.set_auth_token === 'function') {
+            this.wasmClient.set_auth_token(context?.token ?? null);
+        }
+        this.authListeners.forEach((callback) => callback(this.currentUser));
+    }
+    toRuntimeIdentity(user) {
+        if (!user) {
+            return null;
+        }
+        return {
+            id: user.uid,
+            email: user.email,
+            displayName: user.displayName,
+            isAnonymous: user.isAnonymous,
+            getToken: async (forceRefresh = false) => {
+                try {
+                    return await user.getIdToken(forceRefresh);
+                }
+                catch {
+                    return null;
+                }
+            },
+        };
+    }
+    getCurrentUserId() {
+        if (this.authContext?.userId) {
+            return this.authContext.userId;
+        }
+        return this.auth.currentUser?.uid ?? null;
+    }
+    getFilteredDevices(excludeNodeId) {
+        const devices = Array.from(this.devicesById.values())
+            .filter((device) => this.matchesTag(device));
+        if (!excludeNodeId)
+            return devices;
+        return devices.filter((device) => device.ticket !== excludeNodeId && device.deviceId !== excludeNodeId);
+    }
+    matchesTag(device) {
+        return typeof device.tag === 'string' && device.tag === this.tag;
+    }
+    emitDeviceUpdateForListener(listener) {
+        listener.callback(this.getFilteredDevices(listener.excludeNodeId));
+    }
+    emitDeviceUpdate() {
+        for (const listener of this.deviceListeners.values()) {
+            this.emitDeviceUpdateForListener(listener);
+        }
+    }
+    applyDeviceEvents(events) {
+        for (const event of events) {
+            if (event.type === 'removed') {
+                this.devicesById.delete(event.deviceId);
+                continue;
+            }
+            const normalized = this.normalizeDevice(event.device);
+            if (!normalized.deviceId)
+                continue;
+            if (!this.matchesTag(normalized)) {
+                this.devicesById.delete(normalized.deviceId);
+                continue;
+            }
+            this.devicesById.set(normalized.deviceId, normalized);
+        }
+    }
+    async stopDeviceSubscription() {
+        this.deviceSubscriptionCancelled = true;
+        if (this.deviceReader) {
+            try {
+                await this.deviceReader.cancel();
+            }
+            catch {
+                // noop
+            }
+            this.deviceReader = null;
+        }
+        this.activeDeviceUserId = null;
+        this.deviceSubscriptionTask = null;
+    }
+    startDeviceSubscription(userId) {
+        if (this.deviceSubscriptionTask && this.activeDeviceUserId === userId) {
+            return;
+        }
+        this.deviceSubscriptionTask = (async () => {
+            if (this.activeDeviceUserId && this.activeDeviceUserId !== userId) {
+                await this.stopDeviceSubscription();
+            }
+            this.activeDeviceUserId = userId;
+            this.deviceSubscriptionCancelled = false;
+            try {
+                const startedAt = Date.now();
+                let wasmClient = null;
+                while (!this.deviceSubscriptionCancelled) {
+                    wasmClient = await this.waitForWasmClient(2000);
+                    if (wasmClient && typeof wasmClient.subscribe_devices === 'function') {
+                        break;
+                    }
+                    if (Date.now() - startedAt >= this.wasmReadyWarningDelayMs) {
+                        this.warnMissingWasmOnce('onDevicesChange');
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, 250));
+                }
+                if (!wasmClient || this.deviceSubscriptionCancelled) {
+                    this.emitDeviceUpdate();
+                    return;
+                }
+                const initialDevices = await this.searchDevices();
+                this.devicesById.clear();
+                for (const device of initialDevices) {
+                    this.devicesById.set(device.deviceId, device);
+                }
+                this.emitDeviceUpdate();
+                const stream = await this.subscribeDevices(userId);
+                this.deviceReader = stream.getReader();
+                while (!this.deviceSubscriptionCancelled) {
+                    const { done, value } = await this.deviceReader.read();
+                    if (done || !value)
+                        break;
+                    this.applyDeviceEvents(value);
+                    this.emitDeviceUpdate();
+                }
+            }
+            catch (error) {
+                if (!this.deviceSubscriptionCancelled) {
+                    console.warn('[WasmSignaling] onDevicesChange stream failed:', error);
+                }
+            }
+            finally {
+                this.deviceReader = null;
+                if (this.deviceSubscriptionCancelled || this.deviceListeners.size === 0) {
+                    this.activeDeviceUserId = null;
+                    this.deviceSubscriptionTask = null;
+                }
+            }
+        })();
+    }
+    setWasmClient(client) {
+        this.wasmClient = client;
+        if (this.authContext && typeof this.wasmClient?.set_auth_token === 'function') {
+            this.wasmClient.set_auth_token(this.authContext.token ?? null);
+        }
+    }
+    warnMissingWasmOnce(method) {
+        if (this.missingWasmWarnings.has(method)) {
+            return;
+        }
+        this.missingWasmWarnings.add(method);
+        console.warn(`[WasmSignaling] ${method} skipped: wasm client is not ready.`);
+    }
+    async waitForWasmClient(timeoutMs = 4000, pollMs = 50) {
+        if (this.wasmClient) {
+            return this.wasmClient;
+        }
+        const start = Date.now();
+        while (!this.wasmClient && Date.now() - start < timeoutMs) {
+            await new Promise((resolve) => setTimeout(resolve, pollMs));
+        }
+        return this.wasmClient ?? null;
+    }
+    emptyStream() {
+        return new ReadableStream({
+            start(controller) {
+                controller.close();
+            },
+        });
+    }
+    normalizeDevice(raw, fallbackId) {
+        const deviceId = raw.deviceId || (fallbackId || '');
+        const nodeId = raw.nodeId || raw.ticket || '';
+        return {
+            deviceId,
+            deviceName: raw.deviceName || 'Unknown Device',
+            online: !!raw.online,
+            ticket: nodeId,
+            tag: typeof raw.tag === 'string' ? raw.tag : undefined,
+            nodeId,
+            platformType: typeof raw.platformType === 'string' ? raw.platformType : undefined,
+            capabilities: raw.capabilities || undefined,
+            sessionId: typeof raw.sessionId === 'string' ? raw.sessionId : undefined,
+            userId: typeof raw.userId === 'string' ? raw.userId : undefined,
+            lastSeenAt: raw.lastSeenAt,
+            expiresAt: raw.expiresAt,
+            createdAt: raw.createdAt,
+            updatedAt: raw.updatedAt,
+            metadata: typeof raw.metadata === 'string' ? raw.metadata : undefined,
+        };
+    }
+    get currentUser() {
+        if (this.authContext?.userId) {
+            const token = this.authContext.token ?? null;
+            return {
+                id: this.authContext.userId,
+                getToken: async () => token,
+            };
+        }
+        return this.toRuntimeIdentity(this.auth.currentUser);
+    }
+    onAuthChange(callback) {
+        this.authListeners.push(callback);
+        callback(this.currentUser);
+        return () => {
+            this.authListeners = this.authListeners.filter(cb => cb !== callback);
+        };
+    }
+    async checkForSSOToken() {
+        await getAuthHost().checkForSSOToken();
+    }
+    async waitForAuth() {
+        if (this.authContext?.userId) {
+            return;
+        }
+        await getAuthHost().waitForAuth();
+    }
+    async signInAnonymously() {
+        await getAuthHost().signInAnonymously();
+    }
+    async signOut() {
+        await this.auth.signOut();
+        await this.signInAnonymously();
+    }
+    async getTurnCredentials() {
+        if (!this.auth.currentUser)
+            return null;
+        // In the future this should come from Rust/Tauri IPC.
+        return null;
+    }
+    async updatePresence(localNodeId, ticketStr, isOnline = true, ttlMs = 300000, metadata) {
+        const userId = this.getCurrentUserId();
+        if (!userId)
+            return;
+        const localDeviceId = this.resolveWebLogicalDeviceId();
+        const effectiveTtlMs = this.getNodeIdPersistenceMode() === 'ephemeral'
+            ? WasmSignalingBackend.EPHEMERAL_DEVICE_ID_TTL_MS
+            : ttlMs;
+        const mergedMetadata = this.withWebPresenceMetadata(metadata, localDeviceId);
+        const deviceName = this.options.storagePrefix
+            ? `Web (${this.options.storagePrefix.replace(/_$/, '')})`
+            : 'Web';
+        const wasmClient = await this.waitForWasmClient();
+        if (wasmClient && typeof wasmClient.update_presence === 'function') {
+            try {
+                const ttlBigInt = BigInt(Math.max(0, Math.trunc(effectiveTtlMs)));
+                await wasmClient.update_presence(userId, deviceName, ticketStr, mergedMetadata, ttlBigInt);
+            }
+            catch (error) {
+                console.warn('[WasmSignaling] WASM update_presence failed:', error);
+            }
+            return;
+        }
+        this.warnMissingWasmOnce('updatePresence');
+    }
+    async setOffline(localNodeId) {
+        const userId = this.getCurrentUserId();
+        if (!userId)
+            return;
+        const wasmClient = await this.waitForWasmClient();
+        if (wasmClient && typeof wasmClient.set_offline === 'function') {
+            try {
+                await wasmClient.set_offline(userId);
+            }
+            catch (error) {
+                console.warn('[WasmSignaling] WASM set_offline failed:', error);
+            }
+            return;
+        }
+        this.warnMissingWasmOnce('setOffline');
+    }
+    async cleanupStaleDevices() {
+        // Rust daemon handles this automatically.
+    }
+    async sendMessage(targetId, payload, state, replyPayload) {
+        const wasmClient = await this.waitForWasmClient();
+        if (!wasmClient || typeof wasmClient.send_message !== 'function') {
+            this.warnMissingWasmOnce('sendMessage');
+            return '';
+        }
+        return wasmClient.send_message(targetId, payload, state, replyPayload);
+    }
+    async pollMessages(targetId) {
+        // Deprecated
+        return [];
+    }
+    async searchDevices(excludeNodeId) {
+        const userId = this.getCurrentUserId();
+        if (!userId)
+            return [];
+        const wasmClient = await this.waitForWasmClient(500);
+        if (wasmClient && typeof wasmClient.search_devices === 'function') {
+            const devices = await wasmClient.search_devices(userId);
+            const normalized = (Array.isArray(devices) ? devices : [])
+                .map((device) => this.normalizeDevice(device))
+                .filter((device) => this.matchesTag(device));
+            if (!excludeNodeId)
+                return normalized;
+            return normalized.filter((d) => d.ticket !== excludeNodeId && d.deviceId !== excludeNodeId);
+        }
+        return [];
+    }
+    onDevicesChange(callback, excludeNodeId) {
+        const userId = this.getCurrentUserId();
+        if (!userId)
+            return () => { };
+        const listenerId = this.nextDeviceListenerId++;
+        const listener = { callback, excludeNodeId };
+        this.deviceListeners.set(listenerId, listener);
+        this.emitDeviceUpdateForListener(listener);
+        this.startDeviceSubscription(userId);
+        return () => {
+            this.deviceListeners.delete(listenerId);
+            if (this.deviceListeners.size === 0) {
+                void this.stopDeviceSubscription();
+            }
+        };
+    }
+    async subscribeDevices(userId) {
+        const wasmClient = await this.waitForWasmClient();
+        if (!wasmClient || typeof wasmClient.subscribe_devices !== 'function') {
+            this.warnMissingWasmOnce('subscribeDevices');
+            return this.emptyStream();
+        }
+        return wasmClient.subscribe_devices(userId);
+    }
+    async createSession(session) {
+        const wasmClient = await this.waitForWasmClient();
+        if (!wasmClient || typeof wasmClient.create_session !== 'function') {
+            this.warnMissingWasmOnce('createSession');
+            return;
+        }
+        const userId = this.getCurrentUserId();
+        if (!userId && !session.initiator && !session.target) {
+            throw new Error('createSession requires user scope');
+        }
+        const scopedSession = {
+            ...session,
+            initiator: session.initiator ?? userId ?? undefined,
+            target: session.target ?? userId ?? undefined,
+        };
+        return wasmClient.create_session(JSON.stringify(scopedSession));
+    }
+    async updateSession(sessionId, updateData) {
+        const wasmClient = await this.waitForWasmClient();
+        if (!wasmClient || typeof wasmClient.update_session !== 'function') {
+            this.warnMissingWasmOnce('updateSession');
+            return;
+        }
+        const userId = this.getCurrentUserId();
+        if (!userId) {
+            throw new Error('updateSession requires authenticated user scope');
+        }
+        const scopedSessionId = `${userId}::${sessionId}`;
+        return wasmClient.update_session(scopedSessionId, JSON.stringify(updateData));
+    }
+    async subscribeSessions(localDeviceId) {
+        const wasmClient = await this.waitForWasmClient();
+        if (!wasmClient || typeof wasmClient.subscribe_sessions !== 'function') {
+            this.warnMissingWasmOnce('subscribeSessions');
+            return this.emptyStream();
+        }
+        const userId = this.getCurrentUserId();
+        if (!userId) {
+            throw new Error('subscribeSessions requires authenticated user scope');
+        }
+        const scopedKey = `${userId}::${localDeviceId}`;
+        return wasmClient.subscribe_sessions(scopedKey);
+    }
+    async advertiseLocalDaemon(params) {
+        const userId = this.getCurrentUserId();
+        if (!userId)
+            return;
+        const wasmClient = await this.waitForWasmClient();
+        if (!wasmClient || typeof wasmClient.advertise_local_daemon !== 'function') {
+            this.warnMissingWasmOnce('advertiseLocalDaemon');
+            return;
+        }
+        const ttlMs = params.ttlMs ?? 60000;
+        await wasmClient.advertise_local_daemon(userId, params.deviceId, params.host, params.localPort, params.localToken, ttlMs);
+    }
+    async findLocalDaemons() {
+        const userId = this.getCurrentUserId();
+        if (!userId)
+            return [];
+        const wasmClient = await this.waitForWasmClient(this.wasmReadyWarningDelayMs);
+        if (!wasmClient || typeof wasmClient.find_local_daemons !== 'function') {
+            this.warnMissingWasmOnce('findLocalDaemons');
+            return [];
+        }
+        const raw = await wasmClient.find_local_daemons(userId);
+        const now = Date.now();
+        const entries = (Array.isArray(raw) ? raw : [])
+            .map((entry) => {
+            const port = typeof entry.localPort === 'number'
+                ? entry.localPort
+                : typeof entry.localPort === 'string'
+                    ? Number(entry.localPort)
+                    : NaN;
+            const token = typeof entry.localToken === 'string' ? entry.localToken : '';
+            const expiresAt = typeof entry.expiresAt === 'number'
+                ? entry.expiresAt
+                : typeof entry.expiresAt === 'string'
+                    ? Number(entry.expiresAt)
+                    : 0;
+            if (!Number.isFinite(port) || port <= 0 || !token || expiresAt <= now) {
+                return null;
+            }
+            return {
+                deviceId: typeof entry.deviceId === 'string' ? entry.deviceId : '',
+                host: typeof entry.host === 'string' && entry.host.length > 0 ? entry.host : '127.0.0.1',
+                localPort: port,
+                localToken: token,
+                expiresAt,
+                updatedAt: typeof entry.updatedAt === 'number' ? entry.updatedAt : undefined,
+            };
+        })
+            .filter((entry) => !!entry);
+        return entries;
+    }
+}
+WasmSignalingBackend.WEB_DEVICE_ID_STORAGE_PREFIX = 'pluto_rtc_web_device_identity';
+WasmSignalingBackend.EPHEMERAL_DEVICE_ID_TTL_MS = 60000;

package/dist/core/transports/WebRTCTransport.d.ts

@@ -0,0 +1,23 @@
+import { ITransport } from './ITransport';
+export declare class WebRTCTransport implements ITransport {
+    readonly name = "webrtc";
+    get isReady(): boolean;
+    private pc;
+    private dc;
+    private state;
+    private pendingCandidates;
+    private messageListeners;
+    private stateListeners;
+    private internalSignalSender;
+    getNativeTransport(): RTCPeerConnection | null;
+    setSignalSender(sender: (msg: any) => Promise<void>): void;
+    init(localNodeId: string, remoteNodeId: string, options: any): Promise<void>;
+    private setupDataChannel;
+    private setupPCHandlers;
+    handleSignalingMessage(msg: any): void;
+    send(data: Uint8Array): Promise<void>;
+    close(): void;
+    onMessage(callback: (data: Uint8Array) => void): void;
+    onStateChange(callback: (state: 'connecting' | 'connected' | 'failed' | 'disconnected') => void): void;
+    private setState;
+}

package/dist/core/transports/WebRTCTransport.js

@@ -0,0 +1,132 @@
+export class WebRTCTransport {
+    constructor() {
+        this.name = 'webrtc';
+        this.pc = null;
+        this.dc = null;
+        this.state = 'disconnected';
+        this.pendingCandidates = [];
+        this.messageListeners = [];
+        this.stateListeners = [];
+        this.internalSignalSender = null;
+    }
+    get isReady() { return this.state === 'connected'; }
+    getNativeTransport() {
+        return this.pc;
+    }
+    setSignalSender(sender) {
+        this.internalSignalSender = sender;
+    }
+    async init(localNodeId, remoteNodeId, options) {
+        this.setState('connecting');
+        const config = options.rtcConfig || {};
+        try {
+            this.pc = new RTCPeerConnection(config);
+        }
+        catch (e) {
+            console.error("[WebRTCTransport] Constructor failed", e);
+            this.setState('failed');
+            return;
+        }
+        const isInitiator = localNodeId > remoteNodeId;
+        const dc = this.pc.createDataChannel("pluto-dc", { negotiated: true, id: 0 });
+        this.setupDataChannel(dc);
+        this.setupPCHandlers(isInitiator);
+    }
+    setupDataChannel(dc) {
+        this.dc = dc;
+        dc.onopen = () => console.log("[WebRTCTransport] DC OPEN");
+        dc.onmessage = (ev) => {
+            const data = typeof ev.data === 'string' ? new TextEncoder().encode(ev.data) : new Uint8Array(ev.data);
+            this.messageListeners.forEach(cb => cb(data));
+        };
+    }
+    setupPCHandlers(isInitiator) {
+        if (!this.pc)
+            return;
+        this.pc.onicecandidate = (ev) => {
+            if (ev.candidate && this.internalSignalSender) {
+                this.internalSignalSender({ transport: 'webrtc', type: 'candidate', candidate: ev.candidate });
+            }
+        };
+        this.pc.onnegotiationneeded = async () => {
+            if (!isInitiator)
+                return;
+            if (this.pc?.signalingState !== 'stable')
+                return;
+            try {
+                const offer = await this.pc.createOffer();
+                await this.pc.setLocalDescription(offer);
+                if (this.internalSignalSender) {
+                    this.internalSignalSender({ transport: 'webrtc', type: 'sdp', sdp: offer });
+                }
+            }
+            catch (e) {
+                console.error("Offer failed", e);
+            }
+        };
+        this.pc.onconnectionstatechange = () => {
+            const state = this.pc?.connectionState;
+            if (state === 'connected') {
+                this.setState('connected');
+            }
+            else if (state === 'failed' || state === 'disconnected') {
+                this.setState('failed');
+            }
+        };
+    }
+    handleSignalingMessage(msg) {
+        if (!this.pc || msg.transport !== 'webrtc')
+            return;
+        if (msg.type === 'candidate') {
+            if (this.pc.remoteDescription) {
+                this.pc.addIceCandidate(msg.candidate).catch(e => console.error("AddICE failed", e));
+            }
+            else {
+                this.pendingCandidates.push(msg.candidate);
+            }
+        }
+        else if (msg.type === 'sdp') {
+            const sdp = msg.sdp;
+            this.pc.setRemoteDescription(sdp).then(async () => {
+                if (this.pendingCandidates.length) {
+                    this.pendingCandidates.forEach(c => this.pc?.addIceCandidate(c));
+                    this.pendingCandidates = [];
+                }
+                if (sdp.type === 'offer') {
+                    const answer = await this.pc.createAnswer();
+                    await this.pc.setLocalDescription(answer);
+                    if (this.internalSignalSender) {
+                        this.internalSignalSender({ transport: 'webrtc', type: 'sdp', sdp: answer });
+                    }
+                }
+            }).catch(e => console.error("SDP Error", e));
+        }
+    }
+    async send(data) {
+        if (this.dc && this.dc.readyState === 'open') {
+            const payload = new Uint8Array(data);
+            this.dc.send(payload);
+        }
+        else {
+            throw new Error("WebRTC DataChannel not open");
+        }
+    }
+    close() {
+        this.pc?.close();
+        this.pc = null;
+        this.dc = null;
+        this.setState('disconnected');
+    }
+    onMessage(callback) {
+        this.messageListeners.push(callback);
+    }
+    onStateChange(callback) {
+        this.stateListeners.push(callback);
+    }
+    setState(state) {
+        if (this.state !== state) {
+            this.state = state;
+            this.stateListeners.forEach(cb => cb(state));
+        }
+    }
+}