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

package/dist/chunk-DJ3WT3FA.js

@@ -0,0 +1,1890 @@
+import { RpcAdsApi, RpcAnalyticsApi, RpcStorageApi, RpcAvatarApi, RpcNavigationApi, RpcNotificationsApi, RpcPopupsApi, HostProfileApi, HostDeviceApi, HostEnvironmentApi, HostSystemApi, HostCdnApi, HostTimeApi, RpcAiApi, RpcHapticsApi, RpcFeaturesApi, RpcLifecycleApi, RpcRoomsApi, RpcLoggingApi, RpcIapApi, RpcPreloaderApi, RpcSharedAssetsApi, initializeRoomsApi, isSandboxEnabled, MockAdsApi, MockLifecycleApi, MockAnalyticsApi, createMockStorageApi, MockAvatarApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockProfileApi, MockDeviceApi, MockEnvironmentApi, MockSystemApi, MockCdnApi, MockTimeApi, MockAiApi, MockHapticsApi, MockFeaturesApi, MockLoggingApi, MockIapApi, MockSocialApi, MockPreloaderApi, MockSharedAssetsApi } from './chunk-Q7SNANYR.js';
+
+// 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/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
+    );
+  };
+  venusApi.simulation.subscribeAsync = (options) => {
+    return host.simulation.subscribeAsync(options);
+  };
+}
+
+// src/version.ts
+var SDK_VERSION = "3.4.3-beta.0";
+
+// 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/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;
+  }
+  log(message) {
+    console.log(`[Venus SDK] [Remote Host] ${message}`);
+  }
+};
+
+// 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 kickPlayerAsync() {
+      throw roomsUnavailableError();
+    },
+    async startRoomGameAsync() {
+      throw roomsUnavailableError();
+    },
+    async proposeMoveAsync() {
+      throw roomsUnavailableError();
+    },
+    async validateMoveAsync() {
+      throw roomsUnavailableError();
+    }
+  };
+}
+var SIMULATION_UNAVAILABLE_MESSAGE = "[Venus SDK] Simulation API is only available when running inside the Venus host environment.";
+function createUnavailableSimulationApi() {
+  const simulationUnavailableError = () => new Error(SIMULATION_UNAVAILABLE_MESSAGE);
+  return {
+    isEnabled() {
+      return false;
+    },
+    async getStateAsync() {
+      throw simulationUnavailableError();
+    },
+    async getConfigAsync() {
+      throw simulationUnavailableError();
+    },
+    async executeRecipeAsync() {
+      throw simulationUnavailableError();
+    },
+    async getActiveRunsAsync() {
+      throw simulationUnavailableError();
+    },
+    async collectRecipeAsync() {
+      throw simulationUnavailableError();
+    },
+    async executeScopedRecipeAsync() {
+      throw simulationUnavailableError();
+    },
+    async triggerRecipeChainAsync() {
+      throw simulationUnavailableError();
+    },
+    async getAvailableRecipesAsync() {
+      throw simulationUnavailableError();
+    },
+    async getRecipeRequirementsAsync() {
+      throw simulationUnavailableError();
+    },
+    async getBatchRecipeRequirementsAsync() {
+      throw simulationUnavailableError();
+    },
+    async resolveFieldValueAsync() {
+      throw simulationUnavailableError();
+    },
+    async getEntityMetadataAsync() {
+      throw simulationUnavailableError();
+    },
+    async getSlotContainersAsync() {
+      throw simulationUnavailableError();
+    },
+    async getSlotAssignmentsAsync() {
+      throw simulationUnavailableError();
+    },
+    async assignItemToSlotAsync() {
+      throw simulationUnavailableError();
+    },
+    async removeItemFromSlotAsync() {
+      throw simulationUnavailableError();
+    },
+    async getAvailableItemsAsync() {
+      throw simulationUnavailableError();
+    },
+    async calculatePowerPreviewAsync() {
+      throw simulationUnavailableError();
+    },
+    async validateSlotAssignmentAsync() {
+      throw simulationUnavailableError();
+    },
+    async executeBatchOperationsAsync() {
+      throw simulationUnavailableError();
+    },
+    async subscribeAsync() {
+      throw simulationUnavailableError();
+    }
+  };
+}
+var MockHost = class {
+  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.simulation = createUnavailableSimulationApi();
+    this.rooms = createUnavailableRoomsApi();
+    this.leaderboard = new MockLeaderboardApi();
+    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.logging = new MockLoggingApi();
+    this.iap = new MockIapApi();
+    this.social = new MockSocialApi();
+    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();
+    }
+  }
+  tryAwake() {
+    if (this.state === 2 /* SLEEPING */) {
+      this.triggerLifecycleEvent("AWAKE" /* AWAKE */);
+      this.state = 1 /* PAUSED */;
+    }
+  }
+  trySleep() {
+    if (this.state === 1 /* PAUSED */) {
+      this.triggerLifecycleEvent("SLEEP" /* SLEEP */);
+      this.state = 2 /* SLEEPING */;
+    }
+  }
+  tryPlay() {
+    if (this.state === 3 /* TERMINATED */) {
+      this.triggerLifecycleEvent("AWAKE" /* AWAKE */);
+      this.state = 1 /* PAUSED */;
+      this.triggerLifecycleEvent("RESUME" /* RESUME */);
+      this.state = 0 /* PLAYING */;
+    }
+  }
+  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
+async function createHost(venusApi, isMock) {
+  if (isMock) {
+    if (import.meta.env?.DEV && isSandboxEnabled()) {
+      const { SandboxHost } = await import('./SandboxHost-JNX5UBGL.js');
+      return new SandboxHost(venusApi);
+    }
+    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 || {};
+  };
+}
+
+export { HASH_ALGORITHM_NODE, HASH_ALGORITHM_WEB_CRYPTO, MockLeaderboardApi, RemoteHost, RpcClient, RpcLeaderboardApi, RpcSimulationApi, RpcSocialApi, SDK_VERSION, computeScoreHash, createHost, initializeLeaderboard, initializeSimulation, initializeSocial };
+//# sourceMappingURL=chunk-DJ3WT3FA.js.map
+//# sourceMappingURL=chunk-DJ3WT3FA.js.map