onelobby 0.0.0-stage → 0.2.0

package/dist/lobby.js

@@ -0,0 +1,840 @@
+import { Chat } from "./chat.js";
+import { CodecError, MAX_FRAME_BYTES, MODE_LOCKSTEP, MODE_RAW, PROTO, decodeMessage, encodeMessage, } from "./codec.js";
+import { Reassembler, splitChunks } from "./chunking.js";
+import { Emitter } from "./emitter.js";
+import { Lockstep } from "./lockstep.js";
+import { claimWinsWrapped, pickNewHost } from "./migration.js";
+import { OneLobbyError } from "./signaling.js";
+import { Voice } from "./voice.js";
+import { hostConnections, joinerSocket } from "./socket.js";
+/** The smallest `peerTimeoutMs` honoured: three missed pings. */
+export const MIN_PEER_TIMEOUT_MS = 6000;
+/** The name shown for a peer that chose none: "Player N", N = its seat (peer id, join order). */
+export function seatName(p) {
+    const n = typeof p.name === "string" ? p.name.trim() : "";
+    // "Player" is onelobby-server's stand-in for an empty name
+    if (n && n !== "Player")
+        return p;
+    return { ...p, name: `Player ${p.peerId}` };
+}
+function hasRelay(ice) {
+    return ice.some((s) => (Array.isArray(s.urls) ? s.urls : [s.urls]).some((u) => /^turns?:/i.test(String(u))));
+}
+const HOST_WATCHDOG_MS = 250;
+const PING_EVERY_MS = 2000;
+/** One joined lobby: roster, star of peer links, and the lockstep/chat/voice engines riding on them. */
+export class Lobby extends Emitter {
+    code;
+    mode;
+    tickRate;
+    lockstep;
+    chat;
+    voice;
+    localPeerId;
+    hostPeerId;
+    phase;
+    meta;
+    resumeToken;
+    /** Last measured round trip to the host in ms (joiners), or 0. */
+    rtt = 0;
+    /**
+     * Direct-IP host only (onelobby/direct): the code friends paste to join, e.g. "6B01-RGFE-P2B" (docs/direct-ip.md
+     * s.2a). Show it with joinCodeKind. Empty when the machine has no IPv4 address, and on joiners.
+     */
+    joinCode = "";
+    /** "internet": the router forwarded the port and the code carries its public address; "same_network": the LAN address. */
+    joinCodeKind = "none";
+    /** Direct-IP host only: this machine's addresses with the port, for an "Advanced" fold-out. */
+    directAddresses = [];
+    /** Direct-IP host only: how the router port-open went ("UPnP", "no UPnP gateway answered; ...", "off"). */
+    portMapping = "";
+    signaling;
+    cfg;
+    roster = new Map();
+    links = new Map();
+    connected = new Set(); // host: peers that said hi
+    hiSentTo = new Set();
+    epoch = 0;
+    ended = false;
+    serverUp = true;
+    cancelWatchdog = null;
+    cancelPing = null;
+    pingN = 0;
+    chunkId = 1;
+    reassemblers = new Map();
+    hub;
+    outbox = new Map();
+    markReady = () => { };
+    failReady = () => { };
+    isReady = false;
+    cancelReadyTimer = null;
+    relayRetry = false;
+    /** clock.now() of the last frame from each peer (peerTimeoutMs). */
+    lastHeard = new Map();
+    /** Host: per-peer fixed window for rateLimit. */
+    rate = new Map();
+    /**
+     * Resolves when this peer can exchange data: immediately for the host, once the link to the host is open for a
+     * joiner. Rejects with OneLobbyError("ice_failed") when the joiner cannot reach the host in `readyTimeoutMs`
+     * (or with "closed"/"kicked" when the lobby ends first).
+     */
+    ready = new Promise((res, rej) => {
+        this.markReady = () => {
+            if (this.isReady)
+                return;
+            this.isReady = true;
+            this.cancelReadyTimer?.();
+            this.cancelReadyTimer = null;
+            res();
+        };
+        this.failReady = rej;
+    });
+    constructor(cfg) {
+        super();
+        this.cfg = cfg;
+        this.signaling = cfg.signaling;
+        const st = cfg.state;
+        this.code = st.code;
+        this.mode = st.mode;
+        this.tickRate = st.tickRate;
+        this.localPeerId = st.you;
+        this.hostPeerId = st.hostId;
+        this.phase = st.phase;
+        this.meta = { ...st.meta };
+        this.resumeToken = st.resumeToken;
+        for (const p of st.peers)
+            this.roster.set(p.peerId, seatName(p));
+        this.ready.catch(() => { }); // a rejection is also reported through errorSink; awaiting `ready` stays optional
+        const self = this;
+        this.hub = {
+            get clock() { return self.cfg.clock; },
+            get localPeerId() { return self.localPeerId; },
+            get hostPeerId() { return self.hostPeerId; },
+            get isHost() { return self.isHost; },
+            get tickRate() { return self.tickRate; },
+            connectedPeers: () => self.connectedPeerIds(),
+            sendTo: (peerId, msg, route, channel) => self.sendTo(peerId, msg, route ?? 0, channel),
+            sendToHost: (msg, route, channel) => {
+                if (!self.isHost)
+                    self.sendTo(self.hostPeerId, msg, route ?? 0, channel);
+            },
+            dropPeer: (peerId, reason) => self.dropPeer(peerId, reason),
+            reportError: (e) => self.reportError(e),
+            nextChunkId: () => self.chunkId++ >>> 0,
+        };
+        this.lockstep = new Lockstep(this.hub, { hashEveryTicks: cfg.hashEveryTicks });
+        this.chat = new Chat(this.hub, cfg.wall, (id) => this.voice.isMutedPeer(id));
+        this.voice = new Voice(this.hub, cfg.voice);
+        this.lockstep.on("started", () => this.setPhase("in_game"));
+        this.lockstep.on("error", (e) => this.reportError(e));
+        this.signaling.onMessage = (m) => this.onSignaling(m);
+        this.signaling.onClose = () => this.onServerClosed();
+        if (this.isHost)
+            this.markReady();
+        else
+            this.armReadyTimer();
+        if (this.isHost && this.mode === "lockstep") {
+            if (this.phase === "in_game")
+                this.lockstep.hostStart();
+            else
+                this.lockstep.hostIdle();
+        }
+        this.cancelWatchdog = cfg.clock.setInterval(() => this.watchdog(), HOST_WATCHDOG_MS);
+        this.cancelPing = cfg.clock.setInterval(() => this.pingHost(), PING_EVERY_MS);
+    }
+    // ---- state -----------------------------------------------------------------------------------------------------
+    get isHost() {
+        return this.localPeerId === this.hostPeerId;
+    }
+    get peers() {
+        return [...this.roster.values()].sort((a, b) => a.peerId - b.peerId);
+    }
+    peer(peerId) {
+        return this.roster.get(peerId);
+    }
+    /** Peers whose link is open and handshake done (host: the ready joiners; joiner: the host once ready). */
+    get connectedPeers() {
+        return this.connectedPeerIds();
+    }
+    /**
+     * Joiner: the link to the host as a WebSocket-shaped object (text by default), so WebSocket client code runs
+     * unchanged. It opens when `ready` resolves and closes when the session ends (`host_left` gives code 1001).
+     */
+    asWebSocket(opts) {
+        return joinerSocket(this, opts);
+    }
+    /** Host: `handler(conn)` once per joiner (a WebSocket-shaped connection), the server-side mirror of asWebSocket(). */
+    onConnection(handler, opts) {
+        return hostConnections(this, handler, opts);
+    }
+    set snapshotChunkSize(n) {
+        this.lockstep.chunkSize = n;
+    }
+    /** Current migration epoch (0 until the first host change). */
+    get hostEpoch() {
+        return this.epoch;
+    }
+    /** @internal Host role: create the link to `peerId` and start negotiating (adapters and tests). */
+    _offer(peerId) {
+        this.offerTo(peerId);
+        return this.links.get(peerId);
+    }
+    /** @internal Joiner role: create the answering link to `peerId` (adapters and tests). */
+    _answer(peerId) {
+        return this.makeLink(peerId);
+    }
+    /** @internal Called by OneLobby right after construction: the host waits for joiners, a joiner waits for the host's offer. */
+    _begin() {
+        /* joiners are passive until the host offers; hosts create links on peer_joined */
+    }
+    // ---- game-facing actions ---------------------------------------------------------------------------------------
+    async start() {
+        if (!this.isHost)
+            throw new Error("only the host can start the game");
+        if (this.phase === "in_game")
+            return;
+        this.signaling.send({ t: "phase", phase: "in_game" });
+        this.setPhase("in_game");
+        if (this.mode === "lockstep")
+            this.lockstep.hostStart();
+    }
+    async setMeta(meta) {
+        if (!this.isHost)
+            throw new Error("only the host can set metadata");
+        this.meta = { ...meta };
+        this.signaling.send({ t: "meta", meta });
+        this.emit("metaChanged", this.meta);
+    }
+    async kick(peerId) {
+        if (!this.isHost)
+            throw new Error("only the host can kick");
+        this.signaling.send({ t: "kick", peerId });
+        this.removePeer(peerId, "kicked");
+    }
+    async approve(peerId, ok) {
+        if (!this.isHost)
+            throw new Error("only the host can approve joins");
+        this.signaling.send({ t: "approve", peerId, ok });
+    }
+    async leave() {
+        if (this.ended)
+            return;
+        this.signaling.send({ t: "leave" });
+        this.teardown("left");
+    }
+    /** raw mode (and any extra game data): to one peer. */
+    send(peerId, bytes, opts = {}) {
+        const channel = opts.channel ?? "reliable";
+        if (this.isHost)
+            this.sendTo(peerId, { type: "raw", bytes }, this.localPeerId, channel);
+        else
+            this.sendTo(this.hostPeerId, { type: "raw", bytes }, peerId, channel);
+    }
+    /** To everyone else in the lobby. */
+    broadcast(bytes, opts = {}) {
+        const channel = opts.channel ?? "reliable";
+        if (this.isHost) {
+            // peers whose channels are not open yet get reliable broadcasts queued and flushed in order
+            for (const p of this.roster.keys())
+                if (p !== this.localPeerId)
+                    this.sendTo(p, { type: "raw", bytes }, this.localPeerId, channel);
+        }
+        else {
+            this.sendTo(this.hostPeerId, { type: "raw", bytes }, 0, channel);
+        }
+    }
+    // ---- sending ---------------------------------------------------------------------------------------------------
+    channelFor(msg) {
+        if (msg.type === "voice")
+            return "voice";
+        if (msg.type === "ping" || msg.type === "pong")
+            return "fast";
+        return "reliable";
+    }
+    sendTo(peerId, msg, route, channel) {
+        const link = this.links.get(peerId);
+        const ch0 = channel ?? this.channelFor(msg);
+        const queueable = msg.type === "raw" || msg.type === "chat" || msg.type === "cmd";
+        // game data to a host-side peer waits for its `hi`; protocol messages only need the link
+        const ready = !!link?.isOpen && (!queueable || !this.isHost || this.connected.has(peerId));
+        if (!ready) {
+            // Reliable game data for a peer that is in the roster (or is the host) but not connected yet waits for its handshake.
+            const known = this.roster.has(peerId) || peerId === this.hostPeerId;
+            if (queueable && ch0 === "reliable" && known && !this.ended) {
+                let q = this.outbox.get(peerId);
+                if (!q)
+                    this.outbox.set(peerId, (q = []));
+                if (q.length >= 1000)
+                    q.shift();
+                q.push({ msg, route, channel });
+            }
+            return;
+        }
+        if (!link)
+            return;
+        try {
+            const ch = ch0;
+            let bytes;
+            try {
+                bytes = encodeMessage(msg, route);
+            }
+            catch (e) {
+                if (!(e instanceof CodecError) || e.code !== "too_long")
+                    throw e;
+                bytes = encodeMessage(msg, route, true);
+            }
+            if (bytes.length > MAX_FRAME_BYTES) {
+                // Oversized frame: send the whole inner frame as a chunk set (spec/binary.md "Large non-snapshot frames").
+                for (const c of splitChunks(this.chunkId++ >>> 0, bytes))
+                    link.send(ch, encodeMessage(c, route));
+            }
+            else {
+                link.send(ch, bytes);
+            }
+        }
+        catch (e) {
+            this.reportError(e instanceof Error ? e : new Error(String(e)));
+        }
+    }
+    connectedPeerIds() {
+        if (this.isHost)
+            return [...this.connected].filter((id) => this.links.get(id)?.isOpen).sort((a, b) => a - b);
+        const l = this.links.get(this.hostPeerId);
+        return l?.isOpen ? [this.hostPeerId] : [];
+    }
+    reportError(e) {
+        this.errorSink?.(e);
+    }
+    /** @internal set by OneLobby so lobby errors reach `kit.on("error")`. */
+    errorSink = null;
+    /** @internal set by OneLobby: the server issued a new resume token (rememberSeat). */
+    seatSink = null;
+    // ---- joiner connect timeout -------------------------------------------------------------------------------------
+    armReadyTimer() {
+        const total = this.cfg.readyTimeoutMs ?? 0;
+        if (!(total > 0))
+            return;
+        const canRelay = !this.cfg.relayOnly && hasRelay(this.cfg.ice);
+        const first = canRelay ? Math.ceil(total / 2) : total;
+        this.cancelReadyTimer = this.cfg.clock.setTimeout(() => {
+            if (this.isReady || this.ended)
+                return;
+            if (canRelay)
+                this.retryRelayed(total - first);
+            else
+                this.giveUpConnecting();
+        }, first);
+    }
+    /** The direct attempt stalled: dial the host ourselves through the TURN relay (a host answers any offer). */
+    retryRelayed(budget) {
+        this.relayRetry = true;
+        const link = this.makeLink(this.hostPeerId, true);
+        link.startOffer();
+        this.cancelReadyTimer = this.cfg.clock.setTimeout(() => {
+            if (!this.isReady && !this.ended)
+                this.giveUpConnecting();
+        }, budget);
+    }
+    giveUpConnecting() {
+        const err = new OneLobbyError("ice_failed", `could not open a connection to the host${this.relayRetry ? " (direct or relayed)" : ""}`);
+        this.failReady(err);
+        this.reportError(err);
+        if (this.ended)
+            return;
+        this.signaling.send({ t: "leave" });
+        this.teardown("ice_failed");
+    }
+    // ---- links -----------------------------------------------------------------------------------------------------
+    makeLink(peerId, relayOnly = this.cfg.relayOnly) {
+        const old = this.links.get(peerId);
+        if (old) {
+            old.onClose = null;
+            old.onMessage = null;
+            old.close();
+        }
+        const link = this.cfg.links.create({ remoteId: peerId, iceServers: this.cfg.ice, relayOnly });
+        this.links.set(peerId, link);
+        link.onSignal = (s) => this.signaling.send({ t: "signal", to: peerId, ...s });
+        link.onOpen = () => this.onLinkOpen(peerId, link);
+        link.onClose = (reason) => this.onLinkClosed(peerId, link, reason);
+        link.onMessage = (ch, bytes) => this.onData(peerId, ch, bytes);
+        link.onPath = (path) => this.signaling.send({ t: "path", path });
+        return link;
+    }
+    /** Host side: offer to a joiner. */
+    offerTo(peerId) {
+        const link = this.makeLink(peerId);
+        link.startOffer();
+    }
+    onLinkOpen(peerId, link) {
+        if (this.isHost) {
+            // Joiner speaks first (`hi`). After a migration the new host announces itself so the joiner knows who won.
+            if (this.epoch > 0)
+                this.sendTo(peerId, { type: "host_claim", epoch: this.epoch, hostId: this.localPeerId, tick: this.lockstep.lastTick }, 0);
+            return;
+        }
+        if (peerId === this.hostPeerId)
+            this.sendHi(link);
+        // else: an unexpected offerer; wait for its host_claim before trusting it
+    }
+    sendHi(link) {
+        if (this.hiSentTo.has(link))
+            return;
+        this.hiSentTo.add(link);
+        this.lockstep.touch();
+        link.send("reliable", encodeMessage(this.lockstep.hiMessage(this.localPeerId)));
+        this.markReady();
+        this.emit("ready");
+        this.emit("peerReady", this.roster.get(link.remoteId) ?? { peerId: link.remoteId, name: "" });
+        this.flush(link.remoteId);
+    }
+    onLinkClosed(peerId, link, _reason) {
+        if (this.links.get(peerId) !== link)
+            return; // replaced
+        this.links.delete(peerId);
+        this.hiSentTo.delete(link);
+        if (this.ended)
+            return;
+        if (this.isHost) {
+            this.connected.delete(peerId);
+            this.lockstep.onPeerLeft(peerId);
+            this.voice.onPeerLeft(peerId);
+            // The server announces the departure; if it is gone, drop the peer ourselves.
+            if (!this.serverUp && this.roster.has(peerId))
+                this.removePeer(peerId, "timeout");
+        }
+        else if (peerId === this.hostPeerId) {
+            // Never connected yet (ICE failed): not a host loss. The ready timer retries over the relay or gives up.
+            if (!this.isReady && this.cancelReadyTimer)
+                return;
+            this.handleHostLost("link closed");
+        }
+    }
+    // ---- data channel dispatch -------------------------------------------------------------------------------------
+    onData(from, channel, bytes, reassembled = false) {
+        let d;
+        try {
+            d = decodeMessage(bytes, reassembled);
+        }
+        catch (e) {
+            this.reportError(e instanceof Error ? e : new Error(String(e)));
+            return;
+        }
+        if (!d)
+            return;
+        if (!reassembled)
+            this.lastHeard.set(from, this.cfg.clock.now());
+        const { msg, route } = d;
+        switch (msg.type) {
+            case "hi":
+                if (this.isHost)
+                    this.onHi(from, msg.lastTick);
+                break;
+            case "welcome_dc":
+                if (!this.isHost) {
+                    if (msg.hostId !== this.hostPeerId)
+                        this.setHost(msg.hostId);
+                    this.lockstep.touch();
+                }
+                break;
+            case "cmd":
+            case "frame":
+            case "hash":
+            case "desync":
+            case "snapshot_req":
+            case "snapshot":
+                if (from === this.hostPeerId || this.isHost)
+                    this.lockstep.handle(from, msg);
+                break;
+            case "chunk": {
+                if (reassembled)
+                    break; // a chunk set never nests another
+                let r = this.reassemblers.get(from);
+                if (!r)
+                    this.reassemblers.set(from, (r = new Reassembler()));
+                let whole;
+                try {
+                    whole = r.push(msg);
+                }
+                catch (e) {
+                    this.reportError(e instanceof Error ? e : new Error(String(e)));
+                    break;
+                }
+                if (!whole)
+                    break;
+                if (this.lockstep.snapshotPending && from === this.hostPeerId)
+                    this.lockstep.onSnapshotPayload(whole);
+                else
+                    this.onData(from, channel, whole, true); // an oversized inner frame
+                break;
+            }
+            case "chat":
+            case "chat_history":
+            case "chat_reject":
+                this.chat.handle(from, route, msg);
+                break;
+            case "voice":
+                if (channel === "voice")
+                    this.voice.handle(from, route, msg); // a voice frame on another channel is ignored
+                break;
+            case "raw":
+                this.onRaw(from, route, msg.bytes, channel);
+                break;
+            case "ping":
+                this.sendTo(from, { type: "pong", n: msg.n, t: msg.t }, 0, "fast");
+                break;
+            case "pong":
+                this.rtt = Math.max(0, (this.cfg.clock.now() >>> 0) - msg.t);
+                break;
+            case "host_claim":
+                this.onHostClaim(from, msg.epoch, msg.hostId);
+                break;
+        }
+    }
+    onHi(from, lastTick) {
+        this.connected.add(from);
+        this.sendTo(from, {
+            type: "welcome_dc",
+            // the tick the snapshot will carry (the game's applied tick), so welcome_dc.tick == snapshot.tick even when
+            // the game loop has not yet consumed every emitted frame; 0 before the game starts
+            tick: this.mode === "lockstep" ? this.lockstep.currentTick : 0,
+            tickRate: this.tickRate,
+            mode: this.mode === "lockstep" ? MODE_LOCKSTEP : MODE_RAW,
+            hostId: this.localPeerId,
+        }, 0);
+        this.chat.sendHistory(from);
+        if (this.mode === "lockstep")
+            this.lockstep.onPeerHi(from, lastTick);
+        this.emit("peerReady", this.roster.get(from) ?? { peerId: from, name: "" });
+        this.flush(from);
+    }
+    flush(peerId) {
+        const q = this.outbox.get(peerId);
+        if (!q)
+            return;
+        this.outbox.delete(peerId);
+        for (const m of q)
+            this.sendTo(peerId, m.msg, m.route, m.channel);
+    }
+    onRaw(from, route, bytes, channel) {
+        if (!this.isHost) {
+            this.emit("message", route, bytes, channel);
+            return;
+        }
+        if (!this.allowRaw(from))
+            return;
+        if (route === 0 || route === this.localPeerId) {
+            this.emit("message", from, bytes, channel);
+        }
+        if (route === 0) {
+            for (const p of this.connectedPeerIds())
+                if (p !== from)
+                    this.sendTo(p, { type: "raw", bytes }, from, channel);
+        }
+        else if (route !== this.localPeerId) {
+            this.sendTo(route, { type: "raw", bytes }, from, channel);
+        }
+    }
+    allowRaw(from) {
+        const lim = this.cfg.rateLimit;
+        if (!lim || !(lim.messages > 0) || !(lim.perMs > 0))
+            return true;
+        const now = this.cfg.clock.now();
+        let w = this.rate.get(from);
+        if (!w || now - w.start >= lim.perMs)
+            this.rate.set(from, (w = { start: now, n: 0 }));
+        return ++w.n <= lim.messages;
+    }
+    // ---- migration -------------------------------------------------------------------------------------------------
+    setHost(hostId) {
+        if (hostId === this.hostPeerId)
+            return;
+        this.hostPeerId = hostId;
+        this.emit("hostChanged", hostId);
+    }
+    /** The host is gone (link closed, no frames for 3 s, or the server said so): run the s.9 rule. */
+    handleHostLost(reason) {
+        if (this.isHost || this.ended)
+            return;
+        if (this.cfg.direct) {
+            this.teardown("host_left");
+            return;
+        }
+        const failed = this.hostPeerId;
+        const gone = this.roster.get(failed);
+        if (gone) {
+            this.roster.delete(failed);
+            this.emit("peerLeft", gone, reason === "link closed" ? "timeout" : reason);
+        }
+        const old = this.links.get(failed);
+        if (old) {
+            old.onClose = null;
+            old.onMessage = null;
+            old.close();
+            this.links.delete(failed);
+            this.hiSentTo.delete(old);
+        }
+        const candidate = pickNewHost([...this.roster.keys(), this.localPeerId], failed) ?? this.localPeerId;
+        if (candidate === this.localPeerId)
+            this.becomeHost();
+        // else: wait for the candidate's host_claim (or the server's host_changed); it offers to us and we answer with hi
+    }
+    becomeHost() {
+        this.epoch = (this.epoch + 1) & 0xffff;
+        this.hostPeerId = this.localPeerId;
+        this.markReady();
+        this.connected.clear();
+        this.hiSentTo.clear();
+        this.lastHeard.clear(); // joiners spoke to the old host; their clocks start when they say hi to us
+        this.lockstep.becomeHost();
+        this.emit("hostChanged", this.localPeerId);
+        if (this.serverUp)
+            this.signaling.send({ t: "host_changed", hostId: this.localPeerId, epoch: this.epoch });
+        for (const p of this.roster.keys()) {
+            if (p !== this.localPeerId)
+                this.offerTo(p);
+        }
+    }
+    onHostClaim(from, epoch, hostId) {
+        const mine = { epoch: this.epoch, hostId: this.hostPeerId };
+        const theirs = { epoch, hostId };
+        if (hostId === this.hostPeerId && epoch === this.epoch && !this.isHost) {
+            const l = this.links.get(from);
+            if (l)
+                this.sendHi(l);
+            return;
+        }
+        if (!claimWinsWrapped(theirs, mine))
+            return; // we hold the better claim
+        const wasHost = this.isHost;
+        this.epoch = epoch;
+        if (wasHost) {
+            // We lose: demote. Everyone else will be offered to by the winner.
+            for (const [id, l] of this.links) {
+                if (id === from)
+                    continue;
+                l.onClose = null;
+                l.onMessage = null;
+                l.close();
+                this.links.delete(id);
+            }
+            this.connected.clear();
+            this.lockstep.becomeJoiner();
+        }
+        this.setHost(hostId);
+        const link = this.links.get(from);
+        if (link && from === hostId)
+            this.sendHi(link);
+    }
+    // ---- signaling -------------------------------------------------------------------------------------------------
+    onSignaling(m) {
+        switch (m.t) {
+            case "peer_joined": {
+                if (!m.peer || this.roster.has(m.peer.peerId))
+                    return;
+                const peer = seatName(m.peer);
+                this.roster.set(peer.peerId, peer);
+                this.emit("peerJoined", peer);
+                if (this.isHost)
+                    this.offerTo(peer.peerId);
+                break;
+            }
+            case "peer_left":
+                this.removePeer(Number(m.peerId), String(m.reason ?? "left"));
+                break;
+            case "host_changed": {
+                if (this.cfg.direct) {
+                    // the hub promotes a joiner as the host leaves; in direct mode the hub is going with it
+                    if (!this.isHost)
+                        this.teardown("host_left");
+                    break;
+                }
+                const id = Number(m.hostId);
+                if (typeof m.epoch === "number" && m.epoch > this.epoch)
+                    this.epoch = m.epoch & 0xffff;
+                if (id === this.hostPeerId)
+                    break;
+                if (id === this.localPeerId && !this.isHost) {
+                    const failed = this.hostPeerId;
+                    this.roster.delete(failed);
+                    this.becomeHost();
+                }
+                else {
+                    this.setHost(id);
+                }
+                break;
+            }
+            case "join_request":
+                this.emit("joinRequested", seatName(m.peer));
+                break;
+            case "lobby": {
+                const st = m;
+                this.meta = { ...st.meta };
+                if (st.resumeToken && st.resumeToken !== this.resumeToken) {
+                    this.resumeToken = st.resumeToken;
+                    this.seatSink?.(this.resumeToken);
+                }
+                this.roster = new Map(st.peers.map((p) => [p.peerId, seatName(p)]));
+                if (st.hostId !== this.hostPeerId && !this.isHost)
+                    this.setHost(st.hostId);
+                this.setPhase(st.phase);
+                break;
+            }
+            case "meta":
+                this.meta = { ...m.meta };
+                this.emit("metaChanged", this.meta);
+                break;
+            case "phase":
+                this.setPhase(m.phase);
+                break;
+            case "signal":
+                void this.onSignal(Number(m.from), m);
+                break;
+            case "error":
+                if (m.code === "kicked")
+                    this.teardown("kicked");
+                else
+                    this.reportError(new OneLobbyError(String(m.code), String(m.msg ?? ""), m.data));
+                break;
+        }
+    }
+    async onSignal(from, s) {
+        let link = this.links.get(from);
+        if (s.sdp?.type === "offer") {
+            // We are the answerer; an offer always comes from the (new) host.
+            link = this.makeLink(from);
+        }
+        if (!link)
+            return;
+        const payload = {};
+        if (s.sdp)
+            payload.sdp = s.sdp;
+        if (s.ice)
+            payload.ice = s.ice;
+        await link.handleSignal(payload);
+    }
+    removePeer(peerId, reason) {
+        const peer = this.roster.get(peerId);
+        if (peerId === this.localPeerId) {
+            this.teardown(reason === "kicked" ? "kicked" : reason);
+            return;
+        }
+        if (peer)
+            this.roster.delete(peerId);
+        const link = this.links.get(peerId);
+        if (link && peerId !== this.hostPeerId) {
+            link.onClose = null;
+            link.onMessage = null;
+            link.close();
+            this.links.delete(peerId);
+            this.hiSentTo.delete(link);
+        }
+        this.connected.delete(peerId);
+        this.outbox.delete(peerId);
+        this.lastHeard.delete(peerId);
+        this.rate.delete(peerId);
+        this.lockstep.onPeerLeft(peerId);
+        this.chat.onPeerLeft(peerId);
+        this.voice.onPeerLeft(peerId);
+        if (peer)
+            this.emit("peerLeft", peer, reason);
+        if (peerId === this.hostPeerId && !this.isHost) {
+            this.handleHostLost(reason);
+        }
+    }
+    dropPeer(peerId, reason) {
+        this.signaling.send({ t: "kick", peerId });
+        this.removePeer(peerId, reason);
+    }
+    setPhase(p) {
+        if (p !== "lobby" && p !== "in_game")
+            return;
+        if (this.phase === p)
+            return;
+        this.phase = p;
+        if (p === "in_game" && !this.lockstep.started)
+            this.lockstep.markStarted();
+        this.emit("phase", p);
+    }
+    onServerClosed() {
+        if (this.ended)
+            return;
+        if (this.cfg.direct && !this.isHost) {
+            this.teardown("host_left");
+            return;
+        }
+        this.serverUp = false;
+        this.emit("serverLost");
+        // Alone with no peers: nothing keeps this session alive.
+        if (this.links.size === 0 && this.roster.size <= 1)
+            this.teardown("server_lost");
+    }
+    // ---- housekeeping ----------------------------------------------------------------------------------------------
+    watchdog() {
+        if (this.ended)
+            return;
+        const timeout = this.cfg.peerTimeoutMs ?? 0;
+        if (timeout > 0)
+            this.dropSilent(Math.max(timeout, MIN_PEER_TIMEOUT_MS));
+        if (this.ended || this.isHost)
+            return;
+        if (this.mode === "lockstep" && this.lockstep.hostSilent()) {
+            this.lockstep.touch();
+            this.lockstep.pokeHost(); // a live-but-stalled host answers with a snapshot; a dead one is replaced below
+            this.handleHostLost("timeout");
+        }
+    }
+    /** peerTimeoutMs: the host drops joiners it has not heard from; a joiner handles a silent host as lost. */
+    dropSilent(timeout) {
+        const now = this.cfg.clock.now();
+        if (this.isHost) {
+            for (const id of [...this.connected]) {
+                const last = this.lastHeard.get(id);
+                if (last !== undefined && now - last > timeout)
+                    this.removePeer(id, "timeout");
+            }
+        }
+        else if (this.isReady) {
+            const last = this.lastHeard.get(this.hostPeerId);
+            if (last !== undefined && now - last > timeout) {
+                this.lastHeard.delete(this.hostPeerId);
+                this.handleHostLost("timeout");
+            }
+        }
+    }
+    pingHost() {
+        if (this.ended || this.isHost)
+            return;
+        this.sendTo(this.hostPeerId, { type: "ping", n: ++this.pingN, t: this.cfg.clock.now() >>> 0 }, 0, "fast");
+    }
+    teardown(reason) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.cancelReadyTimer?.();
+        if (!this.isReady) {
+            const code = reason === "ice_failed" || reason === "kicked" ? reason : "closed";
+            this.failReady(new OneLobbyError(code, `the lobby ended before connecting (${reason})`));
+        }
+        this.cancelWatchdog?.();
+        this.cancelPing?.();
+        this.lockstep.stop();
+        this.voice.close();
+        for (const l of this.links.values()) {
+            l.onClose = null;
+            l.onMessage = null;
+            l.close();
+        }
+        this.links.clear();
+        this.signaling.onClose = null;
+        this.signaling.onMessage = null;
+        this.signaling.close();
+        this.emit("sessionEnded", reason);
+    }
+    /** Total in-flight links (diagnostics and tests). */
+    get linkCount() {
+        return this.links.size;
+    }
+}
+export { PROTO };
+//# sourceMappingURL=lobby.js.map