@bountyboard/arcade-sdk 1.1.0 → 1.3.0

package/dist/multiplayer.cjs

@@ -30,6 +30,316 @@ var VERSION = 1;
 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";
@@ -37,6 +347,8 @@ var AD_PLACEMENT_SRC = "https://pagead2.googlesyndication.com/pagead/js/adsbygoo
 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",
@@ -61,6 +373,14 @@ function cleanText(value, fallback, max) {
   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";
 }
@@ -180,13 +500,14 @@ function createBBArcade() {
   };
   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) {
@@ -207,7 +528,7 @@ function createBBArcade() {
       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"));
@@ -217,7 +538,7 @@ function createBBArcade() {
           delete pending[requestId];
           reject(sdkError("error"));
         }
-      }, SAVE_TIMEOUT_MS);
+      }, timeoutMs);
       pending[requestId] = { resolve, reject, timer };
       try {
         window.parent.postMessage(
@@ -309,7 +630,7 @@ function createBBArcade() {
       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);
@@ -333,7 +654,7 @@ function createBBArcade() {
         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) {
@@ -395,7 +716,15 @@ function createBBArcade() {
     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") {
@@ -527,6 +856,7 @@ function createBBArcade() {
         let resolved = false;
         let status = "unavailable";
         let rewardOffered = false;
+        let adShown = false;
         const waitTimer = setTimeout(function() {
           if (rewardOffered || resolved) return;
           const timeout = Object.assign(
@@ -571,6 +901,7 @@ function createBBArcade() {
             }
             post("rewarded_ad", void 0, Object.assign({ event: "started" }, base));
             try {
+              adShown = true;
               showAdFn();
             } catch (err) {
               const showError = Object.assign(
@@ -620,7 +951,13 @@ function createBBArcade() {
             },
             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
@@ -791,6 +1128,16 @@ function createBBArcade() {
     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,
@@ -823,12 +1170,29 @@ function createBBArcade() {
     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;
@@ -894,7 +1258,17 @@ function createInertBBArcade() {
     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);
@@ -908,13 +1282,17 @@ var BBArcade = typeof window === "undefined" ? createInertBBArcade() : createBBA
 
 // 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) {
@@ -931,23 +1309,13 @@ function randomChars(length) {
 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;
@@ -958,28 +1326,34 @@ function serializeJoinData(data) {
   } 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
@@ -992,15 +1366,20 @@ var RoomConnection = class {
     // 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);
@@ -1009,15 +1388,17 @@ var RoomConnection = class {
       }
       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;
@@ -1028,14 +1409,23 @@ var RoomConnection = class {
         }
         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);
           }
@@ -1074,24 +1464,27 @@ var RoomConnection = class {
         }
         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;
@@ -1120,7 +1513,7 @@ var RoomConnection = class {
     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();
@@ -1155,6 +1548,12 @@ var RoomConnection = class {
     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) {
@@ -1174,23 +1573,57 @@ var RoomConnection = class {
     }
   }
 };
+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 };
 // Annotate the CommonJS export names for ESM import in node: