y-openrtc 0.1.0

package/dist/provider.js

@@ -0,0 +1,762 @@
+import * as awarenessProtocol from 'y-protocols/awareness';
+import { BroadcastMeshTransport } from './broadcast.js';
+import { applyProviderMessage, encodeAwarenessQuery, encodeAwarenessUpdate, encodeDocUpdate, encodeSyncStep1, encodeSyncStep2, } from './codec.js';
+import { decryptFrame, deriveRoomKey, encryptFrame } from './crypto.js';
+import { roomNameToOpenrtcRoomId } from './roomName.js';
+import { acquireRuntimeLease } from './runtimePool.js';
+const warnedCompatibilityOptions = new Set();
+function createProviderId() {
+    if (typeof globalThis.crypto?.randomUUID === 'function') {
+        return globalThis.crypto.randomUUID();
+    }
+    return `y-openrtc-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function isBinaryPayload(value) {
+    return value instanceof Uint8Array || value instanceof ArrayBuffer;
+}
+function normalizeBinaryPayload(value) {
+    return value instanceof Uint8Array ? value : new Uint8Array(value);
+}
+function stableScore(seed) {
+    let hash = 2166136261;
+    for (let index = 0; index < seed.length; index += 1) {
+        hash ^= seed.charCodeAt(index);
+        hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0;
+}
+function hasActiveMember(member) {
+    const now = Date.now();
+    if (typeof member.expiresAt === 'number') {
+        return member.expiresAt >= now;
+    }
+    const lastSeenAt = member.lastSeenAt ?? member.joinedAt ?? 0;
+    return now - lastSeenAt <= 5 * 60 * 1000;
+}
+function shouldInitiateConnection(localNodeId, remoteNodeId) {
+    return localNodeId.localeCompare(remoteNodeId) < 0;
+}
+function normalizeOpenrtcRoomId(roomId) {
+    return roomId === 'demo' ? roomId : roomId.toUpperCase();
+}
+function errorText(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function isRoomNotFoundError(error) {
+    const text = errorText(error);
+    return /room not found|not found|status["']?\s*:\s*["']?not_found|code["']?\s*:\s*404/i.test(text);
+}
+function isRoomAlreadyExistsError(error) {
+    const text = errorText(error);
+    return /already exists|status["']?\s*:\s*["']?already-exists|code["']?\s*:\s*409/i.test(text);
+}
+function isRoomFullError(error) {
+    const text = errorText(error);
+    return /room is full|resource[-_\s]?exhausted|status["']?\s*:\s*["']?resource-exhausted|code["']?\s*:\s*(8|429)/i.test(text);
+}
+function isTransientStartupError(error) {
+    return /relay-only endpoint ticket unavailable|failed to fetch|network|timed out/i.test(errorText(error));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export class OpenrtcProvider {
+    constructor(roomName, doc, options = {}) {
+        this.providerId = createProviderId();
+        this.listeners = new Map();
+        this.runtimeLease = null;
+        this.runtime = null;
+        this.roomId = null;
+        this.localNodeId = null;
+        this.broadcastTransport = null;
+        this.stopWatchingRoom = null;
+        this.stopRuntimeConnections = null;
+        this.stopRuntimeConnectionStates = null;
+        this.roomMembers = new Map();
+        this.openrtcConnections = new Map();
+        this.bcPeers = new Map();
+        this.pendingNodeIds = new Set();
+        this.shouldConnect = false;
+        this.destroyed = false;
+        this.synced = false;
+        this.localObserversAttached = false;
+        this.connectPromise = null;
+        this.reconcileTimer = null;
+        this.runtimeRefreshTimer = null;
+        this.diagnostics = {
+            openrtcSent: 0,
+            openrtcReceived: 0,
+            broadcastSent: 0,
+            broadcastReceived: 0,
+            decryptFailed: 0,
+            providerMessagesApplied: 0,
+            providerRepliesSent: 0,
+            docUpdatesBroadcast: 0,
+            syncStep1Received: 0,
+            syncStep2Received: 0,
+            syncUpdateReceived: 0,
+            awarenessReceived: 0,
+            awarenessQueryReceived: 0,
+        };
+        this.roomName = roomName;
+        this.doc = doc;
+        this.options = options;
+        this.awareness = options.awareness ?? new awarenessProtocol.Awareness(doc);
+        this.filterBcConns = options.filterBcConns ?? true;
+        this.maxConns = options.maxConns ?? 20 + Math.floor(Math.random() * 15);
+        this.keyPromise = deriveRoomKey(options.password ?? null, roomName);
+        this.docUpdateHandler = (update, origin) => {
+            if (origin === this) {
+                return;
+            }
+            this.diagnostics.docUpdatesBroadcast += 1;
+            void this.broadcastProviderPayload(encodeDocUpdate(update));
+        };
+        this.awarenessUpdateHandler = ({ added, updated, removed }, origin) => {
+            if (origin === this) {
+                return;
+            }
+            const clients = added.concat(updated, removed);
+            void this.broadcastProviderPayload(encodeAwarenessUpdate(this.awareness, clients));
+        };
+        this.destroyHandler = () => {
+            void this.destroyInternal();
+        };
+        this.warnCompatibilityOptions();
+        this.doc.on('destroy', this.destroyHandler);
+        this.connect();
+    }
+    get connected() {
+        return this.shouldConnect;
+    }
+    on(name, listener) {
+        const listeners = this.listeners.get(name) ?? new Set();
+        listeners.add(listener);
+        this.listeners.set(name, listeners);
+        return listener;
+    }
+    off(name, listener) {
+        this.listeners.get(name)?.delete(listener);
+    }
+    once(name, listener) {
+        const wrapped = ((payload) => {
+            this.off(name, wrapped);
+            listener(payload);
+        });
+        this.on(name, wrapped);
+    }
+    emit(name, payload) {
+        for (const listener of this.listeners.get(name) ?? []) {
+            listener(payload);
+        }
+    }
+    connect() {
+        if (this.destroyed || this.shouldConnect) {
+            return;
+        }
+        this.shouldConnect = true;
+        this.emitStatus();
+        this.connectPromise = this.connectWithRetry().catch((error) => {
+            if (!this.destroyed) {
+                console.warn('[y-openrtc] connect failed:', error);
+            }
+            if (this.shouldConnect) {
+                this.shouldConnect = false;
+                this.emitStatus();
+            }
+        });
+    }
+    disconnect() {
+        void this.disconnectInternal('disconnect');
+    }
+    destroy() {
+        void this.destroyInternal();
+    }
+    diagnosticSnapshot() {
+        return { ...this.diagnostics };
+    }
+    warnCompatibilityOptions() {
+        if (this.options.signaling && !warnedCompatibilityOptions.has('signaling')) {
+            warnedCompatibilityOptions.add('signaling');
+            console.warn('[y-openrtc] `signaling` is ignored. OpenRTC owns signaling and discovery.');
+        }
+        if (this.options.peerOpts && !warnedCompatibilityOptions.has('peerOpts')) {
+            warnedCompatibilityOptions.add('peerOpts');
+            console.warn('[y-openrtc] `peerOpts` is ignored. OpenRTC owns peer transport setup.');
+        }
+    }
+    emitStatus() {
+        this.emit('status', { connected: this.connected });
+    }
+    emitSynced(nextSynced) {
+        if (this.synced === nextSynced) {
+            return;
+        }
+        this.synced = nextSynced;
+        this.emit('synced', { synced: nextSynced });
+    }
+    emitPeers(added, removed) {
+        const payload = {
+            added,
+            removed,
+            openrtcPeers: Array.from(this.openrtcConnections.keys()),
+            webrtcPeers: Array.from(this.openrtcConnections.keys()),
+            bcPeers: Array.from(this.bcPeers.keys()),
+        };
+        this.emit('peers', payload);
+    }
+    attachLocalObservers() {
+        if (this.localObserversAttached) {
+            return;
+        }
+        this.localObserversAttached = true;
+        this.doc.on('update', this.docUpdateHandler);
+        this.awareness.on('update', this.awarenessUpdateHandler);
+    }
+    detachLocalObservers() {
+        if (!this.localObserversAttached) {
+            return;
+        }
+        this.localObserversAttached = false;
+        this.doc.off('update', this.docUpdateHandler);
+        this.awareness.off('update', this.awarenessUpdateHandler);
+    }
+    async connectInternal() {
+        const lease = acquireRuntimeLease({
+            ...this.options,
+            authMode: this.options.authMode ?? 'anonymous',
+            allowAnonymousHostedDefaults: this.options.allowAnonymousHostedDefaults ?? !this.options.apiKey,
+            space: this.options.space ?? this.options.spaceKey ?? (!this.options.apiKey ? this.roomName : undefined),
+        });
+        this.runtimeLease = lease;
+        const runtime = await lease.ensureReady();
+        if (!this.shouldConnect || this.destroyed || this.runtimeLease !== lease) {
+            await lease.release();
+            return;
+        }
+        this.runtime = runtime;
+        this.localNodeId = await runtime.getNodeId();
+        const preferredRoomId = normalizeOpenrtcRoomId(this.options.roomIdOverride ?? await roomNameToOpenrtcRoomId(this.roomName));
+        const roomCandidates = this.resolveRoomCandidates(preferredRoomId);
+        this.attachLocalObservers();
+        this.stopRuntimeConnections = runtime.onConnection((connection) => {
+            if (!this.shouldConnect || !this.isRelevantConnection(connection)) {
+                return;
+            }
+            this.attachConnection(connection);
+            void this.reconcilePeers();
+        });
+        if (typeof runtime.onConnectionStateChange === 'function') {
+            const stopRuntimeConnectionStates = runtime.onConnectionStateChange((state) => {
+                if (!this.shouldConnect || state.state !== 'connected') {
+                    return;
+                }
+                this.refreshKnownRuntimeConnections();
+                // When a peer's transport upgrades (e.g. iroh → WebRTC), the
+                // initial syncStep1 may have been sent over a transport that
+                // could not deliver it (e.g. dropped at the JSON parser on the
+                // far side). Replay sync to the affected peer so that late
+                // upgrades still converge.
+                const remoteNodeId = state.remoteNodeId ?? null;
+                if (remoteNodeId) {
+                    this.resyncPeer(remoteNodeId);
+                }
+            });
+            if (typeof stopRuntimeConnectionStates === 'function') {
+                this.stopRuntimeConnectionStates = stopRuntimeConnectionStates;
+            }
+            else {
+                void Promise.resolve(stopRuntimeConnectionStates)
+                    .then((stop) => {
+                    if (this.destroyed || !this.shouldConnect) {
+                        stop?.();
+                        return;
+                    }
+                    this.stopRuntimeConnectionStates = stop ?? null;
+                })
+                    .catch(() => undefined);
+            }
+        }
+        this.roomId = await this.joinFirstAvailableRoom(runtime, roomCandidates);
+        if (!this.shouldConnect || this.destroyed) {
+            await this.disconnectOwnedResources('connect-aborted');
+            return;
+        }
+        this.broadcastTransport = new BroadcastMeshTransport({
+            channelName: `y-openrtc:${this.roomId}`,
+            providerId: this.providerId,
+            nodeId: this.localNodeId,
+            onPeerMessage: (message) => {
+                if (message.action === 'add') {
+                    const hadPeer = this.bcPeers.has(message.providerId);
+                    this.bcPeers.set(message.providerId, message.nodeId);
+                    if (!hadPeer) {
+                        this.emitPeers([message.providerId], []);
+                        this.broadcastTransport?.announcePresence();
+                    }
+                }
+                else if (this.bcPeers.delete(message.providerId)) {
+                    this.emitPeers([], [message.providerId]);
+                }
+                this.requestReconcile();
+            },
+            onPayload: (message) => {
+                this.diagnostics.broadcastReceived += 1;
+                void this.handleIncomingPayload(message.data, { type: 'bc', providerId: message.providerId, nodeId: message.nodeId }, (reply) => this.sendBroadcastPayload(reply));
+            },
+        });
+        this.broadcastTransport.connect();
+        this.stopWatchingRoom = runtime.watchRoom(this.roomId, (members) => {
+            this.replaceRoomMembers(members);
+            this.refreshKnownRuntimeConnections();
+            this.requestReconcile();
+        });
+        this.refreshKnownRuntimeConnections();
+        this.startRuntimeConnectionRefresh();
+        this.broadcastInitialBcState();
+        this.requestReconcile();
+        this.updateSyncedState();
+    }
+    async connectWithRetry() {
+        let lastError;
+        for (const delayMs of [0, 500, 1500, 3000]) {
+            if (delayMs > 0) {
+                await sleep(delayMs);
+            }
+            try {
+                await this.connectInternal();
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                await this.disconnectOwnedResources('connect-retry').catch(() => undefined);
+                if (!this.shouldConnect || this.destroyed || !isTransientStartupError(error)) {
+                    throw error;
+                }
+            }
+        }
+        throw lastError ?? new Error('OpenRTC provider startup failed.');
+    }
+    resolveRoomCandidates(preferredRoomId) {
+        const configured = this.options.roomIdCandidates
+            ?.map((roomId) => normalizeOpenrtcRoomId(roomId.trim()))
+            .filter(Boolean) ?? [];
+        const candidates = configured.length > 0 ? configured : [preferredRoomId];
+        if (!candidates.includes(preferredRoomId)) {
+            candidates.unshift(preferredRoomId);
+        }
+        return [...new Set(candidates)];
+    }
+    async joinFirstAvailableRoom(runtime, roomIds) {
+        let lastError;
+        for (const roomId of roomIds) {
+            try {
+                await this.joinOrCreateRuntimeRoom(runtime, roomId);
+                return roomId;
+            }
+            catch (error) {
+                lastError = error;
+                if (!isRoomFullError(error)) {
+                    throw error;
+                }
+            }
+        }
+        throw lastError ?? new Error('No y-openrtc room candidates were available.');
+    }
+    async joinOrCreateRuntimeRoom(runtime, roomId) {
+        try {
+            await runtime.joinRoom(roomId, { bootstrapPeers: false });
+        }
+        catch (error) {
+            if (!isRoomNotFoundError(error)) {
+                throw error;
+            }
+            try {
+                await runtime.createRoom(roomId);
+            }
+            catch (createError) {
+                if (!isRoomAlreadyExistsError(createError)) {
+                    throw createError;
+                }
+            }
+            await this.joinRoomAfterCreate(runtime, roomId);
+        }
+    }
+    async joinRoomAfterCreate(runtime, roomId) {
+        let lastError;
+        for (const delayMs of [150, 350, 750, 1500, 3000]) {
+            if (delayMs > 0) {
+                await sleep(delayMs);
+            }
+            try {
+                await runtime.joinRoom(roomId, { bootstrapPeers: false });
+                return;
+            }
+            catch (error) {
+                lastError = error;
+                if (!isRoomNotFoundError(error)) {
+                    throw error;
+                }
+            }
+        }
+        throw lastError ?? new Error(`Room ${roomId} was not available after creation.`);
+    }
+    requestReconcile() {
+        if (!this.shouldConnect || this.destroyed) {
+            return;
+        }
+        if (this.reconcileTimer) {
+            clearTimeout(this.reconcileTimer);
+            this.reconcileTimer = null;
+        }
+        const delayMs = this.filterBcConns && this.broadcastTransport?.available ? 25 : 0;
+        this.reconcileTimer = setTimeout(() => {
+            this.reconcileTimer = null;
+            void this.reconcilePeers();
+        }, delayMs);
+    }
+    replaceRoomMembers(members) {
+        this.roomMembers.clear();
+        for (const member of members) {
+            if (!member.nodeId || !hasActiveMember(member)) {
+                continue;
+            }
+            this.roomMembers.set(member.nodeId, member);
+        }
+    }
+    async reconcilePeers() {
+        const runtime = this.runtime;
+        if (!runtime || !this.shouldConnect || !this.localNodeId) {
+            return;
+        }
+        const localNodeId = this.localNodeId;
+        const candidates = Array.from(this.roomMembers.values())
+            .filter((member) => member.nodeId !== this.localNodeId)
+            .filter((member) => !!member.ticket)
+            .filter((member) => !this.filterBcConns || !this.hasBcNodeId(member.nodeId))
+            .sort((left, right) => stableScore(`${this.providerId}:${right.nodeId}`) -
+            stableScore(`${this.providerId}:${left.nodeId}`));
+        const desiredNodeIds = new Set(candidates.slice(0, this.maxConns).map((member) => member.nodeId));
+        // When acceptAllConnections is set, peers aren't discovered through
+        // room membership — they connect directly via ticket. Skip the
+        // membership-based reconciliation that would otherwise drop them.
+        if (this.options.acceptAllConnections !== true) {
+            for (const [nodeId, record] of this.openrtcConnections.entries()) {
+                if (desiredNodeIds.has(nodeId)) {
+                    continue;
+                }
+                this.openrtcConnections.delete(nodeId);
+                this.emitPeers([], [nodeId]);
+                this.updateSyncedState();
+                if (this.runtimeLease?.owned) {
+                    await record.connection.disconnect().catch(() => undefined);
+                }
+            }
+        }
+        const connectableMembers = candidates.filter((member) => desiredNodeIds.has(member.nodeId) &&
+            shouldInitiateConnection(localNodeId, member.nodeId) &&
+            !this.openrtcConnections.has(member.nodeId) &&
+            !this.pendingNodeIds.has(member.nodeId));
+        await Promise.allSettled(connectableMembers.map(async (member) => {
+            this.pendingNodeIds.add(member.nodeId);
+            try {
+                const connection = await runtime.connectByTicket({
+                    ticket: member.ticket,
+                    timeoutMs: 20000,
+                });
+                if (this.isRelevantConnection(connection)) {
+                    this.attachConnection(connection);
+                }
+            }
+            catch (error) {
+                console.warn(`[y-openrtc] failed to connect to room peer ${member.nodeId}:`, error);
+                this.requestReconcile();
+            }
+            finally {
+                this.pendingNodeIds.delete(member.nodeId);
+            }
+        }));
+    }
+    hasBcNodeId(nodeId) {
+        for (const bcNodeId of this.bcPeers.values()) {
+            if (bcNodeId === nodeId) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isRelevantConnection(connection) {
+        if (!connection.remoteNodeId || connection.remoteNodeId === this.localNodeId) {
+            return false;
+        }
+        return this.options.acceptAllConnections === true || this.roomMembers.has(connection.remoteNodeId);
+    }
+    refreshKnownRuntimeConnections() {
+        const runtime = this.runtime;
+        if (!runtime || !this.shouldConnect) {
+            return;
+        }
+        for (const connection of runtime.getConnections()) {
+            if (this.isRelevantConnection(connection)) {
+                this.attachConnection(connection);
+            }
+        }
+    }
+    startRuntimeConnectionRefresh() {
+        if (this.runtimeRefreshTimer) {
+            return;
+        }
+        this.runtimeRefreshTimer = setInterval(() => {
+            this.refreshKnownRuntimeConnections();
+            this.requestReconcile();
+        }, 1000);
+    }
+    resyncPeer(remoteNodeId) {
+        const record = this.openrtcConnections.get(remoteNodeId);
+        if (!record) {
+            return;
+        }
+        record.synced = false;
+        void this.sendControlToConnection(record.connection, encodeSyncStep1(this.doc));
+        void this.sendControlToConnection(record.connection, encodeAwarenessQuery());
+        this.updateSyncedState();
+    }
+    sendInitialSync(connection, record) {
+        void this.sendControlToConnection(connection, encodeSyncStep1(this.doc));
+        void this.sendControlToConnection(connection, encodeAwarenessQuery());
+        const awarenessStates = Array.from(this.awareness.getStates().keys());
+        if (awarenessStates.length > 0) {
+            void this.sendControlToConnection(connection, encodeAwarenessUpdate(this.awareness, awarenessStates));
+        }
+        for (const delayMs of [250, 1000, 3000]) {
+            setTimeout(() => {
+                if (this.destroyed
+                    || !this.shouldConnect
+                    || record.synced
+                    || connection.isClosed
+                    || this.openrtcConnections.get(connection.remoteNodeId)?.connection.id !== connection.id) {
+                    return;
+                }
+                void this.sendControlToConnection(connection, encodeSyncStep1(this.doc));
+                void this.sendControlToConnection(connection, encodeAwarenessQuery());
+            }, delayMs);
+        }
+    }
+    attachConnection(connection) {
+        const nodeId = connection.remoteNodeId;
+        if (!nodeId) {
+            return;
+        }
+        const existing = this.openrtcConnections.get(nodeId);
+        if (existing?.connection.id === connection.id) {
+            return;
+        }
+        if (existing) {
+            this.openrtcConnections.delete(nodeId);
+        }
+        const record = {
+            connection,
+            synced: false,
+        };
+        this.openrtcConnections.set(nodeId, record);
+        this.emitPeers([nodeId], existing ? [nodeId] : []);
+        this.updateSyncedState();
+        connection.onMessage((message) => {
+            if (!isBinaryPayload(message)) {
+                return;
+            }
+            this.diagnostics.openrtcReceived += 1;
+            void this.handleIncomingPayload(normalizeBinaryPayload(message), { type: 'openrtc', nodeId, connectionId: connection.id }, (reply) => this.sendControlToConnection(connection, reply), record);
+        });
+        connection.onDisconnect(() => {
+            if (!this.openrtcConnections.delete(nodeId)) {
+                return;
+            }
+            this.emitPeers([], [nodeId]);
+            this.updateSyncedState();
+            this.requestReconcile();
+        });
+        this.sendInitialSync(connection, record);
+    }
+    async sendToConnection(connection, payload) {
+        const encrypted = await encryptFrame(payload, await this.keyPromise);
+        this.diagnostics.openrtcSent += 1;
+        await connection.send(encrypted);
+    }
+    async sendControlToConnection(connection, payload) {
+        const encrypted = await encryptFrame(payload, await this.keyPromise);
+        this.diagnostics.openrtcSent += 1;
+        const transportSender = connection;
+        if (typeof transportSender.sendOnTransport === 'function') {
+            try {
+                await transportSender.sendOnTransport('iroh-relay', encrypted);
+                return;
+            }
+            catch {
+                try {
+                    await transportSender.sendOnTransport('iroh', encrypted);
+                    return;
+                }
+                catch {
+                    // Fall back to the default transport order.
+                }
+            }
+        }
+        await connection.send(encrypted);
+    }
+    async sendBroadcastPayload(payload) {
+        const encrypted = await encryptFrame(payload, await this.keyPromise);
+        this.diagnostics.broadcastSent += 1;
+        this.broadcastTransport?.sendPayload(encrypted);
+    }
+    async broadcastProviderPayload(payload, force = false) {
+        if (!force && !this.shouldConnect) {
+            return;
+        }
+        const encrypted = await encryptFrame(payload, await this.keyPromise);
+        this.broadcastTransport?.sendPayload(encrypted);
+        await Promise.allSettled(Array.from(this.openrtcConnections.values()).map(({ connection }) => connection.send(encrypted)));
+    }
+    broadcastInitialBcState() {
+        if (!this.broadcastTransport) {
+            return;
+        }
+        void this.broadcastProviderPayload(encodeSyncStep1(this.doc));
+        void this.broadcastProviderPayload(encodeSyncStep2(this.doc));
+        void this.broadcastProviderPayload(encodeAwarenessQuery());
+        const awarenessStates = Array.from(this.awareness.getStates().keys());
+        if (awarenessStates.length > 0) {
+            void this.broadcastProviderPayload(encodeAwarenessUpdate(this.awareness, awarenessStates));
+        }
+    }
+    async handleIncomingPayload(payload, origin, reply, connectionRecord) {
+        let decrypted;
+        try {
+            decrypted = await decryptFrame(payload, await this.keyPromise);
+        }
+        catch {
+            this.diagnostics.decryptFailed += 1;
+            return;
+        }
+        const messageType = decrypted[0];
+        if (messageType === 0) {
+            const syncType = decrypted[1];
+            if (syncType === 0)
+                this.diagnostics.syncStep1Received += 1;
+            else if (syncType === 1)
+                this.diagnostics.syncStep2Received += 1;
+            else if (syncType === 2)
+                this.diagnostics.syncUpdateReceived += 1;
+        }
+        else if (messageType === 1) {
+            this.diagnostics.awarenessReceived += 1;
+        }
+        else if (messageType === 3) {
+            this.diagnostics.awarenessQueryReceived += 1;
+        }
+        const replies = applyProviderMessage({
+            doc: this.doc,
+            awareness: this.awareness,
+            payload: decrypted,
+            origin,
+            onSynced: () => {
+                if (!connectionRecord) {
+                    return;
+                }
+                connectionRecord.synced = true;
+                this.updateSyncedState();
+            },
+        });
+        this.diagnostics.providerMessagesApplied += 1;
+        for (const replyPayload of replies) {
+            this.diagnostics.providerRepliesSent += 1;
+            await reply(replyPayload);
+        }
+    }
+    updateSyncedState() {
+        const connections = Array.from(this.openrtcConnections.values());
+        const nextSynced = connections.every((record) => record.synced);
+        this.emitSynced(nextSynced);
+    }
+    async disconnectOwnedResources(reason) {
+        const runtime = this.runtime;
+        const roomId = this.roomId;
+        const lease = this.runtimeLease;
+        const trackedConnections = Array.from(this.openrtcConnections.values());
+        this.stopWatchingRoom?.();
+        this.stopWatchingRoom = null;
+        this.stopRuntimeConnections?.();
+        this.stopRuntimeConnections = null;
+        this.stopRuntimeConnectionStates?.();
+        this.stopRuntimeConnectionStates = null;
+        if (this.reconcileTimer) {
+            clearTimeout(this.reconcileTimer);
+            this.reconcileTimer = null;
+        }
+        if (this.runtimeRefreshTimer) {
+            clearInterval(this.runtimeRefreshTimer);
+            this.runtimeRefreshTimer = null;
+        }
+        this.broadcastTransport?.disconnect();
+        this.broadcastTransport = null;
+        this.roomMembers.clear();
+        this.bcPeers.clear();
+        this.pendingNodeIds.clear();
+        this.openrtcConnections.clear();
+        this.runtime = null;
+        this.roomId = null;
+        this.localNodeId = null;
+        this.runtimeLease = null;
+        if (runtime && roomId) {
+            await runtime.leaveRoom(roomId).catch(() => undefined);
+        }
+        if (lease?.owned) {
+            await Promise.allSettled(trackedConnections.map(({ connection }) => connection.disconnect().catch(() => undefined)));
+        }
+        await lease?.release();
+        this.emitSynced(false);
+        if (reason === 'destroy') {
+            return;
+        }
+    }
+    async disconnectInternal(reason) {
+        if (!this.shouldConnect && !this.runtimeLease) {
+            return;
+        }
+        if (this.localObserversAttached) {
+            awarenessProtocol.removeAwarenessStates(this.awareness, [this.doc.clientID], this);
+            await this.broadcastProviderPayload(encodeAwarenessUpdate(this.awareness, [this.doc.clientID]), true);
+        }
+        this.shouldConnect = false;
+        this.emitStatus();
+        this.detachLocalObservers();
+        const removed = [
+            ...this.openrtcConnections.keys(),
+            ...this.bcPeers.keys(),
+        ];
+        if (removed.length > 0) {
+            this.emitPeers([], removed);
+        }
+        await this.disconnectOwnedResources(reason);
+    }
+    async destroyInternal() {
+        if (this.destroyed) {
+            return;
+        }
+        this.destroyed = true;
+        this.doc.off('destroy', this.destroyHandler);
+        await this.disconnectInternal('destroy');
+        this.listeners.clear();
+    }
+}