@series-inc/venus-sdk 3.4.2-beta.2 → 3.4.3-beta.0

package/dist/{chunk-OKOJGDZJ.js → chunk-Q7SNANYR.js}

@@ -112,7 +112,7 @@ var VenusMessageId = /* @__PURE__ */ ((VenusMessageId2) => {
   VenusMessageId2["H5_ROOM_START_GAME"] = "H5_ROOM_START_GAME";
   VenusMessageId2["H5_ROOM_PROPOSE_MOVE"] = "h5:room:proposeMove";
   VenusMessageId2["H5_ROOM_END_GAME"] = "H5_ROOM_END_GAME";
-  VenusMessageId2["H5_ROOM_ELIMINATE_PLAYER"] = "H5_ROOM_ELIMINATE_PLAYER";
+  VenusMessageId2["H5_ROOM_KICK_PLAYER"] = "H5_ROOM_KICK_PLAYER";
   VenusMessageId2["H5_ROOM_PROMOTE_TO_SPECTATOR"] = "H5_ROOM_PROMOTE_TO_SPECTATOR";
   VenusMessageId2["H5_LOAD_EMBEDDED_ASSET"] = "H5_LOAD_EMBEDDED_ASSET";
   VenusMessageId2["H5_SHOW_LOAD_SCREEN"] = "H5_SHOW_LOAD_SCREEN";
@@ -1599,6 +1599,9 @@ var RpcLoggingApi = class {
     return message;
   }
   toStringArg(arg) {
+    if (arg instanceof Error) {
+      return `${arg.name}: ${arg.message}`;
+    }
     if (arg) {
       if (typeof arg === "object") {
         try {
@@ -2017,109 +2020,6 @@ function initializeProfile(venusApi, host) {
   };
 }
 
-// src/utils/idGenerator.ts
-function generateId() {
-  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-
-// src/rpc/RpcClient.ts
-var RpcClient = class {
-  pendingCalls = /* @__PURE__ */ new Map();
-  notificationCallbacks = /* @__PURE__ */ new Map();
-  onResponseSub = null;
-  onNotificationSub = null;
-  transport = null;
-  start(transport) {
-    this.transport = transport;
-    this.onResponseSub = transport.onResponse(async (response) => {
-      return this.handleRpcResponse(response);
-    });
-    this.onNotificationSub = transport.onNotification(async (notification) => {
-      return this.handleRpcNotification(notification);
-    });
-  }
-  stop() {
-    if (this.onResponseSub) {
-      this.onResponseSub.unsubscribe();
-      this.onResponseSub = null;
-    }
-    if (this.onNotificationSub) {
-      this.onNotificationSub.unsubscribe();
-      this.onNotificationSub = null;
-    }
-    this.transport = null;
-  }
-  onNotification(id, callback) {
-    this.notificationCallbacks.set(id, callback);
-    return {
-      unsubscribe: () => {
-        this.notificationCallbacks.delete(id);
-      }
-    };
-  }
-  callT(method, args, timeout = 5e3) {
-    return this.call(method, args, timeout);
-  }
-  async call(method, args, timeout = 5e3) {
-    return new Promise((resolve, reject) => {
-      const id = generateId();
-      this.addPendingCall(id, resolve, reject);
-      const request = {
-        type: "rpc-request",
-        id,
-        method,
-        args
-      };
-      if (this.transport) {
-        this.transport.sendRequest(request);
-      }
-      if (timeout > 0) {
-        setTimeout(() => {
-          if (this.hasPendingCall(id)) {
-            this.removePendingCall(id);
-            reject(new Error(`RPC call ${method} timed out`));
-          }
-        }, timeout);
-      }
-    });
-  }
-  hasPendingCall(id) {
-    return this.pendingCalls.has(id);
-  }
-  addPendingCall(id, resolve, reject) {
-    this.pendingCalls.set(id, {
-      id,
-      resolve,
-      reject
-    });
-  }
-  removePendingCall(id) {
-    this.pendingCalls.delete(id);
-  }
-  getPendingCall(id) {
-    return this.pendingCalls.get(id);
-  }
-  handleRpcResponse(response) {
-    const pending = this.getPendingCall(response.id);
-    if (!pending) {
-      return false;
-    }
-    this.removePendingCall(response.id);
-    if (response.error) {
-      pending.reject(new Error(response.error.message));
-      return true;
-    }
-    pending.resolve(response.result);
-    return true;
-  }
-  handleRpcNotification(notification) {
-    const callback = this.notificationCallbacks.get(notification.id);
-    if (callback) {
-      callback(notification.payload);
-    }
-  }
-};
-
 // src/rooms/VenusRoom.ts
 var ROOM_GAME_PHASES = ["waiting", "playing", "ended"];
 var VenusRoom = class {
@@ -2351,6 +2251,16 @@ var RpcRoomsApi = class {
       }
     );
   }
+  async kickPlayerAsync(room, targetProfileId, options = {}) {
+    const args = {
+      roomId: room.id,
+      targetProfileId
+    };
+    if (options.reason !== void 0) {
+      args.reason = options.reason;
+    }
+    await this.rpcClient.call("H5_ROOM_KICK_PLAYER" /* H5_ROOM_KICK_PLAYER */, args);
+  }
   async startRoomGameAsync(room, options = {}) {
     await this.rpcClient.call(
       "H5_ROOM_START_GAME" /* H5_ROOM_START_GAME */,
@@ -2364,15 +2274,20 @@ var RpcRoomsApi = class {
     );
   }
   async proposeMoveAsync(room, proposalPayload) {
+    const args = {
+      roomId: room.id,
+      gameSpecificState: proposalPayload.gameSpecificState,
+      moveType: proposalPayload.moveType
+    };
+    if (proposalPayload.clientContext !== void 0) {
+      args.clientContext = proposalPayload.clientContext;
+    }
+    if (proposalPayload.clientProposalId !== void 0) {
+      args.clientProposalId = proposalPayload.clientProposalId;
+    }
     const data = await this.rpcClient.call(
       "h5:room:proposeMove" /* H5_ROOM_PROPOSE_MOVE */,
-      {
-        roomId: room.id,
-        gameSpecificState: proposalPayload.gameSpecificState,
-        moveType: proposalPayload.moveType,
-        clientContext: proposalPayload.clientContext,
-        clientProposalId: proposalPayload.clientProposalId
-      }
+      args
     );
     return data;
   }
@@ -2497,6 +2412,7 @@ function initializeRoomsApi(venusApi, host) {
     ["getRoomDataAsync"],
     ["sendRoomMessageAsync"],
     ["leaveRoomAsync"],
+    ["kickPlayerAsync"],
     ["startRoomGameAsync"],
     ["proposeMoveAsync"],
     ["validateMoveAsync"]
@@ -2573,6 +2489,19 @@ var MockStorageApi = class {
     }
     return items;
   }
+  async getAllData() {
+    const result = {};
+    const orderedKeys = this.keys();
+    for (const key of orderedKeys) {
+      const value = localStorage.getItem(this.buildKey(key));
+      if (value !== null) {
+        result[key] = value;
+      } else {
+        this.removeFromOrder(key);
+      }
+    }
+    return result;
+  }
   async getItem(key) {
     const fullKey = this.buildKey(key);
     await this.simulateSyncDelay();
@@ -2850,6 +2779,20 @@ var RpcStorageApi = class {
     }
     return this.rpcClient.call(this.methodIds.getAllItems);
   }
+  async getAllData() {
+    const result = {};
+    const len = await this.length();
+    for (let i = 0; i < len; i++) {
+      const key = await this.key(i);
+      if (key !== null) {
+        const value = await this.getItem(key);
+        if (value !== null) {
+          result[key] = value;
+        }
+      }
+    }
+    return result;
+  }
   setMultipleItems(items) {
     if (!this.methodIds.setMultipleItems) {
       throw new Error("Method not implemented");
@@ -2867,361 +2810,6 @@ function initializeStorage(venusApiInstance, host) {
   venusApiInstance.globalStorage = host.globalStorage;
 }
 
-// src/simulation/RpcSimulationApi.ts
-var RpcSimulationApi = class {
-  rpcClient;
-  _simulationConfig = null;
-  subscriptionCallbacks = /* @__PURE__ */ new Map();
-  constructor(rpcClient) {
-    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
-        );
-      });
-    };
-  }
-  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 || [];
-  }
-  async getSlotAssignmentsAsync(containerId) {
-    const response = await this.rpcClient.call(
-      "H5_SIMULATION_GET_ASSIGNMENTS" /* H5_SIMULATION_GET_ASSIGNMENTS */,
-      {
-        containerId
-      }
-    );
-    return Array.isArray(response) ? response : response.assignments || [];
-  }
-  async getStateAsync(roomId) {
-    const response = await this.rpcClient.call(
-      "H5_SIMULATION_GET_STATE" /* H5_SIMULATION_GET_STATE */,
-      {
-        roomId
-      }
-    );
-    if (response.configuration) {
-      this._simulationConfig = response.configuration;
-    }
-    return response;
-  }
-  async getConfigAsync(roomId) {
-    if (this._simulationConfig) {
-      return this._simulationConfig;
-    }
-    const config = await this.rpcClient.call(
-      "H5_SIMULATION_GET_CONFIG" /* H5_SIMULATION_GET_CONFIG */,
-      {
-        roomId
-      }
-    );
-    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 */,
-      {
-        recipeId,
-        entity,
-        inputs,
-        roomId: options?.roomId ?? null,
-        options
-      }
-    );
-  }
-  getAvailableRecipesAsync(options) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_AVAILABLE_RECIPES" /* H5_SIMULATION_GET_AVAILABLE_RECIPES */,
-      {
-        roomId: options?.roomId || null,
-        includeActorRecipes: options?.includeActorRecipes || false
-      }
-    );
-  }
-  getRecipeRequirementsAsync(recipe) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_RECIPE_REQUIREMENTS */,
-      {
-        recipeId: recipe.recipeId,
-        entity: recipe.entity,
-        batchAmount: recipe.batchAmount
-      }
-    );
-  }
-  getBatchRecipeRequirementsAsync(recipes) {
-    return this.rpcClient.call(
-      "H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS */,
-      {
-        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
-      }
-    );
-  }
-  async resolveFieldValueAsync(entityId, fieldPath, entity) {
-    const response = await this.rpcClient.call(
-      "H5_SIMULATION_RESOLVE_VALUE" /* H5_SIMULATION_RESOLVE_VALUE */,
-      {
-        entityId,
-        fieldPath,
-        entity
-      }
-    );
-    return response.value;
-  }
-  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;
-    }
-    try {
-      callback(notification.updates);
-    } catch (error) {
-      console.error("[Venus SDK] Error in simulation subscription callback", error);
-    }
-  }
-  ensureValidSubscribeOptions(options) {
-    if (typeof options !== "object" || options === null) {
-      throw new Error("Simulation subscribe requires an options object");
-    }
-    const opts = options;
-    if (typeof opts.onUpdate !== "function") {
-      throw new Error("Simulation subscribe requires an onUpdate callback");
-    }
-    const hasFilter = Array.isArray(opts.entities) && opts.entities.length > 0 || Array.isArray(opts.tags) && opts.tags.length > 0 || Boolean(opts.activeRuns);
-    if (!hasFilter) {
-      throw new Error(
-        "Simulation subscribe requires at least one filter (entities, tags, activeRuns)"
-      );
-    }
-  }
-};
-
-// 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/time/utils.ts
 function isPacificDaylightTime(date) {
   const year = date.getFullYear();
@@ -3425,9 +3013,6 @@ function initializeTime(venusApi, host) {
   };
 }
 
