onelobby 0.3.0 → 0.4.1

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.3.0";
+export declare const LIB_VERSION = "0.4.1";
 /** Where `rememberSeat` keeps the resume token: the subset of the Web Storage API it uses. */
 export interface SeatStorage {
     getItem(key: string): string | null;
@@ -134,6 +134,8 @@ export declare class OneLobby extends Emitter<OneLobbyEvents> {
     resume(): Promise<Lobby | null>;
     private helloMsg;
     private connect;
+    /** The signaling socket only (no hello yet); with a timeout (direct IP), no answer is `direct_unreachable`. */
+    private open;
     private makeLobby;
     host(h: HostOptions): Promise<Lobby>;
     join(code: string): Promise<Lobby>;
@@ -144,8 +146,16 @@ export declare class OneLobby extends Emitter<OneLobbyEvents> {
      * The address is also given to ICE as the host's UDP candidate. When the host leaves, `sessionEnded("host_left")`.
      */
     joinDirect(codeOrAddress: string, opts?: JoinDirectOptions): Promise<Lobby>;
+    /**
+     * Take a direct-IP seat back after a drop or a restart: the code (or address) joined before and that lobby's
+     * `resumeToken` (save it after every join; it changes on each resume). The host keeps a dropped seat for 60 s and the
+     * same peer id comes back. Rejects with `invalid_token` when the seat is gone: offer `joinDirect` then.
+     */
+    rejoinDirect(codeOrAddress: string, resumeToken: string, opts?: JoinDirectOptions): Promise<Lobby>;
+    private directTarget;
     /** @internal onelobby/direct's host: create the one lobby on the embedded hub, in direct mode. */
     hostDirectWith(h: HostOptions, hooks: DirectLobbyHooks): Promise<Lobby>;
     rejoin(resumeToken: string): Promise<Lobby>;
+    private resumeAt;
     list(opts?: ListOptions): Promise<LobbySummary[]>;
 }

package/dist/onelobby.global.js

@@ -1,4 +1,4 @@
-/*! onelobby 0.3.0 | MIT license */
+/*! onelobby 0.4.1 | MIT license */
 "use strict";
 var OneLobby = (() => {
   var __defProp = Object.defineProperty;
@@ -25,6 +25,7 @@ var OneLobby = (() => {
     CHAT_MAX_BYTES: () => CHAT_MAX_BYTES,
     Chat: () => Chat,
     DEFAULT_READY_TIMEOUT_MS: () => DEFAULT_READY_TIMEOUT_MS,
+    ErrorCodes: () => ErrorCodes,
     Keepalive: () => Keepalive,
     KeepaliveError: () => KeepaliveError,
     LIB_NAME: () => LIB_NAME,
@@ -629,13 +630,17 @@ var OneLobby = (() => {
     }
     return out;
   }
+  var MAX_PARTIAL_SETS = 8;
   var Reassembler = class {
     parts = /* @__PURE__ */ new Map();
+    // insertion order = oldest first
     /** 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) {
+        this.parts.delete(chunk.id);
+        while (this.parts.size >= MAX_PARTIAL_SETS) this.parts.delete(this.parts.keys().next().value);
         e = { count: chunk.count, got: 0, parts: new Array(chunk.count), bytes: 0 };
         this.parts.set(chunk.id, e);
       }
@@ -647,7 +652,15 @@ var OneLobby = (() => {
         this.parts.delete(chunk.id);
         throw new CodecError("too_long", `chunk set over ${MAX_REASSEMBLED_BYTES} bytes`);
       }
-      if (e.got < e.count) return null;
+      if (e.got < e.count) {
+        while (this.pendingBytes > MAX_REASSEMBLED_BYTES && this.parts.size > 1) {
+          for (const id of this.parts.keys()) if (id !== chunk.id) {
+            this.parts.delete(id);
+            break;
+          }
+        }
+        return null;
+      }
       this.parts.delete(chunk.id);
       const out = new Uint8Array(e.bytes);
       let pos = 0;
@@ -660,6 +673,12 @@ var OneLobby = (() => {
     get pending() {
       return this.parts.size;
     }
+    /** Bytes held across incomplete sets. */
+    get pendingBytes() {
+      let n = 0;
+      for (const p of this.parts.values()) n += p.bytes;
+      return n;
+    }
     clear() {
       this.parts.clear();
     }
@@ -669,9 +688,10 @@ var OneLobby = (() => {
   function deflateAvailable() {
     return typeof CompressionStream !== "undefined" && typeof DecompressionStream !== "undefined";
   }
-  async function pipe(bytes, stream) {
+  async function pipe(bytes, stream, maxBytes = Infinity) {
     const w = stream.writable.getWriter();
-    void w.write(bytes).then(() => w.close());
+    void w.write(bytes).then(() => w.close()).catch(() => {
+    });
     const chunks = [];
     const r = stream.readable.getReader();
     let total = 0;
@@ -680,6 +700,11 @@ var OneLobby = (() => {
       if (done) break;
       chunks.push(value);
       total += value.length;
+      if (total > maxBytes) {
+        void r.cancel().catch(() => {
+        });
+        throw new CodecError("too_long", `snapshot inflates to more than ${maxBytes} bytes`);
+      }
     }
     const out = new Uint8Array(total);
     let pos = 0;
@@ -692,8 +717,8 @@ var OneLobby = (() => {
   function deflate(bytes) {
     return pipe(bytes, new CompressionStream("deflate"));
   }
-  function inflate(bytes) {
-    return pipe(bytes, new DecompressionStream("deflate"));
+  function inflate(bytes, maxBytes = MAX_REASSEMBLED_BYTES) {
+    return pipe(bytes, new DecompressionStream("deflate"), maxBytes);
   }
 
   // src/lockstep.ts
@@ -701,6 +726,7 @@ var OneLobby = (() => {
   var MAX_RESTORE_RETRIES = 3;
   var HOST_SILENCE_MS = 3e3;
   var PEER_HASH_SILENCE_MS = 1e4;
+  var MAX_PENDING_PER_PEER = 256;
   var SNAPSHOT_COMPRESS_MIN = 1024;
   var Lockstep = class extends Emitter {
     constructor(hub, opts) {
@@ -732,6 +758,7 @@ var OneLobby = (() => {
     hosting = false;
     _started = false;
     pending = [];
+    _droppedCommands = 0;
     ready = /* @__PURE__ */ new Set();
     snapshotting = /* @__PURE__ */ new Set();
     cancelTicker = null;
@@ -746,6 +773,10 @@ var OneLobby = (() => {
     // joiner side
     pendingSnapshot = null;
     // ---- public game-facing surface -------------------------------------------------------------------------------
+    /** Remote commands the host dropped because that peer already had MAX_PENDING_PER_PEER waiting. */
+    get droppedCommands() {
+      return this._droppedCommands;
+    }
     get started() {
       return this._started;
     }
@@ -891,7 +922,12 @@ var OneLobby = (() => {
     handle(from, msg) {
       switch (msg.type) {
         case "cmd":
-          if (this.hosting) this.pending.push({ peerId: from, bytes: msg.bytes });
+          if (this.hosting) {
+            let waiting = 0;
+            for (const c of this.pending) if (c.peerId === from) waiting++;
+            if (waiting >= MAX_PENDING_PER_PEER) this._droppedCommands++;
+            else this.pending.push({ peerId: from, bytes: msg.bytes });
+          }
           break;
         case "frame":
           if (!this.hosting) this.onFrame(msg.tick, msg.commands);
@@ -2980,7 +3016,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
 
   // src/onelobby.ts
   var LIB_NAME = "onelobby";
-  var LIB_VERSION = "0.3.0";
+  var LIB_VERSION = "0.4.1";
   var DEFAULT_READY_TIMEOUT_MS = 15e3;
   function hasMic() {
     return typeof navigator !== "undefined" && !!navigator.mediaDevices?.getUserMedia && typeof AudioWorkletNode !== "undefined";
@@ -3105,6 +3141,17 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       };
     }
     async connect(url = this.options.lobbyServer, factory = this.socketFactory, timeoutMs = 0) {
+      const sig = await this.open(url, factory, timeoutMs);
+      try {
+        const welcome = await sig.request(this.helloMsg(), "welcome");
+        return { sig, welcome };
+      } catch (e) {
+        sig.close();
+        throw e;
+      }
+    }
+    /** The signaling socket only (no hello yet); with a timeout (direct IP), no answer is `direct_unreachable`. */
+    async open(url, factory, timeoutMs) {
       const sig = new SignalingClient(url, factory, this.clock);
       if (timeoutMs > 0) {
         let cancel = () => {
@@ -3122,13 +3169,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
           cancel();
         }
       } else await sig.connect();
-      try {
-        const welcome = await sig.request(this.helloMsg(), "welcome");
-        return { sig, welcome };
-      } catch (e) {
-        sig.close();
-        throw e;
-      }
+      return sig;
     }
     makeLobby(sig, welcome, state, direct, rateLimit) {
       const lobby = new Lobby({
@@ -3210,6 +3251,30 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
      * The address is also given to ICE as the host's UDP candidate. When the host leaves, `sessionEnded("host_left")`.
      */
     async joinDirect(codeOrAddress, opts = {}) {
+      const { addr, links } = this.directTarget(codeOrAddress, opts);
+      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");
+        const lobby = this.makeLobby(sig, welcome, state, { links });
+        lobby.joinCode = joinedWith(addr);
+        return lobby;
+      } catch (e) {
+        sig.close();
+        throw e;
+      }
+    }
+    /**
+     * Take a direct-IP seat back after a drop or a restart: the code (or address) joined before and that lobby's
+     * `resumeToken` (save it after every join; it changes on each resume). The host keeps a dropped seat for 60 s and the
+     * same peer id comes back. Rejects with `invalid_token` when the seat is gone: offer `joinDirect` then.
+     */
+    async rejoinDirect(codeOrAddress, resumeToken, opts = {}) {
+      const { addr, links } = this.directTarget(codeOrAddress, opts);
+      const lobby = await this.resumeAt(resumeToken, addr.url, opts.connectTimeoutMs ?? 5e3, { links });
+      lobby.joinCode = joinedWith(addr);
+      return lobby;
+    }
+    directTarget(codeOrAddress, opts) {
       let input = codeOrAddress.trim();
       if (looksLikeJoinCode(input)) {
         const d = decodeJoinCode(input);
@@ -3221,16 +3286,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       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");
-        const lobby = this.makeLobby(sig, welcome, state, { links });
-        lobby.joinCode = joinedWith(addr);
-        return lobby;
-      } catch (e) {
-        sig.close();
-        throw e;
-      }
+      return { addr, links };
     }
     /** @internal onelobby/direct's host: create the one lobby on the embedded hub, in direct mode. */
     async hostDirectWith(h, hooks) {
@@ -3256,8 +3312,10 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
       }
     }
     async rejoin(resumeToken) {
-      const sig = new SignalingClient(this.options.lobbyServer, this.socketFactory, this.clock);
-      await sig.connect();
+      return this.resumeAt(resumeToken, this.options.lobbyServer, 0);
+    }
+    async resumeAt(resumeToken, url, timeoutMs, direct) {
+      const sig = await this.open(url, this.socketFactory, timeoutMs);
       try {
         const lobbyP = sig.expect("lobby");
         const welcomeP = sig.request(this.helloMsg(resumeToken), "welcome");
@@ -3266,7 +3324,7 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
         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);
+        return this.makeLobby(sig, welcome, state, direct);
       } catch (e) {
         sig.close();
         throw e;
@@ -3295,6 +3353,33 @@ registerProcessor('onelobby-capture', OneLobbyCapture);
   }
 
   // src/friendly.ts
+  var ErrorCodes = {
+    // from the lobby server or a direct host's hub
+    UnknownCode: "unknown_code",
+    BadCode: "bad_code",
+    LobbyFull: "lobby_full",
+    VersionMismatch: "version_mismatch",
+    InGame: "in_game",
+    Kicked: "kicked",
+    BadPassword: "bad_password",
+    NotHost: "not_host",
+    RateLimited: "rate_limited",
+    ServerFull: "server_full",
+    GameNotAllowed: "game_not_allowed",
+    BadRequest: "bad_request",
+    // from this client
+    ServerClosed: "server_closed",
+    IceFailed: "ice_failed",
+    Timeout: "timeout",
+    DirectUnreachable: "direct_unreachable",
+    BadAddress: "bad_address",
+    PortInUse: "port_in_use",
+    ConnectFailed: "connect_failed",
+    Closed: "closed",
+    ServerLost: "server_lost",
+    InvalidToken: "invalid_token",
+    NoServer: "no_server"
+  };
   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." },