@series-inc/venus-sdk 2.4.1 → 3.0.0

package/dist/venus-api/index.cjs

@@ -1,7 +1,9 @@
 '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;
@@ -10,6 +12,15 @@ 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/venus-api/systems/core.js
@@ -100,6 +111,221 @@ var init_core = __esm({
   }
 });
 
+// src/rooms/RoomsApi.ts
+var init_RoomsApi = __esm({
+  "src/rooms/RoomsApi.ts"() {
+  }
+});
+
+// src/rooms/VenusRoom.ts
+var VenusRoom;
+var init_VenusRoom = __esm({
+  "src/rooms/VenusRoom.ts"() {
+    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: () => 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/storage/MockStorageApi.ts
 function createMockStorageApi(storageType, appUrl) {
   const appIdentifier = appUrl ? generateAppIdentifier(appUrl) : null;
@@ -339,23 +565,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);
@@ -379,14 +609,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) {
@@ -736,7 +968,7 @@ var MockNotificationsApi = class {
     __publicField(this, "venusApi");
     this.venusApi = venusApi;
   }
-  async cancelLocalNotification(notificationId) {
+  async cancelNotification(notificationId) {
     const venusApi = this.venusApi;
     if (isWebPlatform()) {
       console.log(
@@ -777,7 +1009,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"
@@ -792,7 +1025,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");
@@ -802,17 +1035,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);
     });
   }
@@ -832,36 +1067,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/time/utils.ts
@@ -1797,1002 +2074,66 @@ function initializeAi(venusApi, host) {
   venusApi.ai = host.ai;
 }
 
-// src/venus-api/systems/rooms.js
-init_core();
-var mockRooms = /* @__PURE__ */ new Map();
-var mockMessages = /* @__PURE__ */ new Map();
-var mockRoomMoves = /* @__PURE__ */ new Map();
-var mockSubscriptions = /* @__PURE__ */ new Map();
-function generateRoomId() {
-  return "room_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-}
-function generateMessageId() {
-  return "msg_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-}
-function generateRoomCode() {
-  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-  let code = "";
-  for (let i = 0; i < 6; i++) {
-    code += characters.charAt(Math.floor(Math.random() * characters.length));
-  }
-  return code;
-}
-function broadcastEvent(roomId, eventType, eventData) {
-  console.log(`[Venus Mock Rooms] Broadcasting ${eventType} for room ${roomId}:`, eventData);
-  for (const [instanceId, subscriptions] of mockSubscriptions.entries()) {
-    const roomSubscriptions = subscriptions.get(roomId);
-    if (roomSubscriptions) {
-      setTimeout(() => {
-        if (roomSubscriptions.onRoomDataUpdated && eventType === "room_data_updated") {
-          roomSubscriptions.onRoomDataUpdated(eventData);
-        }
-        if (roomSubscriptions.onMessageReceived && eventType === "message_received") {
-          roomSubscriptions.onMessageReceived(eventData);
-        }
-        if (roomSubscriptions.onPlayerJoined && eventType === "player_joined") {
-          roomSubscriptions.onPlayerJoined(eventData);
-        }
-        if (roomSubscriptions.onPlayerLeft && eventType === "player_left") {
-          roomSubscriptions.onPlayerLeft(eventData);
-        }
-        if (roomSubscriptions.onGameStarted && eventType === "game_started") {
-          roomSubscriptions.onGameStarted(eventData);
-        }
-        if (roomSubscriptions.onTurnChanged && eventType === "turn_changed") {
-          roomSubscriptions.onTurnChanged(eventData);
-        }
-        if (roomSubscriptions.onOptimisticGameStateUpdated && eventType === "app:h5:optimisticGameStateUpdated") {
-          roomSubscriptions.onOptimisticGameStateUpdated(eventData);
-        }
-        if (roomSubscriptions.onProposedMoveValidationUpdated && eventType === "app:h5:proposedMoveValidationUpdated") {
-          roomSubscriptions.onProposedMoveValidationUpdated(eventData);
-        }
-      }, 50);
-    }
-  }
-}
-var MockVenusRoom = class {
-  constructor(roomData) {
-    this.id = roomData.id;
-    this.roomId = roomData.id;
-    this.name = roomData.name;
-    this.players = roomData.currentPlayers || [];
-    this.maxPlayers = roomData.maxPlayers;
-    this.gameType = roomData.gameType;
-    this._subscriptions = /* @__PURE__ */ new Map();
-    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(`[Venus Mock 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
-    });
-  }
-  // Update room data
-  async updateData(updates, merge = true) {
-    return roomsMock.updateRoomData(this.roomId, updates, merge);
-  }
-  // Get room data
-  async getData() {
-    return roomsMock.getRoomData(this.roomId);
-  }
-  // Send message
-  async sendMessage(messageData) {
-    return roomsMock.sendMessage(this.roomId, messageData);
-  }
-  // Subscribe to room data changes
-  subscribeToData(callback) {
-    return roomsMock.subscribeToRoom(this.roomId, {
-      onRoomDataUpdated: callback
-    });
-  }
-  // Subscribe to messages
-  subscribeToMessages(callback) {
-    return roomsMock.subscribeToRoom(this.roomId, {
-      onMessageReceived: callback
-    });
-  }
-  // Leave room
-  async leave() {
-    this._subscriptions.forEach((sub) => {
-      if (sub.unsubscribe) sub.unsubscribe();
-    });
-    this._subscriptions.clear();
-    return { success: true };
-  }
-  // Start game
-  async startGame(gameConfig = {}, turnOrder = null) {
-    return roomsMock.startGame(this.roomId, gameConfig);
-  }
-  // End game
-  async endGame(winner = null, reason = null, gameResults = {}) {
-    return roomsMock.endGame(this.roomId, winner, reason, gameResults);
-  }
-  // Propose move (for client-proposed state architecture)
-  async proposeMove(proposalPayload) {
-    return roomsMock.proposeMove(this.roomId, proposalPayload);
-  }
-  // Validate move
-  async validateMove(moveId, isValid, reason = null, validatorId = null) {
-    console.log(`[Venus Mock VenusRoom] Validating move ${moveId}: ${isValid}`);
-    return { success: true, moveId, isValid, reason };
-  }
-  // Subscribe to game events
-  subscribeToGameEvents(callback) {
-    return roomsMock.subscribeToRoom(this.roomId, {
-      onOptimisticGameStateUpdated: callback,
-      onProposedMoveValidationUpdated: callback
-    });
+// src/venus-api/systems/asset-loader.js
+var VenusAssetLoader = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.blobUrls = /* @__PURE__ */ new Map();
+    this.isWebView = false;
+    this.venusAPI = null;
   }
-  // Generic message handler for room-manager.js integration
-  onMessage(callback) {
-    return roomsMock.subscribeToRoom(this.roomId, {
-      onRoomDataUpdated: callback,
-      onMessageReceived: callback,
-      onGameStarted: callback,
-      onTurnChanged: callback,
-      onOptimisticGameStateUpdated: callback,
-      onProposedMoveValidationUpdated: callback
-    });
+  // Set the VenusAPI reference during initialization
+  setVenusAPI(api) {
+    this.venusAPI = api;
+    this.isWebView = !api.isWeb || !api.isWeb();
   }
-  // Unified subscription helper
-  subscribe(options = {}) {
-    const unsubFns = [];
-    if (options.onData) {
-      const sub = this.subscribeToData(options.onData);
-      unsubFns.push(() => sub.unsubscribe());
-    }
-    if (options.onMessages) {
-      const sub = this.subscribeToMessages(options.onMessages);
-      unsubFns.push(() => sub.unsubscribe());
-    }
-    if (options.onMoves || options.onGameEvents) {
-      const handler = options.onMoves || options.onGameEvents;
-      const sub = this.subscribeToGameEvents(handler);
-      unsubFns.push(() => sub.unsubscribe());
+  /**
+   * Load any asset with automatic optimization
+   * @param {string} url - Asset URL
+   * @param {Object} options - Loading options
+   * @returns {Promise<string>} - URL to use (original, blob, or object URL)
+   */
+  async loadAsset(url, options = {}) {
+    const {
+      type = "auto",
+      // 'image', 'audio', 'video', 'text', 'json', 'auto'
+      cache = true,
+      // Use cache
+      timeout = 3e4,
+      isOptional = false
+      // New option to suppress error logging for optional assets
+    } = options;
+    const resolvedUrl = this.venusAPI && this.venusAPI.resolveAssetUrl ? this.venusAPI.resolveAssetUrl(url) : this._resolveAssetUrl(url);
+    if (cache && this.cache.has(resolvedUrl)) {
+      return this.cache.get(resolvedUrl);
     }
-    let called = false;
-    return () => {
-      if (called) return;
-      called = true;
-      unsubFns.forEach((fn) => {
-        try {
-          fn();
-        } catch (e) {
-          console.error("Mock room subscribe teardown error", e);
-        }
-      });
-    };
-  }
-};
-var roomsMock = {
-  createRoom(options = {}) {
+    const assetType = type === "auto" ? this._detectType(resolvedUrl) : type;
     try {
-      console.log(`[Venus Mock Rooms] Creating room with options:`, options);
-      const roomId = generateRoomId();
-      const creatorId = options.userId || "mock-user-creator";
-      const creatorDisplayName = options.userDisplayName || `Creator ${creatorId.slice(-4)}`;
-      const initialGameState = {
-        phase: "waiting",
-        currentPlayer: creatorId,
-        // Creator might be the first player by default
-        turnOrder: [creatorId],
-        playerStates: {
-          [creatorId]: {
-            displayName: creatorDisplayName,
-            status: "active",
-            role: "admin",
-            // Creator is admin
-            joinedAt: /* @__PURE__ */ new Date()
-          }
-        },
-        gameStartedAt: null,
-        turnCount: 0
-        // other game-specific state can be added by the H5 app via customMetadata or startGame
-      };
-      const room = {
-        id: roomId,
-        appId: options.appId || "mock-app",
-        name: options.name || "Mock Room",
-        type: "shared",
-        createdBy: creatorId,
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date(),
-        isPrivate: options.isPrivate || false,
-        maxPlayers: options.maxPlayers || 4,
-        currentPlayers: [creatorId],
-        status: "active",
-        customMetadata: {
-          ...options.customMetadata || {},
-          rules: {
-            ...options.customMetadata?.rules || {},
-            // Default generic rules, can be overridden by H5 app's options
-            ruleEngine: options.customMetadata?.rules?.ruleEngine || "generic-v1",
-            turnBased: options.customMetadata?.rules?.turnBased ?? true,
-            minPlayers: options.customMetadata?.rules?.minPlayers || 1,
-            maxPlayers: options.maxPlayers || 4,
-            gameState: initialGameState
+      let resultUrl = resolvedUrl;
+      if (assetType === "text" || assetType === "json") {
+        const content = await this._fetchText(resolvedUrl, timeout);
+        this.cache.set(resolvedUrl, content);
+        return content;
+      }
+      const isMockMode = this.venusAPI && this.venusAPI.isMock && this.venusAPI.isMock();
+      if (this.isWebView && !isMockMode && ["image", "audio", "video"].includes(assetType)) {
+        if (assetType === "video") {
+          resultUrl = await this._loadAsBlob(resolvedUrl, assetType);
+          if (cache) {
+            this.cache.set(resolvedUrl, resultUrl);
           }
-        },
-        admins: [creatorId],
-        roomCode: options.roomCode || (options.isPrivate ? generateRoomCode() : null),
-        description: options.description,
-        gameType: options.gameType,
-        data: {},
-        // General purpose data, game state is in customMetadata.rules.gameState
-        version: 1
-      };
-      mockRooms.set(roomId, room);
-      mockMessages.set(roomId, []);
-      mockRoomMoves.set(roomId, []);
-      console.log(`[Venus Mock Rooms] Created room ${roomId} with initial state:`, room);
-      return Promise.resolve(new MockVenusRoom(room));
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error creating room:`, error);
-      return Promise.reject({ success: false, error: error.message || "Failed to create room" });
-    }
-  },
-  joinRoom(roomId, playerMetadata = {}) {
-    try {
-      console.log(`[Venus Mock Rooms] Joining room ${roomId}`);
-      const room = mockRooms.get(roomId);
-      if (!room) {
-        return Promise.reject({ success: false, error: "Room not found" });
-      }
-      const joiningPlayerId = playerMetadata.userId || "mock-user-" + Math.random().toString(36).substr(2, 5);
-      const joiningPlayerDisplayName = playerMetadata.displayName || `Player ${joiningPlayerId.slice(-4)}`;
-      if (room.currentPlayers.includes(joiningPlayerId)) {
-        console.log(`[Venus Mock Rooms] Player ${joiningPlayerId} already in room ${roomId}. Updating display name if needed.`);
-        if (room.customMetadata.rules.gameState.playerStates[joiningPlayerId]) {
-          room.customMetadata.rules.gameState.playerStates[joiningPlayerId].displayName = joiningPlayerDisplayName;
-          room.customMetadata.rules.gameState.playerStates[joiningPlayerId].status = "active";
+          return resultUrl;
+        } else if (assetType === "audio") {
+          resultUrl = await this._loadAsBlob(resolvedUrl, assetType);
         } else {
-          room.customMetadata.rules.gameState.playerStates[joiningPlayerId] = {
-            displayName: joiningPlayerDisplayName,
-            status: "active",
-            role: "player",
-            joinedAt: /* @__PURE__ */ new Date()
-          };
-        }
-        room.updatedAt = /* @__PURE__ */ new Date();
-        room.version++;
-        broadcastEvent(roomId, "room_data_updated", { roomId, roomData: room, timestamp: Date.now() });
-        return Promise.resolve(new MockVenusRoom(room));
-      }
-      if (room.currentPlayers.length >= room.maxPlayers) {
-        return Promise.reject({ success: false, error: "Room is full" });
-      }
-      room.currentPlayers.push(joiningPlayerId);
-      room.customMetadata.rules.gameState.playerStates[joiningPlayerId] = {
-        displayName: joiningPlayerDisplayName,
-        status: "active",
-        role: "player",
-        joinedAt: /* @__PURE__ */ new Date()
-      };
-      if (room.customMetadata.rules.gameState.phase === "waiting" && room.customMetadata.rules.gameState.turnOrder) {
-        if (!room.customMetadata.rules.gameState.turnOrder.includes(joiningPlayerId)) {
-          room.customMetadata.rules.gameState.turnOrder.push(joiningPlayerId);
+          resultUrl = await this._loadAsBlob(resolvedUrl, assetType);
         }
       }
-      room.updatedAt = /* @__PURE__ */ new Date();
-      room.version++;
-      broadcastEvent(roomId, "player_joined", { roomId, player: { id: joiningPlayerId, displayName: joiningPlayerDisplayName } });
-      broadcastEvent(roomId, "room_data_updated", { roomId, roomData: room, timestamp: Date.now() });
-      console.log(`[Venus Mock Rooms] Player ${joiningPlayerId} joined room ${roomId}. Current state:`, room);
-      return Promise.resolve(new MockVenusRoom(room));
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error joining room:`, error);
-      return Promise.reject({ success: false, error: error.message || "Failed to join room" });
-    }
-  },
-  updateRoomData(roomId, updates, merge = true) {
-    try {
-      console.log(`[Venus Mock Rooms] Updating room ${roomId} data:`, updates);
-      const room = mockRooms.get(roomId);
-      if (!room) {
-        throw new Error("Room not found");
+      if (!(this.isWebView && !isMockMode && assetType === "video")) {
+        await this._verifyAsset(resultUrl, assetType);
       }
-      if (merge) {
-        room.data = { ...room.data, ...updates };
-      } else {
-        room.data = updates;
-      }
-      room.updatedAt = /* @__PURE__ */ new Date();
-      room.version++;
-      broadcastEvent(roomId, "room_data_updated", {
-        roomId,
-        roomData: room,
-        timestamp: Date.now()
-      });
-      return Promise.resolve({
-        success: true
-      });
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error updating room data:`, error);
-      return Promise.reject(new Error(error.message || "Failed to update room data"));
-    }
-  },
-  getRoomData(roomId) {
-    try {
-      console.log(`[Venus Mock Rooms] Getting room ${roomId} data`);
-      const room = mockRooms.get(roomId);
-      if (!room) {
-        throw new Error("Room not found");
-      }
-      return Promise.resolve({
-        success: true,
-        data: room.data || {}
-      });
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error getting room data:`, error);
-      return Promise.reject(new Error(error.message || "Failed to get room data"));
-    }
-  },
-  sendMessage(roomId, message) {
-    try {
-      const room = mockRooms.get(roomId);
-      if (!room) {
-        return Promise.reject({ success: false, error: "Room not found" });
-      }
-      if (message.type === "chat") {
-        console.log(`[Venus Mock Rooms] Sending CHAT message to room ${roomId}:`, message);
-        const messageId = generateMessageId();
-        const messageData = {
-          id: messageId,
-          roomId,
-          senderId: message.senderId || "mock-user-chatter",
-          // H5 app should provide senderId
-          content: message.content || "",
-          type: "chat",
-          metadata: message.metadata || {},
-          timestamp: /* @__PURE__ */ new Date()
-        };
-        const messages = mockMessages.get(roomId) || [];
-        messages.push(messageData);
-        mockMessages.set(roomId, messages);
-        broadcastEvent(roomId, "message_received", { roomId, message: messageData });
-        return Promise.resolve({ success: true, messageId });
-      } else {
-        console.log(`[Venus Mock Rooms] Sending GAME ACTION/MOVE to room ${roomId} via moves subcollection:`, message);
-        const playerId = message.playerId || message.metadata?.playerId || "mock-player-action";
-        if (!playerId) ;
-        const move = {
-          playerId,
-          moveData: message.moveData || message.content || message.metadata || { type: message.type },
-          // Ensure type is captured
-          clientValidationHash: message.clientValidationHash,
-          timestamp: /* @__PURE__ */ new Date(),
-          // client-side timestamp for the move proposal
-          status: "pending_mock_processing"
-        };
-        const roomMoves = mockRoomMoves.get(roomId) || [];
-        roomMoves.push(move);
-        mockRoomMoves.set(roomId, roomMoves);
-        this._processMockMove(roomId, move, room);
-        return Promise.resolve({ success: true, moveId: "mock-move-" + Date.now() });
-      }
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error sending message/move:`, error);
-      return Promise.reject({ success: false, error: error.message || "Failed to send message/move" });
-    }
-  },
-  subscribeToRoom(roomId, options = {}) {
-    try {
-      console.log(`[Venus Mock Rooms] Subscribing to room ${roomId}:`, options);
-      const room = mockRooms.get(roomId);
-      if (!room) {
-        throw new Error("Room not found");
-      }
-      const instanceId = "mock-instance-" + Date.now();
-      if (!mockSubscriptions.has(instanceId)) {
-        mockSubscriptions.set(instanceId, /* @__PURE__ */ new Map());
-      }
-      const subscriptions = mockSubscriptions.get(instanceId);
-      subscriptions.set(roomId, {
-        onRoomDataUpdated: options.onRoomDataUpdated,
-        onMessageReceived: options.onMessageReceived,
-        onPlayerJoined: options.onPlayerJoined,
-        onPlayerLeft: options.onPlayerLeft,
-        onGameStarted: options.onGameStarted,
-        onTurnChanged: options.onTurnChanged
-      });
-      return Promise.resolve({
-        success: true,
-        unsubscribe: () => {
-          subscriptions.delete(roomId);
-          console.log(`[Venus Mock Rooms] Unsubscribed from room ${roomId}`);
-        }
-      });
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error subscribing to room:`, error);
-      return Promise.reject(new Error(error.message || "Failed to subscribe to room"));
-    }
-  },
-  listPublicRooms(gameType, limit = 20) {
-    try {
-      console.log(`[Venus Mock Rooms] Listing public rooms:`, { gameType, limit });
-      let rooms = Array.from(mockRooms.values()).filter(
-        (room) => !room.isPrivate && room.status === "active" && (!gameType || room.gameType === gameType)
-      );
-      rooms = rooms.slice(0, limit);
-      return Promise.resolve({
-        success: true,
-        rooms
-      });
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error listing public rooms:`, error);
-      return Promise.reject(new Error(error.message || "Failed to list public rooms"));
-    }
-  },
-  searchRooms(searchQuery, gameType, limit = 20) {
-    try {
-      console.log(`[Venus Mock Rooms] Searching rooms:`, { searchQuery, gameType, limit });
-      let rooms = Array.from(mockRooms.values()).filter(
-        (room) => !room.isPrivate && room.status === "active" && (!gameType || room.gameType === gameType) && (!searchQuery || room.name.toLowerCase().includes(searchQuery.toLowerCase()) || room.description?.toLowerCase().includes(searchQuery.toLowerCase()))
-      );
-      rooms = rooms.slice(0, limit);
-      return Promise.resolve({
-        success: true,
-        rooms
-      });
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error searching rooms:`, error);
-      return Promise.reject({ success: false, error: error.message || "Failed to search rooms" });
-    }
-  },
-  // Smart matchmaking - join existing room or create new one
-  joinOrCreateRoom(options = {}) {
-    try {
-      console.log(`[Venus Mock Rooms] Smart matchmaking with options:`, options);
-      const { matchCriteria = {}, createOptions = {} } = options;
-      let matchingRoom = null;
-      for (const room of mockRooms.values()) {
-        const matchesGameType = !matchCriteria.gameType || room.gameType === matchCriteria.gameType;
-        const matchesPrivacy = !matchCriteria.hasOwnProperty("isPrivate") || room.isPrivate === matchCriteria.isPrivate;
-        const hasSpace = !matchCriteria.hasSpace || room.currentPlayers.length < room.maxPlayers;
-        const isActive = room.status === "active";
-        const isWaiting = room.customMetadata?.rules?.gameState?.phase === "waiting";
-        if (matchesGameType && matchesPrivacy && hasSpace && isActive && isWaiting) {
-          matchingRoom = room;
-          console.log(`[Venus Mock Rooms] Found matching room: ${room.id}`);
-          break;
-        }
-      }
-      if (matchingRoom) {
-        console.log(`[Venus Mock Rooms] Joining existing room: ${matchingRoom.id}`);
-        const joiningPlayerId = createOptions.userId || options.userId || "mock-user-joiner";
-        const joiningPlayerDisplayName = createOptions.userDisplayName || options.userDisplayName || `Player ${joiningPlayerId.slice(-4)}`;
-        if (matchingRoom.currentPlayers.includes(joiningPlayerId)) {
-          return Promise.resolve({
-            action: "joined",
-            room: new MockVenusRoom(matchingRoom),
-            playersJoined: 0
-          });
-        }
-        matchingRoom.currentPlayers.push(joiningPlayerId);
-        matchingRoom.customMetadata.rules.gameState.playerStates[joiningPlayerId] = {
-          displayName: joiningPlayerDisplayName,
-          status: "active",
-          role: "player",
-          joinedAt: /* @__PURE__ */ new Date()
-        };
-        if (matchingRoom.customMetadata.rules.gameState.phase === "waiting" && matchingRoom.customMetadata.rules.gameState.turnOrder) {
-          if (!matchingRoom.customMetadata.rules.gameState.turnOrder.includes(joiningPlayerId)) {
-            matchingRoom.customMetadata.rules.gameState.turnOrder.push(joiningPlayerId);
-          }
-        }
-        matchingRoom.updatedAt = /* @__PURE__ */ new Date();
-        matchingRoom.version++;
-        if (matchingRoom.currentPlayers.length >= matchingRoom.maxPlayers) {
-          console.log(`[Venus Mock Rooms] Room ${matchingRoom.id} is full, auto-starting game`);
-          const gameState = matchingRoom.customMetadata.rules.gameState;
-          gameState.phase = "playing";
-          gameState.gameStartedAt = /* @__PURE__ */ new Date();
-          let turnOrder = [...matchingRoom.currentPlayers];
-          if (matchingRoom.customMetadata.rules.randomizePlayerOrder) {
-            for (let i = turnOrder.length - 1; i > 0; i--) {
-              const j = Math.floor(Math.random() * (i + 1));
-              [turnOrder[i], turnOrder[j]] = [turnOrder[j], turnOrder[i]];
-            }
-          }
-          gameState.turnOrder = turnOrder;
-          gameState.currentPlayer = turnOrder[0] || null;
-          if (matchingRoom.gameType === "chess" && turnOrder.length >= 2) {
-            gameState.playerStates[turnOrder[0]].gameRole = "white";
-            gameState.playerStates[turnOrder[1]].gameRole = "black";
-          }
-          broadcastEvent(matchingRoom.id, "game_started", {
-            roomId: matchingRoom.id,
-            gameState,
-            turnOrder: gameState.turnOrder,
-            currentPlayer: gameState.currentPlayer
-          });
-        }
-        broadcastEvent(matchingRoom.id, "player_joined", {
-          roomId: matchingRoom.id,
-          player: { id: joiningPlayerId, displayName: joiningPlayerDisplayName }
-        });
-        broadcastEvent(matchingRoom.id, "room_data_updated", {
-          roomId: matchingRoom.id,
-          roomData: matchingRoom,
-          timestamp: Date.now()
-        });
-        return Promise.resolve({
-          action: "joined",
-          room: new MockVenusRoom(matchingRoom),
-          playersJoined: 1
-        });
-      } else {
-        console.log(`[Venus Mock Rooms] No matching room found, creating new room`);
-        const roomCreationOptions = {
-          ...createOptions,
-          userId: createOptions.userId || options.userId || "mock-user-creator",
-          userDisplayName: createOptions.userDisplayName || options.userDisplayName || "Creator"
-        };
-        const createResult = this.createRoom(roomCreationOptions);
-        return createResult.then((room) => ({
-          action: "created",
-          room,
-          // createRoom already returns MockVenusRoom instance
-          playersJoined: 1
-        }));
-      }
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error in joinOrCreateRoom:`, error);
-      return Promise.reject({ success: false, error: error.message || "Failed to join or create room" });
-    }
-  },
-  joinRoomByCode(roomCode, playerMetadata = {}) {
-    try {
-      console.log(`[Venus Mock Rooms] Joining room by code ${roomCode}`);
-      let foundRoom = null;
-      for (const [roomId, room] of mockRooms.entries()) {
-        if (room.roomCode === roomCode && room.status === "active") {
-          foundRoom = room;
-          break;
-        }
-      }
-      if (!foundRoom) {
-        return Promise.reject({ success: false, error: `Room not found with code: ${roomCode}` });
-      }
-      return this.joinRoom(foundRoom.id, playerMetadata);
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error joining room by code:`, error);
-      return Promise.reject({ success: false, error: error.message || "Failed to join room by code" });
-    }
-  },
-  // Stage 2: Enhanced game features
-  startGame(roomId, gameConfig = {}, requestingUserId = "mock-admin-user") {
-    try {
-      console.log(`[Venus Mock Rooms] Starting game in room ${roomId} by ${requestingUserId}`);
-      const room = mockRooms.get(roomId);
-      if (!room) {
-        return Promise.reject({ success: false, error: "Room not found" });
-      }
-      if (!room.admins.includes(requestingUserId) && room.createdBy !== requestingUserId) {
-        return Promise.reject({ success: false, error: "Only admin or creator can start game" });
-      }
-      if (room.customMetadata.rules.gameState.phase === "playing") {
-        return Promise.reject({ success: false, error: "Game already in progress" });
-      }
-      const minPlayers = room.customMetadata.rules.minPlayers || 1;
-      if (room.currentPlayers.length < minPlayers) {
-        return Promise.reject({ success: false, error: `Not enough players. Needs ${minPlayers}` });
-      }
-      const gameState = room.customMetadata.rules.gameState;
-      gameState.phase = "playing";
-      gameState.gameStartedAt = /* @__PURE__ */ new Date();
-      let turnOrder = [...room.currentPlayers];
-      if (room.customMetadata.rules.randomizePlayerOrder) {
-        for (let i = turnOrder.length - 1; i > 0; i--) {
-          const j = Math.floor(Math.random() * (i + 1));
-          [turnOrder[i], turnOrder[j]] = [turnOrder[j], turnOrder[i]];
-        }
-      }
-      gameState.turnOrder = turnOrder;
-      gameState.currentPlayer = turnOrder[0] || null;
-      turnOrder.forEach((playerId) => {
-        if (!gameState.playerStates[playerId]) {
-          gameState.playerStates[playerId] = { displayName: `Player ${playerId.slice(-4)}`, status: "active", role: "player" };
-        } else {
-          gameState.playerStates[playerId].status = "active";
-          if (!gameState.playerStates[playerId].displayName) {
-            gameState.playerStates[playerId].displayName = `Player ${playerId.slice(-4)}`;
-          }
-        }
-      });
-      room.updatedAt = /* @__PURE__ */ new Date();
-      room.version++;
-      console.log(`[Venus Mock Rooms] Game started in room ${roomId}. New state:`, room);
-      broadcastEvent(roomId, "game_started", { roomId, gameState, turnOrder: gameState.turnOrder, currentPlayer: gameState.currentPlayer });
-      broadcastEvent(roomId, "room_data_updated", { roomId, roomData: room, timestamp: Date.now() });
-      return Promise.resolve({ success: true, ...room });
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error starting game:`, error);
-      return Promise.reject({ success: false, error: error.message || "Failed to start game" });
-    }
-  },
-  endGame(roomId, winner = null, reason = null, gameResults = {}) {
-    try {
-      console.log(`[Venus Mock Rooms] Player requesting to end game in room ${roomId}`);
-      const room = mockRooms.get(roomId);
-      if (!room) return Promise.reject({ success: false, error: "Room not found" });
-      const playerId = gameResults.endedBy || "mock-player-ender";
-      const move = {
-        playerId,
-        moveData: {
-          type: "end_game",
-          winner,
-          reason,
-          gameResults
-        },
-        timestamp: /* @__PURE__ */ new Date(),
-        status: "pending_mock_processing"
-      };
-      const roomMoves = mockRoomMoves.get(roomId) || [];
-      roomMoves.push(move);
-      mockRoomMoves.set(roomId, roomMoves);
-      this._processMockMove(roomId, move, room);
-      return Promise.resolve({ success: true, moveId: "mock-move-" + Date.now() });
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error ending game:`, error);
-      return Promise.reject({ success: false, error: error.message || "Failed to end game" });
-    }
-  },
-  // NEW: Propose move (client-proposed state architecture)
-  proposeMove(roomId, proposalPayload, proposerId = "mock-proposer") {
-    try {
-      console.log(`[Venus Mock Rooms] Player ${proposerId} proposing move in room ${roomId}:`, proposalPayload);
-      const room = mockRooms.get(roomId);
-      if (!room) return Promise.reject({ success: false, error: "Room not found" });
-      const proposedMoveId = `prop_move_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
-      const proposedMove = {
-        id: proposedMoveId,
-        proposerProfileId: proposerId,
-        timestamp: /* @__PURE__ */ new Date(),
-        gameSpecificState: proposalPayload.gameSpecificState,
-        moveType: proposalPayload.moveType,
-        clientContext: proposalPayload.clientContext,
-        clientProposalId: proposalPayload.clientProposalId,
-        serverGenericValidationStatus: "pending",
-        serverCustomValidationStatus: "pending",
-        clientConsensusStatus: "pending",
-        ...proposalPayload.resignedBy && { resignedBy: proposalPayload.resignedBy },
-        ...proposalPayload.winner && { winner: proposalPayload.winner }
-      };
-      if (!mockRoomMoves.has(roomId + "_proposed")) {
-        mockRoomMoves.set(roomId + "_proposed", []);
-      }
-      mockRoomMoves.get(roomId + "_proposed").push(proposedMove);
-      if (proposalPayload.gameSpecificState) {
-        room.optimisticGameState = proposalPayload.gameSpecificState;
-        room.lastProposedMoveId = proposedMoveId;
-        room.lastProposedMoveBy = proposerId;
-        room.lastProposedMoveAt = /* @__PURE__ */ new Date();
-        room.updatedAt = /* @__PURE__ */ new Date();
-        room.version++;
-      }
-      setTimeout(() => {
-        this._processMockProposedMove(roomId, proposedMoveId, proposedMove, room);
-      }, 100);
-      broadcastEvent(roomId, "room_data_updated", {
-        roomId,
-        roomData: room,
-        timestamp: Date.now()
-      });
-      if (proposalPayload.gameSpecificState) {
-        broadcastEvent(roomId, "app:h5:optimisticGameStateUpdated", {
-          roomId,
-          optimisticGameState: proposalPayload.gameSpecificState
-        });
-      }
-      return Promise.resolve({
-        success: true,
-        proposedMoveId,
-        optimisticGameState: proposalPayload.gameSpecificState
-      });
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error proposing move:`, error);
-      return Promise.reject({ success: false, error: error.message || "Failed to propose move" });
-    }
-  },
-  // NEW internal helper to simulate server-side move processing for mock API
-  _processMockMove(roomId, move, room) {
-    console.log("[Venus Mock Rooms] Simulating server processing for move:", move);
-    move.id = "processed-mock-move-" + Date.now();
-    setTimeout(() => {
-      const currentRoomState = mockRooms.get(roomId);
-      if (!currentRoomState) return;
-      const { rules, gameState } = currentRoomState.customMetadata;
-      const { playerId, moveData } = move;
-      let isValidMove = true;
-      let validationError = null;
-      if (rules.turnBased && gameState.currentPlayer !== playerId) {
-        isValidMove = false;
-        validationError = "Not current player's turn.";
-        console.warn(`[Venus Mock Rooms] Invalid move by ${playerId}: Not their turn. Current: ${gameState.currentPlayer}`);
-      }
-      const moveType = moveData?.type;
-      if (isValidMove && moveType && rules.allowedMessageTypes?.[gameState.phase]?.[moveType]) {
-        const ruleForMoveType = rules.allowedMessageTypes[gameState.phase][moveType];
-        if (ruleForMoveType.requiredFields) {
-          for (const field of ruleForMoveType.requiredFields) {
-            if (!(field in moveData)) {
-              isValidMove = false;
-              validationError = `Missing required field: ${field} for move type ${moveType}.`;
-              console.warn(`[Venus Mock Rooms] Invalid move by ${playerId}: ${validationError}`);
-              break;
-            }
-          }
-        }
-      } else if (isValidMove && moveType && !rules.allowedMessageTypes?.[gameState.phase]?.[moveType]) {
-        console.warn(`[Venus Mock Rooms] Move type "${moveType}" not defined in allowedMessageTypes for phase "${gameState.phase}". Processing by default.`);
-      }
-      if (isValidMove) {
-        console.log("[Venus Mock Rooms] Move considered valid by mock server. Updating game state.");
-        move.status = "mock_valid";
-        gameState.lastMoveBy = playerId;
-        gameState.lastMoveTimestamp = /* @__PURE__ */ new Date();
-        if (moveData.type === "end_game") {
-          gameState.phase = "ended";
-          gameState.endedAt = /* @__PURE__ */ new Date();
-          currentRoomState.status = "archived";
-          console.log("[Venus Mock Rooms] Mock: Game ended.");
-        } else if (moveData.type === "force_update_state") {
-          Object.assign(gameState, moveData.payload);
-          console.log("[Venus Mock Rooms] Mock: Game state forcibly updated with:", moveData.payload);
-        }
-        const nonTurnAdvancingMoves = ["end_game", "force_update_state"];
-        if (rules.turnBased && gameState.turnOrder && gameState.turnOrder.length > 0 && !nonTurnAdvancingMoves.includes(moveData.type)) {
-          const currentPlayerIndex = gameState.turnOrder.indexOf(gameState.currentPlayer || "");
-          if (currentPlayerIndex !== -1) {
-            const nextPlayerIndex = (currentPlayerIndex + 1) % gameState.turnOrder.length;
-            gameState.currentPlayer = gameState.turnOrder[nextPlayerIndex];
-            gameState.turnCount = (gameState.turnCount || 0) + 1;
-            console.log(`[Venus Mock Rooms] Mock: Turn advanced to ${gameState.currentPlayer}`);
-            broadcastEvent(roomId, "turn_changed", {
-              roomId,
-              currentPlayer: gameState.currentPlayer,
-              previousPlayer: playerId,
-              // The one who just moved
-              turnCount: gameState.turnCount
-            });
-          }
-        }
-        currentRoomState.updatedAt = /* @__PURE__ */ new Date();
-        currentRoomState.version++;
-        broadcastEvent(roomId, "room_data_updated", { roomId, roomData: currentRoomState, timestamp: Date.now() });
-      } else {
-        console.warn("[Venus Mock Rooms] Move considered invalid by mock server. No game state change.", { validationError });
-        move.status = "mock_invalid";
-        move.error = validationError;
-      }
-      console.log("[Venus Mock Rooms] Finished mock processing for move:", move);
-    }, 100);
-  },
-  // NEW: Process proposed move for mock API
-  _processMockProposedMove(roomId, proposedMoveId, proposedMove, room) {
-    console.log("[Venus Mock Rooms] Simulating server processing for proposed move:", proposedMoveId);
-    const { rules, gameState } = room.customMetadata;
-    const { proposerProfileId, gameSpecificState, moveType } = proposedMove;
-    let isGenericValid = true;
-    let genericValidationReason = "";
-    if (moveType === "resignation") {
-      const resignedBy = proposedMove.resignedBy || gameSpecificState?.resignedBy;
-      if (!resignedBy) {
-        isGenericValid = false;
-        genericValidationReason = "Security violation: Resignation move must specify who is resigning (resignedBy field required).";
-      } else if (resignedBy !== proposerProfileId) {
-        isGenericValid = false;
-        genericValidationReason = `Security violation: Player ${proposerProfileId} cannot resign on behalf of player ${resignedBy}. Players can only resign themselves.`;
-      } else if (!gameState.playerStates || !gameState.playerStates[proposerProfileId]) {
-        isGenericValid = false;
-        genericValidationReason = `Security violation: Player ${proposerProfileId} is not in this game and cannot resign.`;
-      } else {
-        console.log(`[Venus Mock Rooms] \u2705 Resignation move validated: ${proposerProfileId} is resigning themselves`);
-      }
-    } else {
-      if (rules.turnBased && gameState.currentPlayer !== proposerProfileId) {
-        isGenericValid = false;
-        genericValidationReason = `Not player's turn. Current: ${gameState.currentPlayer}`;
-      }
-    }
-    if (isGenericValid && moveType && rules.allowedMessageTypes?.[gameState.phase]?.[moveType]) {
-      const ruleForMoveType = rules.allowedMessageTypes[gameState.phase][moveType];
-      if (ruleForMoveType.requiredFields) {
-        for (const field of ruleForMoveType.requiredFields) {
-          const hasField = moveType === "resignation" ? proposedMove[field] !== void 0 || gameSpecificState[field] !== void 0 : gameSpecificState[field] !== void 0;
-          if (!hasField) {
-            isGenericValid = false;
-            genericValidationReason = `Missing required field: ${field}`;
-            break;
-          }
-        }
-      }
-    }
-    proposedMove.serverGenericValidationStatus = isGenericValid ? "valid" : "invalid";
-    proposedMove.serverGenericValidationReason = genericValidationReason;
-    proposedMove.serverCustomValidationStatus = "not_applicable";
-    proposedMove.clientConsensusStatus = "valid";
-    if (isGenericValid) {
-      Object.assign(gameState, gameSpecificState);
-      if (gameSpecificState.isGameOver === true) {
-        gameState.phase = "ended";
-        gameState.winner = gameSpecificState.winner || null;
-        gameState.endReason = gameSpecificState.gameStatus || "completed";
-        gameState.endedAt = /* @__PURE__ */ new Date();
-        gameState.currentPlayer = null;
-        console.log(`[Venus Mock Rooms] \u{1F3C1} Game ended in room ${roomId}: ${gameState.endReason}, winner: ${gameState.winner || "draw"}`);
-      } else {
-        if (rules.turnBased && gameState.turnOrder && gameState.turnOrder.length > 0) {
-          const currentPlayerIndex = gameState.turnOrder.indexOf(gameState.currentPlayer || "");
-          if (currentPlayerIndex !== -1) {
-            const nextPlayerIndex = (currentPlayerIndex + 1) % gameState.turnOrder.length;
-            gameState.currentPlayer = gameState.turnOrder[nextPlayerIndex];
-            gameState.turnCount = (gameState.turnCount || 0) + 1;
-          }
-        }
-      }
-      gameState.lastMoveBy = proposerProfileId;
-      gameState.lastMoveTimestamp = /* @__PURE__ */ new Date();
-      room.updatedAt = /* @__PURE__ */ new Date();
-      room.version++;
-      console.log(`[Venus Mock Rooms] Proposed move ${proposedMoveId} validated and applied`);
-    } else {
-      console.log(`[Venus Mock Rooms] Proposed move ${proposedMoveId} validation failed: ${genericValidationReason}`);
-    }
-    broadcastEvent(roomId, "app:h5:proposedMoveValidationUpdated", {
-      roomId,
-      proposedMoveId,
-      proposedMoveData: proposedMove
-    });
-    if (isGenericValid) {
-      broadcastEvent(roomId, "room_data_updated", {
-        roomId,
-        roomData: room,
-        timestamp: Date.now()
-      });
-    }
-  },
-  getUserRooms(appId, includeArchived = false) {
-    try {
-      console.log(`[Venus Mock Rooms] Getting user rooms:`, { appId, includeArchived });
-      const userId = "mock-user";
-      let rooms = Array.from(mockRooms.values()).filter(
-        (room) => room.currentPlayers.includes(userId) && (!appId || room.appId === appId) && (includeArchived || room.status === "active")
-      );
-      rooms.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
-      return Promise.resolve({
-        success: true,
-        rooms
-      });
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error getting user rooms:`, error);
-      return Promise.reject(new Error(error.message || "Failed to get user rooms"));
-    }
-  },
-  getGameState(roomId) {
-    try {
-      console.log(`[Venus Mock Rooms] Getting game state for room ${roomId}`);
-      const room = mockRooms.get(roomId);
-      if (!room) {
-        return Promise.reject({ success: false, error: "Room not found" });
-      }
-      const gameState = room.customMetadata?.rules?.gameState || {};
-      return Promise.resolve({
-        success: true,
-        data: gameState
-        // Return the authoritative game state from the mock room
-      });
-    } catch (error) {
-      console.error(`[Venus Mock Rooms] Error getting game state:`, error);
-      return Promise.reject({ success: false, error: error.message || "Failed to get game state" });
-    }
-  }
-};
-function initializeRooms(venusApiInstance, mockData = null) {
-  if (mockData && Array.isArray(mockData.rooms)) {
-    mockData.rooms.forEach((room) => {
-      mockRooms.set(room.id, room);
-      mockMessages.set(room.id, []);
-      mockPlayers.set(room.id, room.currentPlayers.map((playerId) => ({
-        id: playerId,
-        roomId: room.id,
-        joinedAt: /* @__PURE__ */ new Date(),
-        lastActive: /* @__PURE__ */ new Date(),
-        status: "active",
-        customData: {},
-        role: playerId === room.createdBy ? "owner" : "member"
-      })));
-    });
-  }
-  venusApiInstance.rooms = createProxiedObject.call(venusApiInstance, "rooms", roomsMock);
-  venusApiInstance.getUserRooms = createProxiedMethod("getUserRooms", roomsMock.getUserRooms);
-  venusApiInstance.createRoom = createProxiedMethod("createRoom", roomsMock.createRoom);
-  venusApiInstance.joinRoom = createProxiedMethod("joinRoom", roomsMock.joinRoom);
-  venusApiInstance.joinOrCreateRoom = createProxiedMethod("joinOrCreateRoom", roomsMock.joinOrCreateRoom);
-  venusApiInstance.joinRoomByCode = createProxiedMethod("joinRoomByCode", roomsMock.joinRoomByCode);
-  venusApiInstance.listPublicRooms = createProxiedMethod("listPublicRooms", roomsMock.listPublicRooms);
-  venusApiInstance.searchRooms = createProxiedMethod("searchRooms", roomsMock.searchRooms);
-  venusApiInstance.subscribeToRoom = createProxiedMethod("subscribeToRoom", roomsMock.subscribeToRoom);
-  venusApiInstance.isRoomSystemEnabled = function() {
-    return true;
-  };
-}
-
-// src/venus-api/systems/asset-loader.js
-var VenusAssetLoader = class {
-  constructor() {
-    this.cache = /* @__PURE__ */ new Map();
-    this.blobUrls = /* @__PURE__ */ new Map();
-    this.isWebView = false;
-    this.venusAPI = null;
-  }
-  // Set the VenusAPI reference during initialization
-  setVenusAPI(api) {
-    this.venusAPI = api;
-    this.isWebView = !api.isWeb || !api.isWeb();
-  }
-  /**
-   * Load any asset with automatic optimization
-   * @param {string} url - Asset URL
-   * @param {Object} options - Loading options
-   * @returns {Promise<string>} - URL to use (original, blob, or object URL)
-   */
-  async loadAsset(url, options = {}) {
-    const {
-      type = "auto",
-      // 'image', 'audio', 'video', 'text', 'json', 'auto'
-      cache = true,
-      // Use cache
-      timeout = 3e4,
-      isOptional = false
-      // New option to suppress error logging for optional assets
-    } = options;
-    const resolvedUrl = this.venusAPI && this.venusAPI.resolveAssetUrl ? this.venusAPI.resolveAssetUrl(url) : this._resolveAssetUrl(url);
-    if (cache && this.cache.has(resolvedUrl)) {
-      return this.cache.get(resolvedUrl);
-    }
-    const assetType = type === "auto" ? this._detectType(resolvedUrl) : type;
-    try {
-      let resultUrl = resolvedUrl;
-      if (assetType === "text" || assetType === "json") {
-        const content = await this._fetchText(resolvedUrl, timeout);
-        this.cache.set(resolvedUrl, content);
-        return content;
-      }
-      const isMockMode = this.venusAPI && this.venusAPI.isMock && this.venusAPI.isMock();
-      if (this.isWebView && !isMockMode && ["image", "audio", "video"].includes(assetType)) {
-        if (assetType === "video") {
-          resultUrl = await this._loadAsBlob(resolvedUrl, assetType);
-          if (cache) {
-            this.cache.set(resolvedUrl, resultUrl);
-          }
-          return resultUrl;
-        } else if (assetType === "audio") {
-          resultUrl = await this._loadAsBlob(resolvedUrl, assetType);
-        } else {
-          resultUrl = await this._loadAsBlob(resolvedUrl, assetType);
-        }
-      }
-      if (!(this.isWebView && !isMockMode && assetType === "video")) {
-        await this._verifyAsset(resultUrl, assetType);
-      }
-      if (cache) {
-        this.cache.set(resolvedUrl, resultUrl);
+      if (cache) {
+        this.cache.set(resolvedUrl, resultUrl);
       }
       return resultUrl;
     } catch (error) {
@@ -4635,34 +3976,272 @@ function initializeIap(venusApiInstance, host) {
   venusApiInstance.iap = host.iap;
 }
 
-// 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"
+// 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 {
-      id: "mock_profile_123",
-      name: "Mock User",
-      username: "mockuser"
+      accepted: true,
+      rank: inserted?.rank ?? null
     };
   }
-};
-
-// src/profile/MockProfileApi.ts
-var MockProfileApi = class {
-  getCurrentProfile() {
+  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 {
-      id: "mock_profile_123",
-      name: "Mock User",
-      username: "mockuser"
+      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/profile/HostProfileApi.ts
+var HostProfileApi = class {
+  getCurrentProfile() {
+    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: profile.id,
+      username: profile.username,
+      avatarUrl: profile.avatarUrl,
+      isAnonymous: profile.isAnonymous
+    };
+  }
+};
+
+// src/profile/MockProfileApi.ts
+var MockProfileApi = class {
+  getCurrentProfile() {
+    return {
+      id: "mock_profile_123",
+      name: "Mock User",
+      username: "mockuser",
+      isAnonymous: false
+    };
+  }
+};
 
 // src/profile/index.ts
 function initializeProfile(venusApi, host) {
@@ -4921,14 +4500,6 @@ var MockPostApi = class {
       commentsCount: 0
     };
   }
-  async sharePostAsync(context) {
-    console.log("[Venus Mock] Sharing post with additionalInfo:", context);
-    await createMockDelay(MOCK_DELAYS.short);
-    return {
-      shared: true,
-      platform: "mock"
-    };
-  }
   async toggleFollowAsync() {
     const venusApi = this.venusApi;
     console.log("[Venus Mock] *Toggling follow status");
@@ -4973,11 +4544,6 @@ var RpcPostApi = class {
   openCommentsAsync() {
     return this.rpcClient.call("H5_OPEN_COMMENTS" /* OPEN_COMMENTS */, {});
   }
-  sharePostAsync(context) {
-    return this.rpcClient.call("H5_SHARE_POST" /* SHARE_POST */, {
-      shareContext: context
-    });
-  }
   toggleFollowAsync() {
     return this.rpcClient.call(
       "H5_TOGGLE_FOLLOW" /* TOGGLE_FOLLOW */,
@@ -5000,9 +4566,6 @@ function initializePost(venusApi, host) {
   venusApi.toggleLikeAsync = () => {
     return host.post.toggleLikeAsync();
   };
-  venusApi.sharePostAsync = async (options) => {
-    await host.post.sharePostAsync(options);
-  };
   venusApi.openCommentsAsync = async () => {
     await host.post.openCommentsAsync();
   };
@@ -5097,59 +4660,73 @@ function initializeFeaturesApi(venusApi, 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();
     }
@@ -5162,52 +4739,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/simulation/utils.ts
@@ -6072,41 +5623,8 @@ function initializeSimulation(venusApi, host) {
   };
 }
 
-// src/rooms/MockRoomsApi.ts
-var MockRoomsApi = class {
-  constructor() {
-    // Mock room storage to simulate real-time rooms in development
-    __publicField(this, "mockRooms", /* @__PURE__ */ new Map());
-    __publicField(this, "mockMessages", /* @__PURE__ */ new Map());
-    // roomId -> messages[]
-    __publicField(this, "mockRoomMoves", /* @__PURE__ */ new Map());
-    // roomId -> moves[]
-    __publicField(this, "mockSubscriptions", /* @__PURE__ */ new Map());
-  }
-  join(roomId) {
-    throw new Error("Method not implemented.");
-  }
-  // instanceId -> subscriptions
-  createRoom(options) {
-    return Promise.resolve(void 0);
-  }
-  generateRoomId() {
-    return "room_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-  }
-  // Helper to generate message IDs
-  generateMessageId() {
-    return "msg_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-  }
-  // Helper to generate room codes
-  generateRoomCode() {
-    const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-    let code = "";
-    for (let i = 0; i < 6; i++) {
-      code += characters.charAt(Math.floor(Math.random() * characters.length));
-    }
-    return code;
-  }
-};
+// src/MockHost.ts
+init_rooms();
 
 // src/logging/MockLoggingApi.ts
 var MockLoggingApi = class {
@@ -6252,7 +5770,121 @@ var MockSharedAssetsApi = class {
   }
 };
 
+// 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/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");
@@ -6276,6 +5908,9 @@ var MockHost = class {
     __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);
@@ -6305,18 +5940,24 @@ var MockHost = class {
     this.features = new MockFeaturesApi();
     this.lifecycle = this._mockLifecyclesApi;
     this.simulation = new MockSimulationApi();
-    this.rooms = new MockRoomsApi();
+    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() {
+  initialize(options) {
     this._isInitialized = true;
-    return Promise.resolve();
+    return Promise.resolve({
+      initializeAsleep: false
+    });
   }
   updateUiControls() {
     const controls = {
@@ -6387,27 +6028,87 @@ var MockHost = class {
     };
   }
   async handleMenuButtonClicked() {
-    this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
-    const sleepAwakeToggleAction = {
+    if (this.state === 0 /* PLAYING */) {
+      this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
+      this.state = 1 /* PAUSED */;
+    }
+    const actionSheetItems = [];
+    const awakeAction = {
       label: "\u23F0 Awake",
-      id: "sleepAwakeToggle"
+      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 */) {
-      sleepAwakeToggleAction.label = "\u{1F4A4} Sleep";
-    }
-    const action = await this.showActionSheetOverlay([sleepAwakeToggleAction]);
-    if (action === sleepAwakeToggleAction.id) {
-      if (this.state === 1 /* PAUSED */) {
-        this.state = 2 /* SLEEPING */;
-        this.triggerLifecycleEvent("HIDDEN" /* HIDDEN */);
-      } else {
-        this.state = 1 /* PAUSED */;
-        this.triggerLifecycleEvent("SHOWN" /* SHOWN */);
-      }
+      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 {
-      if (this.state === 1 /* PAUSED */) {
-        this.triggerLifecycleEvent("RESUME" /* RESUME */);
-      }
+      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) {
@@ -6538,28 +6239,16 @@ var MockHost = class {
   }
   triggerLifecycleEvent(name) {
     console.log("Trigger Lifecycle Event: ", name);
-    if (name == "PLAY" /* PLAY */) {
-      this._mockLifecyclesApi.triggerOnPlayCallbacks({
-        hudInsets: { top: 60, right: 0, bottom: 0, left: 0 },
-        // shareData: {
-        //   title: 'Mock Share Title',
-        //   description: 'Mock share description for testing',
-        // },
-        format: "post"
-        // stackData: null,
-      });
-    } else if (name == "PAUSE" /* PAUSE */) {
-      this._mockLifecyclesApi.triggerOnPauseCallbacks();
+    if (name == "PAUSE" /* PAUSE */) {
+      this._mockLifecyclesApi.triggerPauseCallbacks();
     } else if (name == "RESUME" /* RESUME */) {
-      this._mockLifecyclesApi.triggerOnResumeCallbacks();
+      this._mockLifecyclesApi.triggerResumeCallbacks();
     } else if (name == "QUIT" /* QUIT */) {
-      this._mockLifecyclesApi.triggerOnQuitCallbacks();
-    } else if (name == "SHOWN" /* SHOWN */) {
-      this._mockLifecyclesApi.triggerOnShowCallbacks({
-        hudInsets: { top: 60, bottom: 120, left: 0, right: 0 }
-      });
-    } else if (name == "HIDDEN" /* HIDDEN */) {
-      this._mockLifecyclesApi.triggerOnHideCallbacks();
+      this._mockLifecyclesApi.triggerQuitCallbacks();
+    } else if (name == "AWAKE" /* AWAKE */) {
+      this._mockLifecyclesApi.triggerAwakeCallbacks();
+    } else if (name == "SLEEP" /* SLEEP */) {
+      this._mockLifecyclesApi.triggerSleepCallbacks();
     }
   }
   setOverlayElementVisibility(element, visible) {
@@ -6862,7 +6551,7 @@ var VenusTransport = class {
         return;
       }
       this.notifyVenusMessageReceived(message);
-      if (message.type === "PLAY" /* PLAY */ || message.type === "PAUSE" /* PAUSE */ || message.type === "RESUME" /* RESUME */ || message.type === "SHOWN" /* SHOWN */ || message.type === "HIDDEN" /* HIDDEN */ || message.type === "CLEANUP" /* CLEANUP */ || message.type === "QUIT" /* QUIT */) {
+      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,
@@ -7044,177 +6733,49 @@ var VenusTransport = class {
   }
 };
 
-// src/notifications/RpcNotificationsApi.ts
-var RpcNotificationsApi = class {
+// 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;
-  }
-  async scheduleLocalNotification(title, body, options) {
-    const request = {
-      title,
-      body,
-      data: options?.payload,
-      key: options?.groupId,
-      priority: options?.priority || 1,
-      trigger: options?.trigger ?? null
+    this.subscriptions = {
+      data: {},
+      messages: {},
+      gameEvents: {},
+      allEvents: {}
     };
-    const response = await this.rpcClient.call(
-      "H5_SCHEDULE_LOCAL_NOTIFICATION" /* SCHEDULE_LOCAL_NOTIFICATION */,
-      request
-    );
-    if (response.scheduled) {
-      return response.id;
-    }
-    return null;
-  }
-  async cancelLocalNotification(id) {
-    const result = await this.rpcClient.call(
-      "H5_CANCEL_LOCAL_NOTIFICATION" /* CANCEL_LOCAL_NOTIFICATION */,
-      {
-        id
-      }
-    );
-    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;
+  /**
+   * Get the subscription state for external access (used by setupRoomNotifications)
+   */
+  getSubscriptions() {
+    return this.subscriptions;
   }
-  async setLocalNotificationsEnabled(enabled) {
-    const response = await this.rpcClient.call(
-      "H5_SET_LOCAL_NOTIFICATIONS_ENABLED" /* SET_LOCAL_NOTIFICATIONS_ENABLED */,
-      {
-        enabled
-      }
+  /**
+   * Set up room notification routing from the transport
+   */
+  setupNotifications(transport) {
+    const { setupRoomNotifications: setupRoomNotifications2 } = (init_rooms(), __toCommonJS(rooms_exports));
+    this.transportSubscription = setupRoomNotifications2(
+      transport,
+      () => this.getSubscriptions()
     );
-    return response.enabled;
   }
-};
-
-// src/rooms/VenusRoom.ts
-var 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
-      });
-    }
-  }
-  // NEW: Generic message handler for room-manager.js integration
-  onMessage(callback) {
-    const subscriptionId = "messages_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-    if (!window.venus._roomSubscriptions.allEvents) {
-      window.venus._roomSubscriptions.allEvents = {};
-    }
-    if (!window.venus._roomSubscriptions.allEvents[this.id]) {
-      window.venus._roomSubscriptions.allEvents[this.id] = [];
+  /**
+   * Clean up subscriptions and resources
+   */
+  dispose() {
+    if (this.transportSubscription) {
+      this.transportSubscription.unsubscribe();
+      this.transportSubscription = null;
+      console.log("[Venus Rooms] Cleaned up room notification subscription");
     }
-    window.venus._roomSubscriptions.allEvents[this.id].push(callback);
-    this._subscriptions.set(subscriptionId, {
-      type: "allEvents",
-      callback
-    });
-    return {
-      unsubscribe: () => {
-        const callbacks = window.venus._roomSubscriptions.allEvents[this.id] || [];
-        const index = callbacks.indexOf(callback);
-        if (index > -1) callbacks.splice(index, 1);
-        this._subscriptions.delete(subscriptionId);
-      }
-    };
-  }
-};
-
-// src/rooms/RpcRoomsApi.ts
-var RpcRoomsApi = class {
-  constructor(rpcClient) {
-    __publicField(this, "rpcClient");
-    __publicField(this, "isRoomSystemEnabled", function() {
-      return true;
-    });
-    this.rpcClient = rpcClient;
-  }
-  join(roomId) {
-    throw new Error("Method not implemented.");
   }
   async createRoom(options) {
     const response = await this.rpcClient.call(
@@ -7248,33 +6809,6 @@ var RpcRoomsApi = class {
       playersJoined: data.playersJoined
     };
   }
-  async listPublicRooms(gameType, limit = 20) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_LIST_PUBLIC" /* H5_ROOM_LIST_PUBLIC */,
-      {
-        gameType,
-        limit
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to list public rooms");
-    }
-    return response.rooms || [];
-  }
-  async searchRooms(searchQuery, gameType, limit = 20) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_SEARCH" /* H5_ROOM_SEARCH */,
-      {
-        searchQuery,
-        gameType,
-        limit
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to search rooms");
-    }
-    return response.rooms || [];
-  }
   async joinRoomByCode(roomCode) {
     const response = await this.rpcClient.call(
       "H5_ROOM_JOIN_BY_CODE" /* H5_ROOM_JOIN_BY_CODE */,
@@ -7282,7 +6816,7 @@ var RpcRoomsApi = class {
         roomCode
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to join room by code");
     }
     const roomData = response.roomData || response;
@@ -7290,15 +6824,14 @@ var RpcRoomsApi = class {
     return room;
   }
   // Get user's rooms with optional filtering
-  async getUserRooms(appId, includeArchived = false) {
+  async getUserRooms(includeArchived = false) {
     const response = await this.rpcClient.call(
       "H5_ROOM_GET_USER_ROOMS" /* H5_ROOM_GET_USER_ROOMS */,
       {
-        appId,
-        includePersonal: includeArchived
+        includeArchived
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to get user rooms");
     }
     const rawRooms = response.rooms || [];
@@ -7321,62 +6854,6 @@ var RpcRoomsApi = class {
     }
     return venusRooms;
   }
-  // Convenience method for common use case
-  quickMatch(gameType) {
-    return this.joinOrCreateRoom({
-      matchCriteria: {
-        gameType,
-        isPrivate: false,
-        hasSpace: true
-      },
-      createOptions: {
-        name: gameType + " Game",
-        gameType,
-        isPrivate: false,
-        maxPlayers: 4
-        // sensible default
-      }
-    });
-  }
-  // Enhanced room creation with game rules
-  async createGameRoom(options) {
-    const enhancedOptions = {
-      ...options,
-      customMetadata: {
-        ...options.customMetadata,
-        rules: {
-          ruleEngine: options.ruleEngine || "basic",
-          validateMessages: options.validateMessages || false,
-          randomizePlayerOrder: options.randomizePlayerOrder || false,
-          clientValidation: options.clientValidation || false,
-          allowedMessageTypes: options.allowedMessageTypes || {},
-          gameState: {
-            phase: "waiting",
-            currentPlayer: null,
-            turnOrder: [],
-            playerStates: {},
-            ...options.initialGameState
-          },
-          ...options.rules
-        }
-      }
-    };
-    return this.createRoom(enhancedOptions);
-  }
-  // Convenience method for subscribing to all game events
-  subscribeToGameEvents(roomId, callback) {
-    if (!window.venus._roomSubscriptions.gameEvents[roomId]) {
-      window.venus._roomSubscriptions.gameEvents[roomId] = [];
-    }
-    window.venus._roomSubscriptions.gameEvents[roomId].push(callback);
-    return {
-      unsubscribe: () => {
-        const callbacks = window.venus._roomSubscriptions.gameEvents[roomId] || [];
-        const index = callbacks.indexOf(callback);
-        if (index > -1) callbacks.splice(index, 1);
-      }
-    };
-  }
   async updateData(room, updates, merge = true) {
     const response = await this.rpcClient.call(
       "H5_ROOM_UPDATE_DATA" /* H5_ROOM_UPDATE_DATA */,
@@ -7386,7 +6863,7 @@ var RpcRoomsApi = class {
         merge
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to update room data");
     }
     return response.data;
@@ -7398,7 +6875,7 @@ var RpcRoomsApi = class {
         roomId: room.id
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to get room data");
     }
     return response.data;
@@ -7411,7 +6888,7 @@ var RpcRoomsApi = class {
         message: messageData
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to send message");
     }
     return response.messageId;
@@ -7423,7 +6900,7 @@ var RpcRoomsApi = class {
         roomId: room.id
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to leave room");
     }
     return response;
@@ -7437,7 +6914,7 @@ var RpcRoomsApi = class {
         turnOrder
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to start game");
     }
     return response.data;
@@ -7453,7 +6930,7 @@ var RpcRoomsApi = class {
         clientProposalId: proposalPayload.clientProposalId
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to propose move");
     }
     return response.data;
@@ -7464,20 +6941,20 @@ var RpcRoomsApi = class {
   }
   async roomSubscribeToGameEvents(room, callback) {
     "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-    if (!window.venus._roomSubscriptions.gameEvents[room.id]) {
-      window.venus._roomSubscriptions.gameEvents[room.id] = [];
+    if (!this.subscriptions.gameEvents[room.id]) {
+      this.subscriptions.gameEvents[room.id] = [];
     }
-    window.venus._roomSubscriptions.gameEvents[room.id].push(callback);
+    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 (!window.venus._roomSubscriptions.data[roomId]) {
-        window.venus._roomSubscriptions.data[roomId] = [];
+      if (!this.subscriptions.data[roomId]) {
+        this.subscriptions.data[roomId] = [];
       }
-      window.venus._roomSubscriptions.data[roomId].push(options.onData);
+      this.subscriptions.data[roomId].push(options.onData);
       subscriptionIds.push({
         type: "data",
         id: dataSubId,
@@ -7486,10 +6963,10 @@ var RpcRoomsApi = class {
     }
     if (options.onMessages) {
       const msgSubId = "messages_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-      if (!window.venus._roomSubscriptions.messages[roomId]) {
-        window.venus._roomSubscriptions.messages[roomId] = [];
+      if (!this.subscriptions.messages[roomId]) {
+        this.subscriptions.messages[roomId] = [];
       }
-      window.venus._roomSubscriptions.messages[roomId].push(options.onMessages);
+      this.subscriptions.messages[roomId].push(options.onMessages);
       subscriptionIds.push({
         type: "messages",
         id: msgSubId,
@@ -7498,18 +6975,20 @@ var RpcRoomsApi = class {
     }
     if (options.onMoves || options.onGameEvents) {
       const handler = options.onMoves || options.onGameEvents;
-      const gameSubId = "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-      if (!window.venus._roomSubscriptions.gameEvents[roomId]) {
-        window.venus._roomSubscriptions.gameEvents[roomId] = [];
+      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
+        });
       }
-      window.venus._roomSubscriptions.gameEvents[roomId].push(handler);
-      subscriptionIds.push({
-        type: "gameEvents",
-        id: gameSubId,
-        callback: handler
-      });
     }
-    const needsSubscription = subscriptionIds.length > 0 && (!window.venus._roomSubscriptions.data[roomId] || window.venus._roomSubscriptions.data[roomId].length <= 1) && (!window.venus._roomSubscriptions.messages[roomId] || window.venus._roomSubscriptions.messages[roomId].length <= 1) && (!window.venus._roomSubscriptions.gameEvents[roomId] || window.venus._roomSubscriptions.gameEvents[roomId].length <= 1);
+    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,
@@ -7525,11 +7004,12 @@ var RpcRoomsApi = class {
       if (called) return;
       called = true;
       subscriptionIds.forEach((sub) => {
-        const callbacks = window.venus._roomSubscriptions[sub.type][roomId] || [];
+        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 = (!window.venus._roomSubscriptions.data[roomId] || window.venus._roomSubscriptions.data[roomId].length === 0) && (!window.venus._roomSubscriptions.messages[roomId] || window.venus._roomSubscriptions.messages[roomId].length === 0) && (!window.venus._roomSubscriptions.gameEvents[roomId] || window.venus._roomSubscriptions.gameEvents[roomId].length === 0);
+      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
@@ -7541,6 +7021,36 @@ var RpcRoomsApi = class {
   }
 };
 
+// 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/";
@@ -7568,6 +7078,9 @@ var RemoteHost = class {
     __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);
@@ -7622,97 +7135,62 @@ var RemoteHost = class {
     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() {
+  async initialize(options) {
     this.log("Initializing Remote Host...");
     const transport = new VenusTransport();
     transport.start();
     this.rpcClient.start(transport);
-    try {
-      this.log("Trying to initialize using NEW method...");
-      transport.instanceId = await this.initNew();
-    } catch (error) {
-      this.log(`Failed to initialize using NEW method: ${error}`);
-      this.log(`Trying to initialize using OLD method...`);
-      transport.instanceId = await this.initOld(transport);
-    }
-    this.log(`Remote Host Initialized with id: ${transport.instanceId}`);
-    this._isInitialized = true;
-    this.venusApi._bootstrap.apiInjected = true;
-    this.venusApi._bootstrap.venus = window.venus;
-    await this.rpcClient.call("READY" /* READY */, {});
-  }
-  registerIFrame(transport) {
-    return new Promise((resolve, reject) => {
-      this.log("Registering IFrame...");
-      const location = window.location;
-      const pathName = location.pathname;
-      const tokens = pathName.split("/");
-      const appId = tokens[2];
-      console.log("[Venus SDK] App ID ", appId);
-      const registrationMessage = {
-        type: "H5_IFRAME_REGISTER",
-        instanceId: appId,
-        direction: "H5_TO_APP",
-        timestamp: Date.now()
-      };
-      const subscription = transport.onVenusMessage((message) => {
-        if (message.type == "INJECT_VENUS_API_SCRIPT") {
-          const scriptContent = message.data?.script;
-          if (!scriptContent) {
-            throw new Error("Failed to inject venus api, no script found.");
-          }
-          const script = document.createElement("script");
-          script.type = "text/javascript";
-          script.textContent = scriptContent;
-          document.head.appendChild(script);
-          setTimeout(() => {
-            if (window.venus) {
-              subscription.unsubscribe();
-              resolve(window.venus?._config?.instanceId);
-            }
-          }, 100);
-        }
-      });
-      transport.sendVenusMessage(registrationMessage);
-      setTimeout(() => {
-        subscription.unsubscribe();
-        reject();
-      }, 1e3);
-    });
-  }
-  async initNew() {
+    const roomsApi = this.rooms;
+    roomsApi.setupNotifications(transport);
     const response = await this.rpcClient.call(
       "INITIALIZE_SDK" /* INIT_SDK */,
       {},
-      1e3
+      5e3
     );
-    return response.instanceId;
-  }
-  async initOld(transport) {
-    const isInIframe = window.self !== window.top;
-    const hasReactNativeWebView = typeof window.ReactNativeWebView !== "undefined";
-    if (hasReactNativeWebView) {
-      return this.useInjectedId();
-    } else if (isInIframe) {
-      return await this.registerIFrame(transport);
-    } else {
-      throw new Error("Failed to initialize. Unknown Error");
+    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;
+        }
+      }
     }
-  }
-  useInjectedId() {
-    const instanceId = window.venus?._config?.instanceId || window._venusInitState?.poolId;
-    this.log(`On mobile, using injected instanceId: ${instanceId}`);
-    if (!instanceId) {
-      throw new Error("Expected injected instanceId on mobile");
+    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 instanceId;
+    return {
+      hudInsets,
+      initializeAsleep: response.initializeAsleep
+    };
   }
   log(message) {
     console.log(`[Venus SDK] [Remote Host] ${message}`);
@@ -7730,8 +7208,19 @@ function createHost(venusApi, isMock) {
   }
 }
 
+// src/venus-api/index.js
+init_rooms();
+
 // src/version.ts
-var SDK_VERSION = "2.4.1";
+var SDK_VERSION = "3.0.0";
+
+// src/social/index.ts
+function initializeSocial(venusApi, host) {
+  venusApi.social = host.social;
+  venusApi.getLaunchParams = () => {
+    return venusApi.launchParams || {};
+  };
+}
 
 // src/venus-api/index.js
 var HapticStyle = {
@@ -7848,12 +7337,7 @@ var VenusAPI2 = class {
       // Static locale data at top level
       locale: "en-US",
       languageCode: "en",
-      // Static profile data (renamed from currentProfile)
-      profile: {
-        id: "mock-profile-123",
-        username: "MockProfile",
-        avatarUrl: "https://i.pravatar.cc/150?u=mock"
-      },
+      // Note: Profile is now separate from config and accessed via getCurrentProfile()
       // Complete environment info (matching buildStaticConfig)
       environment: {
         isDevelopment: true,
@@ -7920,14 +7404,11 @@ var VenusAPI2 = class {
       }
     };
     this._detectHostedEnvironment();
+    this.launchParams = {};
     this.config = createProxiedObject.call(this, "config", {
       locale: "en-US",
       languageCode: "en",
-      profile: {
-        id: "mock-user-123",
-        username: "Test User",
-        avatarUrl: null
-      },
+      // Note: Profile is no longer in config - use getCurrentProfile() instead
       environment: {
         isDevelopment: true,
         platform: typeof navigator !== "undefined" ? navigator.platform : "unknown",
@@ -8041,12 +7522,15 @@ var VenusAPI2 = class {
     const host = createHost(this, !isInsideHostedEnv);
     this.host = host;
     initializeStorage(this, host);
+    initializeRoomsApi(this, host);
     initializeAds(this, host);
     initializeTheme(this);
     initializePopups(this, host);
     initializeAnalytics(this, host);
     initializeIap(this, host);
+    initializeLeaderboard(this, host);
     initializeLocalNotifications(this, host);
+    initializePreloader(this, host);
     initializeTime(this, host);
     initializeLifecycleApi(this, host);
     initializeHaptics(this, host);
@@ -8061,8 +7545,8 @@ var VenusAPI2 = class {
     initializeStackNavigation(this, host);
     initializePost(this, host);
     initializeAi(this, host);
-    initializeRooms(this);
     initializeSimulation(this, host);
+    initializeSocial(this, host);
     initializeAssetLoader(this, createProxiedMethod);
   }
   // Generate deterministic instance ID based on current page URL
@@ -8117,97 +7601,31 @@ var VenusAPI2 = class {
       this.config.languageCode = this._mock.localeOverride.split("-")[0];
     }
     if (this._mock.roomsData) {
-      initializeRooms(this, this._mock.roomsData);
+      console.warn(
+        "[Venus Mock] Rooms mock data is no longer supported. Rooms functionality requires the Venus host environment."
+      );
     }
   }
   //---------------------------------------
   // PUBLIC API METHODS
   //---------------------------------------
-  async initializeAsync(options = {}) {
+  async initializeAsync(options) {
     if (this._shared.initialized) {
       return Promise.resolve(true);
     }
     if (this._shared.initPromise) {
       return this._shared.initPromise;
     }
-    this._shared.initPromise = new Promise(async (resolve) => {
+    this._shared.initPromise = new Promise(async (resolve, reject) => {
       try {
-        if (options) {
-          const supportedRootParams = [
-            "hardDisableMock",
-            "mock",
-            "helpText",
-            "forceRemoteCdn"
-          ];
-          const supportedMockParams = [
-            "initDelay",
-            "isMobile",
-            "isWeb",
-            "locale",
-            "rooms",
-            "craftingConfig",
-            "onShowContext",
-            "onHideContext"
-          ];
-          Object.keys(options).forEach((param) => {
-            if (!supportedRootParams.includes(param)) {
-              this.log(`Unsupported parameter: ${param}`);
-            }
-          });
-          if (options.mockData && typeof options.mockData === "object") {
-            console.warn(
-              "[Venus Mock] mockData is deprecated, use options.mock instead"
-            );
-            options.mock = { ...options.mock, ...options.mockData };
-          }
-          if (options.mock && typeof options.mock === "object") {
-            Object.keys(options.mock).forEach((param) => {
-              if (!supportedMockParams.includes(param)) {
-                this.log(`Unsupported mock parameter: ${param}`);
-              }
-            });
-          }
-          if (options.helpText && typeof options.helpText === "string") {
-            this._mock.helpText = options.helpText;
-          }
-          if (typeof options.forceRemoteCdn === "boolean") {
-            this._mock.forceRemoteCdn = options.forceRemoteCdn;
-            console.log(
-              "[Venus Mock] Force remote CDN mode:",
-              options.forceRemoteCdn
-            );
-          }
-        }
-        await this.host.initialize();
-        if (this._bootstrap.isInsideHostedEnvironment) {
-          this._shared.initialized = true;
-          resolve(true);
-          return;
+        const result = await this.host.initialize(options);
+        this._shared.initialized = true;
+        if (!options.usePreloader) {
+          this.host.preloader.hideLoadScreen();
         }
-        const mockDelay = options.mock?.initDelay ?? 100;
-        this.log(`Using mock initialization delay: ${mockDelay}ms`);
-        setTimeout(async () => {
-          this._shared.initialized = true;
-          this._initializeMockMode();
-          resolve(true);
-        }, mockDelay);
+        resolve(result);
       } catch (err) {
-        console.warn(
-          "[Venus Bootstrap] Initialization error, falling back to mock mode",
-          err
-        );
-        if (options.hardDisableMock) {
-          console.warn(
-            "[Venus Bootstrap] hardDisableMock is true, not using mock."
-          );
-          resolve(false);
-          return;
-        }
-        this._initializeMockMode();
-        setTimeout(async () => {
-          this._shared.initialized = true;
-          resolve(true);
-        }, 100);
+        reject(err);
       }
     });
     return this._shared.initPromise;