minimojs 1.0.0-alpha.35 → 1.0.0-alpha.37

package/dist/minimo-multiplayer.js

@@ -0,0 +1,1310 @@
+/**
+ * What a room promise is refused with. `reason` is one of:
+ * `unavailable` (not on Minimo Games, or the game's creator is not on Pro),
+ * `cancelled` (the player closed the lobby), `room_not_found`, `full`,
+ * `in_progress`, `removed`, `not_your_turn`, `stale` (another change came
+ * first; read the room again and retry), `not_host`, `wrong_phase`,
+ * `not_enough_players`, `state_too_large`, `closed`, or another the room
+ * names.
+ */
+export class MultiplayerError extends Error {
+    constructor(message, reason) {
+        super(message);
+        this.name = "MultiplayerError";
+        this.reason = reason;
+    }
+}
+const HOST_TIMEOUT_MS = 1500;
+const REQUEST_TIMEOUT_MS = 20000;
+const pendingRequests = new Map();
+const eventListeners = new Set();
+let nextRequestId = 1;
+let listening = false;
+let hostPromise = null;
+function parentWindow() {
+    try {
+        return typeof window !== "undefined" && window.parent && window.parent !== window ? window.parent : null;
+    }
+    catch {
+        return null;
+    }
+}
+function listen() {
+    if (listening || typeof window === "undefined")
+        return;
+    listening = true;
+    window.addEventListener("message", (event) => {
+        if (event.source !== parentWindow())
+            return;
+        const message = event.data;
+        if (!message || typeof message !== "object")
+            return;
+        if (message.type === "minimo:multiplayer-event") {
+            for (const listener of [...eventListeners])
+                listener(message);
+            return;
+        }
+        if (message.type !== "minimo:multiplayer-response" || typeof message.id !== "string")
+            return;
+        const pending = pendingRequests.get(message.id);
+        if (!pending)
+            return;
+        pendingRequests.delete(message.id);
+        if (message.ok)
+            pending.resolve(message.result);
+        else
+            pending.reject(new MultiplayerError(message.error || "The room did not answer", message.reason || "error"));
+    });
+}
+function request(action, payload, timeoutMs = REQUEST_TIMEOUT_MS) {
+    const parent = parentWindow();
+    if (!parent)
+        return Promise.reject(new MultiplayerError("Multiplayer works only on Minimo Games", "unavailable"));
+    listen();
+    const id = `multiplayer-${nextRequestId++}`;
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            pendingRequests.delete(id);
+            reject(new MultiplayerError("The room did not answer", "timeout"));
+        }, timeoutMs);
+        pendingRequests.set(id, {
+            resolve: (value) => { clearTimeout(timer); resolve(value); },
+            reject: (error) => { clearTimeout(timer); reject(error); },
+        });
+        parent.postMessage({ type: "minimo:multiplayer-request", id, action, ...payload }, "*");
+    });
+}
+function connectHost() {
+    hostPromise ?? (hostPromise = request("hello", {}, HOST_TIMEOUT_MS)
+        .then((info) => (info && info.host === "minimo-games" ? info : null))
+        .catch(() => null));
+    return hostPromise;
+}
+// ---------------------------------------------------------------------------
+// Seeded randomness, the same on every player's device for the same seed.
+/** @internal mulberry32: small, fast, and good enough for shuffles and levels. */
+export function seededRandom(seed) {
+    let state = seed >>> 0;
+    return () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let value = state;
+        value = Math.imul(value ^ (value >>> 15), value | 1);
+        value ^= value + Math.imul(value ^ (value >>> 7), value | 61);
+        return ((value ^ (value >>> 14)) >>> 0) / 4294967296;
+    };
+}
+// ---------------------------------------------------------------------------
+// The lobby, the strip, and the results, drawn over the game in HTML.
+const STYLE_ID = "minimo-multiplayer-style";
+const STYLE = `
+.minimo-mp{position:fixed;z-index:2147483000;display:flex;align-items:center;justify-content:center;box-sizing:border-box;
+  background:rgba(0,0,0,.55);-webkit-user-select:none;user-select:none;touch-action:manipulation}
+.minimo-mp *{box-sizing:border-box}
+.minimo-mp-panel{display:flex;flex-direction:column;gap:.7em;width:min(92%,26em);max-height:94%;overflow-y:auto;padding:1.1em;border-radius:.9em;
+  background:var(--mmp-bg);color:var(--mmp-fg);font-family:var(--mmp-font);box-shadow:0 .6em 2em rgba(0,0,0,.5);text-align:center}
+.minimo-mp h2{margin:0;color:var(--mmp-accent);font-size:1.35em;font-weight:700}
+.minimo-mp p{margin:0}
+.minimo-mp-muted{opacity:.7;font-size:.85em}
+.minimo-mp-error{color:#ff8f8f;font-size:.85em}
+.minimo-mp button{padding:.55em 1em;border:.08em solid currentColor;border-radius:999px;background:none;color:inherit;font:inherit;
+  font-size:.9em;cursor:pointer}
+.minimo-mp button:disabled{opacity:.45;cursor:default}
+.minimo-mp .minimo-mp-primary{border-color:var(--mmp-accent);background:var(--mmp-accent);color:var(--mmp-bg);font-weight:700}
+.minimo-mp-row{display:flex;gap:.5em;justify-content:center;flex-wrap:wrap}
+.minimo-mp input{flex:1 1 6em;min-width:0;padding:.5em .6em;border:.08em solid currentColor;border-radius:.4em;background:rgba(255,255,255,.08);
+  color:inherit;font:inherit;font-size:max(16px,.95em);text-align:center}
+.minimo-mp-code-input{text-transform:uppercase;letter-spacing:.2em}
+.minimo-mp-code{margin:0;color:var(--mmp-accent);font-size:2.2em;font-weight:800;letter-spacing:.18em;font-variant-numeric:tabular-nums}
+.minimo-mp-qr{align-self:center;width:8.5em;height:8.5em;border-radius:.4em;background:#fff}
+.minimo-mp-link{word-break:break-all;font-size:.75em;opacity:.75}
+.minimo-mp-players{margin:0;padding:0;list-style:none;text-align:left}
+.minimo-mp-player{display:flex;align-items:center;gap:.55em;padding:.35em .5em;border-radius:.4em}
+.minimo-mp-player:nth-child(odd){background:rgba(255,255,255,.06)}
+.minimo-mp-player.is-me{color:var(--mmp-accent);font-weight:700}
+.minimo-mp-dot{flex:0 0 .55em;height:.55em;border-radius:50%;background:#59d38c}
+.minimo-mp-dot.is-away{background:#888}
+.minimo-mp-name{flex:1 1 auto;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.minimo-mp-tag{flex:0 0 auto;font-size:.75em;opacity:.75}
+.minimo-mp-score{flex:0 0 auto;font-variant-numeric:tabular-nums}
+.minimo-mp-player button{padding:.15em .55em;font-size:.75em}
+.minimo-mp-strip{position:fixed;z-index:2147482999;display:flex;align-items:flex-start;justify-content:center;box-sizing:border-box;
+  pointer-events:none;font-family:var(--mmp-font)}
+.minimo-mp-strip-bar{display:flex;align-items:center;gap:.6em;margin-top:.4em;padding:.3em .8em;border-radius:999px;
+  background:rgba(0,0,0,.6);color:#fff;font-size:.8em;pointer-events:auto}
+.minimo-mp-strip-bar.is-mine{background:var(--mmp-accent);color:var(--mmp-bg);font-weight:700}
+.minimo-mp-strip-bar button{padding:.1em .6em;border:.08em solid currentColor;border-radius:999px;background:none;color:inherit;font:inherit;cursor:pointer}
+`;
+function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[char]);
+}
+function defaultFormat(score) {
+    return Number.isInteger(score) ? score.toLocaleString() : score.toLocaleString(undefined, { maximumFractionDigits: 3 });
+}
+function ensureStyle() {
+    if (document.getElementById(STYLE_ID))
+        return;
+    const style = document.createElement("style");
+    style.id = STYLE_ID;
+    style.textContent = STYLE;
+    document.head.appendChild(style);
+}
+function hoursLeft(until) {
+    if (!until)
+        return "";
+    const ms = Date.parse(until) - Date.now();
+    if (!(ms > 0))
+        return "";
+    const minutes = Math.ceil(ms / 60000);
+    return minutes >= 120 ? `${Math.round(minutes / 60)} h` : `${minutes} min`;
+}
+/** @internal */
+export function renderLobbyHtml(screen, view) {
+    const parts = [];
+    const title = (text) => parts.push(`<h2>${escapeHtml(text)}</h2>`);
+    const error = (text) => {
+        if (text)
+            parts.push(`<p class="minimo-mp-error" role="alert">${escapeHtml(text)}</p>`);
+    };
+    const players = (room, showScores) => {
+        parts.push('<ul class="minimo-mp-players">');
+        const list = showScores ? [...room.players].sort((a, b) => rankOf(room, a) - rankOf(room, b)) : room.players;
+        for (const player of list) {
+            const tags = [];
+            if (player.host)
+                tags.push("host");
+            if (!player.connected)
+                tags.push("away");
+            parts.push(`<li class="minimo-mp-player${player.me ? " is-me" : ""}">`
+                + `<span class="minimo-mp-dot${player.connected ? "" : " is-away"}" aria-hidden="true"></span>`
+                + `<span class="minimo-mp-name">${escapeHtml(player.name)}${player.me ? " (you)" : ""}</span>`
+                + (tags.length ? `<span class="minimo-mp-tag">${tags.join(" · ")}</span>` : "")
+                + (showScores ? `<span class="minimo-mp-score">${player.score === null ? (room.mode === "competition" && room.phase === "playing" ? "playing…" : "—") : escapeHtml(view.format(player.score))}</span>` : "")
+                + (!showScores && room.isHost && !player.me ? `<button type="button" data-remove="${escapeHtml(player.id)}" aria-label="Remove ${escapeHtml(player.name)}">Remove</button>` : "")
+                + "</li>");
+        }
+        parts.push("</ul>");
+    };
+    const share = (room) => {
+        parts.push(`<p class="minimo-mp-muted">Room code</p><p class="minimo-mp-code">${escapeHtml(room.code)}</p>`);
+        // Hidden if it does not load, rather than shown as a broken image.
+        if (room.qrUrl)
+            parts.push(`<img class="minimo-mp-qr" src="${escapeHtml(room.qrUrl)}" alt="QR code of the room's link" onerror="this.hidden=true">`);
+        parts.push(`<p class="minimo-mp-link">${escapeHtml(room.link)}</p>`);
+        parts.push('<div class="minimo-mp-row"><button type="button" data-copy>Copy link</button></div>');
+    };
+    parts.push(`<div class="minimo-mp-panel" role="dialog" aria-modal="true" aria-label="${escapeHtml(view.title)}">`);
+    switch (screen.kind) {
+        case "unavailable":
+        case "closed":
+            title(screen.kind === "closed" ? "Room closed" : view.title);
+            parts.push(`<p>${escapeHtml(screen.message)}</p>`);
+            parts.push('<div class="minimo-mp-row"><button type="button" class="minimo-mp-primary" data-close>OK</button></div>');
+            break;
+        case "name":
+            title(view.title);
+            parts.push("<p>Your name, shown to the other players and in leaderboards.</p>");
+            // Not a <form>: a game's frame on Minimo Games is sandboxed without forms.
+            parts.push(`<div class="minimo-mp-row" data-name-form><input name="name" maxlength="24" placeholder="Your name" aria-label="Your name" autocomplete="nickname" value="${escapeHtml(screen.name)}"></div>`);
+            error(screen.error);
+            parts.push('<div class="minimo-mp-row"><button type="button" data-close>Cancel</button><button type="button" class="minimo-mp-primary" data-save-name>Continue</button></div>');
+            break;
+        case "menu":
+            title(view.title);
+            if (screen.name) {
+                parts.push(`<p class="minimo-mp-muted">Playing as ${escapeHtml(screen.name)}${screen.account ? "" : ' · <button type="button" data-rename>Change</button>'}</p>`);
+            }
+            parts.push(`<div class="minimo-mp-row"><button type="button" class="minimo-mp-primary" data-create${screen.busy ? " disabled" : ""}>Create a room</button></div>`);
+            parts.push('<p class="minimo-mp-muted">or join a friend\'s room</p>');
+            parts.push(`<div class="minimo-mp-row" data-join-form><input class="minimo-mp-code-input" name="code" maxlength="5" placeholder="CODE" aria-label="Room code" autocomplete="off" autocapitalize="characters" spellcheck="false" value="${escapeHtml(screen.code)}">`
+                + `<button type="button" data-join${screen.busy ? " disabled" : ""}>Join</button></div>`);
+            error(screen.error);
+            parts.push('<div class="minimo-mp-row"><button type="button" data-close>Close</button></div>');
+            break;
+        case "waiting": {
+            const room = screen.room;
+            title(view.title);
+            share(room);
+            players(room, false);
+            error(screen.error);
+            if (room.phase === "playing") {
+                // A challenge runs from the start; a player joins and plays at once.
+                const left = hoursLeft(room.deadline ? room.deadline.toISOString() : null);
+                if (left)
+                    parts.push(`<p class="minimo-mp-muted">The challenge ends in ${left}.</p>`);
+                parts.push('<div class="minimo-mp-row"><button type="button" data-leave>Leave</button><button type="button" class="minimo-mp-primary" data-play>Play</button></div>');
+            }
+            else if (room.isHost) {
+                const enough = room.players.length >= room.minPlayers;
+                if (!enough)
+                    parts.push(`<p class="minimo-mp-muted">Waiting for players: at least ${room.minPlayers}.</p>`);
+                parts.push(`<div class="minimo-mp-row"><button type="button" data-leave>Leave</button><button type="button" class="minimo-mp-primary" data-start${enough ? "" : " disabled"}>Start</button></div>`);
+            }
+            else {
+                parts.push('<p class="minimo-mp-muted">Waiting for the host to start.</p>');
+                parts.push('<div class="minimo-mp-row"><button type="button" data-leave>Leave</button></div>');
+            }
+            break;
+        }
+        case "results": {
+            const room = screen.room;
+            title(view.resultsTitle);
+            if (room.mode === "competition" && room.phase === "playing") {
+                const left = hoursLeft(room.deadline ? room.deadline.toISOString() : null);
+                parts.push(`<p class="minimo-mp-muted">${room.challengeHours !== null ? `Results so far${left ? ` · the challenge ends in ${left}` : ""}` : "Waiting for the others to finish…"}</p>`);
+            }
+            players(room, true);
+            error(screen.error);
+            const buttons = ['<button type="button" data-leave>Leave</button>'];
+            if (room.challengeHours !== null && room.phase === "playing") {
+                buttons.push('<button type="button" data-copy>Copy link</button>');
+            }
+            else if (room.isHost && room.phase === "playing") {
+                buttons.push('<button type="button" data-end-round>End round</button>');
+            }
+            else if (room.isHost && room.phase === "finished") {
+                buttons.push('<button type="button" class="minimo-mp-primary" data-rematch>Play again</button>');
+            }
+            else if (room.phase === "finished") {
+                parts.push('<p class="minimo-mp-muted">Waiting for the host to play again.</p>');
+            }
+            parts.push(`<div class="minimo-mp-row">${buttons.join("")}</div>`);
+            break;
+        }
+    }
+    parts.push("</div>");
+    return parts.join("");
+}
+function rankOf(room, player) {
+    const result = room.results?.find((entry) => entry.id === player.id);
+    return result ? result.rank : 1000 + player.seat;
+}
+/** @internal The strip's text, apart from the page. */
+export function renderStripHtml(room) {
+    if (room.phase !== "playing" || room.mode !== "turns")
+        return "";
+    const turn = room.players.find((player) => player.id === room.turn) ?? null;
+    const away = room.players.filter((player) => !player.connected);
+    const parts = [];
+    if (!room.connected) {
+        parts.push("Reconnecting…");
+    }
+    else if (turn) {
+        parts.push(turn.me ? "Your turn" : `${escapeHtml(turn.name)}'s turn`);
+    }
+    if (away.length > 0 && room.connected) {
+        parts.push(`${away.map((player) => escapeHtml(player.name)).join(", ")} dropped out`);
+    }
+    const skip = room.isHost && turn && !turn.me && !turn.connected ? ' <button type="button" data-skip>Skip</button>' : "";
+    return `<div class="minimo-mp-strip-bar${turn?.me && room.connected ? " is-mine" : ""}" role="status">${parts.join(" · ")}${skip}</div>`;
+}
+/** An element laid over the game's canvas, following it as the page resizes. */
+function overGame(game, className, style) {
+    ensureStyle();
+    const root = document.createElement("div");
+    root.className = className;
+    root.style.setProperty("--mmp-bg", style.background);
+    root.style.setProperty("--mmp-fg", style.color);
+    root.style.setProperty("--mmp-accent", style.accent);
+    root.style.setProperty("--mmp-font", style.font);
+    const canvas = game.getCanvasElement();
+    const place = () => {
+        const rect = canvas.getBoundingClientRect();
+        root.style.left = `${rect.left}px`;
+        root.style.top = `${rect.top}px`;
+        root.style.width = `${rect.width}px`;
+        root.style.height = `${rect.height}px`;
+        root.style.fontSize = `${Math.max(12, Math.min(22, rect.width / 22))}px`;
+    };
+    place();
+    // Keys typed into the lobby, such as a name or a code, must not reach the game.
+    const stopKeys = (event) => event.stopPropagation();
+    root.addEventListener("keydown", stopKeys);
+    root.addEventListener("keyup", stopKeys);
+    window.addEventListener("resize", place);
+    document.body.appendChild(root);
+    return {
+        root,
+        remove: () => {
+            window.removeEventListener("resize", place);
+            root.remove();
+        },
+    };
+}
+async function copyText(text) {
+    try {
+        await navigator.clipboard.writeText(text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ---------------------------------------------------------------------------
+// A room.
+/**
+ * A room the player is in: its players, its phase, its shared state, the
+ * player's private state, and whose turn it is. Every field reads the room as
+ * the player last received it.
+ *
+ * Changes made by the other players arrive between frames, and the listeners
+ * given to {@link Room.onChange} and {@link Room.onMessage} are called inside
+ * the game's loop, before the scene's `onUpdate`, so a game never sees the room
+ * change halfway through a frame. A change the player makes themselves is in
+ * the room when its promise resolves.
+ *
+ * Get a room from {@link Multiplayer.lobby}, {@link Multiplayer.create}, or
+ * {@link Multiplayer.join}.
+ */
+export class Room {
+    /** @internal */
+    constructor(game, owner, snapshot, linkBase) {
+        /** @internal */ this._connected = true;
+        /** @internal */ this._closed = null;
+        /** @internal */ this._random = null;
+        /** @internal */ this._randomSeed = null;
+        /** @internal */ this._changeListeners = new Set();
+        /** @internal */ this._messageListeners = new Set();
+        /** @internal */ this._closeListeners = new Set();
+        /** @internal */ this._watchers = new Set();
+        /** @internal */ this._queue = [];
+        /** @internal */ this._flushScheduledAt = 0;
+        this._game = game;
+        this._owner = owner;
+        this._snapshot = snapshot;
+        this._link = linkBase;
+    }
+    /** The room's code, such as `KQ7XA`, which friends type to join. */
+    get code() {
+        return this._snapshot.code;
+    }
+    /** The address that opens the game straight into this room. */
+    get link() {
+        try {
+            const url = new URL(this._link);
+            url.searchParams.set("room", this.code);
+            return url.href;
+        }
+        catch {
+            return `${this._link}?room=${this.code}`;
+        }
+    }
+    /** @internal An image of the link's QR code, drawn by Minimo Games. */
+    get qrUrl() {
+        try {
+            const url = new URL(this._link);
+            return `${url.origin}/multiplayer/qr.svg?link=${encodeURIComponent(this.link)}`;
+        }
+        catch {
+            return null;
+        }
+    }
+    get mode() {
+        return this._snapshot.mode;
+    }
+    get phase() {
+        return this._snapshot.phase;
+    }
+    /** Grows each time the room starts a new round: 1 for the first. */
+    get round() {
+        return this._snapshot.round;
+    }
+    /** The players in the room, by seat. */
+    get players() {
+        return this._snapshot.players.map((player) => ({ ...player, me: player.id === this._snapshot.me }));
+    }
+    /** The player playing on this device. */
+    get me() {
+        return this.players.find((player) => player.me) ?? {
+            id: this._snapshot.me, name: "", seat: -1, host: false, connected: false, finished: false, score: null, me: true,
+        };
+    }
+    /** Whether the player on this device is the room's host. */
+    get isHost() {
+        return this._snapshot.host === this._snapshot.me;
+    }
+    /** The id of the player whose turn it is, or `null`. */
+    get turn() {
+        return this._snapshot.turn;
+    }
+    /** Whether it is the turn of the player on this device. */
+    get isMyTurn() {
+        return this._snapshot.turn !== null && this._snapshot.turn === this._snapshot.me;
+    }
+    /**
+     * Whether the player on this device can change the state now: on their
+     * turn, or, when no one has the turn, if they are the host.
+     */
+    get canUpdate() {
+        return this.phase === "playing" && (this._snapshot.turn ?? this._snapshot.host) === this._snapshot.me;
+    }
+    /** The shared state every player receives, or `null` before anyone writes one. */
+    get state() {
+        return this._snapshot.state;
+    }
+    /** This player's private state, which no other player receives, or `null`. */
+    get mine() {
+        return this._snapshot.mine;
+    }
+    /** The state's version, which grows with every change. */
+    get version() {
+        return this._snapshot.version;
+    }
+    /** The round's seed, the same for every player, or `null` before the first round. */
+    get seed() {
+        return this._snapshot.seed;
+    }
+    /** When a competition's round, or a challenge, ends, or `null`. */
+    get deadline() {
+        return this._snapshot.deadlineAt ? new Date(this._snapshot.deadlineAt) : null;
+    }
+    /** The fewest players who can start. */
+    get minPlayers() {
+        return this._snapshot.options.minPlayers;
+    }
+    /** The most players the room seats. */
+    get maxPlayers() {
+        return this._snapshot.options.maxPlayers;
+    }
+    /** For an asynchronous challenge, how many hours it runs; otherwise `null`. */
+    get challengeHours() {
+        return this._snapshot.options.challengeHours;
+    }
+    /**
+     * The results, best first: in a competition, the players who have finished
+     * so far; in a game by turns, the scores given to {@link Room.end}. `null`
+     * when there are none.
+     */
+    get results() {
+        return this._snapshot.results?.map((result) => ({ ...result, me: result.id === this._snapshot.me })) ?? null;
+    }
+    /** Whether the player's connection to the room is up. It reconnects on its own. */
+    get connected() {
+        return this._connected && this._closed === null;
+    }
+    /** Whether the room has closed, or the player left it. */
+    get closed() {
+        return this._closed !== null;
+    }
+    /** @internal Why the room closed: `"closed"`, `"removed"`, or `"left"`. */
+    get _closedReason() {
+        return this._closed;
+    }
+    /**
+     * A random number from 0 up to 1, from the round's seed: every player who
+     * calls it in the same order gets the same numbers, so they can deal the
+     * same deck or build the same level. It starts again at each round.
+     */
+    random() {
+        const seed = this._snapshot.seed ?? 0;
+        if (this._random === null || this._randomSeed !== seed) {
+            this._random = seededRandom(seed);
+            this._randomSeed = seed;
+        }
+        return this._random();
+    }
+    /** A shuffled copy of `items`, from the round's seed, as {@link Room.random} is. */
+    shuffle(items) {
+        const copy = [...items];
+        for (let index = copy.length - 1; index > 0; index -= 1) {
+            const other = Math.floor(this.random() * (index + 1));
+            [copy[index], copy[other]] = [copy[other], copy[index]];
+        }
+        return copy;
+    }
+    /** The player with this id, or `null`. */
+    player(id) {
+        return this.players.find((player) => player.id === id) ?? null;
+    }
+    /**
+     * Calls `listener` whenever the room changes: a player joins or leaves, the
+     * state or the turn changes, the phase moves on. It runs inside the game's
+     * loop. Returns a function that stops it.
+     */
+    onChange(listener) {
+        this._changeListeners.add(listener);
+        return () => this._changeListeners.delete(listener);
+    }
+    /**
+     * Calls `listener` for each message another player sends with
+     * {@link Room.send}. It runs inside the game's loop. Returns a function that
+     * stops it.
+     */
+    onMessage(listener) {
+        this._messageListeners.add(listener);
+        return () => this._messageListeners.delete(listener);
+    }
+    /**
+     * Calls `listener` once when the room closes, the player is removed, or the
+     * player leaves. `reason` is `"closed"`, `"removed"`, or `"left"`.
+     */
+    onClose(listener) {
+        this._closeListeners.add(listener);
+        return () => this._closeListeners.delete(listener);
+    }
+    /** @internal Watchers redraw the lobby and the strip at once, outside the loop. */
+    _watch(watcher) {
+        this._watchers.add(watcher);
+        return () => this._watchers.delete(watcher);
+    }
+    /** @internal */
+    _apply(snapshot) {
+        if (snapshot.code !== this._snapshot.code || snapshot.revision < this._snapshot.revision)
+            return false;
+        const changed = snapshot.revision !== this._snapshot.revision || JSON.stringify(snapshot.players) !== JSON.stringify(this._snapshot.players);
+        this._snapshot = snapshot;
+        if (changed) {
+            this._enqueue(() => {
+                for (const listener of [...this._changeListeners])
+                    listener(this);
+            });
+        }
+        this._notifyWatchers();
+        return changed;
+    }
+    /** @internal */
+    _setConnected(connected) {
+        if (this._connected === connected)
+            return;
+        this._connected = connected;
+        this._notifyWatchers();
+    }
+    /** @internal */
+    _message(kind, data, from) {
+        const player = this.player(from);
+        this._enqueue(() => {
+            for (const listener of [...this._messageListeners])
+                listener(kind, data, player);
+        });
+    }
+    /** @internal */
+    _close(reason) {
+        if (this._closed !== null)
+            return;
+        this._closed = reason;
+        this._notifyWatchers();
+        this._enqueue(() => {
+            for (const listener of [...this._closeListeners])
+                listener(reason);
+        });
+    }
+    /** @internal */
+    _notifyWatchers() {
+        for (const watcher of [...this._watchers])
+            watcher();
+    }
+    /**
+     * Runs `work` inside the game's loop: a timer of the game fires at the start
+     * of the next frame. `game.reset()` clears timers, so a flush that has not
+     * run for a while is scheduled again.
+     *
+     * @internal
+     */
+    _enqueue(work) {
+        this._queue.push(work);
+        const now = Date.now();
+        if (this._flushScheduledAt !== 0 && now - this._flushScheduledAt < 500)
+            return;
+        this._flushScheduledAt = now;
+        this._game.addTimer(0, false, () => {
+            this._flushScheduledAt = 0;
+            const queue = this._queue;
+            this._queue = [];
+            for (const item of queue) {
+                try {
+                    item();
+                }
+                catch (error) {
+                    console.error("[minimo-multiplayer] a room listener failed", error);
+                }
+            }
+        });
+    }
+    /** @internal */
+    async _act(payload) {
+        if (this._closed !== null)
+            throw new MultiplayerError("The room has closed", "closed");
+        const result = await request("act", { code: this.code, payload });
+        if (result.room)
+            this._apply(result.room);
+    }
+    /** Starts the game, as the host, once enough players are in. Every player's lobby closes. */
+    start() {
+        return this._act({ action: "start" });
+    }
+    /**
+     * Changes the room, on the player's turn or, when no one has the turn, as
+     * the host: the shared state, players' private states, and whose turn it
+     * is. It names the version it started from, and is refused with `stale` if
+     * another change came first.
+     *
+     * ```js
+     * await room.update({ state: { board }, turn: "next" });
+     * ```
+     */
+    update(changes) {
+        const payload = { action: "update", base: this.version };
+        if (Object.prototype.hasOwnProperty.call(changes, "state"))
+            payload.state = changes.state ?? null;
+        if (changes.private)
+            payload.private = changes.private;
+        if (changes.turn)
+            payload.turn = changes.turn;
+        return this._act(payload);
+    }
+    /**
+     * Ends a game by turns, on the player's turn or as the host. `scores`, by
+     * player id, become the results, ranked by the room's order; `state` is a
+     * last state to show, such as the final board.
+     */
+    end(scores, state) {
+        const payload = { action: "end" };
+        if (scores)
+            payload.results = scores;
+        if (state !== undefined)
+            payload.state = state;
+        return this._act(payload);
+    }
+    /**
+     * Reports the player's result in a competition's round. The round finishes
+     * when every player has reported, when its time limit passes, or when the
+     * host ends it.
+     */
+    finish(score) {
+        return this._act({ action: "finish", score: Number(score) });
+    }
+    /** Ends a competition's round now, as the host, with the results reported so far. */
+    endRound() {
+        return this._act({ action: "endRound" });
+    }
+    /** Passes the turn to the next player, as the host, such as when its player dropped out. */
+    skipTurn() {
+        return this._act({ action: "skip" });
+    }
+    /** Removes a player from the room, as the host. They cannot join it again. */
+    remove(playerId) {
+        return this._act({ action: "remove", player: playerId });
+    }
+    /**
+     * Plays again, as the host, once the room has finished: the room goes back
+     * to its lobby with the same players, or, for a challenge, starts a new
+     * round at once.
+     */
+    rematch() {
+        return this._act({ action: "rematch" });
+    }
+    /**
+     * Sends a message to the other players, which the room passes on and does
+     * not keep, such as a reaction. `kind` is a short name; `data` is plain
+     * JSON, at most 1 KB.
+     */
+    async send(kind, data = null) {
+        if (this._closed !== null)
+            throw new MultiplayerError("The room has closed", "closed");
+        await request("act", { code: this.code, payload: { action: "message", kind, data } });
+    }
+    /** Leaves the room. The others are told, and the turn and the host pass on. */
+    async leave() {
+        if (this._closed !== null)
+            return;
+        try {
+            await request("act", { code: this.code, payload: { action: "leave" } });
+        }
+        finally {
+            this._close("left");
+            this._owner._forget(this);
+        }
+    }
+    /** Resolves when the room's game starts, or at once if it is playing. */
+    waitForStart() {
+        if (this.phase === "playing")
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const stop = this._watch(() => {
+                if (this.phase === "playing") {
+                    stop();
+                    resolve();
+                }
+                else if (this._closed !== null) {
+                    stop();
+                    reject(new MultiplayerError("The room has closed", this._closed));
+                }
+            });
+        });
+    }
+    /**
+     * Shows the results over the game, in HTML, and keeps them up to date as
+     * players finish. The host can play again from it, or end a round still
+     * running. Resolves `"rematch"` when the next game starts, with the lobby
+     * shown while the players wait, or `"leave"` when the player leaves or the
+     * room closes.
+     */
+    showResults(options = {}) {
+        return this._owner._showResults(this, options);
+    }
+}
+// ---------------------------------------------------------------------------
+// The module's entry point.
+/**
+ * Multiplayer rooms for a game on Minimo Games: two to eight players, each on
+ * their own device, meet in a room by its code or its link, and play by turns
+ * on a small state the room keeps, or each play the same round of a
+ * competition and compare their scores. Nothing is synchronized frame by
+ * frame: it suits card games, board games, word games, and races against the
+ * clock, not action games.
+ *
+ * It works only inside Minimo Games, and only while the game's creator is on
+ * Minimo Games Pro. Players need no account: a guest types a name once.
+ *
+ * {@link Multiplayer.lobby} shows the lobby over the game, in HTML: creating a
+ * room, joining one by its code, sharing its link, and waiting for the others
+ * until the host starts. A player who opens the room's link lands in it.
+ *
+ * ```js
+ * import { Multiplayer } from "https://cdn.jsdelivr.net/npm/minimojs@<version>/dist/minimo-multiplayer.js";
+ *
+ * const mp = new Multiplayer(game, { mode: "turns", minPlayers: 2, maxPlayers: 4 });
+ * const room = await mp.lobby();        // resolves when the host starts
+ * if (room.isHost) await room.update({ state: deal(room.shuffle(deck)), turn: "next" });
+ * room.onChange(() => redraw(room.state, room.mine));
+ * // On the player's turn:
+ * if (room.isMyTurn) await room.update({ state: next, turn: "next" });
+ * // When someone wins:
+ * await room.end({ [winnerId]: 1 });
+ * const choice = await room.showResults(); // "rematch" or "leave"
+ * ```
+ *
+ * A game with its own welcome screen asks {@link Multiplayer.pendingRoom}
+ * first, so a player who opened a room's link, or reloaded the page in a
+ * room, goes straight to it instead of to the welcome screen:
+ *
+ * ```js
+ * const pending = await mp.pendingRoom();
+ * if (pending) room = await mp.lobby(); // that room's lobby, or its game in progress
+ * else showWelcome();                   // Play online, then mp.lobby() to create or join
+ * ```
+ */
+export class Multiplayer {
+    /**
+     * @param game - The game.
+     * @param options - How its rooms work, and how the lobby looks.
+     */
+    constructor(game, options = {}) {
+        /** @internal */ this._room = null;
+        /** @internal */ this._info = null;
+        /** @internal */ this._listening = false;
+        /** @internal */ this._overlay = null;
+        /** @internal */ this._closeOverlay = null;
+        /** @internal */ this._strip = null;
+        /** @internal */ this._stopStrip = null;
+        this._game = game;
+        this._options = { ...options };
+    }
+    /** The room the player is in, or `null`. */
+    get room() {
+        return this._room;
+    }
+    /**
+     * Whether multiplayer can be played here: inside Minimo Games, with the
+     * game's creator on Pro.
+     */
+    async available() {
+        const info = await connectHost();
+        return Boolean(info && info.available);
+    }
+    /** @internal */
+    _style() {
+        return {
+            font: this._options.font ?? 'system-ui, -apple-system, "Segoe UI", Roboto, sans-serif',
+            background: this._options.background ?? "#15151d",
+            color: this._options.color ?? "#ffffff",
+            accent: this._options.accent ?? "#ffcc33",
+        };
+    }
+    /** @internal */
+    _roomOptions() {
+        const { mode, minPlayers, maxPlayers, order, timeLimit, challengeHours, turnTimeout } = this._options;
+        const options = { mode: mode ?? "turns" };
+        if (minPlayers !== undefined)
+            options.minPlayers = minPlayers;
+        if (maxPlayers !== undefined)
+            options.maxPlayers = maxPlayers;
+        if (order !== undefined)
+            options.order = order;
+        if (timeLimit !== undefined)
+            options.timeLimit = timeLimit;
+        if (challengeHours !== undefined)
+            options.challengeHours = challengeHours;
+        if (turnTimeout !== undefined)
+            options.turnTimeout = turnTimeout;
+        return options;
+    }
+    /** @internal */
+    async _host() {
+        if (!(await connectHost()))
+            throw new MultiplayerError("Multiplayer works only on Minimo Games", "unavailable");
+        // Asked again each time: the room the player is in, and their name, change while the game runs.
+        const info = await request("hello", {}, HOST_TIMEOUT_MS * 2);
+        this._info = info;
+        if (!info.available) {
+            throw new MultiplayerError(info.preview ? "Multiplayer is part of Minimo Games Pro: this preview opens rooms once the game's creator is on Pro" : "Multiplayer is not available for this game", "unavailable");
+        }
+        if (!this._listening) {
+            this._listening = true;
+            listen();
+            eventListeners.add((event) => this._onEvent(event));
+        }
+        return info;
+    }
+    /** @internal */
+    _onEvent(event) {
+        const room = this._room;
+        if (!room)
+            return;
+        switch (event.event) {
+            case "room":
+                if (event.room.code === room.code)
+                    room._apply(event.room);
+                break;
+            case "message":
+                room._message(event.kind, event.data, event.from);
+                break;
+            case "connection":
+                room._setConnected(event.connected);
+                break;
+            case "closed":
+                room._close(event.reason === "removed" ? "removed" : "closed");
+                this._forget(room);
+                break;
+        }
+    }
+    /** @internal */
+    _forget(room) {
+        if (this._room === room) {
+            this._room = null;
+            this._removeStrip();
+        }
+    }
+    /** @internal */
+    _adopt(snapshot) {
+        if (this._room && this._room.code === snapshot.code && !this._room.closed) {
+            this._room._apply(snapshot);
+            return this._room;
+        }
+        const room = new Room(this._game, this, snapshot, this._info?.link ?? "");
+        this._room = room;
+        this._showStrip(room);
+        return room;
+    }
+    /** Creates a room, without the lobby. The player is its host. */
+    async create() {
+        await this._host();
+        const result = await request("create", { options: this._roomOptions() });
+        return this._adopt(result.room);
+    }
+    /** Joins a room by its code, without the lobby, or returns to one the player is in. */
+    async join(code) {
+        await this._host();
+        const result = await request("join", { code: String(code).trim().toUpperCase() });
+        return this._adopt(result.room);
+    }
+    /**
+     * The room this player is expected in, before any screen is shown: the room
+     * whose link they opened, an invitation, or the room they were in on this
+     * device before the page reloaded. `null` on a normal visit, outside
+     * Minimo Games, and when the game's creator is not on Pro.
+     *
+     * It opens nothing, joins nothing, and can be asked again: the room stays
+     * pending until the player is in it. {@link Multiplayer.lobby} then takes
+     * them straight into it. A room that has closed since, as an old link's,
+     * is still returned, and the lobby then says there is no room with that
+     * code.
+     */
+    async pendingRoom() {
+        if (this._room && !this._room.closed)
+            return { code: this._room.code, invited: false };
+        if (!(await connectHost()))
+            return null;
+        const info = await request("hello", {}, HOST_TIMEOUT_MS * 2).catch(() => null);
+        if (!info || !info.available || typeof info.roomCode !== "string")
+            return null;
+        const code = info.roomCode.trim().toUpperCase();
+        return /^[A-Z0-9]{5}$/.test(code) ? { code, invited: Boolean(info.fromLink) } : null;
+    }
+    /**
+     * The player's name on Minimo Games, the one leaderboards show, or `null`
+     * before they choose one.
+     */
+    async playerName() {
+        const info = await connectHost();
+        return info?.name ?? null;
+    }
+    /** @internal */
+    _closeLobby() {
+        this._closeOverlay?.();
+    }
+    /** @internal Shows `screen` in the overlay, creating it if needed. */
+    _render(screen, resultsTitle = "Results", format = defaultFormat) {
+        if (!this._overlay)
+            return;
+        this._overlay.root.innerHTML = renderLobbyHtml(screen, {
+            title: this._options.title ?? "Play with friends",
+            format,
+            resultsTitle,
+        });
+        const input = this._overlay.root.querySelector("input");
+        if (input && document.activeElement?.tagName !== "INPUT")
+            input.focus();
+    }
+    /**
+     * Shows the lobby over the game, in HTML, and resolves with the room when
+     * its game starts. The player chooses a name if they have none, creates a
+     * room or joins one by its code, shares its code and link with friends, and
+     * waits; the host starts once enough players are in. A player who opened the
+     * game from a room's link goes straight into that room, and one who reloads
+     * the page returns to theirs.
+     *
+     * Refused with `unavailable` outside Minimo Games or when the game's creator
+     * is not on Pro, after the lobby says so, and with `cancelled` when the
+     * player closes it.
+     */
+    async lobby() {
+        if (typeof document === "undefined" || !document.body) {
+            throw new MultiplayerError("Multiplayer needs a page to show its lobby", "unavailable");
+        }
+        this._closeLobby();
+        const overlay = overGame(this._game, "minimo-mp", this._style());
+        this._overlay = overlay;
+        return new Promise((resolve, reject) => {
+            let screen = { kind: "menu", name: null, account: false, error: null, busy: true, code: "" };
+            let stopWatching = null;
+            let settled = false;
+            let pendingError = null;
+            // A room's link opened by a player with no name yet: they choose one, then go in.
+            let pendingCode = null;
+            const finish = (room, error) => {
+                if (settled)
+                    return;
+                settled = true;
+                stopWatching?.();
+                overlay.remove();
+                if (this._overlay === overlay) {
+                    this._overlay = null;
+                    this._closeOverlay = null;
+                }
+                if (room)
+                    resolve(room);
+                else
+                    reject(error ?? new MultiplayerError("The lobby was closed", "cancelled"));
+            };
+            this._closeOverlay = () => finish(null);
+            const show = (next) => {
+                screen = next;
+                this._render(screen);
+            };
+            const menu = (error = null, code = "") => {
+                show({ kind: "menu", name: this._info?.name ?? null, account: Boolean(this._info?.account), error, busy: false, code });
+            };
+            const wait = (room) => {
+                stopWatching?.();
+                const redraw = () => {
+                    if (settled)
+                        return;
+                    if (room.closed) {
+                        stopWatching?.();
+                        show({ kind: "closed", message: room._closedReason === "removed" ? "You were removed from this room." : "The room has closed." });
+                        return;
+                    }
+                    // A game by turns starts for everyone at once; a challenge waits for the player's Play.
+                    if (room.phase === "playing" && room.challengeHours === null) {
+                        finish(room);
+                        return;
+                    }
+                    show({ kind: "waiting", room, error: screen.kind === "waiting" ? screen.error : null });
+                };
+                stopWatching = room._watch(redraw);
+                redraw();
+            };
+            const needsName = () => !this._info?.account && !this._info?.name;
+            const askAccountName = async () => {
+                if (this._info?.account && !this._info.name) {
+                    const answer = await request("setName", {}, 10 * 60 * 1000).catch(() => ({ name: null }));
+                    if (this._info)
+                        this._info.name = answer.name;
+                }
+            };
+            const enter = async (work) => {
+                if (needsName()) {
+                    show({ kind: "name", name: "", error: null });
+                    return;
+                }
+                if (screen.kind === "menu")
+                    show({ ...screen, busy: true, error: null });
+                try {
+                    await askAccountName();
+                    wait(await work());
+                }
+                catch (error) {
+                    const reason = error instanceof MultiplayerError ? error.reason : "error";
+                    menu(error instanceof Error ? friendlyError(reason, error.message) : "Something went wrong.");
+                }
+            };
+            overlay.root.addEventListener("click", (event) => {
+                const target = event.target;
+                if (!target)
+                    return;
+                const room = screen.kind === "waiting" ? screen.room : null;
+                if (target.closest("[data-close]")) {
+                    // After a room closes, the player is back at the menu, to make or join another.
+                    if (screen.kind === "closed")
+                        menu();
+                    else
+                        finish(null, pendingError ?? undefined);
+                }
+                else if (target.closest("[data-save-name]") || target.closest("[data-rename]")) {
+                    if (target.closest("[data-rename]")) {
+                        show({ kind: "name", name: this._info?.name ?? "", error: null });
+                        return;
+                    }
+                    const input = overlay.root.querySelector("[data-name-form] input");
+                    void request("setName", { name: input?.value ?? "" }).then((answer) => {
+                        if (!answer.name) {
+                            show({ kind: "name", name: input?.value ?? "", error: "Write a name of up to 24 characters." });
+                            return;
+                        }
+                        if (this._info)
+                            this._info.name = answer.name;
+                        menu();
+                        if (pendingCode) {
+                            const code = pendingCode;
+                            pendingCode = null;
+                            void enter(() => this.join(code));
+                        }
+                    }, () => show({ kind: "name", name: input?.value ?? "", error: "The name could not be saved." }));
+                }
+                else if (target.closest("[data-create]")) {
+                    void enter(() => this.create());
+                }
+                else if (target.closest("[data-join]")) {
+                    const input = overlay.root.querySelector("[data-join-form] input");
+                    const code = (input?.value ?? "").trim().toUpperCase();
+                    if (!/^[A-Z0-9]{5}$/.test(code)) {
+                        menu("Type the 5 letters and digits of the room's code.", code);
+                        return;
+                    }
+                    void enter(() => this.join(code));
+                }
+                else if (room && target.closest("[data-start]")) {
+                    room.start().catch((error) => show({ kind: "waiting", room, error: friendlyError(error.reason, error.message) }));
+                }
+                else if (room && target.closest("[data-play]")) {
+                    finish(room);
+                }
+                else if (room && target.closest("[data-leave]")) {
+                    stopWatching?.();
+                    void room.leave().catch(() => undefined).then(() => menu());
+                }
+                else if (room && target.closest("[data-remove]")) {
+                    const id = target.closest("[data-remove]")?.getAttribute("data-remove");
+                    if (id)
+                        room.remove(id).catch(() => undefined);
+                }
+                else if (room && target.closest("[data-copy]")) {
+                    void copyText(room.link).then((copied) => {
+                        const button = overlay.root.querySelector("[data-copy]");
+                        if (button)
+                            button.textContent = copied ? "Copied" : "Copy failed";
+                    });
+                }
+            });
+            overlay.root.addEventListener("keydown", (event) => {
+                if (event.key === "Escape" && screen.kind !== "waiting")
+                    finish(null, pendingError ?? undefined);
+                else if (event.key === "Enter") {
+                    const target = event.target;
+                    if (target?.closest("[data-name-form]"))
+                        overlay.root.querySelector("[data-save-name]")?.click();
+                    else if (target?.closest("[data-join-form]"))
+                        overlay.root.querySelector("[data-join]")?.click();
+                }
+            });
+            this._render(screen);
+            void (async () => {
+                let info;
+                try {
+                    info = await this._host();
+                }
+                catch (error) {
+                    pendingError = error instanceof MultiplayerError ? error : new MultiplayerError("Multiplayer is not available", "unavailable");
+                    show({ kind: "unavailable", message: pendingError.message });
+                    return;
+                }
+                // Already in a room on this device, as after a reload, or arriving by a room's link.
+                if (this._room && !this._room.closed) {
+                    wait(this._room);
+                    return;
+                }
+                if (info.roomCode) {
+                    if (needsName()) {
+                        pendingCode = info.roomCode;
+                        show({ kind: "name", name: "", error: null });
+                        return;
+                    }
+                    try {
+                        await askAccountName();
+                        wait(await this.join(info.roomCode));
+                        return;
+                    }
+                    catch (error) {
+                        const reason = error instanceof MultiplayerError ? error.reason : "error";
+                        menu(info.fromLink ? friendlyError(reason, error.message) : null);
+                        // A room that is gone is not tried again.
+                        void request("forget", {}).catch(() => undefined);
+                        return;
+                    }
+                }
+                if (needsName()) {
+                    show({ kind: "name", name: "", error: null });
+                    return;
+                }
+                menu();
+            })();
+        });
+    }
+    /** @internal */
+    _showResults(room, options) {
+        if (typeof document === "undefined" || !document.body)
+            return Promise.resolve("leave");
+        this._closeLobby();
+        const overlay = overGame(this._game, "minimo-mp", this._style());
+        this._overlay = overlay;
+        const format = options.format ?? defaultFormat;
+        const title = options.title ?? "Results";
+        const startRound = room.round;
+        return new Promise((resolve) => {
+            let settled = false;
+            let error = null;
+            const finish = (choice) => {
+                if (settled)
+                    return;
+                settled = true;
+                stop();
+                overlay.remove();
+                if (this._overlay === overlay) {
+                    this._overlay = null;
+                    this._closeOverlay = null;
+                }
+                resolve(choice);
+            };
+            this._closeOverlay = () => finish("leave");
+            const redraw = () => {
+                if (settled)
+                    return;
+                if (room.closed) {
+                    this._render({ kind: "closed", message: "The room has closed." });
+                    return;
+                }
+                if (room.round > startRound && room.phase === "playing" && room.challengeHours === null) {
+                    finish("rematch");
+                    return;
+                }
+                if (room.phase === "lobby" || (room.round > startRound && room.phase === "playing")) {
+                    this._render({ kind: "waiting", room, error });
+                    return;
+                }
+                this._render({ kind: "results", room, error }, title, format);
+            };
+            const stop = room._watch(redraw);
+            overlay.root.addEventListener("click", (event) => {
+                const target = event.target;
+                if (!target)
+                    return;
+                const fail = (reason, message) => {
+                    error = friendlyError(reason, message);
+                    redraw();
+                };
+                if (target.closest("[data-close]"))
+                    finish("leave");
+                else if (target.closest("[data-leave]"))
+                    void room.leave().catch(() => undefined).then(() => finish("leave"));
+                else if (target.closest("[data-rematch]"))
+                    room.rematch().catch((e) => fail(e.reason, e.message));
+                else if (target.closest("[data-start]"))
+                    room.start().catch((e) => fail(e.reason, e.message));
+                else if (target.closest("[data-play]"))
+                    finish("rematch");
+                else if (target.closest("[data-end-round]"))
+                    room.endRound().catch((e) => fail(e.reason, e.message));
+                else if (target.closest("[data-remove]")) {
+                    const id = target.closest("[data-remove]")?.getAttribute("data-remove");
+                    if (id)
+                        room.remove(id).catch(() => undefined);
+                }
+                else if (target.closest("[data-copy]")) {
+                    void copyText(room.link).then((copied) => {
+                        const button = overlay.root.querySelector("[data-copy]");
+                        if (button)
+                            button.textContent = copied ? "Copied" : "Copy failed";
+                    });
+                }
+            });
+            redraw();
+        });
+    }
+    /** @internal */
+    _showStrip(room) {
+        this._removeStrip();
+        if (this._options.strip === false || typeof document === "undefined" || !document.body)
+            return;
+        const strip = overGame(this._game, "minimo-mp-strip", this._style());
+        this._strip = strip;
+        const redraw = () => {
+            const html = renderStripHtml(room);
+            if (strip.root.innerHTML !== html)
+                strip.root.innerHTML = html;
+        };
+        strip.root.addEventListener("click", (event) => {
+            if (event.target?.closest("[data-skip]"))
+                room.skipTurn().catch(() => undefined);
+        });
+        this._stopStrip = room._watch(redraw);
+        redraw();
+    }
+    /** @internal */
+    _removeStrip() {
+        this._stopStrip?.();
+        this._stopStrip = null;
+        this._strip?.remove();
+        this._strip = null;
+    }
+    /** Closes the lobby or the results, if showing. The room is kept. */
+    close() {
+        this._closeLobby();
+    }
+    /** Closes the lobby and the strip. The player stays in their room; call {@link Room.leave} to leave it. */
+    destroy() {
+        this._closeLobby();
+        this._removeStrip();
+    }
+}
+function friendlyError(reason, message) {
+    switch (reason) {
+        case "room_not_found":
+            return "There is no room with this code.";
+        case "full":
+            return "This room is full.";
+        case "in_progress":
+            return "This room's game has already started.";
+        case "removed":
+            return "You were removed from this room.";
+        case "not_enough_players":
+            return message;
+        case "too_many_rooms":
+        case "room_limit":
+        case "rate_limited":
+            return message;
+        case "unavailable":
+            return message;
+        default:
+            return message || "Something went wrong.";
+    }
+}