@series-inc/venus-sdk 2.4.1 → 3.0.0

package/dist/index.cjs

@@ -1,9 +1,243 @@
 'use strict';
 
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
+// src/rooms/RoomsApi.ts
+var init_RoomsApi = __esm({
+  "src/rooms/RoomsApi.ts"() {
+  }
+});
+
+// src/rooms/VenusRoom.ts
+exports.VenusRoom = void 0;
+var init_VenusRoom = __esm({
+  "src/rooms/VenusRoom.ts"() {
+    exports.VenusRoom = class {
+      constructor(roomData) {
+        __publicField(this, "id");
+        __publicField(this, "name");
+        __publicField(this, "players");
+        __publicField(this, "maxPlayers");
+        __publicField(this, "gameType");
+        __publicField(this, "appId");
+        __publicField(this, "type");
+        __publicField(this, "createdBy");
+        __publicField(this, "createdAt");
+        __publicField(this, "updatedAt");
+        __publicField(this, "isPrivate");
+        __publicField(this, "currentPlayers");
+        __publicField(this, "status");
+        __publicField(this, "customMetadata");
+        __publicField(this, "admins");
+        __publicField(this, "roomCode");
+        __publicField(this, "description");
+        __publicField(this, "data");
+        __publicField(this, "version");
+        __publicField(this, "_subscriptions", /* @__PURE__ */ new Map());
+        this.id = roomData.id;
+        this.name = roomData.name;
+        this.players = roomData.currentPlayers || [];
+        this.maxPlayers = roomData.maxPlayers;
+        this.gameType = roomData.gameType;
+        this.appId = roomData.appId;
+        this.type = roomData.type;
+        this.createdBy = roomData.createdBy;
+        this.createdAt = roomData.createdAt;
+        this.updatedAt = roomData.updatedAt;
+        this.isPrivate = roomData.isPrivate;
+        this.currentPlayers = roomData.currentPlayers || [];
+        this.status = roomData.status;
+        this.customMetadata = roomData.customMetadata || {};
+        this.admins = roomData.admins || [];
+        this.roomCode = roomData.roomCode;
+        this.description = roomData.description;
+        this.data = roomData.data || {};
+        this.version = roomData.version;
+        console.log(`VenusRoom: Created room object for ${this.id}`, {
+          hasCustomMetadata: !!this.customMetadata,
+          hasGameState: !!this.customMetadata?.rules?.gameState,
+          gamePhase: this.customMetadata?.rules?.gameState?.phase,
+          currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
+        });
+      }
+      updateFromRoomData(newRoomData) {
+        if (newRoomData.id === this.id) {
+          this.name = newRoomData.name || this.name;
+          this.players = newRoomData.currentPlayers || this.players;
+          this.maxPlayers = newRoomData.maxPlayers || this.maxPlayers;
+          this.gameType = newRoomData.gameType || this.gameType;
+          this.currentPlayers = newRoomData.currentPlayers || this.currentPlayers;
+          this.customMetadata = newRoomData.customMetadata || this.customMetadata;
+          this.data = newRoomData.data || this.data;
+          this.status = newRoomData.status || this.status;
+          this.updatedAt = newRoomData.updatedAt || this.updatedAt;
+          console.log(`VenusRoom: Updated room object ${this.id} with fresh data`, {
+            hasCustomMetadata: !!this.customMetadata,
+            hasGameState: !!this.customMetadata?.rules?.gameState,
+            gamePhase: this.customMetadata?.rules?.gameState?.phase,
+            currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rooms/index.ts
+var rooms_exports = {};
+__export(rooms_exports, {
+  VenusRoom: () => exports.VenusRoom,
+  initializeRoomsApi: () => initializeRoomsApi,
+  setupRoomNotifications: () => setupRoomNotifications
+});
+function bindMethod(target, targetKey, source, sourceKey) {
+  const key = sourceKey ?? targetKey;
+  const fn = source?.[key];
+  if (typeof fn === "function") {
+    target[targetKey] = fn.bind(source);
+    return true;
+  }
+  return false;
+}
+function setupRoomNotifications(transport, getSubscriptions) {
+  console.log("[Venus Rooms] Setting up room notification listeners");
+  return transport.onVenusMessage((message) => {
+    const subscriptions = getSubscriptions();
+    if (!subscriptions) {
+      return;
+    }
+    if (message.type === "H5_ROOM_DATA_UPDATED") {
+      const messageData = message.data;
+      const { roomId, roomData } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.data?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Room data updated for ${roomId}, notifying ${callbacks.length} callbacks`, roomData);
+      callbacks.forEach((callback) => {
+        try {
+          callback(roomData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in room data callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+    if (message.type === "H5_ROOM_MESSAGE_RECEIVED" || message.type === "H5_ROOM_MESSAGE_UPDATED" || message.type === "H5_ROOM_MESSAGE_DELETED") {
+      const messageData = message.data;
+      const { roomId } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.messages?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Room message event for ${roomId}, notifying ${callbacks.length} callbacks`);
+      callbacks.forEach((callback) => {
+        try {
+          callback(messageData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in room message callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+    if (message.type === "app:h5:proposedMoveValidationUpdated") {
+      const messageData = message.data;
+      const { roomId } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.gameEvents?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Proposed move validation updated for ${roomId}, notifying ${callbacks.length} callbacks`);
+      callbacks.forEach((callback) => {
+        try {
+          callback(messageData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in game event callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+  });
+}
+function initializeRoomsApi(venusApi, host) {
+  const roomsApi = host?.rooms;
+  if (!roomsApi) {
+    console.warn(
+      "[Venus SDK] Host did not provide a rooms implementation. Rooms API will be unavailable."
+    );
+    return;
+  }
+  const venus = venusApi;
+  const existingNamespace = venus.rooms || {};
+  const roomsNamespace = Object.assign({}, existingNamespace);
+  const namespaceBindings = [
+    ["create", "createRoom"],
+    ["joinOrCreate", "joinOrCreateRoom"],
+    ["joinByCode", "joinRoomByCode"],
+    ["list", "getUserRooms"],
+    ["subscribeToRoom", "subscribe"],
+    ["updateRoomData", "updateData"],
+    ["getRoomData", "getData"],
+    ["sendRoomMessage", "sendMessage"],
+    ["leaveRoom", "leave"],
+    ["startRoomGame", "startGame"],
+    ["proposeMove"],
+    ["validateMove"]
+  ];
+  namespaceBindings.forEach(([targetKey, sourceKey]) => {
+    bindMethod(roomsNamespace, targetKey, roomsApi, sourceKey);
+  });
+  venus.rooms = roomsNamespace;
+}
+var init_rooms = __esm({
+  "src/rooms/index.ts"() {
+    init_RoomsApi();
+    init_VenusRoom();
+  }
+});
+
 // src/VenusMessageId.ts
 var VenusMessageId = /* @__PURE__ */ ((VenusMessageId2) => {
   VenusMessageId2["H5_RESPONSE"] = "H5_RESPONSE";
@@ -54,7 +288,8 @@ var VenusMessageId = /* @__PURE__ */ ((VenusMessageId2) => {
   VenusMessageId2["TOGGLE_LIKE"] = "H5_TOGGLE_LIKE";
   VenusMessageId2["OPEN_COMMENTS"] = "H5_OPEN_COMMENTS";
   VenusMessageId2["TOGGLE_FOLLOW"] = "H5_TOGGLE_FOLLOW";
-  VenusMessageId2["SHARE_POST"] = "H5_SHARE_POST";
+  VenusMessageId2["SHARE_LINK"] = "H5_SHARE_LINK";
+  VenusMessageId2["CREATE_SHARE_QRCODE"] = "H5_CREATE_SHARE_QRCODE";
   VenusMessageId2["AI_CHAT_COMPLETION"] = "H5_AI_CHAT_COMPLETION";
   VenusMessageId2["AI_GET_AVAILABLE_MODELS"] = "H5_AI_GET_AVAILABLE_MODELS";
   VenusMessageId2["TRIGGER_HAPTIC"] = "H5_TRIGGER_HAPTIC";
@@ -66,13 +301,11 @@ var VenusMessageId = /* @__PURE__ */ ((VenusMessageId2) => {
   VenusMessageId2["IAP_WALLET_UPDATE"] = "IAP_WALLET_UPDATE";
   VenusMessageId2["READY"] = "READY";
   VenusMessageId2["INIT_SDK"] = "INITIALIZE_SDK";
-  VenusMessageId2["PLAY"] = "PLAY";
   VenusMessageId2["PAUSE"] = "PAUSE";
   VenusMessageId2["RESUME"] = "RESUME";
-  VenusMessageId2["SHOWN"] = "SHOWN";
-  VenusMessageId2["HIDDEN"] = "HIDDEN";
+  VenusMessageId2["AWAKE"] = "AWAKE";
+  VenusMessageId2["SLEEP"] = "SLEEP";
   VenusMessageId2["QUIT"] = "QUIT";
-  VenusMessageId2["CLEANUP"] = "CLEANUP";
   VenusMessageId2["GET_EXPERIMENT"] = "H5_GET_EXPERIMENT";
   VenusMessageId2["GET_FEATURE_FLAG"] = "H5_GET_FEATURE_FLAG";
   VenusMessageId2["GET_FEATURE_GATE"] = "H5_GET_FEATURE_GATE";
@@ -96,6 +329,11 @@ var VenusMessageId = /* @__PURE__ */ ((VenusMessageId2) => {
   VenusMessageId2["H5_SIMULATION_GET_AVAILABLE_ITEMS"] = "H5_SIMULATION_GET_AVAILABLE_ITEMS";
   VenusMessageId2["H5_SIMULATION_VALIDATE_ASSIGNMENT"] = "H5_SIMULATION_VALIDATE_ASSIGNMENT";
   VenusMessageId2["H5_SIMULATION_BATCH_OPERATIONS"] = "H5_SIMULATION_BATCH_OPERATIONS";
+  VenusMessageId2["H5_LEADERBOARD_START_RUN"] = "H5_LEADERBOARD_START_RUN";
+  VenusMessageId2["H5_LEADERBOARD_SUBMIT_SCORE"] = "H5_LEADERBOARD_SUBMIT_SCORE";
+  VenusMessageId2["H5_LEADERBOARD_GET"] = "H5_LEADERBOARD_GET";
+  VenusMessageId2["H5_LEADERBOARD_GET_HIGHLIGHT"] = "H5_LEADERBOARD_GET_HIGHLIGHT";
+  VenusMessageId2["H5_LEADERBOARD_GET_PLAYER_STATS"] = "H5_LEADERBOARD_GET_PLAYER_STATS";
   VenusMessageId2["H5_ROOM_CREATE"] = "H5_ROOM_CREATE";
   VenusMessageId2["H5_ROOM_JOIN"] = "H5_ROOM_JOIN";
   VenusMessageId2["H5_ROOM_JOIN_OR_CREATE"] = "H5_ROOM_JOIN_OR_CREATE";
@@ -119,6 +357,10 @@ var VenusMessageId = /* @__PURE__ */ ((VenusMessageId2) => {
   VenusMessageId2["H5_ROOM_ELIMINATE_PLAYER"] = "H5_ROOM_ELIMINATE_PLAYER";
   VenusMessageId2["H5_ROOM_PROMOTE_TO_SPECTATOR"] = "H5_ROOM_PROMOTE_TO_SPECTATOR";
   VenusMessageId2["H5_LOAD_EMBEDDED_ASSET"] = "H5_LOAD_EMBEDDED_ASSET";
+  VenusMessageId2["H5_SHOW_LOAD_SCREEN"] = "H5_SHOW_LOAD_SCREEN";
+  VenusMessageId2["H5_HIDE_LOAD_SCREEN"] = "H5_HIDE_LOAD_SCREEN";
+  VenusMessageId2["H5_SET_LOADER_TEXT"] = "H5_SET_LOADER_TEXT";
+  VenusMessageId2["H5_SET_LOADER_PROGRESS"] = "H5_SET_LOADER_PROGRESS";
   VenusMessageId2["H5_IAP_OPEN_STORE"] = "H5_IAP_OPEN_STORE";
   VenusMessageId2["H5_IAP_GET_CURRENCY_ICON"] = "H5_IAP_GET_CURRENCY_ICON";
   return VenusMessageId2;
@@ -130,23 +372,27 @@ var RpcAdsApi = class {
     __publicField(this, "rpcClient");
     this.rpcClient = rpcClient;
   }
-  async showInterstitialAd() {
+  async showInterstitialAd(options) {
     console.log(`[Venus SDK] [RpcAdsApi] showInterstitialAd`);
     const response = await this.rpcClient.call(
       "H5_SHOW_INTERSTITIAL_AD" /* SHOW_INTERSTITIAL_AD */,
-      {},
+      options || {},
       -1
     );
     return response.shown;
   }
   async isRewardedAdReadyAsync() {
-    return true;
+    console.log(`[Venus SDK] [RpcAdsApi] isRewardedAdReadyAsync`);
+    const response = await this.rpcClient.call(
+      "H5_IS_REWARDED_AD_READY" /* IS_REWARDED_AD_READY */
+    );
+    return response.ready;
   }
-  async showRewardedAdAsync() {
+  async showRewardedAdAsync(options) {
     console.log("[Venus SDK] [RpcAdsApi] showRewardedAdAsync");
     const result = await this.rpcClient.call(
       "H5_SHOW_REWARDED_AD" /* SHOW_REWARDED_AD */,
-      {},
+      options || {},
       -1
     );
     const resultAsString = JSON.stringify(result, null, 2);
@@ -181,14 +427,16 @@ var MockAdsApi = class {
     await createMockDelay(MOCK_DELAYS.short);
     return true;
   }
-  async showRewardedAdAsync() {
+  async showRewardedAdAsync(options) {
     this.log("[MockAdsApi] showRewardedAdAsync called");
-    await this.mockOverlay.showAdOverlay();
+    await this.mockOverlay.showAdOverlay(options);
     this.log("[MockAdsApi] Rewarded ad completed");
     return true;
   }
-  async showInterstitialAd() {
+  async showInterstitialAd(options) {
     this.log(`[MockAdsApi] showInterstitialAd`);
+    await this.mockOverlay.showAdOverlay(options);
+    this.log("[MockAdsApi] interstitial ad shown");
     return true;
   }
   log(message, ...args) {
@@ -1236,59 +1484,73 @@ function initializeIap(venusApiInstance, host) {
 // src/lifecycles/MockLifecycleApi.ts
 var MockLifecycleApi = class {
   constructor() {
-    __publicField(this, "playCallbacks", []);
-    __publicField(this, "pauseCallbacks", []);
-    __publicField(this, "resumeCallbacks", []);
-    __publicField(this, "quitCallbacks", []);
-    __publicField(this, "showCallbacks", []);
-    __publicField(this, "hideCallbacks", []);
-  }
-  onCleanup(callback) {
-  }
-  onShow(callback) {
-    this.showCallbacks.push(callback);
+    __publicField(this, "pauseCallbacks", /* @__PURE__ */ new Set());
+    __publicField(this, "resumeCallbacks", /* @__PURE__ */ new Set());
+    __publicField(this, "awakeCallbacks", /* @__PURE__ */ new Set());
+    __publicField(this, "sleepCallbacks", /* @__PURE__ */ new Set());
+    __publicField(this, "quitCallbacks", /* @__PURE__ */ new Set());
+  }
+  onSleep(callback) {
+    this.sleepCallbacks.add(callback);
+    return {
+      unsubscribe: () => {
+        this.sleepCallbacks.delete(callback);
+      }
+    };
   }
-  onHide(callback) {
-    this.hideCallbacks.push(callback);
+  onAwake(callback) {
+    this.awakeCallbacks.add(callback);
+    return {
+      unsubscribe: () => {
+        this.awakeCallbacks.delete(callback);
+      }
+    };
   }
   onPause(callback) {
-    this.pauseCallbacks.push(callback);
-  }
-  onPlay(callback) {
-    this.playCallbacks.push(callback);
-  }
-  onQuit(callback) {
-    this.quitCallbacks.push(callback);
+    this.pauseCallbacks.add(callback);
+    return {
+      unsubscribe: () => {
+        this.pauseCallbacks.delete(callback);
+      }
+    };
   }
   onResume(callback) {
-    this.resumeCallbacks.push(callback);
+    this.resumeCallbacks.add(callback);
+    return {
+      unsubscribe: () => {
+        this.resumeCallbacks.delete(callback);
+      }
+    };
   }
-  triggerOnPlayCallbacks(context) {
-    for (const callback of this.playCallbacks) {
-      callback(context);
-    }
+  onQuit(callback) {
+    this.quitCallbacks.add(callback);
+    return {
+      unsubscribe: () => {
+        this.quitCallbacks.delete(callback);
+      }
+    };
   }
-  triggerOnPauseCallbacks() {
+  triggerPauseCallbacks() {
     for (const callback of this.pauseCallbacks) {
       callback();
     }
   }
-  triggerOnResumeCallbacks() {
+  triggerResumeCallbacks() {
     for (const callback of this.resumeCallbacks) {
       callback();
     }
   }
-  triggerOnShowCallbacks(context) {
-    for (const callback of this.showCallbacks) {
-      callback(context);
+  triggerAwakeCallbacks() {
+    for (const callback of this.awakeCallbacks) {
+      callback();
     }
   }
-  triggerOnHideCallbacks() {
-    for (const callback of this.hideCallbacks) {
+  triggerSleepCallbacks() {
+    for (const callback of this.sleepCallbacks) {
       callback();
     }
   }
-  triggerOnQuitCallbacks() {
+  triggerQuitCallbacks() {
     for (const callback of this.quitCallbacks) {
       callback();
     }
@@ -1301,52 +1563,26 @@ var RpcLifecycleApi = class {
     __publicField(this, "rpcClient");
     this.rpcClient = rpcClient;
   }
-  onCleanup(callback) {
-    this.rpcClient.onNotification("CLEANUP" /* CLEANUP */, callback);
-  }
-  onHide(callback) {
-    this.rpcClient.onNotification("HIDDEN" /* HIDDEN */, callback);
-  }
-  onPause(callback) {
-    this.rpcClient.onNotification("PAUSE" /* PAUSE */, callback);
+  onQuit(callback) {
+    return this.rpcClient.onNotification("QUIT" /* QUIT */, callback);
   }
-  onPlay(callback) {
-    this.rpcClient.onNotification("PLAY" /* PLAY */, callback);
+  onSleep(callback) {
+    return this.rpcClient.onNotification("SLEEP" /* SLEEP */, callback);
   }
-  onQuit(callback) {
-    this.rpcClient.onNotification("QUIT" /* QUIT */, callback);
+  onAwake(callback) {
+    return this.rpcClient.onNotification("AWAKE" /* AWAKE */, callback);
   }
   onResume(callback) {
-    this.rpcClient.onNotification("RESUME" /* RESUME */, callback);
+    return this.rpcClient.onNotification("RESUME" /* RESUME */, callback);
   }
-  onShow(callback) {
-    this.rpcClient.onNotification("SHOWN" /* SHOWN */, callback);
+  onPause(callback) {
+    return this.rpcClient.onNotification("PAUSE" /* PAUSE */, callback);
   }
 };
 
 // src/lifecycles/index.ts
 function initializeLifecycleApi(venusApi, host) {
-  venusApi.onPlay = (callback) => {
-    host.lifecycle.onPlay(callback);
-  };
-  venusApi.onPause = (callback) => {
-    host.lifecycle.onPause(callback);
-  };
-  venusApi.onResume = (callback) => {
-    host.lifecycle.onResume(callback);
-  };
-  venusApi.onShow = (callback) => {
-    host.lifecycle.onShow(callback);
-  };
-  venusApi.onHide = (callback) => {
-    host.lifecycle.onHide(callback);
-  };
-  venusApi.onQuit = (callback) => {
-    host.lifecycle.onQuit(callback);
-  };
-  venusApi.onCleanup = (callback) => {
-    host.lifecycle.onCleanup(callback);
-  };
+  venusApi.lifecycles = host.lifecycle;
 }
 
 // src/logging/MockLoggingApi.ts
@@ -1553,7 +1789,7 @@ var MockNotificationsApi = class {
     __publicField(this, "venusApi");
     this.venusApi = venusApi;
   }
-  async cancelLocalNotification(notificationId) {
+  async cancelNotification(notificationId) {
     const venusApi = this.venusApi;
     if (isWebPlatform()) {
       console.log(
@@ -1594,7 +1830,8 @@ var MockNotificationsApi = class {
     const isEnabled = venusApi._mock.notificationsEnabled !== false;
     return isEnabled;
   }
-  async scheduleLocalNotification(title, body, options) {
+  async scheduleAsync(title, body, seconds, notificationId, options) {
+    const { priority = 50, groupId, payload } = options || {};
     if (isWebPlatform()) {
       console.log(
         "[Venus Mock] Notifications not supported on web platform, simulating success"
@@ -1609,7 +1846,7 @@ var MockNotificationsApi = class {
       const mockId = `mock-web-notification-${Date.now()}`;
       return mockId;
     }
-    console.log("[Venus Mock] Schedule local notification:", options);
+    console.log("[Venus Mock] Schedule local notification:", { title, body, seconds, options });
     const venusApi = this.venusApi;
     if (!venusApi._mock.pendingRequests) {
       console.log("[Venus Mock] Initializing pendingRequests");
@@ -1619,17 +1856,19 @@ var MockNotificationsApi = class {
     console.log("[Venus Mock] Creating request with ID:", requestId);
     return new Promise((resolve) => {
       venusApi._mock.pendingRequests[requestId] = { resolve };
-      const notificationId = `mock-notification-${Date.now()}`;
+      const id = notificationId || `mock-notification-${Date.now()}`;
       if (!venusApi._mock.scheduledNotifications) {
         venusApi._mock.scheduledNotifications = {};
       }
-      venusApi._mock.scheduledNotifications[notificationId] = {
-        ...options,
-        id: notificationId,
-        createdAt: Date.now()
+      venusApi._mock.scheduledNotifications[id] = {
+        id,
+        title,
+        body,
+        payload,
+        seconds
       };
       setTimeout(() => {
-        resolve(notificationId);
+        resolve(id);
       }, MOCK_DELAYS.short);
     });
   }
@@ -1649,36 +1888,78 @@ var MockNotificationsApi = class {
   }
 };
 
-// src/notifications/index.ts
-function initializeLocalNotifications(venusApi, host) {
-  venusApi.setLocalNotifEnabledAsync = async (enable) => {
-    await host.notifications.setLocalNotificationsEnabled(enable);
-  };
-  venusApi.isLocalNotifEnabledAsync = async () => {
-    return host.notifications.isLocalNotificationsEnabled();
-  };
-  venusApi.getAllLocalNotifsAsync = async () => {
-    return host.notifications.getAllScheduledLocalNotifications();
-  };
-  venusApi.cancelLocalNotifAsync = async (notificationId) => {
-    await host.notifications.cancelLocalNotification(notificationId);
-  };
-  venusApi.scheduleLocalNotifAsync = async (options) => {
-    const id = await host.notifications.scheduleLocalNotification(
-      options.title,
-      options.body,
+// src/notifications/RpcNotificationsApi.ts
+var RpcNotificationsApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async scheduleAsync(title, body, seconds, notificationId, options) {
+    const { priority = 50, groupId, payload } = options || {};
+    const request = {
+      title,
+      body,
+      priority,
+      key: groupId,
+      data: payload,
+      seconds,
+      notificationId
+    };
+    const response = await this.rpcClient.call(
+      "H5_SCHEDULE_LOCAL_NOTIFICATION" /* SCHEDULE_LOCAL_NOTIFICATION */,
+      request
+    );
+    if (response.scheduled) {
+      return response.id;
+    }
+    return null;
+  }
+  async cancelNotification(id) {
+    const result = await this.rpcClient.call(
+      "H5_CANCEL_LOCAL_NOTIFICATION" /* CANCEL_LOCAL_NOTIFICATION */,
       {
-        trigger: options.trigger,
-        priority: options.priority,
-        groupId: options.groupId,
-        payload: options.payload
+        id
       }
     );
-    if (id) {
-      return id;
-    }
-    return "";
-  };
+    return result.canceled;
+  }
+  async getAllScheduledLocalNotifications() {
+    const response = await this.rpcClient.call(
+      "H5_GET_ALL_SCHEDULED_LOCAL_NOTIFICATIONS" /* GET_ALL_SCHEDULED_LOCAL_NOTIFICATIONS */,
+      {}
+    );
+    const notifications = response.notifications.map((notif) => {
+      return {
+        id: notif.identifier,
+        title: notif.content.title,
+        body: notif.content.body,
+        payload: notif.content.data,
+        trigger: notif.trigger
+      };
+    });
+    return notifications;
+  }
+  async isLocalNotificationsEnabled() {
+    const response = await this.rpcClient.call(
+      "H5_IS_LOCAL_NOTIFICATIONS_ENABLED" /* IS_LOCAL_NOTIFICATIONS_ENABLED */,
+      {}
+    );
+    return response.enabled;
+  }
+  async setLocalNotificationsEnabled(enabled) {
+    const response = await this.rpcClient.call(
+      "H5_SET_LOCAL_NOTIFICATIONS_ENABLED" /* SET_LOCAL_NOTIFICATIONS_ENABLED */,
+      {
+        enabled
+      }
+    );
+    return response.enabled;
+  }
+};
+
+// src/notifications/index.ts
+function initializeLocalNotifications(venusApi, host) {
+  venusApi.notifications = host.notifications;
 }
 
 // src/popups/RpcPopupsApi.ts
@@ -1826,17 +2107,22 @@ function initializePopups(venusApi, host) {
 // src/profile/HostProfileApi.ts
 var HostProfileApi = class {
   getCurrentProfile() {
-    if (window.venus._config && window.venus._config.profile) {
-      return {
-        id: window.venus._config.profile.id || "unknown",
-        name: window.venus._config.profile.username || "Unknown User",
-        username: window.venus._config.profile.username || "unknown"
-      };
+    const profile = window.venus?.profile;
+    if (!profile) {
+      throw new Error(
+        "[Venus SDK] Host profile handshake did not complete. Await VenusAPI.initializeAsync() so INIT_SDK can deliver the profile before calling profile APIs."
+      );
+    }
+    if (!profile.id || !profile.username) {
+      throw new Error(
+        "[Venus SDK] INIT_SDK returned an incomplete profile (missing id/username). The host must supply real credentials before rooms APIs are used."
+      );
     }
     return {
-      id: "mock_profile_123",
-      name: "Mock User",
-      username: "mockuser"
+      id: profile.id,
+      username: profile.username,
+      avatarUrl: profile.avatarUrl,
+      isAnonymous: profile.isAnonymous
     };
   }
 };
@@ -1847,7 +2133,8 @@ var MockProfileApi = class {
     return {
       id: "mock_profile_123",
       name: "Mock User",
-      username: "mockuser"
+      username: "mockuser",
+      isAnonymous: false
     };
   }
 };
@@ -1962,6 +2249,9 @@ var RpcClient = class {
   }
 };
 
+// src/index.ts
+init_rooms();
+
 // src/storage/MockStorageApi.ts
 function createMockStorageApi(storageType, appUrl) {
   const appIdentifier = appUrl ? generateAppIdentifier(appUrl) : null;
@@ -3292,7 +3582,7 @@ function initializeTime(venusApi, host) {
 }
 
 // src/version.ts
-var SDK_VERSION = "2.4.1";
+var SDK_VERSION = "3.0.0";
 
 // src/shared-assets/consts.ts
 var BurgerTimeAssetsCdnPath = "burger-time/Core.stow";
@@ -3363,6 +3653,1657 @@ var MockSharedAssetsApi = class {
   }
 };
 
+// src/leaderboard/RpcLeaderboardApi.ts
+var RpcLeaderboardApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  startRun(mode) {
+    return this.rpcClient.call(
+      "H5_LEADERBOARD_START_RUN" /* H5_LEADERBOARD_START_RUN */,
+      mode ? { mode } : {}
+    );
+  }
+  submitScore(sessionId, score, durationSec, options) {
+    return this.rpcClient.call(
+      "H5_LEADERBOARD_SUBMIT_SCORE" /* H5_LEADERBOARD_SUBMIT_SCORE */,
+      {
+        sessionId,
+        score,
+        durationSec,
+        mode: options?.mode,
+        telemetry: options?.telemetry,
+        metadata: options?.metadata,
+        hash: options?.hash
+      }
+    );
+  }
+  getLeaderboard(options) {
+    return this.rpcClient.call(
+      "H5_LEADERBOARD_GET" /* H5_LEADERBOARD_GET */,
+      options ?? {}
+    );
+  }
+  getPlayerStats(options) {
+    return this.rpcClient.call(
+      "H5_LEADERBOARD_GET_PLAYER_STATS" /* H5_LEADERBOARD_GET_PLAYER_STATS */,
+      options ?? {}
+    );
+  }
+  getLeaderboardHighlight(options) {
+    return this.rpcClient.call(
+      "H5_LEADERBOARD_GET_HIGHLIGHT" /* H5_LEADERBOARD_GET_HIGHLIGHT */,
+      options ?? {}
+    );
+  }
+};
+
+// src/leaderboard/MockLeaderboardApi.ts
+var MockLeaderboardApi = class {
+  constructor(options) {
+    __publicField(this, "sessions", /* @__PURE__ */ new Map());
+    __publicField(this, "entriesByMode", /* @__PURE__ */ new Map());
+    __publicField(this, "sessionCounter", 0);
+    __publicField(this, "requiresHash", false);
+    if (options?.requiresHash) {
+      this.requiresHash = true;
+    }
+  }
+  configure(options) {
+    if (typeof options.requiresHash === "boolean") {
+      this.requiresHash = options.requiresHash;
+    }
+  }
+  generateNonce() {
+    return (Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2)).slice(0, 64);
+  }
+  getModeKey(mode) {
+    const normalizedMode = mode || "default";
+    return `${normalizedMode}`;
+  }
+  getEntriesForMode(mode) {
+    const key = this.getModeKey(mode);
+    if (!this.entriesByMode.has(key)) {
+      this.entriesByMode.set(key, []);
+    }
+    return this.entriesByMode.get(key);
+  }
+  async startRun(mode) {
+    const sessionId = `mock_session_${++this.sessionCounter}`;
+    const startTime = Date.now();
+    const expiresAt = startTime + 36e5;
+    const resolvedMode = mode || "default";
+    const hashNonce = this.requiresHash ? this.generateNonce() : null;
+    this.sessions.set(sessionId, {
+      id: sessionId,
+      expiresAt,
+      mode: resolvedMode,
+      hashNonce,
+      used: false
+    });
+    return {
+      sessionId,
+      startTime,
+      expiresAt,
+      hashNonce,
+      mode: resolvedMode
+    };
+  }
+  async submitScore(sessionId, score, durationSec, options) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error("Invalid leaderboard session");
+    }
+    if (session.expiresAt < Date.now()) {
+      throw new Error("Invalid or expired leaderboard session");
+    }
+    if (session.used) {
+      throw new Error("Leaderboard session already used");
+    }
+    if (options?.mode && options.mode !== session.mode) {
+      throw new Error("Submission mode does not match session mode");
+    }
+    if (session.hashNonce && !options?.hash) {
+      throw new Error("Score hash is required for sealed leaderboard submissions");
+    }
+    const submittedAt = Date.now();
+    const entry = {
+      profileId: `mock_profile`,
+      username: "Mock Player",
+      avatarUrl: null,
+      score,
+      durationSec,
+      submittedAt,
+      sessionId,
+      rank: null,
+      zScore: null,
+      isAnomaly: false,
+      trustScore: 50,
+      metadata: options?.metadata ?? null,
+      isSeed: false
+    };
+    const modeEntries = this.getEntriesForMode(session.mode);
+    modeEntries.push(entry);
+    modeEntries.sort((a, b) => {
+      if (b.score !== a.score) {
+        return b.score - a.score;
+      }
+      return a.submittedAt - b.submittedAt;
+    });
+    modeEntries.forEach((e, index) => {
+      modeEntries[index] = {
+        ...e,
+        rank: index + 1
+      };
+    });
+    session.used = true;
+    session.hashNonce = null;
+    const inserted = modeEntries.find((e) => e.sessionId === sessionId && e.submittedAt === submittedAt);
+    return {
+      accepted: true,
+      rank: inserted?.rank ?? null
+    };
+  }
+  async getLeaderboard(options) {
+    const limit = options?.limit ?? 10;
+    const mode = options?.mode ?? "default";
+    const modeEntries = [...this.getEntriesForMode(mode)];
+    const entries = modeEntries.slice(0, limit).map((entry) => ({
+      ...entry
+    }));
+    return {
+      variant: "standard",
+      entries,
+      totalEntries: modeEntries.length,
+      nextCursor: null,
+      playerRank: null,
+      periodInstance: options?.period ?? "alltime"
+    };
+  }
+  async getPlayerStats(_options) {
+    const mode = _options?.mode ?? "default";
+    const modeEntries = this.getEntriesForMode(mode);
+    const playerEntry = modeEntries[0] ?? null;
+    return {
+      rank: playerEntry?.rank ?? null,
+      score: playerEntry?.score,
+      totalPlayers: modeEntries.length,
+      percentile: playerEntry ? Math.max(0, 1 - ((playerEntry.rank ?? 1) - 1) / Math.max(modeEntries.length, 1)) : void 0,
+      trustScore: 50,
+      periodInstance: _options?.period ?? "alltime"
+    };
+  }
+  async getLeaderboardHighlight(options) {
+    const mode = options?.mode ?? "default";
+    const modeEntries = [...this.getEntriesForMode(mode)];
+    const topCount = Math.max(1, Math.min(options?.topCount ?? 3, 10));
+    const aheadCount = Math.max(0, Math.min(options?.contextAhead ?? 4, 10));
+    const behindCount = Math.max(0, Math.min(options?.contextBehind ?? 2, 10));
+    const topEntries = modeEntries.slice(0, topCount);
+    const playerEntry = modeEntries[0] ?? null;
+    const totalEntries = modeEntries.length;
+    let playerRank = playerEntry?.rank ?? null;
+    let beforePlayer = [];
+    let afterPlayer = [];
+    let totalBefore = playerRank ? playerRank - 1 : 0;
+    let totalAfter = playerRank ? Math.max(totalEntries - playerRank, 0) : 0;
+    let omittedBefore = totalBefore;
+    let omittedAfter = totalAfter;
+    if (playerRank && playerRank > 0) {
+      const beforeStart = Math.max(playerRank - aheadCount - 1, 0);
+      beforePlayer = modeEntries.slice(beforeStart, playerRank - 1);
+      const afterEnd = Math.min(playerRank + behindCount, totalEntries);
+      afterPlayer = modeEntries.slice(playerRank, afterEnd);
+      const shownTopAhead = topEntries.filter((entry) => (entry.rank ?? 0) > 0 && (entry.rank ?? 0) < playerRank).length;
+      omittedBefore = Math.max(totalBefore - (beforePlayer.length + shownTopAhead), 0);
+      omittedAfter = Math.max(totalAfter - afterPlayer.length, 0);
+    }
+    return {
+      variant: "highlight",
+      entries: topEntries,
+      totalEntries,
+      nextCursor: null,
+      playerRank: playerRank ?? null,
+      periodInstance: options?.period ?? "alltime",
+      context: {
+        topEntries,
+        beforePlayer,
+        playerEntry: playerEntry ?? null,
+        afterPlayer,
+        totalBefore,
+        totalAfter,
+        omittedBefore,
+        omittedAfter
+      }
+    };
+  }
+};
+
+// src/leaderboard/index.ts
+function initializeLeaderboard(venusApiInstance, host) {
+  venusApiInstance.leaderboard = host.leaderboard;
+}
+
+// src/game-preloader/MockPreloaderApi.ts
+var MockPreloaderApi = class {
+  async showLoadScreen() {
+    console.log("showLoadScreen");
+  }
+  async hideLoadScreen() {
+    console.log("hideLoadScreen");
+  }
+  async setLoaderText(text) {
+    console.log("setLoaderText", text);
+  }
+  async setLoaderProgress(progress) {
+    console.log("setLoaderProgress", progress);
+  }
+};
+
+// src/game-preloader/RpcPreloaderApi.ts
+var RpcPreloaderApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async showLoadScreen() {
+    await this.rpcClient.call("H5_SHOW_LOAD_SCREEN" /* H5_SHOW_LOAD_SCREEN */);
+  }
+  async hideLoadScreen() {
+    await this.rpcClient.call("H5_HIDE_LOAD_SCREEN" /* H5_HIDE_LOAD_SCREEN */);
+  }
+  async setLoaderText(text) {
+    await this.rpcClient.call("H5_SET_LOADER_TEXT" /* H5_SET_LOADER_TEXT */, { text });
+  }
+  async setLoaderProgress(progress) {
+    await this.rpcClient.call("H5_SET_LOADER_PROGRESS" /* H5_SET_LOADER_PROGRESS */, { progress });
+  }
+};
+
+// src/game-preloader/index.ts
+function initializePreloader(venusApi, host) {
+  venusApi.preloader = host.preloader;
+}
+
+// src/post/MockPostApi.ts
+var MockPostApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  async getPostInfo() {
+    const venusApi = this.venusApi;
+    await createMockDelay(MOCK_DELAYS.short);
+    return venusApi._mock.currentPostInteractions;
+  }
+  async openCommentsAsync() {
+    await createMockDelay(MOCK_DELAYS.short);
+    return {
+      opened: true,
+      commentsCount: 0
+    };
+  }
+  async toggleFollowAsync() {
+    const venusApi = this.venusApi;
+    console.log("[Venus Mock] *Toggling follow status");
+    await createMockDelay(MOCK_DELAYS.short);
+    venusApi._mock.currentPostInteractions.isFollowing = !venusApi._mock.currentPostInteractions.isFollowing;
+    const isFollowing = venusApi._mock.currentPostInteractions.isFollowing;
+    return {
+      isFollowing,
+      action: isFollowing ? "followed" : "unfollowed"
+    };
+  }
+  async toggleLikeAsync() {
+    const venusApi = this.venusApi;
+    await createMockDelay(MOCK_DELAYS.short);
+    venusApi._mock.currentPostInteractions.isLiked = !venusApi._mock.currentPostInteractions.isLiked;
+    const isLiked = venusApi._mock.currentPostInteractions.isLiked;
+    if (isLiked) {
+      venusApi._mock.currentPostInteractions.likesCount++;
+    } else {
+      venusApi._mock.currentPostInteractions.likesCount = Math.max(
+        0,
+        venusApi._mock.currentPostInteractions.likesCount - 1
+      );
+    }
+    return {
+      isLiked,
+      likesCount: venusApi._mock.currentPostInteractions.likesCount,
+      action: isLiked ? "liked" : "unliked"
+    };
+  }
+};
+
+// src/post/RpcPostApi.ts
+var RpcPostApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  getPostInfo() {
+    return this.rpcClient.call("H5_GET_POST_INTERACTIONS" /* GET_POST_INTERACTIONS */, {});
+  }
+  openCommentsAsync() {
+    return this.rpcClient.call("H5_OPEN_COMMENTS" /* OPEN_COMMENTS */, {});
+  }
+  toggleFollowAsync() {
+    return this.rpcClient.call(
+      "H5_TOGGLE_FOLLOW" /* TOGGLE_FOLLOW */,
+      {}
+    );
+  }
+  toggleLikeAsync() {
+    return this.rpcClient.call("H5_TOGGLE_LIKE" /* TOGGLE_LIKE */, {});
+  }
+};
+
+// src/MockHost.ts
+init_rooms();
+
+// src/social/MockSocialApi.ts
+var MOCK_QR_CODE = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+var MockSocialApi = class {
+  async shareLinkAsync(options) {
+    const shareUrl = this.createMockUrl(options.launchParams);
+    if (typeof navigator !== "undefined" && navigator.clipboard) {
+      try {
+        await navigator.clipboard.writeText(shareUrl);
+        console.log("[Venus SDK] (mock) Copied share URL to clipboard");
+      } catch (error) {
+        console.warn(
+          "[Venus SDK] (mock) Failed to copy share URL to clipboard",
+          error
+        );
+      }
+    }
+    return { shareUrl };
+  }
+  async createQRCodeAsync(options) {
+    const shareUrl = this.createMockUrl(options.launchParams);
+    return {
+      shareUrl,
+      qrCode: MOCK_QR_CODE
+    };
+  }
+  createMockUrl(launchParams) {
+    const params = new URLSearchParams(launchParams);
+    return `https://mock-share.venus.test/share?${params.toString()}`;
+  }
+};
+
+// src/MockHost.ts
+var ROOMS_UNAVAILABLE_MESSAGE = "[Venus SDK] Rooms API is only available when running inside the Venus host environment.";
+function createUnavailableRoomsApi() {
+  const roomsUnavailableError = () => new Error(ROOMS_UNAVAILABLE_MESSAGE);
+  return {
+    async createRoom() {
+      throw roomsUnavailableError();
+    },
+    async joinOrCreateRoom() {
+      throw roomsUnavailableError();
+    },
+    async getUserRooms() {
+      throw roomsUnavailableError();
+    },
+    async joinRoomByCode() {
+      throw roomsUnavailableError();
+    },
+    subscribe() {
+      throw roomsUnavailableError();
+    },
+    async updateData() {
+      throw roomsUnavailableError();
+    },
+    async getData() {
+      throw roomsUnavailableError();
+    },
+    async sendMessage() {
+      throw roomsUnavailableError();
+    },
+    async leave() {
+      throw roomsUnavailableError();
+    },
+    async startGame() {
+      throw roomsUnavailableError();
+    },
+    async proposeMove() {
+      throw roomsUnavailableError();
+    },
+    async validateMove() {
+      throw roomsUnavailableError();
+    }
+  };
+}
+var MockHost = class {
+  constructor(venusApi) {
+    __publicField(this, "ads");
+    __publicField(this, "analytics");
+    __publicField(this, "deviceCache");
+    __publicField(this, "appStorage");
+    __publicField(this, "globalStorage");
+    __publicField(this, "avatar3d");
+    __publicField(this, "navigation");
+    __publicField(this, "notifications");
+    __publicField(this, "popups");
+    __publicField(this, "profile");
+    __publicField(this, "cdn");
+    __publicField(this, "time");
+    __publicField(this, "post");
+    __publicField(this, "ai");
+    __publicField(this, "haptics");
+    __publicField(this, "features");
+    __publicField(this, "lifecycle");
+    __publicField(this, "simulation");
+    __publicField(this, "rooms");
+    __publicField(this, "logging");
+    __publicField(this, "iap");
+    __publicField(this, "leaderboard");
+    __publicField(this, "preloader");
+    __publicField(this, "social");
+    __publicField(this, "state", 0 /* PLAYING */);
+    __publicField(this, "venusApi");
+    __publicField(this, "_isInitialized", false);
+    __publicField(this, "_overlay");
+    __publicField(this, "_mockLifecyclesApi");
+    __publicField(this, "_mockAdsApi");
+    this.venusApi = venusApi;
+    this._overlay = this.createOverlay();
+    this._mockAdsApi = new MockAdsApi(this._overlay);
+    this._mockLifecyclesApi = new MockLifecycleApi();
+    this.ads = this._mockAdsApi;
+    this.analytics = new MockAnalyticsApi();
+    const appUrl = typeof window !== "undefined" ? window.location.href : "";
+    this.deviceCache = createMockStorageApi("deviceCache", appUrl);
+    this.appStorage = createMockStorageApi("appStorage", appUrl);
+    this.globalStorage = createMockStorageApi("globalStorage");
+    this.avatar3d = new MockAvatarApi(venusApi);
+    this.navigation = new MockNavigationApi(venusApi);
+    this.notifications = new MockNotificationsApi(venusApi);
+    this.popups = new MockPopupsApi(this._overlay);
+    this.profile = new MockProfileApi();
+    this.cdn = new MockCdnApi();
+    this.time = new MockTimeApi(venusApi);
+    this.post = new MockPostApi(venusApi);
+    this.ai = new MockAiApi();
+    this.haptics = new MockHapticsApi(venusApi);
+    this.features = new MockFeaturesApi();
+    this.lifecycle = this._mockLifecyclesApi;
+    this.simulation = new MockSimulationApi();
+    this.rooms = createUnavailableRoomsApi();
+    this.logging = new MockLoggingApi();
+    this.iap = new MockIapApi();
+    this.social = new MockSocialApi();
+    this.leaderboard = new MockLeaderboardApi();
+    initializeRoomsApi(this.venusApi, this);
+    this.preloader = new MockPreloaderApi();
+    venusApi.isMock = () => true;
+    this.venusApi.sharedAssets = new MockSharedAssetsApi(this.venusApi);
+  }
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  initialize(options) {
+    this._isInitialized = true;
+    return Promise.resolve({
+      initializeAsleep: false
+    });
+  }
+  updateUiControls() {
+    const controls = {
+      closeButton: { x: 16, y: 16, width: 32, height: 32 },
+      menuButton: {
+        x: window.innerWidth - 48,
+        y: 16,
+        width: 32,
+        height: 32
+      },
+      feedHeader: { x: 0, y: 0, width: window.innerWidth, height: 56 },
+      playButton: {
+        x: 0,
+        y: window.innerHeight - 60,
+        width: window.innerWidth,
+        height: 60
+      }
+    };
+    return controls;
+  }
+  createOverlay() {
+    const venusApi = this.venusApi;
+    venusApi.config.ui.controls = this.updateUiControls();
+    const uiControls = venusApi.config.ui.controls;
+    const overlayContainer = document.createElement("div");
+    overlayContainer.id = "venus-mock-overlay";
+    overlayContainer.style.cssText = `
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      pointer-events: none;
+      z-index: 10000;
+    `;
+    document.body.appendChild(overlayContainer);
+    const menuButton = this.createOverlayButton(
+      "close",
+      "Menu",
+      uiControls.menuButton,
+      () => {
+        this.handleMenuButtonClicked();
+      },
+      "rgba(59, 130, 246, 0.7)",
+      // Blue background instead of black
+      "#FFFFFF"
+    );
+    overlayContainer.appendChild(menuButton);
+    const adOverlay = this.setupAdOverlay();
+    const actionSheet = this.setupActionSheetOverlay();
+    window.addEventListener("resize", () => {
+      this.updateOverlayLayout();
+    });
+    return {
+      container: overlayContainer,
+      elements: {
+        menuButton
+      },
+      appVisibilityState: "visible",
+      actionSheetOverlay: actionSheet,
+      adOverlay,
+      showAdOverlay: () => {
+        return this.showAdOverlay("REWARDED VIDEO AD");
+      },
+      showActionSheet: (items, options) => {
+        return this.showActionSheetOverlay(items, options);
+      }
+    };
+  }
+  async handleMenuButtonClicked() {
+    if (this.state === 0 /* PLAYING */) {
+      this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
+      this.state = 1 /* PAUSED */;
+    }
+    const actionSheetItems = [];
+    const awakeAction = {
+      label: "\u23F0 Awake",
+      id: "awakeAction"
+    };
+    const sleepAction = {
+      label: "\u{1F4A4} Sleep",
+      id: "sleepAction"
+    };
+    const quitAction = {
+      label: "\u{1F6D1} Quit",
+      id: "quitAction"
+    };
+    const playAction = {
+      label: "\u25B6\uFE0F Play",
+      id: "playAction"
+    };
+    if (this.state === 1 /* PAUSED */) {
+      actionSheetItems.push(sleepAction);
+    } else if (this.state === 2 /* SLEEPING */) {
+      actionSheetItems.push(awakeAction);
+    }
+    if (this.state !== 3 /* TERMINATED */) {
+      actionSheetItems.push(quitAction);
+    } else if (this.state === 3 /* TERMINATED */) {
+      actionSheetItems.push(playAction);
+    }
+    const action = await this.showActionSheetOverlay(actionSheetItems);
+    if (action === awakeAction.id) {
+      this.tryAwake();
+    } else if (action === sleepAction.id) {
+      this.trySleep();
+    } else if (action === playAction.id) {
+      this.tryPlay();
+    } else if (action === quitAction.id) {
+      this.tryQuit();
+    } else {
+      this.tryResume();
+    }
+  }
+  tryAwake() {
+    if (this.state === 2 /* SLEEPING */) {
+      this.triggerLifecycleEvent("AWAKE" /* AWAKE */);
+      this.state = 1 /* PAUSED */;
+    }
+  }
+  trySleep() {
+    if (this.state === 1 /* PAUSED */) {
+      this.triggerLifecycleEvent("SLEEP" /* SLEEP */);
+      this.state = 2 /* SLEEPING */;
+    }
+  }
+  tryPlay() {
+    if (this.state === 3 /* TERMINATED */) {
+      this.triggerLifecycleEvent("AWAKE" /* AWAKE */);
+      this.state = 1 /* PAUSED */;
+      this.triggerLifecycleEvent("RESUME" /* RESUME */);
+      this.state = 0 /* PLAYING */;
+    }
+  }
+  tryQuit() {
+    if (this.state === 0 /* PLAYING */) {
+      this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
+      this.state = 1 /* PAUSED */;
+    }
+    if (this.state === 1 /* PAUSED */) {
+      this.triggerLifecycleEvent("SLEEP" /* SLEEP */);
+      this.state = 2 /* SLEEPING */;
+    }
+    if (this.state === 2 /* SLEEPING */) {
+      this.triggerLifecycleEvent("QUIT" /* QUIT */);
+      this.state = 3 /* TERMINATED */;
+    }
+  }
+  tryResume() {
+    if (this.state === 1 /* PAUSED */) {
+      this.triggerLifecycleEvent("RESUME" /* RESUME */);
+    }
+  }
+  async showAdOverlay(type) {
+    return new Promise((resolve, reject) => {
+      const overlay = this._overlay;
+      const adOverlay = overlay.adOverlay;
+      overlay.adOverlay.innerHTML = "";
+      const heading = document.createElement("h1");
+      heading.style.cssText = `
+        font-size: 24px;
+        margin-bottom: 20px;
+        text-align: center;
+      `;
+      heading.innerText = type === "interstitial" ? "INTERSTITIAL AD" : "REWARDED VIDEO AD";
+      overlay.adOverlay.appendChild(heading);
+      const content = document.createElement("div");
+      content.style.cssText = `
+        width: 300px;
+        height: 250px;
+        background-color: #1e40af;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        margin-bottom: 20px;
+        border-radius: 8px;
+      `;
+      content.innerText = "Mock Ad Content";
+      adOverlay.appendChild(content);
+      const timer = document.createElement("p");
+      timer.style.cssText = `
+        margin-bottom: 20px;
+        font-size: 16px;
+      `;
+      timer.innerText = "Normally ads would have a timer...";
+      adOverlay.appendChild(timer);
+      const okButton = document.createElement("button");
+      okButton.style.cssText = `
+        padding: 10px 40px;
+        background-color: #2563eb;
+        color: white;
+        border: none;
+        border-radius: 4px;
+        font-size: 16px;
+        cursor: pointer;
+      `;
+      okButton.innerText = "Close Ad";
+      adOverlay.appendChild(okButton);
+      adOverlay.style.display = "flex";
+      okButton.onclick = () => {
+        this.hideAdOverlay();
+        resolve(true);
+      };
+    });
+  }
+  hideAdOverlay() {
+    const overlay = this._overlay;
+    if (overlay.adOverlay) {
+      overlay.adOverlay.style.display = "none";
+    }
+  }
+  setupActionSheetOverlay() {
+    const actionSheetOverlay = document.createElement("div");
+    actionSheetOverlay.id = "venus-action-sheet-overlay";
+    actionSheetOverlay.style.cssText = `
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background-color: rgba(0, 0, 0, 0.5);
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        z-index: 10600;
+        font-family: sans-serif;
+        display: none;
+      `;
+    document.body.appendChild(actionSheetOverlay);
+    return actionSheetOverlay;
+  }
+  createOverlayButton(id, text, position, onClick, background, color) {
+    const button = document.createElement("button");
+    button.id = `venus-mock-${id}-button`;
+    button.innerText = text;
+    button.style.cssText = `
+      position: absolute;
+      left: ${position.x}px;
+      top: ${position.y}px;
+      width: ${position.width}px;
+      min-width: ${position.width}px;
+      height: ${position.height}px;
+      background: ${background};
+      color: ${color};
+      border: none;
+      border-radius: 8px;
+      font-family: sans-serif;
+      font-weight: bold;
+      font-size: ${Math.min(position.width, position.height) / 3}px;
+      cursor: pointer;
+      pointer-events: auto;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      opacity: 0.9;
+      transition: opacity 0.2s;
+    `;
+    button.addEventListener("click", onClick);
+    button.addEventListener("mouseover", () => {
+      button.style.opacity = "1";
+    });
+    button.addEventListener("mouseout", () => {
+      button.style.opacity = "0.9";
+    });
+    return button;
+  }
+  updateOverlayLayout() {
+    const venusApi = this.venusApi;
+    const overlay = this._overlay;
+    venusApi.config.ui.controls = this.updateUiControls();
+    const uiControls = venusApi.config.ui.controls;
+    const menuBtn = overlay.elements.menuButton;
+    const menuPos = uiControls.menuButton;
+    menuBtn.style.left = `${menuPos.x}px`;
+    menuBtn.style.top = `${menuPos.y}px`;
+    menuBtn.style.width = `${menuPos.width}px`;
+    menuBtn.style.minWidth = `${menuPos.width}px`;
+    menuBtn.style.height = `${menuPos.height}px`;
+  }
+  triggerLifecycleEvent(name) {
+    console.log("Trigger Lifecycle Event: ", name);
+    if (name == "PAUSE" /* PAUSE */) {
+      this._mockLifecyclesApi.triggerPauseCallbacks();
+    } else if (name == "RESUME" /* RESUME */) {
+      this._mockLifecyclesApi.triggerResumeCallbacks();
+    } else if (name == "QUIT" /* QUIT */) {
+      this._mockLifecyclesApi.triggerQuitCallbacks();
+    } else if (name == "AWAKE" /* AWAKE */) {
+      this._mockLifecyclesApi.triggerAwakeCallbacks();
+    } else if (name == "SLEEP" /* SLEEP */) {
+      this._mockLifecyclesApi.triggerSleepCallbacks();
+    }
+  }
+  setOverlayElementVisibility(element, visible) {
+    const overlay = this._overlay;
+    const elements = overlay.elements;
+    if (elements[element]) {
+      elements[element].style.display = visible ? "flex" : "none";
+    }
+  }
+  setupAdOverlay() {
+    const adOverlay = document.createElement("div");
+    adOverlay.id = "venus-ad-overlay";
+    adOverlay.style.cssText = `
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background-color: rgba(37, 99, 235, 0.9);
+        color: white;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+        z-index: 10500;
+        font-family: sans-serif;
+        display: none;
+      `;
+    document.body.appendChild(adOverlay);
+    return adOverlay;
+  }
+  log(msg, ...args) {
+    console.log(`[Venus Mock] ${msg}`, ...args);
+  }
+  showActionSheetOverlay(items, options) {
+    this.log("Showing ActionSheetOverlay...");
+    return new Promise((resolve, reject) => {
+      const overlay = this._overlay;
+      overlay.actionSheetOverlay.innerHTML = "";
+      overlay.actionSheetOverlay.style.display = "flex";
+      const actionSheet = document.createElement("div");
+      actionSheet.className = "venus-action-sheet";
+      actionSheet.style.cssText = `
+        background-color: white;
+        border-radius: 8px;
+        width: 80%;
+        max-width: 400px;
+        max-height: 80%;
+        display: flex;
+        flex-direction: column;
+        overflow: hidden;
+        color: black;
+      `;
+      if (options?.title) {
+        const titleContainer = document.createElement("div");
+        titleContainer.style.cssText = `
+          padding: 16px;
+          border-bottom: 1px solid #eaeaea;
+          font-weight: bold;
+          font-size: 18px;
+          text-align: center;
+          color: black;
+        `;
+        titleContainer.innerText = options.title;
+        actionSheet.appendChild(titleContainer);
+      }
+      if (options?.message) {
+        const messageContainer = document.createElement("div");
+        messageContainer.style.cssText = `
+          padding: 8px 16px;
+          color: #666;
+          font-size: 14px;
+          text-align: center;
+        `;
+        messageContainer.innerText = options.message;
+        actionSheet.appendChild(messageContainer);
+      }
+      const optionsContainer = document.createElement("div");
+      optionsContainer.style.cssText = `
+        overflow-y: auto;
+        max-height: 300px;
+      `;
+      items.forEach((item, index) => {
+        const optionItem = document.createElement("div");
+        optionItem.style.cssText = `
+          padding: 12px 16px;
+          border-bottom: 1px solid #eaeaea;
+          cursor: pointer;
+          display: flex;
+          align-items: center;
+          transition: background-color 0.2s;
+          color: black;
+        `;
+        optionItem.addEventListener("mouseover", () => {
+          optionItem.style.backgroundColor = "#f5f5f5";
+        });
+        optionItem.addEventListener("mouseout", () => {
+          optionItem.style.backgroundColor = "white";
+        });
+        if (item.icon) {
+          const iconSpan = document.createElement("span");
+          iconSpan.style.cssText = `
+          margin-right: 12px;
+          font-size: 16px;
+        `;
+          iconSpan.innerText = item.icon;
+          optionItem.appendChild(iconSpan);
+        }
+        const labelSpan = document.createElement("span");
+        labelSpan.style.cssText = `
+        color: black;
+      `;
+        labelSpan.innerText = item.label;
+        optionItem.appendChild(labelSpan);
+        optionItem.addEventListener("click", () => {
+          this.hideActionSheetOverlay();
+          const optionId = item.id !== void 0 ? item.id : index;
+          resolve(optionId);
+        });
+        optionsContainer.appendChild(optionItem);
+      });
+      actionSheet.appendChild(optionsContainer);
+      if (!options?.disableCancel) {
+        const cancelButton = document.createElement("div");
+        cancelButton.style.cssText = `
+        padding: 14px 16px;
+        text-align: center;
+        font-weight: bold;
+        cursor: pointer;
+        color: #3b82f6;
+        border-top: 1px solid #eaeaea;
+      `;
+        cancelButton.innerText = options?.cancelButtonText || "Cancel";
+        cancelButton.addEventListener("click", () => {
+          this.hideActionSheetOverlay();
+          resolve(null);
+        });
+        actionSheet.appendChild(cancelButton);
+      }
+      if (!options?.disableCancel) {
+        const closeButton = document.createElement("div");
+        closeButton.style.cssText = `
+          position: absolute;
+          top: 8px;
+          right: 8px;
+          width: 24px;
+          height: 24px;
+          border-radius: 12px;
+          background-color: rgba(0,0,0,0.1);
+          color: #666;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          cursor: pointer;
+          font-size: 14px;
+        `;
+        closeButton.innerText = "\u2715";
+        closeButton.addEventListener("click", () => {
+          this.hideActionSheetOverlay();
+          resolve(null);
+        });
+        actionSheet.appendChild(closeButton);
+        overlay.actionSheetOverlay.appendChild(actionSheet);
+      }
+    });
+  }
+  hideActionSheetOverlay() {
+    const overlay = this._overlay;
+    if (overlay.actionSheetOverlay) {
+      overlay.actionSheetOverlay.style.display = "none";
+    }
+  }
+};
+
+// src/VenusTransport.ts
+var VenusTransport = class {
+  constructor() {
+    __publicField(this, "messageHandler");
+    __publicField(this, "onNotificationCallbacks", []);
+    __publicField(this, "onNotificationCallbacksToRemove", []);
+    __publicField(this, "onVenusMessageCallbacks", []);
+    __publicField(this, "onResponseCallbacks", []);
+    __publicField(this, "onResponseCallbacksToRemove", []);
+    __publicField(this, "_instanceId", null);
+    __publicField(this, "isStarted", false);
+    __publicField(this, "isProcessingMessage", false);
+    this.messageHandler = async (event) => {
+      this.isProcessingMessage = true;
+      let message;
+      if (typeof event.data === "string") {
+        message = JSON.parse(event.data);
+      } else {
+        message = event.data;
+      }
+      if (!message) {
+        this.logInfo("No message found. Ignoring message...");
+        return;
+      }
+      this.notifyVenusMessageReceived(message);
+      if (message.type === "PAUSE" /* PAUSE */ || message.type === "RESUME" /* RESUME */ || message.type === "AWAKE" /* AWAKE */ || message.type === "SLEEP" /* SLEEP */ || message.type === "QUIT" /* QUIT */) {
+        const notification = {
+          type: "rpc-notification",
+          id: message.type,
+          payload: message.data
+        };
+        this.handleNotification(notification);
+        this.isProcessingMessage = false;
+        return;
+      }
+      const messageData = message.data;
+      if (!messageData) {
+        this.logWarn("No data found. Ignoring message...");
+        this.isProcessingMessage = false;
+        return;
+      }
+      const requestId = messageData.requestId;
+      if (!requestId) {
+        this.logWarn("No requestId. Ignoring message...");
+        this.isProcessingMessage = false;
+        return;
+      }
+      if (message.type !== "H5_RESPONSE" /* H5_RESPONSE */) {
+        this.logWarn(`Ignoring unknown message type: ${message.type}`);
+        this.isProcessingMessage = false;
+        return;
+      }
+      const success = messageData.success;
+      let error = void 0;
+      if (!success) {
+        error = {
+          message: messageData.error || "Unknown error"
+        };
+      }
+      let result = messageData.value;
+      if (result === void 0) {
+        result = messageData.data;
+      }
+      const response = {
+        type: "rpc-response",
+        id: requestId,
+        result,
+        method: message.type,
+        error
+      };
+      await this.handleResponse(response);
+      this.isProcessingMessage = false;
+    };
+  }
+  onNotification(callback) {
+    this.onNotificationCallbacks.push(callback);
+    return {
+      unsubscribe: () => {
+        if (this.isProcessingMessage) {
+          this.onNotificationCallbacks.push(callback);
+        } else {
+          this.removeOnNotificationCallback(callback);
+        }
+      }
+    };
+  }
+  onRequest(callback) {
+    throw new Error("Method not implemented.");
+  }
+  onResponse(callback) {
+    this.onResponseCallbacks.push(callback);
+    return {
+      unsubscribe: () => {
+        if (this.isProcessingMessage) {
+          this.onResponseCallbacksToRemove.push(callback);
+        } else {
+          this.removeOnResponseCallback(callback);
+        }
+      }
+    };
+  }
+  get instanceId() {
+    return this._instanceId;
+  }
+  set instanceId(instanceId) {
+    this._instanceId = instanceId;
+  }
+  sendRequest(request) {
+    const instanceId = this.instanceId || "unknown";
+    const method = request.method;
+    const message = {
+      type: method,
+      direction: "H5_TO_APP",
+      data: {
+        ...request.args,
+        requestId: request.id
+      },
+      instanceId,
+      timestamp: Date.now()
+    };
+    this.sendVenusMessage(message);
+  }
+  sendVenusMessage(message) {
+    const messageAsString = JSON.stringify(message, null, 2);
+    const reactNativeWebView = window.ReactNativeWebView;
+    if (reactNativeWebView) {
+      reactNativeWebView.postMessage(messageAsString);
+    } else {
+      window.parent.postMessage(messageAsString, "*");
+    }
+  }
+  sendResponse(response) {
+    throw new Error("Method not implemented.");
+  }
+  start() {
+    if (this.isStarted) {
+      return;
+    }
+    this.isStarted = true;
+    window.addEventListener("message", this.messageHandler, true);
+    this.logInfo(`Started`);
+  }
+  stop() {
+    if (!this.isStarted) {
+      return;
+    }
+    this.isStarted = false;
+    window.removeEventListener("message", this.messageHandler);
+    this.logInfo(`Stopped`);
+  }
+  handleNotification(notification) {
+    for (const callback of this.onNotificationCallbacks) {
+      callback(notification);
+    }
+    for (const callback of this.onNotificationCallbacksToRemove) {
+      this.removeOnNotificationCallback(callback);
+    }
+    this.onNotificationCallbacksToRemove.length = 0;
+  }
+  async handleResponse(response) {
+    for (const callback of this.onResponseCallbacks) {
+      const consumed = await callback(response);
+      if (consumed) {
+        break;
+      }
+    }
+    for (const callback of this.onResponseCallbacksToRemove) {
+      this.removeOnResponseCallback(callback);
+    }
+    this.onResponseCallbacksToRemove.length = 0;
+  }
+  removeOnResponseCallback(callback) {
+    this.onResponseCallbacks.splice(
+      this.onResponseCallbacks.indexOf(callback),
+      1
+    );
+  }
+  removeOnNotificationCallback(callback) {
+    this.onNotificationCallbacks.splice(
+      this.onNotificationCallbacks.indexOf(callback),
+      1
+    );
+  }
+  logInfo(message, ...params) {
+    console.log(`[Venus Transport] ${message}`, ...params);
+  }
+  logWarn(message, ...params) {
+    console.warn(`[Venus Transport] ${message}`, ...params);
+  }
+  onVenusMessage(callback) {
+    this.onVenusMessageCallbacks.push(callback);
+    return {
+      unsubscribe: () => {
+        this.onVenusMessageCallbacks.splice(
+          this.onVenusMessageCallbacks.indexOf(callback),
+          1
+        );
+      }
+    };
+  }
+  notifyVenusMessageReceived(message) {
+    for (const callback of this.onVenusMessageCallbacks) {
+      callback(message);
+    }
+  }
+};
+
+// src/RemoteHost.ts
+init_rooms();
+
+// src/rooms/RpcRoomsApi.ts
+init_VenusRoom();
+var RpcRoomsApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    __publicField(this, "subscriptions");
+    __publicField(this, "transportSubscription", null);
+    this.rpcClient = rpcClient;
+    this.subscriptions = {
+      data: {},
+      messages: {},
+      gameEvents: {},
+      allEvents: {}
+    };
+  }
+  /**
+   * Get the subscription state for external access (used by setupRoomNotifications)
+   */
+  getSubscriptions() {
+    return this.subscriptions;
+  }
+  /**
+   * Set up room notification routing from the transport
+   */
+  setupNotifications(transport) {
+    const { setupRoomNotifications: setupRoomNotifications2 } = (init_rooms(), __toCommonJS(rooms_exports));
+    this.transportSubscription = setupRoomNotifications2(
+      transport,
+      () => this.getSubscriptions()
+    );
+  }
+  /**
+   * Clean up subscriptions and resources
+   */
+  dispose() {
+    if (this.transportSubscription) {
+      this.transportSubscription.unsubscribe();
+      this.transportSubscription = null;
+      console.log("[Venus Rooms] Cleaned up room notification subscription");
+    }
+  }
+  async createRoom(options) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_CREATE" /* H5_ROOM_CREATE */,
+      {
+        options
+      }
+    );
+    if (response.success === false) {
+      throw new Error(response.error || "Failed to create room");
+    }
+    const roomData = response.roomData || response;
+    const room = new exports.VenusRoom(roomData);
+    return room;
+  }
+  async joinOrCreateRoom(options) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_JOIN_OR_CREATE" /* H5_ROOM_JOIN_OR_CREATE */,
+      {
+        options
+      }
+    );
+    if (response.success === false) {
+      throw new Error(response.error || "Failed to join or create room");
+    }
+    const data = response.value || response;
+    const room = new exports.VenusRoom(data.roomData);
+    return {
+      action: data.action,
+      room,
+      playersJoined: data.playersJoined
+    };
+  }
+  async joinRoomByCode(roomCode) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_JOIN_BY_CODE" /* H5_ROOM_JOIN_BY_CODE */,
+      {
+        roomCode
+      }
+    );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to join room by code");
+    }
+    const roomData = response.roomData || response;
+    const room = new exports.VenusRoom(roomData);
+    return room;
+  }
+  // Get user's rooms with optional filtering
+  async getUserRooms(includeArchived = false) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_GET_USER_ROOMS" /* H5_ROOM_GET_USER_ROOMS */,
+      {
+        includeArchived
+      }
+    );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to get user rooms");
+    }
+    const rawRooms = response.rooms || [];
+    const venusRooms = [];
+    for (const roomData of rawRooms) {
+      if (!roomData.id) {
+        console.warn("getUserRooms: Skipping room with missing ID:", roomData);
+        continue;
+      }
+      try {
+        const venusRoom = new exports.VenusRoom(roomData);
+        venusRooms.push(venusRoom);
+      } catch (error) {
+        console.warn(
+          "getUserRooms: Failed to create VenusRoom object:",
+          error,
+          roomData
+        );
+      }
+    }
+    return venusRooms;
+  }
+  async updateData(room, updates, merge = true) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_UPDATE_DATA" /* H5_ROOM_UPDATE_DATA */,
+      {
+        roomId: room.id,
+        updates,
+        merge
+      }
+    );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to update room data");
+    }
+    return response.data;
+  }
+  async getData(room) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_GET_DATA" /* H5_ROOM_GET_DATA */,
+      {
+        roomId: room.id
+      }
+    );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to get room data");
+    }
+    return response.data;
+  }
+  async sendMessage(venusRoom, messageData) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_SEND_MESSAGE" /* H5_ROOM_SEND_MESSAGE */,
+      {
+        roomId: venusRoom.id,
+        message: messageData
+      }
+    );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to send message");
+    }
+    return response.messageId;
+  }
+  async leave(room) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_LEAVE" /* H5_ROOM_LEAVE */,
+      {
+        roomId: room.id
+      }
+    );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to leave room");
+    }
+    return response;
+  }
+  async startGame(room, gameConfig = {}, turnOrder = null) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_START_GAME" /* H5_ROOM_START_GAME */,
+      {
+        roomId: room.id,
+        gameConfig,
+        turnOrder
+      }
+    );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to start game");
+    }
+    return response.data;
+  }
+  async proposeMove(room, proposalPayload) {
+    const response = await this.rpcClient.call(
+      "h5:room:proposeMove" /* H5_ROOM_PROPOSE_MOVE */,
+      {
+        roomId: room.id,
+        gameSpecificState: proposalPayload.gameSpecificState,
+        moveType: proposalPayload.moveType,
+        clientContext: proposalPayload.clientContext,
+        clientProposalId: proposalPayload.clientProposalId
+      }
+    );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to propose move");
+    }
+    return response.data;
+  }
+  async validateMove(room, moveId, isValid, reason = null, validatorId = null) {
+    console.log(`[Venus Rooms] Validating move ${moveId}: ${isValid}`);
+    return { success: true, moveId, isValid, reason };
+  }
+  async roomSubscribeToGameEvents(room, callback) {
+    "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
+    if (!this.subscriptions.gameEvents[room.id]) {
+      this.subscriptions.gameEvents[room.id] = [];
+    }
+    this.subscriptions.gameEvents[room.id].push(callback);
+  }
+  subscribe(room, options = {}) {
+    const subscriptionIds = [];
+    const roomId = room.id;
+    if (options.onData) {
+      const dataSubId = "data_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
+      if (!this.subscriptions.data[roomId]) {
+        this.subscriptions.data[roomId] = [];
+      }
+      this.subscriptions.data[roomId].push(options.onData);
+      subscriptionIds.push({
+        type: "data",
+        id: dataSubId,
+        callback: options.onData
+      });
+    }
+    if (options.onMessages) {
+      const msgSubId = "messages_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
+      if (!this.subscriptions.messages[roomId]) {
+        this.subscriptions.messages[roomId] = [];
+      }
+      this.subscriptions.messages[roomId].push(options.onMessages);
+      subscriptionIds.push({
+        type: "messages",
+        id: msgSubId,
+        callback: options.onMessages
+      });
+    }
+    if (options.onMoves || options.onGameEvents) {
+      const handler = options.onMoves || options.onGameEvents;
+      if (handler) {
+        const gameSubId = "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
+        if (!this.subscriptions.gameEvents[roomId]) {
+          this.subscriptions.gameEvents[roomId] = [];
+        }
+        this.subscriptions.gameEvents[roomId].push(handler);
+        subscriptionIds.push({
+          type: "gameEvents",
+          id: gameSubId,
+          callback: handler
+        });
+      }
+    }
+    const needsSubscription = subscriptionIds.length > 0 && (this.subscriptions.data[roomId]?.length ?? 0) <= 1 && (this.subscriptions.messages[roomId]?.length ?? 0) <= 1 && (this.subscriptions.gameEvents[roomId]?.length ?? 0) <= 1;
+    if (needsSubscription) {
+      this.rpcClient.call("H5_ROOM_SUBSCRIBE" /* H5_ROOM_SUBSCRIBE */, {
+        roomId,
+        subscribeToData: !!options.onData,
+        subscribeToMessages: !!options.onMessages,
+        subscribeToProposedMoves: !!(options.onMoves || options.onGameEvents)
+      }).catch((error) => {
+        console.error("Failed to set up room subscription:", error);
+      });
+    }
+    let called = false;
+    return () => {
+      if (called) return;
+      called = true;
+      subscriptionIds.forEach((sub) => {
+        const bucket = this.subscriptions[sub.type];
+        const callbacks = bucket && bucket[roomId] || [];
+        const index = callbacks.indexOf(sub.callback);
+        if (index > -1) callbacks.splice(index, 1);
+      });
+      const hasNoCallbacks = (this.subscriptions.data[roomId]?.length ?? 0) === 0 && (this.subscriptions.messages[roomId]?.length ?? 0) === 0 && (this.subscriptions.gameEvents[roomId]?.length ?? 0) === 0;
+      if (hasNoCallbacks) {
+        this.rpcClient.call("H5_ROOM_UNSUBSCRIBE" /* H5_ROOM_UNSUBSCRIBE */, {
+          roomId
+        }).catch((error) => {
+          console.error("Failed to clean up room subscription:", error);
+        });
+      }
+    };
+  }
+};
+
+// src/social/RpcSocialApi.ts
+var RpcSocialApi = class {
+  constructor(rpcClient) {
+    this.rpcClient = rpcClient;
+  }
+  async shareLinkAsync(options) {
+    const result = await this.rpcClient.call("H5_SHARE_LINK" /* SHARE_LINK */, {
+      launchParams: options.launchParams,
+      metadata: options.metadata ?? {}
+    });
+    return {
+      shareUrl: result.shareUrl
+    };
+  }
+  async createQRCodeAsync(options) {
+    const result = await this.rpcClient.call(
+      "H5_CREATE_SHARE_QRCODE" /* CREATE_SHARE_QRCODE */,
+      {
+        launchParams: options.launchParams,
+        metadata: options.metadata ?? {},
+        qrOptions: options.qrOptions ?? {}
+      }
+    );
+    return {
+      shareUrl: result.shareUrl,
+      qrCode: result.qrCode
+    };
+  }
+};
+
+// src/RemoteHost.ts
+var getCdnBaseUrl = () => {
+  return "https://venus-static-01293ak.web.app/";
+};
+var RemoteHost = class {
+  constructor(venusApi) {
+    __publicField(this, "ads");
+    __publicField(this, "analytics");
+    __publicField(this, "deviceCache");
+    __publicField(this, "appStorage");
+    __publicField(this, "globalStorage");
+    __publicField(this, "avatar3d");
+    __publicField(this, "navigation");
+    __publicField(this, "notifications");
+    __publicField(this, "popups");
+    __publicField(this, "profile");
+    __publicField(this, "cdn");
+    __publicField(this, "time");
+    __publicField(this, "post");
+    __publicField(this, "ai");
+    __publicField(this, "haptics");
+    __publicField(this, "features");
+    __publicField(this, "lifecycle");
+    __publicField(this, "simulation");
+    __publicField(this, "rooms");
+    __publicField(this, "logging");
+    __publicField(this, "iap");
+    __publicField(this, "leaderboard");
+    __publicField(this, "preloader");
+    __publicField(this, "social");
+    __publicField(this, "venusApi");
+    __publicField(this, "rpcClient");
+    __publicField(this, "_isInitialized", false);
+    this.venusApi = venusApi;
+    const rpcClient = new RpcClient();
+    this.rpcClient = rpcClient;
+    this.ads = new RpcAdsApi(rpcClient);
+    this.analytics = new RpcAnalyticsApi(rpcClient);
+    this.deviceCache = new RpcStorageApi(rpcClient, {
+      clear: "H5_DEVICE_CACHE_CLEAR" /* DEVICE_CACHE_CLEAR */,
+      getItem: "H5_DEVICE_CACHE_GET_ITEM" /* DEVICE_CACHE_GET_ITEM */,
+      getKey: "H5_DEVICE_CACHE_KEY" /* DEVICE_CACHE_KEY */,
+      length: "H5_DEVICE_CACHE_LENGTH" /* DEVICE_CACHE_LENGTH */,
+      removeItem: "H5_DEVICE_CACHE_REMOVE_ITEM" /* DEVICE_CACHE_REMOVE_ITEM */,
+      setItem: "H5_DEVICE_CACHE_SET_ITEM" /* DEVICE_CACHE_SET_ITEM */
+    });
+    this.appStorage = new RpcStorageApi(rpcClient, {
+      clear: "H5_APP_STORAGE_CLEAR" /* APP_STORAGE_CLEAR */,
+      getItem: "H5_APP_STORAGE_GET_ITEM" /* APP_STORAGE_GET_ITEM */,
+      getKey: "H5_APP_STORAGE_KEY" /* APP_STORAGE_KEY */,
+      length: "H5_APP_STORAGE_LENGTH" /* APP_STORAGE_LENGTH */,
+      removeItem: "H5_APP_STORAGE_REMOVE_ITEM" /* APP_STORAGE_REMOVE_ITEM */,
+      setItem: "H5_APP_STORAGE_SET_ITEM" /* APP_STORAGE_SET_ITEM */,
+      getAllItems: "H5_APP_STORAGE_GET_ALL_ITEMS" /* APP_STORAGE_GET_ALL_ITEMS */,
+      setMultipleItems: "H5_APP_STORAGE_SET_ITEM" /* APP_STORAGE_SET_ITEM */,
+      removeMultipleItems: "H5_APP_STORAGE_REMOVE_ITEM" /* APP_STORAGE_REMOVE_ITEM */
+    });
+    this.globalStorage = new RpcStorageApi(rpcClient, {
+      clear: "H5_GLOBAL_STORAGE_CLEAR" /* GLOBAL_STORAGE_CLEAR */,
+      getItem: "H5_GLOBAL_STORAGE_GET_ITEM" /* GLOBAL_STORAGE_GET_ITEM */,
+      getKey: "H5_GLOBAL_STORAGE_KEY" /* GLOBAL_STORAGE_KEY */,
+      length: "H5_GLOBAL_STORAGE_LENGTH" /* GLOBAL_STORAGE_LENGTH */,
+      removeItem: "H5_GLOBAL_STORAGE_REMOVE_ITEM" /* GLOBAL_STORAGE_REMOVE_ITEM */,
+      setItem: "H5_GLOBAL_STORAGE_SET_ITEM" /* GLOBAL_STORAGE_SET_ITEM */,
+      getAllItems: "H5_GLOBAL_STORAGE_GET_ALL_ITEMS" /* GLOBAL_STORAGE_GET_ALL_ITEMS */,
+      setMultipleItems: "H5_GLOBAL_STORAGE_SET_MULTIPLE_ITEMS" /* GLOBAL_STORAGE_SET_MULTIPLE_ITEMS */,
+      removeMultipleItems: "H5_GLOBAL_STORAGE_REMOVE_MULTIPLE_ITEMS" /* GLOBAL_STORAGE_REMOVE_MULTIPLE_ITEMS */
+    });
+    this.avatar3d = new RpcAvatarApi(rpcClient, venusApi);
+    this.navigation = new RpcNavigationApi(rpcClient, venusApi);
+    this.notifications = new RpcNotificationsApi(rpcClient);
+    this.popups = new RpcPopupsApi(rpcClient);
+    this.profile = new HostProfileApi();
+    this.cdn = new HostCdnApi(getCdnBaseUrl());
+    this.time = new HostTimeApi(rpcClient);
+    this.post = new RpcPostApi(rpcClient);
+    this.ai = new RpcAiApi(rpcClient);
+    this.haptics = new RpcHapticsApi(rpcClient);
+    this.features = new RpcFeaturesApi(rpcClient);
+    this.lifecycle = new RpcLifecycleApi(rpcClient);
+    this.simulation = new RpcSimulationApi(rpcClient);
+    this.rooms = new RpcRoomsApi(rpcClient);
+    this.logging = new RpcLoggingApi(this, rpcClient);
+    this.iap = new RpcIapApi(rpcClient);
+    this.leaderboard = new RpcLeaderboardApi(rpcClient);
+    this.preloader = new RpcPreloaderApi(rpcClient);
+    this.social = new RpcSocialApi(rpcClient);
+    venusApi.isMock = () => false;
+    this.venusApi.sharedAssets = new RpcSharedAssetsApi(rpcClient, venusApi);
+    initializeRoomsApi(this.venusApi, this);
+    console.log("[Venus SDK] Remote host created");
+  }
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  async initialize(options) {
+    this.log("Initializing Remote Host...");
+    const transport = new VenusTransport();
+    transport.start();
+    this.rpcClient.start(transport);
+    const roomsApi = this.rooms;
+    roomsApi.setupNotifications(transport);
+    const response = await this.rpcClient.call(
+      "INITIALIZE_SDK" /* INIT_SDK */,
+      {},
+      5e3
+    );
+    transport.instanceId = response.instanceId;
+    this.log(`Remote Host Initialized with id: ${transport.instanceId}`);
+    if (response.profile) {
+      const profile = response.profile;
+      const sanitizedProfile = {
+        id: profile.id,
+        username: profile.username,
+        avatarUrl: profile.avatarUrl ?? null,
+        isAnonymous: Boolean(profile.isAnonymous)
+      };
+      if (typeof window !== "undefined") {
+        const globalWindow = window;
+        const venus = globalWindow.venus || (globalWindow.venus = {});
+        venus.profile = sanitizedProfile;
+        if (venus._config) {
+          venus._config.profile = sanitizedProfile;
+        }
+        if (venus.config) {
+          venus.config.profile = sanitizedProfile;
+        }
+      }
+    }
+    this._isInitialized = true;
+    this.venusApi.launchParams = response.launchParams || {};
+    await this.rpcClient.call("READY" /* READY */, {});
+    const hudInsets = response.hudInsets;
+    if (hudInsets) {
+      this.venusApi.config.ui.safeArea = hudInsets;
+    }
+    return {
+      hudInsets,
+      initializeAsleep: response.initializeAsleep
+    };
+  }
+  log(message) {
+    console.log(`[Venus SDK] [Remote Host] ${message}`);
+  }
+};
+
+// src/Host.ts
+function createHost(venusApi, isMock) {
+  if (isMock) {
+    console.log("[Venus SDK] Creating Local Host");
+    return new MockHost(venusApi);
+  } else {
+    console.log("[Venus SDK] Creating Remote Host");
+    return new RemoteHost(venusApi);
+  }
+}
+
+// src/social/index.ts
+function initializeSocial(venusApi, host) {
+  venusApi.social = host.social;
+  venusApi.getLaunchParams = () => {
+    return venusApi.launchParams || {};
+  };
+}
+
 exports.HapticFeedbackStyle = HapticFeedbackStyle;
 exports.HostCdnApi = HostCdnApi;
 exports.HostProfileApi = HostProfileApi;
