@series-inc/venus-sdk 3.0.6 → 3.1.0-beta.0

package/dist/venus-api/index.cjs

@@ -1,7 +1,9 @@
 'use strict';
 
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -10,6 +12,15 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/venus-api/systems/core.js
@@ -100,6 +111,221 @@ var init_core = __esm({
   }
 });
 
+// src/rooms/RoomsApi.ts
+var init_RoomsApi = __esm({
+  "src/rooms/RoomsApi.ts"() {
+  }
+});
+
+// src/rooms/VenusRoom.ts
+var VenusRoom;
+var init_VenusRoom = __esm({
+  "src/rooms/VenusRoom.ts"() {
+    VenusRoom = class {
+      constructor(roomData) {
+        __publicField(this, "id");
+        __publicField(this, "name");
+        __publicField(this, "players");
+        __publicField(this, "maxPlayers");
+        __publicField(this, "gameType");
+        __publicField(this, "appId");
+        __publicField(this, "type");
+        __publicField(this, "createdBy");
+        __publicField(this, "createdAt");
+        __publicField(this, "updatedAt");
+        __publicField(this, "isPrivate");
+        __publicField(this, "currentPlayers");
+        __publicField(this, "status");
+        __publicField(this, "customMetadata");
+        __publicField(this, "admins");
+        __publicField(this, "roomCode");
+        __publicField(this, "description");
+        __publicField(this, "data");
+        __publicField(this, "version");
+        __publicField(this, "_subscriptions", /* @__PURE__ */ new Map());
+        this.id = roomData.id;
+        this.name = roomData.name;
+        this.players = roomData.currentPlayers || [];
+        this.maxPlayers = roomData.maxPlayers;
+        this.gameType = roomData.gameType;
+        this.appId = roomData.appId;
+        this.type = roomData.type;
+        this.createdBy = roomData.createdBy;
+        this.createdAt = roomData.createdAt;
+        this.updatedAt = roomData.updatedAt;
+        this.isPrivate = roomData.isPrivate;
+        this.currentPlayers = roomData.currentPlayers || [];
+        this.status = roomData.status;
+        this.customMetadata = roomData.customMetadata || {};
+        this.admins = roomData.admins || [];
+        this.roomCode = roomData.roomCode;
+        this.description = roomData.description;
+        this.data = roomData.data || {};
+        this.version = roomData.version;
+        console.log(`VenusRoom: Created room object for ${this.id}`, {
+          hasCustomMetadata: !!this.customMetadata,
+          hasGameState: !!this.customMetadata?.rules?.gameState,
+          gamePhase: this.customMetadata?.rules?.gameState?.phase,
+          currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
+        });
+      }
+      updateFromRoomData(newRoomData) {
+        if (newRoomData.id === this.id) {
+          this.name = newRoomData.name || this.name;
+          this.players = newRoomData.currentPlayers || this.players;
+          this.maxPlayers = newRoomData.maxPlayers || this.maxPlayers;
+          this.gameType = newRoomData.gameType || this.gameType;
+          this.currentPlayers = newRoomData.currentPlayers || this.currentPlayers;
+          this.customMetadata = newRoomData.customMetadata || this.customMetadata;
+          this.data = newRoomData.data || this.data;
+          this.status = newRoomData.status || this.status;
+          this.updatedAt = newRoomData.updatedAt || this.updatedAt;
+          console.log(`VenusRoom: Updated room object ${this.id} with fresh data`, {
+            hasCustomMetadata: !!this.customMetadata,
+            hasGameState: !!this.customMetadata?.rules?.gameState,
+            gamePhase: this.customMetadata?.rules?.gameState?.phase,
+            currentPlayer: this.customMetadata?.rules?.gameState?.currentPlayer
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/rooms/index.ts
+var rooms_exports = {};
+__export(rooms_exports, {
+  VenusRoom: () => VenusRoom,
+  initializeRoomsApi: () => initializeRoomsApi,
+  setupRoomNotifications: () => setupRoomNotifications
+});
+function bindMethod(target, targetKey, source, sourceKey) {
+  const key = sourceKey ?? targetKey;
+  const fn = source?.[key];
+  if (typeof fn === "function") {
+    target[targetKey] = fn.bind(source);
+    return true;
+  }
+  return false;
+}
+function setupRoomNotifications(transport, getSubscriptions) {
+  console.log("[Venus Rooms] Setting up room notification listeners");
+  return transport.onVenusMessage((message) => {
+    const subscriptions = getSubscriptions();
+    if (!subscriptions) {
+      return;
+    }
+    if (message.type === "H5_ROOM_DATA_UPDATED") {
+      const messageData = message.data;
+      const { roomId, roomData } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.data?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Room data updated for ${roomId}, notifying ${callbacks.length} callbacks`, roomData);
+      callbacks.forEach((callback) => {
+        try {
+          callback(roomData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in room data callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+    if (message.type === "H5_ROOM_MESSAGE_RECEIVED" || message.type === "H5_ROOM_MESSAGE_UPDATED" || message.type === "H5_ROOM_MESSAGE_DELETED") {
+      const messageData = message.data;
+      const { roomId } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.messages?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Room message event for ${roomId}, notifying ${callbacks.length} callbacks`);
+      callbacks.forEach((callback) => {
+        try {
+          callback(messageData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in room message callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+    if (message.type === "app:h5:proposedMoveValidationUpdated") {
+      const messageData = message.data;
+      const { roomId } = messageData;
+      if (!roomId) return;
+      const callbacks = subscriptions.gameEvents?.[roomId] || [];
+      const allEventsCallbacks = subscriptions.allEvents?.[roomId] || [];
+      console.log(`[Venus Rooms] \u{1F514} Proposed move validation updated for ${roomId}, notifying ${callbacks.length} callbacks`);
+      callbacks.forEach((callback) => {
+        try {
+          callback(messageData);
+        } catch (error) {
+          console.error("[Venus Rooms] Error in game event callback:", error);
+          throw error;
+        }
+      });
+      allEventsCallbacks.forEach((callback) => {
+        try {
+          callback({ type: message.type, ...messageData });
+        } catch (error) {
+          console.error("[Venus Rooms] Error in allEvents callback:", error);
+          throw error;
+        }
+      });
+    }
+  });
+}
+function initializeRoomsApi(venusApi, host) {
+  const roomsApi = host?.rooms;
+  if (!roomsApi) {
+    console.warn(
+      "[Venus SDK] Host did not provide a rooms implementation. Rooms API will be unavailable."
+    );
+    return;
+  }
+  const venus = venusApi;
+  const existingNamespace = venus.rooms || {};
+  const roomsNamespace = Object.assign({}, existingNamespace);
+  const namespaceBindings = [
+    ["create", "createRoom"],
+    ["joinOrCreate", "joinOrCreateRoom"],
+    ["joinByCode", "joinRoomByCode"],
+    ["list", "getUserRooms"],
+    ["subscribeToRoom", "subscribe"],
+    ["updateRoomData", "updateData"],
+    ["getRoomData", "getData"],
+    ["sendRoomMessage", "sendMessage"],
+    ["leaveRoom", "leave"],
+    ["startRoomGame", "startGame"],
+    ["proposeMove"],
+    ["validateMove"]
+  ];
+  namespaceBindings.forEach(([targetKey, sourceKey]) => {
+    bindMethod(roomsNamespace, targetKey, roomsApi, sourceKey);
+  });
+  venus.rooms = roomsNamespace;
+}
+var init_rooms = __esm({
+  "src/rooms/index.ts"() {
+    init_RoomsApi();
+    init_VenusRoom();
+  }
+});
+
 // src/storage/MockStorageApi.ts
 function createMockStorageApi(storageType, appUrl) {
   const appIdentifier = appUrl ? generateAppIdentifier(appUrl) : null;
@@ -409,6 +635,190 @@ 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) {
@@ -561,8 +971,13 @@ 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];
@@ -572,8 +987,12 @@ 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 || {};
@@ -581,8 +1000,10 @@ 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;
@@ -591,6 +1012,9 @@ 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",
@@ -601,11 +1025,14 @@ 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()}`;
@@ -627,8 +1054,13 @@ 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;
@@ -822,6 +1254,7 @@ var MockTimeApi = class {
       maximumFractionDigits: options?.maximumFractionDigits || 2,
       ...options
     };
+    console.log(`[Venus Mock] Formatting number ${value} with locale ${locale}`);
     return value.toLocaleString(locale, numberOptions);
   }
   formatTime(timestamp, options) {
@@ -833,9 +1266,13 @@ 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);
@@ -880,6 +1317,7 @@ 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;
@@ -893,6 +1331,11 @@ 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;
   }
 };
@@ -1743,11 +2186,14 @@ 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"));
         };
@@ -1799,6 +2245,7 @@ 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()) {
@@ -4174,6 +4621,7 @@ var MockPostApi = class {
   }
   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;
@@ -4432,426 +4880,871 @@ function initializeLifecycleApi(venusApi, host) {
   venusApi.lifecycles = host.lifecycle;
 }
 
-// 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;
-  }
-};
-
-// 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/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;
     }
-  });
+  }
+  return totals;
 }
 
-// src/rooms/RpcRoomsApi.ts
-var RpcRoomsApi = class {
+// src/simulation/RpcSimulationApi.ts
+var RpcSimulationApi = class {
   constructor(rpcClient) {
     __publicField(this, "rpcClient");
-    __publicField(this, "subscriptions");
+    __publicField(this, "_simulationConfig", null);
     this.rpcClient = rpcClient;
-    this.subscriptions = {
-      data: {},
-      messages: {},
-      gameEvents: {}
-    };
   }
-  /**
-   * Get the subscription state for external access (used by setupRoomNotifications)
-   */
-  getSubscriptions() {
-    return this.subscriptions;
+  async validateSlotAssignmentAsync(containerId, slotId, itemId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_VALIDATE_ASSIGNMENT" /* H5_SIMULATION_VALIDATE_ASSIGNMENT */,
+      {
+        containerId,
+        slotId,
+        itemId
+      }
+    );
   }
-  /**
-   * Set up room notification routing from the transport
-   */
-  setupNotifications(transport) {
-    setupRoomNotifications(transport, () => this.getSubscriptions());
+  sumContributions(contributions) {
+    return sumContributions(contributions);
   }
-  async createRoomAsync(options) {
+  executeBatchOperationsAsync(operations, validateOnly) {
+    return this.rpcClient.call("H5_SIMULATION_BATCH_OPERATIONS" /* H5_SIMULATION_BATCH_OPERATIONS */, {
+      operations,
+      validateOnly
+    });
+  }
+  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
       }
     );
-    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;
+    return response.availableItems || [];
   }
-  async joinOrCreateRoomAsync(options) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_JOIN_OR_CREATE" /* H5_ROOM_JOIN_OR_CREATE */,
+  calculatePowerPreviewAsync(containerId, slotId, candidateItemId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_CALCULATE_POWER_PREVIEW" /* H5_SIMULATION_CALCULATE_POWER_PREVIEW */,
       {
-        options
+        containerId,
+        slotId,
+        candidateItemId
       }
     );
-    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
-    };
   }
-  async joinRoomByCodeAsync(roomCode) {
+  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_ROOM_JOIN_BY_CODE" /* H5_ROOM_JOIN_BY_CODE */,
-      {
-        roomCode
-      }
+      "H5_SIMULATION_GET_CONTAINERS" /* H5_SIMULATION_GET_CONTAINERS */,
+      {}
     );
-    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;
+    return response.containers || [];
   }
-  // Get user's rooms with optional filtering
-  async getUserRoomsAsync(options = {}) {
+  async getSlotAssignmentsAsync(containerId) {
     const response = await this.rpcClient.call(
-      "H5_ROOM_GET_USER_ROOMS" /* H5_ROOM_GET_USER_ROOMS */,
+      "H5_SIMULATION_GET_ASSIGNMENTS" /* H5_SIMULATION_GET_ASSIGNMENTS */,
       {
-        includeArchived: options.includeArchived ?? false
+        containerId
       }
     );
-    if (response?.success === false) {
-      const errorMessage = typeof response.error === "string" ? response.error : "Failed to get user rooms";
-      throw new Error(errorMessage);
-    }
-    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;
+    return Array.isArray(response) ? response : response.assignments || [];
   }
-  async updateRoomDataAsync(room, updates, options = {}) {
+  async getStateAsync(roomId) {
     const response = await this.rpcClient.call(
-      "H5_ROOM_UPDATE_DATA" /* H5_ROOM_UPDATE_DATA */,
+      "H5_SIMULATION_GET_STATE" /* H5_SIMULATION_GET_STATE */,
       {
-        roomId: room.id,
-        updates,
-        merge: options.merge ?? true
+        roomId
       }
     );
-    if (response?.success === false) {
-      const errorMessage = typeof response.error === "string" ? response.error : "Failed to update room data";
-      throw new Error(errorMessage);
+    console.log("[Venus SDK] getStateAsync", response);
+    if (response.configuration) {
+      this._simulationConfig = response.configuration;
     }
+    return response;
   }
-  async getRoomDataAsync(room) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_GET_DATA" /* H5_ROOM_GET_DATA */,
+  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;
+    }
+    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 */,
       {
-        roomId: room.id
+        recipeId,
+        entity,
+        inputs,
+        roomId: options?.roomId ?? null,
+        options
       }
     );
-    if (response?.success === false) {
-      const errorMessage = typeof response.error === "string" ? response.error : "Failed to get room data";
-      throw new Error(errorMessage);
-    }
-    return response.data;
   }
-  async sendRoomMessageAsync(venusRoom, request) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_SEND_MESSAGE" /* H5_ROOM_SEND_MESSAGE */,
+  getAvailableRecipesAsync(options) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_AVAILABLE_RECIPES" /* H5_SIMULATION_GET_AVAILABLE_RECIPES */,
       {
-        roomId: venusRoom.id,
-        message: request.message,
-        metadata: request.metadata
+        roomId: options?.roomId || null,
+        includeActorRecipes: options?.includeActorRecipes || false
       }
     );
-    if (response?.success === false) {
-      const errorMessage = typeof response.error === "string" ? response.error : "Failed to send message";
-      throw new Error(errorMessage);
-    }
-    return response.messageId;
   }
-  async leaveRoomAsync(room) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_LEAVE" /* H5_ROOM_LEAVE */,
+  getRecipeRequirementsAsync(recipe) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_RECIPE_REQUIREMENTS */,
       {
-        roomId: room.id
+        recipeId: recipe.recipeId,
+        entity: recipe.entity,
+        batchAmount: recipe.batchAmount
       }
     );
-    if (response?.success === false) {
-      const errorMessage = typeof response.error === "string" ? response.error : "Failed to leave room";
-      throw new Error(errorMessage);
-    }
   }
-  async startRoomGameAsync(room, options = {}) {
-    const response = await this.rpcClient.call(
-      "H5_ROOM_START_GAME" /* H5_ROOM_START_GAME */,
+  getBatchRecipeRequirementsAsync(recipes) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS */,
       {
-        roomId: room.id,
-        gameConfig: options.gameConfig ?? {},
-        turnOrder: options.turnOrder ?? null
+        recipes
+      }
+    );
+  }
+  triggerRecipeChainAsync(recipeId, options) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_TRIGGER_RECIPE_CHAIN" /* H5_SIMULATION_TRIGGER_RECIPE_CHAIN */,
+      {
+        triggerRecipeId: recipeId,
+        context: options?.context,
+        roomId: options?.roomId
+      }
+    );
+  }
+  getEntityMetadataAsync(entityId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_ENTITY_METADATA" /* H5_SIMULATION_GET_ENTITY_METADATA */,
+      {
+        entityId
       }
     );
-    if (response?.success === false) {
-      const errorMessage = typeof response.error === "string" ? response.error : "Failed to start game";
-      throw new Error(errorMessage);
-    }
   }
-  async proposeMoveAsync(room, proposalPayload) {
+  async resolveFieldValueAsync(entityId, fieldPath, entity) {
     const response = await this.rpcClient.call(
-      "h5:room:proposeMove" /* H5_ROOM_PROPOSE_MOVE */,
+      "H5_SIMULATION_RESOLVE_VALUE" /* H5_SIMULATION_RESOLVE_VALUE */,
       {
-        roomId: room.id,
-        gameSpecificState: proposalPayload.gameSpecificState,
-        moveType: proposalPayload.moveType,
-        clientContext: proposalPayload.clientContext,
-        clientProposalId: proposalPayload.clientProposalId
+        entityId,
+        fieldPath,
+        entity
       }
     );
-    if (response?.success === false) {
-      const errorMessage = typeof response.error === "string" ? response.error : "Failed to propose move";
-      throw new Error(errorMessage);
+    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 response.data;
+    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 }
+      );
+    }
+    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 validateMoveAsync(_room, moveId, verdict) {
+  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
+    };
+  }
+  async triggerRecipeChainAsync(recipeId, options) {
+    this.log("triggerRecipeChainAsync called:", { recipeId, ...options });
     return {
       success: true,
-      moveId,
-      isValid: verdict.isValid,
-      reason: verdict.reason
+      message: "Mock recipe chain triggered successfully"
     };
   }
-  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;
+  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}`
+          );
+        }
       }
     }
-    if (options.onData) {
-      if (!this.subscriptions.data[roomId]) {
-        this.subscriptions.data[roomId] = [];
+    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;
+        }
       }
-      this.subscriptions.data[roomId].push(options.onData);
     }
-    if (options.onMessages) {
-      if (!this.subscriptions.messages[roomId]) {
-        this.subscriptions.messages[roomId] = [];
-      }
-      this.subscriptions.messages[roomId].push(options.onMessages);
+    if (recipe.beginEffects) {
+      this.applyEffects(state, recipe.beginEffects);
     }
-    if (options.onGameEvents) {
-      if (!this.subscriptions.gameEvents[roomId]) {
-        this.subscriptions.gameEvents[roomId] = [];
-      }
-      this.subscriptions.gameEvents[roomId].push(options.onGameEvents);
+    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()
+      };
     }
-    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);
-          }
+  }
+  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;
+      });
+    }
+    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.onMessages) {
-        const callbacks = this.subscriptions.messages[roomId];
-        if (callbacks) {
-          const index = callbacks.indexOf(options.onMessages);
-          if (index > -1) {
-            callbacks.splice(index, 1);
+      });
+    }
+    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);
           }
         }
