openrtc-netcode 0.1.0

package/dist/client.js

@@ -0,0 +1,1184 @@
+import { OpenRTC } from 'openrtc';
+import { TypedEmitter } from './events.js';
+import { decodeEnvelope, encodeEnvelope, isRecord, NETCODE_PROTOCOL, NETCODE_PROTOCOL_VERSION, } from './protocol.js';
+import { isNetcodeObjectState, ReplicatedObjectStore } from './objects.js';
+import { ReplicatedState } from './state.js';
+import { NetcodeVoiceController } from './voice.js';
+const DEFAULT_MAX_PEERS = 8;
+const NETCODE_CHANNEL_ID = 'openrtc-netcode/v1';
+const PING_INTERVAL_MS = 2000;
+const MAX_SEEN_ENVELOPES = 2048;
+const CHANNEL_OPEN_TIMEOUT_MS = 15000;
+const UPGRADED_PAYLOAD_TRANSPORTS = new Set(['webrtc', 'webrtc-lan', 'moq']);
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+export class OpenRtcNetcodeClient {
+    constructor(options = {}) {
+        this.options = options;
+        this.runtime = null;
+        this.ownsRuntime = false;
+        this.localPeerId = null;
+        this.currentLobby = null;
+        this.currentRoomId = null;
+        this.fallbackChannel = null;
+        this.lobbyMetadata = {};
+        this.memberMetadata = {};
+        this.seq = 0;
+        this.started = false;
+        this.stopped = false;
+        this.stopWatchingRoom = null;
+        this.stopRuntimeConnections = null;
+        this.stopIncomingNetcodeChannel = null;
+        this.peerPingTimer = null;
+        this.emitter = new TypedEmitter();
+        this.messageListeners = new Map();
+        this.peersById = new Map();
+        this.peerStatsById = new Map();
+        this.connectionsByPeer = new Map();
+        this.channelsByPeer = new Map();
+        this.pendingChannelsByPeer = new Map();
+        this.connectionIds = new Set();
+        this.pendingPeerIds = new Set();
+        this.directSendWarnings = new Set();
+        this.requestedWebRtcUpgradeConnectionIds = new Set();
+        this.introPeerIds = new Set();
+        this.seenEnvelopeIds = new Set();
+        this.seenEnvelopeOrder = [];
+        this.stateStore = new ReplicatedState((options) => this.resolveStateOwner(options), (key, value, owner) => this.broadcastEnvelope('state.patch', { key, value, owner }));
+        this.objectStore = new ReplicatedObjectStore(() => this.localPeerId, (object) => this.broadcastEnvelope('object.upsert', { object }), (id) => this.broadcastEnvelope('object.remove', { id }));
+        this.voiceController = new NetcodeVoiceController(() => this.localPeerId, () => this.peers, shouldInitiateConnection, (peerId, signal) => this.sendEnvelope(peerId, 'voice.signal', { signal }));
+    }
+    get peerId() {
+        return this.localPeerId;
+    }
+    get lobby() {
+        return this.currentLobby ? cloneLobby(this.currentLobby) : null;
+    }
+    get peers() {
+        return Array.from(this.peersById.values()).map(clonePeer);
+    }
+    get peerStats() {
+        return Array.from(this.peerStatsById.values()).map(clonePeerStats);
+    }
+    get state() {
+        return this.stateStore;
+    }
+    get objects() {
+        return this.objectStore;
+    }
+    get voice() {
+        return this.voiceController;
+    }
+    async start() {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        this.stopped = false;
+        this.runtime = this.options.runtime ?? OpenRTC({
+            apiKey: this.options.apiKey,
+            projectId: this.options.projectId,
+            authMode: this.options.authMode,
+            discoveryMode: this.options.discoveryMode,
+            allowAnonymousHostedDefaults: this.options.allowAnonymousHostedDefaults,
+            space: this.options.space,
+            spaceKey: this.options.spaceKey,
+            spaceTokenProvider: this.options.spaceTokenProvider,
+            storagePrefix: this.options.storagePrefix,
+            nodeIdPersistence: this.options.nodeIdPersistence,
+            transports: this.options.transports,
+            transportPriority: this.options.transportPriority,
+            strictMode: this.options.strictMode,
+            turnCredentialsProvider: this.options.turnCredentialsProvider,
+        });
+        this.ownsRuntime = !this.options.runtime;
+        await callOptional(this.runtime, 'initialize');
+        await callOptional(this.runtime, 'start');
+        this.localPeerId = await this.runtime.getNodeId();
+        this.stateStore.replaceOwner('local', this.localPeerId);
+        this.registerNetcodeChannel();
+        this.registerIncomingNetcodeChannel();
+        this.stopRuntimeConnections = this.runtime.onConnection((connection) => {
+            this.attachConnection(connection);
+        });
+        for (const connection of this.runtime.getConnections()) {
+            this.attachConnection(connection);
+        }
+    }
+    async stop() {
+        this.stopped = true;
+        await this.leaveLobby();
+        this.stopRuntimeConnections?.();
+        this.stopRuntimeConnections = null;
+        this.stopIncomingNetcodeChannel?.();
+        this.stopIncomingNetcodeChannel = null;
+        await this.closeNetcodeChannels();
+        for (const connection of this.connectionsByPeer.values()) {
+            await connection.disconnect?.();
+        }
+        this.connectionsByPeer.clear();
+        this.connectionIds.clear();
+        this.pendingPeerIds.clear();
+        this.directSendWarnings.clear();
+        this.requestedWebRtcUpgradeConnectionIds.clear();
+        this.introPeerIds.clear();
+        this.peerStatsById.clear();
+        this.seenEnvelopeIds.clear();
+        this.seenEnvelopeOrder.length = 0;
+        this.stopPeerPingLoop();
+        this.peersById.clear();
+        this.objectStore.clear();
+        await this.voiceController.stop();
+        this.emitter.clear();
+        this.messageListeners.clear();
+        if (this.ownsRuntime) {
+            await callOptional(this.runtime, 'stop');
+        }
+        this.runtime = null;
+        this.started = false;
+    }
+    async createLobby(options = {}) {
+        await this.start();
+        const runtime = this.requireRuntime();
+        await this.leaveLobby();
+        const lobbyId = await runtime.createRoom(options.id);
+        this.lobbyMetadata = { ...(options.metadata ?? {}) };
+        return this.activateLobby(lobbyId);
+    }
+    async joinLobby(lobbyId, options = {}) {
+        await this.start();
+        const runtime = this.requireRuntime();
+        await this.leaveLobby();
+        const roomId = normalizeLobbyId(lobbyId);
+        this.memberMetadata = { ...(options.metadata ?? {}) };
+        await runtime.joinRoom(roomId, { bootstrapPeers: false });
+        return this.activateLobby(roomId);
+    }
+    async joinOrCreateLobby(lobbyId, options = {}) {
+        try {
+            return await this.joinLobby(lobbyId, options);
+        }
+        catch (error) {
+            if (!isRoomNotFoundError(error)) {
+                throw error;
+            }
+            const runtime = this.requireRuntime();
+            const roomId = normalizeLobbyId(lobbyId);
+            this.memberMetadata = { ...(options.metadata ?? {}) };
+            try {
+                const createdRoomId = await runtime.createRoom(roomId);
+                return this.activateLobby(createdRoomId);
+            }
+            catch (createError) {
+                if (!isRoomAlreadyExistsError(createError)) {
+                    throw createError;
+                }
+            }
+            return this.joinLobbyWithRetry(roomId, options);
+        }
+    }
+    async activateLobby(lobbyId) {
+        const runtime = this.requireRuntime();
+        const roomId = normalizeLobbyId(lobbyId);
+        this.currentRoomId = roomId;
+        this.openFallbackChannel(roomId);
+        this.startPeerPingLoop();
+        this.stopWatchingRoom = runtime.watchRoom(roomId, (members) => {
+            void this.handleRoomMembers(members);
+        });
+        await this.handleRoomMembers(await this.getRoomMembersWithRetry(roomId));
+        await this.broadcastMemberMetadata();
+        return this.requireLobby();
+    }
+    async joinLobbyWithRetry(lobbyId, options) {
+        let lastError;
+        for (let attempt = 0; attempt < 6; attempt += 1) {
+            try {
+                return await this.joinLobby(lobbyId, options);
+            }
+            catch (error) {
+                lastError = error;
+                if (!isRoomAdmissionTransientError(error) || attempt === 5) {
+                    break;
+                }
+                await delay(150 * (attempt + 1));
+            }
+        }
+        throw lastError;
+    }
+    async getRoomMembersWithRetry(roomId) {
+        const runtime = this.requireRuntime();
+        let lastError;
+        for (let attempt = 0; attempt < 6; attempt += 1) {
+            try {
+                return await runtime.getRoomMembers(roomId);
+            }
+            catch (error) {
+                lastError = error;
+                if (!isRoomNotFoundError(error) || attempt === 5) {
+                    break;
+                }
+                await delay(150 * (attempt + 1));
+            }
+        }
+        throw lastError;
+    }
+    async leaveLobby() {
+        const runtime = this.runtime;
+        const roomId = this.currentRoomId;
+        this.stopWatchingRoom?.();
+        this.stopWatchingRoom = null;
+        this.currentRoomId = null;
+        this.stopPeerPingLoop();
+        this.closeFallbackChannel();
+        await this.closeNetcodeChannels();
+        this.currentLobby = null;
+        this.peersById.clear();
+        this.pendingPeerIds.clear();
+        this.introPeerIds.clear();
+        this.peerStatsById.clear();
+        this.seenEnvelopeIds.clear();
+        this.seenEnvelopeOrder.length = 0;
+        this.objectStore.clear();
+        await this.voiceController.stop();
+        if (runtime && roomId) {
+            await runtime.leaveRoom(roomId);
+        }
+        this.emitter.emit('lobby', null);
+    }
+    async send(peerId, type, payload, options = {}) {
+        assertReliable(options);
+        await this.sendEnvelope(peerId, 'user', { type, payload });
+    }
+    async broadcast(type, payload, options = {}) {
+        assertReliable(options);
+        await this.broadcastEnvelope('user', { type, payload });
+    }
+    on(event, handler) {
+        return this.emitter.on(event, handler);
+    }
+    onMessage(type, handler) {
+        const listeners = this.messageListeners.get(type) ?? new Set();
+        const listener = handler;
+        listeners.add(listener);
+        this.messageListeners.set(type, listeners);
+        return () => listeners.delete(listener);
+    }
+    async setLobbyData(key, value) {
+        this.lobbyMetadata = { ...this.lobbyMetadata, [key]: value };
+        this.refreshLobby();
+        await this.broadcastEnvelope('lobby.meta', { values: this.lobbyMetadata });
+    }
+    async setMemberData(key, value) {
+        this.memberMetadata = { ...this.memberMetadata, [key]: value };
+        await this.broadcastMemberMetadata();
+    }
+    async handleRoomMembers(members) {
+        if (this.stopped || !this.localPeerId || !this.currentRoomId) {
+            return;
+        }
+        const activeMembers = members.filter(hasActiveMember);
+        const nextPeerIds = new Set();
+        for (const member of activeMembers) {
+            const peerId = member.nodeId;
+            if (!peerId || peerId === this.localPeerId) {
+                continue;
+            }
+            nextPeerIds.add(peerId);
+            const previous = this.peersById.get(peerId);
+            const peer = {
+                id: peerId,
+                userId: member.userId,
+                ticket: member.ticket,
+                joinedAt: member.joinedAt,
+                connected: this.isPeerPayloadReady(peerId),
+                metadata: previous?.metadata ?? parseMetadata(member.metadata),
+                stats: this.peerStatsById.get(peerId),
+            };
+            this.peersById.set(peerId, peer);
+            this.updatePeerStats(peerId, {
+                connected: peer.connected,
+                transport: this.resolvePeerTransport(peerId),
+            });
+            if (!previous) {
+                this.emitter.emit('peer:joined', clonePeer(peer));
+                if (this.fallbackChannel) {
+                    this.queuePeerIntro(peerId);
+                }
+            }
+        }
+        for (const [peerId, peer] of Array.from(this.peersById.entries())) {
+            if (!nextPeerIds.has(peerId)) {
+                if (this.fallbackChannel) {
+                    continue;
+                }
+                const connection = this.connectionsByPeer.get(peerId);
+                this.peersById.delete(peerId);
+                this.connectionsByPeer.delete(peerId);
+                this.pendingPeerIds.delete(peerId);
+                if (connection?.id) {
+                    this.requestedWebRtcUpgradeConnectionIds.delete(connection.id);
+                }
+                this.introPeerIds.delete(peerId);
+                this.peerStatsById.delete(peerId);
+                this.emitter.emit('peer:left', clonePeer(peer));
+                this.voiceController.handlePeerDisconnected(peerId);
+            }
+        }
+        this.refreshLobby(activeMembers);
+        void this.reconcileMesh();
+    }
+    async reconcileMesh() {
+        if (!this.runtime || !this.localPeerId) {
+            return;
+        }
+        const maxPeers = this.options.maxPeers ?? DEFAULT_MAX_PEERS;
+        for (const peer of this.peersById.values()) {
+            if (this.connectionsByPeer.size >= maxPeers) {
+                return;
+            }
+            if (!peer.ticket || !shouldInitiateConnection(this.localPeerId, peer.id)) {
+                continue;
+            }
+            if (this.connectionsByPeer.has(peer.id) || this.pendingPeerIds.has(peer.id)) {
+                continue;
+            }
+            this.pendingPeerIds.add(peer.id);
+            try {
+                const connection = await this.runtime.connectByTicket({ ticket: peer.ticket });
+                this.attachConnection(connection, peer.id);
+                await this.sendPeerIntro(peer.id, true);
+            }
+            catch (error) {
+                console.warn('[openrtc-netcode] peer dial failed; leaving peer disconnected', error);
+            }
+            finally {
+                this.pendingPeerIds.delete(peer.id);
+            }
+        }
+    }
+    attachConnection(connection, peerIdHint) {
+        const connectionId = connection.id;
+        if (connectionId && this.connectionIds.has(connectionId)) {
+            return;
+        }
+        const peerId = peerIdHint ?? connection.remoteNodeId ?? connection.deviceId;
+        if (!peerId || peerId === this.localPeerId) {
+            return;
+        }
+        if (connectionId) {
+            this.connectionIds.add(connectionId);
+        }
+        this.connectionsByPeer.set(peerId, connection);
+        this.requestPreferredTransportUpgrade(connection);
+        const payloadReady = this.isPeerPayloadReady(peerId);
+        const peer = this.upsertPeer(peerId, { connected: payloadReady });
+        this.updatePeerStats(peerId, {
+            connected: payloadReady,
+            transport: this.resolvePeerTransport(peerId),
+        });
+        if (payloadReady) {
+            this.emitter.emit('peer:connected', clonePeer(peer));
+            void this.voiceController.handlePeerConnected(peerId);
+        }
+        connection.onMessage((message) => {
+            this.handleConnectionMessage(peerId, message);
+        });
+        connection.onDisconnect(() => {
+            if (this.connectionsByPeer.get(peerId) === connection) {
+                this.connectionsByPeer.delete(peerId);
+            }
+            if (connectionId) {
+                this.connectionIds.delete(connectionId);
+                this.requestedWebRtcUpgradeConnectionIds.delete(connectionId);
+            }
+            const disconnected = this.upsertPeer(peerId, { connected: false });
+            this.updatePeerStats(peerId, {
+                connected: false,
+                transport: this.resolvePeerTransport(peerId),
+            });
+            this.emitter.emit('peer:disconnected', clonePeer(disconnected));
+            this.voiceController.handlePeerDisconnected(peerId);
+        });
+        if (payloadReady) {
+            this.queuePeerIntro(peerId, true);
+        }
+        if (payloadReady && this.currentRoomId) {
+            void this.sendEnvelope(peerId, 'ping', {});
+        }
+    }
+    async sendPeerIntro(peerId, force = false) {
+        if (!this.localPeerId) {
+            return;
+        }
+        if (!this.currentRoomId || (!force && this.introPeerIds.has(peerId))) {
+            return;
+        }
+        this.introPeerIds.add(peerId);
+        try {
+            await this.sendEnvelope(peerId, 'hello', {
+                peerId: this.localPeerId,
+                displayName: this.options.displayName,
+            });
+            await this.sendStateSnapshot(peerId);
+            await this.sendObjectSnapshot(peerId);
+            await this.sendEnvelope(peerId, 'lobby.meta', { values: this.lobbyMetadata });
+            await this.sendEnvelope(peerId, 'member.meta', { values: this.memberMetadata });
+        }
+        catch (error) {
+            this.introPeerIds.delete(peerId);
+            throw error;
+        }
+    }
+    queuePeerIntro(peerId, force = false) {
+        queueTask(() => {
+            void this.sendPeerIntro(peerId, force).catch((error) => {
+                if (this.currentRoomId) {
+                    console.warn('[openrtc-netcode] peer intro failed', error);
+                }
+            });
+        });
+    }
+    handleConnectionMessage(peerId, message) {
+        const envelope = decodeEnvelope(message);
+        if (!envelope || envelope.lobbyId !== this.currentRoomId) {
+            return;
+        }
+        if (envelope.from === this.localPeerId) {
+            return;
+        }
+        if (envelope.target && envelope.target !== this.localPeerId) {
+            return;
+        }
+        if (!this.markEnvelopeSeen(envelope)) {
+            return;
+        }
+        this.upsertPeer(peerId, { connected: true });
+        this.updatePeerStats(peerId, {
+            connected: true,
+            transport: this.resolvePeerTransport(peerId),
+        });
+        this.emitter.emit('envelope', envelope);
+        switch (envelope.kind) {
+            case 'hello':
+                this.handleHello(peerId, envelope.body);
+                break;
+            case 'user':
+                this.handleUserMessage(envelope);
+                break;
+            case 'state.snapshot':
+                this.handleStateSnapshot(envelope.body);
+                break;
+            case 'state.patch':
+                this.handleStatePatch(envelope.body);
+                break;
+            case 'object.snapshot':
+                this.handleObjectSnapshot(envelope.from, envelope.body);
+                break;
+            case 'object.upsert':
+                this.handleObjectUpsert(envelope.from, envelope.body);
+                break;
+            case 'object.remove':
+                this.handleObjectRemove(envelope.from, envelope.body);
+                break;
+            case 'lobby.meta':
+                this.handleLobbyMetadata(envelope.body);
+                break;
+            case 'member.meta':
+                this.handleMemberMetadata(peerId, envelope.body);
+                break;
+            case 'voice.signal':
+                this.handleVoiceSignal(peerId, envelope.body);
+                break;
+            case 'ping':
+                void this.sendEnvelope(peerId, 'pong', { pingSentAt: envelope.sentAt });
+                break;
+            case 'peer':
+                break;
+            case 'pong':
+                this.handlePong(peerId, envelope.body);
+                break;
+        }
+    }
+    markEnvelopeSeen(envelope) {
+        const id = `${envelope.from}:${envelope.seq}`;
+        if (this.seenEnvelopeIds.has(id)) {
+            return false;
+        }
+        this.seenEnvelopeIds.add(id);
+        this.seenEnvelopeOrder.push(id);
+        while (this.seenEnvelopeOrder.length > MAX_SEEN_ENVELOPES) {
+            const oldest = this.seenEnvelopeOrder.shift();
+            if (oldest) {
+                this.seenEnvelopeIds.delete(oldest);
+            }
+        }
+        return true;
+    }
+    handleHello(peerId, body) {
+        if (!isRecord(body)) {
+            return;
+        }
+        const displayName = typeof body.displayName === 'string' ? body.displayName : undefined;
+        this.upsertPeer(peerId, {
+            connected: true,
+            metadata: displayName ? { displayName } : undefined,
+        });
+        this.queuePeerIntro(peerId);
+    }
+    handleUserMessage(envelope) {
+        const body = envelope.body;
+        if (!body || typeof body.type !== 'string') {
+            return;
+        }
+        const message = {
+            type: body.type,
+            payload: body.payload,
+            from: envelope.from,
+            target: envelope.target,
+            sentAt: envelope.sentAt,
+        };
+        this.emitter.emit('message', message);
+        for (const listener of this.messageListeners.get(body.type) ?? []) {
+            listener(message);
+        }
+    }
+    handleStateSnapshot(body) {
+        if (!isRecord(body) || !isRecord(body.values) || !isRecord(body.owners)) {
+            return;
+        }
+        const snapshot = {
+            values: body.values,
+            owners: stringifyRecord(body.owners),
+        };
+        this.stateStore.applySnapshot(snapshot.values, snapshot.owners);
+        this.emitter.emit('state:snapshot', snapshot);
+    }
+    handleStatePatch(body) {
+        if (!isRecord(body) || typeof body.key !== 'string' || typeof body.owner !== 'string') {
+            return;
+        }
+        const patch = {
+            key: body.key,
+            value: body.value,
+            owner: body.owner,
+        };
+        this.stateStore.applyPatch(patch.key, patch.value, patch.owner);
+        this.emitter.emit('state:patch', patch);
+    }
+    handleObjectSnapshot(from, body) {
+        if (!isRecord(body) || !isRecord(body.objects)) {
+            return;
+        }
+        const objects = {};
+        for (const [id, object] of Object.entries(body.objects)) {
+            if (isNetcodeObjectState(object)) {
+                objects[id] = object;
+            }
+        }
+        const snapshot = { objects };
+        this.objectStore.applySnapshot(objects, from);
+        this.emitter.emit('object:snapshot', snapshot);
+    }
+    handleObjectUpsert(from, body) {
+        if (!isRecord(body) || !isNetcodeObjectState(body.object)) {
+            return;
+        }
+        const upsert = { object: body.object };
+        this.objectStore.applyUpsert(body.object, from);
+        this.emitter.emit('object:upsert', upsert);
+    }
+    handleObjectRemove(from, body) {
+        if (!isRecord(body) || typeof body.id !== 'string') {
+            return;
+        }
+        const remove = { id: body.id };
+        this.objectStore.applyRemove(remove.id, from);
+        this.emitter.emit('object:remove', remove);
+    }
+    handleLobbyMetadata(body) {
+        if (!isRecord(body) || !isRecord(body.values)) {
+            return;
+        }
+        const metadata = { values: stringifyRecord(body.values) };
+        this.lobbyMetadata = metadata.values;
+        this.refreshLobby();
+        this.emitter.emit('lobby:metadata', metadata);
+    }
+    handleMemberMetadata(peerId, body) {
+        if (!isRecord(body) || !isRecord(body.values)) {
+            return;
+        }
+        const metadata = { values: stringifyRecord(body.values) };
+        this.upsertPeer(peerId, { metadata: metadata.values });
+        this.emitter.emit('member:metadata', { peerId, values: metadata.values });
+    }
+    handleVoiceSignal(peerId, body) {
+        if (!isRecord(body) || !isRecord(body.signal)) {
+            return;
+        }
+        const signal = { signal: body.signal };
+        this.emitter.emit('voice:signal', { peerId, ...signal });
+        void this.voiceController.handleSignal(peerId, signal.signal);
+    }
+    handlePong(peerId, body) {
+        if (!isRecord(body) || typeof body.pingSentAt !== 'number') {
+            return;
+        }
+        const latencyMs = Math.max(0, Date.now() - body.pingSentAt);
+        this.updatePeerStats(peerId, {
+            latencyMs,
+            connected: true,
+            transport: this.resolvePeerTransport(peerId),
+        });
+    }
+    async sendStateSnapshot(peerId) {
+        await this.sendEnvelope(peerId, 'state.snapshot', {
+            values: this.stateStore.snapshot(),
+            owners: this.stateStore.owners(),
+        });
+    }
+    async sendObjectSnapshot(peerId) {
+        await this.sendEnvelope(peerId, 'object.snapshot', {
+            objects: this.objectStore.snapshot(),
+        });
+    }
+    async broadcastMemberMetadata() {
+        await this.broadcastEnvelope('member.meta', { values: this.memberMetadata });
+    }
+    startPeerPingLoop() {
+        this.stopPeerPingLoop();
+        this.peerPingTimer = setInterval(() => {
+            if (!this.currentRoomId || !this.localPeerId) {
+                return;
+            }
+            for (const peer of this.peersById.values()) {
+                const payloadReady = this.isPeerPayloadReady(peer.id);
+                if (!payloadReady) {
+                    const connection = this.connectionsByPeer.get(peer.id);
+                    if (connection) {
+                        this.requestPreferredTransportUpgrade(connection);
+                    }
+                }
+                if (payloadReady && !peer.connected) {
+                    const connected = this.upsertPeer(peer.id, { connected: true });
+                    this.emitter.emit('peer:connected', clonePeer(connected));
+                    void this.voiceController.handlePeerConnected(peer.id);
+                    this.queuePeerIntro(peer.id, true);
+                }
+                if (payloadReady) {
+                    void this.sendEnvelope(peer.id, 'ping', {});
+                }
+                this.updatePeerStats(peer.id, {
+                    connected: payloadReady,
+                    transport: this.resolvePeerTransport(peer.id),
+                });
+            }
+        }, PING_INTERVAL_MS);
+    }
+    stopPeerPingLoop() {
+        if (this.peerPingTimer) {
+            clearInterval(this.peerPingTimer);
+            this.peerPingTimer = null;
+        }
+    }
+    async broadcastEnvelope(kind, body) {
+        const envelope = this.createEnvelope(kind, body);
+        if (this.fallbackChannel) {
+            this.fallbackChannel.postMessage(encodeEnvelope(envelope));
+        }
+        const sends = Array.from(this.connectionsByPeer.keys()).map((peerId) => this.sendDirectEnvelope(peerId, envelope));
+        await Promise.all(sends);
+    }
+    async sendEnvelope(peerId, kind, body) {
+        const envelope = this.createEnvelope(kind, body, peerId);
+        if (this.fallbackChannel) {
+            this.fallbackChannel.postMessage(encodeEnvelope(envelope));
+        }
+        await this.sendDirectEnvelope(peerId, envelope);
+    }
+    async sendDirectEnvelope(peerId, envelope) {
+        const channel = await this.resolveNetcodeChannel(peerId);
+        if (channel) {
+            await channel.send(textEncoder.encode(encodeEnvelope(envelope)));
+            return;
+        }
+        const connection = this.resolvePayloadConnection(peerId);
+        if (!connection || connection.isClosed) {
+            return;
+        }
+        let send;
+        try {
+            send = Promise.resolve(connection.send(encodeEnvelope(envelope)));
+        }
+        catch (error) {
+            if (this.fallbackChannel) {
+                this.warnDirectSendFailure(peerId, envelope.kind, error);
+                return;
+            }
+            throw error;
+        }
+        if (this.fallbackChannel) {
+            void send.catch((error) => this.warnDirectSendFailure(peerId, envelope.kind, error));
+            return;
+        }
+        await send;
+    }
+    warnDirectSendFailure(peerId, kind, error) {
+        const key = `${peerId}:${kind}`;
+        if (this.directSendWarnings.has(key)) {
+            return;
+        }
+        this.directSendWarnings.add(key);
+        console.warn('[openrtc-netcode] direct send failed; local dev fallback already published envelope', error);
+    }
+    openFallbackChannel(roomId) {
+        this.closeFallbackChannel();
+        if (this.options.localFallback !== true) {
+            return;
+        }
+        if (typeof globalThis.BroadcastChannel !== 'function') {
+            return;
+        }
+        const channel = new globalThis.BroadcastChannel(`openrtc-netcode:${roomId}`);
+        channel.onmessage = (event) => {
+            const envelope = decodeEnvelope(event.data);
+            if (!envelope || envelope.from === this.localPeerId) {
+                return;
+            }
+            this.handleConnectionMessage(envelope.from, envelope);
+        };
+        this.fallbackChannel = channel;
+    }
+    closeFallbackChannel() {
+        this.fallbackChannel?.close();
+        this.fallbackChannel = null;
+    }
+    async resolveNetcodeChannel(peerId) {
+        const existing = this.channelsByPeer.get(peerId);
+        if (existing) {
+            return existing;
+        }
+        const pending = this.pendingChannelsByPeer.get(peerId);
+        if (pending) {
+            return pending;
+        }
+        const runtime = this.runtime;
+        if (typeof runtime?.connectScopedChannel !== 'function') {
+            return null;
+        }
+        const ticket = await this.resolvePeerTicket(peerId);
+        if (!ticket) {
+            return null;
+        }
+        const opening = runtime.connectScopedChannel({
+            peerId,
+            ticket,
+            scope: NETCODE_CHANNEL_ID,
+            channelId: NETCODE_CHANNEL_ID,
+            timeoutMs: CHANNEL_OPEN_TIMEOUT_MS,
+            nativeLabel: true,
+            framing: 'u32be',
+        }).then((channel) => {
+            this.attachNetcodeChannel(peerId, channel);
+            return channel;
+        }).catch(() => null).finally(() => {
+            this.pendingChannelsByPeer.delete(peerId);
+        });
+        this.pendingChannelsByPeer.set(peerId, opening);
+        return opening;
+    }
+    async resolvePeerTicket(peerId) {
+        const existing = this.peersById.get(peerId)?.ticket?.trim();
+        if (existing) {
+            return existing;
+        }
+        if (!this.currentRoomId || !this.runtime) {
+            return undefined;
+        }
+        const members = await this.getRoomMembersWithRetry(this.currentRoomId).catch(() => []);
+        const member = members.find((candidate) => candidate.nodeId === peerId && candidate.ticket);
+        if (!member?.ticket) {
+            return undefined;
+        }
+        const previous = this.peersById.get(peerId);
+        this.peersById.set(peerId, {
+            id: peerId,
+            userId: member.userId ?? previous?.userId,
+            ticket: member.ticket,
+            joinedAt: member.joinedAt ?? previous?.joinedAt,
+            connected: previous?.connected ?? this.isPeerPayloadReady(peerId),
+            metadata: previous?.metadata ?? parseMetadata(member.metadata),
+            stats: previous?.stats ?? this.peerStatsById.get(peerId),
+        });
+        this.refreshLobby();
+        return member.ticket;
+    }
+    attachNetcodeChannel(peerId, channel) {
+        this.channelsByPeer.set(peerId, channel);
+        channel.onMessage((payload) => {
+            this.handleConnectionMessage(peerId, textDecoder.decode(payload));
+        });
+        const peer = this.upsertPeer(peerId, { connected: true });
+        this.updatePeerStats(peerId, {
+            connected: true,
+            transport: this.resolvePeerTransport(peerId),
+        });
+        this.emitter.emit('peer:connected', clonePeer(peer));
+        void this.voiceController.handlePeerConnected(peerId);
+        this.queuePeerIntro(peerId, true);
+    }
+    registerIncomingNetcodeChannel() {
+        const runtime = this.runtime;
+        if (typeof runtime?.onIncomingChannelStream !== 'function') {
+            return;
+        }
+        this.stopIncomingNetcodeChannel?.();
+        this.stopIncomingNetcodeChannel = runtime.onIncomingChannelStream(NETCODE_CHANNEL_ID, (incoming) => {
+            if (incoming.type !== 'bi' || !incoming.remoteNodeId || !incoming.stream) {
+                return false;
+            }
+            this.readIncomingNetcodeStream(incoming.remoteNodeId, incoming.stream);
+            return true;
+        });
+    }
+    readIncomingNetcodeStream(peerId, stream) {
+        const readable = stream.recv ?? stream.readable;
+        if (!readable) {
+            return;
+        }
+        void (async () => {
+            const reader = readable.getReader();
+            let buffered = new Uint8Array(0);
+            try {
+                while (!this.stopped) {
+                    const { value, done } = await reader.read();
+                    if (done) {
+                        break;
+                    }
+                    if (!value?.byteLength) {
+                        continue;
+                    }
+                    buffered = concatBytes(buffered, value);
+                    while (buffered.byteLength >= 4) {
+                        const length = readU32BE(buffered);
+                        if (buffered.byteLength < length + 4) {
+                            break;
+                        }
+                        const payload = buffered.slice(4, 4 + length);
+                        buffered = buffered.slice(4 + length);
+                        this.handleConnectionMessage(peerId, textDecoder.decode(payload));
+                    }
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        })();
+    }
+    async closeNetcodeChannels() {
+        const channels = Array.from(this.channelsByPeer.values());
+        this.channelsByPeer.clear();
+        this.pendingChannelsByPeer.clear();
+        await Promise.allSettled(channels.map((channel) => channel.close()));
+    }
+    createEnvelope(kind, body, target) {
+        if (!this.currentRoomId || !this.localPeerId) {
+            throw new Error('openrtc-netcode requires a joined lobby before sending.');
+        }
+        return {
+            protocol: NETCODE_PROTOCOL,
+            v: NETCODE_PROTOCOL_VERSION,
+            kind,
+            lobbyId: this.currentRoomId,
+            from: this.localPeerId,
+            seq: ++this.seq,
+            sentAt: Date.now(),
+            target,
+            body,
+        };
+    }
+    resolveStateOwner(options) {
+        if (options?.owner === 'lobby-owner') {
+            return this.currentLobby?.ownerId ?? this.localPeerId ?? 'local';
+        }
+        if (options?.owner && options.owner !== 'local') {
+            return options.owner;
+        }
+        return this.localPeerId ?? 'local';
+    }
+    upsertPeer(peerId, update) {
+        const previous = this.peersById.get(peerId);
+        const { metadata, ...restUpdate } = update;
+        const peer = {
+            id: peerId,
+            connected: false,
+            ...previous,
+            ...restUpdate,
+            stats: this.peerStatsById.get(peerId),
+            metadata: {
+                ...(previous?.metadata ?? {}),
+                ...(metadata ?? {}),
+            },
+        };
+        this.peersById.set(peerId, peer);
+        this.refreshLobby();
+        return peer;
+    }
+    updatePeerStats(peerId, update) {
+        const previous = this.peerStatsById.get(peerId);
+        const stats = {
+            peerId,
+            transport: previous?.transport ?? 'unknown',
+            latencyMs: previous?.latencyMs ?? null,
+            connected: previous?.connected ?? false,
+            ...update,
+            updatedAt: Date.now(),
+        };
+        this.peerStatsById.set(peerId, stats);
+        const peer = this.peersById.get(peerId);
+        if (peer) {
+            this.peersById.set(peerId, { ...peer, stats });
+            this.refreshLobby();
+        }
+        this.emitter.emit('peer:stats', clonePeerStats(stats));
+        return stats;
+    }
+    resolvePeerTransport(peerId) {
+        const connection = this.resolvePayloadConnection(peerId);
+        const status = connection?.getTransportStatus?.();
+        if (status?.activeTransport) {
+            return status.parallelTransport
+                ? `${status.activeTransport}+${status.parallelTransport}`
+                : status.activeTransport;
+        }
+        const transports = connection?.getAvailableTransports?.();
+        if (transports && transports.length > 0) {
+            return transports.join('+');
+        }
+        return this.connectionsByPeer.has(peerId) ? 'connecting' : 'unknown';
+    }
+    isPeerPayloadReady(peerId) {
+        return this.channelsByPeer.has(peerId) || !!this.resolvePayloadConnection(peerId);
+    }
+    resolvePayloadConnection(peerId) {
+        const channel = this.channelsByPeer.get(peerId);
+        if (channel?.connection) {
+            return channel.connection;
+        }
+        const runtime = this.runtime;
+        if (typeof runtime?.getApplicationReadyConnections === 'function') {
+            return runtime.getApplicationReadyConnections(this.payloadReadinessOptions())
+                .find((connection) => connection.remoteNodeId === peerId || connection.deviceId === peerId)
+                ?? null;
+        }
+        return this.connectionsByPeer.get(peerId) ?? null;
+    }
+    requestPreferredTransportUpgrade(connection) {
+        const preferredTransports = this.payloadReadinessOptions().preferredTransports ?? [];
+        const wantsWebRtc = preferredTransports.some((transport) => transport === 'webrtc' || transport === 'webrtc-lan');
+        if (!wantsWebRtc || typeof connection.requestWebRTCUpgrade !== 'function') {
+            return;
+        }
+        const remotePeerId = connection.remoteNodeId ?? connection.deviceId;
+        if (this.localPeerId && remotePeerId && this.localPeerId.localeCompare(remotePeerId) <= 0) {
+            return;
+        }
+        const upgradeKey = connection.id ?? connection.remoteNodeId ?? connection.deviceId;
+        if (upgradeKey && this.requestedWebRtcUpgradeConnectionIds.has(upgradeKey)) {
+            return;
+        }
+        if (upgradeKey) {
+            this.requestedWebRtcUpgradeConnectionIds.add(upgradeKey);
+        }
+        connection.requestWebRTCUpgrade('openrtc-netcode-preferred-payload');
+    }
+    payloadReadinessOptions() {
+        const preferredTransports = this.options.preferredPayloadTransports
+            ?? derivePreferredPayloadTransports(this.options.transports, this.options.transportPriority);
+        if (preferredTransports.length === 0) {
+            return {};
+        }
+        return {
+            preferredTransports,
+            allowFallbackAfterPreferredTransportFailure: true,
+        };
+    }
+    refreshLobby(members) {
+        if (!this.currentRoomId || !this.localPeerId) {
+            return;
+        }
+        const ownerId = resolveOwnerId(members, this.localPeerId);
+        this.currentLobby = {
+            id: this.currentRoomId,
+            localPeerId: this.localPeerId,
+            ownerId,
+            members: [
+                {
+                    id: this.localPeerId,
+                    connected: true,
+                    metadata: { ...this.memberMetadata },
+                },
+                ...this.peers,
+            ],
+            metadata: { ...this.lobbyMetadata },
+        };
+        this.emitter.emit('lobby', cloneLobby(this.currentLobby));
+    }
+    requireRuntime() {
+        if (!this.runtime) {
+            throw new Error('openrtc-netcode runtime is not started.');
+        }
+        return this.runtime;
+    }
+    requireLobby() {
+        if (!this.currentLobby) {
+            throw new Error('openrtc-netcode is not in a lobby.');
+        }
+        return cloneLobby(this.currentLobby);
+    }
+    registerNetcodeChannel() {
+        const maybeChannelClient = this.runtime;
+        maybeChannelClient.channels?.register({
+            id: NETCODE_CHANNEL_ID,
+            kind: 'sync',
+            ownership: 'shared',
+            peerModel: 'node-first',
+            routing: 'stream-envelope',
+            readiness: 'settled-peer',
+            description: 'OpenRTC netcode V1 messages and state snapshots.',
+        });
+    }
+}
+export function createNetcode(options = {}) {
+    return new OpenRtcNetcodeClient(options);
+}
+export function shouldInitiateConnection(localPeerId, remotePeerId) {
+    return localPeerId.localeCompare(remotePeerId) < 0;
+}
+function normalizeLobbyId(lobbyId) {
+    return lobbyId.trim().toUpperCase();
+}
+function hasActiveMember(member) {
+    const now = Date.now();
+    if (typeof member.expiresAt === 'number') {
+        return member.expiresAt >= now;
+    }
+    const lastSeenAt = member.lastSeenAt ?? member.joinedAt ?? now;
+    return now - lastSeenAt <= 5 * 60 * 1000;
+}
+function resolveOwnerId(members, fallback) {
+    const candidates = (members ?? [])
+        .filter((member) => typeof member.nodeId === 'string')
+        .sort((left, right) => {
+        const joinedDelta = (left.joinedAt ?? 0) - (right.joinedAt ?? 0);
+        return joinedDelta || left.nodeId.localeCompare(right.nodeId);
+    });
+    return candidates[0]?.nodeId ?? fallback;
+}
+function parseMetadata(value) {
+    if (!value) {
+        return {};
+    }
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            return isRecord(parsed) ? stringifyRecord(parsed) : {};
+        }
+        catch {
+            return {};
+        }
+    }
+    return stringifyRecord(value);
+}
+function stringifyRecord(value) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry === 'string') {
+            result[key] = entry;
+        }
+        else if (entry !== undefined) {
+            result[key] = JSON.stringify(entry);
+        }
+    }
+    return result;
+}
+function clonePeer(peer) {
+    return {
+        ...peer,
+        stats: peer.stats ? clonePeerStats(peer.stats) : undefined,
+        metadata: { ...peer.metadata },
+    };
+}
+function clonePeerStats(stats) {
+    return { ...stats };
+}
+function cloneLobby(lobby) {
+    return {
+        ...lobby,
+        metadata: { ...lobby.metadata },
+        members: lobby.members.map(clonePeer),
+    };
+}
+function concatBytes(left, right) {
+    const combined = new Uint8Array(left.byteLength + right.byteLength);
+    combined.set(left, 0);
+    combined.set(right, left.byteLength);
+    return combined;
+}
+function readU32BE(bytes) {
+    return (((bytes[0] ?? 0) * 0x1000000)
+        + (((bytes[1] ?? 0) << 16) >>> 0)
+        + (((bytes[2] ?? 0) << 8) >>> 0)
+        + (bytes[3] ?? 0)) >>> 0;
+}
+function assertReliable(options) {
+    if (options.reliability && options.reliability !== 'reliable') {
+        throw new Error('openrtc-netcode V1 supports reliable messages only.');
+    }
+}
+function isRoomNotFoundError(error) {
+    const text = error instanceof Error ? error.message : String(error);
+    return /room not found|not found|status["']?\s*:\s*["']?not_found|code["']?\s*:\s*404/i.test(text);
+}
+function isRoomAlreadyExistsError(error) {
+    const text = error instanceof Error ? error.message : String(error);
+    return /room already exists|already exists|ALREADY_EXISTS|conflict|code["']?\s*:\s*409/i.test(text);
+}
+function isRoomAdmissionTransientError(error) {
+    const text = error instanceof Error ? error.message : String(error);
+    return isRoomNotFoundError(error)
+        || /permission[_ -]?denied|permission denied|forbidden|code["']?\s*:\s*403|status["']?\s*:\s*["']?permission_denied/i.test(text);
+}
+function derivePreferredPayloadTransports(transports, transportPriority) {
+    const configuredPriority = (transportPriority ?? [])
+        .filter((transport) => UPGRADED_PAYLOAD_TRANSPORTS.has(transport));
+    if (configuredPriority.length > 0) {
+        return [...new Set(configuredPriority)];
+    }
+    const preferred = [];
+    if (transports?.webrtc) {
+        preferred.push('webrtc-lan', 'webrtc');
+    }
+    if (transports?.moq) {
+        preferred.push('moq');
+    }
+    return preferred;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function callOptional(target, method) {
+    const candidate = target;
+    const fn = candidate?.[method];
+    if (typeof fn === 'function') {
+        await fn.call(target);
+    }
+}
+function queueTask(callback) {
+    if (typeof globalThis.queueMicrotask === 'function') {
+        globalThis.queueMicrotask(callback);
+        return;
+    }
+    void Promise.resolve().then(callback);
+}