@bountyboard/arcade-sdk 1.0.0

package/dist/global.js

@@ -0,0 +1,1044 @@
+"use strict";
+(() => {
+  // src/protocol.ts
+  var VERSION = 1;
+  var SDK_MESSAGE_SOURCE = "bb-arcade";
+  var HOST_MESSAGE_SOURCE = "bb-arcade-host";
+
+  // src/core.ts
+  var BOUNTY_BOARD_URL = "https://www.bountyboard.gg/arcade";
+  var ADSENSE_CLIENT_ID = "ca-pub-7727110228190547";
+  var AD_PLACEMENT_SRC = "https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=" + ADSENSE_CLIENT_ID;
+  var AD_PLACEMENT_SCRIPT_ID = "bb-arcade-h5-ads";
+  var DEFAULT_AD_LOAD_TIMEOUT_MS = 6e3;
+  var SAVE_TIMEOUT_MS = 15e3;
+  var INIT_CONFIG_GRACE_MS = 1500;
+  var DEFAULT_ALLOW = [
+    "bountyboard.gg",
+    "bountyboard-staging.vercel.app",
+    "localhost",
+    "127.0.0.1"
+  ];
+  var SITELOCK_PUBLIC_KEY_B64 = "MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE6WC8fJweDpfKRcZW9Q9eOLxPXmFCO8R8lY1kfZbuAQt65E0CTu2rM80XfW3nYrSAqO+Eev8gxrGS0bAnNaMDGg==";
+  var SITELOCK_MAX_SKEW_MS = 5 * 60 * 1e3;
+  function sdkError(code) {
+    const err = new Error(code);
+    err.code = code;
+    return err;
+  }
+  function b64ToBytes(b64) {
+    const bin = atob(b64);
+    const bytes = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+    return bytes;
+  }
+  function cleanText(value, fallback, max) {
+    if (typeof value !== "string") return fallback || "";
+    return value.replace(/[^\w:.-]+/g, "_").slice(0, max || 80) || fallback || "";
+  }
+  function toBoolean(value) {
+    return value === true || value === "true" || value === "1";
+  }
+  function cleanRewardedSize(value) {
+    return value === "small" || value === "medium" || value === "large" ? value : "";
+  }
+  function safeCall(fn, arg) {
+    if (typeof fn !== "function") return;
+    try {
+      fn(arg);
+    } catch (err) {
+      setTimeout(function() {
+        throw err;
+      }, 0);
+    }
+  }
+  function toAllowedHost(value) {
+    const raw = String(value).toLowerCase().trim();
+    if (!raw) return "";
+    try {
+      return new URL(raw.indexOf("//") === -1 ? "https://" + raw : raw).hostname;
+    } catch (err) {
+      return raw;
+    }
+  }
+  function hostnameAllowed(origin, allowHosts) {
+    if (!origin || origin === "null" || typeof origin !== "string") return false;
+    let host;
+    try {
+      host = new URL(origin).hostname.toLowerCase();
+    } catch (err) {
+      return false;
+    }
+    for (let i = 0; i < allowHosts.length; i++) {
+      const allowed = allowHosts[i];
+      if (host === allowed || host.slice(-(allowed.length + 1)) === "." + allowed) return true;
+    }
+    return false;
+  }
+  function verifyHostAttestation(att, senderOrigin) {
+    const a = att;
+    if (!a || typeof a.origin !== "string" || typeof a.ts !== "number" || typeof a.sig !== "string")
+      return Promise.resolve(false);
+    if (a.origin !== senderOrigin) return Promise.resolve(false);
+    if (Math.abs(Date.now() - a.ts) > SITELOCK_MAX_SKEW_MS) return Promise.resolve(false);
+    try {
+      return window.crypto.subtle.importKey(
+        "spki",
+        b64ToBytes(SITELOCK_PUBLIC_KEY_B64),
+        { name: "ECDSA", namedCurve: "P-256" },
+        false,
+        ["verify"]
+      ).then(function(key) {
+        return window.crypto.subtle.verify(
+          { name: "ECDSA", hash: "SHA-256" },
+          key,
+          b64ToBytes(a.sig),
+          new TextEncoder().encode(a.origin + ":" + a.ts)
+        );
+      }).then(
+        function(ok) {
+          return ok === true;
+        },
+        function() {
+          return false;
+        }
+      );
+    } catch (err) {
+      return Promise.resolve(false);
+    }
+  }
+  function sanitizePlayer(value) {
+    if (!value || typeof value !== "object") return null;
+    const raw = value;
+    const name = typeof raw.name === "string" ? raw.name.trim().slice(0, 120) : "";
+    if (!name) return null;
+    const avatarUrl = typeof raw.avatarUrl === "string" && raw.avatarUrl.trim() ? raw.avatarUrl : null;
+    return { name, avatarUrl };
+  }
+  function createBBArcade() {
+    let adPlacementLoad = null;
+    let adPreloadConfigured = false;
+    let rewardedBreakActive = false;
+    let rewardedBreakSequence = 0;
+    function isLocalAdHost() {
+      try {
+        const protocol = window.location && window.location.protocol;
+        const host = window.location && window.location.hostname;
+        return protocol === "file:" || host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+      } catch (err) {
+        return false;
+      }
+    }
+    const localAdHost = isLocalAdHost();
+    const config = {
+      rewardedAds: {
+        enabled: true,
+        adChannel: "",
+        testMode: localAdHost,
+        loadTimeoutMs: DEFAULT_AD_LOAD_TIMEOUT_MS,
+        preload: false
+      }
+    };
+    const hostConfig = {
+      rewardedAds: {
+        received: false,
+        enabled: localAdHost,
+        adChannel: "",
+        testMode: localAdHost,
+        preload: false
+      }
+    };
+    let hostConfigReceived = false;
+    let hostPlayer = null;
+    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 (extra && typeof extra === "object") {
+        const fields = extra;
+        for (const key in fields) {
+          if (Object.prototype.hasOwnProperty.call(fields, key) && fields[key] !== void 0) {
+            message[key] = fields[key];
+          }
+        }
+      }
+      try {
+        window.parent.postMessage(message, "*");
+      } catch (err) {
+      }
+    }
+    function isEmbedded() {
+      try {
+        return window.parent != null && window.parent !== window;
+      } catch (err) {
+        return true;
+      }
+    }
+    function request(type, payload) {
+      return new Promise(function(resolve, reject) {
+        if (blocked) return reject(sdkError("error"));
+        if (!isEmbedded()) return reject(sdkError("unsupported"));
+        const requestId = type + "_" + ++seq + "_" + Date.now();
+        const timer = setTimeout(function() {
+          if (pending[requestId]) {
+            delete pending[requestId];
+            reject(sdkError("error"));
+          }
+        }, SAVE_TIMEOUT_MS);
+        pending[requestId] = { resolve, reject, timer };
+        try {
+          window.parent.postMessage(
+            {
+              source: SDK_MESSAGE_SOURCE,
+              v: VERSION,
+              type,
+              requestId,
+              payload
+            },
+            "*"
+          );
+        } catch (err) {
+          clearTimeout(timer);
+          delete pending[requestId];
+          reject(sdkError("error"));
+        }
+      });
+    }
+    window.addEventListener("message", function(event) {
+      if (event.source !== window.parent) return;
+      const data = event.data;
+      if (!data || data.source !== SDK_MESSAGE_SOURCE) return;
+      if (typeof data.type !== "string" || !data.type.endsWith("_result")) return;
+      const entry = pending[data.requestId];
+      if (!entry) return;
+      clearTimeout(entry.timer);
+      delete pending[data.requestId];
+      if (data.type === "host_result") return entry.resolve({ origin: event.origin });
+      if (data.type === "host_attest_result")
+        return entry.resolve({ origin: event.origin, attestation: data.attestation || null });
+      if (data.type === "experiment_result")
+        return entry.resolve(typeof data.variant === "string" ? data.variant : null);
+      if (data.ok)
+        entry.resolve(
+          data.type === "load_result" ? data.data != null ? data.data : null : data.data
+        );
+      else entry.reject(sdkError(data.code || "error"));
+    });
+    function embeddingOriginSync() {
+      try {
+        if (window.top === window.self) return window.location.origin;
+      } catch (err) {
+      }
+      try {
+        const ancestors = window.location.ancestorOrigins;
+        if (ancestors && ancestors.length && ancestors[0] && ancestors[0] !== "null")
+          return ancestors[0];
+      } catch (err) {
+      }
+      if (document.referrer) {
+        try {
+          return new URL(document.referrer).origin;
+        } catch (err) {
+        }
+      }
+      return null;
+    }
+    function blockHost(options) {
+      if (blocked) return;
+      blocked = true;
+      if (typeof options.onBlocked === "function") {
+        try {
+          options.onBlocked();
+        } catch (err) {
+        }
+        return;
+      }
+      if (options.redirect) {
+        try {
+          window.top.location.href = options.redirect;
+          return;
+        } catch (err) {
+          try {
+            window.location.href = options.redirect;
+            return;
+          } catch (err2) {
+          }
+        }
+      }
+      try {
+        document.documentElement.innerHTML = `<div style="position:fixed;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:14px;font-family:system-ui,-apple-system,sans-serif;background:#1a1206;color:#fff;text-align:center;padding:24px;"><div style="font-size:18px;font-weight:700;">This game isn't available here</div><a href="` + BOUNTY_BOARD_URL + '" target="_blank" rel="noopener" style="display:inline-block;background:#f5b942;color:#1a1206;font-weight:700;font-size:14px;text-decoration:none;padding:10px 20px;border-radius:999px;">Play the original on Bounty Board</a></div>';
+      } catch (err) {
+      }
+    }
+    function lockToHostBestEffort(options, allow) {
+      const origin = embeddingOriginSync();
+      if (origin != null) {
+        if (!hostnameAllowed(origin, allow)) blockHost(options);
+        return;
+      }
+      request("host").then(
+        function(res) {
+          const r = res;
+          if (!hostnameAllowed(r && r.origin, allow)) blockHost(options);
+        },
+        function() {
+          blockHost(options);
+        }
+      );
+    }
+    function lockToHost(options) {
+      const opts = options || {};
+      const allow = DEFAULT_ALLOW.slice();
+      if (opts.allow && opts.allow.length) {
+        for (let i = 0; i < opts.allow.length; i++) {
+          const host = toAllowedHost(opts.allow[i]);
+          if (host) allow.push(host);
+        }
+      }
+      if (opts.signed) {
+        if (!(window.crypto && window.crypto.subtle)) {
+          lockToHostBestEffort(opts, allow);
+          return;
+        }
+        request("host_attest").then(
+          function(res) {
+            const r = res;
+            if (!r || !r.attestation) {
+              lockToHostBestEffort(opts, allow);
+              return;
+            }
+            verifyHostAttestation(r.attestation, r.origin).then(function(ok) {
+              if (!ok || !hostnameAllowed(r.attestation && r.attestation.origin, allow))
+                blockHost(opts);
+            });
+          },
+          function() {
+            blockHost(opts);
+          }
+        );
+        return;
+      }
+      lockToHostBestEffort(opts, allow);
+    }
+    function nextAdBreakId() {
+      rewardedBreakSequence += 1;
+      return [
+        "bbad",
+        Date.now().toString(36),
+        rewardedBreakSequence.toString(36),
+        Math.random().toString(36).slice(2, 10)
+      ].join("_");
+    }
+    function configure(nextConfig) {
+      if (!nextConfig || typeof nextConfig !== "object") return;
+      const rewardedAds = nextConfig.rewardedAds;
+      if (!rewardedAds || typeof rewardedAds !== "object") return;
+      if (rewardedAds.enabled !== void 0) {
+        config.rewardedAds.enabled = rewardedAds.enabled !== false;
+      }
+      if (rewardedAds.adChannel !== void 0) {
+        config.rewardedAds.adChannel = cleanText(rewardedAds.adChannel);
+      }
+      if (rewardedAds.testMode !== void 0) {
+        config.rewardedAds.testMode = toBoolean(rewardedAds.testMode);
+      }
+      if (rewardedAds.preload !== void 0) {
+        config.rewardedAds.preload = toBoolean(rewardedAds.preload);
+      }
+      if (typeof rewardedAds.loadTimeoutMs === "number" && isFinite(rewardedAds.loadTimeoutMs) && rewardedAds.loadTimeoutMs > 0) {
+        config.rewardedAds.loadTimeoutMs = Math.min(15e3, Math.floor(rewardedAds.loadTimeoutMs));
+      }
+      if (config.rewardedAds.preload) preloadRewardedAds();
+    }
+    let configWaiters = [];
+    function notifyConfigReceived() {
+      const waiters = configWaiters;
+      configWaiters = [];
+      for (let i = 0; i < waiters.length; i++) safeCall(waiters[i]);
+    }
+    function applyHostConfig(message) {
+      if (!message || typeof message !== "object") return;
+      const msg = message;
+      if (msg.source !== HOST_MESSAGE_SOURCE || msg.type !== "config") return;
+      hostConfigReceived = true;
+      if (msg.player !== void 0) {
+        hostPlayer = sanitizePlayer(msg.player);
+      }
+      const rewardedAds = msg.rewardedAds;
+      if (rewardedAds && typeof rewardedAds === "object") {
+        hostConfig.rewardedAds.received = true;
+        if (rewardedAds.enabled !== void 0) {
+          hostConfig.rewardedAds.enabled = toBoolean(rewardedAds.enabled);
+        }
+        if (rewardedAds.adChannel !== void 0) {
+          hostConfig.rewardedAds.adChannel = cleanText(rewardedAds.adChannel);
+        }
+        if (rewardedAds.testMode !== void 0) {
+          hostConfig.rewardedAds.testMode = toBoolean(rewardedAds.testMode);
+        }
+        if (rewardedAds.preload !== void 0) {
+          hostConfig.rewardedAds.preload = toBoolean(rewardedAds.preload);
+        }
+        if (hostConfig.rewardedAds.enabled && (hostConfig.rewardedAds.preload || config.rewardedAds.preload)) {
+          preloadRewardedAds();
+        }
+      }
+      notifyConfigReceived();
+    }
+    function areRewardedAdsEnabled() {
+      return config.rewardedAds.enabled !== false && hostConfig.rewardedAds.enabled === true;
+    }
+    function installAdPlacementShim() {
+      const w = window;
+      w.adsbygoogle = w.adsbygoogle || [];
+      if (typeof w.adBreak !== "function") {
+        w.adBreak = function(placement) {
+          w.adsbygoogle.push(placement);
+        };
+      }
+      if (typeof w.adConfig !== "function") {
+        w.adConfig = function(settings) {
+          w.adsbygoogle.push(settings);
+        };
+      }
+    }
+    function ensureAdPlacement(options) {
+      if (typeof document === "undefined") return Promise.resolve(null);
+      installAdPlacementShim();
+      const w = window;
+      if (typeof w.adBreak !== "function") return Promise.resolve(null);
+      if (adPlacementLoad) return adPlacementLoad;
+      adPlacementLoad = new Promise(function(resolve) {
+        let script = document.getElementById(AD_PLACEMENT_SCRIPT_ID);
+        if (!script) {
+          const el = document.createElement("script");
+          el.id = AD_PLACEMENT_SCRIPT_ID;
+          el.async = true;
+          el.src = AD_PLACEMENT_SRC;
+          el.crossOrigin = "anonymous";
+          el.setAttribute("data-ad-client", ADSENSE_CLIENT_ID);
+          if (options.adChannel) el.setAttribute("data-ad-channel", options.adChannel);
+          if (options.testMode) el.setAttribute("data-adbreak-test", "on");
+          (document.head || document.documentElement).appendChild(el);
+          script = el;
+        }
+        resolve(w.adBreak);
+      });
+      return adPlacementLoad;
+    }
+    function requestAdPreload() {
+      const w = window;
+      if (adPreloadConfigured || typeof w.adConfig !== "function") return;
+      adPreloadConfigured = true;
+      try {
+        w.adConfig({ preloadAdBreaks: "on" });
+      } catch (err) {
+      }
+    }
+    function normalizeRewardedOptions(options) {
+      const opts = options && typeof options === "object" ? options : {};
+      const hostHasConfig = hostConfig.rewardedAds.received;
+      return {
+        placement: cleanText(opts.placement || opts.name, "rewarded"),
+        reward: cleanText(opts.reward, "reward"),
+        adBreakId: cleanText(opts.adBreakId, nextAdBreakId(), 128),
+        size: cleanRewardedSize(opts.size),
+        adChannel: cleanText(
+          hostHasConfig ? hostConfig.rewardedAds.adChannel : opts.adChannel || config.rewardedAds.adChannel
+        ),
+        testMode: hostHasConfig ? hostConfig.rewardedAds.testMode : opts.testMode !== void 0 ? toBoolean(opts.testMode) : config.rewardedAds.testMode || hostConfig.rewardedAds.testMode,
+        loadTimeoutMs: typeof opts.loadTimeoutMs === "number" && isFinite(opts.loadTimeoutMs) ? Math.min(15e3, Math.max(1, Math.floor(opts.loadTimeoutMs))) : config.rewardedAds.loadTimeoutMs,
+        beforeReward: opts.beforeReward,
+        adViewed: opts.adViewed,
+        adDismissed: opts.adDismissed,
+        adBreakDone: opts.adBreakDone,
+        onReward: opts.onReward,
+        onDismissed: opts.onDismissed,
+        onDone: opts.onDone,
+        onError: opts.onError,
+        onUnavailable: opts.onUnavailable
+      };
+    }
+    function rewardedAd(rawOptions) {
+      const options = normalizeRewardedOptions(rawOptions);
+      const base = {
+        placement: options.placement,
+        reward: options.reward,
+        adBreakId: options.adBreakId
+      };
+      if (options.size) base.size = options.size;
+      post("rewarded_ad", void 0, Object.assign({ event: "requested" }, base));
+      if (!areRewardedAdsEnabled()) {
+        const disabled = Object.assign(
+          { status: "unavailable", error: "host_disabled" },
+          base
+        );
+        post("rewarded_ad", void 0, Object.assign({ event: "unavailable" }, disabled));
+        safeCall(options.onUnavailable, disabled);
+        safeCall(options.onDone, disabled);
+        return Promise.resolve(disabled);
+      }
+      return ensureAdPlacement(options).then(function(adBreak) {
+        if (typeof adBreak !== "function") {
+          const unavailable = Object.assign(
+            { status: "unavailable", error: "ad_break_unavailable" },
+            base
+          );
+          post("rewarded_ad", void 0, Object.assign({ event: "unavailable" }, unavailable));
+          safeCall(options.onUnavailable, unavailable);
+          safeCall(options.onDone, unavailable);
+          return unavailable;
+        }
+        requestAdPreload();
+        return new Promise(function(resolve) {
+          let resolved = false;
+          let status = "unavailable";
+          let rewardOffered = false;
+          const waitTimer = setTimeout(function() {
+            if (rewardOffered || resolved) return;
+            const timeout = Object.assign(
+              { status: "unavailable", error: "ad_break_timeout" },
+              base
+            );
+            post("rewarded_ad", void 0, Object.assign({ event: "unavailable" }, timeout));
+            safeCall(options.onUnavailable, timeout);
+            done(timeout);
+          }, options.loadTimeoutMs);
+          function done(result) {
+            if (resolved) return;
+            resolved = true;
+            clearTimeout(waitTimer);
+            const finalResult = Object.assign(
+              { status: "unavailable" },
+              base,
+              result || {}
+            );
+            post("rewarded_ad", void 0, Object.assign({ event: "done" }, finalResult));
+            safeCall(options.onDone, finalResult);
+            resolve(finalResult);
+          }
+          function startAd(showAdFn) {
+            if (resolved) return;
+            rewardOffered = true;
+            clearTimeout(waitTimer);
+            status = "ready";
+            let shown = false;
+            function show() {
+              if (shown) return;
+              shown = true;
+              post("rewarded_ad", void 0, Object.assign({ event: "started" }, base));
+              try {
+                showAdFn();
+              } catch (err) {
+                const showError = Object.assign(
+                  { status: "error", error: "show_ad_error" },
+                  base
+                );
+                post("rewarded_ad", void 0, Object.assign({ event: "error" }, showError));
+                safeCall(options.onError, showError);
+                done(showError);
+              }
+            }
+            post("rewarded_ad", void 0, Object.assign({ event: "ready" }, base));
+            try {
+              if (typeof options.beforeReward === "function") options.beforeReward(show);
+              else show();
+            } catch (err) {
+              const beforeError = Object.assign(
+                { status: "error", error: "before_reward_error" },
+                base
+              );
+              post("rewarded_ad", void 0, Object.assign({ event: "error" }, beforeError));
+              safeCall(options.onError, beforeError);
+              done(beforeError);
+            }
+          }
+          try {
+            adBreak({
+              type: "reward",
+              name: options.placement,
+              size: options.size || void 0,
+              beforeReward: startAd,
+              adViewed: function() {
+                status = "viewed";
+                const viewed = Object.assign({ status }, base);
+                post("rewarded_ad", void 0, Object.assign({ event: "viewed" }, viewed));
+                safeCall(options.adViewed, viewed);
+                safeCall(options.onReward, viewed);
+              },
+              adDismissed: function() {
+                if (status !== "viewed") status = "dismissed";
+                const dismissed = Object.assign({ status }, base);
+                post("rewarded_ad", void 0, Object.assign({ event: "dismissed" }, dismissed));
+                safeCall(options.adDismissed, dismissed);
+                safeCall(options.onDismissed, dismissed);
+              },
+              adBreakDone: function(placementInfo) {
+                const result = rewardOffered || status !== "unavailable" ? { status } : { status: "unavailable", error: "no_rewarded_ad" };
+                if (placementInfo && typeof placementInfo === "object") {
+                  result.breakStatus = cleanText(
+                    placementInfo.breakStatus
+                  );
+                }
+                if (result.status === "unavailable") {
+                  post(
+                    "rewarded_ad",
+                    void 0,
+                    Object.assign({ event: "unavailable" }, base, result)
+                  );
+                  safeCall(
+                    options.onUnavailable,
+                    Object.assign({ status: "unavailable" }, base, result)
+                  );
+                }
+                safeCall(options.adBreakDone, placementInfo);
+                done(result);
+              }
+            });
+          } catch (err) {
+            const error = Object.assign(
+              { status: "error", error: "ad_break_error" },
+              base
+            );
+            post("rewarded_ad", void 0, Object.assign({ event: "error" }, error));
+            safeCall(options.onError, error);
+            done(error);
+          }
+        });
+      });
+    }
+    function preloadRewardedAds(rawOptions) {
+      const options = normalizeRewardedOptions(rawOptions);
+      if (!areRewardedAdsEnabled()) return Promise.resolve(false);
+      return ensureAdPlacement(options).then(function(adBreak) {
+        if (typeof adBreak !== "function") return false;
+        requestAdPreload();
+        return true;
+      });
+    }
+    function whenHostConfig(graceMs) {
+      if (hostConfigReceived || !isEmbedded()) return Promise.resolve();
+      return new Promise(function(resolve) {
+        const timer = setTimeout(resolve, graceMs);
+        configWaiters.push(function() {
+          clearTimeout(timer);
+          resolve();
+        });
+      });
+    }
+    function getPlayer() {
+      if (blocked) return Promise.resolve(null);
+      return whenHostConfig(INIT_CONFIG_GRACE_MS).then(function() {
+        return hostPlayer ? { name: hostPlayer.name, avatarUrl: hostPlayer.avatarUrl } : null;
+      });
+    }
+    function init(options) {
+      configure(options);
+      post("init");
+      return whenHostConfig(INIT_CONFIG_GRACE_MS);
+    }
+    function ready() {
+      post("ready");
+    }
+    function normalizeRewardedBreakInput(optionsOrOnStart) {
+      if (typeof optionsOrOnStart === "function") return { onStart: optionsOrOnStart };
+      return optionsOrOnStart && typeof optionsOrOnStart === "object" ? optionsOrOnStart : {};
+    }
+    function rewardedBreak(optionsOrOnStart) {
+      const rawOptions = normalizeRewardedBreakInput(optionsOrOnStart);
+      const normalized = normalizeRewardedOptions(rawOptions);
+      const base = {
+        adBreakId: normalized.adBreakId,
+        placement: normalized.placement,
+        reward: normalized.reward
+      };
+      if (normalized.size) base.size = normalized.size;
+      if (rewardedBreakActive) {
+        post(
+          "rewarded_ad",
+          void 0,
+          Object.assign(
+            { event: "unavailable", status: "unavailable", error: "ad_in_progress" },
+            base
+          )
+        );
+        return Promise.resolve(false);
+      }
+      rewardedBreakActive = true;
+      let startCalled = false;
+      return rewardedAd(
+        Object.assign({}, rawOptions, {
+          beforeReward: function(showAd) {
+            if (startCalled) return;
+            startCalled = true;
+            safeCall(rawOptions.onStart);
+            showAd();
+          }
+        })
+      ).then(
+        function(result) {
+          rewardedBreakActive = false;
+          return Boolean(result && result.status === "viewed");
+        },
+        function() {
+          rewardedBreakActive = false;
+          return false;
+        }
+      );
+    }
+    window.addEventListener("message", function(event) {
+      if (event.source !== window.parent) return;
+      if (!hostnameAllowed(event.origin, DEFAULT_ALLOW)) return;
+      applyHostConfig(event.data);
+    });
+    const sdk = {
+      lockToHost,
+      init,
+      configure,
+      preloadRewardedAds,
+      preloadRewardedAd: preloadRewardedAds,
+      ready,
+      gameLoadingFinished: ready,
+      gameplayStart: function() {
+        post("gameplay_start");
+      },
+      gameplayStop: function() {
+        post("gameplay_stop");
+      },
+      submitScore: function(score, opts) {
+        post("score", score, opts && opts.mode === "daily" ? { mode: "daily" } : void 0);
+      },
+      gameOver: function(score, opts) {
+        post("gameover", score, opts && opts.mode === "daily" ? { mode: "daily" } : void 0);
+      },
+      xrSessionStart: function() {
+        post("xr_session_start");
+      },
+      xrSessionEnd: function() {
+        post("xr_session_end");
+      },
+      rewardedAd,
+      showRewardedAd: rewardedAd,
+      rewardedBreak,
+      save: function(blob) {
+        return request("save", String(blob));
+      },
+      load: function() {
+        return request("load");
+      },
+      getPlayer,
+      getVariant: function(key, variants) {
+        const sorted = Array.isArray(variants) ? variants.slice().sort() : [];
+        const fallback = sorted.length > 0 ? sorted[0] : null;
+        if (typeof key !== "string" || !key || sorted.length < 2) {
+          return Promise.resolve(fallback);
+        }
+        return request("experiment", { key, variants: sorted }).then(
+          function(variant) {
+            return typeof variant === "string" ? variant : fallback;
+          },
+          function() {
+            return fallback;
+          }
+        );
+      },
+      version: VERSION
+    };
+    sdk._request = request;
+    return sdk;
+  }
+
+  // src/inert.ts
+  function sdkError2(code) {
+    const err = new Error(code);
+    err.code = code;
+    return err;
+  }
+  function createInertBBArcade() {
+    const noop = () => {
+    };
+    const unavailable = () => Promise.resolve({
+      status: "unavailable",
+      error: "ad_break_unavailable",
+      placement: "rewarded",
+      reward: "reward",
+      adBreakId: "bbad_inert"
+    });
+    return {
+      lockToHost: noop,
+      init: () => Promise.resolve(),
+      configure: noop,
+      preloadRewardedAds: () => Promise.resolve(false),
+      preloadRewardedAd: () => Promise.resolve(false),
+      ready: noop,
+      gameLoadingFinished: noop,
+      gameplayStart: noop,
+      gameplayStop: noop,
+      submitScore: noop,
+      gameOver: noop,
+      xrSessionStart: noop,
+      xrSessionEnd: noop,
+      rewardedAd: unavailable,
+      showRewardedAd: unavailable,
+      rewardedBreak: () => Promise.resolve(false),
+      save: () => Promise.reject(sdkError2("unsupported")),
+      load: () => Promise.reject(sdkError2("unsupported")),
+      getPlayer: () => Promise.resolve(null),
+      getVariant: (key, variants) => {
+        const sorted = Array.isArray(variants) ? variants.slice().sort() : [];
+        return Promise.resolve(sorted.length > 0 ? sorted[0] : null);
+      },
+      version: VERSION
+    };
+  }
+
+  // src/index.ts
+  var BBArcade = typeof window === "undefined" ? createInertBBArcade() : createBBArcade();
+
+  // src/multiplayer.ts
+  var WELCOME_TIMEOUT_MS = 1e4;
+  var MAX_RECONNECT_ATTEMPTS = 3;
+  var CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+  var CODE_LENGTH = 4;
+  function sdkError3(code) {
+    const err = new Error(code);
+    err.code = code;
+    return err;
+  }
+  function randomChars(length) {
+    const indices = new Uint8Array(length);
+    if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+      crypto.getRandomValues(indices);
+    } else {
+      for (let i = 0; i < length; i++) indices[i] = Math.floor(Math.random() * 256);
+    }
+    let out = "";
+    for (let i = 0; i < length; i++) out += CODE_ALPHABET[indices[i] % CODE_ALPHABET.length];
+    return out;
+  }
+  function generateCode() {
+    return randomChars(CODE_LENGTH);
+  }
+  var guestKey = null;
+  function getGuestKey() {
+    if (!guestKey) guestKey = randomChars(16);
+    return guestKey;
+  }
+  function requestTicket(roomId) {
+    const request = BBArcade._request;
+    if (typeof request !== "function") return Promise.reject(sdkError3("unsupported"));
+    return request("mp_ticket", { roomId, guestKey: getGuestKey() }).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 };
+    });
+  }
+  var RoomConnection = class {
+    constructor(code, devGrant) {
+      this.playerId = "";
+      this.players = [];
+      this.state = 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
+      // typed without fighting generic index-assignment rules.
+      this.handlers = {};
+      this.seq = 0;
+      this.intentionalClose = false;
+      this.ended = false;
+      // Set when the server definitively rejected us (bad ticket, room full/over)
+      // or the welcome timed out — permanent outcomes that must not reconnect.
+      this.terminal = false;
+      this.reconnectAttempts = 0;
+      this.code = code;
+      this.devGrant = devGrant;
+    }
+    /** Connect and resolve on the server's welcome (post-ticket-verification). */
+    connect(grant) {
+      return new Promise((resolve, reject) => {
+        let settled = false;
+        const url = grant.roomUrl + (grant.roomUrl.indexOf("?") === -1 ? "?" : "&") + "ticket=" + encodeURIComponent(grant.ticket);
+        let ws;
+        try {
+          ws = new WebSocket(url);
+        } catch (err) {
+          return reject(sdkError3("error"));
+        }
+        this.ws = ws;
+        const welcomeTimer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          this.terminal = true;
+          try {
+            ws.close();
+          } catch (err) {
+          }
+          reject(sdkError3("error"));
+        }, WELCOME_TIMEOUT_MS);
+        ws.onmessage = (event) => {
+          var _a, _b, _c, _d, _e;
+          let msg;
+          try {
+            msg = JSON.parse(String(event.data));
+          } catch (err) {
+            return;
+          }
+          if (!msg || typeof msg.t !== "string") return;
+          if (msg.t === "welcome") {
+            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.reconnectAttempts = 0;
+            if (!settled) {
+              settled = true;
+              clearTimeout(welcomeTimer);
+              resolve(this);
+            }
+            return;
+          }
+          if (msg.t === "snapshot") {
+            this.state = (_c = msg.state) != null ? _c : this.state;
+            this.emit("snapshot", { tick: Number(msg.tick) || 0, state: this.state });
+            return;
+          }
+          if (msg.t === "player_join") {
+            const player = msg.player;
+            if (player && player.id && !this.players.some((p) => p.id === player.id)) {
+              this.players.push(player);
+            }
+            this.emit("playerJoin", { player });
+            return;
+          }
+          if (msg.t === "player_leave") {
+            const playerId = String((_d = msg.playerId) != null ? _d : "");
+            this.players = this.players.filter((p) => p.id !== playerId);
+            this.emit("playerLeave", { playerId });
+            return;
+          }
+          if (msg.t === "event") {
+            this.emit("event", msg.data);
+            return;
+          }
+          if (msg.t === "match_end") {
+            this.ended = true;
+            this.emit("end", {
+              results: Array.isArray(msg.results) ? msg.results : []
+            });
+            return;
+          }
+          if (msg.t === "error") {
+            const code = String((_e = msg.code) != null ? _e : "error");
+            if (!settled) {
+              settled = true;
+              this.terminal = true;
+              clearTimeout(welcomeTimer);
+              try {
+                ws.close();
+              } catch (err) {
+              }
+              reject(sdkError3(code === "unauthenticated" ? "unauthenticated" : "rejected"));
+              return;
+            }
+            this.emit("error", { code });
+          }
+        };
+        ws.onclose = () => {
+          if (!settled) {
+            settled = true;
+            clearTimeout(welcomeTimer);
+            reject(sdkError3("error"));
+            return;
+          }
+          if (this.intentionalClose || this.ended || this.terminal) {
+            this.emit("close", { reconnecting: false });
+            return;
+          }
+          void this.reconnect();
+        };
+        ws.onerror = () => {
+        };
+      });
+    }
+    async reconnect() {
+      var _a;
+      if (this.intentionalClose || this.ended || this.terminal) return;
+      if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+        this.emit("close", { reconnecting: false });
+        return;
+      }
+      this.reconnectAttempts += 1;
+      this.emit("close", { reconnecting: true });
+      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);
+        if (this.intentionalClose || this.ended || this.terminal) return;
+        await this.connect(grant);
+        if (this.intentionalClose) this.leave();
+      } catch (err) {
+        void this.reconnect();
+      }
+    }
+    send(input) {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+      this.seq += 1;
+      try {
+        this.ws.send(JSON.stringify({ t: "input", seq: this.seq, data: input }));
+      } catch (err) {
+      }
+    }
+    on(event, handler) {
+      var _a, _b;
+      const list = (_b = (_a = this.handlers)[event]) != null ? _b : _a[event] = [];
+      const entry = handler;
+      list.push(entry);
+      return () => {
+        const idx = list.indexOf(entry);
+        if (idx !== -1) list.splice(idx, 1);
+      };
+    }
+    leave() {
+      var _a;
+      this.intentionalClose = true;
+      try {
+        (_a = this.ws) == null ? void 0 : _a.close(1e3);
+      } catch (err) {
+      }
+    }
+    emit(event, data) {
+      const list = this.handlers[event];
+      if (!list) return;
+      for (const handler of list.slice()) {
+        try {
+          handler(data);
+        } catch (err) {
+          setTimeout(() => {
+            throw err;
+          }, 0);
+        }
+      }
+    }
+  };
+  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();
+    if (opts.roomUrl && opts.ticket) {
+      const devGrant = { ticket: opts.ticket, roomUrl: opts.roomUrl, expiresAt: 0 };
+      return new RoomConnection(code, devGrant).connect(devGrant);
+    }
+    return requestTicket(code).then((grant) => new RoomConnection(code, null).connect(grant));
+  }
+  var multiplayer = { joinRoom };
+
+  // src/global.ts
+  BBArcade.multiplayer = multiplayer;
+  window.BBArcade = BBArcade;
+})();