+      });
+    }
+    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;
+        }
       }
-      if (options.onGameEvents) {
-        const callbacks = this.subscriptions.gameEvents[roomId];
-        if (callbacks) {
-          const index = callbacks.indexOf(options.onGameEvents);
-          if (index > -1) {
-            callbacks.splice(index, 1);
-          }
+    }
+    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);
         }
+      } else {
+        console.log(
+          `[Venus Simulation Mock] Auto-restarting ${run.recipeId} (no condition)`
+        );
+        setTimeout(() => {
+          this.executeRecipe(appIdentifier, run.recipeId, recipe.inputs || {});
+        }, 1e3);
       }
-      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);
-        });
+    }
+    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}`
+            );
+          }
+          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}`
+          );
       }
+    }
+  }
+  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/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."
+// 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
     );
-    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;
+  };
+  venusApi.simulation.executeBatchOperationsAsync = (operations, validateOnly) => {
+    return host.simulation.executeBatchOperationsAsync(operations, validateOnly);
+  };
+  venusApi.simulation.validateSlotAssignmentAsync = (containerId, slotId, itemId) => {
+    return host.simulation.validateSlotAssignmentAsync(
+      containerId,
+      slotId,
+      itemId
+    );
+  };
+  venusApi.simulation.sumContributions = (contributions) => {
+    return host.simulation.sumContributions(contributions);
+  };
 }
 
