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

package/dist/index.cjs

@@ -329,11 +329,11 @@ var VenusMessageId = /* @__PURE__ */ ((VenusMessageId2) => {
   VenusMessageId2["H5_SIMULATION_GET_AVAILABLE_ITEMS"] = "H5_SIMULATION_GET_AVAILABLE_ITEMS";
   VenusMessageId2["H5_SIMULATION_VALIDATE_ASSIGNMENT"] = "H5_SIMULATION_VALIDATE_ASSIGNMENT";
   VenusMessageId2["H5_SIMULATION_BATCH_OPERATIONS"] = "H5_SIMULATION_BATCH_OPERATIONS";
-  VenusMessageId2["H5_LEADERBOARD_START_RUN"] = "H5_LEADERBOARD_START_RUN";
+  VenusMessageId2["H5_LEADERBOARD_CREATE_SCORE_TOKEN"] = "H5_LEADERBOARD_CREATE_SCORE_TOKEN";
   VenusMessageId2["H5_LEADERBOARD_SUBMIT_SCORE"] = "H5_LEADERBOARD_SUBMIT_SCORE";
-  VenusMessageId2["H5_LEADERBOARD_GET"] = "H5_LEADERBOARD_GET";
-  VenusMessageId2["H5_LEADERBOARD_GET_HIGHLIGHT"] = "H5_LEADERBOARD_GET_HIGHLIGHT";
-  VenusMessageId2["H5_LEADERBOARD_GET_PLAYER_STATS"] = "H5_LEADERBOARD_GET_PLAYER_STATS";
+  VenusMessageId2["H5_LEADERBOARD_GET_PAGED_SCORES"] = "H5_LEADERBOARD_GET_PAGED_SCORES";
+  VenusMessageId2["H5_LEADERBOARD_GET_PODIUM_SCORES"] = "H5_LEADERBOARD_GET_PODIUM_SCORES";
+  VenusMessageId2["H5_LEADERBOARD_GET_MY_RANK"] = "H5_LEADERBOARD_GET_MY_RANK";
   VenusMessageId2["H5_ROOM_CREATE"] = "H5_ROOM_CREATE";
   VenusMessageId2["H5_ROOM_JOIN"] = "H5_ROOM_JOIN";
   VenusMessageId2["H5_ROOM_JOIN_OR_CREATE"] = "H5_ROOM_JOIN_OR_CREATE";
@@ -3364,9 +3364,11 @@ function isPacificDaylightTime(date) {
 
 // src/time/HostTimeApi.ts
 var HostTimeApi = class {
-  constructor(rpcClient) {
+  constructor(rpcClient, venusApi) {
     __publicField(this, "rpcClient");
+    __publicField(this, "venusApi");
     this.rpcClient = rpcClient;
+    this.venusApi = venusApi;
   }
   async requestTimeAsync() {
     const response = await this.rpcClient.call(
@@ -3376,13 +3378,7 @@ var HostTimeApi = class {
     return response;
   }
   formatTime(timestamp, options) {
-    let locale = "en-US";
-    const windowVenus = window.venus;
-    if (windowVenus._config.locale) {
-      locale = windowVenus._config.locale;
-    } else if (windowVenus._config.environment && windowVenus._config.environment.browserInfo && windowVenus._config.environment.browserInfo.language) {
-      locale = windowVenus._config.environment.browserInfo.language;
-    }
+    const locale = this.venusApi.getLocale();
     const date = new Date(timestamp);
     const dateTimeOptions = {
       dateStyle: options.dateStyle || "medium",
@@ -3394,13 +3390,7 @@ var HostTimeApi = class {
   }
   formatNumber(value, options) {
     try {
-      let locale = "en-US";
-      const windowVenus = window.venus;
-      if (windowVenus._config.locale) {
-        locale = windowVenus._config.locale;
-      } else if (windowVenus._config.environment && windowVenus._config.environment.browserInfo && windowVenus._config.environment.browserInfo.language) {
-        locale = windowVenus._config.environment.browserInfo.language;
-      }
+      const locale = this.venusApi.getLocale();
       const numberOptions = {
         style: options?.style || "decimal",
         minimumFractionDigits: options?.minimumFractionDigits || 0,
@@ -3463,7 +3453,7 @@ var MockTimeApi = class {
     this.venusApi = venusApi;
   }
   formatNumber(value, options) {
-    const locale = this.getLocale();
+    const locale = this.venusApi.getLocale();
     const numberOptions = {
       style: options?.style || "decimal",
       minimumFractionDigits: options?.minimumFractionDigits || 0,
@@ -3474,7 +3464,7 @@ var MockTimeApi = class {
     return value.toLocaleString(locale, numberOptions);
   }
   formatTime(timestamp, options) {
-    const locale = this.getLocale();
+    const locale = this.venusApi.getLocale();
     const date = new Date(timestamp);
     const dateTimeOptions = {
       dateStyle: options.dateStyle || "medium",
@@ -3554,16 +3544,6 @@ var MockTimeApi = class {
     });
     return timeInfo;
   }
-  getLocale() {
-    const venusApi = this.venusApi;
-    let locale = "en-US";
-    if (venusApi._mock.user && venusApi._mock.user.locale) {
-      locale = venusApi._mock.user.locale;
-    } else if (venusApi._mock.environment && venusApi._mock.environment.browserInfo.language) {
-      locale = venusApi._mock.environment.browserInfo.language;
-    }
-    return locale;
-  }
 };
 
 // src/time/index.ts
@@ -3583,12 +3563,181 @@ function initializeTime(venusApi, host) {
 }
 
 // src/version.ts
-var SDK_VERSION = "3.0.4";
+var SDK_VERSION = "3.1.0-beta.0";
 
 // src/shared-assets/consts.ts
 var BurgerTimeAssetsCdnPath = "burger-time/Core.stow";
 var CharacterAssetsCdnPath = "burger-time/Character.stow";
 
+// src/shared-assets/embeddedLibrariesManifest.ts
+var DEFAULT_SHARED_LIB_CDN_BASE = "https://venus-static-01293ak.web.app/libs";
+var EMBEDDED_LIBRARIES = [
+  {
+    libraryKey: "phaser@3.90.0",
+    assetKey: "library:phaser@3.90.0",
+    packageName: "phaser",
+    version: "3.90.0",
+    globalVar: "Phaser",
+    cdnPath: "phaser/3.90.0/phaser.min.js",
+    moduleSpecifiers: [{ match: "exact", value: "phaser" }],
+    loadStage: 0,
+    enabled: true
+  },
+  {
+    libraryKey: "react@18.3.1",
+    assetKey: "library:react@18.3.1",
+    packageName: "react",
+    version: "18.3.1",
+    globalVar: "React",
+    cdnPath: "react/18.3.1/react.production.min.js",
+    moduleSpecifiers: [
+      { match: "exact", value: "react", behavior: "namespace" },
+      { match: "exact", value: "react/jsx-runtime", behavior: "react-jsx-runtime" },
+      {
+        match: "exact",
+        value: "react/jsx-dev-runtime",
+        behavior: "react-jsx-dev-runtime"
+      }
+    ],
+    loadStage: 0,
+    // Must load before ReactDOM
+    enabled: true
+  },
+  {
+    libraryKey: "react-dom@18.3.1",
+    assetKey: "library:react-dom@18.3.1",
+    packageName: "react-dom",
+    version: "18.3.1",
+    globalVar: "ReactDOM",
+    cdnPath: "react-dom/18.3.1/react-dom.production.min.js",
+    moduleSpecifiers: [
+      { match: "exact", value: "react-dom", behavior: "namespace" },
+      { match: "exact", value: "react-dom/client", behavior: "namespace" }
+    ],
+    loadStage: 1,
+    // Depends on React (stage 0)
+    enabled: true
+  },
+  {
+    libraryKey: "three@0.170.0",
+    assetKey: "library:three@0.170.0",
+    packageName: "three",
+    version: "0.170.0",
+    globalVar: "THREE",
+    cdnPath: "three/r170/three.min.js",
+    moduleSpecifiers: [
+      { match: "exact", value: "three", behavior: "namespace" },
+      { match: "prefix", value: "three/examples/jsm/", behavior: "namespace" }
+    ],
+    loadStage: 0,
+    enabled: true
+  },
+  {
+    libraryKey: "matter-js@0.19.0",
+    assetKey: "library:matter-js@0.19.0",
+    packageName: "matter-js",
+    version: "0.19.0",
+    globalVar: "Matter",
+    cdnPath: "matter-js/0.19.0/matter.min.js",
+    moduleSpecifiers: [{ match: "exact", value: "matter-js" }],
+    loadStage: 0,
+    enabled: true
+  },
+  {
+    libraryKey: "inkjs@2.2.0",
+    assetKey: "library:inkjs@2.2.0",
+    packageName: "inkjs",
+    version: "2.2.0",
+    globalVar: "inkjs",
+    cdnPath: "inkjs/2.2.0/ink.min.js",
+    moduleSpecifiers: [{ match: "exact", value: "inkjs" }],
+    loadStage: 0,
+    enabled: true
+  },
+  {
+    libraryKey: "zustand@5.0.3",
+    assetKey: "library:zustand@5.0.3",
+    packageName: "zustand",
+    version: "5.0.3",
+    globalVar: "zustand",
+    cdnPath: "zustand/5.0.3/zustand.min.js",
+    moduleSpecifiers: [
+      { match: "exact", value: "zustand" },
+      { match: "exact", value: "zustand/middleware" }
+    ],
+    loadStage: 0,
+    enabled: true
+  },
+  {
+    libraryKey: "ammo.js@2024.11",
+    assetKey: "library:ammo.js@2024.11",
+    packageName: "ammo.js",
+    version: "2024.11",
+    globalVar: "Ammo",
+    cdnPath: "ammo/2024.11/ammo.js",
+    moduleSpecifiers: [
+      { match: "exact", value: "ammo.js" },
+      { match: "exact", value: "ammo.js/builds/ammo.wasm.js" }
+    ],
+    loadStage: 0,
+    enabled: false
+    // Not ready yet - WASM loading needs additional work
+  }
+];
+var EMBEDDED_LIBRARY_BY_KEY = EMBEDDED_LIBRARIES.reduce(
+  (acc, lib) => {
+    acc[lib.libraryKey] = lib;
+    return acc;
+  },
+  {}
+);
+var MODULE_TO_LIBRARY_SPECIFIERS = EMBEDDED_LIBRARIES.filter(
+  (lib) => lib.enabled
+).flatMap(
+  (lib) => lib.moduleSpecifiers.map((specifier) => ({
+    ...specifier,
+    libraryKey: lib.libraryKey
+  }))
+);
+function getLibraryDefinition(libraryKey) {
+  const definition = EMBEDDED_LIBRARY_BY_KEY[libraryKey];
+  if (!definition) {
+    const availableKeys = Object.keys(EMBEDDED_LIBRARY_BY_KEY).join(", ");
+    throw new Error(
+      `Unsupported embedded library: ${libraryKey}. Available libraries: ${availableKeys}`
+    );
+  }
+  return definition;
+}
+
+// src/shared-assets/base64Utils.ts
+function base64ToArrayBuffer(base64) {
+  const binaryString = atob(base64);
+  const len = binaryString.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes.buffer;
+}
+function base64ToUtf8(base64) {
+  if (typeof TextDecoder !== "undefined") {
+    const decoder = new TextDecoder("utf-8");
+    const buffer = base64ToArrayBuffer(base64);
+    return decoder.decode(new Uint8Array(buffer));
+  }
+  if (typeof globalThis !== "undefined" && typeof globalThis.Buffer !== "undefined") {
+    const BufferCtor = globalThis.Buffer;
+    return BufferCtor.from(base64, "base64").toString("utf-8");
+  }
+  const binaryString = atob(base64);
+  let result = "";
+  for (let i = 0; i < binaryString.length; i++) {
+    result += String.fromCharCode(binaryString.charCodeAt(i));
+  }
+  return decodeURIComponent(escape(result));
+}
+
 // src/shared-assets/RpcSharedAssetsApi.ts
 var RpcSharedAssetsApi = class {
   constructor(rpcClient, venusApi) {
@@ -3627,16 +3776,33 @@ var RpcSharedAssetsApi = class {
       }
     }
   }
-};
-function base64ToArrayBuffer(base64) {
-  const binaryString = atob(base64);
-  const len = binaryString.length;
-  const bytes = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    bytes[i] = binaryString.charCodeAt(i);
+  async loadLibraryCode(libraryKey) {
+    const definition = getLibraryDefinition(libraryKey);
+    try {
+      const response = await this.rpcClient.callT("H5_LOAD_EMBEDDED_ASSET" /* H5_LOAD_EMBEDDED_ASSET */, {
+        assetKey: definition.assetKey
+      });
+      return base64ToUtf8(response.base64Data);
+    } catch (err) {
+      console.error(
+        `[Venus Libraries] Failed to load ${libraryKey} from host via RPC:`,
+        err
+      );
+      console.warn(
+        `[Venus Libraries] Falling back to CDN for ${libraryKey}. This may indicate an asset packaging issue.`
+      );
+      try {
+        const cdnUrl = this.venusApi.cdn.resolveSharedLibUrl(definition.cdnPath);
+        const response = await this.venusApi.cdn.fetchFromCdn(cdnUrl);
+        return await response.text();
+      } catch (cdnError) {
+        throw new Error(
+          `Failed to load embedded library ${libraryKey}: RPC failed, CDN fallback failed: ${cdnError.message}`
+        );
+      }
+    }
   }
-  return bytes.buffer;
-}
+};
 
 // src/shared-assets/MockSharedAssetsApi.ts
 var MockSharedAssetsApi = class {
@@ -3652,49 +3818,114 @@ var MockSharedAssetsApi = class {
     const blob = await this.venusApi.cdn.fetchBlob(CharacterAssetsCdnPath);
     return await blob.arrayBuffer();
   }
+  async loadLibraryCode(libraryKey) {
+    const definition = getLibraryDefinition(libraryKey);
+    const url = this.venusApi.cdn.resolveSharedLibUrl(definition.cdnPath);
+    const response = await this.venusApi.cdn.fetchFromCdn(url);
+    return await response.text();
+  }
 };
 
+// src/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 {
   constructor(rpcClient) {
     __publicField(this, "rpcClient");
+    /** Cache of score tokens for automatic hash computation */
+    __publicField(this, "tokenCache", /* @__PURE__ */ new Map());
     this.rpcClient = rpcClient;
   }
-  startRun(mode) {
-    return this.rpcClient.call(
-      "H5_LEADERBOARD_START_RUN" /* H5_LEADERBOARD_START_RUN */,
+  /**
+   * Create a score token for submitting a score.
+   * Token is cached for automatic hash computation if score sealing is enabled.
+   *
+   * @param mode - Optional game mode
+   * @returns Score token with sealing data if enabled
+   */
+  async createScoreToken(mode) {
+    const token = await this.rpcClient.call(
+      "H5_LEADERBOARD_CREATE_SCORE_TOKEN" /* H5_LEADERBOARD_CREATE_SCORE_TOKEN */,
       mode ? { mode } : {}
     );
+    this.tokenCache.set(token.token, token);
+    return token;
   }
-  submitScore(sessionId, score, durationSec, options) {
+  /**
+   * Submit a score to the leaderboard.
+   * Automatically computes hash if score sealing is enabled and token was created via createScoreToken().
+   *
+   * @param params - Score submission parameters
+   * @returns Submission result with acceptance status and rank
+   * @throws Error if token not found in cache
+   */
+  async submitScore(params) {
+    let hash;
+    if (params.token) {
+      const cachedToken = this.tokenCache.get(params.token);
+      if (!cachedToken) {
+        throw new Error(
+          "Invalid token: not found in cache. Did you call createScoreToken() first?"
+        );
+      }
+      if (cachedToken.sealingNonce && cachedToken.sealingSecret) {
+        hash = await computeScoreHash(
+          params.score,
+          params.duration,
+          params.token,
+          cachedToken.sealingNonce,
+          cachedToken.sealingSecret
+        );
+      }
+      this.tokenCache.delete(params.token);
+    }
     return this.rpcClient.call(
       "H5_LEADERBOARD_SUBMIT_SCORE" /* H5_LEADERBOARD_SUBMIT_SCORE */,
       {
-        sessionId,
-        score,
-        durationSec,
-        mode: options?.mode,
-        telemetry: options?.telemetry,
-        metadata: options?.metadata,
-        hash: options?.hash
+        token: params.token,
+        score: params.score,
+        duration: params.duration,
+        mode: params.mode,
+        telemetry: params.telemetry,
+        metadata: params.metadata,
+        hash
+        // undefined if no sealing, computed if sealing enabled
       }
     );
   }
-  getLeaderboard(options) {
+  getPagedScores(options) {
     return this.rpcClient.call(
-      "H5_LEADERBOARD_GET" /* H5_LEADERBOARD_GET */,
+      "H5_LEADERBOARD_GET_PAGED_SCORES" /* H5_LEADERBOARD_GET_PAGED_SCORES */,
       options ?? {}
     );
   }
-  getPlayerStats(options) {
+  getMyRank(options) {
     return this.rpcClient.call(
-      "H5_LEADERBOARD_GET_PLAYER_STATS" /* H5_LEADERBOARD_GET_PLAYER_STATS */,
+      "H5_LEADERBOARD_GET_MY_RANK" /* H5_LEADERBOARD_GET_MY_RANK */,
       options ?? {}
     );
   }
-  getLeaderboardHighlight(options) {
+  getPodiumScores(options) {
     return this.rpcClient.call(
-      "H5_LEADERBOARD_GET_HIGHLIGHT" /* H5_LEADERBOARD_GET_HIGHLIGHT */,
+      "H5_LEADERBOARD_GET_PODIUM_SCORES" /* H5_LEADERBOARD_GET_PODIUM_SCORES */,
       options ?? {}
     );
   }
@@ -3703,17 +3934,31 @@ var RpcLeaderboardApi = class {
 // src/leaderboard/MockLeaderboardApi.ts
 var MockLeaderboardApi = class {
   constructor(options) {
-    __publicField(this, "sessions", /* @__PURE__ */ new Map());
+    __publicField(this, "tokens", /* @__PURE__ */ new Map());
+    /** Cache of score tokens for automatic hash computation */
+    __publicField(this, "tokenCache", /* @__PURE__ */ new Map());
     __publicField(this, "entriesByMode", /* @__PURE__ */ new Map());
-    __publicField(this, "sessionCounter", 0);
-    __publicField(this, "requiresHash", false);
-    if (options?.requiresHash) {
-      this.requiresHash = true;
+    __publicField(this, "tokenCounter", 0);
+    __publicField(this, "enableScoreSealing", false);
+    __publicField(this, "scoreSealingSecret", "mock-leaderboard-secret-key");
+    if (options?.enableScoreSealing) {
+      this.enableScoreSealing = true;
+    }
+    if (options?.scoreSealingSecret) {
+      this.scoreSealingSecret = options.scoreSealingSecret;
     }
   }
+  /**
+   * Configure mock leaderboard settings
+   *
+   * @param options - Configuration options
+   */
   configure(options) {
-    if (typeof options.requiresHash === "boolean") {
-      this.requiresHash = options.requiresHash;
+    if (typeof options.enableScoreSealing === "boolean") {
+      this.enableScoreSealing = options.enableScoreSealing;
+    }
+    if (options.scoreSealingSecret) {
+      this.scoreSealingSecret = options.scoreSealingSecret;
     }
   }
   generateNonce() {
@@ -3730,83 +3975,149 @@ var MockLeaderboardApi = class {
     }
     return this.entriesByMode.get(key);
   }
-  async startRun(mode) {
-    const sessionId = `mock_session_${++this.sessionCounter}`;
+  /**
+   * Create a mock score token for testing.
+   * Token is cached for automatic hash computation if score sealing is enabled.
+   *
+   * @param mode - Optional game mode
+   * @returns Score token with sealing data if enabled
+   */
+  async createScoreToken(mode) {
+    const token = `mock_token_${++this.tokenCounter}`;
     const startTime = Date.now();
     const expiresAt = startTime + 36e5;
     const resolvedMode = mode || "default";
-    const hashNonce = this.requiresHash ? this.generateNonce() : null;
-    this.sessions.set(sessionId, {
-      id: sessionId,
+    const sealingNonce = this.enableScoreSealing ? this.generateNonce() : null;
+    const sealingSecret = this.enableScoreSealing ? this.scoreSealingSecret : null;
+    this.tokens.set(token, {
+      id: token,
       expiresAt,
       mode: resolvedMode,
-      hashNonce,
+      sealingNonce,
       used: false
     });
-    return {
-      sessionId,
+    const result = {
+      token,
       startTime,
       expiresAt,
-      hashNonce,
+      sealingNonce,
+      sealingSecret,
       mode: resolvedMode
     };
+    this.tokenCache.set(token, result);
+    return result;
   }
-  async submitScore(sessionId, score, durationSec, options) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error("Invalid leaderboard session");
+  /**
+   * Submit a mock score to the leaderboard.
+   * Automatically computes hash if score sealing is enabled and token was created via createScoreToken().
+   *
+   * @param params - Score submission parameters
+   * @returns Submission result with acceptance status and rank
+   * @throws Error if token not found in cache or validation fails
+   */
+  async submitScore(params) {
+    let hash;
+    if (params.token) {
+      const cachedToken = this.tokenCache.get(params.token);
+      if (!cachedToken) {
+        throw new Error(
+          "Invalid token: not found in cache. Did you call createScoreToken() first?"
+        );
+      }
+      if (cachedToken.sealingNonce && cachedToken.sealingSecret) {
+        hash = await computeScoreHash(
+          params.score,
+          params.duration,
+          params.token,
+          cachedToken.sealingNonce,
+          cachedToken.sealingSecret
+        );
+      }
+    }
+    if (!params.token) {
+      const mode = params.mode || "default";
+      const submittedAt2 = Date.now();
+      const entry2 = {
+        profileId: `mock_profile`,
+        username: "Mock Player",
+        avatarUrl: null,
+        score: params.score,
+        duration: params.duration,
+        submittedAt: submittedAt2,
+        token: "simple-mode",
+        rank: null,
+        zScore: null,
+        isAnomaly: false,
+        trustScore: 50,
+        metadata: params.metadata ?? null,
+        isSeed: false
+      };
+      const modeEntries2 = this.getEntriesForMode(mode);
+      modeEntries2.push(entry2);
+      modeEntries2.sort((a, b) => {
+        if (b.score !== a.score) return b.score - a.score;
+        return a.submittedAt - b.submittedAt;
+      });
+      modeEntries2.forEach((e, index) => {
+        modeEntries2[index] = { ...e, rank: index + 1 };
+      });
+      const inserted2 = modeEntries2.find((e) => e.submittedAt === submittedAt2);
+      return {
+        accepted: true,
+        rank: inserted2?.rank ?? null
+      };
+    }
+    const scoreToken = this.tokens.get(params.token);
+    if (!scoreToken) {
+      throw new Error("Invalid score token");
     }
-    if (session.expiresAt < Date.now()) {
-      throw new Error("Invalid or expired leaderboard session");
+    if (scoreToken.expiresAt < Date.now()) {
+      throw new Error("Invalid or expired score token");
     }
-    if (session.used) {
-      throw new Error("Leaderboard session already used");
+    if (scoreToken.used) {
+      throw new Error("Score token already used");
     }
-    if (options?.mode && options.mode !== session.mode) {
-      throw new Error("Submission mode does not match session mode");
+    if (params.mode && params.mode !== scoreToken.mode) {
+      throw new Error("Submission mode does not match token mode");
     }
-    if (session.hashNonce && !options?.hash) {
-      throw new Error("Score hash is required for sealed leaderboard submissions");
+    if (scoreToken.sealingNonce && !hash) {
+      throw new Error("Score hash required when score sealing is enabled");
     }
     const submittedAt = Date.now();
     const entry = {
       profileId: `mock_profile`,
       username: "Mock Player",
       avatarUrl: null,
-      score,
-      durationSec,
+      score: params.score,
+      duration: params.duration,
       submittedAt,
-      sessionId,
+      token: params.token,
       rank: null,
       zScore: null,
       isAnomaly: false,
       trustScore: 50,
-      metadata: options?.metadata ?? null,
+      metadata: params.metadata ?? null,
       isSeed: false
     };
-    const modeEntries = this.getEntriesForMode(session.mode);
+    const modeEntries = this.getEntriesForMode(scoreToken.mode);
     modeEntries.push(entry);
     modeEntries.sort((a, b) => {
-      if (b.score !== a.score) {
-        return b.score - a.score;
-      }
+      if (b.score !== a.score) return b.score - a.score;
       return a.submittedAt - b.submittedAt;
     });
     modeEntries.forEach((e, index) => {
-      modeEntries[index] = {
-        ...e,
-        rank: index + 1
-      };
+      modeEntries[index] = { ...e, rank: index + 1 };
     });
-    session.used = true;
-    session.hashNonce = null;
-    const inserted = modeEntries.find((e) => e.sessionId === sessionId && e.submittedAt === submittedAt);
+    scoreToken.used = true;
+    scoreToken.sealingNonce = null;
+    this.tokenCache.delete(params.token);
+    const inserted = modeEntries.find((e) => e.token === params.token && e.submittedAt === submittedAt);
     return {
       accepted: true,
       rank: inserted?.rank ?? null
     };
   }
-  async getLeaderboard(options) {
+  async getPagedScores(options) {
     const limit = options?.limit ?? 10;
     const mode = options?.mode ?? "default";
     const modeEntries = [...this.getEntriesForMode(mode)];
@@ -3822,7 +4133,7 @@ var MockLeaderboardApi = class {
       periodInstance: options?.period ?? "alltime"
     };
   }
-  async getPlayerStats(_options) {
+  async getMyRank(_options) {
     const mode = _options?.mode ?? "default";
     const modeEntries = this.getEntriesForMode(mode);
     const playerEntry = modeEntries[0] ?? null;
@@ -3835,7 +4146,7 @@ var MockLeaderboardApi = class {
       periodInstance: _options?.period ?? "alltime"
     };
   }
-  async getLeaderboardHighlight(options) {
+  async getPodiumScores(options) {
     const mode = options?.mode ?? "default";
     const modeEntries = [...this.getEntriesForMode(mode)];
     const topCount = Math.max(1, Math.min(options?.topCount ?? 3, 10));
@@ -5222,7 +5533,7 @@ var RemoteHost = class {
     this.popups = new RpcPopupsApi(rpcClient);
     this.profile = new HostProfileApi();
     this.cdn = new HostCdnApi(getCdnBaseUrl());
-    this.time = new HostTimeApi(rpcClient);
+    this.time = new HostTimeApi(rpcClient, venusApi);
     this.post = new RpcPostApi(rpcClient);
     this.ai = new RpcAiApi(rpcClient);
     this.haptics = new RpcHapticsApi(rpcClient);
@@ -5313,10 +5624,356 @@ function initializeSocial(venusApi, host) {
   };
 }
 
+// src/webview/webviewLibraryShimSource.ts
+var WEBVIEW_LIBRARY_SHIM_SOURCE = `
+(function () {
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  if (window.__venusLibraryShim && window.__venusLibraryShim.__initialized) {
+    return;
+  }
+
+  var RESPONSE_TYPE = 'H5_RESPONSE';
+  var REQUEST_TYPE = 'H5_LOAD_EMBEDDED_ASSET';
+  var REQUEST_TIMEOUT_MS = 12000;
+  var pendingRequests = new Map();
+
+  function ensureConfig() {
+    if (!window.__venusLibrariesConfig) {
+      window.__venusLibrariesConfig = {
+        enabled: false,
+        required: [],
+        manifest: {},
+        cdnBase: ''
+      };
+    }
+    if (!window.__venusLibrariesConfig.manifest) {
+      window.__venusLibrariesConfig.manifest = {};
+    }
+    if (!Array.isArray(window.__venusLibrariesConfig.required)) {
+      window.__venusLibrariesConfig.required = [];
+    }
+    return window.__venusLibrariesConfig;
+  }
+
+  function ensureExportsRegistry() {
+    if (!window.__venusLibraryExports) {
+      window.__venusLibraryExports = {};
+    }
+    return window.__venusLibraryExports;
+  }
+
+  function hasHostBridge() {
+    return !!(window.ReactNativeWebView && typeof window.ReactNativeWebView.postMessage === 'function');
+  }
+
+  function registerResponseListeners() {
+    if (window.__venusLibraryShim && window.__venusLibraryShim.__listenerRegistered) {
+      return;
+    }
+
+    function handleMessage(event) {
+      var payload = parsePayload(event && event.data);
+      if (!payload || payload.type !== RESPONSE_TYPE || !payload.data) {
+        return;
+      }
+      var requestId = payload.data.requestId;
+      if (!requestId || !pendingRequests.has(requestId)) {
+        return;
+      }
+      var pending = pendingRequests.get(requestId);
+      pendingRequests.delete(requestId);
+      clearTimeout(pending.timeout);
+
+      if (payload.data.success === false) {
+        pending.reject(new Error(payload.data.error || 'Embedded library load failed'));
+        return;
+      }
+
+      var value = payload.data.value || payload.data;
+      if (!value || !value.base64Data) {
+        pending.reject(new Error('Embedded library response was missing base64Data'));
+        return;
+      }
+
+      pending.resolve(value.base64Data);
+    }
+
+    if (typeof document !== 'undefined' && typeof document.addEventListener === 'function') {
+      document.addEventListener('message', handleMessage, false);
+    }
+    if (typeof window !== 'undefined' && typeof window.addEventListener === 'function') {
+      window.addEventListener('message', handleMessage, false);
+    }
+
+    if (!window.__venusLibraryShim) {
+      window.__venusLibraryShim = {};
+    }
+    window.__venusLibraryShim.__listenerRegistered = true;
+  }
+
+  function parsePayload(raw) {
+    if (!raw || typeof raw !== 'string') {
+      return null;
+    }
+    try {
+      return JSON.parse(raw);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  function createRequestId(libraryKey) {
+    var sanitized = '';
+    for (var i = 0; i < libraryKey.length; i++) {
+      var c = libraryKey.charAt(i);
+      if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '-' || c === '_') {
+        sanitized += c;
+      } else {
+        sanitized += '_';
+      }
+    }
+    return 'embedded-lib-' + sanitized + '-' + Date.now() + '-' + Math.random().toString(36).slice(2);
+  }
+
+  function postHostRequest(assetKey, requestId) {
+    if (!hasHostBridge()) {
+      throw new Error('Host bridge is unavailable');
+    }
+    var bridge = window.ReactNativeWebView;
+    var message = {
+      type: REQUEST_TYPE,
+      direction: 'H5_TO_APP',
+      data: {
+        requestId: requestId,
+        assetKey: assetKey
+      },
+      instanceId: (window._venusInitState && window._venusInitState.poolId) || 'unknown',
+      timestamp: Date.now()
+    };
+    bridge.postMessage(JSON.stringify(message));
+  }
+
+  function loadLibraryViaHost(assetKey, libraryKey) {
+    return new Promise(function (resolve, reject) {
+      var requestId = createRequestId(libraryKey);
+      var timeout = setTimeout(function () {
+        pendingRequests.delete(requestId);
+        reject(new Error('Timed out loading embedded library: ' + libraryKey));
+      }, REQUEST_TIMEOUT_MS);
+
+      pendingRequests.set(requestId, { resolve: resolve, reject: reject, timeout: timeout });
+
+      try {
+        postHostRequest(assetKey, requestId);
+      } catch (error) {
+        pendingRequests.delete(requestId);
+        clearTimeout(timeout);
+        reject(error);
+      }
+    });
+  }
+
+  function buildCdnUrl(config, entry) {
+    var base = config.cdnBase || '';
+    if (!base.endsWith('/')) {
+      base += '/';
+    }
+    var path = entry.cdnPath;
+    if (path.charAt(0) === '/') {
+      path = path.substring(1);
+    }
+    return base + path;
+  }
+
+  async function loadLibraryViaCdn(config, entry, libraryKey) {
+    if (!config.cdnBase) {
+      throw new Error('CDN base URL is not configured');
+    }
+    var url = buildCdnUrl(config, entry);
+    var response = await fetch(url, { credentials: 'omit' });
+    if (!response.ok) {
+      throw new Error('Failed to fetch embedded library from CDN: ' + libraryKey);
+    }
+    return await response.text();
+  }
+
+  function decodeBase64ToUtf8(base64) {
+    if (typeof base64 !== 'string') {
+      throw new Error('Invalid base64 payload');
+    }
+
+    if (typeof atob === 'function') {
+      var binary = atob(base64);
+      if (typeof TextDecoder !== 'undefined') {
+        var len = binary.length;
+        var bytes = new Uint8Array(len);
+        for (var i = 0; i < len; i++) {
+          bytes[i] = binary.charCodeAt(i);
+        }
+        return new TextDecoder('utf-8').decode(bytes);
+      }
+      return decodeURIComponent(escape(binary));
+    }
+
+    var bufferCtor = (typeof globalThis !== 'undefined' && globalThis.Buffer) || (typeof window !== 'undefined' && window.Buffer);
+    if (bufferCtor) {
+      return bufferCtor.from(base64, 'base64').toString('utf-8');
+    }
+
+    throw new Error('No base64 decoder available');
+  }
+
+  function evaluateLibrarySource(libraryKey, globalVar, source) {
+    var registry = ensureExportsRegistry();
+    if (!source) {
+      throw new Error('Embedded library source was empty for ' + libraryKey);
+    }
+
+    var previousValue = window[globalVar];
+    try {
+      var executor = new Function(source + '\\n//# sourceURL=venus-library-' + libraryKey + '.js');
+      executor.call(window);
+    } catch (error) {
+      throw new Error('Failed to evaluate embedded library ' + libraryKey + ': ' + (error && error.message ? error.message : error));
+    }
+
+    var exported = window[globalVar] || previousValue;
+    if (!exported) {
+      throw new Error('Embedded library ' + libraryKey + ' did not register ' + globalVar);
+    }
+
+    registry[libraryKey] = exported;
+    return exported;
+  }
+
+  async function ensureLibraryLoaded(config, libraryKey) {
+    var registry = ensureExportsRegistry();
+    if (registry[libraryKey]) {
+      return registry[libraryKey];
+    }
+
+    var entry = config.manifest && config.manifest[libraryKey];
+    if (!entry) {
+      throw new Error('No manifest entry for embedded library ' + libraryKey);
+    }
+
+    var source = null;
+    if (config.useHost !== false && hasHostBridge()) {
+      try {
+        var base64 = await loadLibraryViaHost(entry.assetKey, libraryKey);
+        source = decodeBase64ToUtf8(base64);
+      } catch (error) {
+        // Log the RPC error loudly before fallback
+        console.error('[Venus Libraries] Failed to load ' + libraryKey + ' from host via RPC:', error);
+        console.warn('[Venus Libraries] Falling back to CDN for ' + libraryKey + '. This may indicate an asset packaging issue.');
+      }
+    }
+
+    if (!source) {
+      source = await loadLibraryViaCdn(config, entry, libraryKey);
+    }
+
+    return evaluateLibrarySource(libraryKey, entry.globalVar, source);
+  }
+
+  async function bootstrap() {
+    try {
+      registerResponseListeners();
+      getBootstrapPromise();
+      
+      var config = ensureConfig();
+      
+      if (!config.enabled) {
+        if (bootstrapResolve) bootstrapResolve();
+        return;
+      }
+      
+      if (!Array.isArray(config.required) || config.required.length === 0) {
+        if (bootstrapResolve) bootstrapResolve();
+        return;
+      }
+
+      // Group libraries by load stage for parallel loading within stages
+      var librariesByStage = {};
+      for (var i = 0; i < config.required.length; i++) {
+        var libraryKey = config.required[i];
+        var entry = config.manifest[libraryKey];
+        var stage = entry.loadStage || 0;
+        if (!librariesByStage[stage]) librariesByStage[stage] = [];
+        librariesByStage[stage].push(libraryKey);
+      }
+      
+      // Load stages sequentially, libraries within each stage in parallel
+      var stages = Object.keys(librariesByStage).sort(function(a, b) {
+        return parseInt(a, 10) - parseInt(b, 10);
+      });
+      
+      for (var s = 0; s < stages.length; s++) {
+        var stage = stages[s];
+        var libs = librariesByStage[stage];
+        
+        // Load all libraries in this stage in parallel
+        var stagePromises = libs.map(function(libraryKey) {
+          return ensureLibraryLoaded(config, libraryKey).catch(function(error) {
+            console.error('[Venus Libraries] Failed to load library ' + libraryKey, error);
+            throw error;
+          });
+        });
+        
+        await Promise.all(stagePromises);
+      }
+      
+      if (bootstrapResolve) bootstrapResolve();
+    } catch (error) {
+      console.error('[Venus Libraries] Bootstrap error', error);
+      if (bootstrapReject) bootstrapReject(error);
+      throw error;
+    }
+  }
+
+  // Create a promise that resolves when bootstrap completes
+  var bootstrapPromise = null;
+  var bootstrapResolve = null;
+  var bootstrapReject = null;
+
+  function getBootstrapPromise() {
+    if (!bootstrapPromise) {
+      bootstrapPromise = new Promise(function(resolve, reject) {
+        bootstrapResolve = resolve;
+        bootstrapReject = reject;
+      });
+    }
+    return bootstrapPromise;
+  }
+
+  window.__venusLibraryShim = {
+    bootstrap: bootstrap,
+    ready: getBootstrapPromise,
+    getExports: function (libraryKey) {
+      var registry = ensureExportsRegistry();
+      return registry[libraryKey];
+    },
+    __initialized: true,
+  };
+})();
+`;
+function getWebviewLibraryShimSource() {
+  return WEBVIEW_LIBRARY_SHIM_SOURCE;
+}
+
+exports.DEFAULT_SHARED_LIB_CDN_BASE = DEFAULT_SHARED_LIB_CDN_BASE;
+exports.EMBEDDED_LIBRARIES = EMBEDDED_LIBRARIES;
+exports.EMBEDDED_LIBRARY_BY_KEY = EMBEDDED_LIBRARY_BY_KEY;
+exports.HASH_ALGORITHM_NODE = HASH_ALGORITHM_NODE;
+exports.HASH_ALGORITHM_WEB_CRYPTO = HASH_ALGORITHM_WEB_CRYPTO;
 exports.HapticFeedbackStyle = HapticFeedbackStyle;
 exports.HostCdnApi = HostCdnApi;
 exports.HostProfileApi = HostProfileApi;
 exports.HostTimeApi = HostTimeApi;
+exports.MODULE_TO_LIBRARY_SPECIFIERS = MODULE_TO_LIBRARY_SPECIFIERS;
 exports.MockAdsApi = MockAdsApi;
 exports.MockAiApi = MockAiApi;
 exports.MockAnalyticsApi = MockAnalyticsApi;
@@ -5360,8 +6017,14 @@ exports.RpcSocialApi = RpcSocialApi;
 exports.RpcStorageApi = RpcStorageApi;
 exports.SDK_VERSION = SDK_VERSION;
 exports.VenusMessageId = VenusMessageId;
+exports.WEBVIEW_LIBRARY_SHIM_SOURCE = WEBVIEW_LIBRARY_SHIM_SOURCE;
+exports.base64ToArrayBuffer = base64ToArrayBuffer;
+exports.base64ToUtf8 = base64ToUtf8;
+exports.computeScoreHash = computeScoreHash;
 exports.createHost = createHost;
 exports.createMockStorageApi = createMockStorageApi;
+exports.getLibraryDefinition = getLibraryDefinition;
+exports.getWebviewLibraryShimSource = getWebviewLibraryShimSource;
 exports.initializeAds = initializeAds;
 exports.initializeAi = initializeAi;
 exports.initializeAnalytics = initializeAnalytics;