@bountyboard/arcade-sdk 1.1.0 → 1.3.0

package/dist/global.js

@@ -5,6 +5,316 @@
   var SDK_MESSAGE_SOURCE = "bb-arcade";
   var HOST_MESSAGE_SOURCE = "bb-arcade-host";
 
+  // src/storage.ts
+  var FLUSH_DELAY_MS = 400;
+  var ENVELOPE_TAG = "__bbArcadeStorage";
+  var ENVELOPE_VERSION = 1;
+  function hasOwn(target, key) {
+    return Object.prototype.hasOwnProperty.call(target, key);
+  }
+  function emptyMap() {
+    return /* @__PURE__ */ Object.create(null);
+  }
+  function storageError(code) {
+    const err = new Error(code);
+    err.code = code;
+    return err;
+  }
+  function parseEnvelope(raw) {
+    if (raw == null) return { ls: {}, app: null };
+    if (raw.charAt(0) !== "{") return { ls: {}, app: raw };
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      return { ls: {}, app: raw };
+    }
+    if (!parsed || typeof parsed !== "object") return { ls: {}, app: raw };
+    const record = parsed;
+    if (record[ENVELOPE_TAG] !== ENVELOPE_VERSION) return { ls: {}, app: raw };
+    const ls = emptyMap();
+    const source = record.ls;
+    if (source && typeof source === "object") {
+      const entries = source;
+      for (const key in entries) {
+        if (hasOwn(entries, key) && typeof entries[key] === "string") {
+          ls[key] = entries[key];
+        }
+      }
+    }
+    return { ls, app: typeof record.app === "string" ? record.app : null };
+  }
+  function buildEnvelope(ls, app) {
+    const envelope = {};
+    envelope[ENVELOPE_TAG] = ENVELOPE_VERSION;
+    envelope.ls = ls;
+    envelope.app = app;
+    return JSON.stringify(envelope);
+  }
+  function quotaError() {
+    try {
+      return new DOMException("Cloud save quota exceeded", "QuotaExceededError");
+    } catch (err) {
+      const fallback = new Error("Cloud save quota exceeded");
+      fallback.name = "QuotaExceededError";
+      return fallback;
+    }
+  }
+  var RESERVED = {
+    getItem: true,
+    setItem: true,
+    removeItem: true,
+    clear: true,
+    key: true,
+    length: true
+  };
+  function createStorageShim(backend = {}) {
+    const map = emptyMap();
+    const localWrites = emptyMap();
+    function keys() {
+      return Object.keys(map);
+    }
+    function changed() {
+      if (backend.onChange) backend.onChange();
+    }
+    const api = {
+      getItem: function(key) {
+        const name = String(key);
+        return hasOwn(map, name) ? map[name] : null;
+      },
+      setItem: function(key, value) {
+        const name = String(key);
+        const next = String(value);
+        if (backend.wouldOverflow && backend.wouldOverflow(name, next)) throw quotaError();
+        map[name] = next;
+        localWrites[name] = true;
+        changed();
+      },
+      removeItem: function(key) {
+        const name = String(key);
+        localWrites[name] = true;
+        if (!hasOwn(map, name)) return;
+        delete map[name];
+        changed();
+      },
+      clear: function() {
+        const existing = keys();
+        for (let i = 0; i < existing.length; i++) {
+          delete map[existing[i]];
+          localWrites[existing[i]] = true;
+        }
+        changed();
+      },
+      key: function(index) {
+        const existing = keys();
+        const at = Number(index);
+        return at >= 0 && at < existing.length ? existing[at] : null;
+      },
+      get length() {
+        return keys().length;
+      }
+    };
+    const storage = new Proxy(api, {
+      get(target, prop, receiver) {
+        if (typeof prop !== "string") return Reflect.get(target, prop, receiver);
+        if (hasOwn(RESERVED, prop)) return Reflect.get(target, prop, receiver);
+        return hasOwn(map, prop) ? map[prop] : void 0;
+      },
+      set(target, prop, value) {
+        if (typeof prop !== "string" || hasOwn(RESERVED, prop)) return true;
+        api.setItem(prop, value);
+        return true;
+      },
+      has(target, prop) {
+        if (typeof prop !== "string") return Reflect.has(target, prop);
+        return hasOwn(RESERVED, prop) || hasOwn(map, prop);
+      },
+      deleteProperty(target, prop) {
+        if (typeof prop === "string" && !hasOwn(RESERVED, prop)) api.removeItem(prop);
+        return true;
+      },
+      ownKeys() {
+        return keys();
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        if (typeof prop !== "string" || !hasOwn(map, prop)) return void 0;
+        return { value: map[prop], writable: true, enumerable: true, configurable: true };
+      }
+    });
+    return {
+      storage,
+      entries: function() {
+        const copy = emptyMap();
+        const existing = keys();
+        for (let i = 0; i < existing.length; i++) copy[existing[i]] = map[existing[i]];
+        return copy;
+      },
+      hydrate: function(values) {
+        for (const key in values) {
+          if (hasOwn(values, key) && !hasOwn(localWrites, key)) map[key] = values[key];
+        }
+      }
+    };
+  }
+  function settled(promise) {
+    return promise.then(
+      function() {
+      },
+      function() {
+      }
+    );
+  }
+  function installSessionStorageShim() {
+    if (nativeStorageWorks("sessionStorage")) return;
+    try {
+      Object.defineProperty(window, "sessionStorage", {
+        value: createStorageShim().storage,
+        configurable: true
+      });
+    } catch (err) {
+    }
+  }
+  function nativeStorageWorks(area) {
+    try {
+      const store = window[area];
+      if (!store) return false;
+      const probe = "__bb_arcade_probe__";
+      store.setItem(probe, "1");
+      store.removeItem(probe);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+  function createStorageController(options) {
+    let shim = null;
+    let mode = "native";
+    let appBlob = null;
+    let hydration = null;
+    let flushTimer = null;
+    let inFlight = Promise.resolve();
+    let dirty = false;
+    let hydrated = false;
+    function serialize() {
+      return buildEnvelope(shim ? shim.entries() : {}, appBlob);
+    }
+    function hydrateFromCloud() {
+      hydration = options.load().then(
+        function(raw) {
+          const envelope = parseEnvelope(raw);
+          if (shim) shim.hydrate(envelope.ls);
+          if (appBlob === null) appBlob = envelope.app;
+          hydrated = true;
+          return mode;
+        },
+        function(err) {
+          const code = err && err.code;
+          if (code === "unsupported" || code === "unauthenticated") mode = "memory";
+          return mode;
+        }
+      );
+      return hydration;
+    }
+    function wouldOverflow(key, value) {
+      if (!shim) return false;
+      const next = shim.entries();
+      next[key] = value;
+      return options.byteLength(buildEnvelope(next, appBlob)) > options.maxBytes;
+    }
+    function persist() {
+      return whenHydrated().then(function() {
+        if (mode === "memory") return;
+        if (hydrated) return options.save(serialize());
+        return hydrateFromCloud().then(function() {
+          if (mode === "memory") return;
+          if (!hydrated) throw storageError("error");
+          return options.save(serialize());
+        });
+      }).then(void 0, function(err) {
+        dirty = true;
+        throw err;
+      });
+    }
+    function flushNow() {
+      if (flushTimer !== null) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      dirty = false;
+      const next = inFlight.then(persist, persist);
+      inFlight = settled(next);
+      return next;
+    }
+    function scheduleFlush() {
+      dirty = true;
+      if (flushTimer !== null) return;
+      flushTimer = setTimeout(function() {
+        flushTimer = null;
+        void settled(flushNow());
+      }, FLUSH_DELAY_MS);
+    }
+    function whenHydrated() {
+      return hydration ? hydration : Promise.resolve(mode);
+    }
+    function attachUnloadFlush() {
+      const flushIfDirty = function() {
+        if (dirty) void settled(flushNow());
+      };
+      try {
+        window.addEventListener("pagehide", flushIfDirty);
+        window.addEventListener("visibilitychange", function() {
+          if (document.visibilityState === "hidden") flushIfDirty();
+        });
+      } catch (err) {
+      }
+    }
+    function install() {
+      if (shim) return mode;
+      installSessionStorageShim();
+      if (nativeStorageWorks("localStorage")) {
+        mode = "native";
+        return mode;
+      }
+      const handle = createStorageShim({ onChange: scheduleFlush, wouldOverflow });
+      try {
+        Object.defineProperty(window, "localStorage", {
+          value: handle.storage,
+          configurable: true
+        });
+      } catch (err) {
+        return mode;
+      }
+      shim = handle;
+      mode = "cloud";
+      attachUnloadFlush();
+      void hydrateFromCloud();
+      return mode;
+    }
+    return {
+      install,
+      active: function() {
+        return shim !== null;
+      },
+      ready: function() {
+        return whenHydrated();
+      },
+      flush: function() {
+        if (!shim && appBlob === null) return Promise.resolve();
+        return flushNow();
+      },
+      writeApp: function(blob) {
+        if (options.byteLength(buildEnvelope(shim ? shim.entries() : {}, blob)) > options.maxBytes) {
+          return Promise.reject(storageError("too_large"));
+        }
+        appBlob = blob;
+        return flushNow();
+      },
+      get mode() {
+        return mode;
+      }
+    };
+  }
+
   // src/core.ts
   var BOUNTY_BOARD_URL = "https://www.bountyboard.gg/arcade";
   var ADSENSE_CLIENT_ID = "ca-pub-7727110228190547";
@@ -12,6 +322,8 @@
   var AD_PLACEMENT_SCRIPT_ID = "bb-arcade-h5-ads";
   var DEFAULT_AD_LOAD_TIMEOUT_MS = 6e3;
   var SAVE_TIMEOUT_MS = 15e3;
+  var LOCK_TIMEOUT_MS = 5e3;
+  var MAX_SAVE_BYTES = 1024 * 1024;
   var INIT_CONFIG_GRACE_MS = 1500;
   var DEFAULT_ALLOW = [
     "bountyboard.gg",
@@ -36,6 +348,14 @@
     if (typeof value !== "string") return fallback || "";
     return value.replace(/[^\w:.-]+/g, "_").slice(0, max || 80) || fallback || "";
   }
+  var cachedTextEncoder = null;
+  function utf8ByteLength(value) {
+    if (typeof TextEncoder !== "undefined") {
+      cachedTextEncoder = cachedTextEncoder || new TextEncoder();
+      return cachedTextEncoder.encode(value).length;
+    }
+    return new Blob([value]).size;
+  }
   function toBoolean(value) {
     return value === true || value === "true" || value === "1";
   }
@@ -155,13 +475,14 @@
     };
     let hostConfigReceived = false;
     let hostPlayer = null;
+    const playerChangeHandlers = [];
     let blocked = false;
     const pending = {};
     let seq = 0;
     function post(type, score, extra) {
       if (blocked) return;
       const message = { source: SDK_MESSAGE_SOURCE, v: VERSION, type };
-      if (typeof score === "number" && isFinite(score)) message.score = Math.floor(score);
+      if (typeof score === "number" && isFinite(score)) message.score = Math.trunc(score);
       if (extra && typeof extra === "object") {
         const fields = extra;
         for (const key in fields) {
@@ -182,7 +503,7 @@
         return true;
       }
     }
-    function request(type, payload) {
+    function request(type, payload, timeoutMs = SAVE_TIMEOUT_MS) {
       return new Promise(function(resolve, reject) {
         if (blocked) return reject(sdkError("error"));
         if (!isEmbedded()) return reject(sdkError("unsupported"));
@@ -192,7 +513,7 @@
             delete pending[requestId];
             reject(sdkError("error"));
           }
-        }, SAVE_TIMEOUT_MS);
+        }, timeoutMs);
         pending[requestId] = { resolve, reject, timer };
         try {
           window.parent.postMessage(
@@ -284,7 +605,7 @@
         if (!hostnameAllowed(origin, allow)) blockHost(options);
         return;
       }
-      request("host").then(
+      request("host", void 0, LOCK_TIMEOUT_MS).then(
         function(res) {
           const r = res;
           if (!hostnameAllowed(r && r.origin, allow)) blockHost(options);
@@ -308,7 +629,7 @@
           lockToHostBestEffort(opts, allow);
           return;
         }
-        request("host_attest").then(
+        request("host_attest", void 0, LOCK_TIMEOUT_MS).then(
           function(res) {
             const r = res;
             if (!r || !r.attestation) {
@@ -370,7 +691,15 @@
       if (msg.source !== HOST_MESSAGE_SOURCE || msg.type !== "config") return;
       hostConfigReceived = true;
       if (msg.player !== void 0) {
-        hostPlayer = sanitizePlayer(msg.player);
+        const nextPlayer = sanitizePlayer(msg.player);
+        const changed = nextPlayer === null ? hostPlayer !== null : hostPlayer === null || nextPlayer.name !== hostPlayer.name || nextPlayer.avatarUrl !== hostPlayer.avatarUrl;
+        hostPlayer = nextPlayer;
+        if (changed) {
+          const snapshot = nextPlayer ? { name: nextPlayer.name, avatarUrl: nextPlayer.avatarUrl } : null;
+          for (let i = 0; i < playerChangeHandlers.length; i++) {
+            safeCall(playerChangeHandlers[i], snapshot);
+          }
+        }
       }
       const rewardedAds = msg.rewardedAds;
       if (rewardedAds && typeof rewardedAds === "object") {
@@ -502,6 +831,7 @@
           let resolved = false;
           let status = "unavailable";
           let rewardOffered = false;
+          let adShown = false;
           const waitTimer = setTimeout(function() {
             if (rewardOffered || resolved) return;
             const timeout = Object.assign(
@@ -546,6 +876,7 @@
               }
               post("rewarded_ad", void 0, Object.assign({ event: "started" }, base));
               try {
+                adShown = true;
                 showAdFn();
               } catch (err) {
                 const showError = Object.assign(
@@ -595,7 +926,13 @@
               },
               adBreakDone: function(placementInfo) {
                 if (resolved) return;
-                const result = rewardOffered || status !== "unavailable" ? { status } : { status: "unavailable", error: "no_rewarded_ad" };
+                const result = rewardOffered || status !== "unavailable" ? {
+                  // A reward was offered but the ad never reached the screen
+                  // (the game retained show() and let the break lapse): the
+                  // break is over without a view, so resolve 'dismissed',
+                  // not the non-terminal-looking 'ready'.
+                  status: status === "ready" && !adShown ? "dismissed" : status
+                } : { status: "unavailable", error: "no_rewarded_ad" };
                 if (placementInfo && typeof placementInfo === "object") {
                   result.breakStatus = cleanText(
                     placementInfo.breakStatus
@@ -766,6 +1103,16 @@
       if (!hostnameAllowed(event.origin, DEFAULT_ALLOW)) return;
       applyHostConfig(event.data);
     });
+    const storage = createStorageController({
+      save: function(blob) {
+        return request("save", blob);
+      },
+      load: function() {
+        return request("load");
+      },
+      byteLength: utf8ByteLength,
+      maxBytes: MAX_SAVE_BYTES
+    });
     const sdk = {
       lockToHost,
       init,
@@ -798,12 +1145,29 @@
       prepareRewardedBreak: prepareRewardedAd,
       rewardedBreak,
       save: function(blob) {
-        return request("save", String(blob));
+        const data = String(blob);
+        if (utf8ByteLength(data) > MAX_SAVE_BYTES) {
+          return Promise.reject(sdkError("too_large"));
+        }
+        if (storage.active()) return storage.writeApp(data);
+        return request("save", data);
       },
       load: function() {
-        return request("load");
+        return request("load").then(function(raw) {
+          return parseEnvelope(raw).app;
+        });
       },
+      storage,
       getPlayer,
+      onPlayerChange: function(handler) {
+        if (typeof handler !== "function") return function() {
+        };
+        playerChangeHandlers.push(handler);
+        return function() {
+          const idx = playerChangeHandlers.indexOf(handler);
+          if (idx !== -1) playerChangeHandlers.splice(idx, 1);
+        };
+      },
       getVariant: function(key, variants) {
         const sorted = Array.isArray(variants) ? variants.slice().sort() : [];
         const fallback = sorted.length > 0 ? sorted[0] : null;
@@ -869,7 +1233,17 @@
       rewardedBreak: () => Promise.resolve(false),
       save: () => Promise.reject(sdkError2("unsupported")),
       load: () => Promise.reject(sdkError2("unsupported")),
+      // No window to shim and nothing to persist to: report the honest mode
+      // rather than pretending an install succeeded.
+      storage: {
+        install: () => "memory",
+        ready: () => Promise.resolve("memory"),
+        flush: () => Promise.resolve(),
+        mode: "memory"
+      },
       getPlayer: () => Promise.resolve(null),
+      onPlayerChange: () => () => {
+      },
       getVariant: (key, variants) => {
         const sorted = Array.isArray(variants) ? variants.slice().sort() : [];
         return Promise.resolve(sorted.length > 0 ? sorted[0] : null);
@@ -883,13 +1257,17 @@
 
   // src/multiplayer.ts
   var WELCOME_TIMEOUT_MS = 1e4;
+  var MIN_WELCOME_TIMEOUT_MS = 1e3;
+  var MAX_WELCOME_TIMEOUT_MS = 6e4;
   var MAX_RECONNECT_ATTEMPTS = 3;
   var MAX_JOIN_DATA_BYTES = 1024;
+  var SEAT_FULL_CLOSE_CODE = 4005;
   var CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
   var CODE_LENGTH = 4;
-  function sdkError3(code) {
+  function sdkError3(code, detail) {
     const err = new Error(code);
     err.code = code;
+    if (detail) err.detail = detail;
     return err;
   }
   function randomChars(length) {
@@ -906,23 +1284,13 @@
   function generateCode() {
     return randomChars(CODE_LENGTH);
   }
-  function utf8ByteLength(value) {
-    let bytes = 0;
-    for (let i = 0; i < value.length; i++) {
-      const code = value.charCodeAt(i);
-      if (code < 128) bytes += 1;
-      else if (code < 2048) bytes += 2;
-      else if (code >= 55296 && code <= 56319 && i + 1 < value.length) {
-        const next = value.charCodeAt(i + 1);
-        if (next >= 56320 && next <= 57343) {
-          bytes += 4;
-          i += 1;
-        } else {
-          bytes += 3;
-        }
-      } else bytes += 3;
+  var cachedTextEncoder2 = null;
+  function utf8ByteLength2(value) {
+    if (typeof TextEncoder !== "undefined") {
+      cachedTextEncoder2 = cachedTextEncoder2 || new TextEncoder();
+      return cachedTextEncoder2.encode(value).length;
     }
-    return bytes;
+    return new Blob([value]).size;
   }
   function serializeJoinData(data) {
     if (data === void 0) return null;
@@ -933,28 +1301,34 @@
     } catch (e) {
       throw sdkError3("rejected");
     }
-    if (!serialized || utf8ByteLength(serialized) > MAX_JOIN_DATA_BYTES) {
+    if (!serialized || utf8ByteLength2(serialized) > MAX_JOIN_DATA_BYTES) {
       throw sdkError3("rejected");
     }
     return serialized;
   }
-  function requestTicket(roomId) {
+  function requestTicket(payload) {
     const request = BBArcade._request;
     if (typeof request !== "function") return Promise.reject(sdkError3("unsupported"));
-    return request("mp_ticket", { roomId }).then((grant) => {
+    return request("mp_ticket", payload).then((grant) => {
       const g = grant;
       if (!g || typeof g.ticket !== "string" || typeof g.roomUrl !== "string") {
         throw sdkError3("error");
       }
-      return { ticket: g.ticket, roomUrl: g.roomUrl, expiresAt: Number(g.expiresAt) || 0 };
+      return {
+        ticket: g.ticket,
+        roomUrl: g.roomUrl,
+        expiresAt: Number(g.expiresAt) || 0,
+        roomId: typeof g.roomId === "string" && g.roomId ? g.roomId : null
+      };
     });
   }
   var RoomConnection = class {
-    constructor(code, devGrant, joinData) {
+    constructor(code, devGrant, joinData, welcomeTimeoutMs = WELCOME_TIMEOUT_MS) {
       this.playerId = "";
       this.players = [];
       this.state = null;
       this.connected = false;
+      this.latencyMs = null;
       this.ws = null;
       // Keyed by event name; values are erased to (unknown) => void internally and
       // retyped at the on()/emit() boundary, which keeps the public API strictly
@@ -967,15 +1341,20 @@
       // or the welcome timed out — permanent outcomes that must not reconnect.
       this.terminal = false;
       this.reconnectAttempts = 0;
+      // The in-flight connect()'s settlement, so leave() can reject a join that
+      // is still waiting on its welcome instead of stranding it on the timeout.
+      this.pendingConnect = null;
       this.code = code;
       this.devGrant = devGrant;
       this.joinData = joinData;
+      this.welcomeTimeoutMs = welcomeTimeoutMs;
     }
     /** Connect and resolve on the server's welcome (post-ticket-verification). */
     connect(grant) {
       return new Promise((resolve, reject) => {
-        let settled = false;
+        let settled2 = false;
         const url = grant.roomUrl + (grant.roomUrl.indexOf("?") === -1 ? "?" : "&") + "ticket=" + encodeURIComponent(grant.ticket) + (this.joinData === null ? "" : "&join=" + encodeURIComponent(this.joinData));
+        const connectStartedAt = Date.now();
         let ws;
         try {
           ws = new WebSocket(url);
@@ -984,15 +1363,17 @@
         }
         this.ws = ws;
         const welcomeTimer = setTimeout(() => {
-          if (settled) return;
-          settled = true;
+          if (settled2) return;
+          settled2 = true;
+          this.pendingConnect = null;
           this.terminal = true;
           try {
             ws.close();
           } catch (err) {
           }
           reject(sdkError3("error"));
-        }, WELCOME_TIMEOUT_MS);
+        }, this.welcomeTimeoutMs);
+        this.pendingConnect = { reject, timer: welcomeTimer };
         ws.onmessage = (event) => {
           var _a, _b, _c, _d, _e;
           let msg;
@@ -1003,14 +1384,23 @@
           }
           if (!msg || typeof msg.t !== "string") return;
           if (msg.t === "welcome") {
+            if (this.intentionalClose) {
+              try {
+                ws.close();
+              } catch (err) {
+              }
+              return;
+            }
             const reconnected = this.reconnectAttempts > 0;
             this.playerId = String((_a = msg.playerId) != null ? _a : "");
             this.players = Array.isArray(msg.players) ? msg.players : [];
             this.state = (_b = msg.state) != null ? _b : null;
             this.connected = true;
             this.reconnectAttempts = 0;
-            if (!settled) {
-              settled = true;
+            this.latencyMs = Math.max(0, Date.now() - connectStartedAt);
+            if (!settled2) {
+              settled2 = true;
+              this.pendingConnect = null;
               clearTimeout(welcomeTimer);
               resolve(this);
             }
@@ -1049,24 +1439,27 @@
           }
           if (msg.t === "error") {
             const code = String((_e = msg.code) != null ? _e : "error");
-            if (!settled) {
-              settled = true;
+            if (!settled2) {
+              settled2 = true;
               this.terminal = true;
+              this.pendingConnect = null;
               clearTimeout(welcomeTimer);
               try {
                 ws.close();
               } catch (err) {
               }
-              reject(sdkError3(code === "unauthenticated" ? "unauthenticated" : "rejected"));
+              reject(sdkError3(code === "unauthenticated" ? "unauthenticated" : "rejected", code));
               return;
             }
             this.emit("error", { code });
           }
         };
-        ws.onclose = () => {
+        ws.onclose = (event) => {
           this.connected = false;
-          if (!settled) {
-            settled = true;
+          if (event && event.code === SEAT_FULL_CLOSE_CODE) this.terminal = true;
+          if (!settled2) {
+            settled2 = true;
+            this.pendingConnect = null;
             clearTimeout(welcomeTimer);
             reject(sdkError3("error"));
             return;
@@ -1095,7 +1488,7 @@
       await new Promise((r) => setTimeout(r, 400 * this.reconnectAttempts));
       if (this.intentionalClose || this.ended || this.terminal) return;
       try {
-        const grant = (_a = this.devGrant) != null ? _a : await requestTicket(this.code);
+        const grant = (_a = this.devGrant) != null ? _a : await requestTicket({ roomId: this.code });
         if (this.intentionalClose || this.ended || this.terminal) return;
         await this.connect(grant);
         if (this.intentionalClose) this.leave();
@@ -1130,6 +1523,12 @@
       var _a;
       this.intentionalClose = true;
       this.connected = false;
+      if (this.pendingConnect) {
+        const pending = this.pendingConnect;
+        this.pendingConnect = null;
+        clearTimeout(pending.timer);
+        pending.reject(sdkError3("error"));
+      }
       try {
         (_a = this.ws) == null ? void 0 : _a.close(1e3);
       } catch (err) {
@@ -1149,27 +1548,62 @@
       }
     }
   };
+  var MATCH_ATTEMPTS = 3;
+  function normalizeWelcomeTimeoutMs(value) {
+    if (typeof value !== "number" || !isFinite(value)) return WELCOME_TIMEOUT_MS;
+    return Math.min(MAX_WELCOME_TIMEOUT_MS, Math.max(MIN_WELCOME_TIMEOUT_MS, Math.floor(value)));
+  }
+  async function matchJoin(joinData, timeoutMs) {
+    let lastError = sdkError3("error");
+    for (let attempt = 0; attempt < MATCH_ATTEMPTS; attempt++) {
+      const grant = await requestTicket({ matchmake: true });
+      if (!grant.roomId) throw sdkError3("error");
+      try {
+        return await new RoomConnection(grant.roomId, null, joinData, timeoutMs).connect(grant);
+      } catch (error) {
+        lastError = error;
+        const detail = error == null ? void 0 : error.detail;
+        if (detail !== "room_full" && detail !== "room_over") throw error;
+      }
+    }
+    throw lastError;
+  }
   function joinRoom(options) {
     const opts = options != null ? options : {};
     if (typeof window === "undefined" || typeof WebSocket === "undefined") {
       return Promise.reject(sdkError3("unsupported"));
     }
-    const code = opts.create || !opts.code ? generateCode() : opts.code.toUpperCase();
     let joinData;
     try {
       joinData = serializeJoinData(opts.joinData);
     } catch (err) {
       return Promise.reject(err);
     }
+    const timeoutMs = normalizeWelcomeTimeoutMs(opts.timeoutMs);
+    if (opts.match) {
+      if (opts.code || opts.create || opts.roomUrl || opts.ticket) {
+        return Promise.reject(sdkError3("rejected"));
+      }
+      return matchJoin(joinData, timeoutMs);
+    }
+    const code = opts.create || !opts.code ? generateCode() : opts.code.toUpperCase();
     if (opts.roomUrl && opts.ticket) {
-      const devGrant = { ticket: opts.ticket, roomUrl: opts.roomUrl, expiresAt: 0 };
-      return new RoomConnection(code, devGrant, joinData).connect(devGrant);
+      const devGrant = {
+        ticket: opts.ticket,
+        roomUrl: opts.roomUrl,
+        expiresAt: 0,
+        roomId: code
+      };
+      return new RoomConnection(code, devGrant, joinData, timeoutMs).connect(devGrant);
     }
-    return requestTicket(code).then((grant) => new RoomConnection(code, null, joinData).connect(grant));
+    return requestTicket({ roomId: code }).then(
+      (grant) => new RoomConnection(code, null, joinData, timeoutMs).connect(grant)
+    );
   }
   var multiplayer = { joinRoom };
 
   // src/global.ts
   BBArcade.multiplayer = multiplayer;
   window.BBArcade = BBArcade;
+  BBArcade.storage.install();
 })();