+// src/MockHost.ts
+init_rooms();
+
 // src/logging/MockLoggingApi.ts
 var MockLoggingApi = class {
   logDebug(message, ...args) {
@@ -4931,6 +5824,174 @@ function initializeLoggingApi(venusApi, host) {
 var BurgerTimeAssetsCdnPath = "burger-time/Core.stow";
 var CharacterAssetsCdnPath = "burger-time/Character.stow";
 
+// 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
+  }
+];
+var EMBEDDED_LIBRARY_BY_KEY = 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
+  }))
+);
+function getLibraryDefinition(libraryKey) {
+  const definition = EMBEDDED_LIBRARY_BY_KEY[libraryKey];
+  if (!definition) {
+    const availableKeys = Object.keys(EMBEDDED_LIBRARY_BY_KEY).join(", ");
+    throw new Error(
+      `Unsupported embedded library: ${libraryKey}. Available libraries: ${availableKeys}`
+    );
+  }
+  return definition;
+}
+
+// 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;
+}
+function base64ToUtf8(base64) {
+  if (typeof TextDecoder !== "undefined") {
+    const decoder = new TextDecoder("utf-8");
+    const buffer = base64ToArrayBuffer(base64);
+    return decoder.decode(new Uint8Array(buffer));
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.Buffer !== "undefined") {
+    const BufferCtor = globalThis.Buffer;
+    return BufferCtor.from(base64, "base64").toString("utf-8");
+  }
+  const binaryString = atob(base64);
+  let result = "";
+  for (let i = 0; i < binaryString.length; i++) {
+    result += String.fromCharCode(binaryString.charCodeAt(i));
+  }
+  return decodeURIComponent(escape(result));
+}
+
 // src/shared-assets/RpcSharedAssetsApi.ts
 var RpcSharedAssetsApi = class {
   constructor(rpcClient, venusApi) {
@@ -4969,16 +6030,33 @@ var RpcSharedAssetsApi = class {
       }
     }
   }
