openrtc-netcode 3.0.0 → 3.0.2

package/dist/client.js

@@ -1,16 +1,25 @@
 import { TypedEmitter } from './events.js';
 import { decodeEnvelope, encodeEnvelope, isRecord, NETCODE_PROTOCOL, PROTOCOL_VERSION, } from './protocol.js';
-import { isNetcodeObjectState, ObjectStore } from './objects.js';
+import { isNetcodeObjectState, isObjectRemoval, ObjectStore } from './objects.js';
 import { ReplicatedState } from './state.js';
 import { NetcodeVoiceController } from './voice.js';
 import { runtimeFromRoom } from './roomRuntime.js';
 import { LatestStateQueue } from './latestState.js';
+import { encodeMotion, decodeMotion, encodeJsonMotion, decodeJsonMotion, jsonMotionRecord, motionToBase64, motionFromBase64 } from './codec.js';
+import { canonicalJson, boundedJson, cloneJson, MAX_FRAME_BYTES } from './validation.js';
+import { snapshotPages, SnapshotAssembly } from './snapshots.js';
+import { freezeJson } from './validation.js';
+import { FrameDecoder } from './framing.js';
+import { SimulationClock } from './simulation.js';
+import { ActionRegistry } from './actions.js';
+import { motionChanged } from './motion.js';
+import { ReplicationScheduler } from './replication.js';
 const DEFAULT_MAX_PEERS = 8;
-const NETCODE_CHANNEL_ID = 'openrtc-netcode/v1';
+const NETCODE_CHANNEL_ID = 'openrtc-netcode/v2';
 const PING_INTERVAL_MS = 2000;
 const MAX_SEEN_ENVELOPES = 2048;
+const MOTION_CHANNEL_ID = 'openrtc-netcode/v2/motion';
 const CHANNEL_OPEN_TIMEOUT_MS = 15000;
