onelobby 0.1.0 → 0.2.0

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.0";
 /** 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.0 | 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,118 @@ var OneLobby = (() => {
     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;
@@ -1682,6 +1795,10 @@ var OneLobby = (() => {
     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`
@@ -1765,6 +1882,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;
     }
@@ -1972,6 +2104,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 +2189,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 +2199,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 +2243,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 });
@@ -2224,6 +2367,8 @@ var OneLobby = (() => {
       }
       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);
@@ -2255,6 +2400,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,6 +2410,22 @@ 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");
@@ -2306,7 +2470,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 +2478,7 @@ var OneLobby = (() => {
         },
         error: (e) => console.error("onelobby: AudioEncoder", e)
       });
-      enc3.configure({
+      enc4.configure({
         codec: "opus",
         sampleRate: SAMPLE_RATE,
         numberOfChannels: 1,
@@ -2332,17 +2496,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 +2515,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();
         }
       };
     }
@@ -2672,7 +2836,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
 
   // src/onelobby.ts
   var LIB_NAME = "onelobby";
-  var LIB_VERSION = "0.1.0";
+  var LIB_VERSION = "0.2.0";
   var DEFAULT_READY_TIMEOUT_MS = 15e3;
   function hasMic() {
     return typeof navigator !== "undefined" && !!navigator.mediaDevices?.getUserMedia && typeof AudioWorkletNode !== "undefined";
@@ -2712,7 +2876,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 +2986,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 +2999,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 +3032,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;
@@ -2936,7 +3103,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;
@@ -3069,9 +3236,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 +3479,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;
       }