@hyve-sdk/js 1.5.1 → 2.1.1

package/dist/react.mjs

@@ -0,0 +1,2151 @@
+// src/react.tsx
+import {
+  createContext,
+  useContext,
+  useRef
+} from "react";
+
+// src/utils/index.ts
+import { v4 as uuidv4 } from "uuid";
+
+// src/utils/logger.ts
+var Logger = class _Logger {
+  config;
+  constructor() {
+    this.config = this.initializeConfig();
+  }
+  /**
+   * Initialize logger configuration based on NODE_ENV
+   */
+  initializeConfig() {
+    const isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+    let enabled = false;
+    let levels = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]);
+    if (isNode) {
+      const nodeEnv = process.env.NODE_ENV;
+      enabled = nodeEnv !== "production";
+      const logLevelEnv = process.env.HYVE_SDK_LOG_LEVEL;
+      if (logLevelEnv) {
+        const configuredLevels = logLevelEnv.split(",").map((l) => l.trim());
+        levels = new Set(configuredLevels);
+      }
+    } else if (typeof window !== "undefined") {
+      try {
+        enabled = process?.env.NODE_ENV !== "production";
+      } catch (e) {
+        enabled = true;
+      }
+      try {
+        const localStorageLogLevel = localStorage.getItem("HYVE_SDK_LOG_LEVEL");
+        if (localStorageLogLevel) {
+          const configuredLevels = localStorageLogLevel.split(",").map((l) => l.trim());
+          levels = new Set(configuredLevels);
+        }
+      } catch (e) {
+      }
+    }
+    return {
+      enabled,
+      prefix: "[Hyve SDK]",
+      levels
+    };
+  }
+  /**
+   * Set which log levels to display
+   */
+  setLevels(levels) {
+    this.config.levels = new Set(levels);
+    if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+      try {
+        localStorage.setItem("HYVE_SDK_LOG_LEVEL", levels.join(","));
+      } catch (e) {
+      }
+    }
+  }
+  /**
+   * Check if logging is enabled
+   */
+  isEnabled() {
+    return this.config.enabled;
+  }
+  /**
+   * Internal log method
+   */
+  log(level, ...args) {
+    if (!this.config.enabled || !this.config.levels.has(level)) {
+      return;
+    }
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `${this.config.prefix} [${level.toUpperCase()}] [${timestamp}]`;
+    switch (level) {
+      case "debug":
+        console.debug(prefix, ...args);
+        break;
+      case "info":
+        console.info(prefix, ...args);
+        break;
+      case "warn":
+        console.warn(prefix, ...args);
+        break;
+      case "error":
+        console.error(prefix, ...args);
+        break;
+    }
+  }
+  /**
+   * Log a debug message
+   */
+  debug(...args) {
+    this.log("debug", ...args);
+  }
+  /**
+   * Log an info message
+   */
+  info(...args) {
+    this.log("info", ...args);
+  }
+  /**
+   * Log a warning message
+   */
+  warn(...args) {
+    this.log("warn", ...args);
+  }
+  /**
+   * Log an error message
+   */
+  error(...args) {
+    this.log("error", ...args);
+  }
+  /**
+   * Create a child logger with a specific prefix
+   */
+  child(prefix) {
+    const childLogger = new _Logger();
+    childLogger.config = {
+      ...this.config,
+      prefix: `${this.config.prefix} [${prefix}]`
+    };
+    return childLogger;
+  }
+};
+var logger = new Logger();
+
+// src/utils/auth.ts
+function parseUrlParams(searchParams) {
+  const params = typeof searchParams === "string" ? new URLSearchParams(searchParams) : searchParams;
+  return {
+    gameStartTab: params.get("game_start_tab") || "",
+    platform: params.get("platform") || "",
+    hyveAccess: params.get("hyve-access") || "",
+    gameId: params.get("game-id") || ""
+  };
+}
+
+// src/utils/native-bridge.ts
+var NativeBridge = class {
+  static handlers = /* @__PURE__ */ new Map();
+  static isInitialized = false;
+  /**
+   * Checks if the app is running inside a React Native WebView
+   */
+  static isNativeContext() {
+    return typeof window !== "undefined" && "ReactNativeWebView" in window;
+  }
+  /**
+   * Initializes the native bridge message listener
+   * Call this once when your app starts
+   */
+  static initialize() {
+    if (this.isInitialized) {
+      logger.debug("[NativeBridge] Already initialized");
+      return;
+    }
+    if (typeof window === "undefined") {
+      logger.warn("[NativeBridge] Window not available, skipping initialization");
+      return;
+    }
+    const boundHandler = this.handleNativeMessage.bind(this);
+    window.addEventListener("message", boundHandler);
+    document.addEventListener("message", boundHandler);
+    this.isInitialized = true;
+    logger.info("[NativeBridge] Initialized and listening for native messages");
+  }
+  /**
+   * Handles incoming messages from React Native
+   */
+  static handleNativeMessage(event) {
+    try {
+      let data;
+      if (typeof event.data === "string") {
+        try {
+          data = JSON.parse(event.data);
+        } catch {
+          logger.debug("[NativeBridge] Ignoring non-JSON message");
+          return;
+        }
+      } else if (typeof event.data === "object" && event.data !== null) {
+        data = event.data;
+      } else {
+        return;
+      }
+      if (!data?.type) {
+        return;
+      }
+      const nativeResponseTypes = [
+        "IAP_AVAILABILITY_RESULT" /* IAP_AVAILABILITY_RESULT */,
+        "PUSH_PERMISSION_GRANTED" /* PUSH_PERMISSION_GRANTED */,
+        "PUSH_PERMISSION_DENIED" /* PUSH_PERMISSION_DENIED */,
+        "PRODUCTS_RESULT" /* PRODUCTS_RESULT */,
+        "PURCHASE_COMPLETE" /* PURCHASE_COMPLETE */,
+        "PURCHASE_ERROR" /* PURCHASE_ERROR */
+      ];
+      if (!nativeResponseTypes.includes(data.type)) {
+        return;
+      }
+      const handler = this.handlers.get(data.type);
+      if (handler) {
+        logger.debug(`[NativeBridge] Handling message: ${data.type}`);
+        handler(data.payload);
+      } else {
+        logger.warn(`[NativeBridge] No handler registered for: ${data.type}`);
+      }
+    } catch (error) {
+      logger.error("[NativeBridge] Error handling native message:", error);
+    }
+  }
+  /**
+   * Sends a message to React Native
+   * @param type Message type
+   * @param payload Optional payload data
+   */
+  static send(type, payload) {
+    if (!this.isNativeContext()) {
+      logger.debug(`[NativeBridge] Not in native context, skipping message: ${type}`);
+      return;
+    }
+    try {
+      const message = { type, payload, timestamp: Date.now() };
+      window.ReactNativeWebView.postMessage(JSON.stringify(message));
+      logger.debug(`[NativeBridge] Sent message to native: ${type}`, payload);
+    } catch (error) {
+      logger.error(`[NativeBridge] Error sending message to native:`, error);
+    }
+  }
+  /**
+   * Registers a handler for messages from React Native
+   * @param type Message type to listen for
+   * @param handler Function to call when message is received
+   */
+  static on(type, handler) {
+    this.handlers.set(type, handler);
+    logger.debug(`[NativeBridge] Registered handler for: ${type}`);
+  }
+  /**
+   * Unregisters a handler for a specific message type
+   * @param type Message type to stop listening for
+   */
+  static off(type) {
+    this.handlers.delete(type);
+    logger.debug(`[NativeBridge] Unregistered handler for: ${type}`);
+  }
+  /**
+   * Clears all registered handlers
+   */
+  static clearHandlers() {
+    this.handlers.clear();
+    logger.debug("[NativeBridge] Cleared all handlers");
+  }
+  /**
+   * Checks if In-App Purchases are available on the device
+   * The native app will respond with a message containing availability status
+   *
+   * @example
+   * // Listen for the response
+   * NativeBridge.on("IAP_AVAILABILITY_RESULT", (payload) => {
+   *   console.log("IAP available:", payload.available);
+   * });
+   *
+   * // Send the request
+   * NativeBridge.checkIAPAvailability();
+   */
+  static checkIAPAvailability() {
+    this.send("CHECK_IAP_AVAILABILITY" /* CHECK_IAP_AVAILABILITY */);
+  }
+  /**
+   * Requests notification permission from the native app
+   * The native app will respond with PUSH_PERMISSION_GRANTED or PUSH_PERMISSION_DENIED
+   *
+   * @example
+   * // Listen for the response
+   * NativeBridge.on("PUSH_PERMISSION_GRANTED", () => {
+   *   console.log("Permission granted");
+   * });
+   *
+   * NativeBridge.on("PUSH_PERMISSION_DENIED", () => {
+   *   console.log("Permission denied");
+   * });
+   *
+   * // Send the request
+   * NativeBridge.requestNotificationPermission();
+   */
+  static requestNotificationPermission() {
+    this.send("REQUEST_NOTIFICATION_PERMISSION" /* REQUEST_NOTIFICATION_PERMISSION */);
+  }
+  /**
+   * Requests available products for a specific game
+   * The native app will respond with PRODUCTS_RESULT containing product details
+   *
+   * @param gameId - The game ID to fetch products for
+   *
+   * @example
+   * // Listen for the response
+   * NativeBridge.on("PRODUCTS_RESULT", (payload) => {
+   *   console.log("Products:", payload.products);
+   * });
+   *
+   * // Send the request
+   * NativeBridge.getProducts(123);
+   */
+  static getProducts(gameId) {
+    this.send("GET_PRODUCTS" /* GET_PRODUCTS */, { gameId });
+  }
+  /**
+   * Initiates a purchase for a specific product
+   * The native app will respond with PURCHASE_COMPLETE or PURCHASE_ERROR
+   *
+   * @param productId - The product ID to purchase
+   * @param userId - The user ID making the purchase
+   *
+   * @example
+   * // Listen for responses
+   * NativeBridge.on("PURCHASE_COMPLETE", (payload) => {
+   *   console.log("Purchase successful:", payload.productId);
+   * });
+   *
+   * NativeBridge.on("PURCHASE_ERROR", (payload) => {
+   *   console.error("Purchase failed:", payload.error);
+   * });
+   *
+   * // Initiate purchase
+   * NativeBridge.purchase("product_123", "user_456");
+   */
+  static purchase(productId, userId) {
+    this.send("PURCHASE" /* PURCHASE */, { productId, userId });
+  }
+};
+
+// src/utils/jwt.ts
+function decodeJwt(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) {
+      logger.warn("Invalid JWT format - expected 3 parts");
+      return null;
+    }
+    const payload = parts[1];
+    const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const jsonPayload = atob(base64);
+    const decoded = JSON.parse(jsonPayload);
+    logger.debug("JWT decoded successfully:", decoded);
+    return decoded;
+  } catch (error) {
+    logger.error("Failed to decode JWT:", error);
+    return null;
+  }
+}
+function extractUserIdFromJwt(token) {
+  const payload = decodeJwt(token);
+  if (!payload) {
+    return null;
+  }
+  const userId = payload.sub || payload.user_id?.toString();
+  if (userId) {
+    logger.info("Extracted user ID from JWT:", userId);
+    return userId;
+  }
+  logger.warn("No user ID found in JWT payload");
+  return null;
+}
+function extractGameIdFromJwt(token) {
+  const payload = decodeJwt(token);
+  if (!payload) {
+    return null;
+  }
+  const gameId = payload.game_id;
+  if (typeof gameId === "number") {
+    logger.info("Extracted game ID from JWT:", gameId);
+    return gameId;
+  }
+  return null;
+}
+
+// src/utils/index.ts
+function generateUUID() {
+  return uuidv4();
+}
+
+// src/services/ads.ts
+var AdsService = class {
+  config = {
+    sound: "on",
+    debug: false,
+    onBeforeAd: () => {
+    },
+    onAfterAd: () => {
+    },
+    onRewardEarned: () => {
+    }
+  };
+  // Cached init promise — ensures adConfig() is only called once
+  initPromise = null;
+  ready = false;
+  /**
+   * Optionally configure the ads service.
+   * Not required — ads work without calling this.
+   */
+  configure(config) {
+    this.config = {
+      ...this.config,
+      ...config,
+      onBeforeAd: config.onBeforeAd ?? this.config.onBeforeAd,
+      onAfterAd: config.onAfterAd ?? this.config.onAfterAd,
+      onRewardEarned: config.onRewardEarned ?? this.config.onRewardEarned
+    };
+    if (this.config.debug) {
+      logger.debug("[AdsService] Configuration updated:", { sound: this.config.sound });
+    }
+  }
+  /**
+   * Initialize the Google H5 Ads system.
+   * Returns a cached promise — safe to call multiple times.
+   */
+  initialize() {
+    if (this.initPromise) return this.initPromise;
+    this.initPromise = new Promise((resolve) => {
+      if (!window.adConfig || !window.adBreak) {
+        if (this.config.debug) {
+          logger.debug("[AdsService] Google Ads SDK not found \u2014 ads unavailable");
+        }
+        resolve(false);
+        return;
+      }
+      if (this.config.debug) {
+        logger.debug("[AdsService] Initializing ads system...");
+      }
+      window.adConfig({
+        sound: this.config.sound,
+        preloadAdBreaks: "on",
+        onReady: () => {
+          this.ready = true;
+          if (this.config.debug) {
+            logger.debug("[AdsService] Ads ready");
+          }
+          resolve(true);
+        }
+      });
+      setTimeout(() => resolve(false), 5e3);
+    });
+    return this.initPromise;
+  }
+  /**
+   * Show an ad. Auto-initializes on the first call.
+   * Returns immediately with success: false if ads are disabled or unavailable.
+   */
+  async show(type) {
+    const requestedAt = Date.now();
+    const ready = await this.initialize();
+    if (!ready || !window.adBreak) {
+      return {
+        success: false,
+        type,
+        error: new Error("Ads not available"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    return this.showAdBreak(type);
+  }
+  /**
+   * Show an ad break via the Google H5 API.
+   */
+  async showAdBreak(type) {
+    const requestedAt = Date.now();
+    return new Promise((resolve) => {
+      const googleType = type === "rewarded" ? "reward" : type === "preroll" ? "start" : "next";
+      const adName = `${type}-ad-${Date.now()}`;
+      if (this.config.debug) {
+        logger.debug(`[AdsService] Showing ${type} ad`);
+      }
+      this.config.onBeforeAd(type);
+      const adBreakConfig = {
+        type: googleType,
+        name: adName,
+        afterAd: () => {
+          this.config.onAfterAd(type);
+        },
+        adBreakDone: (info) => {
+          const completedAt = Date.now();
+          const success = type === "rewarded" ? info?.breakStatus === "viewed" : info?.breakStatus !== "error";
+          const error = info?.breakStatus === "error" && info?.error ? new Error(info.error) : void 0;
+          if (this.config.debug) {
+            logger.debug("[AdsService] Ad break done:", { success, status: info?.breakStatus });
+          }
+          resolve({ success, type, error, requestedAt, completedAt });
+        }
+      };
+      if (type === "rewarded") {
+        adBreakConfig.beforeReward = (showAdFn) => showAdFn();
+        adBreakConfig.adViewed = () => this.config.onRewardEarned();
+      }
+      window.adBreak(adBreakConfig);
+    });
+  }
+  /**
+   * Returns the configured ad lifecycle callbacks.
+   * Used by platform-specific providers (e.g. Playgama) to fire the same hooks.
+   */
+  getCallbacks() {
+    return {
+      onBeforeAd: this.config.onBeforeAd,
+      onAfterAd: this.config.onAfterAd,
+      onRewardEarned: this.config.onRewardEarned
+    };
+  }
+  /**
+   * Check if ads have successfully initialized and are ready to show.
+   */
+  isReady() {
+    return this.ready;
+  }
+};
+
+// src/services/playgama.ts
+var PLAYGAMA_BRIDGE_CDN = "https://bridge.playgama.com/v1/stable/playgama-bridge.js";
+var PlaygamaService = class {
+  initialized = false;
+  /**
+   * Detects if the game is running on the Playgama platform.
+   * Playgama injects a `platform_id=playgama` URL parameter into the game URL.
+   * Falls back to checking document.referrer for playgama.com.
+   */
+  static isPlaygamaDomain() {
+    try {
+      const url = new URL(window.location.href);
+      if (url.searchParams.get("platform_id") === "playgama") {
+        return true;
+      }
+      if (document.referrer.includes("playgama.com")) {
+        return true;
+      }
+      if (window !== window.top) {
+        try {
+          if (window.parent.location.hostname.includes("playgama.com")) {
+            return true;
+          }
+        } catch {
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Loads the Playgama Bridge script from CDN and initializes it.
+   * Safe to call multiple times - resolves immediately if already initialized.
+   */
+  async initialize() {
+    if (this.initialized) return true;
+    try {
+      await this.loadScript();
+      await window.bridge.initialize();
+      this.initialized = true;
+      return true;
+    } catch (error) {
+      logger.warn("[PlaygamaService] Failed to initialize:", error);
+      return false;
+    }
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  async showInterstitial(callbacks) {
+    const requestedAt = Date.now();
+    const bridge = window.bridge;
+    if (!this.initialized || !bridge) {
+      return {
+        success: false,
+        type: "interstitial",
+        error: new Error("Playgama not initialized"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    if (!bridge.advertisement.isInterstitialSupported) {
+      return {
+        success: false,
+        type: "interstitial",
+        error: new Error("Interstitial ads not supported on this platform"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    return new Promise((resolve) => {
+      const handler = (state) => {
+        if (state === "opened") {
+          callbacks?.onBeforeAd?.();
+        } else if (state === "closed") {
+          bridge.advertisement.off(bridge.EVENT_NAME.INTERSTITIAL_STATE_CHANGED, handler);
+          callbacks?.onAfterAd?.();
+          resolve({ success: true, type: "interstitial", requestedAt, completedAt: Date.now() });
+        } else if (state === "failed") {
+          bridge.advertisement.off(bridge.EVENT_NAME.INTERSTITIAL_STATE_CHANGED, handler);
+          callbacks?.onAfterAd?.();
+          resolve({
+            success: false,
+            type: "interstitial",
+            error: new Error("Interstitial ad failed"),
+            requestedAt,
+            completedAt: Date.now()
+          });
+        }
+      };
+      bridge.advertisement.on(bridge.EVENT_NAME.INTERSTITIAL_STATE_CHANGED, handler);
+      bridge.advertisement.showInterstitial();
+    });
+  }
+  async showRewarded(callbacks) {
+    const requestedAt = Date.now();
+    const bridge = window.bridge;
+    if (!this.initialized || !bridge) {
+      return {
+        success: false,
+        type: "rewarded",
+        error: new Error("Playgama not initialized"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    if (!bridge.advertisement.isRewardedSupported) {
+      return {
+        success: false,
+        type: "rewarded",
+        error: new Error("Rewarded ads not supported on this platform"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    return new Promise((resolve) => {
+      let rewarded = false;
+      const handler = (state) => {
+        if (state === "opened") {
+          callbacks?.onBeforeAd?.();
+        } else if (state === "rewarded") {
+          rewarded = true;
+          callbacks?.onRewardEarned?.();
+        } else if (state === "closed" || state === "failed") {
+          bridge.advertisement.off(bridge.EVENT_NAME.REWARDED_STATE_CHANGED, handler);
+          callbacks?.onAfterAd?.();
+          resolve({
+            success: rewarded,
+            type: "rewarded",
+            error: !rewarded ? new Error("Rewarded ad not completed") : void 0,
+            requestedAt,
+            completedAt: Date.now()
+          });
+        }
+      };
+      bridge.advertisement.on(bridge.EVENT_NAME.REWARDED_STATE_CHANGED, handler);
+      bridge.advertisement.showRewarded();
+    });
+  }
+  loadScript() {
+    return new Promise((resolve, reject) => {
+      if (window.bridge) {
+        resolve();
+        return;
+      }
+      const script = document.createElement("script");
+      script.src = PLAYGAMA_BRIDGE_CDN;
+      script.onload = () => resolve();
+      script.onerror = () => reject(new Error("Failed to load Playgama Bridge script"));
+      document.head.appendChild(script);
+    });
+  }
+};
+
+// src/services/crazygames.ts
+var CRAZYGAMES_SDK_CDN = "https://sdk.crazygames.com/crazygames-sdk-v2.js";
+var CrazyGamesService = class {
+  initialized = false;
+  /**
+   * Detects if the game is running on the CrazyGames platform.
+   * Games on CrazyGames run inside an iframe, so we check document.referrer
+   * and attempt to read the parent frame location.
+   */
+  static isCrazyGamesDomain() {
+    try {
+      if (document.referrer.includes("crazygames.com")) {
+        return true;
+      }
+      if (window !== window.top) {
+        try {
+          if (window.parent.location.hostname.includes("crazygames.com")) {
+            return true;
+          }
+        } catch {
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Loads the CrazyGames SDK from CDN and confirms the environment is 'crazygames'.
+   * Safe to call multiple times — resolves immediately if already initialized.
+   */
+  async initialize() {
+    if (this.initialized) return true;
+    try {
+      await this.loadScript();
+      const sdk = window.CrazyGames?.SDK;
+      if (!sdk) {
+        logger.warn("[CrazyGamesService] SDK not found after script load");
+        return false;
+      }
+      const env = await sdk.getEnvironment();
+      if (env !== "crazygames" && env !== "local") {
+        logger.warn("[CrazyGamesService] Unexpected environment:", env);
+        return false;
+      }
+      this.initialized = true;
+      return true;
+    } catch (error) {
+      logger.warn("[CrazyGamesService] Failed to initialize:", error);
+      return false;
+    }
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Shows a midgame (interstitial) ad via the CrazyGames SDK.
+   */
+  async showInterstitial(callbacks) {
+    const requestedAt = Date.now();
+    const sdk = window.CrazyGames?.SDK;
+    if (!this.initialized || !sdk) {
+      return {
+        success: false,
+        type: "interstitial",
+        error: new Error("CrazyGames SDK not initialized"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    return new Promise((resolve) => {
+      sdk.ad.requestAd("midgame", {
+        adStarted: () => {
+          callbacks?.onBeforeAd?.();
+        },
+        adFinished: () => {
+          callbacks?.onAfterAd?.();
+          resolve({ success: true, type: "interstitial", requestedAt, completedAt: Date.now() });
+        },
+        adError: (error) => {
+          callbacks?.onAfterAd?.();
+          resolve({
+            success: false,
+            type: "interstitial",
+            error: new Error(`CrazyGames interstitial ad error: ${error}`),
+            requestedAt,
+            completedAt: Date.now()
+          });
+        }
+      });
+    });
+  }
+  /**
+   * Shows a rewarded ad via the CrazyGames SDK.
+   * Resolves with success: true only when adFinished fires (ad was fully watched).
+   */
+  async showRewarded(callbacks) {
+    const requestedAt = Date.now();
+    const sdk = window.CrazyGames?.SDK;
+    if (!this.initialized || !sdk) {
+      return {
+        success: false,
+        type: "rewarded",
+        error: new Error("CrazyGames SDK not initialized"),
+        requestedAt,
+        completedAt: Date.now()
+      };
+    }
+    return new Promise((resolve) => {
+      sdk.ad.requestAd("rewarded", {
+        adStarted: () => {
+          callbacks?.onBeforeAd?.();
+        },
+        adFinished: () => {
+          callbacks?.onRewardEarned?.();
+          callbacks?.onAfterAd?.();
+          resolve({ success: true, type: "rewarded", requestedAt, completedAt: Date.now() });
+        },
+        adError: (error) => {
+          callbacks?.onAfterAd?.();
+          resolve({
+            success: false,
+            type: "rewarded",
+            error: new Error(`CrazyGames rewarded ad error: ${error}`),
+            requestedAt,
+            completedAt: Date.now()
+          });
+        }
+      });
+    });
+  }
+  /**
+   * Notifies CrazyGames that gameplay has started.
+   * Call when the player actively begins or resumes playing.
+   */
+  gameplayStart() {
+    if (!this.initialized) return;
+    window.CrazyGames?.SDK.game.gameplayStart();
+  }
+  /**
+   * Notifies CrazyGames that gameplay has stopped.
+   * Call during menu access, level completion, or pausing.
+   */
+  gameplayStop() {
+    if (!this.initialized) return;
+    window.CrazyGames?.SDK.game.gameplayStop();
+  }
+  /**
+   * Triggers a celebration effect on the CrazyGames website.
+   * Use sparingly for significant achievements (boss defeat, personal record, etc.)
+   */
+  happytime() {
+    if (!this.initialized) return;
+    window.CrazyGames?.SDK.game.happytime();
+  }
+  loadScript() {
+    return new Promise((resolve, reject) => {
+      if (window.CrazyGames?.SDK) {
+        resolve();
+        return;
+      }
+      const script = document.createElement("script");
+      script.src = CRAZYGAMES_SDK_CDN;
+      script.onload = () => resolve();
+      script.onerror = () => reject(new Error("Failed to load CrazyGames SDK script"));
+      document.head.appendChild(script);
+    });
+  }
+};
+
+// src/services/billing.ts
+var BillingService = class {
+  config;
+  platform = "unknown" /* UNKNOWN */;
+  initPromise = null;
+  nativeAvailable = false;
+  // Stripe instance for web payments
+  stripe = null;
+  checkoutElement = null;
+  // Callbacks for purchase events
+  onPurchaseCompleteCallback;
+  onPurchaseErrorCallback;
+  constructor(config) {
+    this.config = config;
+    this.detectPlatform();
+  }
+  /**
+   * Update billing configuration. Resets initialization so next call re-inits with new config.
+   */
+  configure(config) {
+    this.config = {
+      ...this.config,
+      ...config
+    };
+    this.initPromise = null;
+    logger.info("[BillingService] Configuration updated");
+  }
+  /**
+   * Detects if running on web or native platform
+   */
+  detectPlatform() {
+    const isNative = NativeBridge.isNativeContext();
+    const hasWindow = typeof window !== "undefined";
+    if (isNative) {
+      this.platform = "native" /* NATIVE */;
+      logger.info("[BillingService] Platform: NATIVE");
+    } else if (hasWindow) {
+      this.platform = "web" /* WEB */;
+      logger.info("[BillingService] Platform: WEB");
+    } else {
+      this.platform = "unknown" /* UNKNOWN */;
+      logger.warn("[BillingService] Platform: UNKNOWN");
+    }
+  }
+  /**
+   * Get the current platform
+   */
+  getPlatform() {
+    return this.platform;
+  }
+  /**
+   * Initialize the billing service. Idempotent — returns cached promise on subsequent calls.
+   * Called automatically by getProducts() and purchase().
+   */
+  initialize() {
+    if (this.initPromise) return this.initPromise;
+    logger.info(`[BillingService] Initializing for ${this.platform} platform...`);
+    this.initPromise = (async () => {
+      try {
+        if (this.platform === "native" /* NATIVE */) {
+          return await this.initializeNative();
+        } else if (this.platform === "web" /* WEB */) {
+          return await this.initializeWeb();
+        }
+        logger.error("[BillingService] Cannot initialize: unknown platform");
+        return false;
+      } catch (error) {
+        logger.error("[BillingService] Initialization failed:", error?.message);
+        return false;
+      }
+    })();
+    return this.initPromise;
+  }
+  /**
+   * Initialize native billing
+   */
+  async initializeNative() {
+    return new Promise((resolve) => {
+      let resolved = false;
+      try {
+        NativeBridge.initialize();
+        NativeBridge.on(
+          "PURCHASE_COMPLETE" /* PURCHASE_COMPLETE */,
+          (payload) => {
+            logger.info("[BillingService] Purchase complete:", payload.productId);
+            const result = {
+              success: true,
+              productId: payload.productId,
+              transactionId: payload.transactionId,
+              transactionDate: payload.transactionDate
+            };
+            if (this.onPurchaseCompleteCallback) {
+              this.onPurchaseCompleteCallback(result);
+            }
+          }
+        );
+        NativeBridge.on(
+          "PURCHASE_ERROR" /* PURCHASE_ERROR */,
+          (payload) => {
+            logger.error("[BillingService] Purchase error:", payload.message);
+            const result = {
+              success: false,
+              productId: payload.productId || "unknown",
+              error: {
+                code: payload.code,
+                message: payload.message
+              }
+            };
+            if (this.onPurchaseErrorCallback) {
+              this.onPurchaseErrorCallback(result);
+            }
+          }
+        );
+        NativeBridge.on(
+          "IAP_AVAILABILITY_RESULT" /* IAP_AVAILABILITY_RESULT */,
+          (payload) => {
+            this.nativeAvailable = payload.available;
+            logger.info(`[BillingService] Native billing ${payload.available ? "available" : "unavailable"}`);
+            resolved = true;
+            resolve(payload.available);
+          }
+        );
+        setTimeout(() => {
+          NativeBridge.checkIAPAvailability();
+        }, 100);
+        setTimeout(() => {
+          if (!resolved) {
+            logger.warn("[BillingService] Native initialization timeout");
+            resolved = true;
+            resolve(false);
+          }
+        }, 5e3);
+      } catch (error) {
+        logger.error("[BillingService] Native initialization failed:", error?.message);
+        resolved = true;
+        resolve(false);
+      }
+    });
+  }
+  /**
+   * Initialize web billing (Stripe)
+   */
+  async initializeWeb() {
+    if (!this.config.stripePublishableKey) {
+      logger.error("[BillingService] Stripe publishable key not provided");
+      return false;
+    }
+    try {
+      if (typeof window === "undefined") {
+        logger.error("[BillingService] Window is undefined (not in browser)");
+        return false;
+      }
+      if (!window.Stripe) {
+        await this.loadStripeScript();
+      }
+      if (window.Stripe) {
+        this.stripe = window.Stripe(this.config.stripePublishableKey);
+        logger.info("[BillingService] Web billing initialized");
+        return true;
+      } else {
+        logger.error("[BillingService] Stripe not available after loading");
+        return false;
+      }
+    } catch (error) {
+      logger.error("[BillingService] Stripe initialization failed:", error?.message);
+      return false;
+    }
+  }
+  /**
+   * Load Stripe.js script dynamically
+   */
+  loadStripeScript() {
+    return new Promise((resolve, reject) => {
+      if (typeof window === "undefined") {
+        reject(new Error("Window is not defined"));
+        return;
+      }
+      if (window.Stripe) {
+        resolve();
+        return;
+      }
+      if (!document || !document.head) {
+        reject(new Error("document is undefined"));
+        return;
+      }
+      const script = document.createElement("script");
+      script.src = "https://js.stripe.com/v3/";
+      script.async = true;
+      script.onload = () => {
+        logger.info("[BillingService] Stripe.js loaded");
+        resolve();
+      };
+      script.onerror = () => {
+        logger.error("[BillingService] Failed to load Stripe.js");
+        reject(new Error("Failed to load Stripe.js"));
+      };
+      try {
+        document.head.appendChild(script);
+      } catch (appendError) {
+        reject(appendError);
+      }
+    });
+  }
+  /**
+   * Check if billing is available based on current config and platform state
+   */
+  isAvailable() {
+    if (this.platform === "native" /* NATIVE */) {
+      return this.nativeAvailable;
+    } else if (this.platform === "web" /* WEB */) {
+      return !!this.config.stripePublishableKey;
+    }
+    return false;
+  }
+  /**
+   * Get available products. Auto-initializes on first call.
+   */
+  async getProducts() {
+    await this.initialize();
+    if (this.platform === "native" /* NATIVE */) {
+      return await this.getProductsNative();
+    } else if (this.platform === "web" /* WEB */) {
+      return await this.getProductsWeb();
+    }
+    throw new Error("Cannot get products: unknown platform");
+  }
+  /**
+   * Get products from native IAP
+   */
+  async getProductsNative() {
+    if (!this.config.gameId || !this.config.checkoutUrl) {
+      const error = new Error("gameId and checkoutUrl required for native purchases");
+      logger.error("[BillingService]", error.message);
+      throw error;
+    }
+    const response = await fetch(
+      `${this.config.checkoutUrl}/get-native-packages?game_id=${this.config.gameId}`
+    );
+    if (!response.ok) {
+      throw new Error(`Failed to fetch native products: ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data.packages || !Array.isArray(data.packages)) {
+      throw new Error("Invalid response format: missing packages array");
+    }
+    const products = data.packages.map((pkg) => ({
+      productId: pkg.productId,
+      title: pkg.package_name,
+      description: `${pkg.game_name} - ${pkg.package_name}`,
+      price: pkg.price_cents / 100,
+      localizedPrice: pkg.price_display,
+      currency: "USD"
+    }));
+    logger.info(`[BillingService] Fetched ${products.length} native products`);
+    return products;
+  }
+  /**
+   * Get products from web API (Stripe)
+   */
+  async getProductsWeb() {
+    if (!this.config.checkoutUrl || !this.config.gameId) {
+      const error = new Error("checkoutUrl and gameId required for web purchases");
+      logger.error("[BillingService]", error.message);
+      throw error;
+    }
+    try {
+      const url = `${this.config.checkoutUrl}/get-packages?game_id=${this.config.gameId}`;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch web products: ${response.status}`);
+      }
+      const data = await response.json();
+      if (!data.packages || !Array.isArray(data.packages)) {
+        throw new Error("Invalid response format: missing packages array");
+      }
+      const products = data.packages.map((pkg) => ({
+        productId: pkg.priceId || pkg.productId,
+        // Prefer priceId for Stripe
+        title: pkg.package_name,
+        description: `${pkg.game_name} - ${pkg.package_name}`,
+        price: pkg.price_cents / 100,
+        localizedPrice: pkg.price_display,
+        currency: "USD"
+      }));
+      logger.info(`[BillingService] Fetched ${products.length} web products`);
+      return products;
+    } catch (error) {
+      logger.error("[BillingService] Failed to fetch web products:", error?.message);
+      throw error;
+    }
+  }
+  /**
+   * Purchase a product. Auto-initializes on first call.
+   * @param productId - The product ID (priceId for web/Stripe, productId for native)
+   * @param options - Optional purchase options
+   * @param options.elementId - For web: DOM element ID to mount Stripe checkout (default: 'stripe-checkout-element')
+   */
+  async purchase(productId, options) {
+    await this.initialize();
+    if (!this.isAvailable()) {
+      throw new Error("Billing is not available on this platform");
+    }
+    if (this.platform === "native" /* NATIVE */) {
+      return await this.purchaseNative(productId);
+    } else if (this.platform === "web" /* WEB */) {
+      return await this.purchaseWeb(productId, options?.elementId);
+    }
+    throw new Error("Cannot purchase: unknown platform");
+  }
+  /**
+   * Purchase via native IAP
+   */
+  async purchaseNative(productId) {
+    return new Promise((resolve, reject) => {
+      if (!this.config.userId) {
+        reject(new Error("userId is required for native purchases"));
+        return;
+      }
+      logger.info(`[BillingService] Purchasing: ${productId}`);
+      const previousCompleteCallback = this.onPurchaseCompleteCallback;
+      const previousErrorCallback = this.onPurchaseErrorCallback;
+      const cleanup = () => {
+        this.onPurchaseCompleteCallback = previousCompleteCallback;
+        this.onPurchaseErrorCallback = previousErrorCallback;
+      };
+      const completeHandler = (result) => {
+        if (result.productId === productId) {
+          cleanup();
+          resolve(result);
+          if (previousCompleteCallback) {
+            previousCompleteCallback(result);
+          }
+        }
+      };
+      const errorHandler = (result) => {
+        if (result.productId === productId) {
+          cleanup();
+          reject(new Error(result.error?.message || "Purchase failed"));
+          if (previousErrorCallback) {
+            previousErrorCallback(result);
+          }
+        }
+      };
+      this.onPurchaseCompleteCallback = completeHandler;
+      this.onPurchaseErrorCallback = errorHandler;
+      NativeBridge.purchase(productId, this.config.userId);
+      setTimeout(() => {
+        cleanup();
+        reject(new Error("Purchase timeout"));
+      }, 6e4);
+    });
+  }
+  /**
+   * Purchase via web (Stripe)
+   * @param productId - The priceId (Stripe price ID) for web purchases
+   * @param elementId - Optional DOM element ID to mount the checkout form (default: 'stripe-checkout-element')
+   */
+  async purchaseWeb(productId, elementId) {
+    if (!this.config.userId || !this.config.checkoutUrl) {
+      throw new Error("userId and checkoutUrl are required for web purchases");
+    }
+    if (!this.stripe) {
+      throw new Error("Stripe not initialized. Call initialize() first.");
+    }
+    try {
+      const returnUrl = typeof window !== "undefined" ? `${window.location.href}${window.location.href.includes("?") ? "&" : "?"}payment=complete` : void 0;
+      const requestBody = {
+        priceId: productId,
+        // API expects priceId for Stripe
+        userId: this.config.userId,
+        gameId: this.config.gameId,
+        embedded: true,
+        // Enable embedded checkout
+        return_url: returnUrl
+      };
+      const response = await fetch(`${this.config.checkoutUrl}/create-checkout-session`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(requestBody)
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Failed to create checkout session: ${response.status} - ${errorText}`);
+      }
+      const responseData = await response.json();
+      const { client_secret, id } = responseData;
+      if (!client_secret) {
+        throw new Error("No client_secret returned from checkout session");
+      }
+      await this.mountCheckoutElement(client_secret, elementId || "stripe-checkout-element");
+      logger.info(`[BillingService] Checkout session created: ${id}`);
+      return {
+        success: true,
+        productId,
+        transactionId: id
+      };
+    } catch (error) {
+      logger.error("[BillingService] Web purchase failed:", error?.message);
+      return {
+        success: false,
+        productId,
+        error: {
+          code: "WEB_PURCHASE_FAILED",
+          message: error.message || "Purchase failed"
+        }
+      };
+    }
+  }
+  /**
+   * Mount Stripe embedded checkout element to the DOM
+   * @param clientSecret - The client secret from the checkout session
+   * @param elementId - The ID of the DOM element to mount to
+   */
+  async mountCheckoutElement(clientSecret, elementId) {
+    if (!this.stripe) {
+      throw new Error("Stripe not initialized");
+    }
+    try {
+      if (this.checkoutElement) {
+        logger.info("[BillingService] Unmounting existing checkout element");
+        this.unmountCheckoutElement();
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      const container = document.getElementById(elementId);
+      if (!container) {
+        throw new Error(`Element with id "${elementId}" not found in the DOM`);
+      }
+      container.innerHTML = "";
+      logger.info("[BillingService] Creating new checkout instance");
+      this.checkoutElement = await this.stripe.initEmbeddedCheckout({
+        clientSecret
+      });
+      logger.info("[BillingService] Mounting checkout element to DOM");
+      this.checkoutElement.mount(`#${elementId}`);
+      this.setupCheckoutEventListeners();
+    } catch (error) {
+      logger.error("[BillingService] Failed to mount checkout:", error?.message);
+      throw error;
+    }
+  }
+  /**
+   * Set up event listeners for checkout completion
+   */
+  setupCheckoutEventListeners() {
+    if (typeof window !== "undefined") {
+      const urlParams = new URLSearchParams(window.location.search);
+      const paymentStatus = urlParams.get("payment");
+      if (paymentStatus === "complete") {
+        const sessionId = urlParams.get("session_id");
+        if (this.onPurchaseCompleteCallback) {
+          this.onPurchaseCompleteCallback({
+            success: true,
+            productId: "",
+            // Would need to be tracked separately
+            transactionId: sessionId || void 0
+          });
+        }
+        logger.info("[BillingService] Payment completed");
+        urlParams.delete("payment");
+        urlParams.delete("session_id");
+        const newUrl = `${window.location.pathname}${urlParams.toString() ? "?" + urlParams.toString() : ""}`;
+        window.history.replaceState({}, "", newUrl);
+      }
+    }
+  }
+  /**
+   * Unmount and destroy the checkout element
+   */
+  unmountCheckoutElement() {
+    if (this.checkoutElement) {
+      try {
+        this.checkoutElement.unmount();
+        if (typeof this.checkoutElement.destroy === "function") {
+          this.checkoutElement.destroy();
+        }
+      } catch (error) {
+        logger.warn("[BillingService] Error unmounting checkout element:", error?.message);
+      }
+      this.checkoutElement = null;
+    }
+  }
+  /**
+   * Set callback for successful purchases
+   */
+  onPurchaseComplete(callback) {
+    this.onPurchaseCompleteCallback = callback;
+  }
+  /**
+   * Set callback for failed purchases
+   */
+  onPurchaseError(callback) {
+    this.onPurchaseErrorCallback = callback;
+  }
+  /**
+   * Clean up resources
+   */
+  dispose() {
+    if (this.platform === "native" /* NATIVE */) {
+      NativeBridge.off("IAP_AVAILABILITY_RESULT" /* IAP_AVAILABILITY_RESULT */);
+      NativeBridge.off("PRODUCTS_RESULT" /* PRODUCTS_RESULT */);
+      NativeBridge.off("PURCHASE_COMPLETE" /* PURCHASE_COMPLETE */);
+      NativeBridge.off("PURCHASE_ERROR" /* PURCHASE_ERROR */);
+    }
+    this.unmountCheckoutElement();
+    this.initPromise = null;
+    this.nativeAvailable = false;
+    this.stripe = null;
+    this.onPurchaseCompleteCallback = void 0;
+    this.onPurchaseErrorCallback = void 0;
+  }
+};
+
+// src/services/storage.ts
+var CloudStorageAdapter = class {
+  constructor(callApi) {
+    this.callApi = callApi;
+  }
+  async saveGameData(gameId, key, value) {
+    return this.callApi("/api/v1/persistent-game-data", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ game_id: gameId, key, value })
+    });
+  }
+  async batchSaveGameData(gameId, items) {
+    return this.callApi(
+      "/api/v1/persistent-game-data/batch",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ game_id: gameId, items })
+      }
+    );
+  }
+  async getGameData(gameId, key) {
+    try {
+      const params = new URLSearchParams({ game_id: gameId, key });
+      const response = await this.callApi(
+        `/api/v1/persistent-game-data?${params}`
+      );
+      return response.data;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("404")) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async getMultipleGameData(gameId, keys) {
+    const params = new URLSearchParams({ game_id: gameId });
+    keys.forEach((key) => params.append("keys", key));
+    const response = await this.callApi(
+      `/api/v1/persistent-game-data?${params}`
+    );
+    return response.data;
+  }
+  async deleteGameData(gameId, key) {
+    try {
+      const params = new URLSearchParams({ game_id: gameId, key });
+      const response = await this.callApi(
+        `/api/v1/persistent-game-data?${params}`,
+        { method: "DELETE" }
+      );
+      return response.success && response.deleted_count > 0;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("404")) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async deleteMultipleGameData(gameId, keys) {
+    const params = new URLSearchParams({ game_id: gameId });
+    keys.forEach((key) => params.append("keys", key));
+    const response = await this.callApi(
+      `/api/v1/persistent-game-data?${params}`,
+      { method: "DELETE" }
+    );
+    return response.deleted_count;
+  }
+};
+var LocalStorageAdapter = class {
+  constructor(getUserId) {
+    this.getUserId = getUserId;
+  }
+  storagePrefix = "hyve_game_data";
+  getStorageKey(gameId, key) {
+    return `${this.storagePrefix}:${gameId}:${key}`;
+  }
+  async saveGameData(gameId, key, value) {
+    try {
+      const storageKey = this.getStorageKey(gameId, key);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const existing = localStorage.getItem(storageKey);
+      const createdAt = existing ? JSON.parse(existing).created_at || now : now;
+      const item = { key, value, created_at: createdAt, updated_at: now };
+      localStorage.setItem(storageKey, JSON.stringify(item));
+      return { success: true, message: "Data saved successfully" };
+    } catch (error) {
+      throw new Error(`Failed to save: ${error instanceof Error ? error.message : "Unknown"}`);
+    }
+  }
+  async batchSaveGameData(gameId, items) {
+    for (const item of items) {
+      await this.saveGameData(gameId, item.key, item.value);
+    }
+    return { success: true, message: `${items.length} items saved` };
+  }
+  async getGameData(gameId, key) {
+    const data = localStorage.getItem(this.getStorageKey(gameId, key));
+    return data ? JSON.parse(data) : null;
+  }
+  async getMultipleGameData(gameId, keys) {
+    const items = [];
+    for (const key of keys) {
+      const item = await this.getGameData(gameId, key);
+      if (item) items.push(item);
+    }
+    return items;
+  }
+  async deleteGameData(gameId, key) {
+    const storageKey = this.getStorageKey(gameId, key);
+    const exists = localStorage.getItem(storageKey) !== null;
+    if (exists) localStorage.removeItem(storageKey);
+    return exists;
+  }
+  async deleteMultipleGameData(gameId, keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (await this.deleteGameData(gameId, key)) count++;
+    }
+    return count;
+  }
+};
+
+// src/core/client.ts
+function determineEnvironmentFromParentUrl() {
+  try {
+    let parentUrl = "";
+    if (window !== window.top) {
+      try {
+        parentUrl = window.parent.location.href;
+      } catch (e) {
+        parentUrl = document.referrer;
+      }
+    } else {
+      parentUrl = window.location.href;
+    }
+    logger.debug("Detected parent URL:", parentUrl);
+    if (parentUrl.includes("marvin.dev.hyve.gg") || parentUrl.includes("dev.hyve.gg")) {
+      logger.info("Environment detected: dev (from parent URL)");
+      return true;
+    }
+    if (parentUrl.includes("marvin.hyve.gg") || parentUrl.includes("hyve.gg")) {
+      logger.info("Environment detected: prod (from parent URL)");
+      return false;
+    }
+    logger.info("Environment unknown, defaulting to dev");
+    return true;
+  } catch (error) {
+    logger.warn("Failed to determine environment from parent URL:", error);
+    return true;
+  }
+}
+var HyveClient = class {
+  telemetryConfig;
+  apiBaseUrl;
+  sessionId;
+  userId = null;
+  jwtToken = null;
+  gameId = null;
+  adsService;
+  playgamaService = null;
+  playgamaInitPromise = null;
+  crazyGamesService = null;
+  crazyGamesInitPromise = null;
+  billingService;
+  storageMode;
+  cloudStorageAdapter;
+  localStorageAdapter;
+  /**
+   * Creates a new HyveClient instance
+   * @param config Optional configuration including telemetry and ads
+   */
+  constructor(config) {
+    const isDev = config?.isDev !== void 0 ? config.isDev : determineEnvironmentFromParentUrl();
+    this.telemetryConfig = {
+      isDev,
+      ...config
+    };
+    if (this.telemetryConfig.apiBaseUrl) {
+      this.apiBaseUrl = this.telemetryConfig.apiBaseUrl;
+    } else {
+      this.apiBaseUrl = this.telemetryConfig.isDev ? "https://product-api.dev.hyve.gg" : "https://product-api.prod.hyve.gg";
+    }
+    this.sessionId = generateUUID();
+    this.adsService = new AdsService();
+    if (config?.ads) {
+      this.adsService.configure(config.ads);
+    }
+    if (typeof window !== "undefined" && PlaygamaService.isPlaygamaDomain()) {
+      this.playgamaService = new PlaygamaService();
+      this.playgamaInitPromise = this.playgamaService.initialize().then((success) => {
+        logger.info("Playgama Bridge initialized:", success);
+        return success;
+      });
+    }
+    if (typeof window !== "undefined" && CrazyGamesService.isCrazyGamesDomain()) {
+      this.crazyGamesService = new CrazyGamesService();
+      this.crazyGamesInitPromise = this.crazyGamesService.initialize().then((success) => {
+        logger.info("CrazyGames SDK initialized:", success);
+        return success;
+      });
+    }
+    this.storageMode = config?.storageMode || "cloud";
+    this.cloudStorageAdapter = new CloudStorageAdapter(
+      (endpoint, options) => this.callApi(endpoint, options)
+    );
+    this.localStorageAdapter = new LocalStorageAdapter(() => this.getUserId());
+    if (typeof window !== "undefined") {
+      this._parseUrlAuth();
+    }
+    const billingConfig = {
+      checkoutUrl: this.apiBaseUrl,
+      userId: this.userId ?? void 0,
+      gameId: this.gameId ? Number(this.gameId) : void 0,
+      ...config?.billing
+    };
+    this.billingService = new BillingService(billingConfig);
+    const envSource = config?.isDev !== void 0 ? "explicit config" : "auto-detected from parent URL";
+    logger.info("==========================================");
+    logger.info("HyveClient Initialized");
+    logger.info("==========================================");
+    logger.info("Session ID:", this.sessionId);
+    logger.info(
+      "Environment:",
+      this.telemetryConfig.isDev ? "DEVELOPMENT" : "PRODUCTION",
+      `(${envSource})`
+    );
+    logger.info("API Base URL:", this.apiBaseUrl);
+    logger.info("Playgama platform:", this.playgamaService !== null);
+    logger.info("CrazyGames platform:", this.crazyGamesService !== null);
+    logger.info(
+      "Billing configured:",
+      !!config?.billing && Object.keys(config.billing).length > 0
+    );
+    logger.info("Storage mode:", this.storageMode);
+    logger.info("Authenticated:", this.jwtToken !== null);
+    logger.debug("Config:", {
+      isDev: this.telemetryConfig.isDev,
+      hasCustomApiUrl: !!config?.apiBaseUrl,
+      billingConfigured: !!config?.billing && Object.keys(config.billing).length > 0,
+      storageMode: this.storageMode
+    });
+    logger.info("==========================================");
+  }
+  /**
+   * Parses JWT and game ID from the current window URL and stores them on the client.
+   * Called automatically during construction.
+   */
+  _parseUrlAuth(urlParams) {
+    try {
+      const params = urlParams ? parseUrlParams(urlParams) : parseUrlParams(window.location.search);
+      if (params.hyveAccess) {
+        this.jwtToken = params.hyveAccess;
+        logger.info("JWT token extracted from hyve-access parameter");
+        const userId = extractUserIdFromJwt(this.jwtToken);
+        if (userId) {
+          this.userId = userId;
+          logger.info("User ID extracted from JWT:", userId);
+        }
+        if (!this.gameId) {
+          const gameIdFromJwt = extractGameIdFromJwt(this.jwtToken);
+          if (gameIdFromJwt !== null) {
+            this.gameId = gameIdFromJwt.toString();
+            logger.info("Game ID extracted from JWT:", gameIdFromJwt);
+          }
+        }
+      }
+      if (params.gameId) {
+        this.gameId = params.gameId;
+        logger.info("Game ID extracted from game-id parameter:", this.gameId);
+      }
+      if (this.jwtToken) {
+        logger.info("Authentication successful via JWT");
+      } else {
+        logger.info("No hyve-access JWT token in URL \u2014 unauthenticated");
+      }
+    } catch (error) {
+      logger.error("Error parsing URL auth:", error);
+    }
+  }
+  /**
+   * Sends a user-level telemetry event using JWT authentication
+   * Requires JWT token, authenticated user, and game ID from URL parameters
+   * @param eventLocation Location where the event occurred
+   * @param eventCategory Main category of the event
+   * @param eventAction Primary action taken
+   * @param eventSubCategory Optional sub-category
+   * @param eventSubAction Optional sub-action
+   * @param eventDetails Optional event details (object or JSON string)
+   * @param platformId Optional platform identifier
+   * @returns Promise resolving to boolean indicating success
+   */
+  async sendTelemetry(eventLocation, eventCategory, eventAction, eventSubCategory, eventSubAction, eventDetails, platformId) {
+    if (!this.jwtToken) {
+      logger.error("JWT token required. Ensure hyve-access and game-id are present in the URL.");
+      return false;
+    }
+    if (!this.gameId) {
+      logger.error("Game ID required. Ensure game-id URL parameter is set.");
+      return false;
+    }
+    try {
+      if (eventDetails) {
+        try {
+          if (typeof eventDetails === "string") {
+            JSON.parse(eventDetails);
+          } else if (typeof eventDetails === "object") {
+            JSON.stringify(eventDetails);
+          }
+        } catch (validationError) {
+          logger.error("Invalid JSON in eventDetails:", validationError);
+          logger.error("eventDetails value:", eventDetails);
+          return false;
+        }
+      }
+      const toJsonString = (data) => {
+        if (!data) return null;
+        return typeof data === "string" ? data : JSON.stringify(data);
+      };
+      const telemetryEvent = {
+        game_id: this.gameId,
+        session_id: this.sessionId,
+        platform_id: platformId || null,
+        event_location: eventLocation,
+        event_category: eventCategory,
+        event_action: eventAction,
+        event_sub_category: eventSubCategory || null,
+        event_sub_action: eventSubAction || null,
+        event_details: toJsonString(eventDetails)
+      };
+      logger.debug("Sending telemetry event:", telemetryEvent);
+      const telemetryUrl = `${this.apiBaseUrl}/api/v1/analytics/send`;
+      const response = await fetch(telemetryUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.jwtToken}`
+        },
+        body: JSON.stringify(telemetryEvent)
+      });
+      if (response.ok) {
+        logger.info("Telemetry event sent successfully:", response.status);
+        return true;
+      } else {
+        const errorText = await response.text();
+        logger.error(
+          "Failed to send telemetry event:",
+          response.status,
+          errorText
+        );
+        return false;
+      }
+    } catch (error) {
+      logger.error("Error sending telemetry event:", error);
+      return false;
+    }
+  }
+  /**
+   * Makes an authenticated API call using the JWT token
+   * @param endpoint API endpoint path (will be appended to base URL)
+   * @param options Fetch options (method, body, etc.)
+   * @returns Promise resolving to the API response
+   */
+  async callApi(endpoint, options = {}) {
+    if (!this.jwtToken) {
+      throw new Error(
+        "No JWT token available. Ensure hyve-access and game-id are present in the URL."
+      );
+    }
+    try {
+      const url = `${this.apiBaseUrl}${endpoint.startsWith("/") ? endpoint : `/${endpoint}`}`;
+      logger.debug("Making API call to:", url);
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.jwtToken}`,
+          ...options.headers
+        }
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`API request failed: ${response.status} ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      logger.error("API call failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Gets the user's inventory
+   * @returns Promise resolving to the user's inventory
+   */
+  async getInventory() {
+    return this.callApi("/api/v1/inventory");
+  }
+  /**
+   * Gets a specific inventory item by ID
+   * @param itemId The inventory item ID
+   * @returns Promise resolving to the inventory item details
+   */
+  async getInventoryItem(itemId) {
+    return this.callApi(`/api/v1/inventory/${itemId}`);
+  }
+  /**
+   * Updates the telemetry configuration
+   * @param config New telemetry configuration
+   */
+  updateTelemetryConfig(config) {
+    this.telemetryConfig = {
+      ...this.telemetryConfig,
+      ...config
+    };
+    if (config.apiBaseUrl !== void 0) {
+      this.apiBaseUrl = config.apiBaseUrl;
+    } else if (config.isDev !== void 0) {
+      this.apiBaseUrl = config.isDev ? "https://product-api.dev.hyve.gg" : "https://product-api.prod.hyve.gg";
+    }
+    logger.info("Config updated");
+    logger.info("API Base URL:", this.apiBaseUrl);
+  }
+  /**
+   * Gets the current user ID
+   * @returns Current user ID or null if not authenticated
+   */
+  getUserId() {
+    return this.userId;
+  }
+  /**
+   * Gets the current session ID
+   * @returns Current session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Gets the current JWT token
+   * @returns Current JWT token or null if not available
+   */
+  getJwtToken() {
+    return this.jwtToken;
+  }
+  /**
+   * Gets the current game ID
+   * @returns Current game ID or null if not available
+   */
+  getGameId() {
+    return this.gameId;
+  }
+  /**
+   * Gets the API base URL
+   * @returns API base URL
+   */
+  getApiBaseUrl() {
+    return this.apiBaseUrl;
+  }
+  /**
+   * Checks if user is authenticated
+   * @returns Boolean indicating authentication status
+   */
+  isUserAuthenticated() {
+    return this.userId !== null;
+  }
+  /**
+   * Checks if JWT token is available
+   * @returns Boolean indicating if JWT token is present
+   */
+  hasJwtToken() {
+    return this.jwtToken !== null;
+  }
+  /**
+   * Logs out the current user
+   */
+  logout() {
+    this.userId = null;
+    this.jwtToken = null;
+    this.gameId = null;
+    logger.info("User logged out");
+  }
+  /**
+   * Resets the client state
+   */
+  reset() {
+    this.logout();
+    this.sessionId = generateUUID();
+    logger.info("Client reset with new sessionId:", this.sessionId);
+  }
+  /**
+   * Get the storage adapter based on mode
+   * @param mode Storage mode override (cloud or local)
+   */
+  getStorageAdapter(mode) {
+    const storageMode = mode || this.storageMode;
+    return storageMode === "local" ? this.localStorageAdapter : this.cloudStorageAdapter;
+  }
+  /**
+   * Returns the current game ID or throws if not available.
+   */
+  requireGameId() {
+    const gameId = this.requireGameId();
+    return gameId;
+  }
+  /**
+   * Save persistent game data
+   * @param key Data key
+   * @param value Data value (any JSON-serializable value)
+   * @param storage Storage mode override ('cloud' or 'local')
+   * @returns Promise resolving to save response
+   */
+  async saveGameData(key, value, storage) {
+    const gameId = this.requireGameId();
+    const storageMode = storage || this.storageMode;
+    logger.debug(`Saving game data to ${storageMode}: ${gameId}/${key}`);
+    const adapter = this.getStorageAdapter(storage);
+    const response = await adapter.saveGameData(gameId, key, value);
+    logger.info(`Game data saved successfully to ${storageMode}: ${gameId}/${key}`);
+    return response;
+  }
+  /**
+   * Batch save persistent game data
+   * @param items Array of key-value pairs to save
+   * @param storage Storage mode override ('cloud' or 'local')
+   * @returns Promise resolving to save response
+   */
+  async batchSaveGameData(items, storage) {
+    const gameId = this.requireGameId();
+    const storageMode = storage || this.storageMode;
+    logger.debug(`Batch saving ${items.length} game data entries to ${storageMode} for game: ${gameId}`);
+    const adapter = this.getStorageAdapter(storage);
+    const response = await adapter.batchSaveGameData(gameId, items);
+    logger.info(`Batch saved ${items.length} game data entries successfully to ${storageMode}`);
+    return response;
+  }
+  /**
+   * Get persistent game data
+   * @param key Data key
+   * @param storage Storage mode override ('cloud' or 'local')
+   * @returns Promise resolving to game data item or null if not found
+   */
+  async getGameData(key, storage) {
+    const gameId = this.requireGameId();
+    const storageMode = storage || this.storageMode;
+    logger.debug(`Getting game data from ${storageMode}: ${gameId}/${key}`);
+    const adapter = this.getStorageAdapter(storage);
+    const data = await adapter.getGameData(gameId, key);
+    if (data) {
+      logger.info(`Game data retrieved successfully from ${storageMode}: ${gameId}/${key}`);
+    } else {
+      logger.debug(`Game data not found in ${storageMode}: ${key}`);
+    }
+    return data;
+  }
+  /**
+   * Get multiple persistent game data entries
+   * @param keys Array of data keys
+   * @param storage Storage mode override ('cloud' or 'local')
+   * @returns Promise resolving to array of game data items
+   */
+  async getMultipleGameData(keys, storage) {
+    const gameId = this.requireGameId();
+    const storageMode = storage || this.storageMode;
+    logger.debug(`Getting ${keys.length} game data entries from ${storageMode} for game: ${gameId}`);
+    const adapter = this.getStorageAdapter(storage);
+    const data = await adapter.getMultipleGameData(gameId, keys);
+    logger.info(`Retrieved ${data.length} game data entries from ${storageMode}`);
+    return data;
+  }
+  /**
+   * Delete persistent game data
+   * @param key Data key
+   * @param storage Storage mode override ('cloud' or 'local')
+   * @returns Promise resolving to boolean indicating if data was deleted
+   */
+  async deleteGameData(key, storage) {
+    const gameId = this.requireGameId();
+    const storageMode = storage || this.storageMode;
+    logger.debug(`Deleting game data from ${storageMode}: ${gameId}/${key}`);
+    const adapter = this.getStorageAdapter(storage);
+    const deleted = await adapter.deleteGameData(gameId, key);
+    if (deleted) {
+      logger.info(`Game data deleted successfully from ${storageMode}: ${gameId}/${key}`);
+    } else {
+      logger.debug(`Game data not found in ${storageMode}: ${key}`);
+    }
+    return deleted;
+  }
+  /**
+   * Delete multiple persistent game data entries
+   * @param keys Array of data keys
+   * @param storage Storage mode override ('cloud' or 'local')
+   * @returns Promise resolving to number of entries deleted
+   */
+  async deleteMultipleGameData(keys, storage) {
+    const gameId = this.requireGameId();
+    const storageMode = storage || this.storageMode;
+    logger.debug(`Deleting ${keys.length} game data entries from ${storageMode} for game: ${gameId}`);
+    const adapter = this.getStorageAdapter(storage);
+    const deletedCount = await adapter.deleteMultipleGameData(gameId, keys);
+    logger.info(`Deleted ${deletedCount} game data entries from ${storageMode}`);
+    return deletedCount;
+  }
+  /**
+   * Configure storage mode
+   * @param mode Storage mode ('cloud' or 'local')
+   */
+  configureStorage(mode) {
+    this.storageMode = mode;
+    logger.info("Storage mode updated to:", mode);
+  }
+  /**
+   * Get current storage mode
+   * @returns Current storage mode
+   */
+  getStorageMode() {
+    return this.storageMode;
+  }
+  /**
+   * Configure ads service
+   * @param config Ads configuration
+   */
+  configureAds(config) {
+    this.adsService.configure(config);
+    logger.info("Ads configuration updated");
+  }
+  /**
+   * Show an ad
+   * @param type Type of ad to show ('rewarded', 'interstitial', or 'preroll')
+   * @returns Promise resolving to ad result
+   */
+  async showAd(type) {
+    if (this.crazyGamesService) {
+      if (this.crazyGamesInitPromise) {
+        await this.crazyGamesInitPromise;
+      }
+      if (this.crazyGamesService.isInitialized()) {
+        const { onBeforeAd, onAfterAd, onRewardEarned } = this.adsService.getCallbacks();
+        if (type === "rewarded") {
+          return this.crazyGamesService.showRewarded({
+            onBeforeAd: () => onBeforeAd("rewarded"),
+            onAfterAd: () => onAfterAd("rewarded"),
+            onRewardEarned
+          });
+        }
+        return this.crazyGamesService.showInterstitial({
+          onBeforeAd: () => onBeforeAd(type),
+          onAfterAd: () => onAfterAd(type)
+        });
+      }
+    }
+    if (this.playgamaService) {
+      if (this.playgamaInitPromise) {
+        await this.playgamaInitPromise;
+      }
+      if (this.playgamaService.isInitialized()) {
+        const { onBeforeAd, onAfterAd, onRewardEarned } = this.adsService.getCallbacks();
+        if (type === "rewarded") {
+          return this.playgamaService.showRewarded({
+            onBeforeAd: () => onBeforeAd("rewarded"),
+            onAfterAd: () => onAfterAd("rewarded"),
+            onRewardEarned
+          });
+        }
+        return this.playgamaService.showInterstitial({
+          onBeforeAd: () => onBeforeAd(type),
+          onAfterAd: () => onAfterAd(type)
+        });
+      }
+    }
+    return this.adsService.show(type);
+  }
+  /**
+   * Notifies CrazyGames that gameplay has started.
+   * No-op on other platforms.
+   */
+  async gameplayStart() {
+    if (this.crazyGamesService) {
+      if (this.crazyGamesInitPromise) await this.crazyGamesInitPromise;
+      this.crazyGamesService.gameplayStart();
+    }
+  }
+  /**
+   * Notifies CrazyGames that gameplay has stopped.
+   * No-op on other platforms.
+   */
+  async gameplayStop() {
+    if (this.crazyGamesService) {
+      if (this.crazyGamesInitPromise) await this.crazyGamesInitPromise;
+      this.crazyGamesService.gameplayStop();
+    }
+  }
+  /**
+   * Triggers a celebration effect on the CrazyGames website for significant achievements.
+   * No-op on other platforms.
+   */
+  async happytime() {
+    if (this.crazyGamesService) {
+      if (this.crazyGamesInitPromise) await this.crazyGamesInitPromise;
+      this.crazyGamesService.happytime();
+    }
+  }
+  /**
+   * Check if ads are ready to show
+   * @returns Boolean indicating if ads have initialized successfully
+   */
+  areAdsReady() {
+    return this.adsService.isReady();
+  }
+  /**
+   * Get the billing platform
+   * @returns Current billing platform
+   */
+  getBillingPlatform() {
+    return this.billingService.getPlatform();
+  }
+  /**
+   * Check if billing is available
+   * @returns Boolean indicating if billing is available
+   */
+  isBillingAvailable() {
+    return this.billingService.isAvailable();
+  }
+  /**
+   * Get available billing products
+   * @returns Promise resolving to array of products
+   */
+  async getBillingProducts() {
+    return await this.billingService.getProducts();
+  }
+  /**
+   * Purchase a product
+   * @param productId Product ID to purchase
+   * @param options Optional purchase options (e.g., elementId for web)
+   * @returns Promise resolving to purchase result
+   */
+  async purchaseProduct(productId, options) {
+    return await this.billingService.purchase(productId, options);
+  }
+  /**
+   * Set callback for successful purchases
+   * @param callback Function to call on purchase completion
+   */
+  onPurchaseComplete(callback) {
+    this.billingService.onPurchaseComplete(callback);
+  }
+  /**
+   * Set callback for failed purchases
+   * @param callback Function to call on purchase error
+   */
+  onPurchaseError(callback) {
+    this.billingService.onPurchaseError(callback);
+  }
+  /**
+   * Unmount Stripe checkout element
+   */
+  unmountBillingCheckout() {
+    this.billingService.unmountCheckoutElement();
+  }
+};
+
+// src/react.tsx
+import { jsx } from "react/jsx-runtime";
+var HyveSdkContext = createContext(null);
+function HyveSdkProvider({
+  client,
+  config,
+  children
+}) {
+  const instanceRef = useRef(null);
+  if (client) {
+    instanceRef.current = client;
+  } else if (!instanceRef.current) {
+    instanceRef.current = new HyveClient(config);
+  }
+  return /* @__PURE__ */ jsx(HyveSdkContext.Provider, { value: instanceRef.current, children });
+}
+function useHyveSdk() {
+  const client = useContext(HyveSdkContext);
+  if (!client) {
+    throw new Error("useHyveSdk must be used within a HyveSdkProvider");
+  }
+  return client;
+}
+export {
+  HyveSdkProvider,
+  useHyveSdk
+};