-const UPGRADED_PAYLOAD_TRANSPORTS = new Set(['webrtc', 'moq']);
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
 class ClientImpl {
@@ -20,11 +29,47 @@ class ClientImpl {
         this.localPeerId = null;
         this.currentLobby = null;
         this.currentRoomId = null;
-        this.fallbackChannel = null;
         this.lobbyMetadata = {};
+        this.lobbyMetadataRevision = 0;
+        this.lobbyMetadataOwner = null;
         this.memberMetadata = {};
+        this.memberMetadataRevision = 1;
+        this.memberMetadataRevisions = new Map();
         this.seq = 0;
         this.started = false;
+        this.starting = null;
+        this.stopping = null;
+        this.lobbyOperation = 0;
+        this.activeLobbyOperation = 0;
+        this.desiredRoomId = null;
+        this.lobbyCleanup = null;
+        this.negotiations = new Map();
+        this.lastMotion = new Map();
+        // One bounded set of allowed IDs per active recipient, retained across
+        // view changes so removals also fence a baseline still in flight.
+        this.exposedObjectIds = new Map();
+        this.snapshotRevisions = new Map();
+        this.snapshotSends = new Map();
+        this.snapshotAssemblies = new Map();
+        this.matchGeneration = 0;
+        this.authorityEpoch = crypto.randomUUID();
+        this.peerAuthorityEpochs = new Map();
+        this.peerHelloSequences = new Map();
+        this.retiredAuthorityEpochs = new Set();
+        this.authorityEpochExhausted = false;
+        this.activeHostEpoch = null;
+        this.sessionId = '';
+        this.memberIds = new Set();
+        this.peerGenerations = new Map();
+        this.peerSessions = new Map();
+        this.retiredSessions = new Set();
+        this.connectionSubscriptions = new Map();
+        this.streamReaders = new Map();
+        this.membership = [];
+        this.actions = new ActionRegistry((peerId, kind, body) => this.sendEnvelope(peerId, kind, body));
+        this.sentViews = new Map();
+        this.receivedViews = new Map();
+        this.encodedEnvelopes = new WeakMap();
         this.stopped = false;
         this.stopWatchingRoom = null;
         this.stopRuntimeConnections = null;
@@ -35,19 +80,154 @@ class ClientImpl {
         this.peersById = new Map();
         this.peerStatsById = new Map();
         this.connectionsByPeer = new Map();
+        this.motionChannelsByPeer = new Map();
+        this.pendingMotionChannelsByPeer = new Map();
+        this.pendingAdmissions = new Map();
         this.channelsByPeer = new Map();
         this.pendingChannelsByPeer = new Map();
         this.connectionIds = new Set();
-        this.directSendWarnings = new Set();
         this.introPeerIds = new Set();
         this.seenEnvelopeIds = new Set();
         this.seenEnvelopeOrder = [];
         this.latestStateQueues = new Map();
-        this.stateStore = new ReplicatedState((options) => this.resolveStateOwner(options), (key, value, owner) => this.broadcastLatestState(`state:${key}`, 'state.patch', { key, value, owner }));
-        this.objectStore = new ObjectStore(() => this.localPeerId, (object) => this.broadcastLatestState(`object:${object.id}`, 'object.upsert', { object }), (id) => this.broadcastEnvelope('object.remove', { id }));
+        this.stateStore = new ReplicatedState((options) => this.resolveStateOwner(options), (key, value, owner, revision) => this.broadcastLatestState(`state:${key}`, 'state.patch', { key, value, owner, revision }), 4096, (owner) => owner === this.localPeerId && this.isLocalMatchActive() && (this.options.authority?.mode !== 'host' || (!this.authorityEpochExhausted && owner === this.currentLobby?.ownerId)), (options) => !this.currentLobby?.ownerId && (this.options.authority?.mode === 'host' || options?.owner === 'lobby-owner'));
+        this.objectStore = new ObjectStore(() => this.localPeerId, (object) => this.publishObject(object), async (removal) => {
+            for (const peerId of this.memberIds) {
+                this.replication.cancel(peerId, removal.id);
+                this.lastMotion.get(peerId)?.delete(removal.id);
+            }
+            await Promise.all([...this.memberIds]
+                .filter((peerId) => this.exposedObjectIds.get(peerId)?.has(removal.id))
+                .map((peerId) => this.sendEnvelope(peerId, 'object.remove', removal)));
+        }, 10000, (kind) => this.objectIncarnation(this.sessionId || 'unjoined', this.authorityEpoch, kind), () => this.clock.tick, (kind) => this.isLocalMatchActive() && (!this.requiresHost(kind) || (!this.authorityEpochExhausted && this.currentLobby?.ownerId === this.localPeerId)));
         this.voiceController = new NetcodeVoiceController(() => this.localPeerId, () => this.peers, (peerId) => this.connectionsByPeer.get(peerId)
             ?? this.runtime?.getConnections().find((connection) => connection.remoteNodeId === peerId || connection.deviceId === peerId)
             ?? null);
+        this.clock = new SimulationClock(options.tickRate);
+        if (options.motionThresholds && Object.values(options.motionThresholds).some((value) => !Number.isFinite(value) || value < 0))
+            throw new Error('Invalid motion thresholds.');
+        this.replication = new ReplicationScheduler(async (peerId, objects) => {
+            const generation = this.matchGeneration, authorityEpoch = this.authorityEpoch;
+            const view = this.sentViews.get(peerId);
+            if (!view || !this.currentRoomId)
+                throw new Error('Replication match retired.');
+            const visible = objects.filter((object) => view.ids.has(object.id));
+            if (!visible.length)
+                return;
+            const body = this.options.codec === 'quantized'
+                ? { packed: motionToBase64(encodeMotion(visible, [...view.ids])), viewRevision: view.revision }
+                : { motion: encodeJsonMotion(visible, [...view.ids]), viewRevision: view.revision };
+            const envelope = this.createEnvelope('object.batch', body, peerId);
+            const encoded = this.encodedEnvelope(envelope);
+            await this.sendDirectEnvelope(peerId, envelope, true);
+            if (generation !== this.matchGeneration || authorityEpoch !== this.authorityEpoch)
+                throw new Error('Replication match retired.');
+            let last = this.lastMotion.get(peerId);
+            if (!last) {
+                last = new Map();
+                this.lastMotion.set(peerId, last);
+            }
+            for (const object of visible)
+                last.set(object.id, { object, time: performance.now() });
+            return textEncoder.encode(encoded).byteLength;
+        }, options.replication);
+    }
+    waitForPeer(peerId, timeoutMs = 15000) {
+        if (!this.memberIds.has(peerId) || peerId === this.localPeerId)
+            return Promise.reject(new Error('Peer is outside the match.'));
+        if (this.peerSessions.has(peerId))
+            return Promise.resolve();
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 1 || timeoutMs > 60000)
+            return Promise.reject(new Error('Invalid peer negotiation timeout.'));
+        const existing = this.negotiations.get(peerId);
+        if (existing)
+            return existing;
+        const generation = this.matchGeneration;
+        const pending = new Promise((resolve, reject) => {
+            const stops = [];
+            const finish = (error) => {
+                clearTimeout(timer);
+                for (const stop of stops)
+                    stop();
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            const timer = setTimeout(() => finish(new Error('Netcode v2 peer negotiation timed out.')), timeoutMs);
+            stops.push(this.emitter.on('envelope', (envelope) => {
+                if (envelope.from === peerId && envelope.kind === 'hello' && this.peerSessions.has(peerId))
+                    finish();
+            }));
+            stops.push(this.emitter.on('protocol:error', (error) => {
+                if (error.peerId === peerId && error.reason === 'incompatible-version')
+                    finish(new Error('Incompatible netcode protocol version.'));
+            }));
+            stops.push(this.emitter.on('lobby', () => {
+                if (generation !== this.matchGeneration)
+                    finish(new Error('Netcode match retired.'));
+            }));
+            stops.push(this.emitter.on('peer:left', (peer) => {
+                if (peer.id === peerId)
+                    finish(new Error('Peer left during negotiation.'));
+            }));
+        }).finally(() => { if (this.negotiations.get(peerId) === pending)
+            this.negotiations.delete(peerId); });
+        this.negotiations.set(peerId, pending);
+        return pending;
+    }
+    handleAction(type, handler) { return this.actions.handle(type, handler); }
+    async request(peerId, type, payload, options) {
+        const generation = this.matchGeneration, authorityEpoch = this.authorityEpoch;
+        const recipientEpoch = this.peerAuthorityEpochs.get(peerId);
+        await this.waitForPeer(peerId);
+        if (authorityEpoch !== this.authorityEpoch || (recipientEpoch && recipientEpoch !== this.peerAuthorityEpochs.get(peerId)))
+            throw new Error('Action authority retired.');
+        if (generation !== this.matchGeneration)
+            throw new Error('Netcode match retired.');
+        return this.actions.request(peerId, type, payload, options);
+    }
+    flushReplication() { this.replication.flush(); }
+    replicationStats(peerId) { return this.replication.diagnostics(peerId); }
+    async refreshInterest() {
+        const sends = [];
+        for (const peerId of this.memberIds) {
+            if (peerId === this.localPeerId)
+                continue;
+            const ids = new Set(this.objectStore.list().filter((object) => object.ownerId === this.localPeerId
+                && (this.options.interest?.(peerId, object) ?? true)).map((object) => object.id));
+            const previous = this.sentViews.get(peerId);
+            if (!previous || ids.size !== previous.ids.size || [...ids].some((id) => !previous.ids.has(id)))
+                sends.push(this.sendObjectSnapshot(peerId));
+        }
+        await Promise.all(sends);
+        this.replication.flush();
+    }
+    async publishObject(object) {
+        const generation = this.matchGeneration, authorityEpoch = this.authorityEpoch;
+        const assertCurrent = () => {
+            if (generation !== this.matchGeneration || authorityEpoch !== this.authorityEpoch)
+                throw new Error('Replication authority retired.');
+        };
+        const sends = Array.from(this.memberIds).filter((peerId) => peerId !== this.localPeerId).map(async (peerId) => {
+            await this.waitForPeer(peerId);
+            assertCurrent();
+            const interested = this.options.interest?.(peerId, object) ?? true;
+            const view = this.sentViews.get(peerId);
+            if (!view || view.ids.has(object.id) !== interested || (interested && view.signatures?.get(object.id) !== this.objectSignature(object))) {
+                await this.sendObjectSnapshot(peerId);
+            }
+            assertCurrent();
+            if (!interested)
+                return;
+            const last = this.lastMotion.get(peerId)?.get(object.id);
+            if (last && this.options.motionThresholds && this.objectSignature(last.object) === this.objectSignature(object)
+                && !motionChanged(last.object, object, performance.now() - last.time, this.options.motionThresholds))
+                return;
+            const bytes = this.options.codec === 'quantized' ? 80 : textEncoder.encode(JSON.stringify(jsonMotionRecord(object, 9999))).byteLength + 32;
+            await this.replication.enqueue(peerId, object.id, object, bytes, this.options.priority?.(peerId, object) ?? 0);
+        });
+        await Promise.all(sends);
     }
     get peerId() {
         return this.localPeerId;
@@ -71,10 +251,28 @@ class ClientImpl {
         return this.voiceController;
     }
     async start() {
-        if (this.started) {
-            return;
+        if (this.stopping) {
+            await this.stopping;
+            return this.start();
         }
-        this.started = true;
+        if (this.starting)
+            return this.starting;
+        if (this.started)
+            return;
+        const opening = this.initialize().catch(async (error) => {
+            this.stopRuntimeConnections?.();
+            this.stopRuntimeConnections = null;
+            this.stopIncomingNetcodeChannel?.();
+            this.stopIncomingNetcodeChannel = null;
+            await this.runtime?.dispose?.();
+            this.runtime = null;
+            this.localPeerId = null;
+            throw error;
+        }).finally(() => { this.starting = null; });
+        this.starting = opening;
+        return opening;
+    }
+    async initialize() {
         this.stopped = false;
         if (!this.options.runtime && !this.options.room) {
             throw new Error('openrtc-netcode requires an activated OpenRTC 2.0 room adapter or an explicit openrtc/runtime client.');
@@ -89,24 +287,30 @@ class ClientImpl {
         this.stopRuntimeConnections = this.runtime.onConnection((connection) => {
             this.attachConnection(connection);
         });
-        for (const connection of this.runtime.getConnections()) {
-            this.attachConnection(connection);
-        }
+        this.started = true;
     }
-    async stop() {
+    stop() {
+        this.lobbyOperation++;
+        this.desiredRoomId = null;
+        if (this.stopping)
+            return this.stopping;
         this.stopped = true;
-        await this.leaveLobby();
+        const closing = Promise.resolve().then(() => this.dispose()).finally(() => { if (this.stopping === closing)
+            this.stopping = null; });
+        this.stopping = closing;
+        return closing;
+    }
+    async dispose() {
+        await this.starting?.catch(() => undefined);
+        this.stopped = true;
+        await this.leaveCurrentLobby();
         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.directSendWarnings.clear();
         this.introPeerIds.clear();
         this.peerStatsById.clear();
         this.seenEnvelopeIds.clear();
@@ -116,110 +320,268 @@ class ClientImpl {
         this.peersById.clear();
         this.objectStore.clear();
         await this.voiceController.stop();
-        this.emitter.clear();
-        this.messageListeners.clear();
+        await this.runtime?.dispose?.();
         this.runtime = null;
+        this.localPeerId = null;
+        this.stateStore.clear();
         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 ?? {}) };
-        // Creating a lobby does not itself imply that an injected runtime has
-        // joined its membership scope. Join through the lifecycle owner before
-        // observing the room so it can establish and project peer routes.
-        await runtime.joinRoom(lobbyId, { bootstrapPeers: false });
-        return this.activateLobby(lobbyId);
+        const operation = this.beginLobbyOperation(null);
+        try {
+            await this.start();
+            this.assertLobbyOperation(operation);
+            await this.leaveCurrentLobby();
+            this.assertLobbyOperation(operation);
+            const runtime = this.requireRuntime();
+            const lobbyId = await runtime.createRoom(options.id);
+            this.assertLobbyOperation(operation, runtime);
+            this.desiredRoomId = normalizeLobbyId(lobbyId);
+            this.lobbyMetadata = { ...(options.metadata ?? {}) };
+            this.lobbyMetadataRevision = 1;
+            return await this.joinAndActivateLobby(runtime, lobbyId, operation);
+        }
+        catch (error) {
+            this.clearFailedLobbyIntent(operation);
+            throw error;
+        }
     }
     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 = {}) {
+        const operation = this.beginLobbyOperation(roomId);
         try {
-            return await this.joinLobby(lobbyId, options);
+            await this.start();
+            this.assertLobbyOperation(operation);
+            await this.leaveCurrentLobby();
+            this.assertLobbyOperation(operation);
+            this.memberMetadata = { ...(options.metadata ?? {}) };
+            return await this.joinAndActivateLobby(this.requireRuntime(), roomId, operation);
         }
         catch (error) {
-            if (!isRoomNotFoundError(error)) {
-                throw error;
-            }
-            const runtime = this.requireRuntime();
-            const roomId = normalizeLobbyId(lobbyId);
+            this.clearFailedLobbyIntent(operation);
+            throw error;
+        }
+    }
+    async joinOrCreateLobby(lobbyId, options = {}) {
+        const roomId = normalizeLobbyId(lobbyId);
+        const operation = this.beginLobbyOperation(roomId);
+        try {
+            await this.start();
+            this.assertLobbyOperation(operation);
+            await this.leaveCurrentLobby();
+            this.assertLobbyOperation(operation);
             this.memberMetadata = { ...(options.metadata ?? {}) };
+            const runtime = this.requireRuntime();
+            try {
+                return await this.joinAndActivateLobby(runtime, roomId, operation);
+            }
+            catch (error) {
+                this.assertLobbyOperation(operation, runtime);
+                if (!isRoomNotFoundError(error))
+                    throw error;
+            }
             try {
                 const createdRoomId = await runtime.createRoom(roomId);
-                return this.activateLobby(createdRoomId);
+                this.assertLobbyOperation(operation, runtime);
+                this.desiredRoomId = normalizeLobbyId(createdRoomId);
+                return await this.joinAndActivateLobby(runtime, createdRoomId, operation);
             }
             catch (createError) {
-                if (!isRoomAlreadyExistsError(createError)) {
+                this.assertLobbyOperation(operation, runtime);
+                if (!isRoomAlreadyExistsError(createError))
                     throw createError;
-                }
             }
-            return this.joinLobbyWithRetry(roomId, options);
+            return await this.joinLobbyWithRetry(runtime, roomId, operation);
+        }
+        catch (error) {
+            this.clearFailedLobbyIntent(operation);
+            throw error;
         }
     }
-    async activateLobby(lobbyId) {
-        const runtime = this.requireRuntime();
+    beginLobbyOperation(roomId) {
+        this.desiredRoomId = roomId;
+        return ++this.lobbyOperation;
+    }
+    assertLobbyOperation(operation, runtime) {
+        if (operation !== this.lobbyOperation || this.stopped || this.stopping || (runtime && runtime !== this.runtime)) {
+            throw new Error('Lobby operation superseded.');
+        }
+    }
+    clearFailedLobbyIntent(operation) {
+        if (operation === this.lobbyOperation)
+            this.desiredRoomId = null;
+    }
+    async joinAndActivateLobby(runtime, lobbyId, operation) {
+        this.assertLobbyOperation(operation, runtime);
+        const roomId = normalizeLobbyId(lobbyId);
+        // The borrowed runtime owns admission. Its API has no cancellation
+        // signal, so a superseded completion releases only its obsolete room.
+        let admissions = this.pendingAdmissions.get(runtime);
+        if (!admissions) {
+            admissions = new Map();
+            this.pendingAdmissions.set(runtime, admissions);
+        }
+        let admission = admissions.get(roomId);
+        if (!admission) {
+            admission = Promise.resolve(runtime.joinRoom(roomId, { bootstrapPeers: false }));
+            admissions.set(roomId, admission);
+            const current = admission;
+            void admission.finally(() => {
+                if (admissions.get(roomId) === current)
+                    admissions.delete(roomId);
+                if (!admissions.size)
+                    this.pendingAdmissions.delete(runtime);
+            }).catch(() => undefined);
+        }
+        await admission;
+        try {
+            this.assertLobbyOperation(operation, runtime);
+            return await this.activateLobby(runtime, roomId, operation);
+        }
+        catch (error) {
+            if (this.activeLobbyOperation === operation) {
+                await this.leaveCurrentLobby();
+            }
+            else if (this.currentRoomId !== roomId && this.desiredRoomId !== roomId) {
+                await runtime.leaveRoom(roomId);
+            }
+            throw error;
+        }
+    }
+    async activateLobby(runtime, lobbyId, operation) {
+        this.assertLobbyOperation(operation, runtime);
         const roomId = normalizeLobbyId(lobbyId);
         this.currentRoomId = roomId;
-        this.openFallbackChannel(roomId);
+        this.activeLobbyOperation = operation;
+        this.sessionId = crypto.randomUUID();
+        this.authorityEpoch = crypto.randomUUID();
+        this.peerAuthorityEpochs.clear();
+        this.peerHelloSequences.clear();
+        this.retiredAuthorityEpochs.clear();
+        this.authorityEpochExhausted = false;
+        this.activeHostEpoch = null;
+        const generation = ++this.matchGeneration;
         this.startPeerPingLoop();
-        this.stopWatchingRoom = runtime.watchRoom(roomId, (members) => {
-            void this.handleRoomMembers(members);
+        let rosterObservations = 0;
+        const stopWatching = runtime.watchRoom(roomId, (members) => {
+            if (operation === this.lobbyOperation && generation === this.matchGeneration && this.currentRoomId === roomId) {
+                rosterObservations++;
+                void this.handleRoomMembers(members);
+            }
         });
-        await this.handleRoomMembers(await this.getRoomMembersWithRetry(roomId));
-        await this.broadcastMemberMetadata();
+        if (operation !== this.lobbyOperation || generation !== this.matchGeneration || this.stopped) {
+            stopWatching();
+            throw new Error('Lobby membership retired.');
+        }
+        this.stopWatchingRoom = stopWatching;
+        const observationAtRead = rosterObservations;
+        const members = await this.getRoomMembersWithRetry(runtime, roomId, operation);
+        this.assertLobbyOperation(operation, runtime);
+        if (generation !== this.matchGeneration || this.currentRoomId !== roomId)
+            throw new Error('Lobby activation superseded.');
+        if (rosterObservations === observationAtRead)
+            await this.handleRoomMembers(members);
+        this.assertLobbyOperation(operation, runtime);
+        if (generation !== this.matchGeneration)
+            throw new Error('Lobby activation superseded.');
+        // Admission precedes route settlement. The existing peer introduction
+        // sends the current metadata after its authenticated hello, including
+        // for routes that become ready after this join returns.
         return this.requireLobby();
     }
-    async joinLobbyWithRetry(lobbyId, options) {
+    async joinLobbyWithRetry(runtime, lobbyId, operation) {
         let lastError;
         for (let attempt = 0; attempt < 6; attempt += 1) {
+            this.assertLobbyOperation(operation, runtime);
             try {
-                return await this.joinLobby(lobbyId, options);
+                return await this.joinAndActivateLobby(runtime, lobbyId, operation);
             }
             catch (error) {
+                this.assertLobbyOperation(operation, runtime);
                 lastError = error;
                 if (!isRoomAdmissionTransientError(error) || attempt === 5) {
                     break;
                 }
                 await delay(150 * (attempt + 1));
+                this.assertLobbyOperation(operation, runtime);
             }
         }
         throw lastError;
     }
-    async getRoomMembersWithRetry(roomId) {
-        const runtime = this.requireRuntime();
+    async getRoomMembersWithRetry(runtime, roomId, operation) {
         let lastError;
         for (let attempt = 0; attempt < 6; attempt += 1) {
+            this.assertLobbyOperation(operation, runtime);
             try {
-                return await runtime.getRoomMembers(roomId);
+                const members = await runtime.getRoomMembers(roomId);
+                this.assertLobbyOperation(operation, runtime);
+                return members;
             }
             catch (error) {
+                this.assertLobbyOperation(operation, runtime);
                 lastError = error;
                 if (!isRoomNotFoundError(error) || attempt === 5) {
                     break;
                 }
                 await delay(150 * (attempt + 1));
+                this.assertLobbyOperation(operation, runtime);
             }
         }
         throw lastError;
     }
     async leaveLobby() {
+        this.beginLobbyOperation(null);
+        await this.leaveCurrentLobby();
+    }
+    leaveCurrentLobby() {
+        if (this.lobbyCleanup)
+            return this.lobbyCleanup;
         const runtime = this.runtime;
         const roomId = this.currentRoomId;
         this.stopWatchingRoom?.();
         this.stopWatchingRoom = null;
         this.currentRoomId = null;
+        this.activeLobbyOperation = 0;
+        this.matchGeneration++;
+        this.actions.clear();
+        this.replication.close();
+        this.lastMotion.clear();
+        this.sentViews.clear();
+        this.exposedObjectIds.clear();
+        this.receivedViews.clear();
+        this.snapshotAssemblies.clear();
+        for (const queue of this.snapshotSends.values())
+            queue.close();
+        this.snapshotSends.clear();
+        this.snapshotRevisions.clear();
+        this.clock.reset();
+        this.memberIds.clear();
+        this.peerSessions.clear();
+        this.peerGenerations.clear();
+        this.memberMetadataRevisions.clear();
+        this.memberMetadataRevision = 1;
+        this.retiredSessions.clear();
+        this.peerAuthorityEpochs.clear();
+        this.peerHelloSequences.clear();
+        this.retiredAuthorityEpochs.clear();
+        this.activeHostEpoch = null;
+        this.membership = [];
+        for (const stops of this.connectionSubscriptions.values())
+            for (const stop of stops)
+                stop();
+        this.connectionSubscriptions.clear();
+        this.connectionsByPeer.clear();
+        this.connectionIds.clear();
+        for (const queue of this.latestStateQueues.values())
+            queue.close();
+        this.latestStateQueues.clear();
+        for (const reader of this.streamReaders.keys())
+            void reader.cancel('Netcode match retired').catch(() => undefined);
+        this.streamReaders.clear();
+        if (roomId)
+            this.stateStore.clear();
         this.stopPeerPingLoop();
-        this.closeFallbackChannel();
-        await this.closeNetcodeChannels();
+        const channelsClosed = this.closeNetcodeChannels();
         this.currentLobby = null;
         this.peersById.clear();
         this.introPeerIds.clear();
@@ -228,19 +590,33 @@ class ClientImpl {
         this.seenEnvelopeOrder.length = 0;
         this.latestStateQueues.clear();
         this.objectStore.clear();
-        await this.voiceController.stop();
-        if (runtime && roomId) {
-            await runtime.leaveRoom(roomId);
-        }
+        const voiceStopped = this.voiceController.stop();
         this.emitter.emit('lobby', null);
+        const closing = (async () => {
+            try {
+                await channelsClosed;
+                await voiceStopped;
+            }
+            finally {
+                if (runtime && roomId)
+                    await runtime.leaveRoom(roomId);
+            }
+        })().finally(() => { if (this.lobbyCleanup === closing)
+            this.lobbyCleanup = null; });
+        this.lobbyCleanup = closing;
+        return closing;
     }
     async send(peerId, type, payload, options = {}) {
         assertReliable(options);
-        await this.sendEnvelope(peerId, 'user', { type, payload });
+        const envelope = this.createEnvelope('user', { type, payload }, peerId);
+        await this.waitForPeer(peerId);
+        await this.sendDirectEnvelope(peerId, envelope);
     }
     async broadcast(type, payload, options = {}) {
         assertReliable(options);
-        await this.broadcastEnvelope('user', { type, payload });
+        const envelope = this.createEnvelope('user', { type, payload });
+        const recipients = [...this.memberIds].filter((peerId) => peerId !== this.localPeerId);
+        await Promise.all(recipients.map(async (peerId) => { await this.waitForPeer(peerId); await this.sendDirectEnvelope(peerId, envelope); }));
     }
     on(event, handler) {
         return this.emitter.on(event, handler);
@@ -253,23 +629,36 @@ class ClientImpl {
         return () => listeners.delete(listener);
     }
     async setLobbyData(key, value) {
+        if (this.currentLobby?.ownerId !== this.localPeerId)
+            throw new Error('Lobby metadata requires host authority.');
         this.lobbyMetadata = { ...this.lobbyMetadata, [key]: value };
+        this.lobbyMetadataRevision++;
         this.refreshLobby();
-        await this.broadcastEnvelope('lobby.meta', { values: this.lobbyMetadata });
+        await this.broadcastEnvelope('lobby.meta', { values: this.lobbyMetadata, revision: this.lobbyMetadataRevision });
     }
     async setMemberData(key, value) {
         this.memberMetadata = { ...this.memberMetadata, [key]: value };
+        this.memberMetadataRevision++;
         await this.broadcastMemberMetadata();
     }
     async handleRoomMembers(members) {
         if (this.stopped || !this.localPeerId || !this.currentRoomId) {
             return;
         }
-        const activeMembers = members.filter(hasActiveMember);
+        const activeMembers = members;
+        if (!members.some((member) => member.nodeId === this.localPeerId)) {
+            await this.leaveLobby();
+            return;
+        }
+        this.membership = [...members];
+        this.memberIds.clear();
+        for (const member of members)
+            if (member.nodeId)
+                this.memberIds.add(member.nodeId);
         const nextPeerIds = new Set();
         for (const member of activeMembers) {
             const peerId = member.nodeId;
-            if (!peerId || peerId === this.localPeerId) {
+            if (!peerId || peerId === this.localPeerId || !this.memberIds.has(peerId)) {
                 continue;
             }
             nextPeerIds.add(peerId);
@@ -290,17 +679,23 @@ class ClientImpl {
             });
             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;
-                }
+                this.retirePeerSession(peerId);
+                this.replication.closePeer(peerId);
+                this.sentViews.delete(peerId);
+                this.receivedViews.delete(peerId);
                 this.peersById.delete(peerId);
+                const connection = this.connectionsByPeer.get(peerId);
+                if (connection) {
+                    for (const stop of this.connectionSubscriptions.get(connection) ?? [])
+                        stop();
+                    this.connectionSubscriptions.delete(connection);
+                    if (connection.id)
+                        this.connectionIds.delete(connection.id);
+                }
                 this.connectionsByPeer.delete(peerId);
                 this.introPeerIds.delete(peerId);
                 this.peerStatsById.delete(peerId);
@@ -309,6 +704,11 @@ class ClientImpl {
             }
         }
         this.refreshLobby(activeMembers);
+        for (const connection of this.runtime?.getConnections() ?? []) {
+            const id = connection.remoteNodeId ?? connection.deviceId;
+            if (id && nextPeerIds.has(id))
+                this.attachConnection(connection);
+        }
         void this.reconcileMesh();
     }
     async reconcileMesh() {
@@ -320,17 +720,27 @@ class ClientImpl {
         return;
     }
     attachConnection(connection, peerIdHint) {
+        if (!this.currentRoomId)
+            return;
         const connectionId = connection.id;
         if (connectionId && this.connectionIds.has(connectionId)) {
             return;
         }
         const peerId = peerIdHint ?? connection.remoteNodeId ?? connection.deviceId;
-        if (!peerId || peerId === this.localPeerId) {
+        if (!peerId || peerId === this.localPeerId || !this.memberIds.has(peerId)) {
             return;
         }
         if (connectionId) {
             this.connectionIds.add(connectionId);
         }
+        const previousConnection = this.connectionsByPeer.get(peerId);
+        if (previousConnection && previousConnection !== connection) {
+            for (const stop of this.connectionSubscriptions.get(previousConnection) ?? [])
+                stop();
+            this.connectionSubscriptions.delete(previousConnection);
+            if (previousConnection.id)
+                this.connectionIds.delete(previousConnection.id);
+        }
         this.connectionsByPeer.set(peerId, connection);
         const payloadReady = this.isPeerPayloadReady(peerId);
         const peer = this.upsertPeer(peerId, { connected: payloadReady });
@@ -342,10 +752,19 @@ class ClientImpl {
             this.emitter.emit('peer:connected', clonePeer(peer));
             this.startVoicePeer(peerId);
         }
-        connection.onMessage((message) => {
-            this.handleConnectionMessage(peerId, message);
+        let active = true;
+        const stops = [() => { active = false; }];
+        const generation = this.matchGeneration;
+        const stopMessages = connection.onMessage((message) => {
+            if (active && generation === this.matchGeneration && this.connectionsByPeer.get(peerId) === connection) {
+                this.handleConnectionMessage(peerId, message);
+            }
         });
-        connection.onDisconnect(() => {
+        if (stopMessages)
+            stops.push(stopMessages);
+        const stopDisconnect = connection.onDisconnect(() => {
+            if (!active || generation !== this.matchGeneration)
+                return;
             const wasCurrentConnection = this.connectionsByPeer.get(peerId) === connection;
             if (wasCurrentConnection) {
                 this.connectionsByPeer.delete(peerId);
@@ -364,11 +783,14 @@ class ClientImpl {
             this.emitter.emit('peer:disconnected', clonePeer(disconnected));
             this.voiceController.handlePeerDisconnected(peerId);
         });
+        if (stopDisconnect)
+            stops.push(stopDisconnect);
+        this.connectionSubscriptions.set(connection, stops);
         if (payloadReady) {
             this.queuePeerIntro(peerId, true);
         }
         if (payloadReady && this.currentRoomId) {
-            void this.sendEnvelope(peerId, 'ping', {});
+            void this.sendEnvelope(peerId, 'ping', {}).catch(() => undefined);
         }
     }
     startVoicePeer(peerId) {
@@ -391,11 +813,15 @@ class ClientImpl {
             await this.sendEnvelope(peerId, 'hello', {
                 peerId: this.localPeerId,
                 displayName: this.options.displayName,
+                version: PROTOCOL_VERSION,
+                authorityEpoch: this.authorityEpoch,
             });
+            await this.waitForPeer(peerId);
             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 });
+            if (this.currentLobby?.ownerId === this.localPeerId)
+                await this.sendEnvelope(peerId, 'lobby.meta', { values: this.lobbyMetadata, revision: this.lobbyMetadataRevision });
+            await this.sendEnvelope(peerId, 'member.meta', { values: this.memberMetadata, revision: this.memberMetadataRevision });
         }
         catch (error) {
             this.introPeerIds.delete(peerId);
@@ -403,35 +829,94 @@ class ClientImpl {
         }
     }
     queuePeerIntro(peerId, force = false) {
+        const generation = this.matchGeneration;
         queueTask(() => {
+            if (generation !== this.matchGeneration)
+                return;
             void this.sendPeerIntro(peerId, force).catch((error) => {
-                if (this.currentRoomId) {
+                if (this.currentRoomId && generation === this.matchGeneration && this.memberIds.has(peerId)) {
                     console.warn('[openrtc-netcode] peer intro failed', error);
                 }
             });
         });
     }
     handleConnectionMessage(peerId, message) {
+        if (!this.currentRoomId || !this.memberIds.has(peerId))
+            return;
+        if (typeof message === 'string' && textEncoder.encode(message).byteLength > MAX_FRAME_BYTES)
+            return;
+        if (!boundedJson(typeof message === 'string' ? safeJson(message) : message, 25000, 28))
+            return;
         const envelope = decodeEnvelope(message);
-        if (!envelope || envelope.lobbyId !== this.currentRoomId) {
+        if (!envelope) {
+            const candidate = typeof message === 'string' ? safeJson(message) : message;
+            if (isRecord(candidate) && candidate.protocol === NETCODE_PROTOCOL && candidate.v !== PROTOCOL_VERSION) {
+                this.emitter.emit('protocol:error', { peerId, reason: 'incompatible-version' });
+            }
+            return;
+        }
+        if (envelope.lobbyId !== this.currentRoomId || envelope.from !== peerId) {
             return;
         }
         if (envelope.from === this.localPeerId) {
             return;
         }
+        if ((envelope.targetSessionId && envelope.targetSessionId !== this.sessionId)
+            || (envelope.kind === 'action' && envelope.targetSessionId !== this.sessionId))
+            return;
+        if (envelope.kind === 'action' && envelope.targetAuthorityEpoch !== this.authorityEpoch)
+            return;
         if (envelope.target && envelope.target !== this.localPeerId) {
             return;
         }
+        if (envelope.kind === 'hello') {
+            if (!isRecord(envelope.body) || envelope.body.version !== PROTOCOL_VERSION) {
+                this.emitter.emit('protocol:error', { peerId, reason: 'incompatible-version' });
+                return;
+            }
+            const epoch = envelope.body.authorityEpoch;
+            if (typeof epoch !== 'string' || !epoch.length || epoch.length > 128
+                || this.retiredAuthorityEpochs.has(JSON.stringify([peerId, epoch])))
+                return;
+            const lastHello = this.peerHelloSequences.get(peerId);
+            if (lastHello?.sessionId === envelope.sessionId && envelope.seq <= lastHello.seq)
+                return;
+            const previousEpoch = this.peerAuthorityEpochs.get(peerId);
+            if (!this.acceptPeerSession(peerId, envelope.sessionId))
+                return;
+            this.peerHelloSequences.set(peerId, { sessionId: envelope.sessionId, seq: envelope.seq });
+            this.peerAuthorityEpochs.set(peerId, epoch);
+            if (peerId === this.currentLobby?.ownerId && !this.authorityEpochExhausted
+                && (this.activeHostEpoch?.epoch !== epoch || this.activeHostEpoch.sessionId !== envelope.sessionId)) {
+                if (previousEpoch && previousEpoch !== epoch)
+                    this.resetHostState(peerId);
+                this.receivedViews.delete(peerId);
+                this.snapshotAssemblies.delete(peerId);
+                this.activeHostEpoch = { peerId, sessionId: envelope.sessionId, epoch, floor: envelope.seq };
+            }
+        }
+        else if (this.peerSessions.get(peerId) !== envelope.sessionId) {
+            // Every application state is preceded by an authenticated hello.
+            return;
+        }
+        const hostState = (this.options.authority?.mode === 'host' || !!this.options.authority?.hostOwnedKinds?.length)
+            && (envelope.kind.startsWith('state.') || envelope.kind.startsWith('object.'));
+        if (envelope.from === this.currentLobby?.ownerId && (hostState || envelope.kind === 'lobby.meta')
+            && (this.authorityEpochExhausted || !this.activeHostEpoch
+                || this.activeHostEpoch.sessionId !== envelope.sessionId || envelope.seq <= this.activeHostEpoch.floor))
+            return;
         if (!this.markEnvelopeSeen(envelope)) {
             return;
         }
-        this.upsertPeer(peerId, { connected: true });
-        this.updatePeerStats(peerId, {
-            connected: true,
-            transport: this.resolvePeerTransport(peerId),
-        });
+        freezeJson(envelope);
         this.emitter.emit('envelope', envelope);
         switch (envelope.kind) {
+            case 'action':
+                void this.actions.receive(peerId, envelope.sessionId, envelope.body).catch(() => undefined);
+                break;
+            case 'action.receipt':
+                this.actions.receiveReceipt(peerId, envelope.body);
+                break;
             case 'hello':
                 this.handleHello(peerId, envelope.body);
                 break;
@@ -439,10 +924,10 @@ class ClientImpl {
                 this.handleUserMessage(envelope);
                 break;
             case 'state.snapshot':
-                this.handleStateSnapshot(envelope.body);
+                this.handleStateSnapshot(peerId, envelope.body);
                 break;
             case 'state.patch':
-                this.handleStatePatch(envelope.body);
+                this.handleStatePatch(peerId, envelope.body);
                 break;
             case 'object.snapshot':
                 this.handleObjectSnapshot(envelope.from, envelope.body);
@@ -450,17 +935,20 @@ class ClientImpl {
             case 'object.upsert':
                 this.handleObjectUpsert(envelope.from, envelope.body);
                 break;
+            case 'object.batch':
+                this.handleObjectBatch(peerId, envelope.body);
+                break;
             case 'object.remove':
                 this.handleObjectRemove(envelope.from, envelope.body);
                 break;
             case 'lobby.meta':
-                this.handleLobbyMetadata(envelope.body);
+                this.handleLobbyMetadata(peerId, envelope.body);
                 break;
             case 'member.meta':
                 this.handleMemberMetadata(peerId, envelope.body);
                 break;
             case 'ping':
-                void this.sendEnvelope(peerId, 'pong', { pingSentAt: envelope.sentAt });
+                void this.sendEnvelope(peerId, 'pong', { pingSentAt: envelope.sentAt }).catch(() => undefined);
                 break;
             case 'peer':
                 break;
@@ -469,8 +957,66 @@ class ClientImpl {
                 break;
         }
     }
+    retirePeerSession(peerId) {
+        this.peerGenerations.set(peerId, (this.peerGenerations.get(peerId) ?? 0) + 1);
+        for (const channels of [this.channelsByPeer, this.motionChannelsByPeer]) {
+            const channel = channels.get(peerId);
+            channels.delete(peerId);
+            if (channel)
+                void channel.close().catch(() => undefined);
+        }
+        this.pendingChannelsByPeer.delete(peerId);
+        this.pendingMotionChannelsByPeer.delete(peerId);
+        for (const [reader, owner] of this.streamReaders)
+            if (owner === peerId) {
+                void reader.cancel('Netcode peer retired.').catch(() => undefined);
+                this.streamReaders.delete(reader);
+            }
+        const previous = this.peerSessions.get(peerId);
+        if (previous)
+            this.retiredSessions.add(JSON.stringify([peerId, previous]));
+        this.peerSessions.delete(peerId);
+        this.peerAuthorityEpochs.delete(peerId);
+        this.peerHelloSequences.delete(peerId);
+        if (this.activeHostEpoch?.peerId === peerId)
+            this.activeHostEpoch = null;
+        this.actions.removePeer(peerId);
+        for (const [key, queue] of this.latestStateQueues) {
+            if (JSON.parse(key)[0] !== peerId)
+                continue;
+            queue.close(new Error('Netcode recipient session retired.'));
+            this.latestStateQueues.delete(key);
+        }
+        this.lastMotion.delete(peerId);
+        this.memberMetadataRevisions.delete(peerId);
+        this.stateStore.removeOwner(peerId);
+        this.objectStore.removeOwner(peerId);
+        this.receivedViews.delete(peerId);
+        this.snapshotAssemblies.delete(peerId);
+        this.sentViews.delete(peerId);
+        this.exposedObjectIds.delete(peerId);
+        this.snapshotSends.get(peerId)?.close();
+        this.snapshotSends.delete(peerId);
+        this.snapshotRevisions.delete(peerId);
+        this.introPeerIds.delete(peerId);
+        this.replication.closePeer(peerId);
+    }
+    acceptPeerSession(peerId, sessionId) {
+        if (this.retiredSessions.has(JSON.stringify([peerId, sessionId])))
+            return false;
+        const previous = this.peerSessions.get(peerId);
+        if (previous && previous !== sessionId) {
+            if (this.retiredSessions.size >= 4096) {
+                this.emitter.emit('protocol:error', { peerId, reason: 'session-capacity' });
+                return false;
+            }
+            this.retirePeerSession(peerId);
+        }
+        this.peerSessions.set(peerId, sessionId);
+        return true;
+    }
     markEnvelopeSeen(envelope) {
-        const id = `${envelope.from}:${envelope.seq}`;
+        const id = JSON.stringify([envelope.from, envelope.sessionId, envelope.seq]);
         if (this.seenEnvelopeIds.has(id)) {
             return false;
         }
@@ -488,6 +1034,10 @@ class ClientImpl {
         if (!isRecord(body)) {
             return;
         }
+        if (body.version !== PROTOCOL_VERSION) {
+            this.emitter.emit('protocol:error', { peerId, reason: 'incompatible-version' });
+            return;
+        }
         const displayName = typeof body.displayName === 'string' ? body.displayName : undefined;
         this.upsertPeer(peerId, {
             connected: true,
@@ -512,18 +1062,24 @@ class ClientImpl {
             listener(message);
         }
     }
-    handleStateSnapshot(body) {
-        if (!isRecord(body) || !isRecord(body.values) || !isRecord(body.owners)) {
+    handleStateSnapshot(from, body) {
+        if (this.options.authority?.mode === 'host' && from !== this.currentLobby?.ownerId)
+            return;
+        if (!isRecord(body) || !isRecord(body.values) || !isRecord(body.owners) || !isRecord(body.revisions)) {
             return;
         }
         const snapshot = {
             values: body.values,
             owners: stringifyRecord(body.owners),
+            revisions: body.revisions,
         };
-        this.stateStore.applySnapshot(snapshot.values, snapshot.owners);
-        this.emitter.emit('state:snapshot', snapshot);
+        const accepted = this.stateStore.applySnapshot(snapshot.values, snapshot.owners, snapshot.revisions, from);
+        if (Object.keys(accepted.values).length)
+            this.emitter.emit('state:snapshot', accepted);
     }
-    handleStatePatch(body) {
+    handleStatePatch(from, body) {
+        if (this.options.authority?.mode === 'host' && from !== this.currentLobby?.ownerId)
+            return;
         if (!isRecord(body) || typeof body.key !== 'string' || typeof body.owner !== 'string') {
             return;
         }
@@ -531,45 +1087,121 @@ class ClientImpl {
             key: body.key,
             value: body.value,
             owner: body.owner,
+            revision: body.revision,
         };
-        this.stateStore.applyPatch(patch.key, patch.value, patch.owner);
-        this.emitter.emit('state:patch', patch);
+        if (this.stateStore.applyPatch(patch.key, patch.value, patch.owner, patch.revision, from)) {
+            this.emitter.emit('state:patch', patch);
+        }
     }
     handleObjectSnapshot(from, body) {
-        if (!isRecord(body) || !isRecord(body.objects)) {
+        if (this.options.authority?.mode === 'host' && from !== this.currentLobby?.ownerId)
+            return;
+        if (!isRecord(body) || !isRecord(body.objects))
             return;
+        let assembly = this.snapshotAssemblies.get(from);
+        if (!assembly) {
+            assembly = new SnapshotAssembly();
+            this.snapshotAssemblies.set(from, assembly);
         }
-        const objects = {};
+        const complete = assembly.push(body);
+        if (!complete)
+            return;
+        body = complete;
+        if (!isRecord(body) || !isRecord(body.objects))
+            return;
+        const objects = Object.create(null);
         for (const [id, object] of Object.entries(body.objects)) {
-            if (isNetcodeObjectState(object)) {
+            if (isNetcodeObjectState(object) && object.incarnation === this.objectIncarnation(this.peerSessions.get(from), this.peerAuthorityEpochs.get(from), object.kind) && object.ownerId === from && (!this.requiresHost(object.kind) || from === this.currentLobby?.ownerId)) {
                 objects[id] = object;
             }
         }
-        const snapshot = { objects };
-        this.objectStore.applySnapshot(objects, from);
-        this.emitter.emit('object:snapshot', snapshot);
+        const removed = Object.create(null);
+        if (isRecord(body.removed)) {
+            for (const [id, removal] of Object.entries(body.removed)) {
+                if (isObjectRemoval(removal))
+                    removed[id] = removal;
+            }
+        }
+        const revision = body.viewRevision;
+        const previous = this.receivedViews.get(from);
+        if (typeof revision !== 'number' || !Number.isSafeInteger(revision) || revision < 1 || (previous && previous.revision >= revision))
+            return;
+        const ids = new Set(Object.keys(objects));
+        this.receivedViews.set(from, { revision, ids, definitions: Object.values(objects) });
+        this.objectStore.pruneOwner(from, ids);
+        const snapshot = this.objectStore.applySnapshot(objects, from, removed);
+        if (Object.keys(snapshot.objects).length || Object.keys(snapshot.removed).length) {
+            this.emitter.emit('object:snapshot', snapshot);
+        }
+    }
+    handleObjectBatch(from, body) {
+        if (!isRecord(body))
+            return;
+        const view = this.receivedViews.get(from);
+        if (!view || body.viewRevision !== view.revision)
+            return;
+        let objects;
+        if (typeof body.packed === 'string') {
+            const definitions = view.definitions;
+            try {
+                objects = decodeMotion(motionFromBase64(body.packed), definitions);
+            }
+            catch {
+                return;
+            }
+        }
+        else if (Array.isArray(body.motion)) {
+            try {
+                objects = decodeJsonMotion(body.motion, view.definitions);
+            }
+            catch {
+                return;
+            }
+        }
+        else {
+            if (!Array.isArray(body.objects) || body.objects.length > 1024)
+                return;
+            objects = body.objects;
+        }
+        for (const object of objects)
+            this.handleObjectUpsert(from, { object });
     }
     handleObjectUpsert(from, body) {
         if (!isRecord(body) || !isNetcodeObjectState(body.object)) {
             return;
         }
+        if (body.object.incarnation !== this.objectIncarnation(this.peerSessions.get(from), this.peerAuthorityEpochs.get(from), body.object.kind) || !this.receivedViews.get(from)?.ids.has(body.object.id))
+            return;
+        if (this.requiresHost(body.object.kind) && from !== this.currentLobby?.ownerId)
+            return;
         const upsert = { object: body.object };
-        this.objectStore.applyUpsert(body.object, from);
-        this.emitter.emit('object:upsert', upsert);
+        if (this.objectStore.applyUpsert(body.object, from)) {
+            this.emitter.emit('object:upsert', upsert);
+        }
     }
     handleObjectRemove(from, body) {
-        if (!isRecord(body) || typeof body.id !== 'string') {
+        if (!isObjectRemoval(body)) {
+            return;
+        }
+        if (this.options.authority?.mode === 'host' && from !== this.currentLobby?.ownerId)
             return;
+        if (this.objectStore.applyRemove(body.id, from, body)) {
+            this.emitter.emit('object:remove', body);
         }
-        const remove = { id: body.id };
-        this.objectStore.applyRemove(remove.id, from);
-        this.emitter.emit('object:remove', remove);
     }
-    handleLobbyMetadata(body) {
+    handleLobbyMetadata(from, body) {
+        if (from !== this.currentLobby?.ownerId)
+            return;
         if (!isRecord(body) || !isRecord(body.values)) {
             return;
         }
+        const revision = body.revision;
+        if (typeof revision !== 'number' || !Number.isSafeInteger(revision) || revision < 1
+            || (this.lobbyMetadataOwner === from && revision <= this.lobbyMetadataRevision))
+            return;
         const metadata = { values: stringifyRecord(body.values) };
+        this.lobbyMetadataOwner = from;
+        this.lobbyMetadataRevision = revision;
         this.lobbyMetadata = metadata.values;
         this.refreshLobby();
         this.emitter.emit('lobby:metadata', metadata);
@@ -578,7 +1210,14 @@ class ClientImpl {
         if (!isRecord(body) || !isRecord(body.values)) {
             return;
         }
+        const revision = body.revision;
+        if (typeof revision !== 'number' || !Number.isSafeInteger(revision) || revision < 1 || revision <= (this.memberMetadataRevisions.get(peerId) ?? 0))
+            return;
+        this.memberMetadataRevisions.set(peerId, revision);
         const metadata = { values: stringifyRecord(body.values) };
+        const peer = this.peersById.get(peerId);
+        if (peer)
+            peer.metadata = {};
         this.upsertPeer(peerId, { metadata: metadata.values });
         this.emitter.emit('member:metadata', { peerId, values: metadata.values });
     }
@@ -594,18 +1233,82 @@ class ClientImpl {
         });
     }
     async sendStateSnapshot(peerId) {
-        await this.sendEnvelope(peerId, 'state.snapshot', {
-            values: this.stateStore.snapshot(),
-            owners: this.stateStore.owners(),
-        });
+        const generation = this.matchGeneration, authorityEpoch = this.authorityEpoch;
+        const values = this.stateStore.snapshot(), owners = this.stateStore.owners(), revisions = this.stateStore.revisions();
+        let page = { values: Object.create(null), owners: Object.create(null), revisions: Object.create(null) };
+        let size = 0, count = 0;
+        const send = async () => {
+            if (generation !== this.matchGeneration || authorityEpoch !== this.authorityEpoch)
+                throw new Error('State snapshot match retired.');
+            await this.sendEnvelope(peerId, 'state.snapshot', page);
+            page = { values: Object.create(null), owners: Object.create(null), revisions: Object.create(null) };
+            size = count = 0;
+        };
+        for (const [key, value] of Object.entries(values)) {
+            if (owners[key] !== this.localPeerId || revisions[key] < 1)
+                continue;
+            const bytes = textEncoder.encode(JSON.stringify([key, value, owners[key], revisions[key]])).byteLength;
+            if (count && (size + bytes > 24 * 1024 || count >= 128))
+                await send();
+            page.values[key] = value;
+            page.owners[key] = owners[key];
+            page.revisions[key] = revisions[key];
+            size += bytes;
+            count++;
+        }
+        if (count)
+            await send();
+    }
+    sendObjectSnapshot(peerId) {
+        let queue = this.snapshotSends.get(peerId);
+        if (!queue) {
+            const generation = this.matchGeneration, session = this.peerSessions.get(peerId), authorityEpoch = this.authorityEpoch;
+            queue = new LatestStateQueue(async () => {
+                if (generation !== this.matchGeneration || session !== this.peerSessions.get(peerId) || authorityEpoch !== this.authorityEpoch)
+                    throw new Error('Snapshot match retired.');
+                const objects = Object.fromEntries(Object.entries(this.objectStore.snapshot())
+                    .filter(([, object]) => object.ownerId === this.localPeerId && (this.options.interest?.(peerId, object) ?? true)));
+                const revision = (this.snapshotRevisions.get(peerId) ?? 0) + 1;
+                this.snapshotRevisions.set(peerId, revision);
+                let exposed = this.exposedObjectIds.get(peerId);
+                if (!exposed) {
+                    exposed = new Set();
+                    this.exposedObjectIds.set(peerId, exposed);
+                }
+                // Record before the first await: deletion may race page delivery.
+                for (const id of Object.keys(objects))
+                    exposed.add(id);
+                const pages = snapshotPages({ objects, viewRevision: revision,
+                    removed: Object.fromEntries(Object.entries(this.objectStore.removalSnapshot())
+                        .filter(([id, removal]) => removal.ownerId === this.localPeerId && exposed.has(id))),
+                });
+                for (const page of pages) {
+                    if (generation !== this.matchGeneration || session !== this.peerSessions.get(peerId) || authorityEpoch !== this.authorityEpoch)
+                        throw new Error('Snapshot match retired.');
+                    await this.sendEnvelope(peerId, 'object.snapshot', page);
+                }
+                if (generation !== this.matchGeneration || session !== this.peerSessions.get(peerId) || authorityEpoch !== this.authorityEpoch)
+                    throw new Error('Snapshot match retired.');
+                this.sentViews.set(peerId, { revision, ids: new Set(Object.keys(objects)),
+                    signatures: new Map(Object.values(objects).map((object) => [object.id, this.objectSignature(object)])),
+                });
+            });
+            this.snapshotSends.set(peerId, queue);
+        }
+        return queue.push(undefined);
     }
-    async sendObjectSnapshot(peerId) {
-        await this.sendEnvelope(peerId, 'object.snapshot', {
-            objects: this.objectStore.snapshot(),
-        });
+    isLocalMatchActive() {
+        return !!this.currentRoomId && !!this.localPeerId && this.memberIds.has(this.localPeerId)
+            && (this.runtime?.isRoomActive?.(this.currentRoomId) ?? true);
+    }
+    requiresHost(kind) {
+        return this.options.authority?.mode === 'host' || !!(kind && this.options.authority?.hostOwnedKinds?.includes(kind));
+    }
+    objectSignature(object) {
+        return canonicalJson([object.kind, object.metadata ?? {}, object.transform.scale ?? null]);
     }
     async broadcastMemberMetadata() {
-        await this.broadcastEnvelope('member.meta', { values: this.memberMetadata });
+        await this.broadcastEnvelope('member.meta', { values: this.memberMetadata, revision: this.memberMetadataRevision });
     }
     startPeerPingLoop() {
         this.stopPeerPingLoop();
@@ -616,7 +1319,7 @@ class ClientImpl {
             for (const peer of this.peersById.values()) {
                 const payloadReady = this.refreshPeerPayloadState(peer.id);
                 if (payloadReady) {
-                    void this.sendEnvelope(peer.id, 'ping', {});
+                    void this.sendEnvelope(peer.id, 'ping', {}).catch(() => undefined);
                 }
             }
         }, PING_INTERVAL_MS);
@@ -644,90 +1347,53 @@ class ClientImpl {
     }
     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));
+        const sends = Array.from(this.memberIds).filter((peerId) => peerId !== this.localPeerId)
+            .map((peerId) => this.sendDirectEnvelope(peerId, envelope));
         await Promise.all(sends);
     }
     broadcastLatestState(key, kind, body) {
-        let queue = this.latestStateQueues.get(key);
-        if (!queue) {
-            queue = new LatestStateQueue((state) => this.broadcastEnvelope(state.kind, state.body));
-            this.latestStateQueues.set(key, queue);
-        }
-        return queue.push({ kind, body });
+        const envelope = this.createEnvelope(kind, body);
+        return Promise.all([...this.memberIds].filter((peerId) => peerId !== this.localPeerId).map((peerId) => {
+            const queueKey = JSON.stringify([peerId, key]);
+            let queue = this.latestStateQueues.get(queueKey);
+            if (!queue) {
+                queue = new LatestStateQueue((state) => this.sendDirectEnvelope(peerId, state));
+                this.latestStateQueues.set(queueKey, queue);
+            }
+            return queue.push(envelope);
+        })).then(() => undefined);
     }
     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);
+    async sendDirectEnvelope(peerId, envelope, motion = false) {
+        if (!this.isLocalMatchActive() || !this.memberIds.has(peerId) || envelope.lobbyId !== this.currentRoomId || envelope.sessionId !== this.sessionId) {
+            throw new Error('Netcode recipient is outside the current match.');
+        }
+        const generation = this.matchGeneration;
+        const channel = await this.resolveNetcodeChannel(peerId, motion);
+        if (generation !== this.matchGeneration || !this.memberIds.has(peerId) || !this.isLocalMatchActive())
+            throw new Error('Netcode match retired.');
         if (channel) {
-            await channel.send(textEncoder.encode(encodeEnvelope(envelope)));
+            await channel.send(textEncoder.encode(this.encodedEnvelope(envelope)));
             return;
         }
         const connection = this.resolvePayloadConnection(peerId);
         if (!connection || connection.isClosed) {
-            return;
+            throw new Error('Netcode recipient has no application-ready route.');
         }
-        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;
+        await connection.send(this.encodedEnvelope(envelope));
     }
-    closeFallbackChannel() {
-        this.fallbackChannel?.close();
-        this.fallbackChannel = null;
-    }
-    async resolveNetcodeChannel(peerId) {
-        const existing = this.channelsByPeer.get(peerId);
+    async resolveNetcodeChannel(peerId, motion = false) {
+        const channels = motion ? this.motionChannelsByPeer : this.channelsByPeer;
+        const pendingChannels = motion ? this.pendingMotionChannelsByPeer : this.pendingChannelsByPeer;
+        const channelId = motion ? MOTION_CHANNEL_ID : NETCODE_CHANNEL_ID;
+        const existing = channels.get(peerId);
         if (existing) {
             return existing;
         }
-        const pending = this.pendingChannelsByPeer.get(peerId);
+        const pending = pendingChannels.get(peerId);
         if (pending) {
             return pending;
         }
@@ -735,57 +1401,41 @@ class ClientImpl {
         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,
-            framing: 'u32be',
-        }).then((channel) => {
-            this.attachNetcodeChannel(peerId, channel);
+        const generation = this.matchGeneration;
+        const peerGeneration = this.peerGenerations.get(peerId) ?? 0;
+        const opening = Promise.resolve().then(() => {
+            if (generation !== this.matchGeneration)
+                return null;
+            return runtime.connectScopedChannel({
+                peerId, scope: channelId, channelId, existingRouteOnly: true,
+                timeoutMs: CHANNEL_OPEN_TIMEOUT_MS, framing: 'u32be',
+                maxFrameBytes: MAX_FRAME_BYTES, frameTimeoutMs: 10000,
+            });
+        }).then(async (channel) => {
+            if (!channel)
+                return null;
+            if (generation !== this.matchGeneration || peerGeneration !== (this.peerGenerations.get(peerId) ?? 0) || !this.memberIds.has(peerId)) {
+                await channel.close();
+                return null;
+            }
+            this.attachNetcodeChannel(peerId, channel, motion);
             return channel;
         }).catch(() => null).finally(() => {
-            this.pendingChannelsByPeer.delete(peerId);
+            if (pendingChannels.get(peerId) === opening)
+                pendingChannels.delete(peerId);
         });
-        this.pendingChannelsByPeer.set(peerId, opening);
+        pendingChannels.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);
+    attachNetcodeChannel(peerId, channel, motion = false) {
+        (motion ? this.motionChannelsByPeer : this.channelsByPeer).set(peerId, channel);
+        const generation = this.matchGeneration;
         channel.onMessage((payload) => {
-            this.handleConnectionMessage(peerId, textDecoder.decode(payload));
+            if (generation === this.matchGeneration)
+                this.handleConnectionMessage(peerId, textDecoder.decode(payload));
         });
+        if (motion)
+            return;
         const peer = this.upsertPeer(peerId, { connected: true });
         this.updatePeerStats(peerId, {
             connected: true,
@@ -801,56 +1451,96 @@ class ClientImpl {
             return;
         }
         this.stopIncomingNetcodeChannel?.();
-        this.stopIncomingNetcodeChannel = runtime.onChannelStream(NETCODE_CHANNEL_ID, (incoming) => {
+        const stops = [NETCODE_CHANNEL_ID, MOTION_CHANNEL_ID].map((channelId) => runtime.onChannelStream(channelId, (incoming) => {
             if (incoming.type !== 'bi' || !incoming.remoteNodeId || !incoming.stream) {
                 return false;
             }
             this.readIncomingNetcodeStream(incoming.remoteNodeId, incoming.stream);
             return true;
-        });
+        }));
+        this.stopIncomingNetcodeChannel = () => { for (const stop of stops)
+            stop(); };
     }
     readIncomingNetcodeStream(peerId, stream) {
         const readable = stream.recv ?? stream.readable;
-        if (!readable) {
+        if (!readable || !this.memberIds.has(peerId) || this.streamReaders.size >= 32) {
+            void readable?.cancel('Netcode stream admission rejected.').catch(() => undefined);
+            void (stream.send ?? stream.writable)?.abort('Netcode stream admission rejected.').catch(() => undefined);
             return;
         }
+        const generation = this.matchGeneration;
+        const reader = readable.getReader();
+        this.streamReaders.set(reader, peerId);
         void (async () => {
-            const reader = readable.getReader();
-            let buffered = new Uint8Array(0);
+            const decoder = new FrameDecoder();
+            let incompleteSince = performance.now();
             try {
-                while (!this.stopped) {
-                    const { value, done } = await reader.read();
-                    if (done) {
-                        break;
+                while (!this.stopped && generation === this.matchGeneration) {
+                    let timer;
+                    let result;
+                    try {
+                        if (decoder.incomplete) {
+                            const remaining = Math.max(1, 15000 - (performance.now() - incompleteSince));
+                            const timeout = new Promise((_, reject) => {
+                                timer = setTimeout(() => reject(new Error('Netcode frame read timed out.')), remaining);
+                            });
+                            result = await Promise.race([reader.read(), timeout]);
+                        }
+                        else
+                            result = await reader.read();
                     }
-                    if (!value?.byteLength) {
-                        continue;
+                    finally {
+                        clearTimeout(timer);
                     }
-                    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));
+                    if (result.done) {
+                        if (decoder.incomplete)
+                            throw new Error('Truncated netcode frame.');
+                        break;
                     }
+                    if (generation !== this.matchGeneration)
+                        break;
+                    const wasIncomplete = decoder.incomplete;
+                    let completed = false;
+                    decoder.feed(result.value, (payload) => { completed = true; this.handleConnectionMessage(peerId, textDecoder.decode(payload)); });
+                    if (!wasIncomplete || completed)
+                        incompleteSince = performance.now();
+                    if (!decoder.incomplete)
+                        incompleteSince = performance.now();
                 }
             }
+            catch (error) {
+                if (generation === this.matchGeneration)
+                    this.emitter.emit('protocol:error', {
+                        peerId, reason: error instanceof Error ? error.message : String(error),
+                    });
+            }
             finally {
+                await reader.cancel('Netcode reader retired').catch(() => undefined);
                 reader.releaseLock();
+                this.streamReaders.delete(reader);
             }
-        })();
+        })().catch(() => undefined);
     }
     async closeNetcodeChannels() {
-        const channels = Array.from(this.channelsByPeer.values());
+        const channels = [...this.channelsByPeer.values(), ...this.motionChannelsByPeer.values()];
+        this.motionChannelsByPeer.clear();
+        this.pendingMotionChannelsByPeer.clear();
         this.channelsByPeer.clear();
         this.pendingChannelsByPeer.clear();
         await Promise.allSettled(channels.map((channel) => channel.close()));
     }
+    encodedEnvelope(envelope) {
+        let encoded = this.encodedEnvelopes.get(envelope);
+        if (!encoded) {
+            encoded = encodeEnvelope(envelope);
+            if (!boundedJson(envelope, 25000, 28) || textEncoder.encode(encoded).byteLength > MAX_FRAME_BYTES)
+                throw new Error('Netcode frame exceeds byte limit.');
+            this.encodedEnvelopes.set(envelope, encoded);
+        }
+        return encoded;
+    }
     createEnvelope(kind, body, target) {
-        if (!this.currentRoomId || !this.localPeerId) {
+        if (!this.isLocalMatchActive() || !this.currentRoomId || !this.localPeerId) {
             throw new Error('openrtc-netcode requires a joined lobby before sending.');
         }
         return {
@@ -861,11 +1551,17 @@ class ClientImpl {
             from: this.localPeerId,
             seq: ++this.seq,
             sentAt: Date.now(),
+            sessionId: this.sessionId,
             target,
-            body,
+            targetSessionId: target && kind !== 'hello' ? this.peerSessions.get(target) : undefined,
+            targetAuthorityEpoch: target && kind === 'action' ? this.peerAuthorityEpochs.get(target) : undefined,
+            body: freezeJson(cloneJson(body, MAX_FRAME_BYTES - 2048, 25000, 28)),
         };
     }
     resolveStateOwner(options) {
+        if (this.options.authority?.mode === 'host') {
+            return this.currentLobby?.ownerId ?? this.options.authority.hostId ?? this.localPeerId ?? 'local';
+        }
         if (options?.owner === 'lobby-owner') {
             return this.currentLobby?.ownerId ?? this.localPeerId ?? 'local';
         }
@@ -951,11 +1647,81 @@ class ClientImpl {
             allowFallback: true,
         };
     }
+    objectIncarnation(sessionId, epoch, kind) {
+        return this.requiresHost(kind) ? (sessionId && epoch ? `${sessionId}:${epoch}` : undefined) : sessionId;
+    }
+    resetHostState(peerId) {
+        if (this.options.authority?.mode === 'host') {
+            this.stateStore.removeOwner(peerId);
+            this.objectStore.removeOwner(peerId);
+        }
+        else if (this.options.authority?.hostOwnedKinds?.length) {
+            this.objectStore.removeOwner(peerId, new Set(this.options.authority.hostOwnedKinds));
+        }
+    }
     refreshLobby(members) {
         if (!this.currentRoomId || !this.localPeerId) {
             return;
         }
-        const ownerId = resolveOwnerId(members, this.localPeerId);
+        const ownerId = this.options.authority?.hostId ?? resolveOwnerId(members ?? this.membership, this.localPeerId);
+        const previousHost = this.currentLobby?.ownerId;
+        if (!previousHost)
+            this.stateStore.bindInitialHost(ownerId, this.localPeerId);
+        if (previousHost && previousHost !== ownerId) {
+            const previousEpoch = previousHost === this.localPeerId ? this.authorityEpoch : this.peerAuthorityEpochs.get(previousHost);
+            if (previousEpoch) {
+                if (this.retiredAuthorityEpochs.size >= 4096) {
+                    this.authorityEpochExhausted = true;
+                    this.emitter.emit('protocol:error', { peerId: previousHost, reason: 'authority-capacity' });
+                }
+                else
+                    this.retiredAuthorityEpochs.add(JSON.stringify([previousHost, previousEpoch]));
+            }
+            // The authenticated hello and membership projections can arrive in
+            // either order. Reuse an already observed, non-retired host period.
+            const hostHello = this.peerHelloSequences.get(ownerId);
+            const hostEpoch = this.peerAuthorityEpochs.get(ownerId);
+            this.activeHostEpoch = hostHello && hostEpoch
+                && !this.retiredAuthorityEpochs.has(JSON.stringify([ownerId, hostEpoch]))
+                ? { peerId: ownerId, sessionId: hostHello.sessionId, epoch: hostEpoch, floor: hostHello.seq }
+                : null;
+            this.resetHostState(previousHost);
+            this.actions.removePeer(previousHost, { preserveReceipts: true });
+            if (previousHost === this.localPeerId || ownerId === this.localPeerId) {
+                // The match/session and physical routes remain owned by their
+                // existing owners. Only this sender's game-authority period changes.
+                this.authorityEpoch = crypto.randomUUID();
+                this.actions.clear({ preserveOutgoing: true });
+                this.replication.close();
+                this.lastMotion.clear();
+                for (const queue of this.latestStateQueues.values())
+                    queue.close(new Error('Host authority reset.'));
+                this.latestStateQueues.clear();
+                for (const queue of this.snapshotSends.values())
+                    queue.close();
+                this.snapshotSends.clear();
+                this.sentViews.clear();
+                for (const exposed of this.exposedObjectIds.values()) {
+                    for (const id of exposed)
+                        if (!this.objectStore.read(id))
+                            exposed.delete(id);
+                }
+            }
+            for (const peerId of this.memberIds)
+                if (peerId !== this.localPeerId)
+                    this.queuePeerIntro(peerId, true);
+            for (const [peerId, view] of this.sentViews) {
+                for (const id of [...view.ids])
+                    if (!this.objectStore.read(id)) {
+                        this.replication.cancel(peerId, id);
+                        this.lastMotion.get(peerId)?.delete(id);
+                    }
+            }
+        }
+        if (this.lobbyMetadataOwner !== ownerId) {
+            this.lobbyMetadataOwner = ownerId;
+            this.lobbyMetadataRevision = this.localPeerId === ownerId ? Math.max(1, this.lobbyMetadataRevision) : 0;
+        }
         this.currentLobby = {
             id: this.currentRoomId,
             localPeerId: this.localPeerId,
@@ -986,15 +1752,17 @@ class ClientImpl {
     }
     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.',
-        });
+        for (const [id, delivery] of [[NETCODE_CHANNEL_ID, 'reliable'], [MOTION_CHANNEL_ID, 'latest-state']])
+            maybeChannelClient.channels?.register({
+                id,
+                kind: 'sync',
+                ownership: 'shared',
+                peerModel: 'node-first',
+                routing: 'stream-envelope',
+                readiness: 'settled-peer',
+                delivery,
+                description: 'OpenRTC netcode V2 reliable control, actions and state snapshots.',
+            });
     }
 }
 export function createNetcode(options = {}) {
@@ -1003,20 +1771,11 @@ export function createNetcode(options = {}) {
 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 ?? [])
+    const candidates = [...(members ?? []), { nodeId: fallback }]
         .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 left.nodeId < right.nodeId ? -1 : left.nodeId > right.nodeId ? 1 : 0;
     });
     return candidates[0]?.nodeId ?? fallback;
 }
@@ -1064,18 +1823,6 @@ function cloneLobby(lobby) {
         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.');
@@ -1111,3 +1858,11 @@ function queueTask(callback) {
     }
     void Promise.resolve().then(callback);
 }
+function safeJson(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}