@series-inc/venus-sdk 2.4.1 → 2.6.2

package/dist/venus-api/index.cjs

@@ -1,7 +1,9 @@
 'use strict';
 
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -10,6 +12,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/venus-api/systems/core.js
@@ -100,6 +111,221 @@ var init_core = __esm({
   }
 });
 
+// src/rooms/RoomsApi.ts
+var init_RoomsApi = __esm({
+  "src/rooms/RoomsApi.ts"() {
+  }
+});
+
+// src/rooms/VenusRoom.ts
+var VenusRoom;
+var init_VenusRoom = __esm({
+  "src/rooms/VenusRoom.ts"() {
+    VenusRoom = class {
+      constructor(roomData) {
+        __publicField(this, "id");
+        __publicField(this, "name");
+        __publicField(this, "players");
+        __publicField(this, "maxPlayers");
+        __publicField(this, "gameType");
+        __publicField(this, "appId");
+        __publicField(this, "type");
+        __publicField(this, "createdBy");
+        __publicField(this, "createdAt");
+        __publicField(this, "updatedAt");
+        __publicField(this, "isPrivate");
+        __publicField(this, "currentPlayers");
+        __publicField(this, "status");
+        __publicField(this, "customMetadata");
+        __publicField(this, "admins");
+        __publicField(this, "roomCode");
+        __publicField(this, "description");
+        __publicField(this, "data");
+        __publicField(this, "version");
+        __publicField(this, "_subscriptions", /* @__PURE__ */ new Map());
+        this.id = roomData.id;
+        this.name = roomData.name;
+        this.players = roomData.currentPlayers || [];
+        this.maxPlayers = roomData.maxPlayers;
+        this.gameType = roomData.gameType;
+        this.appId = roomData.appId;
+        this.type = roomData.type;
+        this.createdBy = roomData.createdBy;
+        this.createdAt = roomData.createdAt;
+        this.updatedAt = roomData.updatedAt;
+        this.isPrivate = roomData.isPrivate;
+        this.currentPlayers = roomData.currentPlayers || [];
+        this.status = roomData.status;
+        this.customMetadata = roomData.customMetadata || {};
+        this.admins = roomData.admins || [];
+        this.roomCode = roomData.roomCode;
+        this.description = roomData.description;
+        this.data = roomData.data || {};
+        this.version = roomData.version;
+        console.log(`VenusRoom: Created room object for ${this.id}`, {
+          hasCustomMetadata: !!this.customMetadata,
+          hasGameState: !!this.customMetadata?.rules?.gameState,
+          gamePhase: this.customMetadata?.rules?.gameState?.phase,
+          currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
+        });
+      }
+      updateFromRoomData(newRoomData) {
+        if (newRoomData.id === this.id) {
+          this.name = newRoomData.name || this.name;
+          this.players = newRoomData.currentPlayers || this.players;
+          this.maxPlayers = newRoomData.maxPlayers || this.maxPlayers;
+          this.gameType = newRoomData.gameType || this.gameType;
+          this.currentPlayers = newRoomData.currentPlayers || this.currentPlayers;
+          this.customMetadata = newRoomData.customMetadata || this.customMetadata;
+          this.data = newRoomData.data || this.data;
+          this.status = newRoomData.status || this.status;
+          this.updatedAt = newRoomData.updatedAt || this.updatedAt;
+          console.log(`VenusRoom: Updated room object ${this.id} with fresh data`, {
+            hasCustomMetadata: !!this.customMetadata,
+            hasGameState: !!this.customMetadata?.rules?.gameState,
+            gamePhase: this.customMetadata?.rules?.gameState?.phase,
+            currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rooms/index.ts
+var rooms_exports = {};
+__export(rooms_exports, {
+  VenusRoom: () => VenusRoom,
+  initializeRoomsApi: () => initializeRoomsApi,
+  setupRoomNotifications: () => setupRoomNotifications
+});
+function bindMethod(target, targetKey, source, sourceKey) {
+  const key = sourceKey ?? targetKey;
+  const fn = source?.[key];
+  if (typeof fn === "function") {
+    target[targetKey] = fn.bind(source);
+    return true;
+  }
+  return false;
+}
+function setupRoomNotifications(transport, getSubscriptions) {
+  console.log("[Venus Rooms] Setting up room notification listeners");
+  return transport.onVenusMessage((message) => {
+    const subscriptions = getSubscriptions();
+    if (!subscriptions) {
+      return;
+    }
+    if (message.type === "H5_ROOM_DATA_UPDATED") {
+      const messageData = message.data;
+      const { roomId, roomData } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.data?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Room data updated for ${roomId}, notifying ${callbacks.length} callbacks`, roomData);
+      callbacks.forEach((callback) => {
+        try {
+          callback(roomData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in room data callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+    if (message.type === "H5_ROOM_MESSAGE_RECEIVED" || message.type === "H5_ROOM_MESSAGE_UPDATED" || message.type === "H5_ROOM_MESSAGE_DELETED") {
+      const messageData = message.data;
+      const { roomId } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.messages?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Room message event for ${roomId}, notifying ${callbacks.length} callbacks`);
+      callbacks.forEach((callback) => {
+        try {
+          callback(messageData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in room message callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+    if (message.type === "app:h5:proposedMoveValidationUpdated") {
+      const messageData = message.data;
+      const { roomId } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.gameEvents?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Proposed move validation updated for ${roomId}, notifying ${callbacks.length} callbacks`);
+      callbacks.forEach((callback) => {
+        try {
+          callback(messageData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in game event callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+  });
+}
+function initializeRoomsApi(venusApi, host) {
+  const roomsApi = host?.rooms;
+  if (!roomsApi) {
+    console.warn(
+      "[Venus SDK] Host did not provide a rooms implementation. Rooms API will be unavailable."
+    );
+    return;
+  }
+  const venus = venusApi;
+  const existingNamespace = venus.rooms || {};
+  const roomsNamespace = Object.assign({}, existingNamespace);
+  const namespaceBindings = [
+    ["create", "createRoom"],
+    ["joinOrCreate", "joinOrCreateRoom"],
+    ["joinByCode", "joinRoomByCode"],
+    ["list", "getUserRooms"],
+    ["subscribeToRoom", "subscribe"],
+    ["updateRoomData", "updateData"],
+    ["getRoomData", "getData"],
+    ["sendRoomMessage", "sendMessage"],
+    ["leaveRoom", "leave"],
+    ["startRoomGame", "startGame"],
+    ["proposeMove"],
+    ["validateMove"]
+  ];
+  namespaceBindings.forEach(([targetKey, sourceKey]) => {
+    bindMethod(roomsNamespace, targetKey, roomsApi, sourceKey);
+  });
+  venus.rooms = roomsNamespace;
+}
+var init_rooms = __esm({
+  "src/rooms/index.ts"() {
+    init_RoomsApi();
+    init_VenusRoom();
+  }
+});
+
 // src/storage/MockStorageApi.ts
 function createMockStorageApi(storageType, appUrl) {
   const appIdentifier = appUrl ? generateAppIdentifier(appUrl) : null;
@@ -349,7 +575,11 @@ var RpcAdsApi = class {
     return response.shown;
   }
   async isRewardedAdReadyAsync() {
-    return true;
+    console.log(`[Venus SDK] [RpcAdsApi] isRewardedAdReadyAsync`);
+    const response = await this.rpcClient.call(
+      "H5_IS_REWARDED_AD_READY" /* IS_REWARDED_AD_READY */
+    );
+    return response.ready;
   }
   async showRewardedAdAsync() {
     console.log("[Venus SDK] [RpcAdsApi] showRewardedAdAsync");
@@ -387,6 +617,8 @@ var MockAdsApi = class {
   }
   async showInterstitialAd() {
     this.log(`[MockAdsApi] showInterstitialAd`);
+    await this.mockOverlay.showAdOverlay();
+    this.log("[MockAdsApi] interstitial ad shown");
     return true;
   }
   log(message, ...args) {
@@ -736,7 +968,7 @@ var MockNotificationsApi = class {
     __publicField(this, "venusApi");
     this.venusApi = venusApi;
   }
-  async cancelLocalNotification(notificationId) {
+  async cancelNotification(notificationId) {
     const venusApi = this.venusApi;
     if (isWebPlatform()) {
       console.log(
@@ -777,16 +1009,16 @@ var MockNotificationsApi = class {
     const isEnabled = venusApi._mock.notificationsEnabled !== false;
     return isEnabled;
   }
-  async scheduleLocalNotification(title, body, options) {
+  async scheduleAsync(options) {
     if (isWebPlatform()) {
       console.log(
         "[Venus Mock] Notifications not supported on web platform, simulating success"
       );
       console.info(
         "\u{1F514} [Venus Mock] Notification would be scheduled:",
-        title || "Untitled",
+        options.title || "Untitled",
         "\n   Body:",
-        body || "No body",
+        options.body || "No body",
         "\n   This is a simulation - real notifications require a native platform."
       );
       const mockId = `mock-web-notification-${Date.now()}`;
@@ -807,9 +1039,11 @@ var MockNotificationsApi = class {
         venusApi._mock.scheduledNotifications = {};
       }
       venusApi._mock.scheduledNotifications[notificationId] = {
-        ...options,
         id: notificationId,
-        createdAt: Date.now()
+        title: options.title,
+        body: options.body,
+        payload: options.payload,
+        trigger: options.trigger
       };
       setTimeout(() => {
         resolve(notificationId);
@@ -832,36 +1066,76 @@ var MockNotificationsApi = class {
   }
 };
 
-// src/notifications/index.ts
-function initializeLocalNotifications(venusApi, host) {
-  venusApi.setLocalNotifEnabledAsync = async (enable) => {
-    await host.notifications.setLocalNotificationsEnabled(enable);
-  };
-  venusApi.isLocalNotifEnabledAsync = async () => {
-    return host.notifications.isLocalNotificationsEnabled();
-  };
-  venusApi.getAllLocalNotifsAsync = async () => {
-    return host.notifications.getAllScheduledLocalNotifications();
-  };
-  venusApi.cancelLocalNotifAsync = async (notificationId) => {
-    await host.notifications.cancelLocalNotification(notificationId);
-  };
-  venusApi.scheduleLocalNotifAsync = async (options) => {
-    const id = await host.notifications.scheduleLocalNotification(
-      options.title,
-      options.body,
+// src/notifications/RpcNotificationsApi.ts
+var RpcNotificationsApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async scheduleAsync(options) {
+    const request = {
+      title: options.title,
+      body: options.body,
+      data: options.payload,
+      key: options.groupId,
+      priority: options.priority || 1,
+      trigger: options.trigger
+    };
+    const response = await this.rpcClient.call(
+      "H5_SCHEDULE_LOCAL_NOTIFICATION" /* SCHEDULE_LOCAL_NOTIFICATION */,
+      request
+    );
+    if (response.scheduled) {
+      return response.id;
+    }
+    return null;
+  }
+  async cancelNotification(id) {
+    const result = await this.rpcClient.call(
+      "H5_CANCEL_LOCAL_NOTIFICATION" /* CANCEL_LOCAL_NOTIFICATION */,
       {
-        trigger: options.trigger,
-        priority: options.priority,
-        groupId: options.groupId,
-        payload: options.payload
+        id
       }
     );
-    if (id) {
-      return id;
-    }
-    return "";
-  };
+    return result.canceled;
+  }
+  async getAllScheduledLocalNotifications() {
+    const response = await this.rpcClient.call(
+      "H5_GET_ALL_SCHEDULED_LOCAL_NOTIFICATIONS" /* GET_ALL_SCHEDULED_LOCAL_NOTIFICATIONS */,
+      {}
+    );
+    const notifications = response.notifications.map((notif) => {
+      return {
+        id: notif.identifier,
+        title: notif.content.title,
+        body: notif.content.body,
+        payload: notif.content.data,
+        trigger: notif.trigger
+      };
+    });
+    return notifications;
+  }
+  async isLocalNotificationsEnabled() {
+    const response = await this.rpcClient.call(
+      "H5_IS_LOCAL_NOTIFICATIONS_ENABLED" /* IS_LOCAL_NOTIFICATIONS_ENABLED */,
+      {}
+    );
+    return response.enabled;
+  }
+  async setLocalNotificationsEnabled(enabled) {
+    const response = await this.rpcClient.call(
+      "H5_SET_LOCAL_NOTIFICATIONS_ENABLED" /* SET_LOCAL_NOTIFICATIONS_ENABLED */,
+      {
+        enabled
+      }
+    );
+    return response.enabled;
+  }
+};
+
+// src/notifications/index.ts
+function initializeLocalNotifications(venusApi, host) {
+  venusApi.notifications = host.notifications;
 }
 
 // src/time/utils.ts
@@ -1734,1003 +2008,67 @@ function initializeStackNavigation(venusApi, host) {
 var RpcAiApi = class {
   constructor(rpcClient) {
     __publicField(this, "rpcClient");
-    this.rpcClient = rpcClient;
-  }
-  async requestChatCompletionAsync(request) {
-    const response = await this.rpcClient.call(
-      "H5_AI_CHAT_COMPLETION" /* AI_CHAT_COMPLETION */,
-      {
-        request: (() => {
-          const { apiKey, ...requestWithoutApiKey } = request;
-          return requestWithoutApiKey;
-        })()
-      }
-    );
-    return response;
-  }
-  async getAvailableCompletionModels() {
-    const response = await this.rpcClient.call(
-      "H5_AI_GET_AVAILABLE_MODELS" /* AI_GET_AVAILABLE_MODELS */
-    );
-    return response;
-  }
-};
-
-// src/ai/MockAiApi.ts
-var MockAiApi = class {
-  async requestChatCompletionAsync(request) {
-    const { apiKey, ...requestBody } = request;
-    if (!apiKey) {
-      throw new Error("An API key is required for a chat completion request when developing locally.");
-    }
-    const response = await fetch("https://series.ullm.rho.live/api/v1/completions", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
-      },
-      body: JSON.stringify(requestBody)
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
-    }
-    const data = await response.json();
-    return data;
-  }
-  async getAvailableCompletionModels() {
-    const response = await fetch("https://series.ullm.rho.live/api/v1/models", {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
-    }
-    const data = await response.json();
-    return data;
-  }
-};
-
-// src/ai/index.ts
-function initializeAi(venusApi, host) {
-  venusApi.ai = host.ai;
-}
-
-// src/venus-api/systems/rooms.js
-init_core();
-var mockRooms = /* @__PURE__ */ new Map();
-var mockMessages = /* @__PURE__ */ new Map();
-var mockRoomMoves = /* @__PURE__ */ new Map();
-var mockSubscriptions = /* @__PURE__ */ new Map();
-function generateRoomId() {
-  return "room_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-}
-function generateMessageId() {
-  return "msg_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-}
-function generateRoomCode() {
-  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-  let code = "";
-  for (let i = 0; i < 6; i++) {
-    code += characters.charAt(Math.floor(Math.random() * characters.length));
-  }
-  return code;
-}
-function broadcastEvent(roomId, eventType, eventData) {
-  console.log(`[Venus Mock Rooms] Broadcasting ${eventType} for room ${roomId}:`, eventData);
-  for (const [instanceId, subscriptions] of mockSubscriptions.entries()) {
-    const roomSubscriptions = subscriptions.get(roomId);
-    if (roomSubscriptions) {
-      setTimeout(() => {
-        if (roomSubscriptions.onRoomDataUpdated && eventType === "room_data_updated") {
-          roomSubscriptions.onRoomDataUpdated(eventData);
-        }
-        if (roomSubscriptions.onMessageReceived && eventType === "message_received") {
-          roomSubscriptions.onMessageReceived(eventData);
-        }
-        if (roomSubscriptions.onPlayerJoined && eventType === "player_joined") {
-          roomSubscriptions.onPlayerJoined(eventData);
-        }
-        if (roomSubscriptions.onPlayerLeft && eventType === "player_left") {
-          roomSubscriptions.onPlayerLeft(eventData);
-        }
-        if (roomSubscriptions.onGameStarted && eventType === "game_started") {
-          roomSubscriptions.onGameStarted(eventData);
-        }
-        if (roomSubscriptions.onTurnChanged && eventType === "turn_changed") {
-          roomSubscriptions.onTurnChanged(eventData);
-        }
-        if (roomSubscriptions.onOptimisticGameStateUpdated && eventType === "app:h5:optimisticGameStateUpdated") {
-          roomSubscriptions.onOptimisticGameStateUpdated(eventData);
-        }
-        if (roomSubscriptions.onProposedMoveValidationUpdated && eventType === "app:h5:proposedMoveValidationUpdated") {
-          roomSubscriptions.onProposedMoveValidationUpdated(eventData);
-        }
-      }, 50);
-    }
-  }
-}
-var MockVenusRoom = class {
-  constructor(roomData) {
-    this.id = roomData.id;
-    this.roomId = roomData.id;
-    this.name = roomData.name;
-    this.players = roomData.currentPlayers || [];
-    this.maxPlayers = roomData.maxPlayers;
-    this.gameType = roomData.gameType;
-    this._subscriptions = /* @__PURE__ */ new Map();
-    this.appId = roomData.appId;
-    this.type = roomData.type;
-    this.createdBy = roomData.createdBy;
-    this.createdAt = roomData.createdAt;
-    this.updatedAt = roomData.updatedAt;
-    this.isPrivate = roomData.isPrivate;
-    this.currentPlayers = roomData.currentPlayers || [];
-    this.status = roomData.status;
-    this.customMetadata = roomData.customMetadata || {};
-    this.admins = roomData.admins || [];
-    this.roomCode = roomData.roomCode;
-    this.description = roomData.description;
-    this.data = roomData.data || {};
-    this.version = roomData.version;
-    console.log(`[Venus Mock VenusRoom] Created room object for ${this.id}`, {
-      hasCustomMetadata: !!this.customMetadata,
-      hasGameState: !!this.customMetadata?.rules?.gameState,
-      gamePhase: this.customMetadata?.rules?.gameState?.phase,
-      currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
-    });
-  }
-  // Update room data
-  async updateData(updates, merge = true) {
-    return roomsMock.updateRoomData(this.roomId, updates, merge);
-  }
-  // Get room data
-  async getData() {
-    return roomsMock.getRoomData(this.roomId);
-  }
-  // Send message
-  async sendMessage(messageData) {
-    return roomsMock.sendMessage(this.roomId, messageData);
-  }
-  // Subscribe to room data changes
-  subscribeToData(callback) {
-    return roomsMock.subscribeToRoom(this.roomId, {
-      onRoomDataUpdated: callback
-    });
-  }
-  // Subscribe to messages
-  subscribeToMessages(callback) {
-    return roomsMock.subscribeToRoom(this.roomId, {
-      onMessageReceived: callback
-    });
-  }
-  // Leave room
-  async leave() {
-    this._subscriptions.forEach((sub) => {
-      if (sub.unsubscribe) sub.unsubscribe();
-    });
-    this._subscriptions.clear();
-    return { success: true };
-  }
-  // Start game
-  async startGame(gameConfig = {}, turnOrder = null) {
-    return roomsMock.startGame(this.roomId, gameConfig);
-  }
-  // End game
-  async endGame(winner = null, reason = null, gameResults = {}) {
-    return roomsMock.endGame(this.roomId, winner, reason, gameResults);
-  }
-  // Propose move (for client-proposed state architecture)
-  async proposeMove(proposalPayload) {
-    return roomsMock.proposeMove(this.roomId, proposalPayload);
-  }
-  // Validate move
-  async validateMove(moveId, isValid, reason = null, validatorId = null) {
-    console.log(`[Venus Mock VenusRoom] Validating move ${moveId}: ${isValid}`);
-    return { success: true, moveId, isValid, reason };
-  }
-  // Subscribe to game events
-  subscribeToGameEvents(callback) {
-    return roomsMock.subscribeToRoom(this.roomId, {
-      onOptimisticGameStateUpdated: callback,
-      onProposedMoveValidationUpdated: callback
-    });
-  }
-  // 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;
-          }
-        }
+    this.rpcClient = rpcClient;
+  }
+  async requestChatCompletionAsync(request) {
+    const response = await this.rpcClient.call(
+      "H5_AI_CHAT_COMPLETION" /* AI_CHAT_COMPLETION */,
+      {
+        request: (() => {
+          const { apiKey, ...requestWithoutApiKey } = request;
+          return requestWithoutApiKey;
+        })()
       }
-      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}`);
+    );
+    return response;
+  }
+  async getAvailableCompletionModels() {
+    const response = await this.rpcClient.call(
+      "H5_AI_GET_AVAILABLE_MODELS" /* AI_GET_AVAILABLE_MODELS */
+    );
+    return response;
+  }
+};
+
+// src/ai/MockAiApi.ts
+var MockAiApi = class {
+  async requestChatCompletionAsync(request) {
+    const { apiKey, ...requestBody } = request;
+    if (!apiKey) {
+      throw new Error("An API key is required for a chat completion request when developing locally.");
     }
-    broadcastEvent(roomId, "app:h5:proposedMoveValidationUpdated", {
-      roomId,
-      proposedMoveId,
-      proposedMoveData: proposedMove
+    const response = await fetch("https://series.ullm.rho.live/api/v1/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(requestBody)
     });
-    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" });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
     }
+    const data = await response.json();
+    return data;
   }
-};
-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"
-      })));
+  async getAvailableCompletionModels() {
+    const response = await fetch("https://series.ullm.rho.live/api/v1/models", {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
     });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const data = await response.json();
+    return data;
   }
-  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/ai/index.ts
+function initializeAi(venusApi, host) {
+  venusApi.ai = host.ai;
 }
 
 // src/venus-api/systems/asset-loader.js
@@ -4638,17 +3976,22 @@ function initializeIap(venusApiInstance, host) {
 // src/profile/HostProfileApi.ts
 var HostProfileApi = class {
   getCurrentProfile() {
-    if (window.venus._config && window.venus._config.profile) {
-      return {
-        id: window.venus._config.profile.id || "unknown",
-        name: window.venus._config.profile.username || "Unknown User",
-        username: window.venus._config.profile.username || "unknown"
-      };
+    const profile = window.venus?.profile;
+    if (!profile) {
+      throw new Error(
+        "[Venus SDK] Host profile handshake did not complete. Await VenusAPI.initializeAsync() so INIT_SDK can deliver the profile before calling profile APIs."
+      );
+    }
+    if (!profile.id || !profile.username) {
+      throw new Error(
+        "[Venus SDK] INIT_SDK returned an incomplete profile (missing id/username). The host must supply real credentials before rooms APIs are used."
+      );
     }
     return {
-      id: "mock_profile_123",
-      name: "Mock User",
-      username: "mockuser"
+      id: profile.id,
+      username: profile.username,
+      avatarUrl: profile.avatarUrl,
+      isAnonymous: profile.isAnonymous
     };
   }
 };
@@ -4659,7 +4002,8 @@ var MockProfileApi = class {
     return {
       id: "mock_profile_123",
       name: "Mock User",
-      username: "mockuser"
+      username: "mockuser",
+      isAnonymous: false
     };
   }
 };
@@ -6072,41 +5416,8 @@ function initializeSimulation(venusApi, host) {
   };
 }
 
-// src/rooms/MockRoomsApi.ts
-var MockRoomsApi = class {
-  constructor() {
-    // Mock room storage to simulate real-time rooms in development
-    __publicField(this, "mockRooms", /* @__PURE__ */ new Map());
-    __publicField(this, "mockMessages", /* @__PURE__ */ new Map());
-    // roomId -> messages[]
-    __publicField(this, "mockRoomMoves", /* @__PURE__ */ new Map());
-    // roomId -> moves[]
-    __publicField(this, "mockSubscriptions", /* @__PURE__ */ new Map());
-  }
-  join(roomId) {
-    throw new Error("Method not implemented.");
-  }
-  // instanceId -> subscriptions
-  createRoom(options) {
-    return Promise.resolve(void 0);
-  }
-  generateRoomId() {
-    return "room_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-  }
-  // Helper to generate message IDs
-  generateMessageId() {
-    return "msg_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-  }
-  // Helper to generate room codes
-  generateRoomCode() {
-    const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-    let code = "";
-    for (let i = 0; i < 6; i++) {
-      code += characters.charAt(Math.floor(Math.random() * characters.length));
-    }
-    return code;
-  }
-};
+// src/MockHost.ts
+init_rooms();
 
 // src/logging/MockLoggingApi.ts
 var MockLoggingApi = class {
@@ -6252,7 +5563,90 @@ var MockSharedAssetsApi = class {
   }
 };
 
+// src/game-preloader/MockPreloaderApi.ts
+var MockPreloaderApi = class {
+  async showLoadScreen() {
+    console.log("showLoadScreen");
+  }
+  async hideLoadScreen() {
+    console.log("hideLoadScreen");
+  }
+  async setLoaderText(text) {
+    console.log("setLoaderText", text);
+  }
+  async setLoaderProgress(progress) {
+    console.log("setLoaderProgress", progress);
+  }
+};
+
+// src/game-preloader/RpcPreloaderApi.ts
+var RpcPreloaderApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async showLoadScreen() {
+    await this.rpcClient.call("H5_SHOW_LOAD_SCREEN" /* H5_SHOW_LOAD_SCREEN */);
+  }
+  async hideLoadScreen() {
+    await this.rpcClient.call("H5_HIDE_LOAD_SCREEN" /* H5_HIDE_LOAD_SCREEN */);
+  }
+  async setLoaderText(text) {
+    await this.rpcClient.call("H5_SET_LOADER_TEXT" /* H5_SET_LOADER_TEXT */, { text });
+  }
+  async setLoaderProgress(progress) {
+    await this.rpcClient.call("H5_SET_LOADER_PROGRESS" /* H5_SET_LOADER_PROGRESS */, { progress });
+  }
+};
+
+// src/game-preloader/index.ts
+function initializePreloader(venusApi, host) {
+  venusApi.preloader = host.preloader;
+}
+
 // src/MockHost.ts
+var ROOMS_UNAVAILABLE_MESSAGE = "[Venus SDK] Rooms API is only available when running inside the Venus host environment.";
+function createUnavailableRoomsApi() {
+  const roomsUnavailableError = () => new Error(ROOMS_UNAVAILABLE_MESSAGE);
+  return {
+    async createRoom() {
+      throw roomsUnavailableError();
+    },
+    async joinOrCreateRoom() {
+      throw roomsUnavailableError();
+    },
+    async getUserRooms() {
+      throw roomsUnavailableError();
+    },
+    async joinRoomByCode() {
+      throw roomsUnavailableError();
+    },
+    subscribe() {
+      throw roomsUnavailableError();
+    },
+    async updateData() {
+      throw roomsUnavailableError();
+    },
+    async getData() {
+      throw roomsUnavailableError();
+    },
+    async sendMessage() {
+      throw roomsUnavailableError();
+    },
+    async leave() {
+      throw roomsUnavailableError();
+    },
+    async startGame() {
+      throw roomsUnavailableError();
+    },
+    async proposeMove() {
+      throw roomsUnavailableError();
+    },
+    async validateMove() {
+      throw roomsUnavailableError();
+    }
+  };
+}
 var MockHost = class {
   constructor(venusApi) {
     __publicField(this, "ads");
@@ -6276,6 +5670,7 @@ var MockHost = class {
     __publicField(this, "rooms");
     __publicField(this, "logging");
     __publicField(this, "iap");
+    __publicField(this, "preloader");
     __publicField(this, "state", 0 /* PLAYING */);
     __publicField(this, "venusApi");
     __publicField(this, "_isInitialized", false);
@@ -6305,18 +5700,19 @@ var MockHost = class {
     this.features = new MockFeaturesApi();
     this.lifecycle = this._mockLifecyclesApi;
     this.simulation = new MockSimulationApi();
-    this.rooms = new MockRoomsApi();
+    this.rooms = createUnavailableRoomsApi();
     this.logging = new MockLoggingApi();
     this.iap = new MockIapApi();
+    initializeRoomsApi(this.venusApi, this);
+    this.preloader = new MockPreloaderApi();
     venusApi.isMock = () => true;
     this.venusApi.sharedAssets = new MockSharedAssetsApi(this.venusApi);
   }
   get isInitialized() {
     return this._isInitialized;
   }
-  initialize() {
+  async initialize(options = {}) {
     this._isInitialized = true;
-    return Promise.resolve();
   }
   updateUiControls() {
     const controls = {
@@ -7044,177 +6440,49 @@ var VenusTransport = class {
   }
 };
 
-// src/notifications/RpcNotificationsApi.ts
-var RpcNotificationsApi = class {
+// src/RemoteHost.ts
+init_rooms();
+
+// src/rooms/RpcRoomsApi.ts
+init_VenusRoom();
+var RpcRoomsApi = class {
   constructor(rpcClient) {
     __publicField(this, "rpcClient");
+    __publicField(this, "subscriptions");
+    __publicField(this, "transportSubscription", null);
     this.rpcClient = rpcClient;
-  }
-  async scheduleLocalNotification(title, body, options) {
-    const request = {
-      title,
-      body,
-      data: options?.payload,
-      key: options?.groupId,
-      priority: options?.priority || 1,
-      trigger: options?.trigger ?? null
+    this.subscriptions = {
+      data: {},
+      messages: {},
+      gameEvents: {},
+      allEvents: {}
     };
-    const response = await this.rpcClient.call(
-      "H5_SCHEDULE_LOCAL_NOTIFICATION" /* SCHEDULE_LOCAL_NOTIFICATION */,
-      request
-    );
-    if (response.scheduled) {
-      return response.id;
-    }
-    return null;
-  }
-  async cancelLocalNotification(id) {
-    const result = await this.rpcClient.call(
-      "H5_CANCEL_LOCAL_NOTIFICATION" /* CANCEL_LOCAL_NOTIFICATION */,
-      {
-        id
-      }
-    );
-    return result.canceled;
-  }
-  async getAllScheduledLocalNotifications() {
-    const response = await this.rpcClient.call(
-      "H5_GET_ALL_SCHEDULED_LOCAL_NOTIFICATIONS" /* GET_ALL_SCHEDULED_LOCAL_NOTIFICATIONS */,
-      {}
-    );
-    const notifications = response.notifications.map((notif) => {
-      return {
-        id: notif.identifier,
-        title: notif.content.title,
-        body: notif.content.body,
-        payload: notif.content.data,
-        trigger: notif.trigger
-      };
-    });
-    return notifications;
   }
-  async isLocalNotificationsEnabled() {
-    const response = await this.rpcClient.call(
-      "H5_IS_LOCAL_NOTIFICATIONS_ENABLED" /* IS_LOCAL_NOTIFICATIONS_ENABLED */,
-      {}
-    );
-    return response.enabled;
+  /**
+   * Get the subscription state for external access (used by setupRoomNotifications)
+   */
+  getSubscriptions() {
+    return this.subscriptions;
   }
-  async setLocalNotificationsEnabled(enabled) {
-    const response = await this.rpcClient.call(
-      "H5_SET_LOCAL_NOTIFICATIONS_ENABLED" /* SET_LOCAL_NOTIFICATIONS_ENABLED */,
-      {
-        enabled
-      }
+  /**
+   * Set up room notification routing from the transport
+   */
+  setupNotifications(transport) {
+    const { setupRoomNotifications: setupRoomNotifications2 } = (init_rooms(), __toCommonJS(rooms_exports));
+    this.transportSubscription = setupRoomNotifications2(
+      transport,
+      () => this.getSubscriptions()
     );
-    return response.enabled;
-  }
-};
-
-// src/rooms/VenusRoom.ts
-var VenusRoom = class {
-  constructor(roomData) {
-    __publicField(this, "id");
-    __publicField(this, "name");
-    __publicField(this, "players");
-    __publicField(this, "maxPlayers");
-    __publicField(this, "gameType");
-    __publicField(this, "appId");
-    __publicField(this, "type");
-    __publicField(this, "createdBy");
-    __publicField(this, "createdAt");
-    __publicField(this, "updatedAt");
-    __publicField(this, "isPrivate");
-    __publicField(this, "currentPlayers");
-    __publicField(this, "status");
-    __publicField(this, "customMetadata");
-    __publicField(this, "admins");
-    __publicField(this, "roomCode");
-    __publicField(this, "description");
-    __publicField(this, "data");
-    __publicField(this, "version");
-    __publicField(this, "_subscriptions", /* @__PURE__ */ new Map());
-    this.id = roomData.id;
-    this.name = roomData.name;
-    this.players = roomData.currentPlayers || [];
-    this.maxPlayers = roomData.maxPlayers;
-    this.gameType = roomData.gameType;
-    this.appId = roomData.appId;
-    this.type = roomData.type;
-    this.createdBy = roomData.createdBy;
-    this.createdAt = roomData.createdAt;
-    this.updatedAt = roomData.updatedAt;
-    this.isPrivate = roomData.isPrivate;
-    this.currentPlayers = roomData.currentPlayers || [];
-    this.status = roomData.status;
-    this.customMetadata = roomData.customMetadata || {};
-    this.admins = roomData.admins || [];
-    this.roomCode = roomData.roomCode;
-    this.description = roomData.description;
-    this.data = roomData.data || {};
-    this.version = roomData.version;
-    console.log(`VenusRoom: Created room object for ${this.id}`, {
-      hasCustomMetadata: !!this.customMetadata,
-      hasGameState: !!this.customMetadata?.rules?.gameState,
-      gamePhase: this.customMetadata?.rules?.gameState?.phase,
-      currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
-    });
-  }
-  updateFromRoomData(newRoomData) {
-    if (newRoomData.id === this.id) {
-      this.name = newRoomData.name || this.name;
-      this.players = newRoomData.currentPlayers || this.players;
-      this.maxPlayers = newRoomData.maxPlayers || this.maxPlayers;
-      this.gameType = newRoomData.gameType || this.gameType;
-      this.currentPlayers = newRoomData.currentPlayers || this.currentPlayers;
-      this.customMetadata = newRoomData.customMetadata || this.customMetadata;
-      this.data = newRoomData.data || this.data;
-      this.status = newRoomData.status || this.status;
-      this.updatedAt = newRoomData.updatedAt || this.updatedAt;
-      console.log(`VenusRoom: Updated room object ${this.id} with fresh data`, {
-        hasCustomMetadata: !!this.customMetadata,
-        hasGameState: !!this.customMetadata?.rules?.gameState,
-        gamePhase: this.customMetadata?.rules?.gameState?.phase,
-        currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
-      });
-    }
   }
-  // NEW: Generic message handler for room-manager.js integration
-  onMessage(callback) {
-    const subscriptionId = "messages_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-    if (!window.venus._roomSubscriptions.allEvents) {
-      window.venus._roomSubscriptions.allEvents = {};
-    }
-    if (!window.venus._roomSubscriptions.allEvents[this.id]) {
-      window.venus._roomSubscriptions.allEvents[this.id] = [];
+  /**
+   * Clean up subscriptions and resources
+   */
+  dispose() {
+    if (this.transportSubscription) {
+      this.transportSubscription.unsubscribe();
+      this.transportSubscription = null;
+      console.log("[Venus Rooms] Cleaned up room notification subscription");
     }
-    window.venus._roomSubscriptions.allEvents[this.id].push(callback);
-    this._subscriptions.set(subscriptionId, {
-      type: "allEvents",
-      callback
-    });
-    return {
-      unsubscribe: () => {
-        const callbacks = window.venus._roomSubscriptions.allEvents[this.id] || [];
-        const index = callbacks.indexOf(callback);
-        if (index > -1) callbacks.splice(index, 1);
-        this._subscriptions.delete(subscriptionId);
-      }
-    };
-  }
-};
-
-// src/rooms/RpcRoomsApi.ts
-var RpcRoomsApi = class {
-  constructor(rpcClient) {
-    __publicField(this, "rpcClient");
-    __publicField(this, "isRoomSystemEnabled", function() {
-      return true;
-    });
-    this.rpcClient = rpcClient;
-  }
-  join(roomId) {
-    throw new Error("Method not implemented.");
   }
   async createRoom(options) {
     const response = await this.rpcClient.call(
@@ -7248,33 +6516,6 @@ var RpcRoomsApi = class {
       playersJoined: data.playersJoined
     };
   }
-  async listPublicRooms(gameType, limit = 20) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_LIST_PUBLIC" /* H5_ROOM_LIST_PUBLIC */,
-      {
-        gameType,
-        limit
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to list public rooms");
-    }
-    return response.rooms || [];
-  }
-  async searchRooms(searchQuery, gameType, limit = 20) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_SEARCH" /* H5_ROOM_SEARCH */,
-      {
-        searchQuery,
-        gameType,
-        limit
-      }
-    );
-    if (!response.success) {
-      throw new Error(response.error || "Failed to search rooms");
-    }
-    return response.rooms || [];
-  }
   async joinRoomByCode(roomCode) {
     const response = await this.rpcClient.call(
       "H5_ROOM_JOIN_BY_CODE" /* H5_ROOM_JOIN_BY_CODE */,
@@ -7282,7 +6523,7 @@ var RpcRoomsApi = class {
         roomCode
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to join room by code");
     }
     const roomData = response.roomData || response;
@@ -7290,15 +6531,14 @@ var RpcRoomsApi = class {
     return room;
   }
   // Get user's rooms with optional filtering
-  async getUserRooms(appId, includeArchived = false) {
+  async getUserRooms(includeArchived = false) {
     const response = await this.rpcClient.call(
       "H5_ROOM_GET_USER_ROOMS" /* H5_ROOM_GET_USER_ROOMS */,
       {
-        appId,
-        includePersonal: includeArchived
+        includeArchived
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to get user rooms");
     }
     const rawRooms = response.rooms || [];
@@ -7321,62 +6561,6 @@ var RpcRoomsApi = class {
     }
     return venusRooms;
   }
-  // Convenience method for common use case
-  quickMatch(gameType) {
-    return this.joinOrCreateRoom({
-      matchCriteria: {
-        gameType,
-        isPrivate: false,
-        hasSpace: true
-      },
-      createOptions: {
-        name: gameType + " Game",
-        gameType,
-        isPrivate: false,
-        maxPlayers: 4
-        // sensible default
-      }
-    });
-  }
-  // Enhanced room creation with game rules
-  async createGameRoom(options) {
-    const enhancedOptions = {
-      ...options,
-      customMetadata: {
-        ...options.customMetadata,
-        rules: {
-          ruleEngine: options.ruleEngine || "basic",
-          validateMessages: options.validateMessages || false,
-          randomizePlayerOrder: options.randomizePlayerOrder || false,
-          clientValidation: options.clientValidation || false,
-          allowedMessageTypes: options.allowedMessageTypes || {},
-          gameState: {
-            phase: "waiting",
-            currentPlayer: null,
-            turnOrder: [],
-            playerStates: {},
-            ...options.initialGameState
-          },
-          ...options.rules
-        }
-      }
-    };
-    return this.createRoom(enhancedOptions);
-  }
-  // Convenience method for subscribing to all game events
-  subscribeToGameEvents(roomId, callback) {
-    if (!window.venus._roomSubscriptions.gameEvents[roomId]) {
-      window.venus._roomSubscriptions.gameEvents[roomId] = [];
-    }
-    window.venus._roomSubscriptions.gameEvents[roomId].push(callback);
-    return {
-      unsubscribe: () => {
-        const callbacks = window.venus._roomSubscriptions.gameEvents[roomId] || [];
-        const index = callbacks.indexOf(callback);
-        if (index > -1) callbacks.splice(index, 1);
-      }
-    };
-  }
   async updateData(room, updates, merge = true) {
     const response = await this.rpcClient.call(
       "H5_ROOM_UPDATE_DATA" /* H5_ROOM_UPDATE_DATA */,
@@ -7386,7 +6570,7 @@ var RpcRoomsApi = class {
         merge
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to update room data");
     }
     return response.data;
@@ -7398,7 +6582,7 @@ var RpcRoomsApi = class {
         roomId: room.id
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to get room data");
     }
     return response.data;
@@ -7411,7 +6595,7 @@ var RpcRoomsApi = class {
         message: messageData
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to send message");
     }
     return response.messageId;
@@ -7423,7 +6607,7 @@ var RpcRoomsApi = class {
         roomId: room.id
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to leave room");
     }
     return response;
@@ -7437,7 +6621,7 @@ var RpcRoomsApi = class {
         turnOrder
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to start game");
     }
     return response.data;
@@ -7453,7 +6637,7 @@ var RpcRoomsApi = class {
         clientProposalId: proposalPayload.clientProposalId
       }
     );
-    if (!response.success) {
+    if (response?.success === false) {
       throw new Error(response.error || "Failed to propose move");
     }
     return response.data;
@@ -7464,20 +6648,20 @@ var RpcRoomsApi = class {
   }
   async roomSubscribeToGameEvents(room, callback) {
     "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-    if (!window.venus._roomSubscriptions.gameEvents[room.id]) {
-      window.venus._roomSubscriptions.gameEvents[room.id] = [];
+    if (!this.subscriptions.gameEvents[room.id]) {
+      this.subscriptions.gameEvents[room.id] = [];
     }
-    window.venus._roomSubscriptions.gameEvents[room.id].push(callback);
+    this.subscriptions.gameEvents[room.id].push(callback);
   }
   subscribe(room, options = {}) {
     const subscriptionIds = [];
     const roomId = room.id;
     if (options.onData) {
       const dataSubId = "data_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-      if (!window.venus._roomSubscriptions.data[roomId]) {
-        window.venus._roomSubscriptions.data[roomId] = [];
+      if (!this.subscriptions.data[roomId]) {
+        this.subscriptions.data[roomId] = [];
       }
-      window.venus._roomSubscriptions.data[roomId].push(options.onData);
+      this.subscriptions.data[roomId].push(options.onData);
       subscriptionIds.push({
         type: "data",
         id: dataSubId,
@@ -7486,10 +6670,10 @@ var RpcRoomsApi = class {
     }
     if (options.onMessages) {
       const msgSubId = "messages_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-      if (!window.venus._roomSubscriptions.messages[roomId]) {
-        window.venus._roomSubscriptions.messages[roomId] = [];
+      if (!this.subscriptions.messages[roomId]) {
+        this.subscriptions.messages[roomId] = [];
       }
-      window.venus._roomSubscriptions.messages[roomId].push(options.onMessages);
+      this.subscriptions.messages[roomId].push(options.onMessages);
       subscriptionIds.push({
         type: "messages",
         id: msgSubId,
@@ -7498,18 +6682,20 @@ var RpcRoomsApi = class {
     }
     if (options.onMoves || options.onGameEvents) {
       const handler = options.onMoves || options.onGameEvents;
-      const gameSubId = "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-      if (!window.venus._roomSubscriptions.gameEvents[roomId]) {
-        window.venus._roomSubscriptions.gameEvents[roomId] = [];
+      if (handler) {
+        const gameSubId = "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
+        if (!this.subscriptions.gameEvents[roomId]) {
+          this.subscriptions.gameEvents[roomId] = [];
+        }
+        this.subscriptions.gameEvents[roomId].push(handler);
+        subscriptionIds.push({
+          type: "gameEvents",
+          id: gameSubId,
+          callback: handler
+        });
       }
-      window.venus._roomSubscriptions.gameEvents[roomId].push(handler);
-      subscriptionIds.push({
-        type: "gameEvents",
-        id: gameSubId,
-        callback: handler
-      });
     }
-    const needsSubscription = subscriptionIds.length > 0 && (!window.venus._roomSubscriptions.data[roomId] || window.venus._roomSubscriptions.data[roomId].length <= 1) && (!window.venus._roomSubscriptions.messages[roomId] || window.venus._roomSubscriptions.messages[roomId].length <= 1) && (!window.venus._roomSubscriptions.gameEvents[roomId] || window.venus._roomSubscriptions.gameEvents[roomId].length <= 1);
+    const needsSubscription = subscriptionIds.length > 0 && (this.subscriptions.data[roomId]?.length ?? 0) <= 1 && (this.subscriptions.messages[roomId]?.length ?? 0) <= 1 && (this.subscriptions.gameEvents[roomId]?.length ?? 0) <= 1;
     if (needsSubscription) {
       this.rpcClient.call("H5_ROOM_SUBSCRIBE" /* H5_ROOM_SUBSCRIBE */, {
         roomId,
@@ -7525,11 +6711,12 @@ var RpcRoomsApi = class {
       if (called) return;
       called = true;
       subscriptionIds.forEach((sub) => {
-        const callbacks = window.venus._roomSubscriptions[sub.type][roomId] || [];
+        const bucket = this.subscriptions[sub.type];
+        const callbacks = bucket && bucket[roomId] || [];
         const index = callbacks.indexOf(sub.callback);
         if (index > -1) callbacks.splice(index, 1);
       });
-      const hasNoCallbacks = (!window.venus._roomSubscriptions.data[roomId] || window.venus._roomSubscriptions.data[roomId].length === 0) && (!window.venus._roomSubscriptions.messages[roomId] || window.venus._roomSubscriptions.messages[roomId].length === 0) && (!window.venus._roomSubscriptions.gameEvents[roomId] || window.venus._roomSubscriptions.gameEvents[roomId].length === 0);
+      const hasNoCallbacks = (this.subscriptions.data[roomId]?.length ?? 0) === 0 && (this.subscriptions.messages[roomId]?.length ?? 0) === 0 && (this.subscriptions.gameEvents[roomId]?.length ?? 0) === 0;
       if (hasNoCallbacks) {
         this.rpcClient.call("H5_ROOM_UNSUBSCRIBE" /* H5_ROOM_UNSUBSCRIBE */, {
           roomId
@@ -7568,6 +6755,7 @@ var RemoteHost = class {
     __publicField(this, "rooms");
     __publicField(this, "logging");
     __publicField(this, "iap");
+    __publicField(this, "preloader");
     __publicField(this, "venusApi");
     __publicField(this, "rpcClient");
     __publicField(this, "_isInitialized", false);
@@ -7622,18 +6810,22 @@ var RemoteHost = class {
     this.rooms = new RpcRoomsApi(rpcClient);
     this.logging = new RpcLoggingApi(this, rpcClient);
     this.iap = new RpcIapApi(rpcClient);
+    this.preloader = new RpcPreloaderApi(rpcClient);
     venusApi.isMock = () => false;
     this.venusApi.sharedAssets = new RpcSharedAssetsApi(rpcClient, venusApi);
+    initializeRoomsApi(this.venusApi, this);
     console.log("[Venus SDK] Remote host created");
   }
   get isInitialized() {
     return this._isInitialized;
   }
-  async initialize() {
+  async initialize(options = {}) {
     this.log("Initializing Remote Host...");
     const transport = new VenusTransport();
     transport.start();
     this.rpcClient.start(transport);
+    const roomsApi = this.rooms;
+    roomsApi.setupNotifications(transport);
     try {
       this.log("Trying to initialize using NEW method...");
       transport.instanceId = await this.initNew();
@@ -7693,6 +6885,26 @@ var RemoteHost = class {
       {},
       1e3
     );
+    if (response.profile) {
+      const profile = response.profile;
+      const sanitizedProfile = {
+        id: profile.id,
+        username: profile.username,
+        avatarUrl: profile.avatarUrl ?? null,
+        isAnonymous: Boolean(profile.isAnonymous)
+      };
+      if (typeof window !== "undefined") {
+        const globalWindow = window;
+        const venus = globalWindow.venus || (globalWindow.venus = {});
+        venus.profile = sanitizedProfile;
+        if (venus._config) {
+          venus._config.profile = sanitizedProfile;
+        }
+        if (venus.config) {
+          venus.config.profile = sanitizedProfile;
+        }
+      }
+    }
     return response.instanceId;
   }
   async initOld(transport) {
@@ -7730,8 +6942,11 @@ function createHost(venusApi, isMock) {
   }
 }
 
+// src/venus-api/index.js
+init_rooms();
+
 // src/version.ts
-var SDK_VERSION = "2.4.1";
+var SDK_VERSION = "2.6.2";
 
 // src/venus-api/index.js
 var HapticStyle = {
@@ -7848,12 +7063,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,
@@ -7923,11 +7133,7 @@ var VenusAPI2 = class {
     this.config = createProxiedObject.call(this, "config", {
       locale: "en-US",
       languageCode: "en",
-      profile: {
-        id: "mock-user-123",
-        username: "Test User",
-        avatarUrl: null
-      },
+      // Note: Profile is no longer in config - use getCurrentProfile() instead
       environment: {
         isDevelopment: true,
         platform: typeof navigator !== "undefined" ? navigator.platform : "unknown",
@@ -8041,12 +7247,14 @@ var VenusAPI2 = class {
     const host = createHost(this, !isInsideHostedEnv);
     this.host = host;
     initializeStorage(this, host);
+    initializeRoomsApi(this, host);
     initializeAds(this, host);
     initializeTheme(this);
     initializePopups(this, host);
     initializeAnalytics(this, host);
     initializeIap(this, host);
     initializeLocalNotifications(this, host);
+    initializePreloader(this, host);
     initializeTime(this, host);
     initializeLifecycleApi(this, host);
     initializeHaptics(this, host);
@@ -8061,7 +7269,6 @@ var VenusAPI2 = class {
     initializeStackNavigation(this, host);
     initializePost(this, host);
     initializeAi(this, host);
-    initializeRooms(this);
     initializeSimulation(this, host);
     initializeAssetLoader(this, createProxiedMethod);
   }
@@ -8117,7 +7324,9 @@ var VenusAPI2 = class {
       this.config.languageCode = this._mock.localeOverride.split("-")[0];
     }
     if (this._mock.roomsData) {
-      initializeRooms(this, this._mock.roomsData);
+      console.warn(
+        "[Venus Mock] Rooms mock data is no longer supported. Rooms functionality requires the Venus host environment."
+      );
     }
   }
   //---------------------------------------
@@ -8137,7 +7346,8 @@ var VenusAPI2 = class {
             "hardDisableMock",
             "mock",
             "helpText",
-            "forceRemoteCdn"
+            "forceRemoteCdn",
+            "usePreloader"
           ];
           const supportedMockParams = [
             "initDelay",
@@ -8178,7 +7388,10 @@ var VenusAPI2 = class {
             );
           }
         }
-        await this.host.initialize();
+        await this.host.initialize(options);
+        if (!options.usePreloader) {
+          await this.host.preloader.hideLoadScreen();
+        }
         if (this._bootstrap.isInsideHostedEnvironment) {
           this._shared.initialized = true;
           resolve(true);