@series-inc/venus-sdk 2.4.1 → 3.0.0

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, SDK_VERSION, createHost, initializeStorage, initializeRoomsApi, initializeAds, initializePopups, initializeAnalytics, initializeIap, initializeLeaderboard, initializeLocalNotifications, initializePreloader, initializeTime, initializeLifecycleApi, initializeHaptics, initializeCdn, initializeFeaturesApi, initializeLoggingApi, initializeProfile, initializeAvatar3d, initializeStackNavigation, initializePost, initializeAi, initializeSimulation, initializeSocial } from '../chunk-6DYG4RFQ.mjs';
+import { createProxiedObject, createProxiedMethod } 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,
@@ -2890,1532 +1955,17 @@ async function initializeNumbers(venusApiInstance) {
   );
 }
 
-// src/post/MockPostApi.ts
-var MockPostApi = class {
-  constructor(venusApi) {
-    __publicField(this, "venusApi");
-    this.venusApi = venusApi;
-  }
-  async getPostInfo() {
-    const venusApi = this.venusApi;
-    await createMockDelay(MOCK_DELAYS.short);
-    return venusApi._mock.currentPostInteractions;
-  }
-  async openCommentsAsync() {
-    await createMockDelay(MOCK_DELAYS.short);
-    return {
-      opened: true,
-      commentsCount: 0
-    };
-  }
-  async 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");
-    await createMockDelay(MOCK_DELAYS.short);
-    venusApi._mock.currentPostInteractions.isFollowing = !venusApi._mock.currentPostInteractions.isFollowing;
-    const isFollowing = venusApi._mock.currentPostInteractions.isFollowing;
-    return {
-      isFollowing,
-      action: isFollowing ? "followed" : "unfollowed"
-    };
-  }
-  async toggleLikeAsync() {
-    const venusApi = this.venusApi;
-    await createMockDelay(MOCK_DELAYS.short);
-    venusApi._mock.currentPostInteractions.isLiked = !venusApi._mock.currentPostInteractions.isLiked;
-    const isLiked = venusApi._mock.currentPostInteractions.isLiked;
-    if (isLiked) {
-      venusApi._mock.currentPostInteractions.likesCount++;
-    } else {
-      venusApi._mock.currentPostInteractions.likesCount = Math.max(
-        0,
-        venusApi._mock.currentPostInteractions.likesCount - 1
-      );
-    }
-    return {
-      isLiked,
-      likesCount: venusApi._mock.currentPostInteractions.likesCount,
-      action: isLiked ? "liked" : "unliked"
-    };
-  }
-};
-
-// src/post/RpcPostApi.ts
-var RpcPostApi = class {
-  constructor(rpcClient) {
-    __publicField(this, "rpcClient");
-    this.rpcClient = rpcClient;
-  }
-  getPostInfo() {
-    return this.rpcClient.call("H5_GET_POST_INTERACTIONS" /* GET_POST_INTERACTIONS */, {});
-  }
-  openCommentsAsync() {
-    return this.rpcClient.call("H5_OPEN_COMMENTS" /* OPEN_COMMENTS */, {});
-  }
-  sharePostAsync(context) {
-    return this.rpcClient.call("H5_SHARE_POST" /* SHARE_POST */, {
-      shareContext: context
-    });
-  }
-  toggleFollowAsync() {
-    return this.rpcClient.call(
-      "H5_TOGGLE_FOLLOW" /* TOGGLE_FOLLOW */,
-      {}
-    );
-  }
-  toggleLikeAsync() {
-    return this.rpcClient.call("H5_TOGGLE_LIKE" /* TOGGLE_LIKE */, {});
-  }
+// src/venus-api/index.js
+init_rooms();
+var HapticStyle = {
+  LIGHT: "light",
+  MEDIUM: "medium",
+  HEAVY: "heavy",
+  SUCCESS: "success",
+  WARNING: "warning",
+  ERROR: "error"
 };
-
-// src/post/index.ts
-function initializePost(venusApi, host) {
-  venusApi.getPostInteractionsAsync = () => {
-    return host.post.getPostInfo();
-  };
-  venusApi.toggleFollowAsync = () => {
-    return host.post.toggleFollowAsync();
-  };
-  venusApi.toggleLikeAsync = () => {
-    return host.post.toggleLikeAsync();
-  };
-  venusApi.sharePostAsync = async (options) => {
-    await host.post.sharePostAsync(options);
-  };
-  venusApi.openCommentsAsync = async () => {
-    await host.post.openCommentsAsync();
-  };
-}
-
-// 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
-var MockHost = class {
-  constructor(venusApi) {
-    __publicField(this, "ads");
-    __publicField(this, "analytics");
-    __publicField(this, "deviceCache");
-    __publicField(this, "appStorage");
-    __publicField(this, "globalStorage");
-    __publicField(this, "avatar3d");
-    __publicField(this, "navigation");
-    __publicField(this, "notifications");
-    __publicField(this, "popups");
-    __publicField(this, "profile");
-    __publicField(this, "cdn");
-    __publicField(this, "time");
-    __publicField(this, "post");
-    __publicField(this, "ai");
-    __publicField(this, "haptics");
-    __publicField(this, "features");
-    __publicField(this, "lifecycle");
-    __publicField(this, "simulation");
-    __publicField(this, "rooms");
-    __publicField(this, "logging");
-    __publicField(this, "iap");
-    __publicField(this, "state", 0 /* PLAYING */);
-    __publicField(this, "venusApi");
-    __publicField(this, "_isInitialized", false);
-    __publicField(this, "_overlay");
-    __publicField(this, "_mockLifecyclesApi");
-    __publicField(this, "_mockAdsApi");
-    this.venusApi = venusApi;
-    this._overlay = this.createOverlay();
-    this._mockAdsApi = new MockAdsApi(this._overlay);
-    this._mockLifecyclesApi = new MockLifecycleApi();
-    this.ads = this._mockAdsApi;
-    this.analytics = new MockAnalyticsApi();
-    const appUrl = typeof window !== "undefined" ? window.location.href : "";
-    this.deviceCache = createMockStorageApi("deviceCache", appUrl);
-    this.appStorage = createMockStorageApi("appStorage", appUrl);
-    this.globalStorage = createMockStorageApi("globalStorage");
-    this.avatar3d = new MockAvatarApi(venusApi);
-    this.navigation = new MockNavigationApi(venusApi);
-    this.notifications = new MockNotificationsApi(venusApi);
-    this.popups = new MockPopupsApi(this._overlay);
-    this.profile = new MockProfileApi();
-    this.cdn = new MockCdnApi();
-    this.time = new MockTimeApi(venusApi);
-    this.post = new MockPostApi(venusApi);
-    this.ai = new MockAiApi();
-    this.haptics = new MockHapticsApi(venusApi);
-    this.features = new MockFeaturesApi();
-    this.lifecycle = this._mockLifecyclesApi;
-    this.simulation = new MockSimulationApi();
-    this.rooms = new MockRoomsApi();
-    this.logging = new MockLoggingApi();
-    this.iap = new MockIapApi();
-    venusApi.isMock = () => true;
-    this.venusApi.sharedAssets = new MockSharedAssetsApi(this.venusApi);
-  }
-  get isInitialized() {
-    return this._isInitialized;
-  }
-  initialize() {
-    this._isInitialized = true;
-    return Promise.resolve();
-  }
-  updateUiControls() {
-    const controls = {
-      closeButton: { x: 16, y: 16, width: 32, height: 32 },
-      menuButton: {
-        x: window.innerWidth - 48,
-        y: 16,
-        width: 32,
-        height: 32
-      },
-      feedHeader: { x: 0, y: 0, width: window.innerWidth, height: 56 },
-      playButton: {
-        x: 0,
-        y: window.innerHeight - 60,
-        width: window.innerWidth,
-        height: 60
-      }
-    };
-    return controls;
-  }
-  createOverlay() {
-    const venusApi = this.venusApi;
-    venusApi.config.ui.controls = this.updateUiControls();
-    const uiControls = venusApi.config.ui.controls;
-    const overlayContainer = document.createElement("div");
-    overlayContainer.id = "venus-mock-overlay";
-    overlayContainer.style.cssText = `
-      position: fixed;
-      top: 0;
-      left: 0;
-      width: 100%;
-      height: 100%;
-      pointer-events: none;
-      z-index: 10000;
-    `;
-    document.body.appendChild(overlayContainer);
-    const menuButton = this.createOverlayButton(
-      "close",
-      "Menu",
-      uiControls.menuButton,
-      () => {
-        this.handleMenuButtonClicked();
-      },
-      "rgba(59, 130, 246, 0.7)",
-      // Blue background instead of black
-      "#FFFFFF"
-    );
-    overlayContainer.appendChild(menuButton);
-    const adOverlay = this.setupAdOverlay();
-    const actionSheet = this.setupActionSheetOverlay();
-    window.addEventListener("resize", () => {
-      this.updateOverlayLayout();
-    });
-    return {
-      container: overlayContainer,
-      elements: {
-        menuButton
-      },
-      appVisibilityState: "visible",
-      actionSheetOverlay: actionSheet,
-      adOverlay,
-      showAdOverlay: () => {
-        return this.showAdOverlay("REWARDED VIDEO AD");
-      },
-      showActionSheet: (items, options) => {
-        return this.showActionSheetOverlay(items, options);
-      }
-    };
-  }
-  async handleMenuButtonClicked() {
-    this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
-    const sleepAwakeToggleAction = {
-      label: "\u23F0 Awake",
-      id: "sleepAwakeToggle"
-    };
-    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 */);
-      }
-    } else {
-      if (this.state === 1 /* PAUSED */) {
-        this.triggerLifecycleEvent("RESUME" /* RESUME */);
-      }
-    }
-  }
-  async showAdOverlay(type) {
-    return new Promise((resolve, reject) => {
-      const overlay = this._overlay;
-      const adOverlay = overlay.adOverlay;
-      overlay.adOverlay.innerHTML = "";
-      const heading = document.createElement("h1");
-      heading.style.cssText = `
-        font-size: 24px;
-        margin-bottom: 20px;
-        text-align: center;
-      `;
-      heading.innerText = type === "interstitial" ? "INTERSTITIAL AD" : "REWARDED VIDEO AD";
-      overlay.adOverlay.appendChild(heading);
-      const content = document.createElement("div");
-      content.style.cssText = `
-        width: 300px;
-        height: 250px;
-        background-color: #1e40af;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        margin-bottom: 20px;
-        border-radius: 8px;
-      `;
-      content.innerText = "Mock Ad Content";
-      adOverlay.appendChild(content);
-      const timer = document.createElement("p");
-      timer.style.cssText = `
-        margin-bottom: 20px;
-        font-size: 16px;
-      `;
-      timer.innerText = "Normally ads would have a timer...";
-      adOverlay.appendChild(timer);
-      const okButton = document.createElement("button");
-      okButton.style.cssText = `
-        padding: 10px 40px;
-        background-color: #2563eb;
-        color: white;
-        border: none;
-        border-radius: 4px;
-        font-size: 16px;
-        cursor: pointer;
-      `;
-      okButton.innerText = "Close Ad";
-      adOverlay.appendChild(okButton);
-      adOverlay.style.display = "flex";
-      okButton.onclick = () => {
-        this.hideAdOverlay();
-        resolve(true);
-      };
-    });
-  }
-  hideAdOverlay() {
-    const overlay = this._overlay;
-    if (overlay.adOverlay) {
-      overlay.adOverlay.style.display = "none";
-    }
-  }
-  setupActionSheetOverlay() {
-    const actionSheetOverlay = document.createElement("div");
-    actionSheetOverlay.id = "venus-action-sheet-overlay";
-    actionSheetOverlay.style.cssText = `
-        position: fixed;
-        top: 0;
-        left: 0;
-        width: 100%;
-        height: 100%;
-        background-color: rgba(0, 0, 0, 0.5);
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        z-index: 10600;
-        font-family: sans-serif;
-        display: none;
-      `;
-    document.body.appendChild(actionSheetOverlay);
-    return actionSheetOverlay;
-  }
-  createOverlayButton(id, text, position, onClick, background, color) {
-    const button = document.createElement("button");
-    button.id = `venus-mock-${id}-button`;
-    button.innerText = text;
-    button.style.cssText = `
-      position: absolute;
-      left: ${position.x}px;
-      top: ${position.y}px;
-      width: ${position.width}px;
-      min-width: ${position.width}px;
-      height: ${position.height}px;
-      background: ${background};
-      color: ${color};
-      border: none;
-      border-radius: 8px;
-      font-family: sans-serif;
-      font-weight: bold;
-      font-size: ${Math.min(position.width, position.height) / 3}px;
-      cursor: pointer;
-      pointer-events: auto;
-      display: flex;
-      align-items: center;
-      justify-content: center;
-      opacity: 0.9;
-      transition: opacity 0.2s;
-    `;
-    button.addEventListener("click", onClick);
-    button.addEventListener("mouseover", () => {
-      button.style.opacity = "1";
-    });
-    button.addEventListener("mouseout", () => {
-      button.style.opacity = "0.9";
-    });
-    return button;
-  }
-  updateOverlayLayout() {
-    const venusApi = this.venusApi;
-    const overlay = this._overlay;
-    venusApi.config.ui.controls = this.updateUiControls();
-    const uiControls = venusApi.config.ui.controls;
-    const menuBtn = overlay.elements.menuButton;
-    const menuPos = uiControls.menuButton;
-    menuBtn.style.left = `${menuPos.x}px`;
-    menuBtn.style.top = `${menuPos.y}px`;
-    menuBtn.style.width = `${menuPos.width}px`;
-    menuBtn.style.minWidth = `${menuPos.width}px`;
-    menuBtn.style.height = `${menuPos.height}px`;
-  }
-  triggerLifecycleEvent(name) {
-    console.log("Trigger Lifecycle Event: ", name);
-    if (name == "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();
-    } else if (name == "RESUME" /* RESUME */) {
-      this._mockLifecyclesApi.triggerOnResumeCallbacks();
-    } 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();
-    }
-  }
-  setOverlayElementVisibility(element, visible) {
-    const overlay = this._overlay;
-    const elements = overlay.elements;
-    if (elements[element]) {
-      elements[element].style.display = visible ? "flex" : "none";
-    }
-  }
-  setupAdOverlay() {
-    const adOverlay = document.createElement("div");
-    adOverlay.id = "venus-ad-overlay";
-    adOverlay.style.cssText = `
-        position: fixed;
-        top: 0;
-        left: 0;
-        width: 100%;
-        height: 100%;
-        background-color: rgba(37, 99, 235, 0.9);
-        color: white;
-        display: flex;
-        flex-direction: column;
-        align-items: center;
-        justify-content: center;
-        z-index: 10500;
-        font-family: sans-serif;
-        display: none;
-      `;
-    document.body.appendChild(adOverlay);
-    return adOverlay;
-  }
-  log(msg, ...args) {
-    console.log(`[Venus Mock] ${msg}`, ...args);
-  }
-  showActionSheetOverlay(items, options) {
-    this.log("Showing ActionSheetOverlay...");
-    return new Promise((resolve, reject) => {
-      const overlay = this._overlay;
-      overlay.actionSheetOverlay.innerHTML = "";
-      overlay.actionSheetOverlay.style.display = "flex";
-      const actionSheet = document.createElement("div");
-      actionSheet.className = "venus-action-sheet";
-      actionSheet.style.cssText = `
-        background-color: white;
-        border-radius: 8px;
-        width: 80%;
-        max-width: 400px;
-        max-height: 80%;
-        display: flex;
-        flex-direction: column;
-        overflow: hidden;
-        color: black;
-      `;
-      if (options?.title) {
-        const titleContainer = document.createElement("div");
-        titleContainer.style.cssText = `
-          padding: 16px;
-          border-bottom: 1px solid #eaeaea;
-          font-weight: bold;
-          font-size: 18px;
-          text-align: center;
-          color: black;
-        `;
-        titleContainer.innerText = options.title;
-        actionSheet.appendChild(titleContainer);
-      }
-      if (options?.message) {
-        const messageContainer = document.createElement("div");
-        messageContainer.style.cssText = `
-          padding: 8px 16px;
-          color: #666;
-          font-size: 14px;
-          text-align: center;
-        `;
-        messageContainer.innerText = options.message;
-        actionSheet.appendChild(messageContainer);
-      }
-      const optionsContainer = document.createElement("div");
-      optionsContainer.style.cssText = `
-        overflow-y: auto;
-        max-height: 300px;
-      `;
-      items.forEach((item, index) => {
-        const optionItem = document.createElement("div");
-        optionItem.style.cssText = `
-          padding: 12px 16px;
-          border-bottom: 1px solid #eaeaea;
-          cursor: pointer;
-          display: flex;
-          align-items: center;
-          transition: background-color 0.2s;
-          color: black;
-        `;
-        optionItem.addEventListener("mouseover", () => {
-          optionItem.style.backgroundColor = "#f5f5f5";
-        });
-        optionItem.addEventListener("mouseout", () => {
-          optionItem.style.backgroundColor = "white";
-        });
-        if (item.icon) {
-          const iconSpan = document.createElement("span");
-          iconSpan.style.cssText = `
-          margin-right: 12px;
-          font-size: 16px;
-        `;
-          iconSpan.innerText = item.icon;
-          optionItem.appendChild(iconSpan);
-        }
-        const labelSpan = document.createElement("span");
-        labelSpan.style.cssText = `
-        color: black;
-      `;
-        labelSpan.innerText = item.label;
-        optionItem.appendChild(labelSpan);
-        optionItem.addEventListener("click", () => {
-          this.hideActionSheetOverlay();
-          const optionId = item.id !== void 0 ? item.id : index;
-          resolve(optionId);
-        });
-        optionsContainer.appendChild(optionItem);
-      });
-      actionSheet.appendChild(optionsContainer);
-      if (!options?.disableCancel) {
-        const cancelButton = document.createElement("div");
-        cancelButton.style.cssText = `
-        padding: 14px 16px;
-        text-align: center;
-        font-weight: bold;
-        cursor: pointer;
-        color: #3b82f6;
-        border-top: 1px solid #eaeaea;
-      `;
-        cancelButton.innerText = options?.cancelButtonText || "Cancel";
-        cancelButton.addEventListener("click", () => {
-          this.hideActionSheetOverlay();
-          resolve(null);
-        });
-        actionSheet.appendChild(cancelButton);
-      }
-      if (!options?.disableCancel) {
-        const closeButton = document.createElement("div");
-        closeButton.style.cssText = `
-          position: absolute;
-          top: 8px;
-          right: 8px;
-          width: 24px;
-          height: 24px;
-          border-radius: 12px;
-          background-color: rgba(0,0,0,0.1);
-          color: #666;
-          display: flex;
-          align-items: center;
-          justify-content: center;
-          cursor: pointer;
-          font-size: 14px;
-        `;
-        closeButton.innerText = "\u2715";
-        closeButton.addEventListener("click", () => {
-          this.hideActionSheetOverlay();
-          resolve(null);
-        });
-        actionSheet.appendChild(closeButton);
-        overlay.actionSheetOverlay.appendChild(actionSheet);
-      }
-    });
-  }
-  hideActionSheetOverlay() {
-    const overlay = this._overlay;
-    if (overlay.actionSheetOverlay) {
-      overlay.actionSheetOverlay.style.display = "none";
-    }
-  }
-};
-
-// src/VenusTransport.ts
-var VenusTransport = class {
-  constructor() {
-    __publicField(this, "messageHandler");
-    __publicField(this, "onNotificationCallbacks", []);
-    __publicField(this, "onNotificationCallbacksToRemove", []);
-    __publicField(this, "onVenusMessageCallbacks", []);
-    __publicField(this, "onResponseCallbacks", []);
-    __publicField(this, "onResponseCallbacksToRemove", []);
-    __publicField(this, "_instanceId", null);
-    __publicField(this, "isStarted", false);
-    __publicField(this, "isProcessingMessage", false);
-    this.messageHandler = async (event) => {
-      this.isProcessingMessage = true;
-      let message;
-      if (typeof event.data === "string") {
-        message = JSON.parse(event.data);
-      } else {
-        message = event.data;
-      }
-      if (!message) {
-        this.logInfo("No message found. Ignoring message...");
-        return;
-      }
-      this.notifyVenusMessageReceived(message);
-      if (message.type === "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 */) {
-        const notification = {
-          type: "rpc-notification",
-          id: message.type,
-          payload: message.data
-        };
-        this.handleNotification(notification);
-        this.isProcessingMessage = false;
-        return;
-      }
-      const messageData = message.data;
-      if (!messageData) {
-        this.logWarn("No data found. Ignoring message...");
-        this.isProcessingMessage = false;
-        return;
-      }
-      const requestId = messageData.requestId;
-      if (!requestId) {
-        this.logWarn("No requestId. Ignoring message...");
-        this.isProcessingMessage = false;
-        return;
-      }
-      if (message.type !== "H5_RESPONSE" /* H5_RESPONSE */) {
-        this.logWarn(`Ignoring unknown message type: ${message.type}`);
-        this.isProcessingMessage = false;
-        return;
-      }
-      const success = messageData.success;
-      let error = void 0;
-      if (!success) {
-        error = {
-          message: messageData.error || "Unknown error"
-        };
-      }
-      let result = messageData.value;
-      if (result === void 0) {
-        result = messageData.data;
-      }
-      const response = {
-        type: "rpc-response",
-        id: requestId,
-        result,
-        method: message.type,
-        error
-      };
-      await this.handleResponse(response);
-      this.isProcessingMessage = false;
-    };
-  }
-  onNotification(callback) {
-    this.onNotificationCallbacks.push(callback);
-    return {
-      unsubscribe: () => {
-        if (this.isProcessingMessage) {
-          this.onNotificationCallbacks.push(callback);
-        } else {
-          this.removeOnNotificationCallback(callback);
-        }
-      }
-    };
-  }
-  onRequest(callback) {
-    throw new Error("Method not implemented.");
-  }
-  onResponse(callback) {
-    this.onResponseCallbacks.push(callback);
-    return {
-      unsubscribe: () => {
-        if (this.isProcessingMessage) {
-          this.onResponseCallbacksToRemove.push(callback);
-        } else {
-          this.removeOnResponseCallback(callback);
-        }
-      }
-    };
-  }
-  get instanceId() {
-    return this._instanceId;
-  }
-  set instanceId(instanceId) {
-    this._instanceId = instanceId;
-  }
-  sendRequest(request) {
-    const instanceId = this.instanceId || "unknown";
-    const method = request.method;
-    const message = {
-      type: method,
-      direction: "H5_TO_APP",
-      data: {
-        ...request.args,
-        requestId: request.id
-      },
-      instanceId,
-      timestamp: Date.now()
-    };
-    this.sendVenusMessage(message);
-  }
-  sendVenusMessage(message) {
-    const messageAsString = JSON.stringify(message, null, 2);
-    const reactNativeWebView = window.ReactNativeWebView;
-    if (reactNativeWebView) {
-      reactNativeWebView.postMessage(messageAsString);
-    } else {
-      window.parent.postMessage(messageAsString, "*");
-    }
-  }
-  sendResponse(response) {
-    throw new Error("Method not implemented.");
-  }
-  start() {
-    if (this.isStarted) {
-      return;
-    }
-    this.isStarted = true;
-    window.addEventListener("message", this.messageHandler, true);
-    this.logInfo(`Started`);
-  }
-  stop() {
-    if (!this.isStarted) {
-      return;
-    }
-    this.isStarted = false;
-    window.removeEventListener("message", this.messageHandler);
-    this.logInfo(`Stopped`);
-  }
-  handleNotification(notification) {
-    for (const callback of this.onNotificationCallbacks) {
-      callback(notification);
-    }
-    for (const callback of this.onNotificationCallbacksToRemove) {
-      this.removeOnNotificationCallback(callback);
-    }
-    this.onNotificationCallbacksToRemove.length = 0;
-  }
-  async handleResponse(response) {
-    for (const callback of this.onResponseCallbacks) {
-      const consumed = await callback(response);
-      if (consumed) {
-        break;
-      }
-    }
-    for (const callback of this.onResponseCallbacksToRemove) {
-      this.removeOnResponseCallback(callback);
-    }
-    this.onResponseCallbacksToRemove.length = 0;
-  }
-  removeOnResponseCallback(callback) {
-    this.onResponseCallbacks.splice(
-      this.onResponseCallbacks.indexOf(callback),
-      1
-    );
-  }
-  removeOnNotificationCallback(callback) {
-    this.onNotificationCallbacks.splice(
-      this.onNotificationCallbacks.indexOf(callback),
-      1
-    );
-  }
-  logInfo(message, ...params) {
-    console.log(`[Venus Transport] ${message}`, ...params);
-  }
-  logWarn(message, ...params) {
-    console.warn(`[Venus Transport] ${message}`, ...params);
-  }
-  onVenusMessage(callback) {
-    this.onVenusMessageCallbacks.push(callback);
-    return {
-      unsubscribe: () => {
-        this.onVenusMessageCallbacks.splice(
-          this.onVenusMessageCallbacks.indexOf(callback),
-          1
-        );
-      }
-    };
-  }
-  notifyVenusMessageReceived(message) {
-    for (const callback of this.onVenusMessageCallbacks) {
-      callback(message);
-    }
-  }
-};
-
-// src/notifications/RpcNotificationsApi.ts
-var RpcNotificationsApi = class {
-  constructor(rpcClient) {
-    __publicField(this, "rpcClient");
-    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
-    };
-    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;
-  }
-  async setLocalNotificationsEnabled(enabled) {
-    const response = await this.rpcClient.call(
-      "H5_SET_LOCAL_NOTIFICATIONS_ENABLED" /* SET_LOCAL_NOTIFICATIONS_ENABLED */,
-      {
-        enabled
-      }
-    );
-    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] = [];
-    }
-    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(
-      "H5_ROOM_CREATE" /* H5_ROOM_CREATE */,
-      {
-        options
-      }
-    );
-    if (response.success === false) {
-      throw new Error(response.error || "Failed to create room");
-    }
-    const roomData = response.roomData || response;
-    const room = new VenusRoom(roomData);
-    return room;
-  }
-  async joinOrCreateRoom(options) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_JOIN_OR_CREATE" /* H5_ROOM_JOIN_OR_CREATE */,
-      {
-        options
-      }
-    );
-    if (response.success === false) {
-      throw new Error(response.error || "Failed to join or create room");
-    }
-    const data = response.value || response;
-    const room = new VenusRoom(data.roomData);
-    return {
-      action: data.action,
-      room,
-      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 */,
-      {
-        roomCode
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to join room by code");
-    }
-    const roomData = response.roomData || response;
-    const room = new VenusRoom(roomData);
-    return room;
-  }
-  // Get user's rooms with optional filtering
-  async getUserRooms(appId, includeArchived = false) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_GET_USER_ROOMS" /* H5_ROOM_GET_USER_ROOMS */,
-      {
-        appId,
-        includePersonal: includeArchived
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to get user rooms");
-    }
-    const rawRooms = response.rooms || [];
-    const venusRooms = [];
-    for (const roomData of rawRooms) {
-      if (!roomData.id) {
-        console.warn("getUserRooms: Skipping room with missing ID:", roomData);
-        continue;
-      }
-      try {
-        const venusRoom = new VenusRoom(roomData);
-        venusRooms.push(venusRoom);
-      } catch (error) {
-        console.warn(
-          "getUserRooms: Failed to create VenusRoom object:",
-          error,
-          roomData
-        );
-      }
-    }
-    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 */,
-      {
-        roomId: room.id,
-        updates,
-        merge
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to update room data");
-    }
-    return response.data;
-  }
-  async getData(room) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_GET_DATA" /* H5_ROOM_GET_DATA */,
-      {
-        roomId: room.id
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to get room data");
-    }
-    return response.data;
-  }
-  async sendMessage(venusRoom, messageData) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_SEND_MESSAGE" /* H5_ROOM_SEND_MESSAGE */,
-      {
-        roomId: venusRoom.id,
-        message: messageData
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to send message");
-    }
-    return response.messageId;
-  }
-  async leave(room) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_LEAVE" /* H5_ROOM_LEAVE */,
-      {
-        roomId: room.id
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to leave room");
-    }
-    return response;
-  }
-  async startGame(room, gameConfig = {}, turnOrder = null) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_START_GAME" /* H5_ROOM_START_GAME */,
-      {
-        roomId: room.id,
-        gameConfig,
-        turnOrder
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to start game");
-    }
-    return response.data;
-  }
-  async proposeMove(room, proposalPayload) {
-    const response = await this.rpcClient.call(
-      "h5:room:proposeMove" /* H5_ROOM_PROPOSE_MOVE */,
-      {
-        roomId: room.id,
-        gameSpecificState: proposalPayload.gameSpecificState,
-        moveType: proposalPayload.moveType,
-        clientContext: proposalPayload.clientContext,
-        clientProposalId: proposalPayload.clientProposalId
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to propose move");
-    }
-    return response.data;
-  }
-  async validateMove(room, moveId, isValid, reason = null, validatorId = null) {
-    console.log(`[Venus Rooms] Validating move ${moveId}: ${isValid}`);
-    return { success: true, moveId, isValid, reason };
-  }
-  async roomSubscribeToGameEvents(room, callback) {
-    "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-    if (!window.venus._roomSubscriptions.gameEvents[room.id]) {
-      window.venus._roomSubscriptions.gameEvents[room.id] = [];
-    }
-    window.venus._roomSubscriptions.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] = [];
-      }
-      window.venus._roomSubscriptions.data[roomId].push(options.onData);
-      subscriptionIds.push({
-        type: "data",
-        id: dataSubId,
-        callback: options.onData
-      });
-    }
-    if (options.onMessages) {
-      const msgSubId = "messages_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-      if (!window.venus._roomSubscriptions.messages[roomId]) {
-        window.venus._roomSubscriptions.messages[roomId] = [];
-      }
-      window.venus._roomSubscriptions.messages[roomId].push(options.onMessages);
-      subscriptionIds.push({
-        type: "messages",
-        id: msgSubId,
-        callback: options.onMessages
-      });
-    }
-    if (options.onMoves || options.onGameEvents) {
-      const handler = options.onMoves || options.onGameEvents;
-      const gameSubId = "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-      if (!window.venus._roomSubscriptions.gameEvents[roomId]) {
-        window.venus._roomSubscriptions.gameEvents[roomId] = [];
-      }
-      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);
-    if (needsSubscription) {
-      this.rpcClient.call("H5_ROOM_SUBSCRIBE" /* H5_ROOM_SUBSCRIBE */, {
-        roomId,
-        subscribeToData: !!options.onData,
-        subscribeToMessages: !!options.onMessages,
-        subscribeToProposedMoves: !!(options.onMoves || options.onGameEvents)
-      }).catch((error) => {
-        console.error("Failed to set up room subscription:", error);
-      });
-    }
-    let called = false;
-    return () => {
-      if (called) return;
-      called = true;
-      subscriptionIds.forEach((sub) => {
-        const callbacks = window.venus._roomSubscriptions[sub.type][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);
-      if (hasNoCallbacks) {
-        this.rpcClient.call("H5_ROOM_UNSUBSCRIBE" /* H5_ROOM_UNSUBSCRIBE */, {
-          roomId
-        }).catch((error) => {
-          console.error("Failed to clean up room subscription:", error);
-        });
-      }
-    };
-  }
-};
-
-// src/RemoteHost.ts
-var getCdnBaseUrl = () => {
-  return "https://venus-static-01293ak.web.app/";
-};
-var RemoteHost = class {
-  constructor(venusApi) {
-    __publicField(this, "ads");
-    __publicField(this, "analytics");
-    __publicField(this, "deviceCache");
-    __publicField(this, "appStorage");
-    __publicField(this, "globalStorage");
-    __publicField(this, "avatar3d");
-    __publicField(this, "navigation");
-    __publicField(this, "notifications");
-    __publicField(this, "popups");
-    __publicField(this, "profile");
-    __publicField(this, "cdn");
-    __publicField(this, "time");
-    __publicField(this, "post");
-    __publicField(this, "ai");
-    __publicField(this, "haptics");
-    __publicField(this, "features");
-    __publicField(this, "lifecycle");
-    __publicField(this, "simulation");
-    __publicField(this, "rooms");
-    __publicField(this, "logging");
-    __publicField(this, "iap");
-    __publicField(this, "venusApi");
-    __publicField(this, "rpcClient");
-    __publicField(this, "_isInitialized", false);
-    this.venusApi = venusApi;
-    const rpcClient = new RpcClient();
-    this.rpcClient = rpcClient;
-    this.ads = new RpcAdsApi(rpcClient);
-    this.analytics = new RpcAnalyticsApi(rpcClient);
-    this.deviceCache = new RpcStorageApi(rpcClient, {
-      clear: "H5_DEVICE_CACHE_CLEAR" /* DEVICE_CACHE_CLEAR */,
-      getItem: "H5_DEVICE_CACHE_GET_ITEM" /* DEVICE_CACHE_GET_ITEM */,
-      getKey: "H5_DEVICE_CACHE_KEY" /* DEVICE_CACHE_KEY */,
-      length: "H5_DEVICE_CACHE_LENGTH" /* DEVICE_CACHE_LENGTH */,
-      removeItem: "H5_DEVICE_CACHE_REMOVE_ITEM" /* DEVICE_CACHE_REMOVE_ITEM */,
-      setItem: "H5_DEVICE_CACHE_SET_ITEM" /* DEVICE_CACHE_SET_ITEM */
-    });
-    this.appStorage = new RpcStorageApi(rpcClient, {
-      clear: "H5_APP_STORAGE_CLEAR" /* APP_STORAGE_CLEAR */,
-      getItem: "H5_APP_STORAGE_GET_ITEM" /* APP_STORAGE_GET_ITEM */,
-      getKey: "H5_APP_STORAGE_KEY" /* APP_STORAGE_KEY */,
-      length: "H5_APP_STORAGE_LENGTH" /* APP_STORAGE_LENGTH */,
-      removeItem: "H5_APP_STORAGE_REMOVE_ITEM" /* APP_STORAGE_REMOVE_ITEM */,
-      setItem: "H5_APP_STORAGE_SET_ITEM" /* APP_STORAGE_SET_ITEM */,
-      getAllItems: "H5_APP_STORAGE_GET_ALL_ITEMS" /* APP_STORAGE_GET_ALL_ITEMS */,
-      setMultipleItems: "H5_APP_STORAGE_SET_ITEM" /* APP_STORAGE_SET_ITEM */,
-      removeMultipleItems: "H5_APP_STORAGE_REMOVE_ITEM" /* APP_STORAGE_REMOVE_ITEM */
-    });
-    this.globalStorage = new RpcStorageApi(rpcClient, {
-      clear: "H5_GLOBAL_STORAGE_CLEAR" /* GLOBAL_STORAGE_CLEAR */,
-      getItem: "H5_GLOBAL_STORAGE_GET_ITEM" /* GLOBAL_STORAGE_GET_ITEM */,
-      getKey: "H5_GLOBAL_STORAGE_KEY" /* GLOBAL_STORAGE_KEY */,
-      length: "H5_GLOBAL_STORAGE_LENGTH" /* GLOBAL_STORAGE_LENGTH */,
-      removeItem: "H5_GLOBAL_STORAGE_REMOVE_ITEM" /* GLOBAL_STORAGE_REMOVE_ITEM */,
-      setItem: "H5_GLOBAL_STORAGE_SET_ITEM" /* GLOBAL_STORAGE_SET_ITEM */,
-      getAllItems: "H5_GLOBAL_STORAGE_GET_ALL_ITEMS" /* GLOBAL_STORAGE_GET_ALL_ITEMS */,
-      setMultipleItems: "H5_GLOBAL_STORAGE_SET_MULTIPLE_ITEMS" /* GLOBAL_STORAGE_SET_MULTIPLE_ITEMS */,
-      removeMultipleItems: "H5_GLOBAL_STORAGE_REMOVE_MULTIPLE_ITEMS" /* GLOBAL_STORAGE_REMOVE_MULTIPLE_ITEMS */
-    });
-    this.avatar3d = new RpcAvatarApi(rpcClient, venusApi);
-    this.navigation = new RpcNavigationApi(rpcClient, venusApi);
-    this.notifications = new RpcNotificationsApi(rpcClient);
-    this.popups = new RpcPopupsApi(rpcClient);
-    this.profile = new HostProfileApi();
-    this.cdn = new HostCdnApi(getCdnBaseUrl());
-    this.time = new HostTimeApi(rpcClient);
-    this.post = new RpcPostApi(rpcClient);
-    this.ai = new RpcAiApi(rpcClient);
-    this.haptics = new RpcHapticsApi(rpcClient);
-    this.features = new RpcFeaturesApi(rpcClient);
-    this.lifecycle = new RpcLifecycleApi(rpcClient);
-    this.simulation = new RpcSimulationApi(rpcClient);
-    this.rooms = new RpcRoomsApi(rpcClient);
-    this.logging = new RpcLoggingApi(this, rpcClient);
-    this.iap = new RpcIapApi(rpcClient);
-    venusApi.isMock = () => false;
-    this.venusApi.sharedAssets = new RpcSharedAssetsApi(rpcClient, venusApi);
-    console.log("[Venus SDK] Remote host created");
-  }
-  get isInitialized() {
-    return this._isInitialized;
-  }
-  async initialize() {
-    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 response = await this.rpcClient.call(
-      "INITIALIZE_SDK" /* INIT_SDK */,
-      {},
-      1e3
-    );
-    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");
-    }
-  }
-  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");
-    }
-    return instanceId;
-  }
-  log(message) {
-    console.log(`[Venus SDK] [Remote Host] ${message}`);
-  }
-};
-
-// src/Host.ts
-function createHost(venusApi, isMock) {
-  if (isMock) {
-    console.log("[Venus SDK] Creating Local Host");
-    return new MockHost(venusApi);
-  } else {
-    console.log("[Venus SDK] Creating Remote Host");
-    return new RemoteHost(venusApi);
-  }
-}
-
-// src/venus-api/index.js
-var HapticStyle = {
-  LIGHT: "light",
-  MEDIUM: "medium",
-  HEAVY: "heavy",
-  SUCCESS: "success",
-  WARNING: "warning",
-  ERROR: "error"
-};
-var VenusAPI2 = class {
+var VenusAPI2 = class {
   constructor() {
     console.log(`[Venus SDK] SDK Version: ${SDK_VERSION}`);
     this._shared = {
@@ -4521,12 +2071,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,
@@ -4593,14 +2138,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",
@@ -4714,12 +2256,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);
@@ -4734,8 +2279,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
@@ -4790,97 +2335,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;