onelobby 0.2.0 → 0.2.2

package/dist/onelobby.d.ts

@@ -5,7 +5,7 @@ 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.2.0";
+export declare const LIB_VERSION = "0.2.2";
 /** Where `rememberSeat` keeps the resume token: the subset of the Web Storage API it uses. */
 export interface SeatStorage {
     getItem(key: string): string | null;

package/dist/onelobby.global.js

@@ -1,4 +1,4 @@
-/*! onelobby 0.2.0 | MIT license */
+/*! onelobby 0.2.2 | MIT license */
 "use strict";
 var OneLobby = (() => {
   var __defProp = Object.defineProperty;
@@ -1146,8 +1146,19 @@ var OneLobby = (() => {
     cancelPing = null;
     pingN = 0;
     closed = false;
-    onMessage = null;
+    handler = null;
+    // Messages with no waiter and no handler yet. The reply that resolves join/create can arrive in the same socket
+    // read as the host's first offer; both are dispatched before the awaiting code builds its Lobby and sets a handler.
+    backlog = [];
     onClose = null;
+    get onMessage() {
+      return this.handler;
+    }
+    /** Setting a handler first delivers, in order, what arrived while there was none. */
+    set onMessage(h) {
+      this.handler = h;
+      while (h && this.handler === h && this.backlog.length) h(this.backlog.shift());
+    }
     connect() {
       return new Promise((resolve, reject) => {
         let s;
@@ -1187,7 +1198,8 @@ var OneLobby = (() => {
             else w.resolve(m);
             return;
           }
-          this.onMessage?.(m);
+          if (this.handler) this.handler(m);
+          else if (this.backlog.length < 256) this.backlog.push(m);
         };
         s.onclose = () => {
           if (!this.lastRx) reject(new OneLobbyError("connect_failed", `cannot reach ${this.url}`));
@@ -1626,11 +1638,12 @@ var OneLobby = (() => {
 
   // src/socket.ts
   function closeCodeFor(reason) {
-    if (reason === "left") return 1e3;
+    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 {
@@ -1646,7 +1659,9 @@ var OneLobby = (() => {
     onLocalClose;
     readyState = 0;
     bufferedAmount = 0;
-    onopen = null;
+    openHandler = null;
+    /** OPEN, but `onopen` has not run yet for any handler. */
+    openPending = false;
     onmessage = null;
     onclose = null;
     onerror = null;
@@ -1662,12 +1677,28 @@ var OneLobby = (() => {
       this.closed(code, reason);
       this.onLocalClose();
     }
-    /** @internal OPEN now; `onopen` now, or one microtask later so a handler assigned right after creation still runs. */
+    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;
-      if (!later) this.onopen?.({ type: "open" });
-      else queueMicrotask(() => this.readyState === 1 && this.onopen?.({ type: "open" }));
+      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) {
@@ -1689,7 +1720,7 @@ var OneLobby = (() => {
       lobby.on("message", (from, bytes) => {
         if (from === lobby.hostPeerId) s.deliver(bytes);
       }),
-      lobby.on("sessionEnded", (reason) => s.closed(closeCodeFor(reason), reason)),
+      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"))
     ];
@@ -1722,7 +1753,10 @@ var OneLobby = (() => {
     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(
+        "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());
@@ -1736,6 +1770,7 @@ var OneLobby = (() => {
 
   // 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;
@@ -1775,6 +1810,8 @@ var OneLobby = (() => {
     cfg;
     roster = /* @__PURE__ */ new Map();
     links = /* @__PURE__ */ new Map();
+    /** ICE from a peer that has no link yet: its candidates can overtake its offer (node-datachannel). */
+    earlyIce = /* @__PURE__ */ new Map();
     connected = /* @__PURE__ */ new Set();
     // host: peers that said hi
     hiSentTo = /* @__PURE__ */ new Set();
@@ -1797,12 +1834,14 @@ var OneLobby = (() => {
     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 = () => {
@@ -1930,10 +1969,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");
@@ -2334,36 +2395,71 @@ 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;
       }
     }
     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;
+      if (s.sdp?.type === "offer") {
+        link = this.makeLink(from);
+        const early = this.earlyIce.get(from) ?? [];
+        this.earlyIce.delete(from);
+        const done = link.handleSignal(payload);
+        for (const e of early) void link.handleSignal(e);
+        await done;
+        return;
+      }
+      if (!link) {
+        if (!payload.ice || this.ended || !this.roster.has(from)) return;
+        const q = this.earlyIce.get(from) ?? [];
+        if (q.length < 64) q.push(payload);
+        this.earlyIce.set(from, q);
+        return;
+      }
       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);
         return;
       }
       if (peer) this.roster.delete(peerId);
+      this.earlyIce.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);
@@ -2372,14 +2468,15 @@ var OneLobby = (() => {
       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;
@@ -2430,7 +2527,7 @@ var OneLobby = (() => {
       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?.();
@@ -2442,16 +2539,18 @@ 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.earlyIce.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() {
@@ -2620,8 +2719,14 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     pc;
     channels = {};
     pendingIce = [];
+    /**
+     * Set once setRemoteDescription resolves. Not `pc.remoteDescription`: node-datachannel's polyfill returns an object
+     * there before any is set, and its addIceCandidate throws until one is.
+     */
+    haveRemote = false;
     closed = false;
     opened = 0;
+    early = [];
     extra;
     /** `rtc`: the RTCPeerConnection class to use (default the global one; in Node, node-datachannel's polyfill). */
     constructor(opts, rtc = globalThis.RTCPeerConnection) {
@@ -2647,6 +2752,14 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
           else this.fail(s);
         }
       };
+    }
+    /**
+     * The offerer creates the channels just before its offer, the answerer once the remote offer is set. Creating them
+     * any earlier makes libdatachannel (node-datachannel) start an offer of its own on the answering side, which then
+     * collides with the real one (both ICE agents controlling, the link never opens).
+     */
+    openChannels() {
+      if (this.channels.reliable) return;
       for (const name of ["reliable", "fast", "voice"]) {
         const ch = this.pc.createDataChannel(name, CHANNEL_INIT[name]);
         ch.binaryType = "arraybuffer";
@@ -2654,6 +2767,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
           if (++this.opened === 3 && !this.closed) {
             this.isOpen = true;
             this.onOpen?.();
+            for (const [n, data] of this.early.splice(0)) if (!this.closed) this.onMessage?.(n, data);
             void this.reportPath();
           }
         };
@@ -2661,6 +2775,10 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
         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);
+          if (!this.isOpen) {
+            if (this.early.length < 1e3) this.early.push([name, data]);
+            return;
+          }
           this.onMessage?.(name, data);
         };
         this.channels[name] = ch;
@@ -2669,6 +2787,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
     startOffer() {
       void (async () => {
         try {
+          this.openChannels();
           const offer = await this.pc.createOffer();
           await this.pc.setLocalDescription(offer);
           this.onSignal?.({ sdp: { type: "offer", sdp: offer.sdp ?? "" } });
@@ -2681,19 +2800,21 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       try {
         if (s.sdp) {
           await this.pc.setRemoteDescription({ type: s.sdp.type, sdp: s.sdp.sdp });
+          this.haveRemote = true;
           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") {
+            this.openChannels();
             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);
+          if (this.haveRemote) await this.pc.addIceCandidate(s.ice);
           else this.pendingIce.push(s.ice);
         }
       } catch (e) {
@@ -2761,6 +2882,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;
@@ -2836,7 +2980,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
 
   // src/onelobby.ts
   var LIB_NAME = "onelobby";
-  var LIB_VERSION = "0.2.0";
+  var LIB_VERSION = "0.2.2";
   var DEFAULT_READY_TIMEOUT_MS = 15e3;
   function hasMic() {
     return typeof navigator !== "undefined" && !!navigator.mediaDevices?.getUserMedia && typeof AudioWorkletNode !== "undefined";
@@ -3080,7 +3224,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;
@@ -3139,6 +3285,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 = {