-};
-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);
+  async loadLibraryCode(libraryKey) {
+    const definition = getLibraryDefinition(libraryKey);
+    try {
+      const response = await this.rpcClient.callT("H5_LOAD_EMBEDDED_ASSET" /* H5_LOAD_EMBEDDED_ASSET */, {
+        assetKey: definition.assetKey
+      });
+      return base64ToUtf8(response.base64Data);
+    } catch (err) {
+      console.error(
+        `[Venus Libraries] Failed to load ${libraryKey} from host via RPC:`,
+        err
+      );
+      console.warn(
+        `[Venus Libraries] Falling back to CDN for ${libraryKey}. This may indicate an asset packaging issue.`
+      );
+      try {
+        const cdnUrl = this.venusApi.cdn.resolveSharedLibUrl(definition.cdnPath);
+        const response = await this.venusApi.cdn.fetchFromCdn(cdnUrl);
+        return await response.text();
+      } catch (cdnError) {
+        throw new Error(
+          `Failed to load embedded library ${libraryKey}: RPC failed, CDN fallback failed: ${cdnError.message}`
+        );
+      }
+    }
   }
-  return bytes.buffer;
-}
+};
 
 // src/shared-assets/MockSharedAssetsApi.ts
 var MockSharedAssetsApi = class {
@@ -4994,6 +6072,12 @@ var MockSharedAssetsApi = class {
     const blob = await this.venusApi.cdn.fetchBlob(CharacterAssetsCdnPath);
     return await blob.arrayBuffer();
   }
+  async loadLibraryCode(libraryKey) {
+    const definition = getLibraryDefinition(libraryKey);
+    const url = this.venusApi.cdn.resolveSharedLibUrl(definition.cdnPath);
+    const response = await this.venusApi.cdn.fetchFromCdn(url);
+    return await response.text();
+  }
 };
 
 // src/game-preloader/MockPreloaderApi.ts