@@ -3375,16 +5316,20 @@ exports.MockCdnApi = MockCdnApi;
 exports.MockFeaturesApi = MockFeaturesApi;
 exports.MockHapticsApi = MockHapticsApi;
 exports.MockIapApi = MockIapApi;
+exports.MockLeaderboardApi = MockLeaderboardApi;
 exports.MockLifecycleApi = MockLifecycleApi;
 exports.MockLoggingApi = MockLoggingApi;
 exports.MockNavigationApi = MockNavigationApi;
 exports.MockNotificationsApi = MockNotificationsApi;
 exports.MockPopupsApi = MockPopupsApi;
+exports.MockPreloaderApi = MockPreloaderApi;
 exports.MockProfileApi = MockProfileApi;
 exports.MockSharedAssetsApi = MockSharedAssetsApi;
 exports.MockSimulationApi = MockSimulationApi;
+exports.MockSocialApi = MockSocialApi;
 exports.MockStorageApi = MockStorageApi;
 exports.MockTimeApi = MockTimeApi;
+exports.RemoteHost = RemoteHost;
 exports.RpcAdsApi = RpcAdsApi;
 exports.RpcAiApi = RpcAiApi;
 exports.RpcAnalyticsApi = RpcAnalyticsApi;
@@ -3393,15 +5338,20 @@ exports.RpcClient = RpcClient;
 exports.RpcFeaturesApi = RpcFeaturesApi;
 exports.RpcHapticsApi = RpcHapticsApi;
 exports.RpcIapApi = RpcIapApi;
