@magicworks/client-party-game 0.1.0-rc.5 → 0.1.0-rc.7

package/dist/client.js

@@ -1,14 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PartyGameClient = void 0;
+const connection_1 = require("./connection");
 const protocol_1 = require("./protocol");
+/**
+ * The global fetch, looked up when called. Called as a plain function, as
+ * browsers insist, and without `globalThis`, which the app's oldest web
+ * engine (Chrome 56) does not have.
+ */
+const globalFetch = url => typeof fetch === 'function'
+    ? fetch(url)
+    : Promise.reject(new Error('no fetch: pass one to PartyGameClient'));
 const defaultAckTimeoutMs = 8000;
+const defaultPlacementTimeoutMs = 4000;
 const defaultClockSyncIntervalMs = 60 * 1000;
-const defaultRegionFallbackMs = 12 * 1000;
-const defaultRegionDownMs = 5 * 60 * 1000;
+/**
+ * A server that has gone keeps its TVs waiting no more than about 15s for a
+ * new room, and one that stalls for a few seconds keeps them: a TV that gives
+ * up on its room mid-game leaves its phones behind in it.
+ */
+const defaultRoomRetryMs = [1000, 3000, 5000, 10000, 15000];
 const clockSyncSamples = 5;
-/** Servers that can be on their way out at once, during a deploy. */
-const maxDrainingRetries = 3;
 /** Hops a room can have made between servers since we last knew its code. */
 const maxRedirects = 3;
 /**
@@ -31,29 +43,14 @@ const moduleRoomMemory = {
         rememberedCode = code;
     },
 };
-function withTimeout(promise, ms, what) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(`party server did not answer ${what} in ${ms}ms`)), ms);
-        promise.then(value => {
-            clearTimeout(timer);
-            resolve(value);
-        }, error => {
-            clearTimeout(timer);
-            reject(error);
-        });
+/** `players` with each one's flags in `flags` taken on: a new list, so a screen holding the last one sees the change. */
+function withFlags(players, flags) {
+    const changed = new Map(flags.map(entry => [entry.id, entry]));
+    return players.map(player => {
+        const entry = changed.get(player.id);
+        return entry ? { ...player, ...entry } : player;
     });
 }