@@ -5073,116 +6157,44 @@ var ROOMS_UNAVAILABLE_MESSAGE = "[Venus SDK] Rooms API is only available when ru
 function createUnavailableRoomsApi() {
   const roomsUnavailableError = () => new Error(ROOMS_UNAVAILABLE_MESSAGE);
   return {
-    async createRoomAsync() {
+    async createRoom() {
       throw roomsUnavailableError();
     },
-    async joinOrCreateRoomAsync() {
+    async joinOrCreateRoom() {
       throw roomsUnavailableError();
     },
-    async joinRoomByCodeAsync() {
+    async getUserRooms() {
       throw roomsUnavailableError();
     },
-    async getUserRoomsAsync() {
+    async joinRoomByCode() {
       throw roomsUnavailableError();
     },
-    async subscribeAsync() {
+    subscribe() {
       throw roomsUnavailableError();
     },
-    async updateRoomDataAsync() {
+    async updateData() {
       throw roomsUnavailableError();
     },
-    async getRoomDataAsync() {
+    async getData() {
       throw roomsUnavailableError();
     },
-    async sendRoomMessageAsync() {
+    async sendMessage() {
       throw roomsUnavailableError();
     },
-    async leaveRoomAsync() {
+    async leave() {
       throw roomsUnavailableError();
     },
-    async startRoomGameAsync() {
+    async startGame() {
       throw roomsUnavailableError();
     },
-    async proposeMoveAsync() {
+    async proposeMove() {
       throw roomsUnavailableError();
     },
-    async validateMoveAsync() {
+    async validateMove() {
       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");
@@ -5237,7 +6249,7 @@ var MockHost = class {
     this.haptics = new MockHapticsApi(venusApi);
     this.features = new MockFeaturesApi();
     this.lifecycle = this._mockLifecyclesApi;
-    this.simulation = createUnavailableSimulationApi();
+    this.simulation = new MockSimulationApi();
     this.rooms = createUnavailableRoomsApi();
     this.logging = new MockLoggingApi();
     this.iap = new MockIapApi();
@@ -5729,11 +6741,6 @@ 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() {
@@ -5776,7 +6783,7 @@ var RpcClient = class {
   }
   async call(method, args, timeout = 5e3) {
     return new Promise((resolve, reject) => {
-      const id = generateId();
+      const id = this.generateId();
       this.addPendingCall(id, resolve, reject);
       const request = {
         type: "rpc-request",
@@ -5813,6 +6820,9 @@ 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) {
@@ -5875,16 +6885,6 @@ 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...");
@@ -6051,361 +7051,294 @@ var VenusTransport = class {
   }
 };
 
-// src/simulation/RpcSimulationApi.ts
-var RpcSimulationApi = class {
+// src/RemoteHost.ts
+init_rooms();
+
+// src/rooms/RpcRoomsApi.ts
+init_VenusRoom();
+var RpcRoomsApi = class {
   constructor(rpcClient) {
     __publicField(this, "rpcClient");
-    __publicField(this, "_simulationConfig", null);
-    __publicField(this, "subscriptionCallbacks", /* @__PURE__ */ new Map());
+    __publicField(this, "subscriptions");
+    __publicField(this, "transportSubscription", null);
     this.rpcClient = rpcClient;
-    this.rpcClient.onNotification(
-      "H5_SIMULATION_UPDATE" /* H5_SIMULATION_UPDATE */,
-      this.handleSimulationUpdate.bind(this)
-    );
-  }
-  isEnabled() {
-    return true;
-  }
-  async validateSlotAssignmentAsync(containerId, slotId, itemId) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_VALIDATE_ASSIGNMENT" /* H5_SIMULATION_VALIDATE_ASSIGNMENT */,
-      {
-        containerId,
-        slotId,
-        itemId
-      }
-    );
-  }
-  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
-        );
-      });
+    this.subscriptions = {
+      data: {},
+      messages: {},
+      gameEvents: {},
+      allEvents: {}
     };
   }
-  executeBatchOperationsAsync(operations, validateOnly) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_BATCH_OPERATIONS" /* H5_SIMULATION_BATCH_OPERATIONS */,
-      {
-        operations,
-        validateOnly
-      }
-    );
-  }
-  async getAvailableItemsAsync(containerId, slotId) {
-    const response = await this.rpcClient.call(
-      "H5_SIMULATION_GET_AVAILABLE_ITEMS" /* H5_SIMULATION_GET_AVAILABLE_ITEMS */,
-      {
-        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
-      }
-    );
-  }
-  async getSlotContainersAsync() {
-    const response = await this.rpcClient.call(
-      "H5_SIMULATION_GET_CONTAINERS" /* H5_SIMULATION_GET_CONTAINERS */,
-      {}
-    );
-    return response.containers || [];
+  /**
+   * Get the subscription state for external access (used by setupRoomNotifications)
+   */
+  getSubscriptions() {
+    return this.subscriptions;
   }
-  async getSlotAssignmentsAsync(containerId) {
-    const response = await this.rpcClient.call(
-      "H5_SIMULATION_GET_ASSIGNMENTS" /* H5_SIMULATION_GET_ASSIGNMENTS */,
-      {
-        containerId
-      }
+  /**
+   * Set up room notification routing from the transport
+   */
+  setupNotifications(transport) {
+    const { setupRoomNotifications: setupRoomNotifications2 } = (init_rooms(), __toCommonJS(rooms_exports));
+    this.transportSubscription = setupRoomNotifications2(
+      transport,
+      () => this.getSubscriptions()
     );
-    return Array.isArray(response) ? response : response.assignments || [];
   }
-  async getStateAsync(roomId) {
-    const response = await this.rpcClient.call(
-      "H5_SIMULATION_GET_STATE" /* H5_SIMULATION_GET_STATE */,
-      {
-        roomId
-      }
-    );
-    if (response.configuration) {
-      this._simulationConfig = response.configuration;
+  /**
+   * Clean up subscriptions and resources
+   */
+  dispose() {
+    if (this.transportSubscription) {
+      this.transportSubscription.unsubscribe();
+      this.transportSubscription = null;
+      console.log("[Venus Rooms] Cleaned up room notification subscription");
     }
-    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 */,
+  async createRoom(options) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_CREATE" /* H5_ROOM_CREATE */,
       {
-        roomId
+        options
       }
     );
-    if (config) {
-      this._simulationConfig = config;
-      return config;
+    if (response.success === false) {
+      throw new Error(response.error || "Failed to create room");
     }
-    throw new Error("No simulation configuration available");
+    const roomData = response.roomData || response;
+    const room = new VenusRoom(roomData);
+    return room;
   }
-  executeRecipeAsync(recipeId, inputs, options) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_EXECUTE_RECIPE" /* H5_SIMULATION_EXECUTE_RECIPE */,
+  async joinOrCreateRoom(options) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_JOIN_OR_CREATE" /* H5_ROOM_JOIN_OR_CREATE */,
       {
-        recipeId,
-        inputs,
-        roomId: options?.roomId,
-        batchAmount: options?.batchAmount,
-        allowPartialBatch: options?.allowPartialBatch,
-        entity: options?.entity
+        options
       }
     );
+    if (response.success === false) {
+      throw new Error(response.error || "Failed to join or create room");
+    }
+    const data = response.value || response;
+    const room = new VenusRoom(data.roomData);
+    return {
+      action: data.action,
+      room,
+      playersJoined: data.playersJoined
+    };
   }
-  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 */,
+  async joinRoomByCode(roomCode) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_JOIN_BY_CODE" /* H5_ROOM_JOIN_BY_CODE */,
       {
-        roomId: options?.roomId
+        roomCode
       }
     );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to join room by code");
+    }
+    const roomData = response.roomData || response;
+    const room = new VenusRoom(roomData);
+    return room;
   }
-  executeScopedRecipeAsync(recipeId, entity, inputs, options) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_EXECUTE_SCOPED_RECIPE" /* H5_SIMULATION_EXECUTE_SCOPED_RECIPE */,
+  // 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 */,
       {
-        recipeId,
-        entity,
-        inputs,
-        roomId: options?.roomId ?? null,
-        options
+        includeArchived
       }
     );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to get user rooms");
+    }
+    const rawRooms = response.rooms || [];
+    const venusRooms = [];
+    for (const roomData of rawRooms) {
+      if (!roomData.id) {
+        console.warn("getUserRooms: Skipping room with missing ID:", roomData);
+        continue;
+      }
+      try {
+        const venusRoom = new VenusRoom(roomData);
+        venusRooms.push(venusRoom);
+      } catch (error) {
+        console.warn(
+          "getUserRooms: Failed to create VenusRoom object:",
+          error,
+          roomData
+        );
+      }
+    }
+    return venusRooms;
   }
-  getAvailableRecipesAsync(options) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_AVAILABLE_RECIPES" /* H5_SIMULATION_GET_AVAILABLE_RECIPES */,
+  async updateData(room, updates, merge = true) {
+    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
       }
     );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to update room data");
+    }
+    return response.data;
   }
-  getRecipeRequirementsAsync(recipe) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_RECIPE_REQUIREMENTS */,
+  async getData(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) {
+      throw new Error(response.error || "Failed to get room data");
+    }
+    return response.data;
   }
-  getBatchRecipeRequirementsAsync(recipes) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS */,
+  async sendMessage(venusRoom, messageData) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_SEND_MESSAGE" /* H5_ROOM_SEND_MESSAGE */,
       {
-        recipes
+        roomId: venusRoom.id,
+        message: messageData
       }
     );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to send message");
+    }
+    return response.messageId;
   }
-  triggerRecipeChainAsync(recipeId, options) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_TRIGGER_RECIPE_CHAIN" /* H5_SIMULATION_TRIGGER_RECIPE_CHAIN */,
+  async leave(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) {
+      throw new Error(response.error || "Failed to leave room");
+    }
+    return response;
   }
-  getEntityMetadataAsync(entityId) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_ENTITY_METADATA" /* H5_SIMULATION_GET_ENTITY_METADATA */,
+  async startGame(room, gameConfig = {}, turnOrder = null) {
+    const response = await this.rpcClient.call(
+      "H5_ROOM_START_GAME" /* H5_ROOM_START_GAME */,
       {
-        entityId
+        roomId: room.id,
+        gameConfig,
+        turnOrder
       }
     );
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to start game");
+    }
+    return response.data;
   }
-  async resolveFieldValueAsync(entityId, fieldPath, entity) {
+  async proposeMove(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;
-  }
-  handleSimulationUpdate(notification) {
-    if (!notification || !notification.subscriptionId) {
-      console.warn("[Venus SDK] Received malformed simulation update");
-      return;
-    }
-    const callback = this.subscriptionCallbacks.get(notification.subscriptionId);
-    if (!callback) {
-      console.warn(
-        "[Venus SDK] Received update for unknown subscription:",
-        notification.subscriptionId
-      );
-      return;
+    if (response?.success === false) {
+      throw new Error(response.error || "Failed to propose move");
     }
-    try {
-      callback(notification.updates);
-    } catch (error) {
-      console.error("[Venus SDK] Error in simulation subscription callback", error);
+    return response.data;
+  }
+  async validateMove(room, moveId, isValid, reason = null, validatorId = null) {
+    console.log(`[Venus Rooms] Validating move ${moveId}: ${isValid}`);
+    return { success: true, moveId, isValid, reason };
+  }
+  async roomSubscribeToGameEvents(room, callback) {
+    "game_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
+    if (!this.subscriptions.gameEvents[room.id]) {
+      this.subscriptions.gameEvents[room.id] = [];
     }
+    this.subscriptions.gameEvents[room.id].push(callback);
   }
-  ensureValidSubscribeOptions(options) {
-    if (typeof options !== "object" || options === null) {
-      throw new Error("Simulation subscribe requires an options object");
+  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
+      });
+    }
+    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
+      });
     }
-    const opts = options;
-    if (typeof opts.onUpdate !== "function") {
-      throw new Error("Simulation subscribe requires an onUpdate callback");
+    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
+        });
+      }
     }
-    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)"
-      );
+    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);
+      });
     }
+    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) {
@@ -6526,6 +7459,7 @@ 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;
@@ -6584,14 +7518,19 @@ 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.5";
+var SDK_VERSION = "3.1.0-beta.0";
 
 // src/social/index.ts
 function initializeSocial(venusApi, host) {
@@ -6652,6 +7591,67 @@ var VenusAPI2 = class {
           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",
@@ -6782,6 +7782,58 @@ var VenusAPI2 = class {
         deviceType: "phone",
         hapticsEnabled: false,
         haptics: { supported: false, enabled: false }
+      },
+      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"
+          }
+        }
       }
     });
     const originalConfig = this.config;
@@ -6810,6 +7862,7 @@ var VenusAPI2 = class {
     initializeStorage(this, host);
     initializeRoomsApi(this, host);
     initializeAds(this, host);
+    initializeTheme(this);
     initializePopups(this, host);
     initializeAnalytics(this, host);
     initializeIap(this, host);
@@ -6891,9 +7944,13 @@ 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";
@@ -6948,6 +8005,7 @@ 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);
   }