+exports.RpcLeaderboardApi = RpcLeaderboardApi;
 exports.RpcLifecycleApi = RpcLifecycleApi;
 exports.RpcLoggingApi = RpcLoggingApi;
 exports.RpcNavigationApi = RpcNavigationApi;
+exports.RpcNotificationsApi = RpcNotificationsApi;
 exports.RpcPopupsApi = RpcPopupsApi;
+exports.RpcPreloaderApi = RpcPreloaderApi;
 exports.RpcSharedAssetsApi = RpcSharedAssetsApi;
 exports.RpcSimulationApi = RpcSimulationApi;
+exports.RpcSocialApi = RpcSocialApi;
 exports.RpcStorageApi = RpcStorageApi;
 exports.SDK_VERSION = SDK_VERSION;
 exports.VenusMessageId = VenusMessageId;
+exports.createHost = createHost;
 exports.createMockStorageApi = createMockStorageApi;
 exports.initializeAds = initializeAds;
 exports.initializeAi = initializeAi;
@@ -3411,15 +5361,20 @@ exports.initializeCdn = initializeCdn;
 exports.initializeFeaturesApi = initializeFeaturesApi;
 exports.initializeHaptics = initializeHaptics;
 exports.initializeIap = initializeIap;
+exports.initializeLeaderboard = initializeLeaderboard;
 exports.initializeLifecycleApi = initializeLifecycleApi;
 exports.initializeLocalNotifications = initializeLocalNotifications;
 exports.initializeLoggingApi = initializeLoggingApi;
 exports.initializePopups = initializePopups;
+exports.initializePreloader = initializePreloader;
 exports.initializeProfile = initializeProfile;
+exports.initializeRoomsApi = initializeRoomsApi;
 exports.initializeSimulation = initializeSimulation;
+exports.initializeSocial = initializeSocial;
 exports.initializeStackNavigation = initializeStackNavigation;
 exports.initializeStorage = initializeStorage;
 exports.initializeTime = initializeTime;
 exports.isPacificDaylightTime = isPacificDaylightTime;
+exports.setupRoomNotifications = setupRoomNotifications;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map