onelobby 0.0.0-stage → 0.2.0

package/dist/onelobby.global.js

@@ -0,0 +1,3897 @@
+/*! onelobby 0.2.0 | MIT license */
+"use strict";
+var OneLobby = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/global.ts
+  var global_exports = {};
+  __export(global_exports, {
+    CHAT_MAX_BYTES: () => CHAT_MAX_BYTES,
+    Chat: () => Chat,
+    DEFAULT_READY_TIMEOUT_MS: () => DEFAULT_READY_TIMEOUT_MS,
+    Keepalive: () => Keepalive,
+    KeepaliveError: () => KeepaliveError,
+    LIB_NAME: () => LIB_NAME,
+    LIB_VERSION: () => LIB_VERSION,
+    LOBBY_TAG: () => LOBBY_TAG,
+    Lobby: () => Lobby,
+    LobbyController: () => LobbyController,
+    Lockstep: () => Lockstep,
+    MIN_PEER_TIMEOUT_MS: () => MIN_PEER_TIMEOUT_MS,
+    OneLobby: () => OneLobby,
+    OneLobbyError: () => OneLobbyError,
+    SharedState: () => SharedState,
+    Voice: () => Voice,
+    closeCodeFor: () => closeCodeFor,
+    codeFromUrl: () => codeFromUrl,
+    decodeJoinCode: () => decodeJoinCode,
+    defineLobbyElement: () => defineLobbyElement,
+    describeError: () => describeError,
+    formatCode: () => formatCode,
+    lobbyServerUrl: () => lobbyServerUrl,
+    looksLikeJoinCode: () => looksLikeJoinCode,
+    normalizeCode: () => normalizeCode,
+    shareUrl: () => shareUrl,
+    webCodecsOpusAvailable: () => webCodecsOpusAvailable,
+    webRtcLinkFactoryFor: () => webRtcLinkFactoryFor
+  });
+
+  // src/clock.ts
+  function workerInterval(fn, ms) {
+    if (typeof Worker === "undefined" || typeof Blob === "undefined" || typeof URL === "undefined" || !URL.createObjectURL) {
+      return null;
+    }
+    try {
+      const src = `let h=0;onmessage=e=>{if(e.data&&e.data.start){h=setInterval(()=>postMessage(0),e.data.ms)}else{clearInterval(h);close()}}`;
+      const url = URL.createObjectURL(new Blob([src], { type: "text/javascript" }));
+      const w = new Worker(url);
+      URL.revokeObjectURL(url);
+      w.onmessage = () => fn();
+      w.postMessage({ start: true, ms });
+      return () => {
+        w.postMessage({ stop: true });
+        w.terminate();
+      };
+    } catch {
+      return null;
+    }
+  }
+  var systemClock = {
+    now: () => typeof performance !== "undefined" ? performance.now() : Date.now(),
+    setInterval(fn, ms) {
+      const w = workerInterval(fn, ms);
+      if (w) return w;
+      const h = setInterval(fn, ms);
+      return () => clearInterval(h);
+    },
+    setTimeout(fn, ms) {
+      const h = setTimeout(fn, ms);
+      return () => clearTimeout(h);
+    }
+  };
+
+  // src/emitter.ts
+  var Emitter = class {
+    handlers = /* @__PURE__ */ new Map();
+    on(event, fn) {
+      let list = this.handlers.get(event);
+      if (!list) this.handlers.set(event, list = []);
+      list.push(fn);
+      return () => this.off(event, fn);
+    }
+    off(event, fn) {
+      const list = this.handlers.get(event);
+      if (!list) return;
+      const i = list.indexOf(fn);
+      if (i >= 0) list.splice(i, 1);
+    }
+    emit(event, ...args) {
+      const list = this.handlers.get(event);
+      if (!list) return;
+      for (const fn of [...list]) {
+        try {
+          fn(...args);
+        } catch (e) {
+          queueMicrotask(() => {
+            throw e;
+          });
+        }
+      }
+    }
+  };
+
+  // src/crockford.ts
+  var CROCKFORD_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+  var CODE_LENGTH = 6;
+  function asciiUpper(s) {
+    return s.replace(/[a-z]/g, (c) => c.toUpperCase());
+  }
+  function normalizeCode(input) {
+    const s = asciiUpper(input).replace(/[ \-]/g, "").replace(/[IL]/g, "1").replace(/O/g, "0");
+    if (s.length !== CODE_LENGTH) return null;
+    for (const ch of s) if (CROCKFORD_ALPHABET.indexOf(ch) < 0) return null;
+    return s;
+  }
+  function formatCode(code) {
+    const c = normalizeCode(code) ?? code.toUpperCase();
+    return c.length === CODE_LENGTH ? `${c.slice(0, 3)} ${c.slice(3)}` : c;
+  }
+
+  // src/codec.ts
+  var MAX_FRAME_BYTES = 16 * 1024;
+  var MAX_REASSEMBLED_BYTES = 64 * 1024 * 1024;
+  var HEADER_BYTES = 3;
+  var PROTO = 1;
+  var MsgType = {
+    hi: 1,
+    welcome_dc: 2,
+    cmd: 16,
+    frame: 17,
+    hash: 18,
+    desync: 19,
+    snapshot_req: 20,
+    snapshot: 21,
+    chunk: 22,
+    raw: 32,
+    ping: 48,
+    pong: 49,
+    host_claim: 64,
+    voice: 80,
+    chat: 96,
+    chat_history: 97,
+    chat_reject: 98
+  };
+  var MODE_LOCKSTEP = 1;
+  var MODE_RAW = 2;
+  var CodecError = class extends Error {
+    constructor(code, detail = "") {
+      super(detail ? `${code}: ${detail}` : code);
+      this.code = code;
+      this.name = "CodecError";
+    }
+    code;
+  };
+  var enc = new TextEncoder();
+  var dec = new TextDecoder("utf-8", { fatal: true });
+  function decodeText(b) {
+    try {
+      return dec.decode(b);
+    } catch {
+      throw new CodecError("bad_utf8");
+    }
+  }
+  var Writer = class {
+    buf;
+    dv;
+    pos = 0;
+    constructor(size) {
+      this.buf = new Uint8Array(size);
+      this.dv = new DataView(this.buf.buffer);
+    }
+    ensure(n) {
+      if (this.pos + n <= this.buf.length) return;
+      const nb = new Uint8Array(Math.max(this.buf.length * 2, this.pos + n));
+      nb.set(this.buf);
+      this.buf = nb;
+      this.dv = new DataView(nb.buffer);
+    }
+    u8(v) {
+      this.ensure(1);
+      this.dv.setUint8(this.pos, v);
+      this.pos += 1;
+    }
+    u16(v) {
+      this.ensure(2);
+      this.dv.setUint16(this.pos, v, true);
+      this.pos += 2;
+    }
+    u32(v) {
+      this.ensure(4);
+      this.dv.setUint32(this.pos, v >>> 0, true);
+      this.pos += 4;
+    }
+    i64(v) {
+      this.ensure(8);
+      this.dv.setBigInt64(this.pos, BigInt(v), true);
+      this.pos += 8;
+    }
+    u64(v) {
+      this.ensure(8);
+      this.dv.setBigUint64(this.pos, BigInt.asUintN(64, v), true);
+      this.pos += 8;
+    }
+    bytes(b) {
+      this.ensure(b.length);
+      this.buf.set(b, this.pos);
+      this.pos += b.length;
+    }
+    done() {
+      return this.buf.slice(0, this.pos);
+    }
+  };
+  var Reader = class {
+    constructor(buf) {
+      this.buf = buf;
+      this.dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    buf;
+    dv;
+    pos = 0;
+    need(n) {
+      if (this.pos + n > this.buf.length) throw new CodecError("too_short", "truncated frame");
+    }
+    u8() {
+      this.need(1);
+      const v = this.dv.getUint8(this.pos);
+      this.pos += 1;
+      return v;
+    }
+    u16() {
+      this.need(2);
+      const v = this.dv.getUint16(this.pos, true);
+      this.pos += 2;
+      return v;
+    }
+    u32() {
+      this.need(4);
+      const v = this.dv.getUint32(this.pos, true);
+      this.pos += 4;
+      return v;
+    }
+    i64() {
+      this.need(8);
+      const v = this.dv.getBigInt64(this.pos, true);
+      this.pos += 8;
+      return Number(v);
+    }
+    u64() {
+      this.need(8);
+      const v = this.dv.getBigUint64(this.pos, true);
+      this.pos += 8;
+      return v;
+    }
+    bytes(n) {
+      this.need(n);
+      const v = this.buf.slice(this.pos, this.pos + n);
+      this.pos += n;
+      return v;
+    }
+    rest() {
+      const v = this.buf.slice(this.pos);
+      this.pos = this.buf.length;
+      return v;
+    }
+  };
+  function encodeMessage(msg, route = 0, allowOversize = false) {
+    const w = new Writer(64);
+    w.u8(MsgType[msg.type]);
+    w.u16(route);
+    switch (msg.type) {
+      case "hi":
+        w.u8(msg.proto);
+        w.u16(msg.peerId);
+        w.i64(msg.lastTick);
+        break;
+      case "welcome_dc":
+        w.i64(msg.tick);
+        w.u8(msg.tickRate);
+        w.u8(msg.mode);
+        w.u16(msg.hostId);
+        break;
+      case "cmd":
+        w.u32(msg.seq);
+        w.u16(msg.bytes.length);
+        w.bytes(msg.bytes);
+        break;
+      case "frame":
+        w.i64(msg.tick);
+        w.u16(msg.commands.length);
+        for (const c of msg.commands) {
+          w.u16(c.peerId);
+          w.u16(c.bytes.length);
+          w.bytes(c.bytes);
+        }
+        break;
+      case "hash":
+        w.i64(msg.tick);
+        w.u64(msg.hash);
+        break;
+      case "desync":
+        w.i64(msg.tick);
+        w.u64(msg.hostHash);
+        w.u64(msg.yourHash);
+        break;
+      case "snapshot_req":
+        w.i64(msg.sinceTick);
+        break;
+      case "snapshot":
+        w.i64(msg.tick);
+        w.u32(msg.total);
+        w.u8(msg.flags);
+        break;
+      case "chunk":
+        w.u32(msg.id);
+        w.u16(msg.index);
+        w.u16(msg.count);
+        w.bytes(msg.bytes);
+        break;
+      case "raw":
+        w.bytes(msg.bytes);
+        break;
+      case "ping":
+      case "pong":
+        w.u32(msg.n);
+        w.u32(msg.t);
+        break;
+      case "host_claim":
+        w.u16(msg.epoch);
+        w.u16(msg.hostId);
+        w.i64(msg.tick);
+        break;
+      case "voice":
+        w.u16(msg.seq);
+        w.u8(msg.flags);
+        w.u8(msg.frames.length);
+        for (const f of msg.frames) {
+          w.u16(f.length);
+          w.bytes(f);
+        }
+        break;
+      case "chat": {
+        const t = enc.encode(msg.text);
+        w.u32(msg.id);
+        w.i64(msg.ts);
+        w.u16(t.length);
+        w.bytes(t);
+        break;
+      }
+      case "chat_history":
+        w.u16(msg.lines.length);
+        for (const l of msg.lines) {
+          const t = enc.encode(l.text);
+          w.u16(l.peerId);
+          w.u32(l.id);
+          w.i64(l.ts);
+          w.u16(t.length);
+          w.bytes(t);
+        }
+        break;
+      case "chat_reject":
+        w.u32(msg.id);
+        w.u8(msg.reason);
+        break;
+    }
+    const out = w.done();
+    if (!allowOversize && out.length > MAX_FRAME_BYTES) throw new CodecError("too_long", `${out.length} > ${MAX_FRAME_BYTES}`);
+    return out;
+  }
+  var TYPE_BY_ID = new Map(
+    Object.keys(MsgType).map((k) => [MsgType[k], k])
+  );
+  function decodeMessage(buf, reassembled = false) {
+    const max = reassembled ? MAX_REASSEMBLED_BYTES : MAX_FRAME_BYTES;
+    if (buf.length > max) throw new CodecError("too_long", `${buf.length} > ${max}`);
+    if (buf.length < HEADER_BYTES) throw new CodecError("too_short", "header");
+    const r = new Reader(buf);
+    const type = TYPE_BY_ID.get(r.u8());
+    const route = r.u16();
+    if (!type) return null;
+    let msg;
+    switch (type) {
+      case "hi":
+        msg = { type, proto: r.u8(), peerId: r.u16(), lastTick: r.i64() };
+        break;
+      case "welcome_dc":
+        msg = { type, tick: r.i64(), tickRate: r.u8(), mode: r.u8(), hostId: r.u16() };
+        break;
+      case "cmd": {
+        const seq = r.u32();
+        msg = { type, seq, bytes: r.bytes(r.u16()) };
+        break;
+      }
+      case "frame": {
+        const tick = r.i64();
+        const n = r.u16();
+        const commands = [];
+        for (let i = 0; i < n; i++) {
+          const peerId = r.u16();
+          commands.push({ peerId, bytes: r.bytes(r.u16()) });
+        }
+        msg = { type, tick, commands };
+        break;
+      }
+      case "hash":
+        msg = { type, tick: r.i64(), hash: r.u64() };
+        break;
+      case "desync":
+        msg = { type, tick: r.i64(), hostHash: r.u64(), yourHash: r.u64() };
+        break;
+      case "snapshot_req":
+        msg = { type, sinceTick: r.i64() };
+        break;
+      case "snapshot":
+        msg = { type, tick: r.i64(), total: r.u32(), flags: r.u8() };
+        break;
+      case "chunk":
+        msg = { type, id: r.u32(), index: r.u16(), count: r.u16(), bytes: r.rest() };
+        break;
+      case "raw":
+        msg = { type, bytes: r.rest() };
+        break;
+      case "ping":
+      case "pong":
+        msg = { type, n: r.u32(), t: r.u32() };
+        break;
+      case "host_claim":
+        msg = { type, epoch: r.u16(), hostId: r.u16(), tick: r.i64() };
+        break;
+      case "voice": {
+        const seq = r.u16();
+        const flags = r.u8();
+        const n = r.u8();
+        const frames = [];
+        for (let i = 0; i < n; i++) frames.push(r.bytes(r.u16()));
+        msg = { type, seq, flags, frames };
+        break;
+      }
+      case "chat": {
+        const id = r.u32();
+        const ts = r.i64();
+        msg = { type, id, ts, text: decodeText(r.bytes(r.u16())) };
+        break;
+      }
+      case "chat_history": {
+        const n = r.u16();
+        const lines = [];
+        for (let i = 0; i < n; i++) {
+          const peerId = r.u16();
+          const id = r.u32();
+          const ts = r.i64();
+          lines.push({ peerId, id, ts, text: decodeText(r.bytes(r.u16())) });
+        }
+        msg = { type, lines };
+        break;
+      }
+      case "chat_reject":
+        msg = { type, id: r.u32(), reason: r.u8() };
+        break;
+    }
+    if (r.pos !== buf.length) throw new CodecError("trailing", `${buf.length - r.pos} extra bytes`);
+    return { route, msg };
+  }
+  var CHAT_REJECT = { rate: 1, length: 2, mutedByHost: 3 };
+  function chatRejectName(code) {
+    return code === 1 ? "rate" : code === 2 ? "length" : code === 3 ? "muted_by_host" : "unknown";
+  }
+
+  // src/chat.ts
+  var CHAT_MAX_BYTES = 256;
+  var CHAT_BURST = 3;
+  var CHAT_WINDOW_MS = 5e3;
+  var CHAT_PER_WINDOW = 5;
+  var CHAT_HISTORY_LINES = 100;
+  var STRIP = /[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/g;
+  function sanitizeChat(text) {
+    return text.replace(STRIP, "");
+  }
+  function utf8Length(text) {
+    return new TextEncoder().encode(text).length;
+  }
+  var ChatLimiter = class {
+    buckets = /* @__PURE__ */ new Map();
+    refillMs = CHAT_WINDOW_MS / CHAT_PER_WINDOW;
+    tryTake(peerId, now) {
+      let b = this.buckets.get(peerId);
+      if (!b) this.buckets.set(peerId, b = { tokens: CHAT_BURST, at: now });
+      b.tokens = Math.min(CHAT_BURST, b.tokens + (now - b.at) / this.refillMs);
+      b.at = now;
+      if (b.tokens < 1) return false;
+      b.tokens -= 1;
+      return true;
+    }
+    forget(peerId) {
+      this.buckets.delete(peerId);
+    }
+  };
+  var Chat = class extends Emitter {
+    constructor(hub, wall, isLocallyMuted) {
+      super();
+      this.hub = hub;
+      this.wall = wall;
+      this.isLocallyMuted = isLocallyMuted;
+    }
+    hub;
+    wall;
+    isLocallyMuted;
+    /** Game-provided profanity hook; applied to every line a player is shown. */
+    filter = (t) => t;
+    lines = [];
+    limiter = new ChatLimiter();
+    hostMuted = /* @__PURE__ */ new Set();
+    localId = 0;
+    stampId = 0;
+    get history() {
+      return this.lines;
+    }
+    /** Returns the local message id (what `rejected` will refer to). */
+    send(text) {
+      const id = ++this.localId >>> 0;
+      if (utf8Length(text) > CHAT_MAX_BYTES * 4) {
+        queueMicrotask(() => this.emit("rejected", id, "length"));
+        return id;
+      }
+      if (this.hub.isHost) this.hostProcess(this.hub.localPeerId, id, text);
+      else this.hub.sendToHost({ type: "chat", id, ts: 0, text });
+      return id;
+    }
+    /** Host only: drop a peer's chat for everyone (`chat_reject` reason 3). */
+    hostMute(peerId, muted) {
+      if (!this.hub.isHost) throw new Error("only the host can mute chat");
+      if (muted) this.hostMuted.add(peerId);
+      else this.hostMuted.delete(peerId);
+    }
+    isHostMuted(peerId) {
+      return this.hostMuted.has(peerId);
+    }
+    onPeerLeft(peerId) {
+      this.limiter.forget(peerId);
+      this.hostMuted.delete(peerId);
+    }
+    /** Host: send recent lines to a freshly connected peer. */
+    sendHistory(peerId) {
+      const lines = this.lines.slice(-CHAT_HISTORY_LINES).map((l) => ({ ...l }));
+      this.hub.sendTo(peerId, { type: "chat_history", lines }, 0);
+    }
+    handle(from, route, msg) {
+      switch (msg.type) {
+        case "chat":
+          if (this.hub.isHost) this.hostProcess(from, msg.id, msg.text);
+          else this.deliver({ peerId: route, id: msg.id, ts: msg.ts, text: msg.text });
+          break;
+        case "chat_history":
+          if (!this.hub.isHost) {
+            this.lines = [];
+            for (const l of msg.lines.slice(-CHAT_HISTORY_LINES)) this.push({ ...l, text: this.safeFilter(l.text) });
+            this.emit("history", this.lines);
+          }
+          break;
+        case "chat_reject":
+          this.emit("rejected", msg.id, chatRejectName(msg.reason));
+          break;
+      }
+    }
+    // ---- host path ----------------------------------------------------------------------------------------------
+    hostProcess(from, id, rawText) {
+      const reject = (code) => {
+        if (from === this.hub.localPeerId) this.emit("rejected", id, chatRejectName(code));
+        else this.hub.sendTo(from, { type: "chat_reject", id, reason: code }, 0);
+      };
+      if (this.hostMuted.has(from)) return reject(CHAT_REJECT.mutedByHost);
+      if (utf8Length(rawText) > CHAT_MAX_BYTES) return reject(CHAT_REJECT.length);
+      if (!this.limiter.tryTake(from, this.hub.clock.now())) return reject(CHAT_REJECT.rate);
+      const text = sanitizeChat(rawText);
+      if (text.length === 0) return;
+      const line = { peerId: from, id: ++this.stampId >>> 0, ts: this.wall(), text };
+      const out = { type: "chat", id: line.id, ts: line.ts, text: line.text };
+      for (const p of this.hub.connectedPeers()) this.hub.sendTo(p, out, from);
+      this.deliver(line);
+    }
+    deliver(line) {
+      const shown = { ...line, text: this.safeFilter(line.text) };
+      this.push(shown);
+      if (this.isLocallyMuted(line.peerId)) return;
+      this.emit("message", shown);
+    }
+    push(line) {
+      if (this.isLocallyMuted(line.peerId)) return;
+      this.lines.push(line);
+      if (this.lines.length > CHAT_HISTORY_LINES) this.lines.splice(0, this.lines.length - CHAT_HISTORY_LINES);
+    }
+    safeFilter(text) {
+      try {
+        return this.filter(text);
+      } catch {
+        return text;
+      }
+    }
+  };
+
+  // src/chunking.ts
+  var CHUNK_PAYLOAD = 16e3;
+  function splitChunks(id, bytes, size = CHUNK_PAYLOAD) {
+    const count = Math.max(1, Math.ceil(bytes.length / size));
+    if (count > 65535) throw new RangeError("payload needs more than 65535 chunks");
+    const out = [];
+    for (let i = 0; i < count; i++) {
+      out.push({
+        type: "chunk",
+        id,
+        index: i,
+        count,
+        bytes: bytes.subarray(i * size, Math.min(bytes.length, (i + 1) * size))
+      });
+    }
+    return out;
+  }
+  var Reassembler = class {
+    parts = /* @__PURE__ */ new Map();
+    /** Returns the full payload when the last chunk arrives, otherwise null. */
+    push(chunk) {
+      if (chunk.count === 0 || chunk.index >= chunk.count) return null;
+      let e = this.parts.get(chunk.id);
+      if (!e || e.count !== chunk.count) {
+        e = { count: chunk.count, got: 0, parts: new Array(chunk.count), bytes: 0 };
+        this.parts.set(chunk.id, e);
+      }
+      if (e.parts[chunk.index]) return null;
+      e.parts[chunk.index] = chunk.bytes;
+      e.got++;
+      e.bytes += chunk.bytes.length;
+      if (e.bytes > MAX_REASSEMBLED_BYTES) {
+        this.parts.delete(chunk.id);
+        throw new CodecError("too_long", `chunk set over ${MAX_REASSEMBLED_BYTES} bytes`);
+      }
+      if (e.got < e.count) return null;
+      this.parts.delete(chunk.id);
+      const out = new Uint8Array(e.bytes);
+      let pos = 0;
+      for (const p of e.parts) {
+        out.set(p, pos);
+        pos += p.length;
+      }
+      return out;
+    }
+    get pending() {
+      return this.parts.size;
+    }
+    clear() {
+      this.parts.clear();
+    }
+  };
+
+  // src/deflate.ts
+  function deflateAvailable() {
+    return typeof CompressionStream !== "undefined" && typeof DecompressionStream !== "undefined";
+  }
+  async function pipe(bytes, stream) {
+    const w = stream.writable.getWriter();
+    void w.write(bytes).then(() => w.close());
+    const chunks = [];
+    const r = stream.readable.getReader();
+    let total = 0;
+    for (; ; ) {
+      const { done, value } = await r.read();
+      if (done) break;
+      chunks.push(value);
+      total += value.length;
+    }
+    const out = new Uint8Array(total);
+    let pos = 0;
+    for (const c of chunks) {
+      out.set(c, pos);
+      pos += c.length;
+    }
+    return out;
+  }
+  function deflate(bytes) {
+    return pipe(bytes, new CompressionStream("deflate"));
+  }
+  function inflate(bytes) {
+    return pipe(bytes, new DecompressionStream("deflate"));
+  }
+
+  // src/lockstep.ts
+  var MAX_DESYNCS = 3;
+  var MAX_RESTORE_RETRIES = 3;
+  var HOST_SILENCE_MS = 3e3;
+  var PEER_HASH_SILENCE_MS = 1e4;
+  var SNAPSHOT_COMPRESS_MIN = 1024;
+  var Lockstep = class extends Emitter {
+    constructor(hub, opts) {
+      super();
+      this.hub = hub;
+      this.hashEveryTicks = Math.max(1, opts.hashEveryTicks);
+      this.historyMax = opts.historyFrames ?? Math.max(60, hub.tickRate * 30);
+      this.lastFrameRx = hub.clock.now();
+    }
+    hub;
+    snapshot = null;
+    restore = null;
+    hashEveryTicks;
+    /** Chunk body size used when serving snapshots. */
+    chunkSize = CHUNK_PAYLOAD;
+    historyMax;
+    queue = [];
+    history = [];
+    /** Highest frame tick received/emitted; -1 = no state (a fresh joiner). */
+    lastFrameTick = -1;
+    /** Tick of the state the game holds (last frame returned by nextFrame, or a restored snapshot). */
+    consumedTick = 0;
+    cmdSeq = 1;
+    awaitingSnapshot = false;
+    lastFrameRx = 0;
+    lastSnapshotReq = -Infinity;
+    restoreFailures = 0;
+    // host side
+    hosting = false;
+    _started = false;
+    pending = [];
+    ready = /* @__PURE__ */ new Set();
+    snapshotting = /* @__PURE__ */ new Set();
+    cancelTicker = null;
+    baseTime = 0;
+    emitted = 0;
+    ownHashes = /* @__PURE__ */ new Map();
+    peerHashes = /* @__PURE__ */ new Map();
+    desyncs = /* @__PURE__ */ new Map();
+    lastHashRx = /* @__PURE__ */ new Map();
+    /** Hashes a peer sent for ticks up to this were computed before it restored a snapshot: stale, not evidence. */
+    staleUpTo = /* @__PURE__ */ new Map();
+    // joiner side
+    pendingSnapshot = null;
+    // ---- public game-facing surface -------------------------------------------------------------------------------
+    get started() {
+      return this._started;
+    }
+    get framesBuffered() {
+      return this.queue.length;
+    }
+    /** True when the game should run ticks without rendering (> 2 frames behind). */
+    get catchingUp() {
+      return this.queue.length > 2;
+    }
+    /** Tick of the game's current state. */
+    get currentTick() {
+      return this.consumedTick;
+    }
+    /** Highest frame tick known to this peer (0 when none yet; the host's `welcome_dc.tick`). */
+    get lastTick() {
+      return Math.max(0, this.lastFrameTick);
+    }
+    /** What `hi.lastTick` carries: -1 until the first frame/snapshot. */
+    get hiTick() {
+      return this.lastFrameTick;
+    }
+    /** Queue a command. Host: into its own next frame. Joiner: to the host (reliable). */
+    submit(bytes) {
+      if (this.hosting) {
+        this.pending.push({ peerId: this.hub.localPeerId, bytes: bytes.slice() });
+      } else {
+        this.hub.sendToHost({ type: "cmd", seq: this.cmdSeq++ >>> 0, bytes });
+      }
+    }
+    nextFrame() {
+      const f = this.queue.shift() ?? null;
+      if (f) this.consumedTick = f.tick;
+      return f;
+    }
+    reportHash(tick, hash) {
+      if (this.awaitingSnapshot || tick <= 0 || tick % this.hashEveryTicks !== 0) return;
+      if (this.hosting) {
+        this.ownHashes.set(tick, hash);
+        this.prune(this.ownHashes);
+        const theirs = this.peerHashes.get(tick);
+        if (theirs) {
+          this.peerHashes.delete(tick);
+          for (const [peer, h] of [...theirs].sort((a, b) => a[0] - b[0])) this.compare(peer, tick, hash, h);
+        }
+      } else {
+        this.hub.sendToHost({ type: "hash", tick, hash });
+      }
+    }
+    // ---- role control (called by Lobby) ---------------------------------------------------------------------------
+    /** Host role without emitting yet (lobby phase): peers may already say hi. */
+    hostIdle() {
+      this.hosting = true;
+      if (this.lastFrameTick < 0) this.lastFrameTick = 0;
+    }
+    /** Host begins emitting frames (game start, or after winning a migration), continuing after the last known tick. */
+    hostStart() {
+      this.hostIdle();
+      this._started = true;
+      this.emitted = 0;
+      this.baseTime = this.hub.clock.now();
+      this.cancelTicker?.();
+      const interval = 1e3 / this.hub.tickRate;
+      this.cancelTicker = this.hub.clock.setInterval(() => this.pump(interval), Math.max(1, Math.floor(interval / 2)));
+    }
+    /** Winning a migration: continue from our last received frame. Pending commands are lost by design. */
+    becomeHost() {
+      this.pending = [];
+      this.ready.clear();
+      this.snapshotting.clear();
+      this.ownHashes.clear();
+      this.peerHashes.clear();
+      this.desyncs.clear();
+      this.awaitingSnapshot = false;
+      this.hostIdle();
+      if (this._started) this.hostStart();
+    }
+    /** Losing a claim, or a new host appeared: stop emitting. Keep history; the new host decides replay vs snapshot. */
+    becomeJoiner() {
+      this.hosting = false;
+      this.cancelTicker?.();
+      this.cancelTicker = null;
+      this.pending = [];
+      this.ready.clear();
+      this.lastFrameRx = this.hub.clock.now();
+    }
+    /** A joiner just learned the session is in game (first frame, snapshot, or phase from the server). */
+    markStarted() {
+      if (this._started) return;
+      this._started = true;
+      this.emit("started");
+    }
+    stop() {
+      this.cancelTicker?.();
+      this.cancelTicker = null;
+    }
+    onPeerLeft(peerId) {
+      this.ready.delete(peerId);
+      this.snapshotting.delete(peerId);
+      this.desyncs.delete(peerId);
+      this.lastHashRx.delete(peerId);
+      this.staleUpTo.delete(peerId);
+      for (const m of this.peerHashes.values()) m.delete(peerId);
+      this.pending = this.pending.filter((c) => c.peerId !== peerId);
+    }
+    // ---- host: frame emission ---------------------------------------------------------------------------------------
+    pump(interval) {
+      if (!this.hosting) return;
+      const now = this.hub.clock.now();
+      let due = Math.floor((now - this.baseTime + 1) / interval) - this.emitted;
+      if (due > 10) {
+        this.baseTime = now - this.emitted * interval;
+        due = 1;
+      }
+      for (let i = 0; i < due; i++) this.emitFrame();
+    }
+    emitFrame() {
+      const commands = this.pending.splice(0).sort((a, b) => a.peerId - b.peerId);
+      const frame = { tick: this.lastFrameTick + 1, commands };
+      this.emitted++;
+      this.lastFrameTick = frame.tick;
+      this.record(frame);
+      this.queue.push(frame);
+      const msg = { type: "frame", tick: frame.tick, commands };
+      for (const p of this.ready) this.hub.sendTo(p, msg, 0);
+      this.checkPeerSilence();
+    }
+    record(f) {
+      this.history.push(f);
+      if (this.history.length > this.historyMax) this.history.splice(0, this.history.length - this.historyMax);
+    }
+    /** The host drops a peer it has had no `hash` from for 10 s (scaled up when hashes are rare). */
+    checkPeerSilence() {
+      if (this.ownHashes.size === 0) return;
+      const now = this.hub.clock.now();
+      const limit = Math.max(PEER_HASH_SILENCE_MS, this.hashEveryTicks / this.hub.tickRate * 1e3 * 3);
+      for (const p of [...this.ready]) {
+        const last = this.lastHashRx.get(p) ?? now;
+        if (now - last > limit) this.hub.dropPeer(p, "timeout");
+      }
+    }
+    // ---- message handling -------------------------------------------------------------------------------------------
+    handle(from, msg) {
+      switch (msg.type) {
+        case "cmd":
+          if (this.hosting) this.pending.push({ peerId: from, bytes: msg.bytes });
+          break;
+        case "frame":
+          if (!this.hosting) this.onFrame(msg.tick, msg.commands);
+          break;
+        case "hash":
+          if (this.hosting) this.onPeerHash(from, msg.tick, msg.hash);
+          break;
+        case "desync":
+          if (!this.hosting) {
+            this.awaitingSnapshot = true;
+            this.queue = [];
+            this.emit("desync", { tick: msg.tick, hostHash: msg.hostHash, yourHash: msg.yourHash });
+          }
+          break;
+        case "snapshot_req":
+          if (this.hosting) void this.sendSnapshot(from);
+          break;
+        case "snapshot":
+          if (!this.hosting) {
+            this.markStarted();
+            this.pendingSnapshot = { tick: msg.tick, total: msg.total, flags: msg.flags };
+          }
+          break;
+      }
+    }
+    /** True when a `snapshot` header was seen and its chunk set has not completed yet. */
+    get snapshotPending() {
+      return this.pendingSnapshot !== null;
+    }
+    /** The reassembled chunk set that follows a `snapshot` header. */
+    onSnapshotPayload(payload) {
+      const ps = this.pendingSnapshot;
+      this.pendingSnapshot = null;
+      if (!ps) return;
+      if (payload.length !== ps.total) {
+        this.awaitingSnapshot = false;
+        this.requestSnapshot();
+        return;
+      }
+      void this.applySnapshot(ps, payload);
+    }
+    onFrame(tick, commands) {
+      this.lastFrameRx = this.hub.clock.now();
+      this.markStarted();
+      if (this.awaitingSnapshot) return;
+      const expected = Math.max(0, this.lastFrameTick) + 1;
+      if (tick < expected) return;
+      if (tick > expected) {
+        this.requestSnapshot();
+        return;
+      }
+      const f = { tick, commands };
+      this.lastFrameTick = tick;
+      this.record(f);
+      this.queue.push(f);
+      if (this.queue.length > this.hub.tickRate * 3) this.requestSnapshot();
+    }
+    /** Joiner asks the host for a snapshot (far behind, gap, silent host). Throttled while one is outstanding. */
+    requestSnapshot() {
+      const now = this.hub.clock.now();
+      if (this.awaitingSnapshot && now - this.lastSnapshotReq < 2e3) return;
+      this.lastSnapshotReq = now;
+      this.awaitingSnapshot = true;
+      this.queue = [];
+      this.hub.sendToHost({ type: "snapshot_req", sinceTick: this.lastFrameTick });
+    }
+    /** 3 s without frames: ask the host for a snapshot without discarding anything (a live host answers). */
+    pokeHost() {
+      this.hub.sendToHost({ type: "snapshot_req", sinceTick: this.lastFrameTick });
+    }
+    async applySnapshot(ps, payload) {
+      try {
+        let bytes = payload;
+        if (ps.flags & 1) bytes = await inflate(payload);
+        if (!this.restore) throw new Error("lockstep.restore is not set; cannot apply a snapshot");
+        this.restore(ps.tick, bytes);
+        this.queue = [];
+        this.history = [];
+        this.lastFrameTick = ps.tick;
+        this.consumedTick = ps.tick;
+        this.awaitingSnapshot = false;
+        this.restoreFailures = 0;
+        this.markStarted();
+        this.lastFrameRx = this.hub.clock.now();
+        this.emit("restored", ps.tick);
+      } catch (e) {
+        this.hub.reportError(e instanceof Error ? e : new Error(String(e)));
+        if (++this.restoreFailures <= MAX_RESTORE_RETRIES) {
+          this.awaitingSnapshot = false;
+          this.lastSnapshotReq = -Infinity;
+          this.requestSnapshot();
+        } else {
+          this.hub.reportError(new Error(`snapshot restore failed ${this.restoreFailures} times; giving up`));
+        }
+      }
+    }
+    // ---- host: hello, hashes, snapshots -----------------------------------------------------------------------------
+    /** Host: a peer said hi (welcome_dc and chat_history already sent). Decide: nothing, replay, or snapshot. */
+    onPeerHi(peerId, lastTick) {
+      this.lastHashRx.set(peerId, this.hub.clock.now());
+      const hostTick = this.lastFrameTick;
+      const first = this.history.length ? this.history[0].tick : hostTick + 1;
+      if (lastTick < 0) {
+        if (this._started && hostTick > 0) void this.sendSnapshot(peerId);
+        else this.ready.add(peerId);
+        return;
+      }
+      if (lastTick <= hostTick && lastTick + 1 >= first) {
+        for (const f of this.history) {
+          if (f.tick > lastTick) this.hub.sendTo(peerId, { type: "frame", tick: f.tick, commands: f.commands }, 0);
+        }
+        this.ready.add(peerId);
+      } else {
+        void this.sendSnapshot(peerId);
+      }
+    }
+    onPeerHash(peerId, tick, hash) {
+      this.lastHashRx.set(peerId, this.hub.clock.now());
+      if (this.isStale(peerId, tick)) return;
+      const own = this.ownHashes.get(tick);
+      if (own === void 0) {
+        let m = this.peerHashes.get(tick);
+        if (!m) this.peerHashes.set(tick, m = /* @__PURE__ */ new Map());
+        m.set(peerId, hash);
+        this.prune(this.peerHashes);
+        return;
+      }
+      this.compare(peerId, tick, own, hash);
+    }
+    compare(peerId, tick, hostHash, yourHash) {
+      if (hostHash === yourHash) return;
+      if (this.isStale(peerId, tick)) return;
+      if (!this.ready.has(peerId) || this.snapshotting.has(peerId)) return;
+      const n = (this.desyncs.get(peerId) ?? 0) + 1;
+      this.desyncs.set(peerId, n);
+      if (n >= MAX_DESYNCS) {
+        this.hub.dropPeer(peerId, "desync");
+        return;
+      }
+      this.hub.sendTo(peerId, { type: "desync", tick, hostHash, yourHash }, 0);
+      void this.sendSnapshot(peerId, tick);
+    }
+    /** Hashes computed before a peer restored its snapshot (ticks after the strike, up to what we had emitted) are not evidence. */
+    isStale(peerId, tick) {
+      const w = this.staleUpTo.get(peerId);
+      return !!w && tick > w.from && tick <= w.to;
+    }
+    async sendSnapshot(peerId, strikeTick = Infinity) {
+      if (this.snapshotting.has(peerId)) return;
+      if (!this.snapshot) {
+        this.hub.reportError(new Error("lockstep.snapshot is not set; cannot serve a snapshot"));
+        return;
+      }
+      this.snapshotting.add(peerId);
+      this.ready.delete(peerId);
+      try {
+        const S = this.consumedTick;
+        const raw = this.snapshot();
+        let payload = raw;
+        let flags = 0;
+        if (raw.length >= SNAPSHOT_COMPRESS_MIN && deflateAvailable()) {
+          payload = await deflate(raw);
+          flags = 1;
+        }
+        if (!this.snapshotting.has(peerId)) return;
+        this.hub.sendTo(peerId, { type: "snapshot", tick: S, total: payload.length, flags }, 0);
+        for (const c of splitChunks(this.hub.nextChunkId(), payload, this.chunkSize)) this.hub.sendTo(peerId, c, 0);
+        for (const f of this.history) {
+          if (f.tick > S) this.hub.sendTo(peerId, { type: "frame", tick: f.tick, commands: f.commands }, 0);
+        }
+        if (strikeTick !== Infinity) this.staleUpTo.set(peerId, { from: strikeTick, to: this.lastFrameTick });
+        else this.staleUpTo.delete(peerId);
+        for (const m of this.peerHashes.values()) m.delete(peerId);
+        this.ready.add(peerId);
+        this.lastHashRx.set(peerId, this.hub.clock.now());
+      } catch (e) {
+        this.hub.reportError(e instanceof Error ? e : new Error(String(e)));
+      } finally {
+        this.snapshotting.delete(peerId);
+      }
+    }
+    prune(m) {
+      if (m.size <= 64) return;
+      const keys = [...m.keys()].sort((a, b) => a - b);
+      for (const k of keys.slice(0, keys.length - 64)) m.delete(k);
+    }
+    // ---- joiner watchdog --------------------------------------------------------------------------------------------
+    /** Joiner: ms since the last frame from the host (only meaningful once in game). */
+    get msSinceFrame() {
+      return this.hub.clock.now() - this.lastFrameRx;
+    }
+    /** True when a started joiner has heard no frames for 3 s: the Lobby then runs the host-loss rule (s.9). */
+    hostSilent() {
+      return !this.hosting && this._started && this.msSinceFrame > HOST_SILENCE_MS;
+    }
+    /** Reset the silence timer, e.g. after the link to a new host opened. */
+    touch() {
+      this.lastFrameRx = this.hub.clock.now();
+    }
+    hiMessage(peerId) {
+      return { type: "hi", proto: PROTO, peerId, lastTick: this.lastFrameTick };
+    }
+    get resyncCount() {
+      return this.desyncs;
+    }
+  };
+
+  // src/migration.ts
+  function pickNewHost(connected, failedHost) {
+    let best = null;
+    for (const id of connected) {
+      if (id === failedHost) continue;
+      if (best === null || id < best) best = id;
+    }
+    return best;
+  }
+  function epochAfter(a, b) {
+    const d = a - b & 65535;
+    return d !== 0 && d < 32768;
+  }
+  function claimWinsWrapped(a, b) {
+    if (a.epoch !== b.epoch) return epochAfter(a.epoch, b.epoch);
+    return a.hostId < b.hostId;
+  }
+
+  // src/signaling.ts
+  var OneLobbyError = class extends Error {
+    constructor(code, message, data) {
+      super(message ? `${code}: ${message}` : code);
+      this.code = code;
+      this.data = data;
+      this.name = "OneLobbyError";
+    }
+    code;
+    data;
+  };
+  var PROTO_ID = "lk1";
+  var PING_EVERY_MS = 1e4;
+  var SILENCE_MS = 3e4;
+  var SignalingClient = class {
+    constructor(url, factory, clock) {
+      this.url = url;
+      this.factory = factory;
+      this.clock = clock;
+    }
+    url;
+    factory;
+    clock;
+    socket = null;
+    waiters = [];
+    lastRx = 0;
+    cancelPing = null;
+    pingN = 0;
+    closed = false;
+    onMessage = null;
+    onClose = null;
+    connect() {
+      return new Promise((resolve, reject) => {
+        let s;
+        try {
+          s = this.factory(this.url);
+        } catch (e) {
+          reject(new OneLobbyError("connect_failed", String(e)));
+          return;
+        }
+        this.socket = s;
+        s.onopen = () => {
+          this.lastRx = this.clock.now();
+          this.cancelPing = this.clock.setInterval(() => this.tick(), PING_EVERY_MS);
+          resolve();
+        };
+        s.onerror = () => {
+          if (!this.lastRx) reject(new OneLobbyError("connect_failed", `cannot reach ${this.url}`));
+        };
+        s.onmessage = (ev) => {
+          this.lastRx = this.clock.now();
+          let m;
+          try {
+            m = JSON.parse(String(ev.data));
+          } catch {
+            return;
+          }
+          if (!m || typeof m.t !== "string") return;
+          if (m.t === "ping") {
+            this.send({ t: "pong", n: m.n });
+            return;
+          }
+          if (m.t === "pong") return;
+          const i = this.waiters.findIndex((w) => w.types.includes(m.t) || m.t === "error");
+          if (i >= 0) {
+            const [w] = this.waiters.splice(i, 1);
+            if (m.t === "error") w.reject(errorFrom(m));
+            else w.resolve(m);
+            return;
+          }
+          this.onMessage?.(m);
+        };
+        s.onclose = () => {
+          if (!this.lastRx) reject(new OneLobbyError("connect_failed", `cannot reach ${this.url}`));
+          this.shutdown();
+        };
+      });
+    }
+    tick() {
+      if (this.clock.now() - this.lastRx > SILENCE_MS) {
+        this.socket?.close(4e3, "silence");
+        this.shutdown();
+        return;
+      }
+      this.send({ t: "ping", n: ++this.pingN });
+    }
+    shutdown() {
+      if (this.closed) return;
+      this.closed = true;
+      this.cancelPing?.();
+      const err = new OneLobbyError("closed", "signaling connection closed");
+      for (const w of this.waiters.splice(0)) w.reject(err);
+      this.onClose?.();
+    }
+    get isOpen() {
+      return !this.closed && this.socket !== null && this.socket.readyState === 1;
+    }
+    send(m) {
+      if (!this.isOpen) return;
+      this.socket.send(JSON.stringify(m));
+    }
+    /** Wait for the next message of one of `types`, or reject on `error`/close. */
+    expect(...types) {
+      if (this.closed) return Promise.reject(new OneLobbyError("closed", "signaling connection closed"));
+      return new Promise((resolve, reject) => {
+        this.waiters.push({ types, resolve, reject });
+      });
+    }
+    async request(m, ...types) {
+      const p = this.expect(...types);
+      this.send(m);
+      return p;
+    }
+    close() {
+      this.socket?.close(1e3, "bye");
+      this.shutdown();
+    }
+  };
+  function errorFrom(m) {
+    return new OneLobbyError(String(m.code ?? "error"), m.msg === void 0 ? void 0 : String(m.msg), m.data);
+  }
+
+  // src/voice-core.ts
+  var SAMPLE_RATE = 48e3;
+  var FRAME_MS = 20;
+  var FRAME_SAMPLES = SAMPLE_RATE * FRAME_MS / 1e3;
+  var FRAMES_PER_PACKET = 2;
+  var MAX_VOICE_PACKET_BYTES = 1024;
+  var MAX_SPEAKERS = 8;
+  var MAX_PACKETS_PER_SEC = 30;
+  var JITTER_MS = 60;
+  var VAD_HANGOVER_MS = 300;
+  var FLAG_END_OF_BURST = 1;
+  var VoicePacketizer = class {
+    constructor(framesPerPacket = FRAMES_PER_PACKET) {
+      this.framesPerPacket = framesPerPacket;
+    }
+    framesPerPacket;
+    seq = 0;
+    buf = [];
+    push(frame) {
+      this.buf.push(frame);
+      if (this.buf.length < this.framesPerPacket) return null;
+      return this.take(0);
+    }
+    /** Wrap already-encoded frames in the next packet (no batching). */
+    packet(frames, flags) {
+      const p = { seq: this.seq, flags, frames };
+      this.seq = this.seq + 1 & 65535;
+      return p;
+    }
+    /** Always emits a packet (possibly with zero frames) carrying the end-of-burst flag. */
+    endBurst() {
+      return this.take(FLAG_END_OF_BURST);
+    }
+    get buffered() {
+      return this.buf.length;
+    }
+    take(flags) {
+      const p = { seq: this.seq, flags, frames: this.buf };
+      this.seq = this.seq + 1 & 65535;
+      this.buf = [];
+      return p;
+    }
+  };
+  function rms(pcm) {
+    if (pcm.length === 0) return 0;
+    let s = 0;
+    for (let i = 0; i < pcm.length; i++) s += pcm[i] * pcm[i];
+    return Math.sqrt(s / pcm.length);
+  }
+  var VoiceGate = class {
+    mode = "pushToTalk";
+    ptt = false;
+    vadThreshold = 0.02;
+    lastLoud = -Infinity;
+    open = false;
+    /** Returns { send, edge } where edge is 'open' | 'close' | null on a transition. */
+    update(level, nowMs) {
+      let want;
+      if (this.mode === "pushToTalk") {
+        want = this.ptt;
+      } else {
+        if (level >= this.vadThreshold) this.lastLoud = nowMs;
+        want = nowMs - this.lastLoud <= VAD_HANGOVER_MS;
+      }
+      const edge = want === this.open ? null : want ? "open" : "close";
+      this.open = want;
+      return { send: want, edge };
+    }
+    get isOpen() {
+      return this.open;
+    }
+  };
+  function seqDiff(a, b) {
+    const d = a - b & 65535;
+    return d >= 32768 ? d - 65536 : d;
+  }
+  var JitterBuffer = class {
+    constructor(jitterMs = JITTER_MS, framesPerPacket = FRAMES_PER_PACKET) {
+      this.framesPerPacket = framesPerPacket;
+      this.prefillFrames = Math.max(1, Math.round(jitterMs / FRAME_MS));
+    }
+    framesPerPacket;
+    packets = /* @__PURE__ */ new Map();
+    expected = null;
+    ready = [];
+    playing = false;
+    endSeq = null;
+    waitTicks = 0;
+    prefillFrames;
+    push(p) {
+      if (this.expected === null) {
+        this.expected = p.seq;
+      } else if (seqDiff(p.seq, this.expected) < 0) {
+        return;
+      }
+      this.packets.set(p.seq, p);
+      if (p.flags & FLAG_END_OF_BURST) this.endSeq = p.seq;
+      else if (this.endSeq !== null && seqDiff(p.seq, this.endSeq) > 0) this.endSeq = null;
+    }
+    get ended() {
+      return this.endSeq !== null;
+    }
+    bufferedFrames() {
+      let n = this.ready.length;
+      for (const p of this.packets.values()) n += p.frames.length;
+      return n;
+    }
+    newerThanExpected() {
+      for (const s of this.packets.keys()) if (this.expected !== null && seqDiff(s, this.expected) > 0) return true;
+      return false;
+    }
+    pull() {
+      if (this.expected === null) return { kind: "idle" };
+      if (!this.playing) {
+        if (this.bufferedFrames() >= this.prefillFrames || this.ended && this.packets.size > 0) this.playing = true;
+        else return { kind: "wait" };
+      }
+      if (this.ready.length === 0) this.refill();
+      const f = this.ready.shift();
+      if (f) {
+        this.waitTicks = 0;
+        return f.length === 0 ? { kind: "plc" } : { kind: "frame", opus: f };
+      }
+      if (this.ended && this.packets.size === 0) {
+        this.reset();
+        return { kind: "idle" };
+      }
+      if (++this.waitTicks > 12) {
+        this.reset();
+        return { kind: "idle" };
+      }
+      return { kind: "wait" };
+    }
+    refill() {
+      if (this.expected === null) return;
+      const p = this.packets.get(this.expected);
+      if (p) {
+        this.packets.delete(this.expected);
+        this.expected = this.expected + 1 & 65535;
+        for (const fr of p.frames) this.ready.push(fr);
+        return;
+      }
+      if (this.newerThanExpected()) {
+        this.expected = this.expected + 1 & 65535;
+        for (let i = 0; i < this.framesPerPacket; i++) this.ready.push(new Uint8Array(0));
+      }
+    }
+    reset() {
+      this.packets.clear();
+      this.ready = [];
+      this.expected = null;
+      this.playing = false;
+      this.endSeq = null;
+      this.waitTicks = 0;
+    }
+    get active() {
+      return this.expected !== null;
+    }
+  };
+  var VoiceRelayPolicy = class {
+    speakers = /* @__PURE__ */ new Map();
+    // peerId -> last packet time
+    windows = /* @__PURE__ */ new Map();
+    /** A burst with no packet for this long counts as over even if its end flag was lost. */
+    burstTimeoutMs = 500;
+    accept(from, size, flags, now) {
+      if (size > MAX_VOICE_PACKET_BYTES) return false;
+      let w = this.windows.get(from);
+      if (!w) this.windows.set(from, w = []);
+      while (w.length && now - w[0] >= 1e3) w.shift();
+      if (w.length >= MAX_PACKETS_PER_SEC) return false;
+      for (const [p, t] of this.speakers) if (now - t > this.burstTimeoutMs) this.speakers.delete(p);
+      if (!this.speakers.has(from) && this.speakers.size >= MAX_SPEAKERS) return false;
+      w.push(now);
+      if (flags & FLAG_END_OF_BURST) this.speakers.delete(from);
+      else this.speakers.set(from, now);
+      return true;
+    }
+    get activeSpeakers() {
+      return this.speakers.size;
+    }
+    forget(peerId) {
+      this.speakers.delete(peerId);
+      this.windows.delete(peerId);
+    }
+  };
+
+  // src/voice.ts
+  var SPEAKING_TIMEOUT_MS = 300;
+  var Voice = class extends Emitter {
+    constructor(hub, deps) {
+      super();
+      this.hub = hub;
+      this.deps = deps;
+    }
+    hub;
+    deps;
+    mode = "pushToTalk";
+    /** Master mute for capture (self). */
+    muted = false;
+    /** 0..1 RMS of the last captured frame. */
+    inputLevel = 0;
+    bitrate = 24e3;
+    _enabled = false;
+    gate = new VoiceGate();
+    packetizer = new VoicePacketizer();
+    relay = new VoiceRelayPolicy();
+    speakers = /* @__PURE__ */ new Map();
+    peerMuted = /* @__PURE__ */ new Set();
+    gains = /* @__PURE__ */ new Map();
+    encoder = null;
+    source = null;
+    sink = null;
+    cancelPlayout = null;
+    endTimer = null;
+    sending = false;
+    get enabled() {
+      return this._enabled;
+    }
+    set enabled(v) {
+      if (v === this._enabled) return;
+      this._enabled = v;
+      if (v) void this.start();
+      else this.stop();
+    }
+    pushToTalk(down) {
+      this.gate.ptt = down;
+    }
+    isMutedPeer(peerId) {
+      return this.peerMuted.has(peerId);
+    }
+    setMuted(peerId, muted) {
+      if (muted) this.peerMuted.add(peerId);
+      else this.peerMuted.delete(peerId);
+    }
+    setVolume(peerId, gain) {
+      this.gains.set(peerId, Math.min(2, Math.max(0, gain)));
+    }
+    volumeOf(peerId) {
+      return this.gains.get(peerId) ?? 1;
+    }
+    // ---- capture -------------------------------------------------------------------------------------------------
+    async start() {
+      try {
+        if (!this.deps.codec) throw new Error("no Opus codec available: supply one through the voice.codec option (WASM fallback)");
+        if (!this.deps.createSink) throw new Error("no audio output available");
+        this.sink = this.deps.createSink();
+        this.cancelPlayout = this.hub.clock.setInterval(() => this.playoutTick(), FRAME_MS);
+        if (this.deps.createSource) {
+          this.encoder = this.deps.codec.createEncoder({ bitrate: this.bitrate }, (opus) => this.onEncoded(opus));
+          this.source = this.deps.createSource();
+          await this.source.start((pcm) => this.onCapturedFrame(pcm, this.hub.clock.now()));
+        }
+      } catch (e) {
+        this._enabled = false;
+        this.stop();
+        this.emit("error", { message: e instanceof Error ? e.message : String(e), cause: e });
+      }
+    }
+    stop() {
+      if (this.sending) this.closeBurst();
+      this.source?.stop();
+      this.source = null;
+      this.encoder?.close();
+      this.encoder = null;
+      this.cancelPlayout?.();
+      this.cancelPlayout = null;
+      this.sink?.close();
+      this.sink = null;
+      for (const [id, s] of this.speakers) {
+        s.decoder?.close();
+        if (s.talking) this.emit("speaking", id, false);
+      }
+      this.speakers.clear();
+    }
+    /** Feed one 20 ms mono 48 kHz frame (called by the mic source; exposed so tests and custom sources can drive it). */
+    onCapturedFrame(pcm, nowMs) {
+      const level = rms(pcm);
+      this.inputLevel = level;
+      if (!this._enabled || this.muted) {
+        if (this.sending) this.closeBurst();
+        return;
+      }
+      const g = this.gate.update(level, nowMs);
+      if (g.send) {
+        this.sending = true;
+        this.endTimer?.();
+        this.endTimer = null;
+        this.encoder?.encode(pcm);
+      } else if (g.edge === "close" && this.sending) {
+        this.closeBurst();
+      }
+    }
+    closeBurst() {
+      this.sending = false;
+      this.endTimer?.();
+      this.endTimer = this.hub.clock.setTimeout(() => {
+        this.endTimer = null;
+        this.sendPacket(this.packetizer.endBurst());
+      }, FRAME_MS * 2);
+    }
+    /** Send already-encoded Opus frames as one packet (no codec involved); used by tools and conformance. */
+    sendEncoded(frames, endOfBurst = false) {
+      this.sendPacket(this.packetizer.packet(frames, endOfBurst ? FLAG_END_OF_BURST : 0));
+    }
+    /** Encoded frame from the encoder (also the test entry point for packetization). */
+    onEncoded(opus) {
+      const p = this.packetizer.push(opus);
+      if (p) this.sendPacket(p);
+    }
+    sendPacket(p) {
+      const msg = { type: "voice", seq: p.seq, flags: p.flags, frames: p.frames };
+      if (this.hub.isHost) {
+        for (const peer of this.hub.connectedPeers()) this.hub.sendTo(peer, msg, this.hub.localPeerId, "voice");
+      } else {
+        this.hub.sendToHost(msg, 0, "voice");
+      }
+    }
+    // ---- receive -------------------------------------------------------------------------------------------------
+    handle(from, route, msg) {
+      if (msg.type !== "voice") return;
+      const size = msg.frames.reduce((a, f) => a + f.length + 2, 0) + 7;
+      const now = this.hub.clock.now();
+      let speaker = route;
+      if (this.hub.isHost) {
+        speaker = from;
+        if (!this.relay.accept(from, size, msg.flags, now)) return;
+        for (const peer of this.hub.connectedPeers()) {
+          if (peer !== from) this.hub.sendTo(peer, msg, from, "voice");
+        }
+      }
+      this.emit("packet", speaker, msg.seq, msg.flags, msg.frames);
+      if (!this._enabled || speaker === this.hub.localPeerId || this.peerMuted.has(speaker)) return;
+      this.receivePacket(speaker, { seq: msg.seq, flags: msg.flags, frames: msg.frames }, now);
+    }
+    /** Local playback path for one speaker's packet (after host forwarding). */
+    receivePacket(speaker, p, now) {
+      let s = this.speakers.get(speaker);
+      if (!s) {
+        s = { jitter: new JitterBuffer(), decoder: null, talking: false, lastHeard: now };
+        this.speakers.set(speaker, s);
+      }
+      s.lastHeard = now;
+      s.jitter.push(p);
+      if (!s.talking && p.frames.length > 0) {
+        s.talking = true;
+        this.emit("speaking", speaker, true);
+      }
+    }
+    playoutTick() {
+      const now = this.hub.clock.now();
+      for (const [id, s] of this.speakers) {
+        const r = s.jitter.pull();
+        if (r.kind === "frame" || r.kind === "plc") {
+          if (!s.decoder && this.deps.codec) {
+            s.decoder = this.deps.codec.createDecoder((pcm) => this.sink?.play(id, pcm, this.volumeOf(id)));
+          }
+          s.decoder?.decode(r.kind === "frame" ? r.opus : null);
+        } else if (r.kind === "idle" && s.talking) {
+          s.talking = false;
+          this.emit("speaking", id, false);
+        } else if (s.talking && now - s.lastHeard > SPEAKING_TIMEOUT_MS + 5 * FRAME_MS && !s.jitter.active) {
+          s.talking = false;
+          this.emit("speaking", id, false);
+        }
+      }
+    }
+    onPeerLeft(peerId) {
+      this.relay.forget(peerId);
+      const s = this.speakers.get(peerId);
+      if (s) {
+        s.decoder?.close();
+        if (s.talking) this.emit("speaking", peerId, false);
+        this.speakers.delete(peerId);
+      }
+    }
+    close() {
+      this._enabled = false;
+      this.stop();
+      this.endTimer?.();
+    }
+    /** For tests: expose the end-of-burst flag constant. */
+    static END = FLAG_END_OF_BURST;
+  };
+
+  // src/socket.ts
+  function closeCodeFor(reason) {
+    if (reason === "left") return 1e3;
+    if (reason === "host_left" || reason === "closed") return 1001;
+    if (reason === "kicked") return 4e3;
+    return 1006;
+  }
+  var enc2 = new TextEncoder();
+  var dec2 = new TextDecoder();
+  var PeerSocket = class {
+    constructor(peerId, out, binary, onLocalClose) {
+      this.peerId = peerId;
+      this.out = out;
+      this.binary = binary;
+      this.onLocalClose = onLocalClose;
+    }
+    peerId;
+    out;
+    binary;
+    onLocalClose;
+    readyState = 0;
+    bufferedAmount = 0;
+    onopen = null;
+    onmessage = null;
+    onclose = null;
+    onerror = null;
+    /** Unsubscribes from the lobby; set by the factory. */
+    detach = () => {
+    };
+    send(data) {
+      if (this.readyState !== 1) return;
+      this.out(typeof data === "string" ? enc2.encode(data) : data);
+    }
+    close(code = 1e3, reason = "left") {
+      if (this.readyState === 3) return;
+      this.closed(code, reason);
+      this.onLocalClose();
+    }
+    /** @internal OPEN now; `onopen` now, or one microtask later so a handler assigned right after creation still runs. */
+    open(later = false) {
+      if (this.readyState !== 0) return;
+      this.readyState = 1;
+      if (!later) this.onopen?.({ type: "open" });
+      else queueMicrotask(() => this.readyState === 1 && this.onopen?.({ type: "open" }));
+    }
+    /** @internal */
+    deliver(bytes) {
+      if (this.readyState === 1) this.onmessage?.({ type: "message", data: this.binary ? bytes : dec2.decode(bytes) });
+    }
+    /** @internal */
+    closed(code, reason) {
+      if (this.readyState === 3) return;
+      this.readyState = 3;
+      this.detach();
+      this.onclose?.({ type: "close", code, reason, wasClean: code === 1e3 || code === 1001 });
+    }
+  };
+  function joinerSocket(lobby, o = {}) {
+    if (lobby.isHost) throw new Error("asWebSocket() is for joiners; the host uses lobby.onConnection()");
+    const channel = o.channel ?? "reliable";
+    const s = new PeerSocket(lobby.hostPeerId, (b) => lobby.send(lobby.hostPeerId, b, { channel }), !!o.binary, () => void lobby.leave());
+    const offs = [
+      lobby.on("message", (from, bytes) => {
+        if (from === lobby.hostPeerId) s.deliver(bytes);
+      }),
+      lobby.on("sessionEnded", (reason) => s.closed(closeCodeFor(reason), reason)),
+      // The socket's far end is the host it opened to; after a migration that server is gone (direct lobbies end instead).
+      lobby.on("hostChanged", () => s.closed(1001, "host_changed"))
+    ];
+    s.detach = () => offs.forEach((f) => f());
+    if (lobby.connectedPeers.includes(lobby.hostPeerId)) s.open(true);
+    else lobby.ready.then(() => s.open(true), () => {
+    });
+    return s;
+  }
+  function hostConnections(lobby, handler, o = {}) {
+    if (!lobby.isHost) throw new Error("onConnection() is for the host; a joiner uses lobby.asWebSocket()");
+    const channel = o.channel ?? "reliable";
+    const conns = /* @__PURE__ */ new Map();
+    let stopped = false;
+    const ensure = (peerId) => {
+      if (peerId === lobby.localPeerId) return void 0;
+      let c = conns.get(peerId);
+      if (c || stopped) return c;
+      c = new PeerSocket(peerId, (b) => lobby.send(peerId, b, { channel }), !!o.binary, () => {
+      });
+      const conn = c;
+      conn.detach = () => {
+        if (conns.get(peerId) === conn) conns.delete(peerId);
+      };
+      conns.set(peerId, conn);
+      conn.open();
+      handler(conn);
+      return conn;
+    };
+    const offs = [
+      lobby.on("peerReady", (p) => void ensure(p.peerId)),
+      lobby.on("message", (from, bytes) => ensure(from)?.deliver(bytes)),
+      lobby.on("peerLeft", (p, reason) => conns.get(p.peerId)?.closed(reason === "left" ? 1001 : closeCodeFor(reason), reason)),
+      lobby.on("sessionEnded", (reason) => {
+        for (const c of [...conns.values()]) c.closed(reason === "left" ? 1001 : closeCodeFor(reason), reason);
+        offs.forEach((f) => f());
+      })
+    ];
+    for (const id of lobby.connectedPeers) ensure(id);
+    return () => {
+      stopped = true;
+    };
+  }
+
+  // src/lobby.ts
+  var MIN_PEER_TIMEOUT_MS = 6e3;
+  function seatName(p) {
+    const n = typeof p.name === "string" ? p.name.trim() : "";
+    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))));
+  }
+  var HOST_WATCHDOG_MS = 250;
+  var PING_EVERY_MS2 = 2e3;
+  var Lobby = class 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 = /* @__PURE__ */ new Map();
+    links = /* @__PURE__ */ new Map();
+    connected = /* @__PURE__ */ new Set();
+    // host: peers that said hi
+    hiSentTo = /* @__PURE__ */ new Set();
+    epoch = 0;
+    ended = false;
+    serverUp = true;
+    cancelWatchdog = null;
+    cancelPing = null;
+    pingN = 0;
+    chunkId = 1;
+    reassemblers = /* @__PURE__ */ new Map();
+    hub;
+    outbox = /* @__PURE__ */ new Map();
+    markReady = () => {
+    };
+    failReady = () => {
+    };
+    isReady = false;
+    cancelReadyTimer = null;
+    relayRetry = false;
+    /** clock.now() of the last frame from each peer (peerTimeoutMs). */
+    lastHeard = /* @__PURE__ */ new Map();
+    /** Host: per-peer fixed window for rateLimit. */
+    rate = /* @__PURE__ */ 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(() => {
+      });
+      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_MS2);
+    }
+    // ---- 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() {
+    }
+    // ---- 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) {
+        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";
+      const ready = !!link?.isOpen && (!queueable || !this.isHost || this.connected.has(peerId));
+      if (!ready) {
+        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 >= 1e3) 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) {
+          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) {
+        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);
+    }
+    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;
+      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);
+        if (!this.serverUp && this.roster.has(peerId)) this.removePeer(peerId, "timeout");
+      } else if (peerId === this.hostPeerId) {
+        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;
+          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);
+          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);
+          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();
+    }
+    becomeHost() {
+      this.epoch = this.epoch + 1 & 65535;
+      this.hostPeerId = this.localPeerId;
+      this.markReady();
+      this.connected.clear();
+      this.hiSentTo.clear();
+      this.lastHeard.clear();
+      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;
+      const wasHost = this.isHost;
+      this.epoch = epoch;
+      if (wasHost) {
+        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) {
+            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 & 65535;
+          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") {
+        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");
+      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();
+        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 !== void 0 && now - last > timeout) this.removePeer(id, "timeout");
+        }
+      } else if (this.isReady) {
+        const last = this.lastHeard.get(this.hostPeerId);
+        if (last !== void 0 && 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;
+    }
+  };
+
+  // src/transport.ts
+  var CHANNEL_IDS = { reliable: 0, fast: 1, voice: 2 };
+  var defaultSocketFactory = (url) => new WebSocket(url);
+
+  // src/voice-browser.ts
+  function webCodecsOpusAvailable() {
+    return typeof AudioEncoder !== "undefined" && typeof AudioDecoder !== "undefined" && typeof AudioData !== "undefined";
+  }
+  var webCodecsOpus = {
+    createEncoder(opts, onFrame) {
+      let ts = 0;
+      const enc4 = new AudioEncoder({
+        output: (chunk) => {
+          const out = new Uint8Array(chunk.byteLength);
+          chunk.copyTo(out);
+          onFrame(out);
+        },
+        error: (e) => console.error("onelobby: AudioEncoder", e)
+      });
+      enc4.configure({
+        codec: "opus",
+        sampleRate: SAMPLE_RATE,
+        numberOfChannels: 1,
+        bitrate: opts.bitrate,
+        opus: { frameDuration: 2e4, application: "voip", useinbandfec: true, usedtx: false, packetlossperc: 10 }
+      });
+      return {
+        encode(pcm) {
+          const data = new AudioData({
+            format: "f32",
+            sampleRate: SAMPLE_RATE,
+            numberOfFrames: pcm.length,
+            numberOfChannels: 1,
+            timestamp: ts,
+            data: pcm
+          });
+          ts += 2e4;
+          enc4.encode(data);
+          data.close();
+        },
+        close() {
+          if (enc4.state !== "closed") enc4.close();
+        }
+      };
+    },
+    createDecoder(onPcm) {
+      let ts = 0;
+      const dec4 = new AudioDecoder({
+        output: (audio) => {
+          const pcm = new Float32Array(audio.numberOfFrames);
+          audio.copyTo(pcm, { planeIndex: 0, format: "f32-planar" });
+          audio.close();
+          onPcm(pcm);
+        },
+        error: (e) => console.error("onelobby: AudioDecoder", e)
+      });
+      dec4.configure({ codec: "opus", sampleRate: SAMPLE_RATE, numberOfChannels: 1 });
+      return {
+        decode(opus) {
+          if (opus === null) {
+            onPcm(new Float32Array(FRAME_SAMPLES));
+            return;
+          }
+          dec4.decode(new EncodedAudioChunk({ type: "key", timestamp: ts, data: opus }));
+          ts += 2e4;
+        },
+        close() {
+          if (dec4.state !== "closed") dec4.close();
+        }
+      };
+    }
+  };
+  var WORKLET_SRC = `
+class OneLobbyCapture extends AudioWorkletProcessor {
+  constructor() { super(); this.buf = new Float32Array(${FRAME_SAMPLES}); this.n = 0; }
+  process(inputs) {
+    const ch = inputs[0] && inputs[0][0];
+    if (ch) {
+      for (let i = 0; i < ch.length; i++) {
+        this.buf[this.n++] = ch[i];
+        if (this.n === ${FRAME_SAMPLES}) {
+          const out = this.buf; this.buf = new Float32Array(${FRAME_SAMPLES}); this.n = 0;
+          this.port.postMessage(out, [out.buffer]);
+        }
+      }
+    }
+    return true;
+  }
+}
+registerProcessor('onelobby-capture', OneLobbyCapture);
+`;
+  var WorkletMic = class {
+    ctx = null;
+    stream = null;
+    async start(onFrame) {
+      this.stream = await navigator.mediaDevices.getUserMedia({
+        audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true, autoGainControl: true }
+      });
+      this.ctx = new AudioContext({ sampleRate: SAMPLE_RATE });
+      const url = URL.createObjectURL(new Blob([WORKLET_SRC], { type: "text/javascript" }));
+      try {
+        await this.ctx.audioWorklet.addModule(url);
+      } finally {
+        URL.revokeObjectURL(url);
+      }
+      const src = this.ctx.createMediaStreamSource(this.stream);
+      const node = new AudioWorkletNode(this.ctx, "onelobby-capture", { numberOfInputs: 1, numberOfOutputs: 0 });
+      node.port.onmessage = (e) => onFrame(e.data);
+      src.connect(node);
+      if (this.ctx.state === "suspended") await this.ctx.resume();
+    }
+    stop() {
+      for (const t of this.stream?.getTracks() ?? []) t.stop();
+      void this.ctx?.close();
+      this.stream = null;
+      this.ctx = null;
+    }
+  };
+  var WebAudioSink = class {
+    ctx = new AudioContext({ sampleRate: SAMPLE_RATE });
+    next = /* @__PURE__ */ new Map();
+    constructor() {
+      void this.ctx.resume();
+    }
+    play(peerId, pcm, gain) {
+      if (pcm.length === 0) return;
+      const buf = this.ctx.createBuffer(1, pcm.length, SAMPLE_RATE);
+      buf.copyToChannel(pcm, 0);
+      const src = this.ctx.createBufferSource();
+      src.buffer = buf;
+      const g = this.ctx.createGain();
+      g.gain.value = gain;
+      src.connect(g).connect(this.ctx.destination);
+      const now = this.ctx.currentTime;
+      let at = this.next.get(peerId) ?? 0;
+      if (at < now + 0.01) at = now + 0.02;
+      src.start(at);
+      this.next.set(peerId, at + pcm.length / SAMPLE_RATE);
+    }
+    close() {
+      void this.ctx.close();
+    }
+  };
+
+  // src/webrtc.ts
+  var CHANNEL_INIT = {
+    reliable: { negotiated: true, id: CHANNEL_IDS.reliable, ordered: true },
+    fast: { negotiated: true, id: CHANNEL_IDS.fast, ordered: false, maxRetransmits: 0 },
+    voice: { negotiated: true, id: CHANNEL_IDS.voice, ordered: false, maxRetransmits: 0 }
+  };
+  var WebRtcLink = class {
+    remoteId;
+    isOpen = false;
+    onSignal = null;
+    onOpen = null;
+    onClose = null;
+    onMessage = null;
+    onPath = null;
+    pc;
+    channels = {};
+    pendingIce = [];
+    closed = false;
+    opened = 0;
+    extra;
+    /** `rtc`: the RTCPeerConnection class to use (default the global one; in Node, node-datachannel's polyfill). */
+    constructor(opts, rtc = globalThis.RTCPeerConnection) {
+      this.remoteId = opts.remoteId;
+      this.extra = opts.extraRemoteCandidates ?? [];
+      const config = {
+        iceServers: opts.iceServers,
+        iceTransportPolicy: opts.relayOnly ? "relay" : "all"
+      };
+      if (opts.portRange) {
+        config.portRangeBegin = opts.portRange.begin;
+        config.portRangeEnd = opts.portRange.end;
+        if (opts.portRange.begin === opts.portRange.end) config.enableIceUdpMux = true;
+      }
+      this.pc = new rtc(config);
+      this.pc.onicecandidate = (e) => {
+        if (e.candidate) this.onSignal?.({ ice: e.candidate.toJSON() });
+      };
+      this.pc.onconnectionstatechange = () => {
+        const s = this.pc.connectionState;
+        if (s === "failed" || s === "closed" || s === "disconnected") {
+          if (s === "disconnected") setTimeout(() => this.pc.connectionState === "disconnected" && this.fail("disconnected"), 4e3);
+          else this.fail(s);
+        }
+      };
+      for (const name of ["reliable", "fast", "voice"]) {
+        const ch = this.pc.createDataChannel(name, CHANNEL_INIT[name]);
+        ch.binaryType = "arraybuffer";
+        ch.onopen = () => {
+          if (++this.opened === 3 && !this.closed) {
+            this.isOpen = true;
+            this.onOpen?.();
+            void this.reportPath();
+          }
+        };
+        ch.onclose = () => this.fail(`channel ${name} closed`);
+        ch.onmessage = (e) => {
+          const d = e.data;
+          const data = d instanceof ArrayBuffer ? new Uint8Array(d) : ArrayBuffer.isView(d) ? new Uint8Array(d.buffer, d.byteOffset, d.byteLength) : new Uint8Array(d);
+          this.onMessage?.(name, data);
+        };
+        this.channels[name] = ch;
+      }
+    }
+    startOffer() {
+      void (async () => {
+        try {
+          const offer = await this.pc.createOffer();
+          await this.pc.setLocalDescription(offer);
+          this.onSignal?.({ sdp: { type: "offer", sdp: offer.sdp ?? "" } });
+        } catch (e) {
+          this.fail(`offer failed: ${String(e)}`);
+        }
+      })();
+    }
+    async handleSignal(s) {
+      try {
+        if (s.sdp) {
+          await this.pc.setRemoteDescription({ type: s.sdp.type, sdp: s.sdp.sdp });
+          for (const c of this.pendingIce.splice(0)) await this.pc.addIceCandidate(c);
+          if (this.extra.length) {
+            const mid = /^a=mid:(\S+)/m.exec(s.sdp.sdp)?.[1] ?? "0";
+            for (const candidate of this.extra.splice(0)) await this.pc.addIceCandidate({ candidate, sdpMid: mid, sdpMLineIndex: 0 });
+          }
+          if (s.sdp.type === "offer") {
+            const answer = await this.pc.createAnswer();
+            await this.pc.setLocalDescription(answer);
+            this.onSignal?.({ sdp: { type: "answer", sdp: answer.sdp ?? "" } });
+          }
+        }
+        if (s.ice) {
+          if (this.pc.remoteDescription) await this.pc.addIceCandidate(s.ice);
+          else this.pendingIce.push(s.ice);
+        }
+      } catch (e) {
+        this.fail(`signal failed: ${String(e)}`);
+      }
+    }
+    /** Selected candidate pair has a relay candidate -> "relayed", else "direct". Retries while stats settle. */
+    async reportPath(attempt = 0) {
+      if (this.closed || attempt > 10) return;
+      try {
+        const stats = await this.pc.getStats();
+        const byId = /* @__PURE__ */ new Map();
+        stats.forEach((v) => byId.set(v.id, v));
+        let pair;
+        stats.forEach((v) => {
+          if (v.type === "transport" && v.selectedCandidatePairId) pair = byId.get(v.selectedCandidatePairId);
+        });
+        if (!pair) stats.forEach((v) => {
+          if (v.type === "candidate-pair" && (v.selected || v.nominated && v.state === "succeeded")) pair = v;
+        });
+        const l = pair && byId.get(pair.localCandidateId);
+        const r = pair && byId.get(pair.remoteCandidateId);
+        if (l && r) {
+          this.onPath?.(l.candidateType === "relay" || r.candidateType === "relay" ? "relayed" : "direct");
+          return;
+        }
+      } catch {
+      }
+      setTimeout(() => void this.reportPath(attempt + 1), 300);
+    }
+    send(channel, bytes) {
+      const ch = this.channels[channel];
+      if (ch && ch.readyState === "open") ch.send(bytes);
+    }
+    close() {
+      this.fail("closed locally");
+    }
+    fail(reason) {
+      if (this.closed) return;
+      this.closed = true;
+      const wasOpen = this.isOpen;
+      this.isOpen = false;
+      try {
+        this.pc.close();
+      } catch {
+      }
+      void wasOpen;
+      this.onClose?.(reason);
+    }
+  };
+  var webRtcLinkFactory = { create: (opts) => new WebRtcLink(opts) };
+  function webRtcLinkFactoryFor(rtc) {
+    return { create: (opts) => new WebRtcLink(opts, rtc) };
+  }
+
+  // src/joincode.ts
+  var JOIN_CODE_LENGTH = 11;
+  function crc5(value, bits) {
+    let crc = 0;
+    for (let i = bits - 1; i >= 0; i--) {
+      const bit = Number(value >> BigInt(i) & 1n);
+      const top = crc >> 4 & 1;
+      crc = crc << 1 & 31;
+      if (top ^ bit) crc ^= 5;
+    }
+    return crc;
+  }
+  function normalizeJoinCode(input) {
+    const s = input.replace(/[ \-]/g, "").replace(/[a-z]/g, (c) => c.toUpperCase()).replace(/[IL]/g, "1").replace(/O/g, "0");
+    if (s.length !== JOIN_CODE_LENGTH) return null;
+    for (const c of s) if (CROCKFORD_ALPHABET.indexOf(c) < 0) return null;
+    return s;
+  }
+  function decodeJoinCode(input) {
+    const s = normalizeJoinCode(input);
+    if (!s) return { error: "bad_code" };
+    let v = 0n;
+    for (const c of s) v = v << 5n | BigInt(CROCKFORD_ALPHABET.indexOf(c));
+    const data = v >> 5n;
+    if (crc5(data, 50) !== Number(v & 31n)) return { error: "bad_code" };
+    if (data >> 48n !== 0n) return { error: "unknown_version" };
+    const port = Number(data & 0xffffn);
+    if (port === 0) return { error: "bad_code" };
+    const a = Number(data >> 16n & 0xffffffffn);
+    return { ip: [a >>> 24, a >>> 16 & 255, a >>> 8 & 255, a & 255].join("."), port };
+  }
+  function looksLikeJoinCode(input) {
+    return !/[.:]/.test(input) && normalizeJoinCode(input) !== null;
+  }
+
+  // src/direct-address.ts
+  var DEFAULT_DIRECT_PORT = 47810;
+  var IPV4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/;
+  var HOSTNAME = /^(?=.{1,253}$)([A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)(\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/;
+  function isIPv4(s) {
+    const m = IPV4.exec(s);
+    return !!m && m.slice(1).every((x) => Number(x) <= 255);
+  }
+  function isIPv6(s) {
+    if (!/^[0-9A-Fa-f:.]+$/.test(s) || s.split("::").length > 2 || !s.includes(":")) return false;
+    const tail = s.split(":").pop() ?? "";
+    const groups = s.split(":").filter((g, i, a) => g !== "" || i > 0 && i < a.length - 1);
+    if (tail.includes(".") && !isIPv4(tail)) return false;
+    return groups.every((g) => g === "" || g.includes(".") || /^[0-9A-Fa-f]{1,4}$/.test(g));
+  }
+  function parseDirectAddress(input, defaultPort = DEFAULT_DIRECT_PORT) {
+    let s = input.trim();
+    if (/^ws:\/\//i.test(s)) s = s.slice(5);
+    s = s.replace(/\/+$/, "");
+    if (!s) return null;
+    let host;
+    let portText = null;
+    if (s[0] === "[") {
+      const close = s.indexOf("]");
+      if (close < 0) return null;
+      host = s.slice(1, close);
+      const rest = s.slice(close + 1);
+      if (rest) {
+        if (rest[0] !== ":") return null;
+        portText = rest.slice(1);
+      }
+    } else {
+      const first = s.indexOf(":");
+      if (first >= 0 && first === s.lastIndexOf(":")) {
+        host = s.slice(0, first);
+        portText = s.slice(first + 1);
+      } else host = s;
+    }
+    let port = defaultPort;
+    if (portText !== null) {
+      if (!/^\d{1,5}$/.test(portText)) return null;
+      port = Number(portText);
+      if (port < 1 || port > 65535) return null;
+    }
+    const v6 = isIPv6(host);
+    if (!v6 && !isIPv4(host) && !HOSTNAME.test(host)) return null;
+    const display = (v6 ? `[${host}]` : host) + `:${port}`;
+    return { host, port, isIPv6: v6, display, url: `ws://${display}/`, candidate: `candidate:1 1 UDP 2122317823 ${host} ${port} typ host` };
+  }
+
+  // src/onelobby.ts
+  var LIB_NAME = "onelobby";
+  var LIB_VERSION = "0.2.0";
+  var DEFAULT_READY_TIMEOUT_MS = 15e3;
+  function hasMic() {
+    return typeof navigator !== "undefined" && !!navigator.mediaDevices?.getUserMedia && typeof AudioWorkletNode !== "undefined";
+  }
+  function browserStorage() {
+    try {
+      const s = globalThis.sessionStorage;
+      return s ?? null;
+    } catch {
+      return null;
+    }
+  }
+  var liveSeats = /* @__PURE__ */ new Set();
+  function seatInUse(token) {
+    for (const l of liveSeats) if (l.resumeToken === token) return true;
+    return false;
+  }
+  var OneLobby = class extends Emitter {
+    options;
+    socketFactory;
+    linkFactory;
+    clock;
+    wall;
+    voiceCodec;
+    createMic;
+    createSink;
+    storage;
+    constructor(o) {
+      super();
+      const tickRate = o.tickRate ?? 20;
+      this.options = {
+        gameId: o.gameId,
+        netVersion: o.netVersion,
+        lobbyServer: o.lobbyServer,
+        mode: o.mode ?? "lockstep",
+        tickRate,
+        hashEveryTicks: o.hashEveryTicks ?? tickRate,
+        displayName: (o.displayName ?? "").trim(),
+        relayOnly: o.relayOnly ?? false,
+        readyTimeoutMs: o.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS,
+        peerTimeoutMs: o.peerTimeoutMs ?? 0
+      };
+      const a = o.advanced ?? {};
+      const pick = (k) => a[k] !== void 0 ? a[k] : o[k];
+      this.socketFactory = pick("socketFactory") ?? defaultSocketFactory;
+      this.linkFactory = pick("linkFactory") ?? webRtcLinkFactory;
+      this.clock = pick("clock") ?? systemClock;
+      this.wall = pick("wallClock") ?? (() => Date.now());
+      const codec = pick("voiceCodec");
+      this.voiceCodec = codec !== void 0 ? codec : webCodecsOpusAvailable() ? webCodecsOpus : null;
+      const mic = pick("createMic");
+      this.createMic = mic !== void 0 ? mic : hasMic() ? () => new WorkletMic() : null;
+      const sink = pick("createSink");
+      this.createSink = sink !== void 0 ? sink : typeof AudioContext !== "undefined" ? () => new WebAudioSink() : null;
+      this.storage = o.rememberSeat === false ? null : a.storage !== void 0 ? a.storage : browserStorage();
+    }
+    // ---- remembered seat -------------------------------------------------------------------------------------------
+    get seatKey() {
+      return `onelobby.seat.${this.options.gameId}`;
+    }
+    loadSeat() {
+      if (!this.storage) return null;
+      try {
+        const raw = this.storage.getItem(this.seatKey);
+        if (!raw) return null;
+        const s = JSON.parse(raw);
+        if (typeof s.code !== "string" || typeof s.token !== "string" || s.server !== this.options.lobbyServer) return null;
+        return s;
+      } catch {
+        return null;
+      }
+    }
+    saveSeat(code, token) {
+      if (!this.storage || !token) return;
+      try {
+        this.storage.setItem(this.seatKey, JSON.stringify({ code, token, server: this.options.lobbyServer }));
+      } catch {
+      }
+    }
+    clearSeat(code) {
+      if (!this.storage) return;
+      try {
+        if (code !== void 0) {
+          const s = this.loadSeat();
+          if (s && s.code !== code) return;
+        }
+        this.storage.removeItem(this.seatKey);
+      } catch {
+      }
+    }
+    /** The lobby code of the seat this tab can take back (rememberSeat), or null. */
+    get rememberedCode() {
+      return this.loadSeat()?.code ?? null;
+    }
+    /**
+     * Take back the seat remembered from before a page reload (host or joiner). Resolves null when there is none
+     * or the server no longer holds it (the seat is forgotten then).
+     */
+    async resume() {
+      const seat = this.loadSeat();
+      if (!seat || seatInUse(seat.token)) return null;
+      try {
+        return await this.rejoin(seat.token);
+      } catch (e) {
+        if (e instanceof OneLobbyError && e.code === "invalid_token") {
+          this.clearSeat();
+          return null;
+        }
+        throw e;
+      }
+    }
+    // ---- connecting ------------------------------------------------------------------------------------------------
+    helloMsg(resumeToken) {
+      return {
+        t: "hello",
+        proto: PROTO_ID,
+        gameId: this.options.gameId,
+        netVersion: this.options.netVersion,
+        client: { lib: LIB_NAME, ver: LIB_VERSION, platform: typeof navigator !== "undefined" ? "browser" : "node" },
+        name: this.options.displayName.slice(0, 24),
+        ...resumeToken ? { resumeToken } : {}
+      };
+    }
+    async connect(url = this.options.lobbyServer, factory = this.socketFactory, timeoutMs = 0) {
+      const sig = new SignalingClient(url, factory, this.clock);
+      if (timeoutMs > 0) {
+        let cancel = () => {
+        };
+        const timeout = new Promise((_, reject) => {
+          cancel = this.clock.setTimeout(() => reject(new OneLobbyError("direct_unreachable", `no answer from ${url} within ${timeoutMs} ms`)), timeoutMs);
+        });
+        try {
+          await Promise.race([sig.connect(), timeout]);
+        } catch (e) {
+          sig.close();
+          if (e instanceof OneLobbyError && e.code === "connect_failed") throw new OneLobbyError("direct_unreachable", `no answer from ${url}`);
+          throw e;
+        } finally {
+          cancel();
+        }
+      } else await sig.connect();
+      try {
+        const welcome = await sig.request(this.helloMsg(), "welcome");
+        return { sig, welcome };
+      } catch (e) {
+        sig.close();
+        throw e;
+      }
+    }
+    makeLobby(sig, welcome, state, direct, rateLimit) {
+      const lobby = new Lobby({
+        signaling: sig,
+        state,
+        ice: welcome.ice ?? [],
+        links: direct?.links ?? this.linkFactory,
+        direct: !!direct,
+        clock: this.clock,
+        wall: this.wall,
+        hashEveryTicks: this.options.hashEveryTicks,
+        relayOnly: state.relayOnly ?? this.options.relayOnly,
+        displayName: this.options.displayName,
+        voice: { codec: this.voiceCodec, createSource: this.createMic, createSink: this.createSink },
+        readyTimeoutMs: this.options.readyTimeoutMs,
+        peerTimeoutMs: this.options.peerTimeoutMs,
+        rateLimit
+      });
+      lobby.errorSink = (e) => this.emit("error", e);
+      if (this.storage && !direct) {
+        liveSeats.add(lobby);
+        this.saveSeat(lobby.code, lobby.resumeToken);
+        lobby.seatSink = (token) => this.saveSeat(lobby.code, token);
+        lobby.on("sessionEnded", () => {
+          liveSeats.delete(lobby);
+          this.clearSeat(lobby.code);
+        });
+      }
+      return lobby;
+    }
+    async host(h) {
+      const { sig, welcome } = await this.connect();
+      try {
+        const state = await sig.request(
+          {
+            t: "create",
+            name: h.name,
+            maxPlayers: h.maxPlayers,
+            visibility: h.visibility ?? "unlisted",
+            mode: this.options.mode,
+            tickRate: this.options.tickRate,
+            lateJoin: h.lateJoin ?? true,
+            meta: h.meta ?? {},
+            ...this.options.relayOnly ? { relayOnly: true } : {}
+          },
+          "lobby"
+        );
+        return this.makeLobby(sig, welcome, state, void 0, h.rateLimit);
+      } catch (e) {
+        sig.close();
+        throw e;
+      }
+    }
+    async join(code) {
+      const norm = normalizeCode(code);
+      if (!norm) throw new OneLobbyError("bad_code", `"${code}" is not a valid join code`);
+      const seat = this.loadSeat();
+      if (seat && seat.code === norm && !seatInUse(seat.token)) {
+        try {
+          return await this.rejoin(seat.token);
+        } catch (e) {
+          this.clearSeat();
+          if (!(e instanceof OneLobbyError && e.code === "invalid_token")) throw e;
+        }
+      }
+      const { sig, welcome } = await this.connect();
+      try {
+        const state = await sig.request({ t: "join", code: norm }, "lobby");
+        return this.makeLobby(sig, welcome, state);
+      } catch (e) {
+        sig.close();
+        throw e;
+      }
+    }
+    /**
+     * Join a direct-IP host (docs/direct-ip.md): a join code from the host's screen (`6B01-RGFE-P2B`, any case, spaces
+     * or hyphens) or, advanced, an address (`ip`, `ip:port`, `[v6]:port`). No lobby server is involved: the code is
+     * the host's address. A mistyped code fails at once with `bad_code`; nobody listening is `direct_unreachable`.
+     * The address is also given to ICE as the host's UDP candidate. When the host leaves, `sessionEnded("host_left")`.
+     */
+    async joinDirect(codeOrAddress, opts = {}) {
+      let input = codeOrAddress.trim();
+      if (looksLikeJoinCode(input)) {
+        const d = decodeJoinCode(input);
+        if ("error" in d)
+          throw new OneLobbyError(d.error, d.error === "unknown_version" ? `"${input}" is a join code from a newer version of the game` : `"${input}" is not a valid join code: check for a typo`);
+        input = `${d.ip}:${d.port}`;
+      }
+      const addr = parseDirectAddress(input, opts.defaultPort ?? DEFAULT_DIRECT_PORT);
+      if (!addr) throw new OneLobbyError("bad_address", `"${codeOrAddress}" is not a join code or an address (try 6B01-RGFE-P2B or 192.168.1.20:47810)`);
+      const inner = this.linkFactory;
+      const links = { create: (o) => inner.create({ ...o, iceServers: [], extraRemoteCandidates: [addr.candidate] }) };
+      const { sig, welcome } = await this.connect(addr.url, this.socketFactory, opts.connectTimeoutMs ?? 5e3);
+      try {
+        const state = await sig.request({ t: "join", ...opts.password ? { password: opts.password } : {} }, "lobby");
+        return this.makeLobby(sig, welcome, state, { links });
+      } catch (e) {
+        sig.close();
+        throw e;
+      }
+    }
+    /** @internal onelobby/direct's host: create the one lobby on the embedded hub, in direct mode. */
+    async hostDirectWith(h, hooks) {
+      const { sig, welcome } = await this.connect("onelobby-direct://host/", hooks.socketFactory);
+      try {
+        const state = await sig.request(
+          {
+            t: "create",
+            name: h.name,
+            maxPlayers: h.maxPlayers,
+            visibility: "unlisted",
+            mode: this.options.mode,
+            tickRate: this.options.tickRate,
+            lateJoin: h.lateJoin ?? true,
+            meta: h.meta ?? {}
+          },
+          "lobby"
+        );
+        return this.makeLobby(sig, welcome, state, { links: hooks.wrapLinks(this.linkFactory) }, h.rateLimit);
+      } catch (e) {
+        sig.close();
+        throw e;
+      }
+    }
+    async rejoin(resumeToken) {
+      const sig = new SignalingClient(this.options.lobbyServer, this.socketFactory, this.clock);
+      await sig.connect();
+      try {
+        const lobbyP = sig.expect("lobby");
+        const welcomeP = sig.request(this.helloMsg(resumeToken), "welcome");
+        lobbyP.catch(() => {
+        });
+        const welcome = await welcomeP;
+        if (welcome.peerId === void 0) throw new OneLobbyError("invalid_token", "resume token unknown or expired");
+        const state = await lobbyP;
+        return this.makeLobby(sig, welcome, state);
+      } catch (e) {
+        sig.close();
+        throw e;
+      }
+    }
+    async list(opts = {}) {
+      const { sig } = await this.connect();
+      try {
+        const res = await sig.request(
+          { t: "list", visibility: "public", meta: opts.meta ?? {}, limit: Math.min(100, opts.limit ?? 50), ...opts.cursor ? { cursor: opts.cursor } : {} },
+          "lobbies"
+        );
+        return res.items ?? [];
+      } finally {
+        sig.close();
+      }
+    }
+  };
+
+  // src/friendly.ts
+  var TEXT = {
+    // server errors (spec/signaling.md)
+    unknown_code: { message: "We couldn't find a lobby with that code.", hint: "Check the code with the host. Codes stop working once everyone leaves." },
+    bad_code: { message: "That doesn't look like a lobby code.", hint: "Codes are 6 letters and numbers, like 7HQ 4K2." },
+    lobby_full: { message: "That lobby is full.", hint: "Ask the host to make room, or start your own lobby." },
+    version_mismatch: { message: "You and the host are running different versions of the game.", hint: "Reload the page (or update the game) on both sides, then try again." },
+    in_game: { message: "That game has already started.", hint: "Ask the host to let people join mid-game, or wait for the next round." },
+    kicked: { message: "The host removed you from the lobby." },
+    denied: { message: "The host didn't let you in this time.", hint: "Ask the host to approve you, then try again." },
+    not_host: { message: "Only the host can do that." },
+    rate_limited: { message: "Slow down a little: too many tries in a short time.", hint: "Wait a moment, then try again." },
+    max_lobbies: { message: "You already have the most lobbies open that this server allows.", hint: "Close one of your other lobbies, then try again." },
+    server_full: { message: "The game server is full right now.", hint: "Try again in a few minutes." },
+    game_not_allowed: { message: "This game server doesn't host this game.", hint: "The game's server setting may be wrong; let the game's owner know." },
+    bad_request: { message: "The game sent something the server didn't understand.", hint: "Reload the page and try again. If it keeps happening, the game may need an update." },
+    // client errors
+    connect_failed: { message: "Couldn't reach the game server.", hint: "Check your internet connection, then try again." },
+    closed: { message: "Lost the connection to the game server.", hint: "Check your internet connection, then try again." },
+    server_lost: { message: "Lost the connection to the game server.", hint: "Your game may keep going; new players can't join until it's back." },
+    invalid_token: { message: "Your old seat in that lobby is no longer available.", hint: "Join again with the lobby code." },
+    ice_failed: { message: "Couldn't connect to the other players.", hint: "Some networks (school, work, public Wi-Fi) block game connections. Try another network or a phone hotspot." },
+    timeout: { message: "The connection took too long.", hint: "Check your internet connection, then try again." },
+    left: { message: "You left the lobby." },
+    unknown: { message: "Something went wrong.", hint: "Try again. If it keeps happening, reload the page." }
+  };
+  var CODE_RE = /^[a-z][a-z0-9_]*$/;
+  function codeOf(err) {
+    if (typeof err === "string") {
+      const m = /^([a-z][a-z0-9_]*)(?::|$)/.exec(err.trim());
+      return { code: m ? m[1] : null };
+    }
+    if (err && typeof err === "object") {
+      const o = err;
+      const data = o.data && typeof o.data === "object" ? o.data : void 0;
+      if (typeof o.code === "string" && CODE_RE.test(o.code)) return { code: o.code, data };
+      if (typeof o.message === "string") {
+        const m = /^([a-z][a-z0-9_]*):/.exec(o.message);
+        if (m && TEXT[m[1]]) return { code: m[1], data };
+        if (o.name === "NetworkError" || /network|failed to fetch|websocket/i.test(o.message)) return { code: "connect_failed" };
+        if (o.name === "TimeoutError" || /timed? ?out/i.test(o.message)) return { code: "timeout" };
+      }
+    }
+    return { code: null };
+  }
+  function describeError(err) {
+    const { code, data } = codeOf(err);
+    if (!code) return { code: "unknown", ...TEXT.unknown };
+    let key = code;
+    if (code === "kicked" && data?.reason === "denied") key = "denied";
+    if (code === "rate_limited" && data?.reason === "max_lobbies") key = "max_lobbies";
+    const e = TEXT[key];
+    if (!e) return { code, ...TEXT.unknown };
+    const out = { code, message: e.message };
+    if (e.hint) out.hint = e.hint;
+    if (code === "rate_limited" && typeof data?.retryAfterMs === "number" && key === "rate_limited") {
+      const s = Math.max(1, Math.ceil(data.retryAfterMs / 1e3));
+      out.hint = `Wait ${s} second${s === 1 ? "" : "s"}, then try again.`;
+    }
+    return out;
+  }
+  function currentHref() {
+    try {
+      return typeof location !== "undefined" ? location.href : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  function shareUrl(code, base, param = "join") {
+    const norm = normalizeCode(code);
+    if (!norm) throw new Error(`"${code}" is not a valid lobby code`);
+    const b = base ?? currentHref();
+    if (!b) throw new Error("shareUrl needs a base URL outside the browser");
+    const u = new URL(b);
+    u.searchParams.delete(param);
+    u.searchParams.set(param, formatCode(norm).replace(" ", "-"));
+    return u.toString();
+  }
+  function codeFromUrl(url, param = "join") {
+    const href = url ?? currentHref();
+    if (!href) return null;
+    let u;
+    try {
+      u = new URL(href, "http://localhost/");
+    } catch {
+      return null;
+    }
+    const v = u.searchParams.get(param) ?? new URLSearchParams(u.hash.replace(/^#/, "")).get(param);
+    return v ? normalizeCode(v) : null;
+  }
+
+  // src/deprecated.ts
+  var Keepalive = OneLobby;
+  var KeepaliveError = OneLobbyError;
+
+  // src/ui/controller.ts
+  var enc3 = new TextEncoder();
+  var dec3 = new TextDecoder();
+  var toBytes = (w) => enc3.encode(JSON.stringify(w));
+  var SharedState = class {
+    constructor(c) {
+      this.c = c;
+    }
+    c;
+    /** @internal */
+    values = /* @__PURE__ */ new Map();
+    get(key) {
+      return this.values.get(key);
+    }
+    /** Set a value for everyone. The host decides the order; everyone gets `shared-change`. */
+    set(key, value) {
+      this.c._sharedOp({ k: "set", key: String(key), v: value === void 0 ? null : value });
+    }
+    /** Add `n` (default 1) to a number, safely even when several players click at once. */
+    add(key, n = 1) {
+      this.c._sharedOp({ k: "add", key: String(key), n: Number(n) || 0 });
+    }
+    /** A plain copy of every value. */
+    all() {
+      return Object.fromEntries(this.values);
+    }
+    keys() {
+      return [...this.values.keys()];
+    }
+  };
+  var LobbyController = class {
+    constructor(opts) {
+      this.opts = opts;
+    }
+    opts;
+    state = "idle";
+    lobby = null;
+    error = null;
+    /** True while a joiner waits for its direct link to the host. */
+    linking = false;
+    name = "";
+    shared = new SharedState(this);
+    onChange = () => {
+    };
+    onEvent = () => {
+    };
+    lastAction = null;
+    unsub = [];
+    gen = 0;
+    /** Host: changes made so far. Joiner: the newest change applied (older queued ones are skipped). */
+    seq = 0;
+    get isHost() {
+      return !!this.lobby && this.lobby.isHost;
+    }
+    get code() {
+      return this.lobby?.code ?? null;
+    }
+    get players() {
+      const l = this.lobby;
+      if (!l) return [];
+      const list = l.peers.map((p) => this.toPlayer(p));
+      if (!list.some((p) => p.isMe)) list.push({ id: l.localPeerId, name: this.name || `Player ${l.localPeerId}`, isHost: l.isHost, isMe: true });
+      return list.sort((a, b) => a.id - b.id);
+    }
+    /** One line of plain language for the status area. */
+    get statusText() {
+      switch (this.state) {
+        case "idle":
+          return "Host a game, or type a code to join one.";
+        case "connecting":
+          return this.lastAction?.kind === "join" ? "Joining\u2026" : this.lastAction?.kind === "resume" ? "Getting your seat back\u2026" : "Creating a game\u2026";
+        case "error":
+          return this.error?.message ?? "Something went wrong.";
+        case "lobby": {
+          if (this.linking) return `Connecting to ${this.hostName}\u2026`;
+          if (this.isHost) {
+            const n = this.players.length;
+            return n <= 1 ? "Waiting for players\u2026 Share the code with your friends." : `${n} players here. Press Start when everyone's in.`;
+          }
+          return `Connected! Waiting for ${this.hostName} to start.`;
+        }
+        case "playing":
+          return this.linking ? `Connecting to ${this.hostName}\u2026` : "Game on!";
+      }
+    }
+    get hostName() {
+      const l = this.lobby;
+      if (!l) return "the host";
+      return l.peer(l.hostPeerId)?.name || "the host";
+    }
+    toPlayer(p, id) {
+      const l = this.lobby;
+      const pid = p?.peerId ?? id ?? 0;
+      return { id: pid, name: p?.name || pid === l.localPeerId && this.name || `Player ${pid}`, isHost: pid === l.hostPeerId, isMe: pid === l.localPeerId };
+    }
+    // ---- actions -----------------------------------------------------------------------------------------------------
+    host(name) {
+      this.lastAction = { kind: "host" };
+      return this.run(name, (kit) => kit.host({ name: this.opts.lobbyName ?? "game", maxPlayers: typeof this.opts.maxPlayers === "function" ? this.opts.maxPlayers() : this.opts.maxPlayers, visibility: "unlisted", lateJoin: true }));
+    }
+    join(code, name) {
+      const norm = normalizeCode(code);
+      this.lastAction = { kind: "join", code };
+      if (!norm) {
+        this.fail(new OneLobbyError("bad_code"));
+        return Promise.resolve();
+      }
+      return this.run(name, (kit) => kit.join(norm));
+    }
+    /**
+     * Take back this tab's seat after a page reload, if the kit remembers one (host or joiner). Quietly stays on the
+     * start screen when there is nothing to resume or the seat is gone. Resolves true when back in a game.
+     */
+    async resume(name) {
+      const kit = this.opts.makeKit(name);
+      if (!kit.resume || !kit.rememberedCode) return false;
+      this.lastAction = { kind: "resume" };
+      await this.run(name, () => kit.resume(), true);
+      return !!this.lobby;
+    }
+    /** Repeat whatever failed last (host or join). */
+    retry() {
+      const a = this.lastAction;
+      if (!a || a.kind === "resume") {
+        this.reset();
+        return Promise.resolve();
+      }
+      return a.kind === "host" ? this.host(this.name) : this.join(a.code, this.name);
+    }
+    async start() {
+      if (!this.lobby || !this.isHost || this.state === "playing") return;
+      await this.lobby.start();
+    }
+    async leave() {
+      const l = this.lobby;
+      this.detach();
+      await l?.leave();
+      this.reset();
+    }
+    /** Back to the start screen (after an error, or to cancel). */
+    reset() {
+      this.detach();
+      this.state = "idle";
+      this.error = null;
+      this.onChange();
+    }
+    /** Send any JSON-able value to everyone else. */
+    send(data) {
+      if (!this.lobby) return;
+      this.lobby.broadcast(toBytes({ k: "m", d: data === void 0 ? null : data }));
+    }
+    // ---- internals ---------------------------------------------------------------------------------------------------
+    async run(name, go, quiet = false) {
+      this.detach();
+      const gen = ++this.gen;
+      this.name = (name || "").trim().slice(0, 24);
+      this.state = "connecting";
+      this.error = null;
+      this.onChange();
+      let lobby;
+      try {
+        lobby = await go(this.opts.makeKit(this.name));
+      } catch (e) {
+        if (gen !== this.gen) return;
+        if (quiet) this.reset();
+        else this.fail(e);
+        return;
+      }
+      if (gen !== this.gen) {
+        void lobby?.leave();
+        return;
+      }
+      if (lobby) this.attach(lobby);
+      else this.reset();
+    }
+    attach(l) {
+      this.lobby = l;
+      if (!l.isHost) this.shared.values.clear();
+      this.seq = 0;
+      this.state = l.phase === "in_game" ? "playing" : "lobby";
+      this.linking = !l.isHost;
+      const on = this.unsub;
+      on.push(l.on("ready", () => this.linked()));
+      on.push(l.on("peerJoined", (p) => {
+        this.onEvent("player-joined", { player: this.toPlayer(p) });
+        this.onChange();
+      }));
+      on.push(l.on("peerLeft", (p, reason) => {
+        this.onEvent("player-left", { player: this.toPlayer(p), reason });
+        this.onChange();
+      }));
+      on.push(l.on("peerReady", (p) => {
+        if (l.isHost && p.peerId !== l.localPeerId) l.send(p.peerId, toBytes({ k: "SS", all: this.shared.all(), q: this.seq }));
+      }));
+      on.push(l.on("hostChanged", () => this.onChange()));
+      on.push(l.on("phase", (ph) => {
+        if (ph === "in_game" && this.state !== "playing") {
+          this.state = "playing";
+          this.onChange();
+          this.onEvent("start", {});
+        }
+      }));
+      on.push(l.on("message", (from, bytes) => this.onRaw(from, bytes)));
+      on.push(l.on("sessionEnded", (reason) => {
+        if (this.lobby !== l) return;
+        if (reason === "left") return;
+        this.fail(new OneLobbyError(reason));
+      }));
+      l.ready.then(() => {
+        if (this.lobby === l) this.linked();
+      }, () => {
+      });
+      this.onChange();
+      if (this.state === "playing" && !this.linking) this.onEvent("start", {});
+    }
+    linked() {
+      if (!this.linking) return;
+      this.linking = false;
+      this.onChange();
+      if (this.state === "playing") this.onEvent("start", {});
+    }
+    detach() {
+      this.gen++;
+      for (const u of this.unsub.splice(0)) u();
+      this.lobby = null;
+      this.linking = false;
+    }
+    fail(e) {
+      const l = this.lobby;
+      this.detach();
+      if (l) void l.leave();
+      this.state = "error";
+      this.error = describeError(e);
+      this.onChange();
+      this.onEvent("error", this.error);
+    }
+    playerById(id) {
+      const l = this.lobby;
+      if (!l || !id) return null;
+      return this.toPlayer(l.peer(id), id);
+    }
+    onRaw(from, bytes) {
+      let w;
+      try {
+        w = JSON.parse(dec3.decode(bytes));
+      } catch {
+        return;
+      }
+      if (!w || typeof w !== "object") return;
+      const l = this.lobby;
+      switch (w.k) {
+        case "m":
+          this.onEvent("message", { from: this.playerById(from), data: w.d });
+          break;
+        case "set":
+        case "add":
+          if (l.isHost) this.applyHost(w, from);
+          break;
+        case "S":
+          if (!l.isHost && from === l.hostPeerId && !(w.q <= this.seq)) {
+            this.seq = w.q;
+            this.applyValue(w.key, w.v, w.by);
+          }
+          break;
+        case "SS":
+          if (!l.isHost && from === l.hostPeerId && w.all && typeof w.all === "object" && !(w.q < this.seq)) {
+            this.seq = w.q;
+            for (const k of [...this.shared.values.keys()]) if (!(k in w.all)) this.applyValue(k, null, 0);
+            for (const [k, v] of Object.entries(w.all)) this.applyValue(k, v, 0);
+          }
+          break;
+      }
+    }
+    /** @internal from SharedState */
+    _sharedOp(op) {
+      const l = this.lobby;
+      if (!l) {
+        const v = op.k === "set" ? op.v : (Number(this.shared.values.get(op.key)) || 0) + op.n;
+        this.applyValue(op.key, v, 0);
+        return;
+      }
+      if (l.isHost) this.applyHost(op, l.localPeerId);
+      else l.send(l.hostPeerId, toBytes(op));
+    }
+    applyHost(op, by) {
+      const l = this.lobby;
+      if (typeof op.key !== "string") return;
+      const v = op.k === "set" ? op.v : (Number(this.shared.values.get(op.key)) || 0) + (Number(op.n) || 0);
+      this.applyValue(op.key, v, by);
+      l.broadcast(toBytes({ k: "S", key: op.key, v, by, q: ++this.seq }));
+    }
+    applyValue(key, v, by) {
+      if (v === null) this.shared.values.delete(key);
+      else this.shared.values.set(key, v);
+      this.onEvent("shared-change", { key, value: v, from: this.playerById(by) });
+    }
+  };
+
+  // src/ui/styles.ts
+  var LOBBY_CSS = `
+:host {
+  --onelobby-bg: #ffffff;
+  --onelobby-fg: #1b1f24;
+  --onelobby-muted: #57606a;
+  --onelobby-border: #d0d7de;
+  --onelobby-accent: #0b5cad;
+  --onelobby-accent-fg: #ffffff;
+  --onelobby-danger: #b42318;
+  --onelobby-field: #f6f8fa;
+  --onelobby-radius: 12px;
+  --onelobby-font: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+  display: block;
+  max-width: 28rem;
+  font-family: var(--onelobby-font);
+  color: var(--onelobby-fg);
+  line-height: 1.4;
+}
+:host([theme="dark"]) {
+  --onelobby-bg: #161b22; --onelobby-fg: #e6edf3; --onelobby-muted: #9da7b3; --onelobby-border: #30363d;
+  --onelobby-accent: #4c9be8; --onelobby-accent-fg: #0d1117; --onelobby-danger: #ff7b72; --onelobby-field: #0d1117;
+}
+@media (prefers-color-scheme: dark) {
+  :host([theme="auto"]), :host(:not([theme])) {
+    --onelobby-bg: #161b22; --onelobby-fg: #e6edf3; --onelobby-muted: #9da7b3; --onelobby-border: #30363d;
+    --onelobby-accent: #4c9be8; --onelobby-accent-fg: #0d1117; --onelobby-danger: #ff7b72; --onelobby-field: #0d1117;
+  }
+}
+[hidden] { display: none !important; }
+.card {
+  background: var(--onelobby-bg);
+  border: 1px solid var(--onelobby-border);
+  border-radius: var(--onelobby-radius);
+  padding: 1rem;
+  display: grid;
+  gap: 0.75rem;
+}
+.status { font-size: 1rem; margin: 0; }
+.status.error { color: var(--onelobby-danger); font-weight: 600; }
+.hint { margin: 0; color: var(--onelobby-muted); }
+label { display: grid; gap: 0.25rem; font-size: 0.9rem; color: var(--onelobby-muted); }
+input {
+  font: inherit; font-size: 1rem; color: var(--onelobby-fg); background: var(--onelobby-field);
+  border: 1px solid var(--onelobby-border); border-radius: 8px; padding: 0.6rem 0.7rem; min-height: 44px; box-sizing: border-box; width: 100%;
+}
+#code { text-transform: uppercase; letter-spacing: 0.15em; font-family: ui-monospace, Consolas, monospace; }
+button {
+  font: inherit; font-size: 1rem; min-height: 44px; padding: 0.5rem 1rem; border-radius: 8px; cursor: pointer;
+  border: 1px solid var(--onelobby-border); background: var(--onelobby-field); color: var(--onelobby-fg);
+}
+button.primary { background: var(--onelobby-accent); color: var(--onelobby-accent-fg); border-color: var(--onelobby-accent); font-weight: 600; }
+button:disabled { opacity: 0.55; cursor: not-allowed; }
+button:focus-visible, input:focus-visible { outline: 3px solid var(--onelobby-accent); outline-offset: 2px; }
+.row { display: flex; gap: 0.5rem; flex-wrap: wrap; align-items: end; }
+.row > label { flex: 1 1 10rem; }
+.or { text-align: center; color: var(--onelobby-muted); font-size: 0.9rem; }
+.codebox { display: grid; gap: 0.5rem; justify-items: start; }
+.code {
+  font-family: ui-monospace, Consolas, monospace; font-size: clamp(2rem, 9vw, 2.75rem); font-weight: 700;
+  letter-spacing: 0.12em; user-select: all;
+}
+h3 { margin: 0; font-size: 0.9rem; color: var(--onelobby-muted); font-weight: 600; }
+ul { list-style: none; margin: 0; padding: 0; display: grid; gap: 0.25rem; }
+li { display: flex; gap: 0.5rem; align-items: center; }
+.tag { font-size: 0.75rem; border: 1px solid var(--onelobby-border); border-radius: 999px; padding: 0 0.5rem; color: var(--onelobby-muted); }
+.bar { display: flex; gap: 0.5rem; flex-wrap: wrap; align-items: center; justify-content: space-between; }
+.sr { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }
+`;
+
+  // src/ui/server-url.ts
+  function lobbyServerUrl(raw) {
+    const s = (raw ?? "").trim();
+    if (!s || /\s/.test(s)) return null;
+    if (/your[-_ ]?(lobby[-_ ]?)?server|replace[-_ ]?me|<|>/i.test(s)) return null;
+    let url = s;
+    if (/^https?:\/\//i.test(url)) url = url.replace(/^http/i, "ws");
+    else if (!/^wss?:\/\//i.test(url)) url = "wss://" + url;
+    let u;
+    try {
+      u = new URL(url);
+    } catch {
+      return null;
+    }
+    const host = u.hostname.toLowerCase();
+    if (!host) return null;
+    if (/(^|\.)example\.(com|net|org)$/.test(host) || /\.example$/.test(host) || host === "example") return null;
+    if (!host.includes(".") && !host.includes(":") && host !== "localhost") return null;
+    return url;
+  }
+
+  // src/ui/element.ts
+  var LOBBY_TAG = "one-lobby";
+  var NAME_KEY = "onelobby-name";
+  var TEMPLATE = `
+<div class="card" part="card">
+  <p class="status" id="status" role="status" aria-live="polite"></p>
+  <p class="hint" id="hint" hidden></p>
+
+  <div id="v-idle" class="view">
+    <div class="row">
+      <label id="nameLabel">Your name
+        <input id="name" maxlength="24" autocomplete="nickname" placeholder="e.g. Sam">
+      </label>
+    </div>
+    <div class="row" style="margin-top:.75rem">
+      <button id="host" class="primary" type="button">Host a game</button>
+    </div>
+    <p class="or">or join a friend</p>
+    <form id="joinForm" class="row">
+      <label>Game code
+        <input id="code" maxlength="9" autocomplete="off" autocapitalize="characters" spellcheck="false" placeholder="ABC 123">
+      </label>
+      <button id="join" type="submit">Join</button>
+    </form>
+  </div>
+
+  <div id="v-busy" class="view" hidden>
+    <button id="cancel" type="button">Cancel</button>
+  </div>
+
+  <div id="v-lobby" class="view" hidden>
+    <div class="codebox">
+      <h3>Game code</h3>
+      <span class="code" id="codeText"></span>
+      <div class="row">
+        <button id="copyCode" type="button">Copy code</button>
+        <button id="copyLink" type="button">Copy invite link</button>
+      </div>
+      <span class="sr" id="copied" aria-live="polite"></span>
+    </div>
+    <h3 id="playersTitle" style="margin-top:.75rem">Players</h3>
+    <ul id="players" aria-labelledby="playersTitle"></ul>
+    <div class="bar" style="margin-top:.75rem">
+      <button id="start" class="primary" type="button">Start</button>
+      <button id="leave" type="button">Leave</button>
+    </div>
+  </div>
+
+  <div id="v-error" class="view" hidden>
+    <div class="row">
+      <button id="retry" class="primary" type="button">Try again</button>
+      <button id="back" type="button">Back</button>
+    </div>
+  </div>
+</div>
+`;
+  function readStored() {
+    try {
+      return localStorage.getItem(NAME_KEY) ?? "";
+    } catch {
+      return "";
+    }
+  }
+  function store(name) {
+    try {
+      localStorage.setItem(NAME_KEY, name);
+    } catch {
+    }
+  }
+  async function copyText(text) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } catch {
+      const ta = document.createElement("textarea");
+      ta.value = text;
+      ta.style.position = "fixed";
+      ta.style.opacity = "0";
+      document.body.appendChild(ta);
+      ta.select();
+      let ok = false;
+      try {
+        ok = document.execCommand("copy");
+      } catch {
+        ok = false;
+      }
+      ta.remove();
+      return ok;
+    }
+  }
+  function makeClass() {
+    class OneLobbyBox extends HTMLElement {
+      static observedAttributes = ["name", "theme"];
+      /** @internal exposed for debugging and tests */
+      _controller;
+      root;
+      $ = (id) => this.root.getElementById(id);
+      autoJoined = false;
+      copiedTimer;
+      constructor() {
+        super();
+        this.root = this.attachShadow({ mode: "open" });
+        this.root.innerHTML = `<style>${LOBBY_CSS}</style>${TEMPLATE}`;
+        this._controller = new LobbyController({ makeKit: (name) => this.makeKit(name), maxPlayers: () => this.maxPlayers });
+        this._controller.onChange = () => this.render();
+        this._controller.onEvent = (type, detail) => this.dispatchEvent(new CustomEvent(type, { detail, bubbles: true, composed: true }));
+        this.wire();
+      }
+      // ---- public API ----------------------------------------------------------------------------------------------
+      get isHost() {
+        return this._controller.isHost;
+      }
+      get players() {
+        return this._controller.players;
+      }
+      get code() {
+        return this._controller.code;
+      }
+      get state() {
+        return this._controller.state;
+      }
+      get shared() {
+        return this._controller.shared;
+      }
+      send(data) {
+        this._controller.send(data);
+      }
+      host() {
+        return this._controller.host(this.playerName());
+      }
+      join(code) {
+        return this._controller.join(code, this.playerName());
+      }
+      start() {
+        return this._controller.start();
+      }
+      leave() {
+        return this._controller.leave();
+      }
+      // ---- lifecycle -----------------------------------------------------------------------------------------------
+      connectedCallback() {
+        const name = this.getAttribute("name");
+        const input = this.$("name");
+        if (!input.value) input.value = name ?? readStored();
+        this.$("nameLabel").hidden = !!name;
+        this.render();
+        if (!this.autoJoined) {
+          this.autoJoined = true;
+          const code = codeFromUrl();
+          if (code && this._controller.state === "idle") {
+            this.$("code").value = formatCode(code);
+            if (input.value.trim()) void this.join(code);
+            else {
+              this.$("status").textContent = "You're invited! Type your name, then press Join.";
+              input.focus();
+            }
+          } else if (!code && this._controller.state === "idle" && lobbyServerUrl(this.getAttribute("server"))) {
+            void this._controller.resume(input.value.trim());
+          }
+        }
+      }
+      disconnectedCallback() {
+        if (this._controller.lobby) void this._controller.leave();
+      }
+      attributeChangedCallback(attr) {
+        if (attr === "name" && this.isConnected) {
+          const v = this.getAttribute("name");
+          if (v) this.$("name").value = v;
+          this.$("nameLabel").hidden = !!v;
+        }
+      }
+      // ---- internals -----------------------------------------------------------------------------------------------
+      get maxPlayers() {
+        const n = parseInt(this.getAttribute("max-players") ?? "", 10);
+        return Number.isFinite(n) && n >= 2 ? Math.min(n, 250) : 8;
+      }
+      playerName() {
+        const v = this.$("name").value.trim() || this.getAttribute("name") || "";
+        if (!this.getAttribute("name") && v) store(v);
+        return v;
+      }
+      makeKit(name) {
+        const server = lobbyServerUrl(this.getAttribute("server"));
+        if (!server) throw new OneLobbyError("no_server", "the <one-lobby> tag has no usable server address");
+        return new OneLobby({
+          gameId: this.getAttribute("game") || "onelobby-drop-in",
+          netVersion: this.getAttribute("version") || "1",
+          lobbyServer: server,
+          mode: "raw",
+          displayName: name,
+          // joiners give up (with a friendly "couldn't connect" and a retry button) after this long
+          readyTimeoutMs: 15e3,
+          advanced: { createMic: null, createSink: null, voiceCodec: null }
+        });
+      }
+      wire() {
+        const on = (id, ev, fn) => this.$(id).addEventListener(ev, fn);
+        on("host", "click", () => void this.host());
+        on("joinForm", "submit", (e) => {
+          e.preventDefault();
+          void this.join(this.$("code").value);
+        });
+        on("cancel", "click", () => this._controller.reset());
+        on("start", "click", () => void this.start());
+        on("leave", "click", () => void this.leave());
+        on("retry", "click", () => void this._controller.retry());
+        on("back", "click", () => this._controller.reset());
+        on("copyCode", "click", () => void this.copy(this.code ?? "", "copyCode", "Copied!"));
+        on("copyLink", "click", () => void this.copy(this.code ? shareUrl(this.code) : "", "copyLink", "Link copied!"));
+      }
+      async copy(text, id, done) {
+        if (!text) return;
+        const ok = await copyText(text);
+        const btn = this.$(id);
+        const label = id === "copyCode" ? "Copy code" : "Copy invite link";
+        btn.textContent = ok ? done : "Couldn't copy, select it by hand";
+        this.$("copied").textContent = ok ? done : "";
+        clearTimeout(this.copiedTimer);
+        this.copiedTimer = setTimeout(() => {
+          btn.textContent = label;
+          this.$("copied").textContent = "";
+        }, 2e3);
+      }
+      render() {
+        const c = this._controller;
+        const s = c.state;
+        const status = this.$("status");
+        status.textContent = s === "error" && c.error?.code === "no_server" ? "This page is missing its lobby server address." : c.statusText;
+        status.classList.toggle("error", s === "error");
+        const hint = this.$("hint");
+        const hintText = s === "error" ? c.error?.code === "no_server" ? 'Put your lobby server address in server="\u2026" on the <one-lobby> tag (it looks like https://your-name.onrender.com). The guide shows how to get one.' : c.error?.hint ?? "" : "";
+        hint.textContent = hintText;
+        hint.hidden = !hintText;
+        this.$("v-idle").hidden = s !== "idle";
+        this.$("v-busy").hidden = s !== "connecting";
+        this.$("v-lobby").hidden = s !== "lobby" && s !== "playing";
+        this.$("v-error").hidden = s !== "error";
+        this.setAttribute("state", s);
+        if (s === "lobby" || s === "playing") {
+          this.$("codeText").textContent = formatCode(c.code ?? "");
+          const ul = this.$("players");
+          ul.replaceChildren(
+            ...c.players.map((p) => {
+              const li = document.createElement("li");
+              const nm = document.createElement("span");
+              nm.textContent = p.name;
+              li.append(nm);
+              if (p.isHost) li.append(Object.assign(document.createElement("span"), { className: "tag", textContent: "host" }));
+              if (p.isMe) li.append(Object.assign(document.createElement("span"), { className: "tag", textContent: "you" }));
+              return li;
+            })
+          );
+          const start = this.$("start");
+          start.hidden = !c.isHost || s === "playing";
+          start.disabled = c.players.length < 2;
+          start.title = start.disabled ? "Wait for at least one more player" : "";
+        }
+      }
+    }
+    return OneLobbyBox;
+  }
+  function defineLobbyElement(tag = LOBBY_TAG) {
+    if (typeof customElements === "undefined" || customElements.get(tag)) return;
+    customElements.define(tag, makeClass());
+  }
+
+  // src/ui/index.ts
+  defineLobbyElement();
+  return __toCommonJS(global_exports);
+})();
+//# sourceMappingURL=onelobby.global.js.map