-// src/version.ts
-var SDK_VERSION = "3.4.2-beta.2";
-
 // src/shared-assets/base64Utils.ts
 function base64ToArrayBuffer(base64) {
   const binaryString = atob(base64);
@@ -3634,377 +3219,6 @@ function getLibraryDefinition(libraryKey) {
   return definition;
 }
 
-// src/leaderboard/utils.ts
-var HASH_ALGORITHM_WEB_CRYPTO = "SHA-256";
-var HASH_ALGORITHM_NODE = "sha256";
-async function computeScoreHash(score, duration, token, sealingNonce, sealingSecret) {
-  const payload = `score:${score}|duration:${duration}|token:${token}`;
-  const fullPayload = `${payload}|nonce:${sealingNonce}`;
-  const encoder = new TextEncoder();
-  const keyData = encoder.encode(sealingSecret);
-  const messageData = encoder.encode(fullPayload);
-  const cryptoKey = await crypto.subtle.importKey(
-    "raw",
-    keyData,
-    { name: "HMAC", hash: HASH_ALGORITHM_WEB_CRYPTO },
-    false,
-    ["sign"]
-  );
-  const signature = await crypto.subtle.sign("HMAC", cryptoKey, messageData);
-  return Array.from(new Uint8Array(signature)).map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-
-// src/leaderboard/RpcLeaderboardApi.ts
-var RpcLeaderboardApi = class {
-  rpcClient;
-  /** Cache of score tokens for automatic hash computation */
-  tokenCache = /* @__PURE__ */ new Map();
-  constructor(rpcClient) {
-    this.rpcClient = rpcClient;
-  }
-  /**
-   * Create a score token for submitting a score.
-   * Token is cached for automatic hash computation if score sealing is enabled.
-   *
-   * @param mode - Optional game mode
-   * @returns Score token with sealing data if enabled
-   */
-  async createScoreToken(mode) {
-    const token = await this.rpcClient.call(
-      "H5_LEADERBOARD_CREATE_SCORE_TOKEN" /* H5_LEADERBOARD_CREATE_SCORE_TOKEN */,
-      mode ? { mode } : {}
-    );
-    this.tokenCache.set(token.token, token);
-    return token;
-  }
-  /**
-   * Submit a score to the leaderboard.
-   * Automatically computes hash if score sealing is enabled and token was created via createScoreToken().
-   *
-   * @param params - Score submission parameters
-   * @returns Submission result with acceptance status and rank
-   * @throws Error if token not found in cache
-   */
-  async submitScore(params) {
-    let hash;
-    if (params.token) {
-      const cachedToken = this.tokenCache.get(params.token);
-      if (!cachedToken) {
-        throw new Error(
-          "Invalid token: not found in cache. Did you call createScoreToken() first?"
-        );
-      }
-      if (cachedToken.sealingNonce && cachedToken.sealingSecret) {
-        hash = await computeScoreHash(
-          params.score,
-          params.duration,
-          params.token,
-          cachedToken.sealingNonce,
-          cachedToken.sealingSecret
-        );
-      }
-      this.tokenCache.delete(params.token);
-    }
-    return this.rpcClient.call(
-      "H5_LEADERBOARD_SUBMIT_SCORE" /* H5_LEADERBOARD_SUBMIT_SCORE */,
-      {
-        token: params.token,
-        score: params.score,
-        duration: params.duration,
-        mode: params.mode,
-        telemetry: params.telemetry,
-        metadata: params.metadata,
-        hash
-        // undefined if no sealing, computed if sealing enabled
-      }
-    );
-  }
-  getPagedScores(options) {
-    return this.rpcClient.call(
-      "H5_LEADERBOARD_GET_PAGED_SCORES" /* H5_LEADERBOARD_GET_PAGED_SCORES */,
-      options ?? {}
-    );
-  }
-  getMyRank(options) {
-    return this.rpcClient.call(
-      "H5_LEADERBOARD_GET_MY_RANK" /* H5_LEADERBOARD_GET_MY_RANK */,
-      options ?? {}
-    );
-  }
-  getPodiumScores(options) {
-    return this.rpcClient.call(
-      "H5_LEADERBOARD_GET_PODIUM_SCORES" /* H5_LEADERBOARD_GET_PODIUM_SCORES */,
-      options ?? {}
-    );
-  }
-};
-
-// src/leaderboard/MockLeaderboardApi.ts
-var MockLeaderboardApi = class {
-  tokens = /* @__PURE__ */ new Map();
-  /** Cache of score tokens for automatic hash computation */
-  tokenCache = /* @__PURE__ */ new Map();
-  entriesByMode = /* @__PURE__ */ new Map();
-  tokenCounter = 0;
-  enableScoreSealing = false;
-  scoreSealingSecret = "mock-leaderboard-secret-key";
-  constructor(options) {
-    if (options?.enableScoreSealing) {
-      this.enableScoreSealing = true;
-    }
-    if (options?.scoreSealingSecret) {
-      this.scoreSealingSecret = options.scoreSealingSecret;
-    }
-  }
-  /**
-   * Configure mock leaderboard settings
-   *
-   * @param options - Configuration options
-   */
-  configure(options) {
-    if (typeof options.enableScoreSealing === "boolean") {
-      this.enableScoreSealing = options.enableScoreSealing;
-    }
-    if (options.scoreSealingSecret) {
-      this.scoreSealingSecret = options.scoreSealingSecret;
-    }
-  }
-  generateNonce() {
-    return (Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2)).slice(0, 64);
-  }
-  getModeKey(mode) {
-    const normalizedMode = mode || "default";
-    return `${normalizedMode}`;
-  }
-  getEntriesForMode(mode) {
-    const key = this.getModeKey(mode);
-    if (!this.entriesByMode.has(key)) {
-      this.entriesByMode.set(key, []);
-    }
-    return this.entriesByMode.get(key);
-  }
-  /**
-   * Create a mock score token for testing.
-   * Token is cached for automatic hash computation if score sealing is enabled.
-   *
-   * @param mode - Optional game mode
-   * @returns Score token with sealing data if enabled
-   */
-  async createScoreToken(mode) {
-    const token = `mock_token_${++this.tokenCounter}`;
-    const startTime = Date.now();
-    const expiresAt = startTime + 36e5;
-    const resolvedMode = mode || "default";
-    const sealingNonce = this.enableScoreSealing ? this.generateNonce() : null;
-    const sealingSecret = this.enableScoreSealing ? this.scoreSealingSecret : null;
-    this.tokens.set(token, {
-      id: token,
-      expiresAt,
-      mode: resolvedMode,
-      sealingNonce,
-      used: false
-    });
-    const result = {
-      token,
-      startTime,
-      expiresAt,
-      sealingNonce,
-      sealingSecret,
-      mode: resolvedMode
-    };
-    this.tokenCache.set(token, result);
-    return result;
-  }
-  /**
-   * Submit a mock score to the leaderboard.
-   * Automatically computes hash if score sealing is enabled and token was created via createScoreToken().
-   *
-   * @param params - Score submission parameters
-   * @returns Submission result with acceptance status and rank
-   * @throws Error if token not found in cache or validation fails
-   */
-  async submitScore(params) {
-    let hash;
-    if (params.token) {
-      const cachedToken = this.tokenCache.get(params.token);
-      if (!cachedToken) {
-        throw new Error(
-          "Invalid token: not found in cache. Did you call createScoreToken() first?"
-        );
-      }
-      if (cachedToken.sealingNonce && cachedToken.sealingSecret) {
-        hash = await computeScoreHash(
-          params.score,
-          params.duration,
-          params.token,
-          cachedToken.sealingNonce,
-          cachedToken.sealingSecret
-        );
-      }
-    }
-    if (!params.token) {
-      const mode = params.mode || "default";
-      const submittedAt2 = Date.now();
-      const entry2 = {
-        profileId: `mock_profile`,
-        username: "Mock Player",
-        avatarUrl: null,
-        score: params.score,
-        duration: params.duration,
-        submittedAt: submittedAt2,
-        token: "simple-mode",
-        rank: null,
-        zScore: null,
-        isAnomaly: false,
-        trustScore: 50,
-        metadata: params.metadata ?? null,
-        isSeed: false
-      };
-      const modeEntries2 = this.getEntriesForMode(mode);
-      modeEntries2.push(entry2);
-      modeEntries2.sort((a, b) => {
-        if (b.score !== a.score) return b.score - a.score;
-        return a.submittedAt - b.submittedAt;
-      });
-      modeEntries2.forEach((e, index) => {
-        modeEntries2[index] = { ...e, rank: index + 1 };
-      });
-      const inserted2 = modeEntries2.find((e) => e.submittedAt === submittedAt2);
-      return {
-        accepted: true,
-        rank: inserted2?.rank ?? null
-      };
-    }
-    const scoreToken = this.tokens.get(params.token);
-    if (!scoreToken) {
-      throw new Error("Invalid score token");
-    }
-    if (scoreToken.expiresAt < Date.now()) {
-      throw new Error("Invalid or expired score token");
-    }
-    if (scoreToken.used) {
-      throw new Error("Score token already used");
-    }
-    if (params.mode && params.mode !== scoreToken.mode) {
-      throw new Error("Submission mode does not match token mode");
-    }
-    if (scoreToken.sealingNonce && !hash) {
-      throw new Error("Score hash required when score sealing is enabled");
-    }
-    const submittedAt = Date.now();
-    const entry = {
-      profileId: `mock_profile`,
-      username: "Mock Player",
-      avatarUrl: null,
-      score: params.score,
-      duration: params.duration,
-      submittedAt,
-      token: params.token,
-      rank: null,
-      zScore: null,
-      isAnomaly: false,
-      trustScore: 50,
-      metadata: params.metadata ?? null,
-      isSeed: false
-    };
-    const modeEntries = this.getEntriesForMode(scoreToken.mode);
-    modeEntries.push(entry);
-    modeEntries.sort((a, b) => {
-      if (b.score !== a.score) return b.score - a.score;
-      return a.submittedAt - b.submittedAt;
-    });
-    modeEntries.forEach((e, index) => {
-      modeEntries[index] = { ...e, rank: index + 1 };
-    });
-    scoreToken.used = true;
-    scoreToken.sealingNonce = null;
-    this.tokenCache.delete(params.token);
-    const inserted = modeEntries.find((e) => e.token === params.token && e.submittedAt === submittedAt);
-    return {
-      accepted: true,
-      rank: inserted?.rank ?? null
-    };
-  }
-  async getPagedScores(options) {
-    const limit = options?.limit ?? 10;
-    const mode = options?.mode ?? "default";
-    const modeEntries = [...this.getEntriesForMode(mode)];
-    const entries = modeEntries.slice(0, limit).map((entry) => ({
-      ...entry
-    }));
-    return {
-      variant: "standard",
-      entries,
-      totalEntries: modeEntries.length,
-      nextCursor: null,
-      playerRank: null,
-      periodInstance: options?.period ?? "alltime"
-    };
-  }
-  async getMyRank(_options) {
-    const mode = _options?.mode ?? "default";
-    const modeEntries = this.getEntriesForMode(mode);
-    const playerEntry = modeEntries[0] ?? null;
-    return {
-      rank: playerEntry?.rank ?? null,
-      score: playerEntry?.score,
-      totalPlayers: modeEntries.length,
-      percentile: playerEntry ? Math.max(0, 1 - ((playerEntry.rank ?? 1) - 1) / Math.max(modeEntries.length, 1)) : void 0,
-      trustScore: 50,
-      periodInstance: _options?.period ?? "alltime"
-    };
-  }
-  async getPodiumScores(options) {
-    const mode = options?.mode ?? "default";
-    const modeEntries = [...this.getEntriesForMode(mode)];
-    const topCount = Math.max(1, Math.min(options?.topCount ?? 3, 10));
-    const aheadCount = Math.max(0, Math.min(options?.contextAhead ?? 4, 10));
-    const behindCount = Math.max(0, Math.min(options?.contextBehind ?? 2, 10));
-    const topEntries = modeEntries.slice(0, topCount);
-    const playerEntry = modeEntries[0] ?? null;
-    const totalEntries = modeEntries.length;
-    let playerRank = playerEntry?.rank ?? null;
-    let beforePlayer = [];
-    let afterPlayer = [];
-    let totalBefore = playerRank ? playerRank - 1 : 0;
-    let totalAfter = playerRank ? Math.max(totalEntries - playerRank, 0) : 0;
-    let omittedBefore = totalBefore;
-    let omittedAfter = totalAfter;
-    if (playerRank && playerRank > 0) {
-      const beforeStart = Math.max(playerRank - aheadCount - 1, 0);
-      beforePlayer = modeEntries.slice(beforeStart, playerRank - 1);
-      const afterEnd = Math.min(playerRank + behindCount, totalEntries);
-      afterPlayer = modeEntries.slice(playerRank, afterEnd);
-      const shownTopAhead = topEntries.filter((entry) => (entry.rank ?? 0) > 0 && (entry.rank ?? 0) < playerRank).length;
-      omittedBefore = Math.max(totalBefore - (beforePlayer.length + shownTopAhead), 0);
-      omittedAfter = Math.max(totalAfter - afterPlayer.length, 0);
-    }
-    return {
-      variant: "highlight",
-      entries: topEntries,
-      totalEntries,
-      nextCursor: null,
-      playerRank: playerRank ?? null,
-      periodInstance: options?.period ?? "alltime",
-      context: {
-        topEntries,
-        beforePlayer,
-        playerEntry: playerEntry ?? null,
-        afterPlayer,
-        totalBefore,
-        totalAfter,
-        omittedBefore,
-        omittedAfter
-      }
-    };
-  }
-};
-
-// src/leaderboard/index.ts
-function initializeLeaderboard(venusApiInstance, host) {
-  venusApiInstance.leaderboard = host.leaderboard;
-}
-
 // src/game-preloader/MockPreloaderApi.ts
 var MockPreloaderApi = class {
   async showLoadScreen() {
@@ -4077,1049 +3291,41 @@ var MockSocialApi = class {
   }
 };
 
-// src/social/RpcSocialApi.ts
-var RpcSocialApi = class {
-  constructor(rpcClient) {
-    this.rpcClient = rpcClient;
-  }
-  async shareLinkAsync(options) {
-    const result = await this.rpcClient.call("H5_SHARE_LINK" /* SHARE_LINK */, {
-      launchParams: options.launchParams,
-      metadata: options.metadata ?? {}
-    });
-    return {
-      shareUrl: result.shareUrl
-    };
-  }
-  async createQRCodeAsync(options) {
-    const result = await this.rpcClient.call(
-      "H5_CREATE_SHARE_QRCODE" /* CREATE_SHARE_QRCODE */,
-      {
-        launchParams: options.launchParams,
-        metadata: options.metadata ?? {},
-        qrOptions: options.qrOptions ?? {}
-      }
-    );
-    return {
-      shareUrl: result.shareUrl,
-      qrCode: result.qrCode
-    };
-  }
-};
-
-// src/VenusTransport.ts
-var VenusTransport = class {
-  messageHandler;
-  onNotificationCallbacks = [];
-  onNotificationCallbacksToRemove = [];
-  onVenusMessageCallbacks = [];
-  onResponseCallbacks = [];
-  onResponseCallbacksToRemove = [];
-  _instanceId = null;
-  isStarted = false;
-  isProcessingMessage = false;
-  constructor() {
-    this.messageHandler = async (event) => {
-      this.isProcessingMessage = true;
-      let message;
-      if (typeof event.data === "string") {
-        message = JSON.parse(event.data);
-      } else {
-        message = event.data;
-      }
-      if (!message) {
-        this.logInfo("No message found. Ignoring message...");
-        return;
-      }
-      this.notifyVenusMessageReceived(message);
-      if (message.type === "PAUSE" /* PAUSE */ || message.type === "RESUME" /* RESUME */ || message.type === "AWAKE" /* AWAKE */ || message.type === "SLEEP" /* SLEEP */ || message.type === "QUIT" /* QUIT */) {
-        const notification = {
-          type: "rpc-notification",
-          id: message.type,
-          payload: message.data
-        };
-        this.handleNotification(notification);
-        this.isProcessingMessage = false;
-        return;
-      }
-      const messageData = message.data;
-      if (!messageData) {
-        this.logWarn("No data found. Ignoring message...");
-        this.isProcessingMessage = false;
-        return;
-      }
-      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...");
-        this.isProcessingMessage = false;
-        return;
-      }
-      if (message.type !== "H5_RESPONSE" /* H5_RESPONSE */) {
-        this.logWarn(`Ignoring unknown message type: ${message.type}`);
-        this.isProcessingMessage = false;
-        return;
-      }
-      const success = messageData.success;
-      let error = void 0;
-      if (!success) {
-        error = {
-          message: messageData.error || "Unknown error"
-        };
-      }
-      let result = messageData.value;
-      if (result === void 0) {
-        result = messageData.data;
-      }
-      const response = {
-        type: "rpc-response",
-        id: requestId,
-        result,
-        method: message.type,
-        error
-      };
-      await this.handleResponse(response);
-      this.isProcessingMessage = false;
-    };
-  }
-  onNotification(callback) {
-    this.onNotificationCallbacks.push(callback);
-    return {
-      unsubscribe: () => {
-        if (this.isProcessingMessage) {
-          this.onNotificationCallbacks.push(callback);
-        } else {
-          this.removeOnNotificationCallback(callback);
-        }
-      }
-    };
-  }
-  onRequest(callback) {
-    throw new Error("Method not implemented.");
-  }
-  onResponse(callback) {
-    this.onResponseCallbacks.push(callback);
-    return {
-      unsubscribe: () => {
-        if (this.isProcessingMessage) {
-          this.onResponseCallbacksToRemove.push(callback);
-        } else {
-          this.removeOnResponseCallback(callback);
-        }
-      }
-    };
-  }
-  get instanceId() {
-    return this._instanceId;
-  }
-  set instanceId(instanceId) {
-    this._instanceId = instanceId;
-  }
-  sendRequest(request) {
-    const instanceId = this.instanceId || "unknown";
-    const method = request.method;
-    const message = {
-      type: method,
-      direction: "H5_TO_APP",
-      data: {
-        ...request.args,
-        requestId: request.id
-      },
-      instanceId,
-      timestamp: Date.now()
-    };
-    this.sendVenusMessage(message);
-  }
-  sendVenusMessage(message) {
-    const messageAsString = JSON.stringify(message, null, 2);
-    const reactNativeWebView = window.ReactNativeWebView;
-    if (reactNativeWebView) {
-      reactNativeWebView.postMessage(messageAsString);
-    } else {
-      window.parent.postMessage(messageAsString, "*");
-    }
-  }
-  sendResponse(response) {
-    throw new Error("Method not implemented.");
-  }
-  start() {
-    if (this.isStarted) {
-      return;
-    }
-    this.isStarted = true;
-    window.addEventListener("message", this.messageHandler, true);
-    this.logInfo(`Started`);
-  }
-  stop() {
-    if (!this.isStarted) {
-      return;
-    }
-    this.isStarted = false;
-    window.removeEventListener("message", this.messageHandler);
-    this.logInfo(`Stopped`);
-  }
-  handleNotification(notification) {
-    for (const callback of this.onNotificationCallbacks) {
-      callback(notification);
-    }
-    for (const callback of this.onNotificationCallbacksToRemove) {
-      this.removeOnNotificationCallback(callback);
-    }
-    this.onNotificationCallbacksToRemove.length = 0;
-  }
-  async handleResponse(response) {
-    for (const callback of this.onResponseCallbacks) {
-      const consumed = await callback(response);
-      if (consumed) {
-        break;
-      }
-    }
-    for (const callback of this.onResponseCallbacksToRemove) {
-      this.removeOnResponseCallback(callback);
-    }
-    this.onResponseCallbacksToRemove.length = 0;
-  }
-  removeOnResponseCallback(callback) {
-    this.onResponseCallbacks.splice(
-      this.onResponseCallbacks.indexOf(callback),
-      1
-    );
-  }
-  removeOnNotificationCallback(callback) {
-    this.onNotificationCallbacks.splice(
-      this.onNotificationCallbacks.indexOf(callback),
-      1
-    );
-  }
-  logInfo(message, ...params) {
-    console.log(`[Venus Transport] ${message}`, ...params);
-  }
-  logWarn(message, ...params) {
-    console.warn(`[Venus Transport] ${message}`, ...params);
-  }
-  onVenusMessage(callback) {
-    this.onVenusMessageCallbacks.push(callback);
-    return {
-      unsubscribe: () => {
-        this.onVenusMessageCallbacks.splice(
-          this.onVenusMessageCallbacks.indexOf(callback),
-          1
-        );
-      }
-    };
-  }
-  notifyVenusMessageReceived(message) {
-    for (const callback of this.onVenusMessageCallbacks) {
-      callback(message);
-    }
-  }
-};
-
-// src/RemoteHost.ts
-var getCdnBaseUrl = () => {
-  return "https://venus-static-01293ak.web.app/";
-};
-var RemoteHost = class {
-  ads;
-  analytics;
-  deviceCache;
-  appStorage;
-  globalStorage;
-  avatar3d;
-  navigation;
-  notifications;
-  popups;
-  profile;
-  system;
-  cdn;
-  time;
-  ai;
-  haptics;
-  features;
-  lifecycle;
-  simulation;
-  rooms;
-  logging;
-  iap;
-  leaderboard;
-  preloader;
-  social;
-  context;
-  get isInitialized() {
-    return this._isInitialized;
-  }
-  venusApi;
-  rpcClient;
-  _isInitialized = false;
-  constructor(venusApi) {
-    this.venusApi = venusApi;
-    const rpcClient = new RpcClient();
-    this.rpcClient = rpcClient;
-    this.ads = new RpcAdsApi(rpcClient);
-    this.analytics = new RpcAnalyticsApi(rpcClient);
-    this.deviceCache = new RpcStorageApi(rpcClient, {
-      clear: "H5_DEVICE_CACHE_CLEAR" /* DEVICE_CACHE_CLEAR */,
-      getItem: "H5_DEVICE_CACHE_GET_ITEM" /* DEVICE_CACHE_GET_ITEM */,
-      getKey: "H5_DEVICE_CACHE_KEY" /* DEVICE_CACHE_KEY */,
-      length: "H5_DEVICE_CACHE_LENGTH" /* DEVICE_CACHE_LENGTH */,
-      removeItem: "H5_DEVICE_CACHE_REMOVE_ITEM" /* DEVICE_CACHE_REMOVE_ITEM */,
-      setItem: "H5_DEVICE_CACHE_SET_ITEM" /* DEVICE_CACHE_SET_ITEM */
-    });
-    this.appStorage = new RpcStorageApi(rpcClient, {
-      clear: "H5_APP_STORAGE_CLEAR" /* APP_STORAGE_CLEAR */,
-      getItem: "H5_APP_STORAGE_GET_ITEM" /* APP_STORAGE_GET_ITEM */,
-      getKey: "H5_APP_STORAGE_KEY" /* APP_STORAGE_KEY */,
-      length: "H5_APP_STORAGE_LENGTH" /* APP_STORAGE_LENGTH */,
-      removeItem: "H5_APP_STORAGE_REMOVE_ITEM" /* APP_STORAGE_REMOVE_ITEM */,
-      setItem: "H5_APP_STORAGE_SET_ITEM" /* APP_STORAGE_SET_ITEM */,
-      getAllItems: "H5_APP_STORAGE_GET_ALL_ITEMS" /* APP_STORAGE_GET_ALL_ITEMS */,
-      setMultipleItems: "H5_APP_STORAGE_SET_ITEM" /* APP_STORAGE_SET_ITEM */,
-      removeMultipleItems: "H5_APP_STORAGE_REMOVE_ITEM" /* APP_STORAGE_REMOVE_ITEM */
-    });
-    this.globalStorage = new RpcStorageApi(rpcClient, {
-      clear: "H5_GLOBAL_STORAGE_CLEAR" /* GLOBAL_STORAGE_CLEAR */,
-      getItem: "H5_GLOBAL_STORAGE_GET_ITEM" /* GLOBAL_STORAGE_GET_ITEM */,
-      getKey: "H5_GLOBAL_STORAGE_KEY" /* GLOBAL_STORAGE_KEY */,
-      length: "H5_GLOBAL_STORAGE_LENGTH" /* GLOBAL_STORAGE_LENGTH */,
-      removeItem: "H5_GLOBAL_STORAGE_REMOVE_ITEM" /* GLOBAL_STORAGE_REMOVE_ITEM */,
-      setItem: "H5_GLOBAL_STORAGE_SET_ITEM" /* GLOBAL_STORAGE_SET_ITEM */,
-      getAllItems: "H5_GLOBAL_STORAGE_GET_ALL_ITEMS" /* GLOBAL_STORAGE_GET_ALL_ITEMS */,
-      setMultipleItems: "H5_GLOBAL_STORAGE_SET_MULTIPLE_ITEMS" /* GLOBAL_STORAGE_SET_MULTIPLE_ITEMS */,
-      removeMultipleItems: "H5_GLOBAL_STORAGE_REMOVE_MULTIPLE_ITEMS" /* GLOBAL_STORAGE_REMOVE_MULTIPLE_ITEMS */
-    });
-    this.avatar3d = new RpcAvatarApi(rpcClient, venusApi);
-    this.navigation = new RpcNavigationApi(rpcClient, venusApi);
-    this.notifications = new RpcNotificationsApi(rpcClient);
-    this.popups = new RpcPopupsApi(rpcClient);
-    this.profile = new HostProfileApi(venusApi);
-    const deviceApi = new HostDeviceApi(venusApi);
-    const environmentApi = new HostEnvironmentApi(venusApi);
-    this.system = new HostSystemApi(deviceApi, environmentApi, venusApi);
-    this.cdn = new HostCdnApi(getCdnBaseUrl());
-    this.time = new HostTimeApi(rpcClient, venusApi);
-    this.ai = new RpcAiApi(rpcClient);
-    this.haptics = new RpcHapticsApi(rpcClient);
-    this.features = new RpcFeaturesApi(rpcClient);
-    this.lifecycle = new RpcLifecycleApi(rpcClient);
-    this.simulation = new RpcSimulationApi(rpcClient);
-    this.rooms = new RpcRoomsApi(rpcClient);
-    this.logging = new RpcLoggingApi(this, rpcClient);
-    this.iap = new RpcIapApi(rpcClient);
-    this.leaderboard = new RpcLeaderboardApi(rpcClient);
-    this.preloader = new RpcPreloaderApi(rpcClient);
-    this.social = new RpcSocialApi(rpcClient);
-    venusApi.isMock = () => false;
-    this.venusApi.sharedAssets = new RpcSharedAssetsApi(rpcClient, venusApi);
-    initializeRoomsApi(this.venusApi, this);
-  }
-  async initialize(options) {
-    this.log("Initializing Remote Host...");
-    const transport = new VenusTransport();
-    transport.start();
-    this.rpcClient.start(transport);
-    const roomsApi = this.rooms;
-    roomsApi.setupNotifications(transport);
-    const response = await this.rpcClient.call(
-      "INITIALIZE_SDK" /* INIT_SDK */,
-      {},
-      5e3
-    );
-    transport.instanceId = response.instanceId;
-    this.log(`Remote Host Initialized with id: ${transport.instanceId}`);
-    const profile = response.profile;
-    const sanitizedProfile = {
-      id: profile.id,
-      username: profile.username,
-      avatarUrl: profile.avatarUrl ?? null,
-      isAnonymous: Boolean(profile.isAnonymous)
-    };
-    this.venusApi._profileData = sanitizedProfile;
-    this.venusApi._deviceData = response.device;
-    this.venusApi._environmentData = response.environment;
-    this.venusApi._localeData = response.locale;
-    this.venusApi._languageCodeData = response.languageCode;
-    this._isInitialized = true;
-    this.venusApi.launchParams = response.launchParams;
-    await this.rpcClient.call("READY" /* READY */, {});
-    const safeArea = response.safeArea;
-    if (safeArea) {
-      this.venusApi._safeAreaData = safeArea;
-    }
-    this.context = {
-      safeArea,
-      initializeAsleep: response.initializeAsleep
-    };
-    return this.context;
+// src/config/sandbox.ts
+function getSandboxConfig() {
+  if (typeof globalThis === "undefined") {
+    return null;
   }
-  log(message) {
-    console.log(`[Venus SDK] [Remote Host] ${message}`);
+  const config = globalThis.__VENUS_SANDBOX__;
+  if (!config?.enabled) {
+    return null;
   }
-};
-
-// src/MockHost.ts
-var ROOMS_UNAVAILABLE_MESSAGE = "[Venus SDK] Rooms API is only available when running inside the Venus host environment.";
-function createUnavailableRoomsApi() {
-  const roomsUnavailableError = () => new Error(ROOMS_UNAVAILABLE_MESSAGE);
-  return {
-    async createRoomAsync() {
-      throw roomsUnavailableError();
-    },
-    async joinOrCreateRoomAsync() {
-      throw roomsUnavailableError();
-    },
-    async joinRoomByCodeAsync() {
-      throw roomsUnavailableError();
-    },
-    async getUserRoomsAsync() {
-      throw roomsUnavailableError();
-    },
-    async subscribeAsync() {
-      throw roomsUnavailableError();
-    },
-    async updateRoomDataAsync() {
-      throw roomsUnavailableError();
-    },
-    async getRoomDataAsync() {
-      throw roomsUnavailableError();
-    },
-    async sendRoomMessageAsync() {
-      throw roomsUnavailableError();
-    },
-    async leaveRoomAsync() {
-      throw roomsUnavailableError();
-    },
-    async startRoomGameAsync() {
-      throw roomsUnavailableError();
-    },
-    async proposeMoveAsync() {
-      throw roomsUnavailableError();
-    },
-    async validateMoveAsync() {
-      throw roomsUnavailableError();
-    }
-  };
+  return config;
 }
-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();
-    }
-  };
+function isSandboxEnabled() {
+  const config = getSandboxConfig();
+  return config?.enabled === true;
 }
-var MockHost = class {
-  ads;
-  analytics;
-  deviceCache;
-  appStorage;
-  globalStorage;
-  avatar3d;
-  navigation;
-  notifications;
-  popups;
-  profile;
-  system;
-  cdn;
-  time;
-  ai;
-  haptics;
-  features;
-  lifecycle;
-  simulation;
-  rooms;
-  logging;
-  iap;
-  leaderboard;
-  preloader;
-  social;
-  context;
-  state = 0 /* PLAYING */;
-  get isInitialized() {
-    return this._isInitialized;
-  }
-  venusApi;
-  _isInitialized = false;
-  _overlay;
-  _mockLifecyclesApi;
-  _mockAdsApi;
-  constructor(venusApi) {
-    this.venusApi = venusApi;
-    this._overlay = this.createOverlay();
-    this._mockAdsApi = new MockAdsApi(this._overlay);
-    this._mockLifecyclesApi = new MockLifecycleApi();
-    this.ads = this._mockAdsApi;
-    this.analytics = new MockAnalyticsApi();
-    const appUrl = typeof window !== "undefined" ? window.location.href : "";
-    this.deviceCache = createMockStorageApi("deviceCache", appUrl);
-    this.appStorage = createMockStorageApi("appStorage", appUrl);
-    this.globalStorage = createMockStorageApi("globalStorage");
-    this.avatar3d = new MockAvatarApi(venusApi);
-    this.navigation = new MockNavigationApi(venusApi);
-    this.notifications = new MockNotificationsApi(venusApi);
-    this.popups = new MockPopupsApi(this._overlay);
-    this.profile = new MockProfileApi(venusApi);
-    const deviceApi = new MockDeviceApi(venusApi);
-    const environmentApi = new MockEnvironmentApi(venusApi);
-    this.system = new MockSystemApi(deviceApi, environmentApi, venusApi);
-    this.cdn = new MockCdnApi(venusApi);
-    this.time = new MockTimeApi(venusApi);
-    this.ai = new MockAiApi();
-    this.haptics = new MockHapticsApi(venusApi);
-    this.features = new MockFeaturesApi();
-    this.lifecycle = this._mockLifecyclesApi;
-    this.simulation = createUnavailableSimulationApi();
-    this.rooms = createUnavailableRoomsApi();
-    this.logging = new MockLoggingApi();
-    this.iap = new MockIapApi();
-    this.social = new MockSocialApi();
-    this.leaderboard = new MockLeaderboardApi();
-    initializeRoomsApi(this.venusApi, this);
-    this.preloader = new MockPreloaderApi();
-    venusApi.isMock = () => true;
-    this.venusApi.sharedAssets = new MockSharedAssetsApi(this.venusApi);
-  }
-  initialize(options) {
-    this._isInitialized = true;
-    this.venusApi._profileData = this.profile.getCurrentProfile();
-    this.venusApi._deviceData = this.system.getDevice();
-    this.venusApi._environmentData = this.system.getEnvironment();
-    this.venusApi._localeData = this.venusApi._mock?.locale || "en-US";
-    this.venusApi._languageCodeData = this.venusApi._mock?.languageCode || "en";
-    this.context = {
-      initializeAsleep: false,
-      safeArea: this.venusApi._safeAreaData
-    };
-    return Promise.resolve(this.context);
-  }
-  createOverlay() {
-    const overlayContainer = document.createElement("div");
-    overlayContainer.id = "venus-mock-overlay";
-    overlayContainer.style.cssText = `
-      position: fixed;
-      top: 0;
-      left: 0;
-      width: 100%;
-      height: 100%;
-      pointer-events: none;
-      z-index: 10000;
-    `;
-    document.body.appendChild(overlayContainer);
-    const menuButton = this.createOverlayButton(
-      "close",
-      "Menu",
-      { x: window.innerWidth - 48, y: 16, width: 32, height: 32 },
-      () => {
-        this.handleMenuButtonClicked();
-      },
-      "rgba(59, 130, 246, 0.7)",
-      // Blue background instead of black
-      "#FFFFFF"
-    );
-    overlayContainer.appendChild(menuButton);
-    const adOverlay = this.setupAdOverlay();
-    const actionSheet = this.setupActionSheetOverlay();
-    window.addEventListener("resize", () => {
-      this.updateOverlayLayout();
-    });
-    return {
-      container: overlayContainer,
-      elements: {
-        menuButton
-      },
-      appVisibilityState: "visible",
-      actionSheetOverlay: actionSheet,
-      adOverlay,
-      showAdOverlay: () => {
-        return this.showAdOverlay("REWARDED VIDEO AD");
-      },
-      showActionSheet: (items, options) => {
-        return this.showActionSheetOverlay(items, options);
-      }
-    };
-  }
-  async handleMenuButtonClicked() {
-    if (this.state === 0 /* PLAYING */) {
-      this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
-      this.state = 1 /* PAUSED */;
-    }
-    const actionSheetItems = [];
-    const awakeAction = {
-      label: "\u23F0 Awake",
-      id: "awakeAction"
-    };
-    const sleepAction = {
-      label: "\u{1F4A4} Sleep",
-      id: "sleepAction"
-    };
-    const quitAction = {
-      label: "\u{1F6D1} Quit",
-      id: "quitAction"
-    };
-    const playAction = {
-      label: "\u25B6\uFE0F Play",
-      id: "playAction"
-    };
-    if (this.state === 1 /* PAUSED */) {
-      actionSheetItems.push(sleepAction);
-    } else if (this.state === 2 /* SLEEPING */) {
-      actionSheetItems.push(awakeAction);
-    }
-    if (this.state !== 3 /* TERMINATED */) {
-      actionSheetItems.push(quitAction);
-    } else if (this.state === 3 /* TERMINATED */) {
-      actionSheetItems.push(playAction);
-    }
-    const action = await this.showActionSheetOverlay(actionSheetItems);
-    if (action === awakeAction.id) {
-      this.tryAwake();
-    } else if (action === sleepAction.id) {
-      this.trySleep();
-    } else if (action === playAction.id) {
-      this.tryPlay();
-    } else if (action === quitAction.id) {
-      this.tryQuit();
-    } else {
-      this.tryResume();
-    }
+var VENUS_API_PROXY_PATH = "/__venusapi";
+function buildFunctionsBaseUrl(config) {
+  if (config.backendUrl) {
+    return config.backendUrl.replace(/\/$/, "");
   }
-  tryAwake() {
-    if (this.state === 2 /* SLEEPING */) {
-      this.triggerLifecycleEvent("AWAKE" /* AWAKE */);
-      this.state = 1 /* PAUSED */;
-    }
+  if (config.target === "local" && config.functionsEmulatorHost && config.firebaseConfig?.projectId) {
+    const region = config.functionsRegion || "us-central1";
+    return `http://${config.functionsEmulatorHost}/${config.firebaseConfig.projectId}/${region}`;
   }
-  trySleep() {
-    if (this.state === 1 /* PAUSED */) {
-      this.triggerLifecycleEvent("SLEEP" /* SLEEP */);
-      this.state = 2 /* SLEEPING */;
-    }
+  if (config.target !== "local" && typeof window !== "undefined") {
+    return VENUS_API_PROXY_PATH;
   }
-  tryPlay() {
-    if (this.state === 3 /* TERMINATED */) {
-      this.triggerLifecycleEvent("AWAKE" /* AWAKE */);
-      this.state = 1 /* PAUSED */;
-      this.triggerLifecycleEvent("RESUME" /* RESUME */);
-      this.state = 0 /* PLAYING */;
-    }
+  if (config.firebaseConfig?.projectId && config.functionsRegion) {
+    return `https://${config.functionsRegion}-${config.firebaseConfig.projectId}.cloudfunctions.net`;
   }
-  tryQuit() {
-    if (this.state === 0 /* PLAYING */) {
-      this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
-      this.state = 1 /* PAUSED */;
-    }
-    if (this.state === 1 /* PAUSED */) {
-      this.triggerLifecycleEvent("SLEEP" /* SLEEP */);
-      this.state = 2 /* SLEEPING */;
-    }
-    if (this.state === 2 /* SLEEPING */) {
-      this.triggerLifecycleEvent("QUIT" /* QUIT */);
-      this.state = 3 /* TERMINATED */;
-    }
-  }
-  tryResume() {
-    if (this.state === 1 /* PAUSED */) {
-      this.triggerLifecycleEvent("RESUME" /* RESUME */);
-      this.state = 0 /* PLAYING */;
-    }
-  }
-  async showAdOverlay(type) {
-    return new Promise((resolve, reject) => {
-      const overlay = this._overlay;
-      const adOverlay = overlay.adOverlay;
-      overlay.adOverlay.innerHTML = "";
-      const heading = document.createElement("h1");
-      heading.style.cssText = `
-        font-size: 24px;
-        margin-bottom: 20px;
-        text-align: center;
-      `;
-      heading.innerText = type === "interstitial" ? "INTERSTITIAL AD" : "REWARDED VIDEO AD";
-      overlay.adOverlay.appendChild(heading);
-      const content = document.createElement("div");
-      content.style.cssText = `
-        width: 300px;
-        height: 250px;
-        background-color: #1e40af;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        margin-bottom: 20px;
-        border-radius: 8px;
-      `;
-      content.innerText = "Mock Ad Content";
-      adOverlay.appendChild(content);
-      const timer = document.createElement("p");
-      timer.style.cssText = `
-        margin-bottom: 20px;
-        font-size: 16px;
-      `;
-      timer.innerText = "Normally ads would have a timer...";
-      adOverlay.appendChild(timer);
-      const okButton = document.createElement("button");
-      okButton.style.cssText = `
-        padding: 10px 40px;
-        background-color: #2563eb;
-        color: white;
-        border: none;
-        border-radius: 4px;
-        font-size: 16px;
-        cursor: pointer;
-      `;
-      okButton.innerText = "Close Ad";
-      adOverlay.appendChild(okButton);
-      adOverlay.style.display = "flex";
-      okButton.onclick = () => {
-        this.hideAdOverlay();
-        resolve(true);
-      };
-    });
-  }
-  hideAdOverlay() {
-    const overlay = this._overlay;
-    if (overlay.adOverlay) {
-      overlay.adOverlay.style.display = "none";
-    }
-  }
-  setupActionSheetOverlay() {
-    const actionSheetOverlay = document.createElement("div");
-    actionSheetOverlay.id = "venus-action-sheet-overlay";
-    actionSheetOverlay.style.cssText = `
-        position: fixed;
-        top: 0;
-        left: 0;
-        width: 100%;
-        height: 100%;
-        background-color: rgba(0, 0, 0, 0.5);
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        z-index: 10600;
-        font-family: sans-serif;
-        display: none;
-      `;
-    document.body.appendChild(actionSheetOverlay);
-    return actionSheetOverlay;
-  }
-  createOverlayButton(id, text, position, onClick, background, color) {
-    const button = document.createElement("button");
-    button.id = `venus-mock-${id}-button`;
-    button.innerText = text;
-    button.style.cssText = `
-      position: absolute;
-      left: ${position.x}px;
-      top: ${position.y}px;
-      width: ${position.width}px;
-      min-width: ${position.width}px;
-      height: ${position.height}px;
-      background: ${background};
-      color: ${color};
-      border: none;
-      border-radius: 8px;
-      font-family: sans-serif;
-      font-weight: bold;
-      font-size: ${Math.min(position.width, position.height) / 3}px;
-      cursor: pointer;
-      pointer-events: auto;
-      display: flex;
-      align-items: center;
-      justify-content: center;
-      opacity: 0.9;
-      transition: opacity 0.2s;
-    `;
-    button.addEventListener("click", onClick);
-    button.addEventListener("mouseover", () => {
-      button.style.opacity = "1";
-    });
-    button.addEventListener("mouseout", () => {
-      button.style.opacity = "0.9";
-    });
-    return button;
-  }
-  updateOverlayLayout() {
-    const overlay = this._overlay;
-    const menuBtn = overlay.elements.menuButton;
-    menuBtn.style.left = `${window.innerWidth - 48}px`;
-    menuBtn.style.top = "16px";
-    menuBtn.style.width = "32px";
-    menuBtn.style.minWidth = "32px";
-    menuBtn.style.height = "32px";
-  }
-  triggerLifecycleEvent(name) {
-    console.log("Trigger Lifecycle Event: ", name);
-    if (name == "PAUSE" /* PAUSE */) {
-      this._mockLifecyclesApi.triggerPauseCallbacks();
-    } else if (name == "RESUME" /* RESUME */) {
-      this._mockLifecyclesApi.triggerResumeCallbacks();
-    } else if (name == "QUIT" /* QUIT */) {
-      this._mockLifecyclesApi.triggerQuitCallbacks();
-    } else if (name == "AWAKE" /* AWAKE */) {
-      this._mockLifecyclesApi.triggerAwakeCallbacks();
-    } else if (name == "SLEEP" /* SLEEP */) {
-      this._mockLifecyclesApi.triggerSleepCallbacks();
-    }
-  }
-  setOverlayElementVisibility(element, visible) {
-    const overlay = this._overlay;
-    const elements = overlay.elements;
-    if (elements[element]) {
-      elements[element].style.display = visible ? "flex" : "none";
-    }
-  }
-  setupAdOverlay() {
-    const adOverlay = document.createElement("div");
-    adOverlay.id = "venus-ad-overlay";
-    adOverlay.style.cssText = `
-        position: fixed;
-        top: 0;
-        left: 0;
-        width: 100%;
-        height: 100%;
-        background-color: rgba(37, 99, 235, 0.9);
-        color: white;
-        display: flex;
-        flex-direction: column;
-        align-items: center;
-        justify-content: center;
-        z-index: 10500;
-        font-family: sans-serif;
-        display: none;
-      `;
-    document.body.appendChild(adOverlay);
-    return adOverlay;
-  }
-  log(msg, ...args) {
-    console.log(`[Venus Mock] ${msg}`, ...args);
-  }
-  showActionSheetOverlay(items, options) {
-    this.log("Showing ActionSheetOverlay...");
-    return new Promise((resolve, reject) => {
-      const overlay = this._overlay;
-      overlay.actionSheetOverlay.innerHTML = "";
-      overlay.actionSheetOverlay.style.display = "flex";
-      const actionSheet = document.createElement("div");
-      actionSheet.className = "venus-action-sheet";
-      actionSheet.style.cssText = `
-        background-color: white;
-        border-radius: 8px;
-        width: 80%;
-        max-width: 400px;
-        max-height: 80%;
-        display: flex;
-        flex-direction: column;
-        overflow: hidden;
-        color: black;
-      `;
-      if (options?.title) {
-        const titleContainer = document.createElement("div");
-        titleContainer.style.cssText = `
-          padding: 16px;
-          border-bottom: 1px solid #eaeaea;
-          font-weight: bold;
-          font-size: 18px;
-          text-align: center;
-          color: black;
-        `;
-        titleContainer.innerText = options.title;
-        actionSheet.appendChild(titleContainer);
-      }
-      if (options?.message) {
-        const messageContainer = document.createElement("div");
-        messageContainer.style.cssText = `
-          padding: 8px 16px;
-          color: #666;
-          font-size: 14px;
-          text-align: center;
-        `;
-        messageContainer.innerText = options.message;
-        actionSheet.appendChild(messageContainer);
-      }
-      const optionsContainer = document.createElement("div");
-      optionsContainer.style.cssText = `
-        overflow-y: auto;
-        max-height: 300px;
-      `;
-      items.forEach((item, index) => {
-        const optionItem = document.createElement("div");
-        optionItem.style.cssText = `
-          padding: 12px 16px;
-          border-bottom: 1px solid #eaeaea;
-          cursor: pointer;
-          display: flex;
-          align-items: center;
-          transition: background-color 0.2s;
-          color: black;
-        `;
-        optionItem.addEventListener("mouseover", () => {
-          optionItem.style.backgroundColor = "#f5f5f5";
-        });
-        optionItem.addEventListener("mouseout", () => {
-          optionItem.style.backgroundColor = "white";
-        });
-        if (item.icon) {
-          const iconSpan = document.createElement("span");
-          iconSpan.style.cssText = `
-          margin-right: 12px;
-          font-size: 16px;
-        `;
-          iconSpan.innerText = item.icon;
-          optionItem.appendChild(iconSpan);
-        }
-        const labelSpan = document.createElement("span");
-        labelSpan.style.cssText = `
-        color: black;
-      `;
-        labelSpan.innerText = item.label;
-        optionItem.appendChild(labelSpan);
-        optionItem.addEventListener("click", () => {
-          this.hideActionSheetOverlay();
-          const optionId = item.id !== void 0 ? item.id : index;
-          resolve(optionId);
-        });
-        optionsContainer.appendChild(optionItem);
-      });
-      actionSheet.appendChild(optionsContainer);
-      if (!options?.disableCancel) {
-        const cancelButton = document.createElement("div");
-        cancelButton.style.cssText = `
-        padding: 14px 16px;
-        text-align: center;
-        font-weight: bold;
-        cursor: pointer;
-        color: #3b82f6;
-        border-top: 1px solid #eaeaea;
-      `;
-        cancelButton.innerText = options?.cancelButtonText || "Cancel";
-        cancelButton.addEventListener("click", () => {
-          this.hideActionSheetOverlay();
-          resolve(null);
-        });
-        actionSheet.appendChild(cancelButton);
-      }
-      if (!options?.disableCancel) {
-        const closeButton = document.createElement("div");
-        closeButton.style.cssText = `
-          position: absolute;
-          top: 8px;
-          right: 8px;
-          width: 24px;
-          height: 24px;
-          border-radius: 12px;
-          background-color: rgba(0,0,0,0.1);
-          color: #666;
-          display: flex;
-          align-items: center;
-          justify-content: center;
-          cursor: pointer;
-          font-size: 14px;
-        `;
-        closeButton.innerText = "\u2715";
-        closeButton.addEventListener("click", () => {
-          this.hideActionSheetOverlay();
-          resolve(null);
-        });
-        actionSheet.appendChild(closeButton);
-        overlay.actionSheetOverlay.appendChild(actionSheet);
-      }
-    });
-  }
-  hideActionSheetOverlay() {
-    const overlay = this._overlay;
-    if (overlay.actionSheetOverlay) {
-      overlay.actionSheetOverlay.style.display = "none";
-    }
-  }
-};
-
-// src/Host.ts
-function createHost(venusApi, isMock) {
-  if (isMock) {
-    return new MockHost(venusApi);
-  } else {
-    return new RemoteHost(venusApi);
-  }
-}
-
-// src/social/index.ts
-function initializeSocial(venusApi, host) {
-  venusApi.social = host.social;
-  venusApi.getLaunchParams = () => {
-    return venusApi.launchParams || {};
-  };
+  throw new Error(
+    `[Venus SDK] Cannot determine backend URL for target "${config.target}". Either provide backendUrl or configure Firebase project settings.`
+  );
 }
 
-export { DEFAULT_SHARED_LIB_CDN_BASE, EMBEDDED_LIBRARIES, EMBEDDED_LIBRARY_BY_KEY, HASH_ALGORITHM_NODE, HASH_ALGORITHM_WEB_CRYPTO, HapticFeedbackStyle, HostCdnApi, HostDeviceApi, HostEnvironmentApi, HostProfileApi, HostSystemApi, HostTimeApi, MODULE_TO_LIBRARY_SPECIFIERS, MockAdsApi, MockAiApi, MockAnalyticsApi, MockAvatarApi, MockCdnApi, MockDeviceApi, MockEnvironmentApi, MockFeaturesApi, MockHapticsApi, MockIapApi, MockLeaderboardApi, MockLifecycleApi, MockLoggingApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockPreloaderApi, MockProfileApi, MockSharedAssetsApi, MockSocialApi, MockStorageApi, MockSystemApi, MockTimeApi, ROOM_GAME_PHASES, RemoteHost, RpcAdsApi, RpcAiApi, RpcAnalyticsApi, RpcAvatarApi, RpcClient, RpcFeaturesApi, RpcHapticsApi, RpcIapApi, RpcLeaderboardApi, RpcLifecycleApi, RpcLoggingApi, RpcNavigationApi, RpcNotificationsApi, RpcPopupsApi, RpcPreloaderApi, RpcRoomsApi, RpcSharedAssetsApi, RpcSimulationApi, RpcSocialApi, RpcStorageApi, SDK_VERSION, VenusMessageId, VenusRoom, base64ToArrayBuffer, base64ToUtf8, computeScoreHash, createHost, createMockStorageApi, getLibraryDefinition, initializeAds, initializeAi, initializeAnalytics, initializeAvatar3d, initializeCdn, initializeFeaturesApi, initializeHaptics, initializeIap, initializeLeaderboard, initializeLifecycleApi, initializeLocalNotifications, initializeLoggingApi, initializePopups, initializePreloader, initializeProfile, initializeRoomsApi, initializeSimulation, initializeSocial, initializeStackNavigation, initializeStorage, initializeSystem, initializeTime, isPacificDaylightTime, setupRoomNotifications };
-//# sourceMappingURL=chunk-OKOJGDZJ.js.map
-//# sourceMappingURL=chunk-OKOJGDZJ.js.map
+export { DEFAULT_SHARED_LIB_CDN_BASE, EMBEDDED_LIBRARIES, EMBEDDED_LIBRARY_BY_KEY, HapticFeedbackStyle, HostCdnApi, HostDeviceApi, HostEnvironmentApi, HostProfileApi, HostSystemApi, HostTimeApi, MODULE_TO_LIBRARY_SPECIFIERS, MockAdsApi, MockAiApi, MockAnalyticsApi, MockAvatarApi, MockCdnApi, MockDeviceApi, MockEnvironmentApi, MockFeaturesApi, MockHapticsApi, MockIapApi, MockLifecycleApi, MockLoggingApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockPreloaderApi, MockProfileApi, MockSharedAssetsApi, MockSocialApi, MockStorageApi, MockSystemApi, MockTimeApi, ROOM_GAME_PHASES, RpcAdsApi, RpcAiApi, RpcAnalyticsApi, RpcAvatarApi, RpcFeaturesApi, RpcHapticsApi, RpcIapApi, RpcLifecycleApi, RpcLoggingApi, RpcNavigationApi, RpcNotificationsApi, RpcPopupsApi, RpcPreloaderApi, RpcRoomsApi, RpcSharedAssetsApi, RpcStorageApi, VenusMessageId, VenusRoom, base64ToArrayBuffer, base64ToUtf8, buildFunctionsBaseUrl, createMockStorageApi, getLibraryDefinition, getSandboxConfig, initializeAds, initializeAi, initializeAnalytics, initializeAvatar3d, initializeCdn, initializeFeaturesApi, initializeHaptics, initializeIap, initializeLifecycleApi, initializeLocalNotifications, initializeLoggingApi, initializePopups, initializePreloader, initializeProfile, initializeRoomsApi, initializeStackNavigation, initializeStorage, initializeSystem, initializeTime, isPacificDaylightTime, isSandboxEnabled, setupRoomNotifications };
+//# sourceMappingURL=chunk-Q7SNANYR.js.map
+//# sourceMappingURL=chunk-Q7SNANYR.js.map