@series-inc/venus-sdk 2.4.1 → 2.6.2

package/dist/venus-api/index.mjs

@@ -1,5 +1,5 @@
-import { SDK_VERSION, initializeStorage, initializeAds, initializePopups, initializeAnalytics, initializeIap, initializeLocalNotifications, initializeTime, initializeLifecycleApi, initializeHaptics, initializeCdn, initializeFeaturesApi, initializeLoggingApi, initializeProfile, initializeAvatar3d, initializeStackNavigation, initializeAi, initializeSimulation, MockAdsApi, MockLifecycleApi, MockAnalyticsApi, createMockStorageApi, MockAvatarApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockProfileApi, MockCdnApi, MockTimeApi, MockAiApi, MockHapticsApi, MockFeaturesApi, MockSimulationApi, MockLoggingApi, MockIapApi, MockSharedAssetsApi, RpcClient, RpcAdsApi, RpcAnalyticsApi, RpcStorageApi, RpcAvatarApi, RpcNavigationApi, RpcPopupsApi, HostProfileApi, HostCdnApi, HostTimeApi, RpcAiApi, RpcHapticsApi, RpcFeaturesApi, RpcLifecycleApi, RpcSimulationApi, RpcLoggingApi, RpcIapApi, RpcSharedAssetsApi } from '../chunk-KQZIPQLJ.mjs';
-import { createProxiedObject, createProxiedMethod, __publicField, createMockDelay, MOCK_DELAYS } from '../chunk-MWUS3A7C.mjs';
+import { init_rooms, init_VenusRoom, SDK_VERSION, initializeStorage, initializeRoomsApi, initializeAds, initializePopups, initializeAnalytics, initializeIap, initializeLocalNotifications, initializePreloader, initializeTime, initializeLifecycleApi, initializeHaptics, initializeCdn, initializeFeaturesApi, initializeLoggingApi, initializeProfile, initializeAvatar3d, initializeStackNavigation, initializeAi, initializeSimulation, MockAdsApi, MockLifecycleApi, MockAnalyticsApi, createMockStorageApi, MockAvatarApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockProfileApi, MockCdnApi, MockTimeApi, MockAiApi, MockHapticsApi, MockFeaturesApi, MockSimulationApi, MockLoggingApi, MockIapApi, MockPreloaderApi, MockSharedAssetsApi, RpcClient, RpcAdsApi, RpcAnalyticsApi, RpcStorageApi, RpcAvatarApi, RpcNavigationApi, RpcNotificationsApi, RpcPopupsApi, HostProfileApi, HostCdnApi, HostTimeApi, RpcAiApi, RpcHapticsApi, RpcFeaturesApi, RpcLifecycleApi, RpcSimulationApi, RpcLoggingApi, RpcIapApi, RpcPreloaderApi, RpcSharedAssetsApi, rooms_exports, VenusRoom } from '../chunk-YDXFZ2A2.mjs';
+import { createProxiedObject, createProxiedMethod, __publicField, createMockDelay, MOCK_DELAYS, __toCommonJS } from '../chunk-W7IPHM67.mjs';
 
 // src/venus-api/systems/theme.js
 var DEFAULT_TYPOGRAPHY = {
@@ -184,941 +184,6 @@ function initializeTheme(venusApiInstance) {
   venusApiInstance.DEFAULT_TYPOGRAPHY = DEFAULT_TYPOGRAPHY;
 }
 
-// src/venus-api/systems/rooms.js
-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
-    });
-  }
-  // 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
-    });
-  }
-  // 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());
-    }
-    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 = {}) {
-    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
-          }
-        },
-        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";
-        } 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);
-        }
-      }
-      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 (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() {
@@ -2869,7 +1934,7 @@ function createNumbersAPI() {
   return numbersAPI;
 }
 async function initializeNumbers(venusApiInstance) {
-  const { createProxiedObject: createProxiedObject2, createProxiedMethod: createProxiedMethod2 } = await import('../core-RDMPQV6U.mjs');
+  const { createProxiedObject: createProxiedObject2, createProxiedMethod: createProxiedMethod2 } = await import('../core-R3FHW62G.mjs');
   const numbersAPI = createNumbersAPI();
   venusApiInstance.numbers = createProxiedObject2.call(
     venusApiInstance,
@@ -2995,43 +2060,50 @@ function initializePost(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();
+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");
@@ -3055,6 +2127,7 @@ var MockHost = class {
     __publicField(this, "rooms");
     __publicField(this, "logging");
     __publicField(this, "iap");
+    __publicField(this, "preloader");
     __publicField(this, "state", 0 /* PLAYING */);
     __publicField(this, "venusApi");
     __publicField(this, "_isInitialized", false);
@@ -3084,18 +2157,19 @@ 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();
+    initializeRoomsApi(this.venusApi, this);
+    this.preloader = new MockPreloaderApi();
     venusApi.isMock = () => true;
     this.venusApi.sharedAssets = new MockSharedAssetsApi(this.venusApi);
   }
   get isInitialized() {
     return this._isInitialized;
   }
-  initialize() {
+  async initialize(options = {}) {
     this._isInitialized = true;
-    return Promise.resolve();
   }
   updateUiControls() {
     const controls = {
@@ -3720,177 +2794,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 } = (init_rooms(), __toCommonJS(rooms_exports));
+    this.transportSubscription = setupRoomNotifications(
+      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(
@@ -3924,33 +2870,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 */,
@@ -3958,7 +2877,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;
@@ -3966,15 +2885,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 || [];
@@ -3997,62 +2915,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 */,
@@ -4062,7 +2924,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;
@@ -4074,7 +2936,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;
@@ -4087,7 +2949,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;
@@ -4099,7 +2961,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;
@@ -4113,7 +2975,7 @@ var RpcRoomsApi = class {
         turnOrder
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to start game");
     }
     return response.data;
@@ -4129,7 +2991,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;
@@ -4140,20 +3002,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,
@@ -4162,10 +3024,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,
@@ -4174,18 +3036,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,
@@ -4201,11 +3065,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
@@ -4244,6 +3109,7 @@ var RemoteHost = class {
     __publicField(this, "rooms");
     __publicField(this, "logging");
     __publicField(this, "iap");
+    __publicField(this, "preloader");
     __publicField(this, "venusApi");
     __publicField(this, "rpcClient");
     __publicField(this, "_isInitialized", false);
@@ -4298,18 +3164,22 @@ var RemoteHost = class {
     this.rooms = new RpcRoomsApi(rpcClient);
     this.logging = new RpcLoggingApi(this, rpcClient);
     this.iap = new RpcIapApi(rpcClient);
+    this.preloader = new RpcPreloaderApi(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);
+    const roomsApi = this.rooms;
+    roomsApi.setupNotifications(transport);
     try {
       this.log("Trying to initialize using NEW method...");
       transport.instanceId = await this.initNew();
@@ -4369,6 +3239,26 @@ var RemoteHost = class {
       {},
       1e3
     );
+    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;
+        }
+      }
+    }
     return response.instanceId;
   }
   async initOld(transport) {
@@ -4407,6 +3297,7 @@ function createHost(venusApi, isMock) {
 }
 
 // src/venus-api/index.js
+init_rooms();
 var HapticStyle = {
   LIGHT: "light",
   MEDIUM: "medium",
@@ -4521,12 +3412,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,
@@ -4596,11 +3482,7 @@ var VenusAPI2 = class {
     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",
@@ -4714,12 +3596,14 @@ 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);
     initializeLocalNotifications(this, host);
+    initializePreloader(this, host);
     initializeTime(this, host);
     initializeLifecycleApi(this, host);
     initializeHaptics(this, host);
@@ -4734,7 +3618,6 @@ var VenusAPI2 = class {
     initializeStackNavigation(this, host);
     initializePost(this, host);
     initializeAi(this, host);
-    initializeRooms(this);
     initializeSimulation(this, host);
     initializeAssetLoader(this, createProxiedMethod);
   }
@@ -4790,7 +3673,9 @@ 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."
+      );
     }
   }
   //---------------------------------------
@@ -4810,7 +3695,8 @@ var VenusAPI2 = class {
             "hardDisableMock",
             "mock",
             "helpText",
-            "forceRemoteCdn"
+            "forceRemoteCdn",
+            "usePreloader"
           ];
           const supportedMockParams = [
             "initDelay",
@@ -4851,7 +3737,10 @@ var VenusAPI2 = class {
             );
           }
         }
-        await this.host.initialize();
+        await this.host.initialize(options);
+        if (!options.usePreloader) {
+          await this.host.preloader.hideLoadScreen();
+        }
         if (this._bootstrap.isInsideHostedEnvironment) {
           this._shared.initialized = true;
           resolve(true);