@series-inc/venus-sdk 3.1.2 → 3.2.1-beta.0

package/dist/venus-api/index.cjs

@@ -1,9 +1,7 @@
 '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;
@@ -12,15 +10,6 @@ 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
@@ -111,237 +100,24 @@ 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
+var STORAGE_PREFIXES = {
+  globalStorage: "venus:global",
+  deviceCache: "venus:deviceCache",
+  appStorage: "venus:appStorage"
+};
 function createMockStorageApi(storageType, appUrl) {
   const appIdentifier = appUrl ? generateAppIdentifier(appUrl) : null;
-  let prefix;
+  let prefix = STORAGE_PREFIXES[storageType];
   let syncDelay = 0;
   switch (storageType) {
     case "deviceCache":
-      prefix = "venus:app";
       syncDelay = 0;
       break;
     case "appStorage":
-      prefix = "venus:app";
       syncDelay = 100;
       break;
     case "globalStorage":
-      prefix = "venus:global";
       syncDelay = 100;
       break;
     default:
@@ -354,29 +130,38 @@ var MockStorageApi = class {
   constructor(prefix, syncDelay) {
     __publicField(this, "prefix");
     __publicField(this, "syncDelay");
+    __publicField(this, "orderStorageKey");
     this.prefix = prefix;
     this.syncDelay = syncDelay;
+    this.orderStorageKey = `${prefix}__order__`;
   }
   async clear() {
+    const keysToRemove = [];
     const fullLength = localStorage.length;
     for (let i = 0; i < fullLength; i++) {
       const fullKey = localStorage.key(i);
-      if (fullKey && fullKey.startsWith(this.prefix)) {
-        localStorage.removeItem(fullKey);
+      if (!fullKey || fullKey === this.orderStorageKey) {
+        continue;
       }
+      if (fullKey.startsWith(this.prefix)) {
+        keysToRemove.push(fullKey);
+      }
+    }
+    for (const key of keysToRemove) {
+      localStorage.removeItem(key);
     }
+    this.clearOrder();
     await this.simulateSyncDelay();
   }
   async getAllItems() {
     const items = new Array();
-    const fullLength = localStorage.length;
-    for (let i = 0; i < fullLength; i++) {
-      const fullKey = localStorage.key(i);
-      if (fullKey && fullKey.startsWith(this.prefix)) {
-        const item = localStorage.getItem(fullKey);
-        if (item) {
-          items.push(item);
-        }
+    const orderedKeys = this.keys();
+    for (const key of orderedKeys) {
+      const value = localStorage.getItem(this.buildKey(key));
+      if (value !== null) {
+        items.push(value);
+      } else {
+        this.removeFromOrder(key);
       }
     }
     return items;
@@ -401,11 +186,13 @@ var MockStorageApi = class {
     const fullKey = this.buildKey(key);
     await this.simulateSyncDelay();
     localStorage.removeItem(fullKey);
+    this.removeFromOrder(key);
   }
   async setItem(key, item) {
     const fullKey = this.buildKey(key);
     await this.simulateSyncDelay();
     localStorage.setItem(fullKey, item);
+    this.upsertOrder(key);
   }
   async setMultipleItems(entries) {
     for (const entry of entries) {
@@ -413,6 +200,7 @@ var MockStorageApi = class {
       localStorage.setItem(fullKey, entry.value);
     }
     await this.simulateSyncDelay();
+    this.bulkUpsertOrder(entries.map((entry) => entry.key));
   }
   async removeMultipleItems(keys) {
     for (const key of keys) {
@@ -420,6 +208,7 @@ var MockStorageApi = class {
       localStorage.removeItem(fullKey);
     }
     await this.simulateSyncDelay();
+    this.bulkRemoveFromOrder(keys);
   }
   buildKey(key) {
     const prefix = this.prefix;
@@ -430,17 +219,8 @@ var MockStorageApi = class {
     return fullKey.substring(prefix.length);
   }
   keys() {
-    const keys = new Array();
-    let length = localStorage.length;
-    for (let i = 0; i < length; i++) {
-      const fullKey = localStorage.key(i);
-      if (fullKey && fullKey.startsWith(this.prefix)) {
-        length++;
-        const key = this.extractKey(fullKey);
-        keys.push(key);
-      }
-    }
-    return keys;
+    const order = this.readOrder();
+    return [...order];
   }
   async simulateSyncDelay() {
     const syncDelay = this.syncDelay;
@@ -448,6 +228,127 @@ var MockStorageApi = class {
       await new Promise((resolve) => setTimeout(resolve, syncDelay));
     }
   }
+  readOrder() {
+    const raw = localStorage.getItem(this.orderStorageKey);
+    if (!raw) {
+      return this.rebuildOrderFromStorage();
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) {
+        return this.normalizeOrder(parsed);
+      }
+    } catch {
+    }
+    return this.rebuildOrderFromStorage();
+  }
+  normalizeOrder(order) {
+    const seen = /* @__PURE__ */ new Set();
+    const normalized = [];
+    let changed = false;
+    for (const entry of order) {
+      if (typeof entry !== "string") {
+        changed = true;
+        continue;
+      }
+      if (seen.has(entry)) {
+        changed = true;
+        continue;
+      }
+      const fullKey = this.buildKey(entry);
+      if (localStorage.getItem(fullKey) === null) {
+        changed = true;
+        continue;
+      }
+      seen.add(entry);
+      normalized.push(entry);
+    }
+    if (changed) {
+      this.writeOrder(normalized);
+    }
+    return normalized;
+  }
+  rebuildOrderFromStorage() {
+    const keys = [];
+    const total = localStorage.length;
+    for (let i = 0; i < total; i++) {
+      const fullKey = localStorage.key(i);
+      if (!fullKey) continue;
+      if (fullKey === this.orderStorageKey) continue;
+      if (fullKey.startsWith(this.prefix)) {
+        keys.push(this.extractKey(fullKey));
+      }
+    }
+    this.writeOrder(keys);
+    return keys;
+  }
+  upsertOrder(key) {
+    const order = this.readOrder();
+    const index = order.indexOf(key);
+    if (index !== -1) {
+      order.splice(index, 1);
+    }
+    order.push(key);
+    this.writeOrder(order);
+  }
+  bulkUpsertOrder(keys) {
+    const dedupedKeys = this.dedupeKeys(keys);
+    if (dedupedKeys.length === 0) {
+      return;
+    }
+    const order = this.readOrder();
+    const keysSet = new Set(dedupedKeys);
+    const filtered = order.filter((entry) => !keysSet.has(entry));
+    for (const key of dedupedKeys) {
+      filtered.push(key);
+    }
+    this.writeOrder(filtered);
+  }
+  removeFromOrder(key) {
+    const order = this.readOrder();
+    const index = order.indexOf(key);
+    if (index !== -1) {
+      order.splice(index, 1);
+      this.writeOrder(order);
+    }
+  }
+  bulkRemoveFromOrder(keys) {
+    const dedupedKeys = this.dedupeKeys(keys);
+    if (dedupedKeys.length === 0) {
+      return;
+    }
+    const order = this.readOrder();
+    const keysSet = new Set(dedupedKeys);
+    const filtered = order.filter((entry) => !keysSet.has(entry));
+    if (filtered.length !== order.length) {
+      this.writeOrder(filtered);
+    }
+  }
+  writeOrder(order) {
+    if (order.length === 0) {
+      localStorage.removeItem(this.orderStorageKey);
+      return;
+    }
+    localStorage.setItem(this.orderStorageKey, JSON.stringify(order));
+  }
+  clearOrder() {
+    localStorage.removeItem(this.orderStorageKey);
+  }
+  dedupeKeys(keys) {
+    const result = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const key of keys) {
+      if (typeof key !== "string") {
+        continue;
+      }
+      if (seen.has(key)) {
+        continue;
+      }
+      seen.add(key);
+      result.push(key);
+    }
+    return result;
+  }
 };
 function generateAppIdentifier(appUrl) {
   if (!appUrl) appUrl = "";
@@ -635,190 +536,6 @@ function initializeAds(venusApiInstance, host) {
   venusApiInstance.ads = host.ads;
 }
 
-// src/venus-api/systems/theme.js
-init_core();
-var DEFAULT_TYPOGRAPHY = {
-  fontFamily: {
-    base: "Plus Jakarta Sans, Roboto, sans-serif",
-    heading: "Plus Jakarta Sans, Roboto, sans-serif",
-    mono: "monospace"
-  },
-  fontSize: {
-    "2xs": "10px",
-    xs: "12px",
-    sm: "14px",
-    md: "16px",
-    lg: "18px",
-    xl: "20px",
-    "2xl": "24px",
-    "3xl": "30px",
-    "4xl": "36px",
-    "5xl": "48px",
-    "6xl": "60px"
-  },
-  fontWeight: {
-    thin: "100",
-    extralight: "200",
-    light: "300",
-    regular: "400",
-    medium: "500",
-    semibold: "600",
-    bold: "700",
-    extrabold: "800",
-    black: "900",
-    extrablack: "950"
-  },
-  lineHeight: {
-    none: "1",
-    tight: "1.25",
-    snug: "1.375",
-    normal: "1.5",
-    relaxed: "1.625",
-    loose: "2"
-  }
-};
-var DEFAULT_THEME = {
-  background: {
-    default: "#131419",
-    // Dark background
-    muted: "#1b1d25",
-    // Mid-dark background
-    dark: "#0d0e11"
-    // Darker background
-  },
-  text: {
-    primary: "#ffffff",
-    // White
-    muted: "#808080",
-    // Gray
-    inverted: "#000000"
-    // Black
-  },
-  theme: {
-    primary: "#f6c833",
-    // Different yellow for testing (slightly lighter)
-    secondary: "#6366f1",
-    // Different secondary for testing (purple)
-    background: "#131419",
-    // Dark background
-    border: "#262626",
-    // Dark border
-    card: "#1b1d25",
-    // Dark card
-    "card-glass": "rgba(27, 29, 37, 0.8)"
-    // Translucent dark card
-  },
-  typography: DEFAULT_TYPOGRAPHY
-};
-function initializeTheme(venusApiInstance) {
-  if (!venusApiInstance._mock.theme) {
-    venusApiInstance._mock.theme = DEFAULT_THEME;
-  }
-  if (!venusApiInstance._mock.typography) {
-    venusApiInstance._mock.typography = DEFAULT_TYPOGRAPHY;
-  }
-  if (!venusApiInstance._mock.safeArea) {
-    venusApiInstance._mock.safeArea = { top: 0, bottom: 0, left: 0, right: 0 };
-  }
-  venusApiInstance.applyVenusThemeToCSS = function(theme) {
-    if (!theme) return;
-    const root = document.documentElement;
-    if (theme.background) {
-      if (theme.background.default)
-        root.style.setProperty("--color-background", theme.background.default);
-      if (theme.background.muted)
-        root.style.setProperty(
-          "--color-background-muted",
-          theme.background.muted
-        );
-      if (theme.background.dark)
-        root.style.setProperty(
-          "--color-background-dark",
-          theme.background.dark
-        );
-    }
-    if (theme.text) {
-      if (theme.text.primary)
-        root.style.setProperty("--color-text-primary", theme.text.primary);
-      if (theme.text.muted)
-        root.style.setProperty("--color-text-muted", theme.text.muted);
-    }
-    if (theme.theme) {
-      if (theme.theme.primary)
-        root.style.setProperty("--color-primary", theme.theme.primary);
-      if (theme.theme.secondary)
-        root.style.setProperty("--color-secondary", theme.theme.secondary);
-      if (theme.theme.border)
-        root.style.setProperty("--color-border", theme.theme.border);
-    }
-    if (theme.typography && theme.typography.fontFamily) {
-      if (theme.typography.fontFamily.base) {
-        root.style.setProperty(
-          "--font-family",
-          theme.typography.fontFamily.base
-        );
-      }
-    }
-    document.body.style.backgroundColor = root.style.getPropertyValue(
-      "--color-background-dark"
-    );
-  };
-  venusApiInstance.applyTheme = createProxiedMethod("applyTheme", function() {
-    let apiTheme = null;
-    apiTheme = this.config.theme;
-    if (apiTheme) {
-      this.applyVenusThemeToCSS(apiTheme);
-      this.colors = {
-        primary: apiTheme.theme?.primary || "#FF2877",
-        secondary: apiTheme.theme?.secondary || "#4755FF",
-        dark: apiTheme.background?.dark || "#0D0E11",
-        darkLight: apiTheme.background?.muted || "#1B1D25",
-        darkLighter: apiTheme.background?.default || "#23252F",
-        textPrimary: apiTheme.text?.primary || "#FFFFFF",
-        textMuted: apiTheme.text?.muted || "#808080",
-        border: apiTheme.theme?.border || "#262626"
-      };
-    } else {
-      this.colors = {
-        primary: "#FF2877",
-        secondary: "#4755FF",
-        dark: "#0D0E11",
-        darkLight: "#1B1D25",
-        darkLighter: "#23252F",
-        textPrimary: "#FFFFFF",
-        textMuted: "#808080",
-        border: "#262626"
-      };
-    }
-    this.log("Theme applied successfully");
-  });
-  venusApiInstance.applySafeArea = createProxiedMethod("applySafeArea", function() {
-    try {
-      const safeArea = this.config.ui.safeArea;
-      if (safeArea) {
-        this.log("Applying safe area insets: " + JSON.stringify(safeArea));
-        if (this.tapToStartScreen) {
-          this.tapToStartScreen.style.marginTop = `${safeArea.top}px`;
-          this.tapToStartScreen.style.marginBottom = `${safeArea.bottom}px`;
-        }
-        if (this.gameOverScreen) {
-          this.gameOverScreen.style.marginTop = `${safeArea.top}px`;
-          this.gameOverScreen.style.marginBottom = `${safeArea.bottom}px`;
-        }
-        if (this.maxScoreContainer) {
-          this.maxScoreContainer.style.marginTop = `${safeArea.top}px`;
-          this.maxScoreContainer.style.marginRight = `${safeArea.right}px`;
-        }
-      }
-    } catch (error) {
-      this.error("Error applying safe area: " + error.message);
-      console.error("Error applying safe area:", error);
-    }
-  });
-  venusApiInstance.DEFAULT_THEME = DEFAULT_THEME;
-  venusApiInstance.DEFAULT_TYPOGRAPHY = DEFAULT_TYPOGRAPHY;
-}
-
 // src/popups/RpcPopupsApi.ts
 var RpcPopupsApi = class {
   constructor(rpcClient) {
@@ -971,13 +688,8 @@ var MockNotificationsApi = class {
   async cancelNotification(notificationId) {
     const venusApi = this.venusApi;
     if (isWebPlatform()) {
-      console.log(
-        "[Venus Mock] Cancel notification on web platform (simulated):",
-        notificationId
-      );
       return true;
     }
-    console.log("[Venus Mock] Cancel local notification:", notificationId);
     await createMockDelay(MOCK_DELAYS.short);
     if (venusApi._mock.scheduledNotifications && venusApi._mock.scheduledNotifications[notificationId]) {
       delete venusApi._mock.scheduledNotifications[notificationId];
@@ -987,12 +699,8 @@ var MockNotificationsApi = class {
   }
   async getAllScheduledLocalNotifications() {
     if (isWebPlatform()) {
-      console.log(
-        "[Venus Mock] Get notifications on web platform (returning empty list)"
-      );
       return [];
     }
-    console.log("[Venus Mock] Get all scheduled local notifications");
     await createMockDelay(MOCK_DELAYS.short);
     const venusApi = this.venusApi;
     const notifications = venusApi._mock.scheduledNotifications || {};
@@ -1000,10 +708,8 @@ var MockNotificationsApi = class {
   }
   async isLocalNotificationsEnabled() {
     if (isWebPlatform()) {
-      console.log("[Venus Mock] Notifications not available on web platform");
       return false;
     }
-    console.log("[Venus Mock] Check if local notifications are enabled");
     await createMockDelay(MOCK_DELAYS.short);
     const venusApi = this.venusApi;
     const isEnabled = venusApi._mock.notificationsEnabled !== false;
@@ -1012,9 +718,6 @@ var MockNotificationsApi = class {
   async scheduleAsync(title, body, seconds, notificationId, options) {
     const { priority = 50, groupId, payload } = options || {};
     if (isWebPlatform()) {
-      console.log(
-        "[Venus Mock] Notifications not supported on web platform, simulating success"
-      );
       console.info(
         "\u{1F514} [Venus Mock] Notification would be scheduled:",
         title || "Untitled",
@@ -1025,14 +728,11 @@ var MockNotificationsApi = class {
       const mockId = `mock-web-notification-${Date.now()}`;
       return mockId;
     }
-    console.log("[Venus Mock] Schedule local notification:", { title, body, seconds, options });
     const venusApi = this.venusApi;
     if (!venusApi._mock.pendingRequests) {
-      console.log("[Venus Mock] Initializing pendingRequests");
       venusApi._mock.pendingRequests = {};
     }
     const requestId = Date.now().toString();
-    console.log("[Venus Mock] Creating request with ID:", requestId);
     return new Promise((resolve) => {
       venusApi._mock.pendingRequests[requestId] = { resolve };
       const id = notificationId || `mock-notification-${Date.now()}`;
@@ -1054,13 +754,8 @@ var MockNotificationsApi = class {
   async setLocalNotificationsEnabled(enabled) {
     const venusApi = this.venusApi;
     if (isWebPlatform()) {
-      console.log(
-        "[Venus Mock] Set notifications enabled on web platform (simulated):",
-        enabled
-      );
       return true;
     }
-    console.log("[Venus Mock] Set local notifications enabled:", enabled);
     await createMockDelay(MOCK_DELAYS.short);
     venusApi._mock.notificationsEnabled = enabled;
     return enabled;
@@ -1157,9 +852,11 @@ function isPacificDaylightTime(date) {
 
 // src/time/HostTimeApi.ts
 var HostTimeApi = class {
-  constructor(rpcClient) {
+  constructor(rpcClient, venusApi) {
     __publicField(this, "rpcClient");
+    __publicField(this, "venusApi");
     this.rpcClient = rpcClient;
+    this.venusApi = venusApi;
   }
   async requestTimeAsync() {
     const response = await this.rpcClient.call(
@@ -1169,13 +866,7 @@ var HostTimeApi = class {
     return response;
   }
   formatTime(timestamp, options) {
-    let locale = "en-US";
-    const windowVenus = window.venus;
-    if (windowVenus._config.locale) {
-      locale = windowVenus._config.locale;
-    } else if (windowVenus._config.environment && windowVenus._config.environment.browserInfo && windowVenus._config.environment.browserInfo.language) {
-      locale = windowVenus._config.environment.browserInfo.language;
-    }
+    const locale = this.venusApi.getLocale();
     const date = new Date(timestamp);
     const dateTimeOptions = {
       dateStyle: options.dateStyle || "medium",
@@ -1187,13 +878,7 @@ var HostTimeApi = class {
   }
   formatNumber(value, options) {
     try {
-      let locale = "en-US";
-      const windowVenus = window.venus;
-      if (windowVenus._config.locale) {
-        locale = windowVenus._config.locale;
-      } else if (windowVenus._config.environment && windowVenus._config.environment.browserInfo && windowVenus._config.environment.browserInfo.language) {
-        locale = windowVenus._config.environment.browserInfo.language;
-      }
+      const locale = this.venusApi.getLocale();
       const numberOptions = {
         style: options?.style || "decimal",
         minimumFractionDigits: options?.minimumFractionDigits || 0,
@@ -1257,18 +942,17 @@ var MockTimeApi = class {
     this.venusApi = venusApi;
   }
   formatNumber(value, options) {
-    const locale = this.getLocale();
+    const locale = this.venusApi.getLocale();
     const numberOptions = {
       style: options?.style || "decimal",
       minimumFractionDigits: options?.minimumFractionDigits || 0,
       maximumFractionDigits: options?.maximumFractionDigits || 2,
       ...options
     };
-    console.log(`[Venus Mock] Formatting number ${value} with locale ${locale}`);
     return value.toLocaleString(locale, numberOptions);
   }
   formatTime(timestamp, options) {
-    const locale = this.getLocale();
+    const locale = this.venusApi.getLocale();
     const date = new Date(timestamp);
     const dateTimeOptions = {
       dateStyle: options.dateStyle || "medium",
@@ -1276,13 +960,9 @@ var MockTimeApi = class {
       hour12: options.hour12 !== void 0 ? options.hour12 : true,
       ...options
     };
-    console.log(
-      `[Venus Mock] Formatting time ${timestamp} with locale ${locale}`
-    );
     return date.toLocaleString(locale, dateTimeOptions);
   }
   async getFutureTimeAsync(options) {
-    console.log("[Venus Mock] Getting future time with options:", options);
     const timeInfo = await this.requestTimeAsync();
     const serverTime = new Date(timeInfo.serverTime);
     const result = new Date(serverTime);
@@ -1327,7 +1007,6 @@ var MockTimeApi = class {
     return result.getTime();
   }
   async requestTimeAsync() {
-    console.log("[Venus Mock] Requesting time");
     await createMockDelay(MOCK_DELAYS.short);
     const venusApi = this.venusApi;
     const mockOffset = venusApi._mock.serverTimeOffset || 2500;
@@ -1341,23 +1020,8 @@ var MockTimeApi = class {
       formattedTime: new Date(localTime).toISOString(),
       locale: venusApi._mock.user?.locale || "en-US"
     };
-    console.log("[Venus Mock] Time response:", {
-      serverTime: new Date(timeInfo.serverTime).toISOString(),
-      localTime: new Date(timeInfo.localTime).toISOString(),
-      timezoneOffset: timeInfo.timezoneOffset
-    });
     return timeInfo;
   }
-  getLocale() {
-    const venusApi = this.venusApi;
-    let locale = "en-US";
-    if (venusApi._mock.user && venusApi._mock.user.locale) {
-      locale = venusApi._mock.user.locale;
-    } else if (venusApi._mock.environment && venusApi._mock.environment.browserInfo.language) {
-      locale = venusApi._mock.environment.browserInfo.language;
-    }
-    return locale;
-  }
 };
 
 // src/time/index.ts
@@ -1392,7 +1056,7 @@ var MockAvatarApi = class {
   async deleteAvatar() {
     console.log(`[Venus Mock] Deleting avatar3d config`);
     const venusApi = this._venusApi;
-    const currentProfile = venusApi.getCurrentProfile();
+    const currentProfile = venusApi.getProfile();
     const profileId = currentProfile?.id || "default_profile";
     localStorage.removeItem(`venus-mock-avatar3d-${profileId}`);
     console.log(
@@ -1407,7 +1071,7 @@ var MockAvatarApi = class {
       console.log(`[Venus Mock] Loading shared avatar3d by ID: ${avatar3dId}`);
       config = await this.selectAvatarConfig(avatar3dId, false);
     } else {
-      const currentProfile = venusApi.getCurrentProfile();
+      const currentProfile = venusApi.getProfile();
       const profileId = currentProfile?.id || "default_profile";
       console.log(`[Venus Mock] Loading avatar3d for profile: ${profileId}`);
       console.log(
@@ -1424,7 +1088,7 @@ var MockAvatarApi = class {
   async saveAvatar(config) {
     console.log(`[Venus Mock] Saving avatar3d config:`, config);
     const venusApi = this._venusApi;
-    const currentProfile = venusApi.getCurrentProfile();
+    const currentProfile = venusApi.getProfile();
     const profileId = currentProfile?.id || "default_profile";
     localStorage.setItem(
       `venus-mock-avatar3d-${profileId}`,
@@ -2085,7 +1749,7 @@ var VenusAssetLoader = class {
   // Set the VenusAPI reference during initialization
   setVenusAPI(api) {
     this.venusAPI = api;
-    this.isWebView = !api.isWeb || !api.isWeb();
+    this.isWebView = typeof window !== "undefined" && typeof window.ReactNativeWebView !== "undefined";
   }
   /**
    * Load any asset with automatic optimization
@@ -2206,14 +1870,11 @@ var VenusAssetLoader = class {
       }, 1e4);
       if (type === "image") {
         const img = new Image();
-        console.log(`\u{1F5BC}\uFE0F [Asset Verification] Verifying image: ${url}`);
         img.onload = () => {
-          console.log(`\u2705 [Asset Verification] Image verified successfully: ${url}`);
           clearTimeout(timeout);
           resolve();
         };
         img.onerror = (error) => {
-          console.log(`\u274C [Asset Verification] Image verification failed: ${url}`, error);
           clearTimeout(timeout);
           reject(new Error("Failed to load image"));
         };
@@ -2265,7 +1926,6 @@ var VenusAssetLoader = class {
       const CDN_BASE_URL = "https://venus-static-01293ak.web.app/";
       const cleanUrl = url.startsWith("/") ? url.slice(1) : url;
       const fullUrl = CDN_BASE_URL + cleanUrl;
-      console.log(`\u{1F310} [Asset Loader] Force remote CDN: ${url} -> ${fullUrl}`);
       return fullUrl;
     }
     if (this.venusAPI && this.venusAPI.isMock && this.venusAPI.isMock()) {
@@ -3976,47 +3636,105 @@ function initializeIap(venusApiInstance, host) {
   venusApiInstance.iap = host.iap;
 }
 
+// src/leaderboard/utils.ts
+var HASH_ALGORITHM_WEB_CRYPTO = "SHA-256";
+async function computeScoreHash(score, duration, token, sealingNonce, sealingSecret) {
+  const payload = `score:${score}|duration:${duration}|token:${token}`;
+  const fullPayload = `${payload}|nonce:${sealingNonce}`;
+  const encoder = new TextEncoder();
+  const keyData = encoder.encode(sealingSecret);
+  const messageData = encoder.encode(fullPayload);
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyData,
+    { name: "HMAC", hash: HASH_ALGORITHM_WEB_CRYPTO },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, messageData);
+  return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
 // src/leaderboard/RpcLeaderboardApi.ts
 var RpcLeaderboardApi = class {
   constructor(rpcClient) {
     __publicField(this, "rpcClient");
+    /** Cache of score tokens for automatic hash computation */
+    __publicField(this, "tokenCache", /* @__PURE__ */ new Map());
     this.rpcClient = rpcClient;
   }
-  startRun(mode) {
-    return this.rpcClient.call(
-      "H5_LEADERBOARD_START_RUN" /* H5_LEADERBOARD_START_RUN */,
+  /**
+   * Create a score token for submitting a score.
+   * Token is cached for automatic hash computation if score sealing is enabled.
+   *
+   * @param mode - Optional game mode
+   * @returns Score token with sealing data if enabled
+   */
+  async createScoreToken(mode) {
+    const token = await this.rpcClient.call(
+      "H5_LEADERBOARD_CREATE_SCORE_TOKEN" /* H5_LEADERBOARD_CREATE_SCORE_TOKEN */,
       mode ? { mode } : {}
     );
+    this.tokenCache.set(token.token, token);
+    return token;
   }
-  submitScore(sessionId, score, durationSec, options) {
+  /**
+   * Submit a score to the leaderboard.
+   * Automatically computes hash if score sealing is enabled and token was created via createScoreToken().
+   *
+   * @param params - Score submission parameters
+   * @returns Submission result with acceptance status and rank
+   * @throws Error if token not found in cache
+   */
+  async submitScore(params) {
+    let hash;
+    if (params.token) {
+      const cachedToken = this.tokenCache.get(params.token);
+      if (!cachedToken) {
+        throw new Error(
+          "Invalid token: not found in cache. Did you call createScoreToken() first?"
+        );
+      }
+      if (cachedToken.sealingNonce && cachedToken.sealingSecret) {
+        hash = await computeScoreHash(
+          params.score,
+          params.duration,
+          params.token,
+          cachedToken.sealingNonce,
+          cachedToken.sealingSecret
+        );
+      }
+      this.tokenCache.delete(params.token);
+    }
     return this.rpcClient.call(
       "H5_LEADERBOARD_SUBMIT_SCORE" /* H5_LEADERBOARD_SUBMIT_SCORE */,
       {
-        sessionId,
-        score,
-        durationSec,
-        mode: options?.mode,
-        telemetry: options?.telemetry,
-        metadata: options?.metadata,
-        hash: options?.hash
+        token: params.token,
+        score: params.score,
+        duration: params.duration,
+        mode: params.mode,
+        telemetry: params.telemetry,
+        metadata: params.metadata,
+        hash
+        // undefined if no sealing, computed if sealing enabled
       }
     );
   }
-  getLeaderboard(options) {
+  getPagedScores(options) {
     return this.rpcClient.call(
-      "H5_LEADERBOARD_GET" /* H5_LEADERBOARD_GET */,
+      "H5_LEADERBOARD_GET_PAGED_SCORES" /* H5_LEADERBOARD_GET_PAGED_SCORES */,
       options ?? {}
     );
   }
-  getPlayerStats(options) {
+  getMyRank(options) {
     return this.rpcClient.call(
-      "H5_LEADERBOARD_GET_PLAYER_STATS" /* H5_LEADERBOARD_GET_PLAYER_STATS */,
+      "H5_LEADERBOARD_GET_MY_RANK" /* H5_LEADERBOARD_GET_MY_RANK */,
       options ?? {}
     );
   }
-  getLeaderboardHighlight(options) {
+  getPodiumScores(options) {
     return this.rpcClient.call(
-      "H5_LEADERBOARD_GET_HIGHLIGHT" /* H5_LEADERBOARD_GET_HIGHLIGHT */,
+      "H5_LEADERBOARD_GET_PODIUM_SCORES" /* H5_LEADERBOARD_GET_PODIUM_SCORES */,
       options ?? {}
     );
   }
@@ -4025,17 +3743,31 @@ var RpcLeaderboardApi = class {
 // src/leaderboard/MockLeaderboardApi.ts
 var MockLeaderboardApi = class {
   constructor(options) {
-    __publicField(this, "sessions", /* @__PURE__ */ new Map());
+    __publicField(this, "tokens", /* @__PURE__ */ new Map());
+    /** Cache of score tokens for automatic hash computation */
+    __publicField(this, "tokenCache", /* @__PURE__ */ new Map());
     __publicField(this, "entriesByMode", /* @__PURE__ */ new Map());
-    __publicField(this, "sessionCounter", 0);
-    __publicField(this, "requiresHash", false);
-    if (options?.requiresHash) {
-      this.requiresHash = true;
+    __publicField(this, "tokenCounter", 0);
+    __publicField(this, "enableScoreSealing", false);
+    __publicField(this, "scoreSealingSecret", "mock-leaderboard-secret-key");
+    if (options?.enableScoreSealing) {
+      this.enableScoreSealing = true;
+    }
+    if (options?.scoreSealingSecret) {
+      this.scoreSealingSecret = options.scoreSealingSecret;
     }
   }
+  /**
+   * Configure mock leaderboard settings
+   *
+   * @param options - Configuration options
+   */
   configure(options) {
-    if (typeof options.requiresHash === "boolean") {
-      this.requiresHash = options.requiresHash;
+    if (typeof options.enableScoreSealing === "boolean") {
+      this.enableScoreSealing = options.enableScoreSealing;
+    }
+    if (options.scoreSealingSecret) {
+      this.scoreSealingSecret = options.scoreSealingSecret;
     }
   }
   generateNonce() {
@@ -4052,83 +3784,149 @@ var MockLeaderboardApi = class {
     }
     return this.entriesByMode.get(key);
   }
-  async startRun(mode) {
-    const sessionId = `mock_session_${++this.sessionCounter}`;
+  /**
+   * Create a mock score token for testing.
+   * Token is cached for automatic hash computation if score sealing is enabled.
+   *
+   * @param mode - Optional game mode
+   * @returns Score token with sealing data if enabled
+   */
+  async createScoreToken(mode) {
+    const token = `mock_token_${++this.tokenCounter}`;
     const startTime = Date.now();
     const expiresAt = startTime + 36e5;
     const resolvedMode = mode || "default";
-    const hashNonce = this.requiresHash ? this.generateNonce() : null;
-    this.sessions.set(sessionId, {
-      id: sessionId,
+    const sealingNonce = this.enableScoreSealing ? this.generateNonce() : null;
+    const sealingSecret = this.enableScoreSealing ? this.scoreSealingSecret : null;
+    this.tokens.set(token, {
+      id: token,
       expiresAt,
       mode: resolvedMode,
-      hashNonce,
+      sealingNonce,
       used: false
     });
-    return {
-      sessionId,
+    const result = {
+      token,
       startTime,
       expiresAt,
-      hashNonce,
+      sealingNonce,
+      sealingSecret,
       mode: resolvedMode
     };
+    this.tokenCache.set(token, result);
+    return result;
   }
-  async submitScore(sessionId, score, durationSec, options) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error("Invalid leaderboard session");
+  /**
+   * Submit a mock score to the leaderboard.
+   * Automatically computes hash if score sealing is enabled and token was created via createScoreToken().
+   *
+   * @param params - Score submission parameters
+   * @returns Submission result with acceptance status and rank
+   * @throws Error if token not found in cache or validation fails
+   */
+  async submitScore(params) {
+    let hash;
+    if (params.token) {
+      const cachedToken = this.tokenCache.get(params.token);
+      if (!cachedToken) {
+        throw new Error(
+          "Invalid token: not found in cache. Did you call createScoreToken() first?"
+        );
+      }
+      if (cachedToken.sealingNonce && cachedToken.sealingSecret) {
+        hash = await computeScoreHash(
+          params.score,
+          params.duration,
+          params.token,
+          cachedToken.sealingNonce,
+          cachedToken.sealingSecret
+        );
+      }
+    }
+    if (!params.token) {
+      const mode = params.mode || "default";
+      const submittedAt2 = Date.now();
+      const entry2 = {
+        profileId: `mock_profile`,
+        username: "Mock Player",
+        avatarUrl: null,
+        score: params.score,
+        duration: params.duration,
+        submittedAt: submittedAt2,
+        token: "simple-mode",
+        rank: null,
+        zScore: null,
+        isAnomaly: false,
+        trustScore: 50,
+        metadata: params.metadata ?? null,
+        isSeed: false
+      };
+      const modeEntries2 = this.getEntriesForMode(mode);
+      modeEntries2.push(entry2);
+      modeEntries2.sort((a, b) => {
+        if (b.score !== a.score) return b.score - a.score;
+        return a.submittedAt - b.submittedAt;
+      });
+      modeEntries2.forEach((e, index) => {
+        modeEntries2[index] = { ...e, rank: index + 1 };
+      });
+      const inserted2 = modeEntries2.find((e) => e.submittedAt === submittedAt2);
+      return {
+        accepted: true,
+        rank: inserted2?.rank ?? null
+      };
     }
-    if (session.expiresAt < Date.now()) {
-      throw new Error("Invalid or expired leaderboard session");
+    const scoreToken = this.tokens.get(params.token);
+    if (!scoreToken) {
+      throw new Error("Invalid score token");
     }
-    if (session.used) {
-      throw new Error("Leaderboard session already used");
+    if (scoreToken.expiresAt < Date.now()) {
+      throw new Error("Invalid or expired score token");
     }
-    if (options?.mode && options.mode !== session.mode) {
-      throw new Error("Submission mode does not match session mode");
+    if (scoreToken.used) {
+      throw new Error("Score token already used");
     }
-    if (session.hashNonce && !options?.hash) {
-      throw new Error("Score hash is required for sealed leaderboard submissions");
+    if (params.mode && params.mode !== scoreToken.mode) {
+      throw new Error("Submission mode does not match token mode");
+    }
+    if (scoreToken.sealingNonce && !hash) {
+      throw new Error("Score hash required when score sealing is enabled");
     }
     const submittedAt = Date.now();
     const entry = {
       profileId: `mock_profile`,
       username: "Mock Player",
       avatarUrl: null,
-      score,
-      durationSec,
+      score: params.score,
+      duration: params.duration,
       submittedAt,
-      sessionId,
+      token: params.token,
       rank: null,
       zScore: null,
       isAnomaly: false,
       trustScore: 50,
-      metadata: options?.metadata ?? null,
+      metadata: params.metadata ?? null,
       isSeed: false
     };
-    const modeEntries = this.getEntriesForMode(session.mode);
+    const modeEntries = this.getEntriesForMode(scoreToken.mode);
     modeEntries.push(entry);
     modeEntries.sort((a, b) => {
-      if (b.score !== a.score) {
-        return b.score - a.score;
-      }
+      if (b.score !== a.score) return b.score - a.score;
       return a.submittedAt - b.submittedAt;
     });
     modeEntries.forEach((e, index) => {
-      modeEntries[index] = {
-        ...e,
-        rank: index + 1
-      };
+      modeEntries[index] = { ...e, rank: index + 1 };
     });
-    session.used = true;
-    session.hashNonce = null;
-    const inserted = modeEntries.find((e) => e.sessionId === sessionId && e.submittedAt === submittedAt);
+    scoreToken.used = true;
+    scoreToken.sealingNonce = null;
+    this.tokenCache.delete(params.token);
+    const inserted = modeEntries.find((e) => e.token === params.token && e.submittedAt === submittedAt);
     return {
       accepted: true,
       rank: inserted?.rank ?? null
     };
   }
-  async getLeaderboard(options) {
+  async getPagedScores(options) {
     const limit = options?.limit ?? 10;
     const mode = options?.mode ?? "default";
     const modeEntries = [...this.getEntriesForMode(mode)];
@@ -4144,7 +3942,7 @@ var MockLeaderboardApi = class {
       periodInstance: options?.period ?? "alltime"
     };
   }
-  async getPlayerStats(_options) {
+  async getMyRank(_options) {
     const mode = _options?.mode ?? "default";
     const modeEntries = this.getEntriesForMode(mode);
     const playerEntry = modeEntries[0] ?? null;
@@ -4157,7 +3955,7 @@ var MockLeaderboardApi = class {
       periodInstance: _options?.period ?? "alltime"
     };
   }
-  async getLeaderboardHighlight(options) {
+  async getPodiumScores(options) {
     const mode = options?.mode ?? "default";
     const modeEntries = [...this.getEntriesForMode(mode)];
     const topCount = Math.max(1, Math.min(options?.topCount ?? 3, 10));
@@ -4210,16 +4008,20 @@ function initializeLeaderboard(venusApiInstance, host) {
 
 // src/profile/HostProfileApi.ts
 var HostProfileApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
   getCurrentProfile() {
-    const profile = window.venus?.profile;
+    const profile = this.venusApi._profileData;
     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."
+        "[Venus SDK] Profile not available. You must await VenusAPI.initializeAsync() before calling getProfile(). INIT_SDK has not completed."
       );
     }
     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."
+        "[Venus SDK] INIT_SDK returned an incomplete profile (missing id/username). The host must supply valid profile data."
       );
     }
     return {
@@ -4233,6 +4035,10 @@ var HostProfileApi = class {
 
 // src/profile/MockProfileApi.ts
 var MockProfileApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
   getCurrentProfile() {
     return {
       id: "mock_profile_123",
@@ -4245,12 +4051,224 @@ var MockProfileApi = class {
 
 // src/profile/index.ts
 function initializeProfile(venusApi, host) {
+  venusApi.getProfile = () => {
+    return host.profile.getCurrentProfile();
+  };
   venusApi.getCurrentProfile = () => {
+    console.warn(
+      "[Venus SDK] DEPRECATED: VenusAPI.getCurrentProfile() is deprecated. Use VenusAPI.getProfile() instead. See migration guide: https://docs.venus.com/migration/profile-api"
+    );
     return host.profile.getCurrentProfile();
   };
 }
 
-// src/cdn/HostCdnApi.ts
+// src/system/HostSystemApi.ts
+var HostSystemApi = class {
+  constructor(deviceApi, environmentApi, venusApi) {
+    __publicField(this, "deviceApi");
+    __publicField(this, "environmentApi");
+    __publicField(this, "venusApi");
+    this.deviceApi = deviceApi;
+    this.environmentApi = environmentApi;
+    this.venusApi = venusApi;
+  }
+  getDevice() {
+    return this.deviceApi.getDevice();
+  }
+  getEnvironment() {
+    return this.environmentApi.getEnvironment();
+  }
+  getSafeArea() {
+    const safeArea = this.venusApi._safeAreaData;
+    if (!safeArea) {
+      throw new Error(
+        "[Venus SDK] getSafeArea() called before initialization. Call VenusAPI.initializeAsync() first."
+      );
+    }
+    return { ...safeArea };
+  }
+  isMobile() {
+    const environment = this.environmentApi.getEnvironment();
+    if (environment.platform === "ios" || environment.platform === "android") {
+      return true;
+    }
+    if (environment.browserInfo) {
+      return environment.browserInfo.isMobile;
+    }
+    return true;
+  }
+  isWeb() {
+    const environment = this.environmentApi.getEnvironment();
+    if (environment.platform === "web") {
+      return true;
+    }
+    if (environment.browserInfo && !environment.browserInfo.isMobile) {
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/system/MockSystemApi.ts
+var MockSystemApi = class {
+  constructor(deviceApi, environmentApi, venusApi) {
+    __publicField(this, "deviceApi");
+    __publicField(this, "environmentApi");
+    __publicField(this, "venusApi");
+    this.deviceApi = deviceApi;
+    this.environmentApi = environmentApi;
+    this.venusApi = venusApi;
+  }
+  getDevice() {
+    return this.deviceApi.getDevice();
+  }
+  getEnvironment() {
+    return this.environmentApi.getEnvironment();
+  }
+  getSafeArea() {
+    const safeArea = this.venusApi._safeAreaData;
+    if (!safeArea) {
+      return {
+        top: 0,
+        right: 0,
+        bottom: 34,
+        left: 0
+      };
+    }
+    return { ...safeArea };
+  }
+  isMobile() {
+    const environment = this.environmentApi.getEnvironment();
+    if (environment.platform === "ios" || environment.platform === "android") {
+      return true;
+    }
+    if (environment.browserInfo) {
+      return environment.browserInfo.isMobile;
+    }
+    return true;
+  }
+  isWeb() {
+    const environment = this.environmentApi.getEnvironment();
+    if (environment.platform === "web") {
+      return true;
+    }
+    if (environment.browserInfo && !environment.browserInfo.isMobile) {
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/system/index.ts
+function initializeSystem(venusApi, host) {
+  venusApi.system = host.system;
+  venusApi.isMobile = () => {
+    console.warn(
+      "[Venus SDK] DEPRECATED: VenusAPI.isMobile() is deprecated. Use VenusAPI.system.isMobile() instead."
+    );
+    return host.system.isMobile();
+  };
+  venusApi.isWeb = () => {
+    console.warn(
+      "[Venus SDK] DEPRECATED: VenusAPI.isWeb() is deprecated. Use VenusAPI.system.isWeb() instead."
+    );
+    return host.system.isWeb();
+  };
+}
+
+// src/device/HostDeviceApi.ts
+var HostDeviceApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  getDevice() {
+    const device = this.venusApi._deviceData;
+    if (!device) {
+      throw new Error(
+        "[Venus SDK] Device info not available. You must await VenusAPI.initializeAsync() before calling getDevice(). INIT_SDK has not completed."
+      );
+    }
+    return device;
+  }
+};
+
+// src/device/MockDeviceApi.ts
+var MockDeviceApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  getDevice() {
+    const width = typeof window !== "undefined" ? window.innerWidth : 400;
+    const height = typeof window !== "undefined" ? window.innerHeight : 800;
+    return {
+      screenSize: { width, height },
+      viewportSize: {
+        width: width - 20,
+        // account for safe area
+        height: height - 20
+      },
+      orientation: width > height ? "landscape" : "portrait",
+      pixelRatio: typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1,
+      fontScale: 1,
+      deviceType: width > 768 ? "tablet" : "phone",
+      hapticsEnabled: false,
+      haptics: { supported: false, enabled: false }
+    };
+  }
+};
+
+// src/environment/HostEnvironmentApi.ts
+var HostEnvironmentApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  getEnvironment() {
+    const environment = this.venusApi._environmentData;
+    if (!environment) {
+      throw new Error(
+        "[Venus SDK] Environment info not available. You must await VenusAPI.initializeAsync() before calling getEnvironment(). INIT_SDK has not completed."
+      );
+    }
+    return environment;
+  }
+};
+
+// src/environment/MockEnvironmentApi.ts
+var MockEnvironmentApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  getEnvironment() {
+    const getBrowser = () => {
+      if (typeof navigator === "undefined") return "unknown";
+      const userAgent = navigator.userAgent;
+      if (/chrome|chromium|crios/i.test(userAgent)) return "chrome";
+      if (/firefox|fxios/i.test(userAgent)) return "firefox";
+      if (/safari/i.test(userAgent)) return "safari";
+      if (/edg/i.test(userAgent)) return "edge";
+      if (/opera|opr/i.test(userAgent)) return "opera";
+      return "unknown";
+    };
+    return {
+      isDevelopment: true,
+      platform: "web",
+      platformVersion: "mock-1.0",
+      browserInfo: {
+        browser: getBrowser(),
+        userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "mock-agent",
+        isMobile: typeof navigator !== "undefined" ? /Mobi|Android/i.test(navigator.userAgent) : false,
+        isTablet: typeof navigator !== "undefined" ? /iPad|Tablet|Pad/i.test(navigator.userAgent) : false,
+        language: typeof navigator !== "undefined" ? navigator.language || "en-US" : "en-US"
+      }
+    };
+  }
+};
+
+// src/cdn/HostCdnApi.ts
 var HostCdnApi = class {
   constructor(baseUrl) {
     __publicField(this, "baseUrl");
@@ -4307,7 +4325,8 @@ var HostCdnApi = class {
       return index === pathParts.length - 1 ? encodeURIComponent(part) : part;
     });
     const encodedSubPath = encodedParts.join("/");
-    const fullUrl = this.baseUrl + "/" + encodedSubPath;
+    const cacheBust = Date.now();
+    const fullUrl = this.baseUrl + "/" + encodedSubPath + `?cacheBust=${cacheBust}`;
     return fullUrl;
   }
   resolveAvatarAssetUrl(subPath) {
@@ -4322,9 +4341,15 @@ var HostCdnApi = class {
 
 // src/cdn/MockCdnApi.ts
 var MockCdnApi = class {
-  constructor() {
-    __publicField(this, "baseUrl");
-    this.baseUrl = "https://venus-static-01293ak.web.app/";
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  get baseUrl() {
+    return this.venusApi._mock?.cdnBaseUrl ?? "https://venus-static-01293ak.web.app/";
+  }
+  get forceRemoteCdn() {
+    return this.venusApi._mock?.cdnForceRemote ?? false;
   }
   async fetchBlob(path, options) {
     const controller = new AbortController();
@@ -4361,6 +4386,10 @@ var MockCdnApi = class {
       return subPath;
     }
     const cleanSubPath = subPath.startsWith("/") ? subPath.slice(1) : subPath;
+    const isLocalhost = typeof window !== "undefined" && (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1");
+    if (isLocalhost && !this.forceRemoteCdn) {
+      return `/${cleanSubPath}`;
+    }
     const pathParts = cleanSubPath.split("/");
     const encodedParts = pathParts.map((part, index) => {
       return index === pathParts.length - 1 ? encodeURIComponent(part) : part;
@@ -4482,96 +4511,6 @@ function initializeCdn(venusApi, host) {
   venusApi.cdn = host.cdn;
 }
 
-// src/post/MockPostApi.ts
-init_core();
-var MockPostApi = class {
-  constructor(venusApi) {
-    __publicField(this, "venusApi");
-    this.venusApi = venusApi;
-  }
-  async getPostInfo() {
-    const venusApi = this.venusApi;
-    await createMockDelay(MOCK_DELAYS.short);
-    return venusApi._mock.currentPostInteractions;
-  }
-  async openCommentsAsync() {
-    await createMockDelay(MOCK_DELAYS.short);
-    return {
-      opened: true,
-      commentsCount: 0
-    };
-  }
-  async toggleFollowAsync() {
-    const venusApi = this.venusApi;
-    console.log("[Venus Mock] *Toggling follow status");
-    await createMockDelay(MOCK_DELAYS.short);
-    venusApi._mock.currentPostInteractions.isFollowing = !venusApi._mock.currentPostInteractions.isFollowing;
-    const isFollowing = venusApi._mock.currentPostInteractions.isFollowing;
-    return {
-      isFollowing,
-      action: isFollowing ? "followed" : "unfollowed"
-    };
-  }
-  async toggleLikeAsync() {
-    const venusApi = this.venusApi;
-    await createMockDelay(MOCK_DELAYS.short);
-    venusApi._mock.currentPostInteractions.isLiked = !venusApi._mock.currentPostInteractions.isLiked;
-    const isLiked = venusApi._mock.currentPostInteractions.isLiked;
-    if (isLiked) {
-      venusApi._mock.currentPostInteractions.likesCount++;
-    } else {
-      venusApi._mock.currentPostInteractions.likesCount = Math.max(
-        0,
-        venusApi._mock.currentPostInteractions.likesCount - 1
-      );
-    }
-    return {
-      isLiked,
-      likesCount: venusApi._mock.currentPostInteractions.likesCount,
-      action: isLiked ? "liked" : "unliked"
-    };
-  }
-};
-
-// src/post/RpcPostApi.ts
-var RpcPostApi = class {
-  constructor(rpcClient) {
-    __publicField(this, "rpcClient");
-    this.rpcClient = rpcClient;
-  }
-  getPostInfo() {
-    return this.rpcClient.call("H5_GET_POST_INTERACTIONS" /* GET_POST_INTERACTIONS */, {});
-  }
-  openCommentsAsync() {
-    return this.rpcClient.call("H5_OPEN_COMMENTS" /* OPEN_COMMENTS */, {});
-  }
-  toggleFollowAsync() {
-    return this.rpcClient.call(
-      "H5_TOGGLE_FOLLOW" /* TOGGLE_FOLLOW */,
-      {}
-    );
-  }
-  toggleLikeAsync() {
-    return this.rpcClient.call("H5_TOGGLE_LIKE" /* TOGGLE_LIKE */, {});
-  }
-};
-
-// src/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.openCommentsAsync = async () => {
-    await host.post.openCommentsAsync();
-  };
-}
-
 // src/haptics/RpcHapticsApi.ts
 var RpcHapticsApi = class {
   constructor(rpcClient) {
@@ -4762,871 +4701,426 @@ function initializeLifecycleApi(venusApi, host) {
   venusApi.lifecycles = host.lifecycle;
 }
 
-// src/simulation/utils.ts
-function sumContributions(contributions) {
-  const totals = {};
-  for (const profileId in contributions) {
-    for (const entityId in contributions[profileId]) {
-      const amount = contributions[profileId][entityId] || 0;
-      totals[entityId] = (totals[entityId] || 0) + amount;
-    }
+// 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, "status");
+    __publicField(this, "customMetadata");
+    __publicField(this, "admins");
+    __publicField(this, "roomCode");
+    __publicField(this, "description");
+    __publicField(this, "data");
+    __publicField(this, "version");
+    this.id = roomData.id;
+    this.name = roomData.name;
+    this.players = Array.isArray(roomData.currentPlayers) ? [...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.status = roomData.status;
+    this.customMetadata = roomData.customMetadata || {};
+    this.admins = Array.isArray(roomData.admins) ? [...roomData.admins] : [];
+    this.roomCode = roomData.roomCode;
+    this.description = roomData.description;
+    this.data = roomData.data || {};
+    this.version = roomData.version;
   }
-  return totals;
+};
+
+// src/rooms/setupRoomNotifications.ts
+function invokeCallbacks(callbacks, event, context) {
+  callbacks.forEach((callback) => {
+    try {
+      callback(event);
+    } catch (error) {
+      console.error(`[Venus SDK] Error in ${context} callback:`, error);
+      throw error;
+    }
+  });
+}
+function setupRoomNotifications(transport, getSubscriptions) {
+  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 event = {
+        type: "H5_ROOM_DATA_UPDATED",
+        roomId,
+        roomData,
+        timestamp: messageData.timestamp
+      };
+      invokeCallbacks(callbacks, event, "room data");
+    }
+    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 event = {
+        type: message.type,
+        roomId,
+        message: messageData.message,
+        timestamp: messageData.timestamp
+      };
+      invokeCallbacks(callbacks, event, "room message");
+    }
+    if (message.type === "app:h5:proposedMoveValidationUpdated") {
+      const messageData = message.data;
+      const { roomId } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.gameEvents[roomId] || [];
+      const event = {
+        type: "app:h5:proposedMoveValidationUpdated",
+        roomId,
+        proposedMoveData: messageData.proposedMoveData,
+        proposedMoveId: messageData.proposedMoveId,
+        changeType: messageData.changeType,
+        timestamp: messageData.timestamp
+      };
+      invokeCallbacks(callbacks, event, "game event");
+    }
+  });
 }
 
-// src/simulation/RpcSimulationApi.ts
-var RpcSimulationApi = class {
+// src/rooms/RpcRoomsApi.ts
+var RpcRoomsApi = class {
   constructor(rpcClient) {
     __publicField(this, "rpcClient");
-    __publicField(this, "_simulationConfig", null);
+    __publicField(this, "subscriptions");
     this.rpcClient = rpcClient;
+    this.subscriptions = {
+      data: {},
+      messages: {},
+      gameEvents: {}
+    };
   }
-  async validateSlotAssignmentAsync(containerId, slotId, itemId) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_VALIDATE_ASSIGNMENT" /* H5_SIMULATION_VALIDATE_ASSIGNMENT */,
+  /**
+   * Get the subscription state for external access (used by setupRoomNotifications)
+   */
+  getSubscriptions() {
+    return this.subscriptions;
+  }
+  /**
+   * Set up room notification routing from the transport
+   */
+  setupNotifications(transport) {
+    setupRoomNotifications(transport, () => this.getSubscriptions());
+  }
+  async createRoomAsync(options) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_CREATE" /* H5_ROOM_CREATE */,
       {
-        containerId,
-        slotId,
-        itemId
+        options
       }
     );
+    if (response.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : "Failed to create room";
+      throw new Error(errorMessage);
+    }
+    const room = new VenusRoom(response.roomData);
+    return room;
   }
-  sumContributions(contributions) {
-    return sumContributions(contributions);
-  }
-  executeBatchOperationsAsync(operations, validateOnly) {
-    return this.rpcClient.call("H5_SIMULATION_BATCH_OPERATIONS" /* H5_SIMULATION_BATCH_OPERATIONS */, {
-      operations,
-      validateOnly
-    });
-  }
-  async getAvailableItemsAsync(containerId, slotId) {
+  async joinOrCreateRoomAsync(options) {
     const response = await this.rpcClient.call(
-      "H5_SIMULATION_GET_AVAILABLE_ITEMS" /* H5_SIMULATION_GET_AVAILABLE_ITEMS */,
+      "H5_ROOM_JOIN_OR_CREATE" /* H5_ROOM_JOIN_OR_CREATE */,
       {
-        containerId,
-        slotId
+        options
       }
     );
-    return response.availableItems || [];
+    if (response.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : "Failed to join or create room";
+      throw new Error(errorMessage);
+    }
+    const room = new VenusRoom(response.value.roomData);
+    return {
+      action: response.value.action,
+      room,
+      playersJoined: response.value.playersJoined
+    };
   }
-  calculatePowerPreviewAsync(containerId, slotId, candidateItemId) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_CALCULATE_POWER_PREVIEW" /* H5_SIMULATION_CALCULATE_POWER_PREVIEW */,
+  async joinRoomByCodeAsync(roomCode) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_JOIN_BY_CODE" /* H5_ROOM_JOIN_BY_CODE */,
       {
-        containerId,
-        slotId,
-        candidateItemId
+        roomCode
       }
     );
+    if (response?.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : "Failed to join room by code";
+      throw new Error(errorMessage);
+    }
+    const room = new VenusRoom(response.roomData);
+    return room;
   }
-  assignItemToSlotAsync(containerId, slotId, itemId) {
-    return this.rpcClient.call("H5_SIMULATION_ASSIGN_ITEM" /* H5_SIMULATION_ASSIGN_ITEM */, {
-      containerId,
-      slotId,
-      itemId
-    });
-  }
-  removeItemFromSlotAsync(containerId, slotId) {
-    return this.rpcClient.call("H5_SIMULATION_REMOVE_ITEM" /* H5_SIMULATION_REMOVE_ITEM */, {
-      containerId,
-      slotId
-    });
-  }
-  async getSlotContainersAsync() {
-    const response = await this.rpcClient.call(
-      "H5_SIMULATION_GET_CONTAINERS" /* H5_SIMULATION_GET_CONTAINERS */,
-      {}
-    );
-    return response.containers || [];
-  }
-  async getSlotAssignmentsAsync(containerId) {
-    const response = await this.rpcClient.call(
-      "H5_SIMULATION_GET_ASSIGNMENTS" /* H5_SIMULATION_GET_ASSIGNMENTS */,
-      {
-        containerId
-      }
-    );
-    return Array.isArray(response) ? response : response.assignments || [];
-  }
-  async getStateAsync(roomId) {
+  // Get user's rooms with optional filtering
+  async getUserRoomsAsync(options = {}) {
     const response = await this.rpcClient.call(
-      "H5_SIMULATION_GET_STATE" /* H5_SIMULATION_GET_STATE */,
+      "H5_ROOM_GET_USER_ROOMS" /* H5_ROOM_GET_USER_ROOMS */,
       {
-        roomId
+        includeArchived: options.includeArchived ?? false
       }
     );
-    console.log("[Venus SDK] getStateAsync", response);
-    if (response.configuration) {
-      this._simulationConfig = response.configuration;
-    }
-    return response;
-  }
-  async getConfigAsync(roomId) {
-    if (this._simulationConfig) {
-      return this._simulationConfig;
-    }
-    const config = await this.rpcClient.call(
-      "H5_SIMULATION_GET_CONFIG" /* H5_SIMULATION_GET_CONFIG */,
-      {}
-    );
-    console.log("[Venus SDK] getConfigAsync", config);
-    if (config) {
-      this._simulationConfig = config;
-      return config;
+    if (response?.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : "Failed to get user rooms";
+      throw new Error(errorMessage);
     }
-    throw new Error("No simulation configuration available");
-  }
-  executeRecipeAsync(recipeId, inputs, options) {
-    return this.rpcClient.call("H5_SIMULATION_EXECUTE_RECIPE" /* H5_SIMULATION_EXECUTE_RECIPE */, {
-      recipeId,
-      inputs,
-      roomId: options?.roomId,
-      batchAmount: options?.batchAmount,
-      allowPartialBatch: options?.allowPartialBatch,
-      entity: options?.entity
-    });
-  }
-  collectRecipeAsync(runId) {
-    return this.rpcClient.call("H5_SIMULATION_COLLECT_RECIPE" /* H5_SIMULATION_COLLECT_RECIPE */, {
-      runId
-    });
-  }
-  getActiveRunsAsync(options) {
-    return this.rpcClient.call("H5_SIMULATION_GET_ACTIVE_RUNS" /* H5_SIMULATION_GET_ACTIVE_RUNS */, {
-      roomId: options?.roomId
-    });
-  }
-  executeScopedRecipeAsync(recipeId, entity, inputs, options) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_EXECUTE_SCOPED_RECIPE" /* H5_SIMULATION_EXECUTE_SCOPED_RECIPE */,
-      {
-        recipeId,
-        entity,
-        inputs,
-        roomId: options?.roomId ?? null,
-        options
+    const venusRooms = [];
+    for (const roomData of response.rooms) {
+      if (!roomData.id) {
+        console.warn("[Venus SDK] getUserRooms: Skipping room with missing ID:", roomData);
+        continue;
       }
-    );
+      try {
+        const venusRoom = new VenusRoom(roomData);
+        venusRooms.push(venusRoom);
+      } catch (error) {
+        console.warn(
+          "[Venus SDK] getUserRooms: Failed to create VenusRoom object:",
+          error,
+          roomData
+        );
+      }
+    }
+    return venusRooms;
   }
-  getAvailableRecipesAsync(options) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_AVAILABLE_RECIPES" /* H5_SIMULATION_GET_AVAILABLE_RECIPES */,
+  async updateRoomDataAsync(room, updates, options = {}) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_UPDATE_DATA" /* H5_ROOM_UPDATE_DATA */,
       {
-        roomId: options?.roomId || null,
-        includeActorRecipes: options?.includeActorRecipes || false
+        roomId: room.id,
+        updates,
+        merge: options.merge ?? true
       }
     );
+    if (response?.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : "Failed to update room data";
+      throw new Error(errorMessage);
+    }
   }
-  getRecipeRequirementsAsync(recipe) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_RECIPE_REQUIREMENTS */,
+  async getRoomDataAsync(room) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_GET_DATA" /* H5_ROOM_GET_DATA */,
       {
-        recipeId: recipe.recipeId,
-        entity: recipe.entity,
-        batchAmount: recipe.batchAmount
+        roomId: room.id
       }
     );
+    if (response?.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : "Failed to get room data";
+      throw new Error(errorMessage);
+    }
+    return response.data;
   }
-  getBatchRecipeRequirementsAsync(recipes) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS */,
+  async sendRoomMessageAsync(venusRoom, request) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_SEND_MESSAGE" /* H5_ROOM_SEND_MESSAGE */,
       {
-        recipes
+        roomId: venusRoom.id,
+        message: request.message,
+        metadata: request.metadata
       }
     );
+    if (response?.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : "Failed to send message";
+      throw new Error(errorMessage);
+    }
+    return response.messageId;
   }
-  triggerRecipeChainAsync(recipeId, options) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_TRIGGER_RECIPE_CHAIN" /* H5_SIMULATION_TRIGGER_RECIPE_CHAIN */,
+  async leaveRoomAsync(room) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_LEAVE" /* H5_ROOM_LEAVE */,
       {
-        triggerRecipeId: recipeId,
-        context: options?.context,
-        roomId: options?.roomId
+        roomId: room.id
       }
     );
+    if (response?.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : "Failed to leave room";
+      throw new Error(errorMessage);
+    }
   }
-  getEntityMetadataAsync(entityId) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_ENTITY_METADATA" /* H5_SIMULATION_GET_ENTITY_METADATA */,
+  async startRoomGameAsync(room, options = {}) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_START_GAME" /* H5_ROOM_START_GAME */,
       {
-        entityId
+        roomId: room.id,
+        gameConfig: options.gameConfig ?? {},
+        turnOrder: options.turnOrder ?? null
       }
     );
+    if (response?.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : "Failed to start game";
+      throw new Error(errorMessage);
+    }
   }
-  async resolveFieldValueAsync(entityId, fieldPath, entity) {
+  async proposeMoveAsync(room, proposalPayload) {
     const response = await this.rpcClient.call(
-      "H5_SIMULATION_RESOLVE_VALUE" /* H5_SIMULATION_RESOLVE_VALUE */,
+      "h5:room:proposeMove" /* H5_ROOM_PROPOSE_MOVE */,
       {
-        entityId,
-        fieldPath,
-        entity
+        roomId: room.id,
+        gameSpecificState: proposalPayload.gameSpecificState,
+        moveType: proposalPayload.moveType,
+        clientContext: proposalPayload.clientContext,
+        clientProposalId: proposalPayload.clientProposalId
       }
     );
-    return response.value;
-  }
-};
-
-// src/simulation/MockSimulationApi.ts
-function generateAppIdentifier2() {
-  if (typeof window === "undefined") return "unknown-app";
-  const url = window.location.href;
-  const match = url.match(/\/H5\/([^\/]+)/);
-  return match ? match[1] : "unknown-app";
-}
-var MockSimulationApi = class {
-  constructor(simulationConfig = null) {
-    __publicField(this, "mockSimulationConfigs", /* @__PURE__ */ new Map());
-    // appIdentifier -> config
-    __publicField(this, "mockSimulationStates", /* @__PURE__ */ new Map());
-    // appIdentifier -> config
-    __publicField(this, "mockActiveTimers", /* @__PURE__ */ new Map());
-    // appIdentifier -> timers[]
-    __publicField(this, "appId");
-    __publicField(this, "providedSimulationConfig");
-    this.appId = generateAppIdentifier2();
-    this.providedSimulationConfig = simulationConfig;
-  }
-  sumContributions(contributions) {
-    return sumContributions(contributions);
-  }
-  async validateSlotAssignmentAsync(containerId, slotId, itemId) {
-    this.log("validateSlotAssignmentAsync called:", {
-      containerId,
-      slotId,
-      itemId
-    });
-    return { valid: true, message: "Mock validation successful" };
-  }
-  async executeBatchOperationsAsync(operations, validateOnly) {
-    this.log("executeBatchOperationsAsync called:", {
-      operations,
-      validateOnly
-    });
-    return {
-      success: true,
-      results: operations.map(() => ({ success: true }))
-    };
-  }
-  async getAvailableItemsAsync(containerId, slotId) {
-    console.log("[Venus Simulation Mock] getAvailableItemsAsync called:", {
-      containerId,
-      slotId
-    });
-    const appIdentifier = generateAppIdentifier2();
-    const mockSimulationConfigs = this.mockSimulationConfigs;
-    const config = mockSimulationConfigs.get(appIdentifier) || {
-      entities: {}
-    };
-    const availableItems = Object.entries(config.entities).slice(0, 3).map(([entityId, entity]) => ({
-      entityId,
-      quantity: 1,
-      metadata: entity.metadata,
-      powerPreview: 100
-      // Mock power value
-    }));
-    return availableItems;
-  }
-  async calculatePowerPreviewAsync(containerId, slotId, candidateItemId) {
-    this.log("calculatePowerPreviewAsync called:", {
-      containerId,
-      slotId,
-      candidateItemId
-    });
-    return {
-      currentPower: 1e3,
-      previewPower: 1200,
-      powerDelta: 200,
-      breakdown: { base: 800, weapon: 200, armor: 200 }
-    };
-  }
-  async getSlotContainersAsync() {
-    this.log("getSlotContainersAsync called");
-    const appIdentifier = this.appId;
-    const mockSimulationConfigs = this.mockSimulationConfigs;
-    const config = mockSimulationConfigs.get(appIdentifier) || {
-      entities: {}
-    };
-    const containers = Object.entries(config.entities).filter(([_2, entity]) => entity.metadata?.slots).map(([entityId, entity]) => ({
-      entityId,
-      slots: entity.metadata?.slots,
-      isOwned: true
-      // Mock: assume all containers are owned
-    }));
-    return containers;
-  }
-  async getSlotAssignmentsAsync(containerId) {
-    this.log("getSlotAssignmentsAsync called for:", containerId);
-    return [];
-  }
-  async resolveFieldValueAsync(entityId, fieldPath, entity) {
-    this.log("resolveFieldValueAsync called:", {
-      entityId,
-      fieldPath,
-      entity
-    });
-    const mockValues = {
-      basePower: 850,
-      weaponPower: 300,
-      armorPower: 150,
-      total_power: 1300,
-      total_defense_power: 5e3
-    };
-    return mockValues[fieldPath] || 100;
-  }
-  async getEntityMetadataAsync(entityId) {
-    this.log("getEntityMetadataAsync called for:", entityId);
-    const mockSimulationConfigs = this.mockSimulationConfigs;
-    const appIdentifier = this.appId;
-    const config = mockSimulationConfigs.get(
-      appIdentifier
-    ) || {
-      entities: {}};
-    const entity = config.entities[entityId];
-    return entity?.metadata || {};
-  }
-  async collectRecipeAsync(runId) {
-    this.log("collectRecipeAsync called:", { runId });
-    const mockRewards = {
-      cash: Math.floor(Math.random() * 1e3) + 500,
-      experience: Math.floor(Math.random() * 50) + 25
-    };
-    return {
-      success: true,
-      runId,
-      rewards: mockRewards,
-      message: "Rewards collected successfully"
-    };
-  }
-  executeRecipeAsync(recipeId, inputs, options) {
-    this.log("executeRecipeAsync called:", {
-      recipeId,
-      inputs,
-      options
-    });
-    const appIdentifier = this.appId;
-    return this.executeRecipe(appIdentifier, recipeId, inputs);
-  }
-  async executeScopedRecipeAsync(recipeId, entity, inputs, options) {
-    this.log("executeScopedRecipeAsync called:", {
-      recipeId,
-      entity,
-      inputs,
-      roomId: options?.roomId,
-      options
-    });
-    return {
-      success: true,
-      message: "Mock scoped recipe execution successful"
-    };
-  }
-  async getActiveRunsAsync(options) {
-    this.log("getActiveRunsAsync called:", options);
-    const appIdentifier = this.appId;
-    let state = this.mockSimulationStates.get(appIdentifier);
-    if (!state) {
-      state = await this.initializeSimulationState(appIdentifier);
-    }
-    return state.activeRuns || [];
-  }
-  async getAvailableRecipesAsync(options) {
-    this.log("getAvailableRecipesAsync called:", options);
-    const baseRecipes = [
-      { id: "collect_resources", scope: "player", clientViewable: true },
-      { id: "upgrade_equipment", scope: "player", clientViewable: true }
-    ];
-    if (options?.roomId) {
-      baseRecipes.push(
-        { id: "room_upgrade", scope: "room", clientViewable: true },
-        { id: "cooperative_project", scope: "room", clientViewable: true }
-      );
-    }
-    if (options?.includeActorRecipes && options?.roomId) {
-      baseRecipes.push(
-        { id: "trade_with_npc", scope: "actor", clientViewable: true },
-        { id: "attack_monster", scope: "actor", clientViewable: true }
-      );
+    if (response?.success === false) {
+      const errorMessage = typeof response.error === "string" ? response.error : "Failed to propose move";
+      throw new Error(errorMessage);
     }
-    return { success: true, recipes: baseRecipes };
-  }
-  async getBatchRecipeRequirementsAsync(recipes) {
-    this.log("getBatchRecipeRequirementsAsync called:", {
-      count: recipes?.length
-    });
-    const results = (recipes || []).map((q) => ({
-      recipeId: q.recipeId,
-      entity: q.entity || null,
-      amount: q.batchAmount || 1,
-      inputs: { cash: "BE:0" },
-      canAfford: true,
-      disabled: false
-    }));
-    return { success: true, results };
-  }
-  async getRecipeRequirementsAsync(recipe) {
-    this.log("getRecipeRequirementsAsync called:", recipe);
-    return {
-      recipeId: recipe.recipeId,
-      entity: recipe.entity || null,
-      amount: recipe.batchAmount,
-      inputs: { cash: "BE:0" },
-      canAfford: true,
-      disabled: false
-    };
+    return response.data;
   }
-  async triggerRecipeChainAsync(recipeId, options) {
-    this.log("triggerRecipeChainAsync called:", { recipeId, ...options });
+  async validateMoveAsync(_room, moveId, verdict) {
     return {
       success: true,
-      message: "Mock recipe chain triggered successfully"
+      moveId,
+      isValid: verdict.isValid,
+      reason: verdict.reason
     };
   }
-  log(message, ...args) {
-    console.log(`[Venus Sim Mock] ${message}`, args);
-  }
-  async executeRecipe(appIdentifier, recipeId, inputs) {
-    this.log(`Executing recipe ${recipeId} for ${appIdentifier}`, inputs);
-    const mockSimulationConfigs = this.mockSimulationConfigs;
-    const mockSimulationStates = this.mockSimulationStates;
-    let config = mockSimulationConfigs.get(appIdentifier);
-    let state = mockSimulationStates.get(appIdentifier);
-    if (!config || !state) {
-      state = await this.initializeSimulationState(appIdentifier);
-      config = mockSimulationConfigs.get(appIdentifier);
-      if (!config) {
-        throw new Error("Failed to initialize simulation config");
-      }
-    }
-    const recipe = config.recipes?.[recipeId];
-    if (!recipe) {
-      throw new Error(`Recipe ${recipeId} not found`);
-    }
-    if (state.disabledRecipes?.includes(recipeId)) {
-      throw new Error(`Recipe ${recipeId} is disabled`);
-    }
-    if (recipe.inputs) {
-      for (const [entityId, required] of Object.entries(recipe.inputs)) {
-        const available = state.inventory[entityId] || 0;
-        if (available < required) {
-          throw new Error(
-            `Insufficient ${entityId}: required ${required}, available ${available}`
-          );
-        }
+  async subscribeAsync(room, options = {}) {
+    const roomId = room.id;
+    const existingData = this.subscriptions.data[roomId];
+    const existingMessages = this.subscriptions.messages[roomId];
+    const existingGameEvents = this.subscriptions.gameEvents[roomId];
+    const subscribeToData = Boolean(options.onData) && (existingData?.length ?? 0) === 0;
+    const subscribeToMessages = Boolean(options.onMessages) && (existingMessages?.length ?? 0) === 0;
+    const subscribeToProposedMoves = Boolean(options.onGameEvents) && (existingGameEvents?.length ?? 0) === 0;
+    if (subscribeToData || subscribeToMessages || subscribeToProposedMoves) {
+      try {
+        await this.rpcClient.call("H5_ROOM_SUBSCRIBE" /* H5_ROOM_SUBSCRIBE */, {
+          roomId,
+          subscribeToData,
+          subscribeToMessages,
+          subscribeToProposedMoves
+        });
+      } catch (error) {
+        console.error("[Venus SDK] Failed to set up room subscription:", error);
+        throw error;
       }
     }
-    if (recipe.inputs) {
-      for (const [entityId, input] of Object.entries(recipe.inputs)) {
-        const inventoryValue = state.inventory[entityId] || 0;
-        if (typeof input === "number" && typeof inventoryValue === "number") {
-          state.inventory[entityId] = inventoryValue - input;
-        }
+    if (options.onData) {
+      if (!this.subscriptions.data[roomId]) {
+        this.subscriptions.data[roomId] = [];
       }
+      this.subscriptions.data[roomId].push(options.onData);
     }
-    if (recipe.beginEffects) {
-      this.applyEffects(state, recipe.beginEffects);
-    }
-    const runId = this.generateRunId();
-    const now = Date.now();
-    const expiresAt = now + (recipe.duration || 0);
-    const run = {
-      id: runId,
-      recipeId,
-      status: "running",
-      startTime: now,
-      expiresAt,
-      inputs: recipe.inputs || {}
-    };
-    state.activeRuns.push(run);
-    if (recipe.duration === 0) {
-      this.completeRun(appIdentifier, runId);
-      return { status: "completed", runId };
-    } else {
-      const mockActiveTimers = this.mockActiveTimers;
-      const timer = setTimeout(() => {
-        this.completeRun(appIdentifier, runId);
-      }, recipe.duration);
-      const timers = mockActiveTimers.get(appIdentifier) || [];
-      timers.push(timer);
-      mockActiveTimers.set(appIdentifier, timers);
-      return {
-        status: "running",
-        runId,
-        expiresAt: new Date(expiresAt).toISOString()
-      };
-    }
-  }
-  async initializeSimulationState(appIdentifier) {
-    this.log(`Initializing simulation state for ${appIdentifier}`);
-    const providedSimulationConfig = this.providedSimulationConfig;
-    const mockSimulationConfigs = this.mockSimulationConfigs;
-    const mockSimulationStates = this.mockSimulationStates;
-    const mockActiveTimers = this.mockActiveTimers;
-    const config = providedSimulationConfig || {
-      version: "1.0",
-      entities: {},
-      recipes: {}
-    };
-    mockSimulationConfigs.set(appIdentifier, config);
-    const initialInventory = {};
-    if (providedSimulationConfig && config.entities) {
-      Object.keys(config.entities).forEach((entityId) => {
-        initialInventory[entityId] = 0;
-      });
+    if (options.onMessages) {
+      if (!this.subscriptions.messages[roomId]) {
+        this.subscriptions.messages[roomId] = [];
+      }
+      this.subscriptions.messages[roomId].push(options.onMessages);
     }
-    const state = {
-      inventory: initialInventory,
-      activeRuns: [],
-      disabledRecipes: new Array()
-    };
-    if (config.recipes) {
-      Object.entries(config.recipes).forEach(([recipeId, recipe]) => {
-        if (recipe.metadata?.startsDisabled) {
-          state.disabledRecipes.push(recipeId);
-        }
-      });
+    if (options.onGameEvents) {
+      if (!this.subscriptions.gameEvents[roomId]) {
+        this.subscriptions.gameEvents[roomId] = [];
+      }
+      this.subscriptions.gameEvents[roomId].push(options.onGameEvents);
     }
-    mockSimulationStates.set(appIdentifier, state);
-    mockActiveTimers.set(appIdentifier, []);
-    console.log(
-      `[Venus Simulation Mock] Initialized state for ${appIdentifier}:`,
-      state
-    );
-    if (config.recipes) {
-      Object.entries(config.recipes).forEach(([recipeId, recipe]) => {
-        const isAutoRestart = recipe.autoRestart || recipe.metadata?.autoRestart;
-        if (isAutoRestart && recipe.outputs) {
-          this.log(`Found auto-restart recipe: ${recipeId}`, {
-            topLevelAutoRestart: recipe.autoRestart,
-            metadataAutoRestart: recipe.metadata?.autoRestart,
-            hasOutputs: !!recipe.outputs,
-            duration: recipe.duration
-          });
-          const condition = recipe.maxRestartCondition || recipe.metadata?.maxRestartCondition;
-          if (condition && condition.entity) {
-            const currentAmount = initialInventory[condition.entity] || 0;
-            if (currentAmount < condition.maxValue) {
-              console.log(
-                `[Venus Simulation Mock] Auto-starting ${recipeId} at initialization`,
-                {
-                  currentAmount,
-                  maxValue: condition.maxValue,
-                  entity: condition.entity
-                }
-              );
-              setTimeout(() => {
-                this.executeRecipe(appIdentifier, recipeId, {});
-              }, 1e3);
-            }
-          } else {
-            console.log(
-              `[Venus Simulation Mock] Auto-starting ${recipeId} at initialization (no condition)`
-            );
-            setTimeout(() => {
-              this.executeRecipe(appIdentifier, recipeId, {});
-            }, 1e3);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      if (options.onData) {
+        const callbacks = this.subscriptions.data[roomId];
+        if (callbacks) {
+          const index = callbacks.indexOf(options.onData);
+          if (index > -1) {
+            callbacks.splice(index, 1);
           }
         }
-      });
-    }
-    return state;
-  }
-  generateRunId() {
-    return "run_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-  }
-  completeRun(appIdentifier, runId) {
-    this.log(`Completing run ${runId} for ${appIdentifier}`);
-    const mockSimulationConfigs = this.mockSimulationConfigs;
-    const mockSimulationStates = this.mockSimulationStates;
-    const config = mockSimulationConfigs.get(appIdentifier);
-    const state = mockSimulationStates.get(appIdentifier);
-    if (!config || !state) return;
-    const runIndex = state.activeRuns.findIndex((r2) => r2.id === runId);
-    if (runIndex === -1) return;
-    const run = state.activeRuns[runIndex];
-    const recipe = config.recipes?.[run.recipeId];
-    if (!recipe) return;
-    const outputs = {};
-    const rng = this.createSeededRandom(runId);
-    if (recipe.outputs) {
-      for (const [entityId, value] of Object.entries(recipe.outputs)) {
-        if (typeof value === "number") {
-          outputs[entityId] = value;
-        } else if (typeof value === "object" && value != null && "min" in value && "max" in value && typeof value.min == "number" && typeof value.max === "number") {
-          outputs[entityId] = Math.floor(rng() * (value.max - value.min + 1)) + value.min;
-        }
       }
-    }
-    for (const [entityId, amount] of Object.entries(outputs)) {
-      state.inventory[entityId] = (state.inventory[entityId] || 0) + amount;
-    }
-    if (recipe.endEffects) {
-      this.applyEffects(state, recipe.endEffects);
-    }
-    run.status = "completed";
-    run.outputs = outputs;
-    state.activeRuns.splice(runIndex, 1);
-    const isAutoRestart = recipe.autoRestart || recipe.metadata?.autoRestart;
-    if (isAutoRestart) {
-      console.log(
-        `[Venus Simulation Mock] Checking auto-restart for ${run.recipeId}`,
-        {
-          topLevelAutoRestart: recipe.autoRestart,
-          metadataAutoRestart: recipe.metadata?.autoRestart,
-          hasCondition: !!(recipe.maxRestartCondition || recipe.metadata?.maxRestartCondition)
-        }
-      );
-      const condition = recipe.maxRestartCondition || recipe.metadata?.maxRestartCondition;
-      if (condition) {
-        const currentAmount = state.inventory[condition.entity] || 0;
-        if (currentAmount < condition.maxValue) {
-          console.log(
-            `[Venus Simulation Mock] Auto-restarting ${run.recipeId}`,
-            {
-              currentAmount,
-              maxValue: condition.maxValue,
-              entity: condition.entity
-            }
-          );
-          setTimeout(() => {
-            this.executeRecipe(appIdentifier, run.recipeId, recipe.inputs || {});
-          }, 1e3);
+      if (options.onMessages) {
+        const callbacks = this.subscriptions.messages[roomId];
+        if (callbacks) {
+          const index = callbacks.indexOf(options.onMessages);
+          if (index > -1) {
+            callbacks.splice(index, 1);
+          }
         }
-      } else {
-        console.log(
-          `[Venus Simulation Mock] Auto-restarting ${run.recipeId} (no condition)`
-        );
-        setTimeout(() => {
-          this.executeRecipe(appIdentifier, run.recipeId, recipe.inputs || {});
-        }, 1e3);
       }
-    }
-    console.log(
-      `[Venus Simulation Mock] Completed run ${runId}, outputs:`,
-      outputs
-    );
-  }
-  createSeededRandom(seed) {
-    let hash = 0;
-    for (let i = 0; i < seed.length; i++) {
-      const char = seed.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return () => {
-      hash = (hash * 9301 + 49297) % 233280;
-      return hash / 233280;
-    };
-  }
-  applyEffects(state, effects) {
-    if (!effects || !Array.isArray(effects)) return;
-    for (const effect of effects) {
-      switch (effect.type) {
-        case "set":
-          state.inventory[effect.target] = effect.value;
-          console.log(
-            `[Venus Simulation Mock] Effect: Set ${effect.target} = ${effect.value}`
-          );
-          break;
-        case "add":
-          state.inventory[effect.target] = (state.inventory[effect.target] || 0) + effect.value;
-          console.log(
-            `[Venus Simulation Mock] Effect: Add ${effect.value} to ${effect.target} (new value: ${state.inventory[effect.target]})`
-          );
-          break;
-        case "multiply":
-          state.inventory[effect.target] = (state.inventory[effect.target] || 0) * effect.value;
-          console.log(
-            `[Venus Simulation Mock] Effect: Multiply ${effect.target} by ${effect.value} (new value: ${state.inventory[effect.target]})`
-          );
-          break;
-        case "min":
-          state.inventory[effect.target] = Math.max(
-            state.inventory[effect.target] || 0,
-            effect.value
-          );
-          console.log(
-            `[Venus Simulation Mock] Effect: Set ${effect.target} min ${effect.value} (new value: ${state.inventory[effect.target]})`
-          );
-          break;
-        case "max":
-          state.inventory[effect.target] = Math.min(
-            state.inventory[effect.target] || 0,
-            effect.value
-          );
-          console.log(
-            `[Venus Simulation Mock] Effect: Set ${effect.target} max ${effect.value} (new value: ${state.inventory[effect.target]})`
-          );
-          break;
-        case "enable_recipe":
-          if (state.disabledRecipes?.includes(effect.target)) {
-            state.disabledRecipes = state.disabledRecipes.filter(
-              (r2) => r2 !== effect.target
-            );
-            console.log(
-              `[Venus Simulation Mock] Effect: Enabled recipe ${effect.target}`
-            );
+      if (options.onGameEvents) {
+        const callbacks = this.subscriptions.gameEvents[roomId];
+        if (callbacks) {
+          const index = callbacks.indexOf(options.onGameEvents);
+          if (index > -1) {
+            callbacks.splice(index, 1);
           }
-          break;
-        case "disable_recipe":
-          if (!state.disabledRecipes) state.disabledRecipes = [];
-          if (!state.disabledRecipes.includes(effect.target)) {
-            state.disabledRecipes.push(effect.target);
-            console.log(
-              `[Venus Simulation Mock] Effect: Disabled recipe ${effect.target}`
-            );
-          }
-          break;
-        case "trigger_recipe":
-          console.log(
-            `[Venus Simulation Mock] Effect: Trigger recipe ${effect.target} (not implemented)`
-          );
-          break;
-        default:
-          console.warn(
-            `[Venus Simulation Mock] Unknown effect type: ${effect.type}`
-          );
+        }
+      }
+      const hasAnySubscriptions = (this.subscriptions.data[roomId]?.length ?? 0) > 0 || (this.subscriptions.messages[roomId]?.length ?? 0) > 0 || (this.subscriptions.gameEvents[roomId]?.length ?? 0) > 0;
+      if (!hasAnySubscriptions) {
+        this.rpcClient.call("H5_ROOM_UNSUBSCRIBE" /* H5_ROOM_UNSUBSCRIBE */, {
+          roomId
+        }).catch((error) => {
+          console.error("[Venus SDK] Failed to clean up room subscription:", error);
+        });
       }
-    }
-  }
-  async getConfigAsync() {
-    console.log("[Venus Simulation Mock] getConfigAsync called");
-    const appIdentifier = this.appId;
-    const mockSimulationConfigs = this.mockSimulationConfigs;
-    const config = mockSimulationConfigs.get(appIdentifier) || {
-      version: "1.0",
-      entities: {},
-      recipes: {}
-    };
-    return config;
-  }
-  async getStateAsync(roomId) {
-    this.log("getStateAsync called:", roomId);
-    const appIdentifier = this.appId;
-    const mockSimulationStates = this.mockSimulationStates;
-    let state = mockSimulationStates.get(appIdentifier);
-    if (!state) {
-      state = await this.initializeSimulationState(appIdentifier);
-    }
-    const mockSimulationConfigs = this.mockSimulationConfigs;
-    return {
-      ...state,
-      roomId,
-      configuration: mockSimulationConfigs.get(appIdentifier)
     };
   }
-  async assignItemToSlotAsync(containerId, slotId, itemId) {
-    this.log("assignItemToSlotAsync called:", {
-      containerId,
-      slotId,
-      itemId
-    });
-    return { success: true, message: "Mock assignment successful" };
-  }
-  async removeItemFromSlotAsync(containerId, slotId) {
-    this.log("removeItemFromSlotAsync called:", {
-      containerId,
-      slotId
-    });
-    return { success: true, message: "Mock removal successful" };
-  }
 };
 
-// src/simulation/index.ts
-function initializeSimulation(venusApi, host) {
-  console.log("[Venus SDK] Initializing new Simulation Api");
-  venusApi.simulation = {
-    isEnabled: () => true
-  };
-  venusApi.simulation.getConfigAsync = () => {
-    return host.simulation.getConfigAsync();
-  };
-  venusApi.simulation.getStateAsync = (options) => {
-    return host.simulation.getStateAsync(options?.roomId);
-  };
-  venusApi.simulation.executeRecipeAsync = (recipeId, inputs, options) => {
-    return host.simulation.executeRecipeAsync(recipeId, inputs, options);
-  };
-  venusApi.simulation.getActiveRunsAsync = () => {
-    return host.simulation.getActiveRunsAsync();
-  };
-  venusApi.simulation.collectRecipeAsync = (runId) => {
-    return host.simulation.collectRecipeAsync(runId);
-  };
-  venusApi.simulation.executeScopedRecipeAsync = (recipeId, entity, inputs, roomId, options) => {
-    return host.simulation.executeScopedRecipeAsync(recipeId, entity, inputs, {
-      roomId,
-      ...options
-    });
-  };
-  venusApi.simulation.triggerRecipeChainAsync = (recipeId, context, roomId) => {
-    return host.simulation.triggerRecipeChainAsync(recipeId, {
-      context,
-      roomId
-    });
-  };
-  venusApi.simulation.getAvailableRecipesAsync = async (roomId, includeActorRecipes) => {
-    const result = await host.simulation.getAvailableRecipesAsync({
-      roomId,
-      includeActorRecipes
-    });
-    return result.recipes;
-  };
-  venusApi.simulation.getRecipeRequirementsAsync = (recipeId, entity, amount) => {
-    return host.simulation.getRecipeRequirementsAsync({
-      recipeId,
-      entity,
-      batchAmount: amount
-    });
-  };
-  venusApi.simulation.getBatchRecipeRequirementsAsync = (recipes) => {
-    return host.simulation.getBatchRecipeRequirementsAsync(recipes);
-  };
-  venusApi.simulation.resolveFieldValueAsync = (entityId, fieldPath, entity) => {
-    return host.simulation.resolveFieldValueAsync(entityId, fieldPath, entity);
-  };
-  venusApi.simulation.getEntityMetadataAsync = (entityId) => {
-    return host.simulation.getEntityMetadataAsync(entityId);
-  };
-  venusApi.simulation.getSlotAssignmentsAsync = (containerId) => {
-    return host.simulation.getSlotAssignmentsAsync(containerId);
-  };
-  venusApi.simulation.getSlotContainersAsync = () => {
-    return host.simulation.getSlotContainersAsync();
-  };
-  venusApi.simulation.assignItemToSlotAsync = (containerId, slotId, itemId) => {
-    return host.simulation.assignItemToSlotAsync(containerId, slotId, itemId);
-  };
-  venusApi.simulation.removeItemFromSlotAsync = (containerId, slotId) => {
-    return host.simulation.removeItemFromSlotAsync(containerId, slotId);
-  };
-  venusApi.simulation.getAvailableItemsAsync = (containerId, slotId) => {
-    return host.simulation.getAvailableItemsAsync(containerId, slotId);
-  };
-  venusApi.simulation.calculatePowerPreviewAsync = (containerId, slotId, candidateItemId) => {
-    return host.simulation.calculatePowerPreviewAsync(
-      containerId,
-      slotId,
-      candidateItemId
-    );
-  };
-  venusApi.simulation.executeBatchOperationsAsync = (operations, validateOnly) => {
-    return host.simulation.executeBatchOperationsAsync(operations, validateOnly);
-  };
-  venusApi.simulation.validateSlotAssignmentAsync = (containerId, slotId, itemId) => {
-    return host.simulation.validateSlotAssignmentAsync(
-      containerId,
-      slotId,
-      itemId
+// src/rooms/index.ts
+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 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."
     );
-  };
-  venusApi.simulation.sumContributions = (contributions) => {
-    return host.simulation.sumContributions(contributions);
-  };
+    return;
+  }
+  const venus = venusApi;
+  const existingNamespace = venus.rooms || {};
+  const roomsNamespace = Object.assign({}, existingNamespace);
+  const namespaceBindings = [
+    ["createRoomAsync"],
+    ["joinOrCreateRoomAsync"],
+    ["joinRoomByCodeAsync"],
+    ["getUserRoomsAsync"],
+    ["subscribeAsync"],
+    ["updateRoomDataAsync"],
+    ["getRoomDataAsync"],
+    ["sendRoomMessageAsync"],
+    ["leaveRoomAsync"],
+    ["startRoomGameAsync"],
+    ["proposeMoveAsync"],
+    ["validateMoveAsync"]
+  ];
+  namespaceBindings.forEach(([targetKey, sourceKey]) => {
+    bindMethod(roomsNamespace, targetKey, roomsApi, sourceKey);
+  });
+  venus.rooms = roomsNamespace;
 }
 
-// src/MockHost.ts
-init_rooms();
-
 // src/logging/MockLoggingApi.ts
 var MockLoggingApi = class {
   logDebug(message, ...args) {
@@ -5702,9 +5196,16 @@ function initializeLoggingApi(venusApi, host) {
   };
 }
 
-// src/shared-assets/consts.ts
-var BurgerTimeAssetsCdnPath = "burger-time/Core.stow";
-var CharacterAssetsCdnPath = "burger-time/Character.stow";
+// src/shared-assets/base64Utils.ts
+function base64ToArrayBuffer(base64) {
+  const binaryString = atob(base64);
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
 
 // src/shared-assets/RpcSharedAssetsApi.ts
 var RpcSharedAssetsApi = class {
@@ -5714,46 +5215,22 @@ var RpcSharedAssetsApi = class {
     this.rpcClient = rpcClient;
     this.venusApi = venusApi;
   }
-  async loadBurgerTimeAssetsBundle() {
-    try {
-      const response = await this.rpcClient.callT("H5_LOAD_EMBEDDED_ASSET" /* H5_LOAD_EMBEDDED_ASSET */, {
-        assetKey: "burgerTimeCoreBundle"
-      });
-      return base64ToArrayBuffer(response.base64Data);
-    } catch (err) {
-      try {
-        const blob = await this.venusApi.cdn.fetchBlob(BurgerTimeAssetsCdnPath);
-        return await blob.arrayBuffer();
-      } catch (e) {
-        throw new Error("Failed to load burgerTimeAssetsBundle");
-      }
-    }
-  }
-  async loadCharactersBundle() {
+  async loadAssetsBundle(game, bundleKey, fileType = "stow") {
     try {
       const response = await this.rpcClient.callT("H5_LOAD_EMBEDDED_ASSET" /* H5_LOAD_EMBEDDED_ASSET */, {
-        assetKey: "characters"
+        assetKey: bundleKey
       });
       return base64ToArrayBuffer(response.base64Data);
     } catch (err) {
       try {
-        const blob = await this.venusApi.cdn.fetchBlob(CharacterAssetsCdnPath);
+        const blob = await this.venusApi.cdn.fetchBlob(`${game}/${bundleKey}.${fileType}`);
         return await blob.arrayBuffer();
       } catch (e) {
-        throw new Error("Failed to load charactersBundle");
+        throw new Error(`Failed to load ${bundleKey}`);
       }
     }
   }
 };
-function base64ToArrayBuffer(base64) {
-  const binaryString = atob(base64);
-  const len = binaryString.length;
-  const bytes = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
-  }
-  return bytes.buffer;
-}
 
 // src/shared-assets/MockSharedAssetsApi.ts
 var MockSharedAssetsApi = class {
@@ -5761,16 +5238,142 @@ var MockSharedAssetsApi = class {
     __publicField(this, "venusApi");
     this.venusApi = venusApi;
   }
-  async loadBurgerTimeAssetsBundle() {
-    const blob = await this.venusApi.cdn.fetchBlob(BurgerTimeAssetsCdnPath);
-    return await blob.arrayBuffer();
-  }
-  async loadCharactersBundle() {
-    const blob = await this.venusApi.cdn.fetchBlob(CharacterAssetsCdnPath);
+  async loadAssetsBundle(game, bundleKey, fileType = "stow") {
+    const blob = await this.venusApi.cdn.fetchBlob(`${game}/${bundleKey}.${fileType}`);
     return await blob.arrayBuffer();
   }
 };
 
+// src/shared-assets/embeddedLibrariesManifest.ts
+var EMBEDDED_LIBRARIES = [
+  {
+    libraryKey: "phaser@3.90.0",
+    assetKey: "library:phaser@3.90.0",
+    packageName: "phaser",
+    version: "3.90.0",
+    globalVar: "Phaser",
+    cdnPath: "phaser/3.90.0/phaser.min.js",
+    moduleSpecifiers: [{ match: "exact", value: "phaser" }],
+    loadStage: 0,
+    enabled: true
+  },
+  {
+    libraryKey: "react@18.3.1",
+    assetKey: "library:react@18.3.1",
+    packageName: "react",
+    version: "18.3.1",
+    globalVar: "React",
+    cdnPath: "react/18.3.1/react.production.min.js",
+    moduleSpecifiers: [
+      { match: "exact", value: "react", behavior: "namespace" },
+      { match: "exact", value: "react/jsx-runtime", behavior: "react-jsx-runtime" },
+      {
+        match: "exact",
+        value: "react/jsx-dev-runtime",
+        behavior: "react-jsx-dev-runtime"
+      }
+    ],
+    loadStage: 0,
+    // Must load before ReactDOM
+    enabled: true
+  },
+  {
+    libraryKey: "react-dom@18.3.1",
+    assetKey: "library:react-dom@18.3.1",
+    packageName: "react-dom",
+    version: "18.3.1",
+    globalVar: "ReactDOM",
+    cdnPath: "react-dom/18.3.1/react-dom.production.min.js",
+    moduleSpecifiers: [
+      { match: "exact", value: "react-dom", behavior: "namespace" },
+      { match: "exact", value: "react-dom/client", behavior: "namespace" }
+    ],
+    loadStage: 1,
+    // Depends on React (stage 0)
+    enabled: true
+  },
+  {
+    libraryKey: "three@0.170.0",
+    assetKey: "library:three@0.170.0",
+    packageName: "three",
+    version: "0.170.0",
+    globalVar: "THREE",
+    cdnPath: "three/r170/three.min.js",
+    moduleSpecifiers: [
+      { match: "exact", value: "three", behavior: "namespace" },
+      { match: "prefix", value: "three/examples/jsm/", behavior: "namespace" }
+    ],
+    loadStage: 0,
+    enabled: true
+  },
+  {
+    libraryKey: "matter-js@0.19.0",
+    assetKey: "library:matter-js@0.19.0",
+    packageName: "matter-js",
+    version: "0.19.0",
+    globalVar: "Matter",
+    cdnPath: "matter-js/0.19.0/matter.min.js",
+    moduleSpecifiers: [{ match: "exact", value: "matter-js" }],
+    loadStage: 0,
+    enabled: true
+  },
+  {
+    libraryKey: "inkjs@2.2.0",
+    assetKey: "library:inkjs@2.2.0",
+    packageName: "inkjs",
+    version: "2.2.0",
+    globalVar: "inkjs",
+    cdnPath: "inkjs/2.2.0/ink.min.js",
+    moduleSpecifiers: [{ match: "exact", value: "inkjs" }],
+    loadStage: 0,
+    enabled: true
+  },
+  {
+    libraryKey: "zustand@5.0.3",
+    assetKey: "library:zustand@5.0.3",
+    packageName: "zustand",
+    version: "5.0.3",
+    globalVar: "zustand",
+    cdnPath: "zustand/5.0.3/zustand.min.js",
+    moduleSpecifiers: [
+      { match: "exact", value: "zustand" },
+      { match: "exact", value: "zustand/middleware" }
+    ],
+    loadStage: 0,
+    enabled: true
+  },
+  {
+    libraryKey: "ammo.js@2024.11",
+    assetKey: "library:ammo.js@2024.11",
+    packageName: "ammo.js",
+    version: "2024.11",
+    globalVar: "Ammo",
+    cdnPath: "ammo/2024.11/ammo.js",
+    moduleSpecifiers: [
+      { match: "exact", value: "ammo.js" },
+      { match: "exact", value: "ammo.js/builds/ammo.wasm.js" }
+    ],
+    loadStage: 0,
+    enabled: false
+    // Not ready yet - WASM loading needs additional work
+  }
+];
+EMBEDDED_LIBRARIES.reduce(
+  (acc, lib) => {
+    acc[lib.libraryKey] = lib;
+    return acc;
+  },
+  {}
+);
+EMBEDDED_LIBRARIES.filter(
+  (lib) => lib.enabled
+).flatMap(
+  (lib) => lib.moduleSpecifiers.map((specifier) => ({
+    ...specifier,
+    libraryKey: lib.libraryKey
+  }))
+);
+
 // src/game-preloader/MockPreloaderApi.ts
 var MockPreloaderApi = class {
   async showLoadScreen() {
@@ -5848,44 +5451,116 @@ var ROOMS_UNAVAILABLE_MESSAGE = "[Venus SDK] Rooms API is only available when ru
 function createUnavailableRoomsApi() {
   const roomsUnavailableError = () => new Error(ROOMS_UNAVAILABLE_MESSAGE);
   return {
-    async createRoom() {
+    async createRoomAsync() {
       throw roomsUnavailableError();
     },
-    async joinOrCreateRoom() {
+    async joinOrCreateRoomAsync() {
       throw roomsUnavailableError();
     },
-    async getUserRooms() {
+    async joinRoomByCodeAsync() {
       throw roomsUnavailableError();
     },
-    async joinRoomByCode() {
+    async getUserRoomsAsync() {
       throw roomsUnavailableError();
     },
-    subscribe() {
+    async subscribeAsync() {
       throw roomsUnavailableError();
     },
-    async updateData() {
+    async updateRoomDataAsync() {
       throw roomsUnavailableError();
     },
-    async getData() {
+    async getRoomDataAsync() {
       throw roomsUnavailableError();
     },
-    async sendMessage() {
+    async sendRoomMessageAsync() {
       throw roomsUnavailableError();
     },
-    async leave() {
+    async leaveRoomAsync() {
       throw roomsUnavailableError();
     },
-    async startGame() {
+    async startRoomGameAsync() {
       throw roomsUnavailableError();
     },
-    async proposeMove() {
+    async proposeMoveAsync() {
       throw roomsUnavailableError();
     },
-    async validateMove() {
+    async validateMoveAsync() {
       throw roomsUnavailableError();
     }
   };
 }
+var SIMULATION_UNAVAILABLE_MESSAGE = "[Venus SDK] Simulation API is only available when running inside the Venus host environment.";
+function createUnavailableSimulationApi() {
+  const simulationUnavailableError = () => new Error(SIMULATION_UNAVAILABLE_MESSAGE);
+  return {
+    isEnabled() {
+      return false;
+    },
+    async getStateAsync() {
+      throw simulationUnavailableError();
+    },
+    async getConfigAsync() {
+      throw simulationUnavailableError();
+    },
+    async executeRecipeAsync() {
+      throw simulationUnavailableError();
+    },
+    async getActiveRunsAsync() {
+      throw simulationUnavailableError();
+    },
+    async collectRecipeAsync() {
+      throw simulationUnavailableError();
+    },
+    async executeScopedRecipeAsync() {
+      throw simulationUnavailableError();
+    },
+    async triggerRecipeChainAsync() {
+      throw simulationUnavailableError();
+    },
+    async getAvailableRecipesAsync() {
+      throw simulationUnavailableError();
+    },
+    async getRecipeRequirementsAsync() {
+      throw simulationUnavailableError();
+    },
+    async getBatchRecipeRequirementsAsync() {
+      throw simulationUnavailableError();
+    },
+    async resolveFieldValueAsync() {
+      throw simulationUnavailableError();
+    },
+    async getEntityMetadataAsync() {
+      throw simulationUnavailableError();
+    },
+    async getSlotContainersAsync() {
+      throw simulationUnavailableError();
+    },
+    async getSlotAssignmentsAsync() {
+      throw simulationUnavailableError();
+    },
+    async assignItemToSlotAsync() {
+      throw simulationUnavailableError();
+    },
+    async removeItemFromSlotAsync() {
+      throw simulationUnavailableError();
+    },
+    async getAvailableItemsAsync() {
+      throw simulationUnavailableError();
+    },
+    async calculatePowerPreviewAsync() {
+      throw simulationUnavailableError();
+    },
+    async validateSlotAssignmentAsync() {
+      throw simulationUnavailableError();
+    },
+    async executeBatchOperationsAsync() {
+      throw simulationUnavailableError();
+    },
+    async subscribeAsync() {
+      throw simulationUnavailableError();
+    }
+  };
+}
 var MockHost = class {
   constructor(venusApi) {
     __publicField(this, "ads");
@@ -5898,9 +5573,9 @@ var MockHost = class {
     __publicField(this, "notifications");
     __publicField(this, "popups");
     __publicField(this, "profile");
+    __publicField(this, "system");
     __publicField(this, "cdn");
     __publicField(this, "time");
-    __publicField(this, "post");
     __publicField(this, "ai");
     __publicField(this, "haptics");
     __publicField(this, "features");
@@ -5932,15 +5607,17 @@ var MockHost = class {
     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.profile = new MockProfileApi(venusApi);
+    const deviceApi = new MockDeviceApi(venusApi);
+    const environmentApi = new MockEnvironmentApi(venusApi);
+    this.system = new MockSystemApi(deviceApi, environmentApi, venusApi);
+    this.cdn = new MockCdnApi(venusApi);
     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.simulation = createUnavailableSimulationApi();
     this.rooms = createUnavailableRoomsApi();
     this.logging = new MockLoggingApi();
     this.iap = new MockIapApi();
@@ -5956,40 +5633,17 @@ var MockHost = class {
   }
   initialize(options) {
     this._isInitialized = true;
-    const controls = this.updateUiControls();
+    this.venusApi._profileData = this.profile.getCurrentProfile();
+    this.venusApi._deviceData = this.system.getDevice();
+    this.venusApi._environmentData = this.system.getEnvironment();
+    this.venusApi._localeData = this.venusApi._mock?.locale || "en-US";
+    this.venusApi._languageCodeData = this.venusApi._mock?.languageCode || "en";
     return Promise.resolve({
       initializeAsleep: false,
-      hudInsets: {
-        top: controls.feedHeader.height,
-        bottom: 0,
-        left: 0,
-        right: 0
-      }
+      safeArea: this.venusApi._safeAreaData
     });
   }
-  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 = `
@@ -6005,7 +5659,7 @@ var MockHost = class {
     const menuButton = this.createOverlayButton(
       "close",
       "Menu",
-      uiControls.menuButton,
+      { x: window.innerWidth - 48, y: 16, width: 32, height: 32 },
       () => {
         this.handleMenuButtonClicked();
       },
@@ -6234,17 +5888,13 @@ var MockHost = class {
     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`;
+    menuBtn.style.left = `${window.innerWidth - 48}px`;
+    menuBtn.style.top = "16px";
+    menuBtn.style.width = "32px";
+    menuBtn.style.minWidth = "32px";
+    menuBtn.style.height = "32px";
   }
   triggerLifecycleEvent(name) {
     console.log("Trigger Lifecycle Event: ", name);
@@ -6432,6 +6082,11 @@ var MockHost = class {
   }
 };
 
+// src/utils/idGenerator.ts
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+}
+
 // src/rpc/RpcClient.ts
 var RpcClient = class {
   constructor() {
@@ -6474,7 +6129,7 @@ var RpcClient = class {
   }
   async call(method, args, timeout = 5e3) {
     return new Promise((resolve, reject) => {
-      const id = this.generateId();
+      const id = generateId();
       this.addPendingCall(id, resolve, reject);
       const request = {
         type: "rpc-request",
@@ -6511,9 +6166,6 @@ var RpcClient = class {
   getPendingCall(id) {
     return this.pendingCalls.get(id);
   }
-  generateId() {
-    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-  }
   handleRpcResponse(response) {
     const pending = this.getPendingCall(response.id);
     if (!pending) {
@@ -6576,6 +6228,16 @@ var VenusTransport = class {
         this.isProcessingMessage = false;
         return;
       }
+      if (message.type === "H5_SIMULATION_UPDATE" /* H5_SIMULATION_UPDATE */) {
+        const notification = {
+          type: "rpc-notification",
+          id: message.type,
+          payload: message.data
+        };
+        this.handleNotification(notification);
+        this.isProcessingMessage = false;
+        return;
+      }
       const requestId = messageData.requestId;
       if (!requestId) {
         this.logWarn("No requestId. Ignoring message...");
@@ -6742,294 +6404,361 @@ var VenusTransport = class {
   }
 };
 
-// src/RemoteHost.ts
-init_rooms();
-
-// src/rooms/RpcRoomsApi.ts
-init_VenusRoom();
-var RpcRoomsApi = class {
+// src/simulation/RpcSimulationApi.ts
+var RpcSimulationApi = class {
   constructor(rpcClient) {
     __publicField(this, "rpcClient");
-    __publicField(this, "subscriptions");
-    __publicField(this, "transportSubscription", null);
+    __publicField(this, "_simulationConfig", null);
+    __publicField(this, "subscriptionCallbacks", /* @__PURE__ */ new Map());
     this.rpcClient = rpcClient;
-    this.subscriptions = {
-      data: {},
-      messages: {},
-      gameEvents: {},
-      allEvents: {}
-    };
+    this.rpcClient.onNotification(
+      "H5_SIMULATION_UPDATE" /* H5_SIMULATION_UPDATE */,
+      this.handleSimulationUpdate.bind(this)
+    );
   }
-  /**
-   * Get the subscription state for external access (used by setupRoomNotifications)
-   */
-  getSubscriptions() {
-    return this.subscriptions;
+  isEnabled() {
+    return true;
   }
-  /**
-   * Set up room notification routing from the transport
-   */
-  setupNotifications(transport) {
-    const { setupRoomNotifications: setupRoomNotifications2 } = (init_rooms(), __toCommonJS(rooms_exports));
-    this.transportSubscription = setupRoomNotifications2(
-      transport,
-      () => this.getSubscriptions()
+  async validateSlotAssignmentAsync(containerId, slotId, itemId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_VALIDATE_ASSIGNMENT" /* H5_SIMULATION_VALIDATE_ASSIGNMENT */,
+      {
+        containerId,
+        slotId,
+        itemId
+      }
     );
   }
-  /**
-   * Clean up subscriptions and resources
-   */
-  dispose() {
-    if (this.transportSubscription) {
-      this.transportSubscription.unsubscribe();
-      this.transportSubscription = null;
-      console.log("[Venus Rooms] Cleaned up room notification subscription");
+  async subscribeAsync(options) {
+    this.ensureValidSubscribeOptions(options);
+    const subscriptionId = generateId();
+    this.subscriptionCallbacks.set(subscriptionId, options.onUpdate);
+    try {
+      await this.rpcClient.call("H5_SIMULATION_SUBSCRIBE" /* H5_SIMULATION_SUBSCRIBE */, {
+        subscriptionId,
+        entities: options.entities,
+        tags: options.tags,
+        activeRuns: options.activeRuns,
+        roomId: options.roomId
+      });
+    } catch (error) {
+      this.subscriptionCallbacks.delete(subscriptionId);
+      throw error;
     }
+    let unsubscribed = false;
+    return () => {
+      if (unsubscribed) {
+        return;
+      }
+      unsubscribed = true;
+      this.subscriptionCallbacks.delete(subscriptionId);
+      void this.rpcClient.call("H5_SIMULATION_UNSUBSCRIBE" /* H5_SIMULATION_UNSUBSCRIBE */, {
+        subscriptionId
+      }).catch((error) => {
+        console.error(
+          "[Venus SDK] Failed to unsubscribe simulation listener",
+          error
+        );
+      });
+    };
+  }
+  executeBatchOperationsAsync(operations, validateOnly) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_BATCH_OPERATIONS" /* H5_SIMULATION_BATCH_OPERATIONS */,
+      {
+        operations,
+        validateOnly
+      }
+    );
   }
-  async createRoom(options) {
+  async getAvailableItemsAsync(containerId, slotId) {
     const response = await this.rpcClient.call(
-      "H5_ROOM_CREATE" /* H5_ROOM_CREATE */,
+      "H5_SIMULATION_GET_AVAILABLE_ITEMS" /* H5_SIMULATION_GET_AVAILABLE_ITEMS */,
       {
-        options
+        containerId,
+        slotId
+      }
+    );
+    return response.availableItems || [];
+  }
+  calculatePowerPreviewAsync(containerId, slotId, candidateItemId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_CALCULATE_POWER_PREVIEW" /* H5_SIMULATION_CALCULATE_POWER_PREVIEW */,
+      {
+        containerId,
+        slotId,
+        candidateItemId
+      }
+    );
+  }
+  assignItemToSlotAsync(containerId, slotId, itemId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_ASSIGN_ITEM" /* H5_SIMULATION_ASSIGN_ITEM */,
+      {
+        containerId,
+        slotId,
+        itemId
+      }
+    );
+  }
+  removeItemFromSlotAsync(containerId, slotId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_REMOVE_ITEM" /* H5_SIMULATION_REMOVE_ITEM */,
+      {
+        containerId,
+        slotId
       }
     );
-    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) {
+  async getSlotContainersAsync() {
     const response = await this.rpcClient.call(
-      "H5_ROOM_JOIN_OR_CREATE" /* H5_ROOM_JOIN_OR_CREATE */,
+      "H5_SIMULATION_GET_CONTAINERS" /* H5_SIMULATION_GET_CONTAINERS */,
+      {}
+    );
+    return response.containers || [];
+  }
+  async getSlotAssignmentsAsync(containerId) {
+    const response = await this.rpcClient.call(
+      "H5_SIMULATION_GET_ASSIGNMENTS" /* H5_SIMULATION_GET_ASSIGNMENTS */,
       {
-        options
+        containerId
       }
     );
-    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
-    };
+    return Array.isArray(response) ? response : response.assignments || [];
   }
-  async joinRoomByCode(roomCode) {
+  async getStateAsync(roomId) {
     const response = await this.rpcClient.call(
-      "H5_ROOM_JOIN_BY_CODE" /* H5_ROOM_JOIN_BY_CODE */,
+      "H5_SIMULATION_GET_STATE" /* H5_SIMULATION_GET_STATE */,
       {
-        roomCode
+        roomId
       }
     );
-    if (response?.success === false) {
-      throw new Error(response.error || "Failed to join room by code");
+    if (response.configuration) {
+      this._simulationConfig = response.configuration;
     }
-    const roomData = response.roomData || response;
-    const room = new VenusRoom(roomData);
-    return room;
+    return response;
   }
-  // Get user's rooms with optional filtering
-  async getUserRooms(includeArchived = false) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_GET_USER_ROOMS" /* H5_ROOM_GET_USER_ROOMS */,
+  async getConfigAsync(roomId) {
+    if (this._simulationConfig) {
+      return this._simulationConfig;
+    }
+    const config = await this.rpcClient.call(
+      "H5_SIMULATION_GET_CONFIG" /* H5_SIMULATION_GET_CONFIG */,
       {
-        includeArchived
+        roomId
       }
     );
-    if (response?.success === false) {
-      throw new Error(response.error || "Failed to get user rooms");
+    if (config) {
+      this._simulationConfig = config;
+      return config;
     }
-    const rawRooms = response.rooms || [];
-    const venusRooms = [];
-    for (const roomData of rawRooms) {
-      if (!roomData.id) {
-        console.warn("getUserRooms: Skipping room with missing ID:", roomData);
-        continue;
+    throw new Error("No simulation configuration available");
+  }
+  executeRecipeAsync(recipeId, inputs, options) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_EXECUTE_RECIPE" /* H5_SIMULATION_EXECUTE_RECIPE */,
+      {
+        recipeId,
+        inputs,
+        roomId: options?.roomId,
+        batchAmount: options?.batchAmount,
+        allowPartialBatch: options?.allowPartialBatch,
+        entity: options?.entity
       }
-      try {
-        const venusRoom = new VenusRoom(roomData);
-        venusRooms.push(venusRoom);
-      } catch (error) {
-        console.warn(
-          "getUserRooms: Failed to create VenusRoom object:",
-          error,
-          roomData
-        );
+    );
+  }
+  collectRecipeAsync(runId) {
+    return this.rpcClient.call("H5_SIMULATION_COLLECT_RECIPE" /* H5_SIMULATION_COLLECT_RECIPE */, {
+      runId
+    });
+  }
+  getActiveRunsAsync(options) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_ACTIVE_RUNS" /* H5_SIMULATION_GET_ACTIVE_RUNS */,
+      {
+        roomId: options?.roomId
       }
-    }
-    return venusRooms;
+    );
   }
-  async updateData(room, updates, merge = true) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_UPDATE_DATA" /* H5_ROOM_UPDATE_DATA */,
+  executeScopedRecipeAsync(recipeId, entity, inputs, options) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_EXECUTE_SCOPED_RECIPE" /* H5_SIMULATION_EXECUTE_SCOPED_RECIPE */,
       {
-        roomId: room.id,
-        updates,
-        merge
+        recipeId,
+        entity,
+        inputs,
+        roomId: options?.roomId ?? null,
+        options
       }
     );
-    if (response?.success === false) {
-      throw new Error(response.error || "Failed to update room data");
-    }
-    return response.data;
   }
-  async getData(room) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_GET_DATA" /* H5_ROOM_GET_DATA */,
+  getAvailableRecipesAsync(options) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_AVAILABLE_RECIPES" /* H5_SIMULATION_GET_AVAILABLE_RECIPES */,
       {
-        roomId: room.id
+        roomId: options?.roomId || null,
+        includeActorRecipes: options?.includeActorRecipes || false
       }
     );
-    if (response?.success === false) {
-      throw new Error(response.error || "Failed to get room data");
-    }
-    return response.data;
   }
-  async sendMessage(venusRoom, messageData) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_SEND_MESSAGE" /* H5_ROOM_SEND_MESSAGE */,
+  getRecipeRequirementsAsync(recipe) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_RECIPE_REQUIREMENTS */,
       {
-        roomId: venusRoom.id,
-        message: messageData
+        recipeId: recipe.recipeId,
+        entity: recipe.entity,
+        batchAmount: recipe.batchAmount
       }
     );
-    if (response?.success === false) {
-      throw new Error(response.error || "Failed to send message");
-    }
-    return response.messageId;
   }
-  async leave(room) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_LEAVE" /* H5_ROOM_LEAVE */,
+  getBatchRecipeRequirementsAsync(recipes) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS */,
       {
-        roomId: room.id
+        recipes
       }
     );
-    if (response?.success === false) {
-      throw new Error(response.error || "Failed to leave room");
-    }
-    return response;
   }
-  async startGame(room, gameConfig = {}, turnOrder = null) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_START_GAME" /* H5_ROOM_START_GAME */,
+  triggerRecipeChainAsync(recipeId, options) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_TRIGGER_RECIPE_CHAIN" /* H5_SIMULATION_TRIGGER_RECIPE_CHAIN */,
       {
-        roomId: room.id,
-        gameConfig,
-        turnOrder
+        triggerRecipeId: recipeId,
+        context: options?.context,
+        roomId: options?.roomId
       }
     );
-    if (response?.success === false) {
-      throw new Error(response.error || "Failed to start game");
-    }
-    return response.data;
   }
-  async proposeMove(room, proposalPayload) {
-    const response = await this.rpcClient.call(
-      "h5:room:proposeMove" /* H5_ROOM_PROPOSE_MOVE */,
+  getEntityMetadataAsync(entityId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_ENTITY_METADATA" /* H5_SIMULATION_GET_ENTITY_METADATA */,
       {
-        roomId: room.id,
-        gameSpecificState: proposalPayload.gameSpecificState,
-        moveType: proposalPayload.moveType,
-        clientContext: proposalPayload.clientContext,
-        clientProposalId: proposalPayload.clientProposalId
+        entityId
       }
     );
-    if (response?.success === false) {
-      throw new Error(response.error || "Failed to propose move");
-    }
-    return response.data;
   }
-  async validateMove(room, moveId, isValid, reason = null, validatorId = null) {
-    console.log(`[Venus Rooms] Validating move ${moveId}: ${isValid}`);
-    return { success: true, moveId, isValid, reason };
+  async resolveFieldValueAsync(entityId, fieldPath, entity) {
+    const response = await this.rpcClient.call(
+      "H5_SIMULATION_RESOLVE_VALUE" /* H5_SIMULATION_RESOLVE_VALUE */,
+      {
+        entityId,
+        fieldPath,
+        entity
+      }
+    );
+    return response.value;
   }
-  async roomSubscribeToGameEvents(room, callback) {
-    "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-    if (!this.subscriptions.gameEvents[room.id]) {
-      this.subscriptions.gameEvents[room.id] = [];
+  handleSimulationUpdate(notification) {
+    if (!notification || !notification.subscriptionId) {
+      console.warn("[Venus SDK] Received malformed simulation update");
+      return;
     }
-    this.subscriptions.gameEvents[room.id].push(callback);
-  }
-  subscribe(room, options = {}) {
-    const subscriptionIds = [];
-    const roomId = room.id;
-    if (options.onData) {
-      const dataSubId = "data_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-      if (!this.subscriptions.data[roomId]) {
-        this.subscriptions.data[roomId] = [];
-      }
-      this.subscriptions.data[roomId].push(options.onData);
-      subscriptionIds.push({
-        type: "data",
-        id: dataSubId,
-        callback: options.onData
-      });
+    const callback = this.subscriptionCallbacks.get(notification.subscriptionId);
+    if (!callback) {
+      console.warn(
+        "[Venus SDK] Received update for unknown subscription:",
+        notification.subscriptionId
+      );
+      return;
     }
-    if (options.onMessages) {
-      const msgSubId = "messages_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-      if (!this.subscriptions.messages[roomId]) {
-        this.subscriptions.messages[roomId] = [];
-      }
-      this.subscriptions.messages[roomId].push(options.onMessages);
-      subscriptionIds.push({
-        type: "messages",
-        id: msgSubId,
-        callback: options.onMessages
-      });
+    try {
+      callback(notification.updates);
+    } catch (error) {
+      console.error("[Venus SDK] Error in simulation subscription callback", error);
     }
-    if (options.onMoves || options.onGameEvents) {
-      const handler = options.onMoves || options.onGameEvents;
-      if (handler) {
-        const gameSubId = "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
-        if (!this.subscriptions.gameEvents[roomId]) {
-          this.subscriptions.gameEvents[roomId] = [];
-        }
-        this.subscriptions.gameEvents[roomId].push(handler);
-        subscriptionIds.push({
-          type: "gameEvents",
-          id: gameSubId,
-          callback: handler
-        });
-      }
+  }
+  ensureValidSubscribeOptions(options) {
+    if (typeof options !== "object" || options === null) {
+      throw new Error("Simulation subscribe requires an options object");
     }
-    const needsSubscription = subscriptionIds.length > 0 && (this.subscriptions.data[roomId]?.length ?? 0) <= 1 && (this.subscriptions.messages[roomId]?.length ?? 0) <= 1 && (this.subscriptions.gameEvents[roomId]?.length ?? 0) <= 1;
-    if (needsSubscription) {
-      this.rpcClient.call("H5_ROOM_SUBSCRIBE" /* H5_ROOM_SUBSCRIBE */, {
-        roomId,
-        subscribeToData: !!options.onData,
-        subscribeToMessages: !!options.onMessages,
-        subscribeToProposedMoves: !!(options.onMoves || options.onGameEvents)
-      }).catch((error) => {
-        console.error("Failed to set up room subscription:", error);
-      });
+    const opts = options;
+    if (typeof opts.onUpdate !== "function") {
+      throw new Error("Simulation subscribe requires an onUpdate callback");
+    }
+    const hasFilter = Array.isArray(opts.entities) && opts.entities.length > 0 || Array.isArray(opts.tags) && opts.tags.length > 0 || Boolean(opts.activeRuns);
+    if (!hasFilter) {
+      throw new Error(
+        "Simulation subscribe requires at least one filter (entities, tags, activeRuns)"
+      );
     }
-    let called = false;
-    return () => {
-      if (called) return;
-      called = true;
-      subscriptionIds.forEach((sub) => {
-        const bucket = this.subscriptions[sub.type];
-        const callbacks = bucket && bucket[roomId] || [];
-        const index = callbacks.indexOf(sub.callback);
-        if (index > -1) callbacks.splice(index, 1);
-      });
-      const hasNoCallbacks = (this.subscriptions.data[roomId]?.length ?? 0) === 0 && (this.subscriptions.messages[roomId]?.length ?? 0) === 0 && (this.subscriptions.gameEvents[roomId]?.length ?? 0) === 0;
-      if (hasNoCallbacks) {
-        this.rpcClient.call("H5_ROOM_UNSUBSCRIBE" /* H5_ROOM_UNSUBSCRIBE */, {
-          roomId
-        }).catch((error) => {
-          console.error("Failed to clean up room subscription:", error);
-        });
-      }
-    };
   }
 };
 
+// src/simulation/index.ts
+function initializeSimulation(venusApi, host) {
+  venusApi.simulation = {
+    isEnabled: () => true
+  };
+  venusApi.simulation.getConfigAsync = () => {
+    return host.simulation.getConfigAsync();
+  };
+  venusApi.simulation.getStateAsync = (roomId) => {
+    return host.simulation.getStateAsync(roomId);
+  };
+  venusApi.simulation.executeRecipeAsync = (recipeId, inputs, options) => {
+    return host.simulation.executeRecipeAsync(recipeId, inputs, options);
+  };
+  venusApi.simulation.getActiveRunsAsync = () => {
+    return host.simulation.getActiveRunsAsync();
+  };
+  venusApi.simulation.collectRecipeAsync = (runId) => {
+    return host.simulation.collectRecipeAsync(runId);
+  };
+  venusApi.simulation.executeScopedRecipeAsync = (recipeId, entity, inputs, options) => {
+    return host.simulation.executeScopedRecipeAsync(recipeId, entity, inputs, options);
+  };
+  venusApi.simulation.triggerRecipeChainAsync = (recipeId, options) => {
+    return host.simulation.triggerRecipeChainAsync(recipeId, options);
+  };
+  venusApi.simulation.getAvailableRecipesAsync = async (options) => {
+    return host.simulation.getAvailableRecipesAsync(options);
+  };
+  venusApi.simulation.getRecipeRequirementsAsync = (recipe) => {
+    return host.simulation.getRecipeRequirementsAsync(recipe);
+  };
+  venusApi.simulation.getBatchRecipeRequirementsAsync = (recipes) => {
+    return host.simulation.getBatchRecipeRequirementsAsync(recipes);
+  };
+  venusApi.simulation.resolveFieldValueAsync = (entityId, fieldPath, entity) => {
+    return host.simulation.resolveFieldValueAsync(entityId, fieldPath, entity);
+  };
+  venusApi.simulation.getEntityMetadataAsync = (entityId) => {
+    return host.simulation.getEntityMetadataAsync(entityId);
+  };
+  venusApi.simulation.getSlotAssignmentsAsync = (containerId) => {
+    return host.simulation.getSlotAssignmentsAsync(containerId);
+  };
+  venusApi.simulation.getSlotContainersAsync = () => {
+    return host.simulation.getSlotContainersAsync();
+  };
+  venusApi.simulation.assignItemToSlotAsync = (containerId, slotId, itemId) => {
+    return host.simulation.assignItemToSlotAsync(containerId, slotId, itemId);
+  };
+  venusApi.simulation.removeItemFromSlotAsync = (containerId, slotId) => {
+    return host.simulation.removeItemFromSlotAsync(containerId, slotId);
+  };
+  venusApi.simulation.getAvailableItemsAsync = (containerId, slotId) => {
+    return host.simulation.getAvailableItemsAsync(containerId, slotId);
+  };
+  venusApi.simulation.calculatePowerPreviewAsync = (containerId, slotId, candidateItemId) => {
+    return host.simulation.calculatePowerPreviewAsync(
+      containerId,
+      slotId,
+      candidateItemId
+    );
+  };
+  venusApi.simulation.executeBatchOperationsAsync = (operations, validateOnly) => {
+    return host.simulation.executeBatchOperationsAsync(operations, validateOnly);
+  };
+  venusApi.simulation.validateSlotAssignmentAsync = (containerId, slotId, itemId) => {
+    return host.simulation.validateSlotAssignmentAsync(
+      containerId,
+      slotId,
+      itemId
+    );
+  };
+}
+
 // src/social/RpcSocialApi.ts
 var RpcSocialApi = class {
   constructor(rpcClient) {
@@ -7076,9 +6805,9 @@ var RemoteHost = class {
     __publicField(this, "notifications");
     __publicField(this, "popups");
     __publicField(this, "profile");
+    __publicField(this, "system");
     __publicField(this, "cdn");
     __publicField(this, "time");
-    __publicField(this, "post");
     __publicField(this, "ai");
     __publicField(this, "haptics");
     __publicField(this, "features");
@@ -7132,10 +6861,12 @@ var RemoteHost = class {
     this.navigation = new RpcNavigationApi(rpcClient, venusApi);
     this.notifications = new RpcNotificationsApi(rpcClient);
     this.popups = new RpcPopupsApi(rpcClient);
-    this.profile = new HostProfileApi();
+    this.profile = new HostProfileApi(venusApi);
+    const deviceApi = new HostDeviceApi(venusApi);
+    const environmentApi = new HostEnvironmentApi(venusApi);
+    this.system = new HostSystemApi(deviceApi, environmentApi, venusApi);
     this.cdn = new HostCdnApi(getCdnBaseUrl());
-    this.time = new HostTimeApi(rpcClient);
-    this.post = new RpcPostApi(rpcClient);
+    this.time = new HostTimeApi(rpcClient, venusApi);
     this.ai = new RpcAiApi(rpcClient);
     this.haptics = new RpcHapticsApi(rpcClient);
     this.features = new RpcFeaturesApi(rpcClient);
@@ -7150,7 +6881,6 @@ var RemoteHost = class {
     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;
@@ -7168,36 +6898,28 @@ var RemoteHost = class {
       5e3
     );
     transport.instanceId = response.instanceId;
-    this.log(`Remote Host Initialized with id: ${transport.instanceId}`);
-    if (response.profile) {
-      const profile = response.profile;
-      const sanitizedProfile = {
-        id: profile.id,
-        username: profile.username,
-        avatarUrl: profile.avatarUrl ?? null,
-        isAnonymous: Boolean(profile.isAnonymous)
-      };
-      if (typeof window !== "undefined") {
-        const globalWindow = window;
-        const venus = globalWindow.venus || (globalWindow.venus = {});
-        venus.profile = sanitizedProfile;
-        if (venus._config) {
-          venus._config.profile = sanitizedProfile;
-        }
-        if (venus.config) {
-          venus.config.profile = sanitizedProfile;
-        }
-      }
-    }
+    this.log(`Remote Host Initialized with id: ${transport.instanceId}, response: ${JSON.stringify(response)}`);
+    const profile = response.profile;
+    const sanitizedProfile = {
+      id: profile.id,
+      username: profile.username,
+      avatarUrl: profile.avatarUrl ?? null,
+      isAnonymous: Boolean(profile.isAnonymous)
+    };
+    this.venusApi._profileData = sanitizedProfile;
+    this.venusApi._deviceData = response.device;
+    this.venusApi._environmentData = response.environment;
+    this.venusApi._localeData = response.locale;
+    this.venusApi._languageCodeData = response.languageCode;
     this._isInitialized = true;
-    this.venusApi.launchParams = response.launchParams || {};
+    this.venusApi.launchParams = response.launchParams;
     await this.rpcClient.call("READY" /* READY */, {});
-    const hudInsets = response.hudInsets;
-    if (hudInsets) {
-      this.venusApi.config.ui.safeArea = hudInsets;
+    const safeArea = response.safeArea;
+    if (safeArea) {
+      this.venusApi._safeAreaData = safeArea;
     }
     return {
-      hudInsets,
+      safeArea,
       initializeAsleep: response.initializeAsleep
     };
   }
@@ -7209,19 +6931,14 @@ var RemoteHost = class {
 // 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
-init_rooms();
-
 // src/version.ts
-var SDK_VERSION = "3.0.4";
+var SDK_VERSION = "3.2.1-beta.0";
 
 // src/social/index.ts
 function initializeSocial(venusApi, host) {
@@ -7271,82 +6988,8 @@ var VenusAPI2 = class {
         bottom: 10,
         left: 0
       },
-      uiControls: {
-        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: 66 },
-        playButton: {
-          x: 0,
-          y: window.innerHeight - 60,
-          width: window.innerWidth,
-          height: 60
-        }
-      },
-      // Complete theme structure (matching createH5Theme output)
-      theme: {
-        background: {
-          default: "#131419",
-          muted: "#1b1d25",
-          dark: "#0d0e11"
-        },
-        text: {
-          primary: "#ffffff",
-          muted: "#808080",
-          inverted: "#000000"
-        },
-        theme: {
-          primary: "#f6c833",
-          secondary: "#6366f1",
-          background: "#131419",
-          border: "#262626",
-          card: "#1b1d25",
-          "card-glass": "rgba(27, 29, 37, 0.8)"
-        },
-        typography: {
-          fontFamily: {
-            base: "Plus Jakarta Sans, Roboto, sans-serif",
-            heading: "Plus Jakarta Sans, Roboto, sans-serif",
-            mono: "monospace"
-          },
-          fontSize: {
-            "2xs": "10px",
-            xs: "12px",
-            sm: "14px",
-            md: "16px",
-            lg: "18px",
-            xl: "20px",
-            "2xl": "24px",
-            "3xl": "30px",
-            "4xl": "36px",
-            "5xl": "48px",
-            "6xl": "60px"
-          },
-          fontWeight: {
-            thin: "100",
-            extralight: "200",
-            light: "300",
-            regular: "400",
-            medium: "500",
-            semibold: "600",
-            bold: "700",
-            extrabold: "800",
-            black: "900",
-            extrablack: "950"
-          },
-          lineHeight: {
-            none: "1",
-            tight: "1.25",
-            snug: "1.375",
-            normal: "1.5",
-            relaxed: "1.625",
-            loose: "2"
-          }
-        }
-      },
-      // Static locale data at top level
-      locale: "en-US",
-      languageCode: "en",
-      // Note: Profile is now separate from config and accessed via getCurrentProfile()
+      // NOTE: locale and languageCode are NOT part of static config
+      // They are delivered via INIT_SDK handshake and accessed via getLocale()/getLanguageCode()
       // Complete environment info (matching buildStaticConfig)
       environment: {
         isDevelopment: true,
@@ -7400,12 +7043,6 @@ var VenusAPI2 = class {
         onHide: null,
         onShow: null
       },
-      currentPostInteractions: {
-        isLiked: false,
-        isFollowing: false,
-        likesCount: 42,
-        commentsCount: 7
-      },
       // Platform overrides for testing different environments
       platformOverrides: {
         isMobile: true,
@@ -7414,117 +7051,74 @@ var VenusAPI2 = class {
     };
     this._detectHostedEnvironment();
     this.launchParams = {};
-    this.config = createProxiedObject.call(this, "config", {
-      locale: "en-US",
-      languageCode: "en",
-      // Note: Profile is no longer in config - use getCurrentProfile() instead
-      environment: {
-        isDevelopment: true,
-        platform: typeof navigator !== "undefined" ? navigator.platform : "unknown",
-        platformVersion: "unknown",
-        browserInfo: {
-          browser: "unknown",
-          userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "unknown",
-          isMobile: true,
-          isTablet: false,
-          language: typeof navigator !== "undefined" ? navigator.language : "en-US"
+    this.config = createProxiedObject.call(this, "config", {});
+    const originalConfig = this.config;
+    this.config = new Proxy(originalConfig, {
+      get(target, prop) {
+        if (prop === "locale") {
+          throw new Error("Use VenusAPI.getLocale() instead.");
+        }
+        if (prop === "languageCode") {
+          throw new Error("Use VenusAPI.getLanguageCode() instead.");
+        }
+        if (prop === "user") {
+          throw new Error("Use VenusAPI.getLocale() and VenusAPI.getLanguageCode() instead.");
+        }
+        if (prop === "device") {
+          throw new Error("Use VenusAPI.system.getDevice() instead.");
+        }
+        if (prop === "environment") {
+          throw new Error("Use VenusAPI.system.getEnvironment() instead.");
+        }
+        if (prop === "profile") {
+          throw new Error("Use VenusAPI.getProfile() instead.");
+        }
+        if (prop === "rooms") {
+          throw new Error("Rooms configuration is internal. Use VenusAPI.rooms methods instead.");
+        }
+        if (prop === "ui") {
+          return new Proxy({}, {
+            get(uiTarget, uiProp) {
+              if (uiProp === "safeArea") {
+                throw new Error("Use VenusAPI.system.getSafeArea() instead.");
+              }
+              if (uiProp === "hudInsets") {
+                throw new Error("Use VenusAPI.system.getSafeArea() instead.");
+              }
+              if (uiProp === "controls") {
+                throw new Error("UI controls are no longer supported.");
+              }
+              throw new Error(`VenusAPI.config.ui.${uiProp} is not supported.`);
+            }
+          });
         }
+        return target[prop];
       },
-      ui: {
-        controls: {
-          closeButton: { x: 16, y: 16, width: 32, height: 32 },
-          menuButton: {
-            x: typeof window !== "undefined" ? window.innerWidth - 48 : 352,
-            y: 16,
-            width: 32,
-            height: 32
-          },
-          feedHeader: {
-            x: 0,
-            y: 0,
-            width: typeof window !== "undefined" ? window.innerWidth : 400,
-            height: 66
-          },
-          playButton: {
-            x: 0,
-            y: typeof window !== "undefined" ? window.innerHeight - 60 : 740,
-            width: typeof window !== "undefined" ? window.innerWidth : 400,
-            height: 60
-          }
-        },
-        safeArea: { top: 44, left: 0, right: 0, bottom: 34 },
-        hudInsets: {
-          preview: { top: 60, left: 0, right: 0, bottom: 40 },
-          fullscreen: { top: 44, left: 0, right: 0, bottom: 34 }
+      set(target, prop, value) {
+        if (prop === "locale" || prop === "languageCode" || prop === "user" || prop === "device" || prop === "environment" || prop === "profile") {
+          throw new Error(`VenusAPI.config.${prop} cannot be set. Configuration is read-only.`);
+        }
+        if (prop === "ui") {
+          console.warn("[Venus SDK] Cannot set config.ui");
+          return true;
         }
+        target[prop] = value;
+        return true;
       },
-      device: {
-        screenSize: {
-          width: typeof window !== "undefined" ? window.screen?.width || 0 : 0,
-          height: typeof window !== "undefined" ? window.screen?.height || 0 : 0
-        },
-        viewportSize: {
-          width: typeof window !== "undefined" ? window.innerWidth : 0,
-          height: typeof window !== "undefined" ? window.innerHeight : 0
-        },
-        orientation: "portrait",
-        pixelRatio: typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1,
-        fontScale: 1,
-        deviceType: "phone",
-        hapticsEnabled: false,
-        haptics: { supported: false, enabled: false }
+      has(target, prop) {
+        if (prop === "ui") {
+          return false;
+        }
+        return prop in target;
       },
-      theme: {
-        background: { default: "#131419", muted: "#1b1d25", dark: "#0d0e11" },
-        text: { primary: "#ffffff", muted: "#808080", inverted: "#000000" },
-        theme: {
-          primary: "#f6c833",
-          secondary: "#6366f1",
-          background: "#131419",
-          border: "#262626",
-          card: "#1b1d25",
-          "card-glass": "rgba(27, 29, 37, 0.8)"
-        },
-        typography: {
-          fontFamily: {
-            base: "Plus Jakarta Sans, Roboto, sans-serif",
-            heading: "Plus Jakarta Sans, Roboto, sans-serif",
-            mono: "monospace"
-          },
-          fontSize: {
-            "2xs": "10px",
-            xs: "12px",
-            sm: "14px",
-            md: "16px",
-            lg: "18px",
-            xl: "20px",
-            "2xl": "24px",
-            "3xl": "30px",
-            "4xl": "36px",
-            "5xl": "48px",
-            "6xl": "60px"
-          },
-          fontWeight: {
-            thin: "100",
-            extralight: "200",
-            light: "300",
-            regular: "400",
-            medium: "500",
-            semibold: "600",
-            bold: "700",
-            extrabold: "800",
-            black: "900",
-            extrablack: "950"
-          },
-          lineHeight: {
-            none: "1",
-            tight: "1.25",
-            snug: "1.375",
-            normal: "1.5",
-            relaxed: "1.625",
-            loose: "2"
-          }
+      ownKeys(target) {
+        return Reflect.ownKeys(target).filter((key) => key !== "ui");
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        if (prop === "ui") {
+          return void 0;
         }
+        return Reflect.getOwnPropertyDescriptor(target, prop);
       }
     });
     const isInsideHostedEnv = this._bootstrap.isInsideHostedEnvironment;
@@ -7533,7 +7127,6 @@ var VenusAPI2 = class {
     initializeStorage(this, host);
     initializeRoomsApi(this, host);
     initializeAds(this, host);
-    initializeTheme(this);
     initializePopups(this, host);
     initializeAnalytics(this, host);
     initializeIap(this, host);
@@ -7548,15 +7141,31 @@ var VenusAPI2 = class {
     initializeLoggingApi(this, host);
     const isAvatar3dDisabled = typeof window !== "undefined" && window.location.search.includes("EXPO_PUBLIC_DISABLE_3D_AVATARS=true");
     initializeProfile(this, host);
+    initializeSystem(this, host);
     if (!isAvatar3dDisabled) {
       initializeAvatar3d(this, host);
     }
     initializeStackNavigation(this, host);
-    initializePost(this, host);
     initializeAi(this, host);
     initializeSimulation(this, host);
     initializeSocial(this, host);
     initializeAssetLoader(this, createProxiedMethod);
+    this.getLocale = () => {
+      if (this._localeData) {
+        return this._localeData;
+      }
+      if (typeof navigator !== "undefined" && navigator.language) {
+        return navigator.language;
+      }
+      return "en-US";
+    };
+    this.getLanguageCode = () => {
+      if (this._languageCodeData) {
+        return this._languageCodeData;
+      }
+      const locale = this.getLocale();
+      return locale.split("-")[0];
+    };
   }
   // Generate deterministic instance ID based on current page URL
   _generateDeterministicInstanceId() {
@@ -7593,21 +7202,14 @@ var VenusAPI2 = class {
   // BOOTSTRAP METHODS
   //---------------------------------------
   _detectHostedEnvironment() {
-    console.log("[Venus SDK] Detecting host environment...");
     const isInIframe = window.self !== window.top;
     const hasReactNativeWebView = typeof window.ReactNativeWebView !== "undefined";
     this._bootstrap.isInsideHostedEnvironment = isInIframe || hasReactNativeWebView;
-    console.log(
-      `[Venus SDK] isInIframe: ${isInIframe}, hasReactNativeWebView: ${hasReactNativeWebView}`
-    );
-  }
-  isMobile() {
-    return typeof window.ReactNativeWebView !== "undefined";
   }
   _initializeMockMode() {
     if (this._mock.localeOverride) {
-      this.config.locale = this._mock.localeOverride;
-      this.config.languageCode = this._mock.localeOverride.split("-")[0];
+      this._localeData = this._mock.localeOverride;
+      this._languageCodeData = this._mock.localeOverride.split("-")[0];
     }
     if (this._mock.roomsData) {
       console.warn(
@@ -7627,6 +7229,10 @@ var VenusAPI2 = class {
     }
     this._shared.initPromise = new Promise(async (resolve, reject) => {
       try {
+        if (this.isMock() && options?.mock) {
+          Object.assign(this._mock, options.mock);
+          console.log("[VenusAPI] Mock options applied:", options.mock);
+        }
         const result = await this.host.initialize(options);
         this._shared.initialized = true;
         if (!options || !options.usePreloader) {
@@ -7654,7 +7260,6 @@ instance.isAvailable = function() {
 (async () => {
   try {
     await initializeNumbers(instance);
-    console.log("[Venus SDK] Numbers system initialized");
   } catch (error) {
     console.error("[Venus SDK] Failed to initialize numbers system:", error);
   }