onelobby 0.1.0 → 0.2.1

package/dist/onelobby.d.ts

@@ -1,11 +1,11 @@
 import { type Clock } from "./clock.js";
 import { Emitter } from "./emitter.js";
-import { Lobby } from "./lobby.js";
+import { Lobby, type RateLimit } from "./lobby.js";
 import { type LobbySummary } from "./signaling.js";
 import { type LinkFactory, type SocketFactory } from "./transport.js";
 import type { VoiceCodec, FrameSource, AudioSink } from "./voice-types.js";
 export declare const LIB_NAME = "onelobby";
-export declare const LIB_VERSION = "0.1.0";
+export declare const LIB_VERSION = "0.2.1";
 /** Where `rememberSeat` keeps the resume token: the subset of the Web Storage API it uses. */
 export interface SeatStorage {
     getItem(key: string): string | null;
@@ -44,6 +44,13 @@ export interface OneLobbyOptions {
      * Default 15000; 0 waits forever.
      */
     readyTimeoutMs?: number;
+    /**
+     * Treat a peer as gone after this many ms of silence. Joiners ping the host every 2 s and the host answers, so the
+     * host drops a silent joiner (`peerLeft`, "timeout") and a joiner handles a silent host as lost (a direct lobby
+     * ends with "host_left"). Default 0 (off): a silently dead peer then surfaces when its link or signaling socket
+     * times out, within about 30 s. Values under 6000 are raised to 6000.
+     */
+    peerTimeoutMs?: number;
     /**
      * Keep this tab's seat across a page reload (sessionStorage): `join(code)` and `resume()` take the seat back
      * instead of joining as a new player. Cleared when the session ends. Default true where sessionStorage exists.
@@ -76,6 +83,8 @@ export interface HostOptions {
     visibility?: "public" | "unlisted" | "private";
     lateJoin?: boolean;
     meta?: Record<string, string>;
+    /** Per-joiner cap on incoming raw messages, e.g. `{ messages: 60, perMs: 1000 }`; the excess is dropped before `message` fires or is relayed. */
+    rateLimit?: RateLimit;
 }
 export interface ListOptions {
     meta?: Record<string, string>;
@@ -102,7 +111,7 @@ export type OneLobbyEvents = {
 export declare const DEFAULT_READY_TIMEOUT_MS = 15000;
 /** Entry point (DESIGN s.11.2). */
 export declare class OneLobby extends Emitter<OneLobbyEvents> {
-    readonly options: Required<Pick<OneLobbyOptions, "gameId" | "netVersion" | "lobbyServer" | "mode" | "tickRate" | "hashEveryTicks" | "displayName" | "relayOnly" | "readyTimeoutMs">>;
+    readonly options: Required<Pick<OneLobbyOptions, "gameId" | "netVersion" | "lobbyServer" | "mode" | "tickRate" | "hashEveryTicks" | "displayName" | "relayOnly" | "readyTimeoutMs" | "peerTimeoutMs">>;
     private socketFactory;
     private linkFactory;
     private clock;

package/dist/onelobby.global.js

@@ -1,4 +1,4 @@
-/*! onelobby 0.1.0 | MIT license */
+/*! onelobby 0.2.1 | MIT license */
 "use strict";
 var OneLobby = (() => {
   var __defProp = Object.defineProperty;
@@ -33,10 +33,12 @@ var OneLobby = (() => {
     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,
@@ -1622,7 +1624,141 @@ var OneLobby = (() => {
     static END = FLAG_END_OF_BURST;
   };
 
+  // src/socket.ts
+  function closeCodeFor(reason) {
+    if (reason === "left" || reason === "disconnected") return 1e3;
+    if (reason === "host_left" || reason === "closed") return 1001;
+    if (reason === "kicked") return 4e3;
+    return 1006;
+  }
+  var nextTask = globalThis.setImmediate ?? ((f) => void setTimeout(f, 0));
+  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;
+    openHandler = null;
+    /** OPEN, but `onopen` has not run yet for any handler. */
+    openPending = false;
+    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();
+    }
+    get onopen() {
+      return this.openHandler;
+    }
+    set onopen(h) {
+      this.openHandler = h;
+      if (h && this.openPending) nextTask(() => this.fireOpen());
+    }
+    /**
+     * @internal OPEN now; `onopen` now, or on a later task (like a real WebSocket) so a handler assigned
+     * after any number of awaits in the same task still runs.
+     */
+    open(later = false) {
+      if (this.readyState !== 0) return;
+      this.readyState = 1;
+      this.openPending = true;
+      if (!later) this.fireOpen();
+      else nextTask(() => this.fireOpen());
+    }
+    fireOpen() {
+      if (this.readyState !== 1 || !this.openPending || !this.openHandler) return;
+      this.openPending = false;
+      this.openHandler({ 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, close) => s.closed(close?.code ?? closeCodeFor(reason), close?.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, close) => conns.get(p.peerId)?.closed(close?.code ?? (reason === "left" ? 1001 : closeCodeFor(reason)), close?.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;
+  var KICK_LINGER_MS = 3e3;
   function seatName(p) {
     const n = typeof p.name === "string" ? p.name.trim() : "";
     if (n && n !== "Player") return p;
@@ -1682,10 +1818,16 @@ var OneLobby = (() => {
     isReady = false;
     cancelReadyTimer = null;
     relayRetry = false;
+    /** clock.now() of the last frame from each peer (peerTimeoutMs). */
+    lastHeard = /* @__PURE__ */ new Map();
+    /** Host: links of kicked / disconnected peers, kept open briefly (removePeer `linger`). */
+    lingering = /* @__PURE__ */ new Set();
+    /** 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).
+     * (or with "closed"/"kicked" when the lobby ends first; "closed" also when the host disconnected it).
      */
     ready = new Promise((res, rej) => {
       this.markReady = () => {
@@ -1765,6 +1907,21 @@ var OneLobby = (() => {
     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;
     }
@@ -1798,10 +1955,32 @@ var OneLobby = (() => {
       this.signaling.send({ t: "meta", meta });
       this.emit("metaChanged", this.meta);
     }
-    async kick(peerId) {
+    /**
+     * Host: removes a player. By default it is a ban: the hub refuses that player's address for the rest of this lobby
+     * (a new tab or a reload included). `{ ban: false }` is `disconnect()`. `code` / `reason` reach the player's
+     * `asWebSocket()` onclose (and `sessionEnded`'s second argument); without them its socket closes with 4000 "kicked".
+     */
+    async kick(peerId, opts = {}) {
       if (!this.isHost) throw new Error("only the host can kick");
-      this.signaling.send({ t: "kick", peerId });
-      this.removePeer(peerId, "kicked");
+      const { ban = true, code, reason } = opts;
+      if (code !== void 0 && !(code === 1e3 || Number.isInteger(code) && code >= 3e3 && code <= 4999))
+        throw new RangeError("close code must be 1000 or 3000-4999");
+      if (reason !== void 0 && reason.length > 120) throw new RangeError("close reason must be at most 120 characters");
+      const msg = { t: "kick", peerId };
+      if (!ban) msg.ban = false;
+      if (code !== void 0) msg.closeCode = code;
+      if (reason !== void 0) msg.closeReason = reason;
+      this.signaling.send(msg);
+      const close = code !== void 0 || reason !== void 0 ? { code, reason } : void 0;
+      this.removePeer(peerId, ban ? "kicked" : "disconnected", close, true);
+    }
+    /**
+     * Host: ends one player's connection without a ban, like a server closing one WebSocket. The player's
+     * `asWebSocket()` gets onclose with `code` (default 1000) and `reason` (default "disconnected"), its lobby ends with
+     * `sessionEnded("disconnected")`, and it may join again (a new tab, a reload). Same as `kick(peerId, { ban: false, code, reason })`.
+     */
+    disconnect(peerId, code, reason) {
+      return this.kick(peerId, { ban: false, code, reason });
     }
     async approve(peerId, ok) {
       if (!this.isHost) throw new Error("only the host can approve joins");
@@ -1972,6 +2151,7 @@ var OneLobby = (() => {
         return;
       }
       if (!d) return;
+      if (!reassembled) this.lastHeard.set(from, this.cfg.clock.now());
       const { msg, route } = d;
       switch (msg.type) {
         case "hi":
@@ -2056,6 +2236,7 @@ var OneLobby = (() => {
         this.emit("message", route, bytes, channel);
         return;
       }
+      if (!this.allowRaw(from)) return;
       if (route === 0 || route === this.localPeerId) {
         this.emit("message", from, bytes, channel);
       }
@@ -2065,6 +2246,14 @@ var OneLobby = (() => {
         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;
@@ -2101,6 +2290,7 @@ var OneLobby = (() => {
       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 });
@@ -2191,8 +2381,13 @@ var OneLobby = (() => {
           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));
+          if (m.code === "kicked") {
+            const d = m.data ?? {};
+            const close = {};
+            if (typeof d.closeCode === "number") close.code = d.closeCode;
+            if (typeof d.closeReason === "string") close.reason = d.closeReason;
+            this.teardown(d.ban === false ? "disconnected" : "kicked", close.code !== void 0 || close.reason !== void 0 ? close : void 0);
+          } else this.reportError(new OneLobbyError(String(m.code), String(m.msg ?? ""), m.data));
           break;
       }
     }
@@ -2207,7 +2402,12 @@ var OneLobby = (() => {
       if (s.ice) payload.ice = s.ice;
       await link.handleSignal(payload);
     }
-    removePeer(peerId, reason) {
+    /**
+     * `linger` (host kick / disconnect): stop using the peer's link at once but leave it open until that peer closes it
+     * or KICK_LINGER_MS pass. The hub tells the peer over its WebSocket; closing the data link first would make it look
+     * like the host vanished (a migration and a 1001 instead of the host's close code).
+     */
+    removePeer(peerId, reason, close, linger = false) {
       const peer = this.roster.get(peerId);
       if (peerId === this.localPeerId) {
         this.teardown(reason === "kicked" ? "kicked" : reason);
@@ -2216,25 +2416,40 @@ var OneLobby = (() => {
       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);
+        if (linger) {
+          this.lingering.add(link);
+          const done = () => {
+            if (!this.lingering.delete(link)) return;
+            cancel();
+            link.onClose = null;
+            link.close();
+          };
+          const cancel = this.cfg.clock.setTimeout(done, KICK_LINGER_MS);
+          link.onClose = done;
+        } else {
+          link.onClose = null;
+          link.close();
+        }
       }
       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 (peer) this.emit("peerLeft", peer, reason, close);
       if (peerId === this.hostPeerId && !this.isHost) {
         this.handleHostLost(reason);
       }
     }
+    /** Lockstep drops (stalled, desynced): removed without a ban, so the player can come back (a rejoin resyncs). */
     dropPeer(peerId, reason) {
-      this.signaling.send({ t: "kick", peerId });
-      this.removePeer(peerId, reason);
+      this.signaling.send({ t: "kick", peerId, ban: false, closeReason: reason });
+      this.removePeer(peerId, reason, void 0, true);
     }
     setPhase(p) {
       if (p !== "lobby" && p !== "in_game") return;
@@ -2255,6 +2470,9 @@ var OneLobby = (() => {
     }
     // ---- 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();
@@ -2262,11 +2480,27 @@ var OneLobby = (() => {
         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) {
+    teardown(reason, close) {
       if (this.ended) return;
       this.ended = true;
       this.cancelReadyTimer?.();
@@ -2278,16 +2512,17 @@ var OneLobby = (() => {
       this.cancelPing?.();
       this.lockstep.stop();
       this.voice.close();
-      for (const l of this.links.values()) {
+      for (const l of [...this.links.values(), ...this.lingering]) {
         l.onClose = null;
         l.onMessage = null;
         l.close();
       }
       this.links.clear();
+      this.lingering.clear();
       this.signaling.onClose = null;
       this.signaling.onMessage = null;
       this.signaling.close();
-      this.emit("sessionEnded", reason);
+      this.emit("sessionEnded", reason, close);
     }
     /** Total in-flight links (diagnostics and tests). */
     get linkCount() {
@@ -2306,7 +2541,7 @@ var OneLobby = (() => {
   var webCodecsOpus = {
     createEncoder(opts, onFrame) {
       let ts = 0;
-      const enc3 = new AudioEncoder({
+      const enc4 = new AudioEncoder({
         output: (chunk) => {
           const out = new Uint8Array(chunk.byteLength);
           chunk.copyTo(out);
@@ -2314,7 +2549,7 @@ var OneLobby = (() => {
         },
         error: (e) => console.error("onelobby: AudioEncoder", e)
       });
-      enc3.configure({
+      enc4.configure({
         codec: "opus",
         sampleRate: SAMPLE_RATE,
         numberOfChannels: 1,
@@ -2332,17 +2567,17 @@ var OneLobby = (() => {
             data: pcm
           });
           ts += 2e4;
-          enc3.encode(data);
+          enc4.encode(data);
           data.close();
         },
         close() {
-          if (enc3.state !== "closed") enc3.close();
+          if (enc4.state !== "closed") enc4.close();
         }
       };
     },
     createDecoder(onPcm) {
       let ts = 0;
-      const dec3 = new AudioDecoder({
+      const dec4 = new AudioDecoder({
         output: (audio) => {
           const pcm = new Float32Array(audio.numberOfFrames);
           audio.copyTo(pcm, { planeIndex: 0, format: "f32-planar" });
@@ -2351,18 +2586,18 @@ var OneLobby = (() => {
         },
         error: (e) => console.error("onelobby: AudioDecoder", e)
       });
-      dec3.configure({ codec: "opus", sampleRate: SAMPLE_RATE, numberOfChannels: 1 });
+      dec4.configure({ codec: "opus", sampleRate: SAMPLE_RATE, numberOfChannels: 1 });
       return {
         decode(opus) {
           if (opus === null) {
             onPcm(new Float32Array(FRAME_SAMPLES));
             return;
           }
-          dec3.decode(new EncodedAudioChunk({ type: "key", timestamp: ts, data: opus }));
+          dec4.decode(new EncodedAudioChunk({ type: "key", timestamp: ts, data: opus }));
           ts += 2e4;
         },
         close() {
-          if (dec3.state !== "closed") dec3.close();
+          if (dec4.state !== "closed") dec4.close();
         }
       };
     }
@@ -2597,6 +2832,29 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     }
     return crc;
   }
+  function parseIPv4(ip) {
+    const parts = ip.split(".");
+    if (parts.length !== 4) return null;
+    let n = 0;
+    for (const p of parts) {
+      if (!/^\d{1,3}$/.test(p) || Number(p) > 255) return null;
+      n = n * 256 + Number(p);
+    }
+    return n;
+  }
+  function encodeJoinCode(ipv4, port) {
+    const ip = parseIPv4(ipv4);
+    if (ip === null) throw new Error(`not an IPv4 address: ${ipv4}`);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`bad port ${port}`);
+    const data = BigInt(ip) << 16n | BigInt(port);
+    let v = data << 5n | BigInt(crc5(data, 50));
+    let s = "";
+    for (let i = 0; i < JOIN_CODE_LENGTH; i++) {
+      s = CROCKFORD_ALPHABET[Number(v & 31n)] + s;
+      v >>= 5n;
+    }
+    return `${s.slice(0, 4)}-${s.slice(4, 8)}-${s.slice(8)}`;
+  }
   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;
@@ -2672,7 +2930,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
 
   // src/onelobby.ts
   var LIB_NAME = "onelobby";
-  var LIB_VERSION = "0.1.0";
+  var LIB_VERSION = "0.2.1";
   var DEFAULT_READY_TIMEOUT_MS = 15e3;
   function hasMic() {
     return typeof navigator !== "undefined" && !!navigator.mediaDevices?.getUserMedia && typeof AudioWorkletNode !== "undefined";
@@ -2712,7 +2970,8 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
         hashEveryTicks: o.hashEveryTicks ?? tickRate,
         displayName: (o.displayName ?? "").trim(),
         relayOnly: o.relayOnly ?? false,
-        readyTimeoutMs: o.readyTimeoutMs ?? DEFAULT_READY_TIMEOUT_MS
+        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];
@@ -2821,7 +3080,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
         throw e;
       }
     }
-    makeLobby(sig, welcome, state, direct) {
+    makeLobby(sig, welcome, state, direct, rateLimit) {
       const lobby = new Lobby({
         signaling: sig,
         state,
@@ -2834,7 +3093,9 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
         relayOnly: state.relayOnly ?? this.options.relayOnly,
         displayName: this.options.displayName,
         voice: { codec: this.voiceCodec, createSource: this.createMic, createSink: this.createSink },
-        readyTimeoutMs: this.options.readyTimeoutMs
+        readyTimeoutMs: this.options.readyTimeoutMs,
+        peerTimeoutMs: this.options.peerTimeoutMs,
+        rateLimit
       });
       lobby.errorSink = (e) => this.emit("error", e);
       if (this.storage && !direct) {
@@ -2865,7 +3126,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
           },
           "lobby"
         );
-        return this.makeLobby(sig, welcome, state);
+        return this.makeLobby(sig, welcome, state, void 0, h.rateLimit);
       } catch (e) {
         sig.close();
         throw e;
@@ -2913,7 +3174,9 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       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 });
+        const lobby = this.makeLobby(sig, welcome, state, { links });
+        lobby.joinCode = joinedWith(addr);
+        return lobby;
       } catch (e) {
         sig.close();
         throw e;
@@ -2936,7 +3199,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
           },
           "lobby"
         );
-        return this.makeLobby(sig, welcome, state, { links: hooks.wrapLinks(this.linkFactory) });
+        return this.makeLobby(sig, welcome, state, { links: hooks.wrapLinks(this.linkFactory) }, h.rateLimit);
       } catch (e) {
         sig.close();
         throw e;
@@ -2972,6 +3235,14 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       }
     }
   };
+  function joinedWith(addr) {
+    if (addr.isIPv6) return addr.display;
+    try {
+      return encodeJoinCode(addr.host, addr.port);
+    } catch {
+      return addr.display;
+    }
+  }
 
   // src/friendly.ts
   var TEXT = {
@@ -3069,9 +3340,9 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
   var KeepaliveError = OneLobbyError;
 
   // src/ui/controller.ts
-  var enc2 = new TextEncoder();
-  var dec2 = new TextDecoder();
-  var toBytes = (w) => enc2.encode(JSON.stringify(w));
+  var enc3 = new TextEncoder();
+  var dec3 = new TextDecoder();
+  var toBytes = (w) => enc3.encode(JSON.stringify(w));
   var SharedState = class {
     constructor(c) {
       this.c = c;
@@ -3312,7 +3583,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     onRaw(from, bytes) {
       let w;
       try {
-        w = JSON.parse(dec2.decode(bytes));
+        w = JSON.parse(dec3.decode(bytes));
       } catch {
         return;
       }