@series-inc/venus-sdk 2.6.2 → 3.0.1

package/dist/venus-api/index.cjs

@@ -565,11 +565,11 @@ var RpcAdsApi = class {
     __publicField(this, "rpcClient");
     this.rpcClient = rpcClient;
   }
-  async showInterstitialAd() {
+  async showInterstitialAd(options) {
     console.log(`[Venus SDK] [RpcAdsApi] showInterstitialAd`);
     const response = await this.rpcClient.call(
       "H5_SHOW_INTERSTITIAL_AD" /* SHOW_INTERSTITIAL_AD */,
-      {},
+      options || {},
       -1
     );
     return response.shown;
@@ -581,11 +581,11 @@ var RpcAdsApi = class {
     );
     return response.ready;
   }
-  async showRewardedAdAsync() {
+  async showRewardedAdAsync(options) {
     console.log("[Venus SDK] [RpcAdsApi] showRewardedAdAsync");
     const result = await this.rpcClient.call(
       "H5_SHOW_REWARDED_AD" /* SHOW_REWARDED_AD */,
-      {},
+      options || {},
       -1
     );
     const resultAsString = JSON.stringify(result, null, 2);
@@ -609,15 +609,15 @@ var MockAdsApi = class {
     await createMockDelay(MOCK_DELAYS.short);
     return true;
   }
-  async showRewardedAdAsync() {
+  async showRewardedAdAsync(options) {
     this.log("[MockAdsApi] showRewardedAdAsync called");
-    await this.mockOverlay.showAdOverlay();
+    await this.mockOverlay.showAdOverlay(options);
     this.log("[MockAdsApi] Rewarded ad completed");
     return true;
   }
-  async showInterstitialAd() {
+  async showInterstitialAd(options) {
     this.log(`[MockAdsApi] showInterstitialAd`);
-    await this.mockOverlay.showAdOverlay();
+    await this.mockOverlay.showAdOverlay(options);
     this.log("[MockAdsApi] interstitial ad shown");
     return true;
   }
@@ -1009,22 +1009,23 @@ var MockNotificationsApi = class {
     const isEnabled = venusApi._mock.notificationsEnabled !== false;
     return isEnabled;
   }
-  async scheduleAsync(options) {
+  async scheduleAsync(title, body, seconds, notificationId, options) {
+    const { priority = 50, groupId, payload } = options || {};
     if (isWebPlatform()) {
       console.log(
         "[Venus Mock] Notifications not supported on web platform, simulating success"
       );
       console.info(
         "\u{1F514} [Venus Mock] Notification would be scheduled:",
-        options.title || "Untitled",
+        title || "Untitled",
         "\n   Body:",
-        options.body || "No body",
+        body || "No body",
         "\n   This is a simulation - real notifications require a native platform."
       );
       const mockId = `mock-web-notification-${Date.now()}`;
       return mockId;
     }
-    console.log("[Venus Mock] Schedule local notification:", options);
+    console.log("[Venus Mock] Schedule local notification:", { title, body, seconds, options });
     const venusApi = this.venusApi;
     if (!venusApi._mock.pendingRequests) {
       console.log("[Venus Mock] Initializing pendingRequests");
@@ -1034,19 +1035,19 @@ var MockNotificationsApi = class {
     console.log("[Venus Mock] Creating request with ID:", requestId);
     return new Promise((resolve) => {
       venusApi._mock.pendingRequests[requestId] = { resolve };
-      const notificationId = `mock-notification-${Date.now()}`;
+      const id = notificationId || `mock-notification-${Date.now()}`;
       if (!venusApi._mock.scheduledNotifications) {
         venusApi._mock.scheduledNotifications = {};
       }
-      venusApi._mock.scheduledNotifications[notificationId] = {
-        id: notificationId,
-        title: options.title,
-        body: options.body,
-        payload: options.payload,
-        trigger: options.trigger
+      venusApi._mock.scheduledNotifications[id] = {
+        id,
+        title,
+        body,
+        payload,
+        seconds
       };
       setTimeout(() => {
-        resolve(notificationId);
+        resolve(id);
       }, MOCK_DELAYS.short);
     });
   }
@@ -1072,14 +1073,16 @@ var RpcNotificationsApi = class {
     __publicField(this, "rpcClient");
     this.rpcClient = rpcClient;
   }
-  async scheduleAsync(options) {
+  async scheduleAsync(title, body, seconds, notificationId, options) {
+    const { priority = 50, groupId, payload } = options || {};
     const request = {
-      title: options.title,
-      body: options.body,
-      data: options.payload,
-      key: options.groupId,
-      priority: options.priority || 1,
-      trigger: options.trigger
+      title,
+      body,
+      priority,
+      key: groupId,
+      data: payload,
+      seconds,
+      notificationId
     };
     const response = await this.rpcClient.call(
       "H5_SCHEDULE_LOCAL_NOTIFICATION" /* SCHEDULE_LOCAL_NOTIFICATION */,
@@ -3973,6 +3976,238 @@ function initializeIap(venusApiInstance, host) {
   venusApiInstance.iap = host.iap;
 }
 
+// src/leaderboard/RpcLeaderboardApi.ts
+var RpcLeaderboardApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  startRun(mode) {
+    return this.rpcClient.call(
+      "H5_LEADERBOARD_START_RUN" /* H5_LEADERBOARD_START_RUN */,
+      mode ? { mode } : {}
+    );
+  }
+  submitScore(sessionId, score, durationSec, options) {
+    return this.rpcClient.call(
+      "H5_LEADERBOARD_SUBMIT_SCORE" /* H5_LEADERBOARD_SUBMIT_SCORE */,
+      {
+        sessionId,
+        score,
+        durationSec,
+        mode: options?.mode,
+        telemetry: options?.telemetry,
+        metadata: options?.metadata,
+        hash: options?.hash
+      }
+    );
+  }
+  getLeaderboard(options) {
+    return this.rpcClient.call(
+      "H5_LEADERBOARD_GET" /* H5_LEADERBOARD_GET */,
+      options ?? {}
+    );
+  }
+  getPlayerStats(options) {
+    return this.rpcClient.call(
+      "H5_LEADERBOARD_GET_PLAYER_STATS" /* H5_LEADERBOARD_GET_PLAYER_STATS */,
+      options ?? {}
+    );
+  }
+  getLeaderboardHighlight(options) {
+    return this.rpcClient.call(
+      "H5_LEADERBOARD_GET_HIGHLIGHT" /* H5_LEADERBOARD_GET_HIGHLIGHT */,
+      options ?? {}
+    );
+  }
+};
+
+// src/leaderboard/MockLeaderboardApi.ts
+var MockLeaderboardApi = class {
+  constructor(options) {
+    __publicField(this, "sessions", /* @__PURE__ */ new Map());
+    __publicField(this, "entriesByMode", /* @__PURE__ */ new Map());
+    __publicField(this, "sessionCounter", 0);
+    __publicField(this, "requiresHash", false);
+    if (options?.requiresHash) {
+      this.requiresHash = true;
+    }
+  }
+  configure(options) {
+    if (typeof options.requiresHash === "boolean") {
+      this.requiresHash = options.requiresHash;
+    }
+  }
+  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);
+  }
+  async startRun(mode) {
+    const sessionId = `mock_session_${++this.sessionCounter}`;
+    const startTime = Date.now();
+    const expiresAt = startTime + 36e5;
+    const resolvedMode = mode || "default";
+    const hashNonce = this.requiresHash ? this.generateNonce() : null;
+    this.sessions.set(sessionId, {
+      id: sessionId,
+      expiresAt,
+      mode: resolvedMode,
+      hashNonce,
+      used: false
+    });
+    return {
+      sessionId,
+      startTime,
+      expiresAt,
+      hashNonce,
+      mode: resolvedMode
+    };
+  }
+  async submitScore(sessionId, score, durationSec, options) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error("Invalid leaderboard session");
+    }
+    if (session.expiresAt < Date.now()) {
+      throw new Error("Invalid or expired leaderboard session");
+    }
+    if (session.used) {
+      throw new Error("Leaderboard session already used");
+    }
+    if (options?.mode && options.mode !== session.mode) {
+      throw new Error("Submission mode does not match session mode");
+    }
+    if (session.hashNonce && !options?.hash) {
+      throw new Error("Score hash is required for sealed leaderboard submissions");
+    }
+    const submittedAt = Date.now();
+    const entry = {
+      profileId: `mock_profile`,
+      username: "Mock Player",
+      avatarUrl: null,
+      score,
+      durationSec,
+      submittedAt,
+      sessionId,
+      rank: null,
+      zScore: null,
+      isAnomaly: false,
+      trustScore: 50,
+      metadata: options?.metadata ?? null,
+      isSeed: false
+    };
+    const modeEntries = this.getEntriesForMode(session.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
+      };
+    });
+    session.used = true;
+    session.hashNonce = null;
+    const inserted = modeEntries.find((e) => e.sessionId === sessionId && e.submittedAt === submittedAt);
+    return {
+      accepted: true,
+      rank: inserted?.rank ?? null
+    };
+  }
+  async getLeaderboard(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 getPlayerStats(_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 getLeaderboardHighlight(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/profile/HostProfileApi.ts
 var HostProfileApi = class {
   getCurrentProfile() {
@@ -4265,14 +4500,6 @@ var MockPostApi = class {
       commentsCount: 0
     };
   }
-  async sharePostAsync(context) {
-    console.log("[Venus Mock] Sharing post with additionalInfo:", context);
-    await createMockDelay(MOCK_DELAYS.short);
-    return {
-      shared: true,
-      platform: "mock"
-    };
-  }
   async toggleFollowAsync() {
     const venusApi = this.venusApi;
     console.log("[Venus Mock] *Toggling follow status");
@@ -4317,11 +4544,6 @@ var RpcPostApi = class {
   openCommentsAsync() {
     return this.rpcClient.call("H5_OPEN_COMMENTS" /* OPEN_COMMENTS */, {});
   }
-  sharePostAsync(context) {
-    return this.rpcClient.call("H5_SHARE_POST" /* SHARE_POST */, {
-      shareContext: context
-    });
-  }
   toggleFollowAsync() {
     return this.rpcClient.call(
       "H5_TOGGLE_FOLLOW" /* TOGGLE_FOLLOW */,
@@ -4344,9 +4566,6 @@ function initializePost(venusApi, host) {
   venusApi.toggleLikeAsync = () => {
     return host.post.toggleLikeAsync();
   };
-  venusApi.sharePostAsync = async (options) => {
-    await host.post.sharePostAsync(options);
-  };
   venusApi.openCommentsAsync = async () => {
     await host.post.openCommentsAsync();
   };
@@ -4441,59 +4660,73 @@ function initializeFeaturesApi(venusApi, host) {
 // src/lifecycles/MockLifecycleApi.ts
 var MockLifecycleApi = class {
   constructor() {
-    __publicField(this, "playCallbacks", []);
-    __publicField(this, "pauseCallbacks", []);
-    __publicField(this, "resumeCallbacks", []);
-    __publicField(this, "quitCallbacks", []);
-    __publicField(this, "showCallbacks", []);
-    __publicField(this, "hideCallbacks", []);
-  }
-  onCleanup(callback) {
-  }
-  onShow(callback) {
-    this.showCallbacks.push(callback);
+    __publicField(this, "pauseCallbacks", /* @__PURE__ */ new Set());
+    __publicField(this, "resumeCallbacks", /* @__PURE__ */ new Set());
+    __publicField(this, "awakeCallbacks", /* @__PURE__ */ new Set());
+    __publicField(this, "sleepCallbacks", /* @__PURE__ */ new Set());
+    __publicField(this, "quitCallbacks", /* @__PURE__ */ new Set());
+  }
+  onSleep(callback) {
+    this.sleepCallbacks.add(callback);
+    return {
+      unsubscribe: () => {
+        this.sleepCallbacks.delete(callback);
+      }
+    };
   }
-  onHide(callback) {
-    this.hideCallbacks.push(callback);
+  onAwake(callback) {
+    this.awakeCallbacks.add(callback);
+    return {
+      unsubscribe: () => {
+        this.awakeCallbacks.delete(callback);
+      }
+    };
   }
   onPause(callback) {
-    this.pauseCallbacks.push(callback);
-  }
-  onPlay(callback) {
-    this.playCallbacks.push(callback);
-  }
-  onQuit(callback) {
-    this.quitCallbacks.push(callback);
+    this.pauseCallbacks.add(callback);
+    return {
+      unsubscribe: () => {
+        this.pauseCallbacks.delete(callback);
+      }
+    };
   }
   onResume(callback) {
-    this.resumeCallbacks.push(callback);
+    this.resumeCallbacks.add(callback);
+    return {
+      unsubscribe: () => {
+        this.resumeCallbacks.delete(callback);
+      }
+    };
   }
-  triggerOnPlayCallbacks(context) {
-    for (const callback of this.playCallbacks) {
-      callback(context);
-    }
+  onQuit(callback) {
+    this.quitCallbacks.add(callback);
+    return {
+      unsubscribe: () => {
+        this.quitCallbacks.delete(callback);
+      }
+    };
   }
-  triggerOnPauseCallbacks() {
+  triggerPauseCallbacks() {
     for (const callback of this.pauseCallbacks) {
       callback();
     }
   }
-  triggerOnResumeCallbacks() {
+  triggerResumeCallbacks() {
     for (const callback of this.resumeCallbacks) {
       callback();
     }
   }
-  triggerOnShowCallbacks(context) {
-    for (const callback of this.showCallbacks) {
-      callback(context);
+  triggerAwakeCallbacks() {
+    for (const callback of this.awakeCallbacks) {
+      callback();
     }
   }
-  triggerOnHideCallbacks() {
-    for (const callback of this.hideCallbacks) {
+  triggerSleepCallbacks() {
+    for (const callback of this.sleepCallbacks) {
       callback();
     }
   }
-  triggerOnQuitCallbacks() {
+  triggerQuitCallbacks() {
     for (const callback of this.quitCallbacks) {
       callback();
     }
@@ -4506,52 +4739,26 @@ var RpcLifecycleApi = class {
     __publicField(this, "rpcClient");
     this.rpcClient = rpcClient;
   }
-  onCleanup(callback) {
-    this.rpcClient.onNotification("CLEANUP" /* CLEANUP */, callback);
-  }
-  onHide(callback) {
-    this.rpcClient.onNotification("HIDDEN" /* HIDDEN */, callback);
-  }
-  onPause(callback) {
-    this.rpcClient.onNotification("PAUSE" /* PAUSE */, callback);
+  onQuit(callback) {
+    return this.rpcClient.onNotification("QUIT" /* QUIT */, callback);
   }
-  onPlay(callback) {
-    this.rpcClient.onNotification("PLAY" /* PLAY */, callback);
+  onSleep(callback) {
+    return this.rpcClient.onNotification("SLEEP" /* SLEEP */, callback);
   }
-  onQuit(callback) {
-    this.rpcClient.onNotification("QUIT" /* QUIT */, callback);
+  onAwake(callback) {
+    return this.rpcClient.onNotification("AWAKE" /* AWAKE */, callback);
   }
   onResume(callback) {
-    this.rpcClient.onNotification("RESUME" /* RESUME */, callback);
+    return this.rpcClient.onNotification("RESUME" /* RESUME */, callback);
   }
-  onShow(callback) {
-    this.rpcClient.onNotification("SHOWN" /* SHOWN */, callback);
+  onPause(callback) {
+    return this.rpcClient.onNotification("PAUSE" /* PAUSE */, callback);
   }
 };
 
 // src/lifecycles/index.ts
 function initializeLifecycleApi(venusApi, host) {
-  venusApi.onPlay = (callback) => {
-    host.lifecycle.onPlay(callback);
-  };
-  venusApi.onPause = (callback) => {
-    host.lifecycle.onPause(callback);
-  };
-  venusApi.onResume = (callback) => {
-    host.lifecycle.onResume(callback);
-  };
-  venusApi.onShow = (callback) => {
-    host.lifecycle.onShow(callback);
-  };
-  venusApi.onHide = (callback) => {
-    host.lifecycle.onHide(callback);
-  };
-  venusApi.onQuit = (callback) => {
-    host.lifecycle.onQuit(callback);
-  };
-  venusApi.onCleanup = (callback) => {
-    host.lifecycle.onCleanup(callback);
-  };
+  venusApi.lifecycles = host.lifecycle;
 }
 
 // src/simulation/utils.ts
@@ -5604,6 +5811,37 @@ function initializePreloader(venusApi, host) {
   venusApi.preloader = host.preloader;
 }
 
+// src/social/MockSocialApi.ts
+var MOCK_QR_CODE = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+var MockSocialApi = class {
+  async shareLinkAsync(options) {
+    const shareUrl = this.createMockUrl(options.launchParams);
+    if (typeof navigator !== "undefined" && navigator.clipboard) {
+      try {
+        await navigator.clipboard.writeText(shareUrl);
+        console.log("[Venus SDK] (mock) Copied share URL to clipboard");
+      } catch (error) {
+        console.warn(
+          "[Venus SDK] (mock) Failed to copy share URL to clipboard",
+          error
+        );
+      }
+    }
+    return { shareUrl };
+  }
+  async createQRCodeAsync(options) {
+    const shareUrl = this.createMockUrl(options.launchParams);
+    return {
+      shareUrl,
+      qrCode: MOCK_QR_CODE
+    };
+  }
+  createMockUrl(launchParams) {
+    const params = new URLSearchParams(launchParams);
+    return `https://mock-share.venus.test/share?${params.toString()}`;
+  }
+};
+
 // src/MockHost.ts
 var ROOMS_UNAVAILABLE_MESSAGE = "[Venus SDK] Rooms API is only available when running inside the Venus host environment.";
 function createUnavailableRoomsApi() {
@@ -5670,7 +5908,9 @@ var MockHost = class {
     __publicField(this, "rooms");
     __publicField(this, "logging");
     __publicField(this, "iap");
+    __publicField(this, "leaderboard");
     __publicField(this, "preloader");
+    __publicField(this, "social");
     __publicField(this, "state", 0 /* PLAYING */);
     __publicField(this, "venusApi");
     __publicField(this, "_isInitialized", false);
@@ -5703,6 +5943,8 @@ var MockHost = class {
     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;
@@ -5711,8 +5953,11 @@ var MockHost = class {
   get isInitialized() {
     return this._isInitialized;
   }
-  async initialize(options = {}) {
+  initialize(options) {
     this._isInitialized = true;
+    return Promise.resolve({
+      initializeAsleep: false
+    });
   }
   updateUiControls() {
     const controls = {
@@ -5783,27 +6028,87 @@ var MockHost = class {
     };
   }
   async handleMenuButtonClicked() {
-    this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
-    const sleepAwakeToggleAction = {
+    if (this.state === 0 /* PLAYING */) {
+      this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
+      this.state = 1 /* PAUSED */;
+    }
+    const actionSheetItems = [];
+    const awakeAction = {
       label: "\u23F0 Awake",
-      id: "sleepAwakeToggle"
+      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 */) {
-      sleepAwakeToggleAction.label = "\u{1F4A4} Sleep";
-    }
-    const action = await this.showActionSheetOverlay([sleepAwakeToggleAction]);
-    if (action === sleepAwakeToggleAction.id) {
-      if (this.state === 1 /* PAUSED */) {
-        this.state = 2 /* SLEEPING */;
-        this.triggerLifecycleEvent("HIDDEN" /* HIDDEN */);
-      } else {
-        this.state = 1 /* PAUSED */;
-        this.triggerLifecycleEvent("SHOWN" /* SHOWN */);
-      }
+      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 {
-      if (this.state === 1 /* PAUSED */) {
-        this.triggerLifecycleEvent("RESUME" /* RESUME */);
-      }
+      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 */);
     }
   }
   async showAdOverlay(type) {
@@ -5934,28 +6239,16 @@ var MockHost = class {
   }
   triggerLifecycleEvent(name) {
     console.log("Trigger Lifecycle Event: ", name);
-    if (name == "PLAY" /* PLAY */) {
-      this._mockLifecyclesApi.triggerOnPlayCallbacks({
-        hudInsets: { top: 60, right: 0, bottom: 0, left: 0 },
-        // shareData: {
-        //   title: 'Mock Share Title',
-        //   description: 'Mock share description for testing',
-        // },
-        format: "post"
-        // stackData: null,
-      });
-    } else if (name == "PAUSE" /* PAUSE */) {
-      this._mockLifecyclesApi.triggerOnPauseCallbacks();
+    if (name == "PAUSE" /* PAUSE */) {
+      this._mockLifecyclesApi.triggerPauseCallbacks();
     } else if (name == "RESUME" /* RESUME */) {
-      this._mockLifecyclesApi.triggerOnResumeCallbacks();
+      this._mockLifecyclesApi.triggerResumeCallbacks();
     } else if (name == "QUIT" /* QUIT */) {
-      this._mockLifecyclesApi.triggerOnQuitCallbacks();
-    } else if (name == "SHOWN" /* SHOWN */) {
-      this._mockLifecyclesApi.triggerOnShowCallbacks({
-        hudInsets: { top: 60, bottom: 120, left: 0, right: 0 }
-      });
-    } else if (name == "HIDDEN" /* HIDDEN */) {
-      this._mockLifecyclesApi.triggerOnHideCallbacks();
+      this._mockLifecyclesApi.triggerQuitCallbacks();
+    } else if (name == "AWAKE" /* AWAKE */) {
+      this._mockLifecyclesApi.triggerAwakeCallbacks();
+    } else if (name == "SLEEP" /* SLEEP */) {
+      this._mockLifecyclesApi.triggerSleepCallbacks();
     }
   }
   setOverlayElementVisibility(element, visible) {
@@ -6258,7 +6551,7 @@ var VenusTransport = class {
         return;
       }
       this.notifyVenusMessageReceived(message);
-      if (message.type === "PLAY" /* PLAY */ || message.type === "PAUSE" /* PAUSE */ || message.type === "RESUME" /* RESUME */ || message.type === "SHOWN" /* SHOWN */ || message.type === "HIDDEN" /* HIDDEN */ || message.type === "CLEANUP" /* CLEANUP */ || message.type === "QUIT" /* QUIT */) {
+      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,
@@ -6728,6 +7021,36 @@ var RpcRoomsApi = 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/RemoteHost.ts
 var getCdnBaseUrl = () => {
   return "https://venus-static-01293ak.web.app/";
@@ -6755,7 +7078,9 @@ var RemoteHost = class {
     __publicField(this, "rooms");
     __publicField(this, "logging");
     __publicField(this, "iap");
+    __publicField(this, "leaderboard");
     __publicField(this, "preloader");
+    __publicField(this, "social");
     __publicField(this, "venusApi");
     __publicField(this, "rpcClient");
     __publicField(this, "_isInitialized", false);
@@ -6810,7 +7135,9 @@ var RemoteHost = class {
     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);
@@ -6819,72 +7146,20 @@ var RemoteHost = class {
   get isInitialized() {
     return this._isInitialized;
   }
-  async initialize(options = {}) {
+  async initialize(options) {
     this.log("Initializing Remote Host...");
     const transport = new VenusTransport();
     transport.start();
     this.rpcClient.start(transport);
     const roomsApi = this.rooms;
     roomsApi.setupNotifications(transport);
-    try {
-      this.log("Trying to initialize using NEW method...");
-      transport.instanceId = await this.initNew();
-    } catch (error) {
-      this.log(`Failed to initialize using NEW method: ${error}`);
-      this.log(`Trying to initialize using OLD method...`);
-      transport.instanceId = await this.initOld(transport);
-    }
-    this.log(`Remote Host Initialized with id: ${transport.instanceId}`);
-    this._isInitialized = true;
-    this.venusApi._bootstrap.apiInjected = true;
-    this.venusApi._bootstrap.venus = window.venus;
-    await this.rpcClient.call("READY" /* READY */, {});
-  }
-  registerIFrame(transport) {
-    return new Promise((resolve, reject) => {
-      this.log("Registering IFrame...");
-      const location = window.location;
-      const pathName = location.pathname;
-      const tokens = pathName.split("/");
-      const appId = tokens[2];
-      console.log("[Venus SDK] App ID ", appId);
-      const registrationMessage = {
-        type: "H5_IFRAME_REGISTER",
-        instanceId: appId,
-        direction: "H5_TO_APP",
-        timestamp: Date.now()
-      };
-      const subscription = transport.onVenusMessage((message) => {
-        if (message.type == "INJECT_VENUS_API_SCRIPT") {
-          const scriptContent = message.data?.script;
-          if (!scriptContent) {
-            throw new Error("Failed to inject venus api, no script found.");
-          }
-          const script = document.createElement("script");
-          script.type = "text/javascript";
-          script.textContent = scriptContent;
-          document.head.appendChild(script);
-          setTimeout(() => {
-            if (window.venus) {
-              subscription.unsubscribe();
-              resolve(window.venus?._config?.instanceId);
-            }
-          }, 100);
-        }
-      });
-      transport.sendVenusMessage(registrationMessage);
-      setTimeout(() => {
-        subscription.unsubscribe();
-        reject();
-      }, 1e3);
-    });
-  }
-  async initNew() {
     const response = await this.rpcClient.call(
       "INITIALIZE_SDK" /* INIT_SDK */,
       {},
-      1e3
+      5e3
     );
+    transport.instanceId = response.instanceId;
+    this.log(`Remote Host Initialized with id: ${transport.instanceId}`);
     if (response.profile) {
       const profile = response.profile;
       const sanitizedProfile = {
@@ -6905,26 +7180,17 @@ var RemoteHost = class {
         }
       }
     }
-    return response.instanceId;
-  }
-  async initOld(transport) {
-    const isInIframe = window.self !== window.top;
-    const hasReactNativeWebView = typeof window.ReactNativeWebView !== "undefined";
-    if (hasReactNativeWebView) {
-      return this.useInjectedId();
-    } else if (isInIframe) {
-      return await this.registerIFrame(transport);
-    } else {
-      throw new Error("Failed to initialize. Unknown Error");
-    }
-  }
-  useInjectedId() {
-    const instanceId = window.venus?._config?.instanceId || window._venusInitState?.poolId;
-    this.log(`On mobile, using injected instanceId: ${instanceId}`);
-    if (!instanceId) {
-      throw new Error("Expected injected instanceId on mobile");
+    this._isInitialized = true;
+    this.venusApi.launchParams = response.launchParams || {};
+    await this.rpcClient.call("READY" /* READY */, {});
+    const hudInsets = response.hudInsets;
+    if (hudInsets) {
+      this.venusApi.config.ui.safeArea = hudInsets;
     }
-    return instanceId;
+    return {
+      hudInsets,
+      initializeAsleep: response.initializeAsleep
+    };
   }
   log(message) {
     console.log(`[Venus SDK] [Remote Host] ${message}`);
@@ -6946,7 +7212,15 @@ function createHost(venusApi, isMock) {
 init_rooms();
 
 // src/version.ts
-var SDK_VERSION = "2.6.2";
+var SDK_VERSION = "3.0.1";
+
+// src/social/index.ts
+function initializeSocial(venusApi, host) {
+  venusApi.social = host.social;
+  venusApi.getLaunchParams = () => {
+    return venusApi.launchParams || {};
+  };
+}
 
 // src/venus-api/index.js
 var HapticStyle = {
@@ -7130,6 +7404,7 @@ var VenusAPI2 = class {
       }
     };
     this._detectHostedEnvironment();
+    this.launchParams = {};
     this.config = createProxiedObject.call(this, "config", {
       locale: "en-US",
       languageCode: "en",
@@ -7253,6 +7528,7 @@ var VenusAPI2 = class {
     initializePopups(this, host);
     initializeAnalytics(this, host);
     initializeIap(this, host);
+    initializeLeaderboard(this, host);
     initializeLocalNotifications(this, host);
     initializePreloader(this, host);
     initializeTime(this, host);
@@ -7270,6 +7546,7 @@ var VenusAPI2 = class {
     initializePost(this, host);
     initializeAi(this, host);
     initializeSimulation(this, host);
+    initializeSocial(this, host);
     initializeAssetLoader(this, createProxiedMethod);
   }
   // Generate deterministic instance ID based on current page URL
@@ -7332,95 +7609,23 @@ var VenusAPI2 = class {
   //---------------------------------------
   // PUBLIC API METHODS
   //---------------------------------------
-  async initializeAsync(options = {}) {
+  async initializeAsync(options) {
     if (this._shared.initialized) {
       return Promise.resolve(true);
     }
     if (this._shared.initPromise) {
       return this._shared.initPromise;
     }
-    this._shared.initPromise = new Promise(async (resolve) => {
+    this._shared.initPromise = new Promise(async (resolve, reject) => {
       try {
-        if (options) {
-          const supportedRootParams = [
-            "hardDisableMock",
-            "mock",
-            "helpText",
-            "forceRemoteCdn",
-            "usePreloader"
-          ];
-          const supportedMockParams = [
-            "initDelay",
-            "isMobile",
-            "isWeb",
-            "locale",
-            "rooms",
-            "craftingConfig",
-            "onShowContext",
-            "onHideContext"
-          ];
-          Object.keys(options).forEach((param) => {
-            if (!supportedRootParams.includes(param)) {
-              this.log(`Unsupported parameter: ${param}`);
-            }
-          });
-          if (options.mockData && typeof options.mockData === "object") {
-            console.warn(
-              "[Venus Mock] mockData is deprecated, use options.mock instead"
-            );
-            options.mock = { ...options.mock, ...options.mockData };
-          }
-          if (options.mock && typeof options.mock === "object") {
-            Object.keys(options.mock).forEach((param) => {
-              if (!supportedMockParams.includes(param)) {
-                this.log(`Unsupported mock parameter: ${param}`);
-              }
-            });
-          }
-          if (options.helpText && typeof options.helpText === "string") {
-            this._mock.helpText = options.helpText;
-          }
-          if (typeof options.forceRemoteCdn === "boolean") {
-            this._mock.forceRemoteCdn = options.forceRemoteCdn;
-            console.log(
-              "[Venus Mock] Force remote CDN mode:",
-              options.forceRemoteCdn
-            );
-          }
-        }
-        await this.host.initialize(options);
-        if (!options.usePreloader) {
-          await this.host.preloader.hideLoadScreen();
+        const result = await this.host.initialize(options);
+        this._shared.initialized = true;
+        if (!options || !options.usePreloader) {
+          this.host.preloader.hideLoadScreen();
         }
-        if (this._bootstrap.isInsideHostedEnvironment) {
-          this._shared.initialized = true;
-          resolve(true);
-          return;
-        }
-        const mockDelay = options.mock?.initDelay ?? 100;
-        this.log(`Using mock initialization delay: ${mockDelay}ms`);
-        setTimeout(async () => {
-          this._shared.initialized = true;
-          this._initializeMockMode();
-          resolve(true);
-        }, mockDelay);
+        resolve(result);
       } catch (err) {
-        console.warn(
-          "[Venus Bootstrap] Initialization error, falling back to mock mode",
-          err
-        );
-        if (options.hardDisableMock) {
-          console.warn(
-            "[Venus Bootstrap] hardDisableMock is true, not using mock."
-          );
-          resolve(false);
-          return;
-        }
-        this._initializeMockMode();
-        setTimeout(async () => {
-          this._shared.initialized = true;
-          resolve(true);
-        }, 100);
+        reject(err);
       }
     });
     return this._shared.initPromise;