-/** URLs without trailing slashes. No Object.entries or fromEntries: older TV browsers lack them, and the app has no polyfill. */
-function tidyUrls(urls) {
-    const tidy = {};
-    for (const key of Object.keys(urls)) {
-        tidy[key] = urls[key].replace(/\/+$/, '');
-    }
-    return tidy;
-}
-function routesAlike(a, b) {
-    return (a ? (0, protocol_1.codePrefixOf)(a) : null) === (b ? (0, protocol_1.codePrefixOf)(b) : null);
-}
 /**
  * Host side of the party games protocol. The TV owns the video and therefore
  * owns round timing: it tells the server when a round starts and when it ends,
@@ -63,41 +60,18 @@ function routesAlike(a, b) {
  * so navigating from the lobby into the first round keeps the same room and
  * the same players.
  *
- * Rooms live in the memory of one server of several, and the load balancer
- * finds it by the room code: every connection made for a room carries its
- * code (ROUTING_QUERY_KEY). A connection made before there is a room goes to
- * any server, so once that server has opened one the client connects again
- * with its code - in the lobby, where a moment's reconnect costs nothing,
- * rather than leaving the game on a route the load balancer can take away.
+ * Rooms live in the memory of one server of several. Reaching the room's -
+ * placing each socket, and placing it again when it drops - is the
+ * connection's job: see PartyConnection.
  */
 class PartyGameClient {
-    url;
-    /** Built in at first, then as the servers say: see PartyRouting. */
-    regionUrls;
-    /** Regions given up on, until when: their rooms are looked for through the global name. */
-    downRegions = {};
-    io;
+    connection;
     hostId;
     roomMemory;
     logger;
-    ackTimeoutMs;
     clockSyncIntervalMs;
-    regionFallbackMs;
-    regionDownMs;
-    /** Runs while the current socket, routed to a room's region, is not connected. */
-    regionTimer = null;
-    /** A connection to the global name, seeing whether it is the region that is out of reach. */
-    regionProbe = null;
-    socket = null;
-    /** The room code the current socket was routed by, if any. */
-    routedCode = null;
-    /**
-     * Whether the current connection is attached to the session's room. Host
-     * calls wait for it: sent while a reconnect is still re-attaching, they
-     * would reach the server from a socket it does not know the room of.
-     */
-    attached = true;
-    attachedWaiters = [];
+    /** Roster changes for a room this TV is about to be handed: see adopt. */
+    earlyFlags = null;
     session = null;
     /** Where the session's room is now, when a server has said it moved. */
     redirectCode = null;
@@ -118,17 +92,28 @@ class PartyGameClient {
     clockOffset = 0;
     clockSyncTimer = null;
     constructor(options) {
-        this.url = options.url.replace(/\/+$/, '');
-        this.regionUrls = tidyUrls(options.regionUrls || {});
-        this.io = options.io;
         this.hostId = options.hostId || processHostId;
         this.roomMemory = options.roomMemory || moduleRoomMemory;
         this.logger = options.logger || console;
-        this.ackTimeoutMs = options.ackTimeoutMs ?? defaultAckTimeoutMs;
         this.clockSyncIntervalMs =
             options.clockSyncIntervalMs ?? defaultClockSyncIntervalMs;
-        this.regionFallbackMs = options.regionFallbackMs ?? defaultRegionFallbackMs;
-        this.regionDownMs = options.regionDownMs ?? defaultRegionDownMs;
+        this.connection = new connection_1.PartyConnection({
+            url: options.url.replace(/\/+$/, ''),
+            regionUrls: options.regionUrls || {},
+            io: options.io,
+            fetch: options.fetch || globalFetch,
+            logger: this.logger,
+            ackTimeoutMs: options.ackTimeoutMs ?? defaultAckTimeoutMs,
+            placementTimeoutMs: options.placementTimeoutMs ?? defaultPlacementTimeoutMs,
+            roomRetryMs: options.roomRetryMs ?? defaultRoomRetryMs,
+        }, {
+            roomCode: () => this.redirectCode || this.session?.code || null,
+            opened: socket => this.listen(socket),
+            connected: (socket, prefix) => {
+                this.syncClock();
+                this.reattach(socket, prefix);
+            },
+        });
     }
     getSession() {
         return this.session;
@@ -137,7 +122,7 @@ class PartyGameClient {
         return this.players;
     }
     isConnected() {
-        return this.socket ? this.socket.connected : false;
+        return this.connection.isConnected();
     }
     /**
      * A download of at least `bytes` random bytes for the TV to time in the
@@ -155,147 +140,8 @@ class PartyGameClient {
         return { url: `${origin}${(0, protocol_1.speedtestPath)(size)}`, bytes: size };
     }
     /* ---------------------------------------------------------- connection */
-    /** The socket for `code`'s room (or for no room), connecting a new one if need be. */
-    socketFor(code, { fresh = false } = {}) {
-        if (this.socket && !fresh && routesAlike(this.routedCode, code)) {
-            return this.socket;
-        }
-        if (this.socket) {
-            this.logger.debug('PartyGames', 'reconnecting to route by', code);
-            this.socket.close();
-        }
-        this.routedCode = code;
-        this.socket = this.openSocket(code);
-        return this.socket;
-    }
-    currentSocket() {
-        return this.socket || this.socketFor(this.session?.code || null);
-    }
-    setAttached(attached) {
-        this.attached = attached;
-        if (attached) {
-            const waiters = this.attachedWaiters;
-            this.attachedWaiters = [];
-            for (const waiter of waiters) {
-                waiter();
-            }
-        }
-    }
-    whenAttached(what) {
-        if (this.attached) {
-            return Promise.resolve();
-        }
-        return withTimeout(new Promise(resolve => this.attachedWaiters.push(resolve)), this.ackTimeoutMs, `${what} (reconnecting)`);
-    }
-    /**
-     * Where `code`'s room is: its region's servers, or for no room - or one in
-     * a region given up on - the nearest.
-     */
-    urlFor(code) {
-        const region = code ? (0, protocol_1.regionOfCode)(code) : null;
-        if (!code || (region && (this.downRegions[region] || 0) > Date.now())) {
-            return this.url;
-        }
-        return (0, protocol_1.socketUrlForCode)(code, {
-            socketUrl: this.url,
-            regionSocketUrls: this.regionUrls,
-        });
-    }
-    /** A socket routed by `code`, to `url` (by default, where `code`'s room is). */
-    connectTo(code, url = this.urlFor(code)) {
-        return this.io(url, {
-            transports: ['websocket'],
-            jsonp: false,
-            query: code ? { [protocol_1.ROUTING_QUERY_KEY]: code } : {},
-            forceNew: true,
-            reconnection: true,
-            reconnectionDelay: 1000,
-            reconnectionDelayMax: 5000,
-            timeout: this.ackTimeoutMs,
-        });
-    }
-    /**
-     * Gives a room's region `regionFallbackMs` to answer `socket`, routed to it
-     * by `code` (null stops watching). A region that does not is checked
-     * against the global name: if that answers, the region is down - its rooms
-     * with it, as a room lives in one server's memory - so the client goes
-     * through the global name instead, where the room's code gets a new room,
-     * in a region that is up. If it does not either, it is this TV that is
-     * offline, and the room is waited for: it may well still be there.
-     */
-    watchRegion(socket, code) {
-        if (this.regionTimer) {
-            clearTimeout(this.regionTimer);
-            this.regionTimer = null;
-        }
-        this.closeRegionProbe();
-        if (!code) {
-            return;
-        }
-        this.regionTimer = setTimeout(() => {
-            this.regionTimer = null;
-            if (socket !== this.socket || socket.connected) {
-                return;
-            }
-            const probe = this.connectTo(null, this.url);
-            this.regionProbe = probe;
-            probe.on('connect', () => {
-                if (probe !== this.regionProbe) {
-                    return;
-                }
-                this.closeRegionProbe();
-                if (socket !== this.socket || socket.connected) {
-                    return;
-                }
-                const region = (0, protocol_1.regionOfCode)(code);
-                if (region) {
-                    this.downRegions[region] = Date.now() + this.regionDownMs;
-                }
-                this.logger.warn('PartyGames', 'region', region, 'out of reach, going through', this.url, 'for', code);
-                this.socketFor(code, { fresh: true });
-            });
-            probe.on('connect_error', () => {
-                if (probe === this.regionProbe) {
-                    /* offline here too: the room is waited for */
-                    this.watchRegion(socket, code);
-                }
-            });
-        }, this.regionFallbackMs);
-    }
-    closeRegionProbe() {
-        const probe = this.regionProbe;
-        if (probe) {
-            this.regionProbe = null;
-            probe.close();
-        }
-    }
-    openSocket(code) {
-        this.setAttached(false);
-        const url = this.urlFor(code);
-        const socket = this.connectTo(code, url);
-        /* a room in a region of its own: watched in case that region is down */
-        const regional = code && url !== this.url ? code : null;
-        this.watchRegion(socket, regional);
-        socket.on('connect', () => {
-            if (socket !== this.socket) {
-                return;
-            }
-            this.logger.debug('PartyGames', 'connected to', url);
-            this.watchRegion(socket, null);
-            this.syncClock();
-            this.reattach(socket);
-        });
-        socket.on('disconnect', () => {
-            if (socket !== this.socket) {
-                return;
-            }
-            this.logger.debug('PartyGames', 'disconnected');
-            this.setAttached(false);
-            this.watchRegion(socket, regional);
-        });
-        socket.on('connect_error', (error) => {
-            this.logger.warn('PartyGames', 'connect error', error?.message);
-        });
+    /** Listens for the room's messages on a socket the connection has opened. */
+    listen(socket) {
         socket.on(protocol_1.HostMessage.Players, (payload) => {
             if (this.session && payload?.code && payload.code !== this.session.code) {
                 /* a room this TV is only now being given - its own went, or moved -
@@ -303,10 +149,26 @@ class PartyGameClient {
                    the roster is the room's it was in */
                 return;
             }
-            this.players = payload?.players || [];
-            for (const listener of this.playersListeners) {
-                listener(this.players);
+            this.setPlayers(payload?.players || []);
+        });
+        socket.on(protocol_1.HostMessage.PlayersChanged, (payload) => {
+            if (!payload?.players) {
+                return;
             }
+            if (payload.code !== this.session?.code) {
+                /* a room being handed to this TV, whose answer has not been taken
+                   on yet: kept until it is, as unlike a whole roster these are not
+                   sent again */
+                this.earlyFlags =
+                    this.earlyFlags?.code === payload.code
+                        ? {
+                            code: payload.code,
+                            players: [...this.earlyFlags.players, ...payload.players],
+                        }
+                        : payload;
+                return;
+            }
+            this.setPlayers(withFlags(this.players, payload.players));
         });
         socket.on(protocol_1.HostMessage.AllAnswered, (payload) => {
             for (const listener of this.allAnsweredListeners) {
@@ -322,7 +184,7 @@ class PartyGameClient {
             }
         });
         socket.on(protocol_1.HostMessage.Move, (message) => {
-            if (socket === this.socket && message?.token) {
+            if (socket === this.connection.current() && message?.token) {
                 this.moveRoom(socket, message.token);
             }
         });
@@ -338,25 +200,35 @@ class PartyGameClient {
             /* clocks drift, and so does the route to the server */
             this.clockSyncTimer = setInterval(() => this.syncClock(), this.clockSyncIntervalMs);
         }
-        return socket;
+    }
+    setPlayers(players) {
+        this.players = players;
+        for (const listener of this.playersListeners) {
+            listener(this.players);
+        }
     }
     /**
      * Back on the room we were already hosting, so a dropped connection
      * mid-party does not lose the players or their scores. If the room is gone
      * - its server is - the server opens a new one, and the session follows.
      */
-    reattach(socket) {
+    reattach(socket, prefix) {
         const session = this.session;
         if (!session) {
-            this.setAttached(true);
+            this.connection.attachedTo(socket);
             return;
         }
-        this.send(socket, protocol_1.HostEvent.Create, {
+        let attached = true;
+        this.connection
+            .send(socket, protocol_1.HostEvent.Create, {
             code: this.redirectCode || session.code,
             hostId: this.hostId,
             features,
         })
             .then(response => {
+            if (socket !== this.connection.current()) {
+                return;
+            }
             if (response?.ok) {
                 // A re-attach is not a reopen, so it says `reused: false`; the
                 // lobby still is the one it was.
@@ -375,13 +247,14 @@ class PartyGameClient {
             }
             else if (response?.reason === protocol_1.HostRefusal.Moved && response.movedTo) {
                 /* it left that server while we were away: follow it */
+                attached = false;
                 this.redirectCode = response.movedTo;
-                this.socketFor(response.movedTo);
+                this.connection.connectFor(response.movedTo);
             }
             else if (response?.reason === protocol_1.HostRefusal.Draining) {
-                /* the room is gone and its server opens no new ones: another will,
-                   over a new connection the load balancer can send elsewhere */
-                this.socketFor(null, { fresh: true });
+                /* the room is gone and its server opens no new ones: another will */
+                attached = false;
+                this.connection.connectFor(null, { avoid: [prefix] });
             }
             else {
                 this.logger.warn('PartyGames', 'failed to re-attach', response);
@@ -389,15 +262,15 @@ class PartyGameClient {
         })
             .catch(error => this.logger.warn('PartyGames', 'failed to re-attach', error))
             .finally(() => {
-            if (socket === this.socket) {
-                this.setAttached(true);
+            if (attached) {
+                this.connection.attachedTo(socket);
             }
         });
     }
     /** Takes on a session the server has handed back, rerouting by its code if need be. */
     adopt(response) {
         if (response.regionSocketUrls) {
-            this.regionUrls = tidyUrls(response.regionSocketUrls);
+            this.connection.setRegionUrls(response.regionSocketUrls);
         }
         const previous = this.session;
         this.redirectCode = null;
@@ -411,6 +284,11 @@ class PartyGameClient {
             players: response.players || [],
         };
         this.players = this.session.players;
+        const early = this.earlyFlags;
+        this.earlyFlags = null;
+        if (early?.code === response.code) {
+            this.setPlayers(withFlags(this.players, early.players));
+        }
         this.roomMemory.set(response.code);
         if (previous && previous.code !== response.code) {
             this.logger.warn('PartyGames', 'room', previous.code, 'is gone, now', response.code);
@@ -418,16 +296,9 @@ class PartyGameClient {
                 listener(this.session);
             }
         }
-        if (!routesAlike(this.routedCode, response.code)) {
-            this.socketFor(response.code);
+        if (!this.connection.routesTo(response.code)) {
+            this.connection.connectFor(response.code);
         }
-        else {
-            /* same server: from now on this socket stands for the room */
-            this.routedCode = response.code;
-        }
-    }
-    send(socket, event, payload = {}) {
-        return withTimeout(new Promise(resolve => socket.emit(event, payload, resolve)), this.ackTimeoutMs, event);
     }
     /**
      * A host call: once the connection is attached to the room. A call that
@@ -435,43 +306,56 @@ class PartyGameClient {
      */
     async emit(event, payload = {}) {
         for (let attempt = 0;; ++attempt) {
-            const socket = this.currentSocket();
-            await this.whenAttached(event);
-            const response = await this.send(this.socket || socket, event, payload);
+            this.connection.ensure();
+            await this.connection.whenAttached(event);
+            const socket = this.connection.current();
+            if (!socket) {
+                throw new Error(`party server not connected for ${event}`);
+            }
+            const response = await this.connection.send(socket, event, payload);
             const reason = response?.reason;
             if (reason !== protocol_1.HostRefusal.Moving || attempt >= maxMovingRetries) {
                 return response;
             }
-            if (this.attached) {
+            if (this.connection.isAttached()) {
                 /* refused before the server said where the room is going: the
                    room:move follows, and has us reconnecting - or the move failed
                    and the server lets the room go on here after a while */
                 await new Promise(resolve => setTimeout(resolve, movingRetryMs));
             }
             /* the room:move that came before this answer has us reconnecting */
-            await this.whenAttached(event);
+            await this.connection.whenAttached(event);
         }
     }
     /**
      * Takes the room to another server, which the one it is on asked for: it
-     * is on its way out, and no game is being played. The room is adopted over
-     * a connection with no room in its query - so the load balancer hands it
-     * to a server still taking parties - the old server is told where it went,
-     * for the phones, and the client then connects for the new code as usual.
-     * Host calls wait meanwhile. If it cannot be done the room stays where it
-     * was, and the server asks again later.
+     * is on its way out, and no game is being played. Another server of the
+     * room's region - the handover is between them, in their tables - is
+     * placed for no room and adopts it over a socket of its own; the old server
+     * is told where it went, for the phones; and the client then connects for
+     * the new code as usual. Host calls wait meanwhile. If it cannot be done
+     * the room stays where it was, and the server asks again later.
      */
     async moveRoom(oldSocket, token) {
-        this.setAttached(false);
-        // The handover is between the servers of one region, whose tables hold
-        // it, so it goes to the room's region rather than the nearest.
-        const regionUrl = this.urlFor(this.session?.code || null);
+        this.connection.setAttached(false);
+        const regionUrl = this.connection.urlFor(this.session?.code || null);
+        const avoid = this.connection.avoidingRouted();
         let adopted = null;
-        for (let attempt = 0; attempt <= maxDrainingRetries && !adopted; ++attempt) {
-            const socket = this.connectTo(null, regionUrl);
+        for (let attempt = 0; attempt <= connection_1.maxDrainingRetries && !adopted; ++attempt) {
+            const placed = await this.connection.place(regionUrl, null, avoid);
+            if (!placed) {
+                /* no server answered: give it a moment before asking again */
+                await new Promise(resolve => setTimeout(resolve, (0, protocol_1.reconnectDelay)(attempt)));
+                continue;
+            }
+            if (placed === connection_1.refused) {
+                /* the next ask goes to the next server */
+                continue;
+            }
+            const socket = this.connection.connectTo(placed.prefix, placed.url);
             try {
-                await withTimeout(new Promise(resolve => socket.on('connect', () => resolve())), this.ackTimeoutMs, 'connecting to move the room');
-                const response = await this.send(socket, protocol_1.HostEvent.Adopt, {
+                await this.connection.whenConnected(socket, 'connecting to move the room');
+                const response = await this.connection.send(socket, protocol_1.HostEvent.Adopt, {
                     token,
                     hostId: this.hostId,
                     features,
@@ -479,28 +363,34 @@ class PartyGameClient {
                 if (response?.ok) {
                     adopted = response;
                 }
-                else if (response?.reason !== protocol_1.HostRefusal.Draining) {
+                else if (response?.reason === protocol_1.HostRefusal.Draining) {
+                    avoid.push(placed.prefix);
+                }
+                else {
                     this.logger.warn('PartyGames', 'could not move the room', response);
                     break;
                 }
             }
             catch (error) {
                 this.logger.warn('PartyGames', 'could not move the room', error);
+                avoid.push(placed.prefix);
             }
             finally {
                 socket.close();
             }
         }
-        if (oldSocket !== this.socket) {
+        if (oldSocket !== this.connection.current()) {
             return;
         }
         if (!adopted) {
-            this.setAttached(true);
+            this.connection.setAttached(true);
             return;
         }
         this.logger.debug('PartyGames', 'room moved to', adopted.code);
-        await this.send(oldSocket, protocol_1.HostEvent.Moved, { code: adopted.code }).catch(error => this.logger.warn('PartyGames', 'could not say where the room went', error));
-        if (oldSocket === this.socket) {
+        await this.connection
+            .send(oldSocket, protocol_1.HostEvent.Moved, { code: adopted.code })
+            .catch(error => this.logger.warn('PartyGames', 'could not say where the room went', error));
+        if (oldSocket === this.connection.current()) {
             this.adopt(adopted);
         }
     }
@@ -514,8 +404,12 @@ class PartyGameClient {
         let best = null;
         for (let sample = 0; sample < clockSyncSamples; ++sample) {
             try {
+                const socket = this.connection.current();
+                if (!socket) {
+                    break;
+                }
                 const sentAt = Date.now();
-                const response = await this.send(this.currentSocket(), protocol_1.TimeEvent.Ping);
+                const response = await this.connection.send(socket, protocol_1.TimeEvent.Ping);
                 const receivedAt = Date.now();
                 const rtt = receivedAt - sentAt;
                 if (typeof response?.now === 'number' && (!best || rtt < best.rtt)) {
@@ -571,8 +465,8 @@ class PartyGameClient {
         };
         /* A fresh room is opened over the connection we have, so the server
            holding the old one closes it; any other ask goes where its room is. */
-        if (!fresh) {
-            this.socketFor(code || null);
+        if (!fresh && !this.connection.connectedFor(code || null)) {
+            this.connection.connectFor(code || null);
         }
         for (let attempt = 0;; ++attempt) {
             if (!fresh && attempt > 0) {
@@ -582,7 +476,7 @@ class PartyGameClient {
             const response = await this.emit(protocol_1.HostEvent.Create, request);
             if (response?.ok) {
                 this.adopt(response);
-                await this.whenAttached('the room');
+                await this.connection.whenAttached('the room');
                 return this.session;
             }
             if (response?.reason === protocol_1.HostRefusal.Moved &&
@@ -590,11 +484,11 @@ class PartyGameClient {
                 attempt < maxRedirects) {
                 /* opened again on another server since we last knew it */
                 this.redirectCode = response.movedTo;
-                this.socketFor(response.movedTo);
+                this.connection.connectFor(response.movedTo);
                 continue;
             }
             if (response?.reason === protocol_1.HostRefusal.Draining &&
-                attempt < maxDrainingRetries) {
+                attempt < connection_1.maxDrainingRetries) {
                 /* asked a server on its way out: any other server will do */
                 this.logger.debug('PartyGames', 'server draining, asking another');
                 if (fresh) {
@@ -603,7 +497,9 @@ class PartyGameClient {
                 }
                 // A new connection even if this one had no room either: over the
                 // same socket the same draining server would answer again.
-                this.socketFor(null, { fresh: true });
+                this.connection.connectFor(null, {
+                    avoid: this.connection.avoidingRouted(),
+                });
                 continue;
             }
             throw new Error(response?.error || 'failed to open a party game room');
@@ -675,6 +571,14 @@ class PartyGameClient {
         if (!response?.ok) {
             throw new Error(response?.error || 'failed to open the round');
         }
+        // Nobody has answered the new round, nor been scored on it: the server
+        // leaves this to the TV rather than send the whole roster again.
+        this.setPlayers(this.players.map(player => ({
+            ...player,
+            answered: false,
+            correct: null,
+            gained: 0,
+        })));
     }
     /** When the server has said a round starts: at once if it already has. */
     waitForRoundGo(round) {
@@ -697,8 +601,20 @@ class PartyGameClient {
         if (!response?.ok) {
             return null;
         }
-        this.players = response.players || [];
-        return response;
+        // Each player only as the round changed them: the rest - name,
+        // connection, flags - from the roster this TV already has.
+        const known = new Map(this.players.map(player => [player.id, player]));
+        this.players = (response.players || [])
+            .map(standing => ({
+            name: '',
+            connected: false,
+            ready: false,
+            answered: false,
+            ...known.get(standing.id),
+            ...standing,
+        }))
+            .sort((a, b) => a.rank - b.rank);
+        return { ...response, players: this.players };
     }
     /**
      * An ad is playing, between rounds: the phones say so until the next round
@@ -758,7 +674,9 @@ class PartyGameClient {
             this.lastHost) {
             const { gameType, genre, genreName } = this.lastHost;
             this.session = null;
-            this.socketFor(null, { fresh: true });
+            this.connection.connectFor(null, {
+                avoid: this.connection.avoidingRouted(),
+            });
             return (await this.host(gameType, genre, genreName, true)).players;
         }
         if (!response?.ok) {
@@ -810,21 +728,11 @@ class PartyGameClient {
             clearInterval(this.clockSyncTimer);
             this.clockSyncTimer = null;
         }
-        if (this.regionTimer) {
-            clearTimeout(this.regionTimer);
-            this.regionTimer = null;
-        }
-        this.closeRegionProbe();
         this.session = null;
         this.redirectCode = null;
         this.players = [];
-        if (this.socket) {
-            const socket = this.socket;
-            this.socket = null;
-            this.routedCode = null;
-            socket.close();
-        }
-        this.setAttached(true);
+        this.earlyFlags = null;
+        this.connection.close();
     }
 }
 exports.PartyGameClient = PartyGameClient;