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

package/dist/{chunk-PXWCNWJ6.mjs → chunk-EMVTVSGL.mjs}

@@ -1,4 +1,5 @@
-import { __esm, __export, __publicField, createMockDelay, MOCK_DELAYS, isWebPlatform, __toCommonJS } from './chunk-W7IPHM67.mjs';
+import { createMockDelay, MOCK_DELAYS, isWebPlatform } from './chunk-QABXMFND.mjs';
+import { __esm, __export, __publicField, __toCommonJS } from './chunk-2PDL7CQK.mjs';
 
 // src/rooms/VenusRoom.ts
 var VenusRoom;
@@ -306,11 +307,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";
@@ -3326,9 +3327,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(
@@ -3338,13 +3341,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",
@@ -3356,13 +3353,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,
@@ -3425,7 +3416,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,
@@ -3436,7 +3427,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",
@@ -3516,16 +3507,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
@@ -3545,7 +3526,176 @@ function initializeTime(venusApi, host) {
 }
 
 // src/version.ts
-var SDK_VERSION = "3.0.4";
+var SDK_VERSION = "3.1.0-beta.0";
+
+// 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/consts.ts
 var BurgerTimeAssetsCdnPath = "burger-time/Core.stow";
@@ -3589,16 +3739,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 {
@@ -3614,49 +3781,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 ?? {}
     );
   }
@@ -3665,17 +3897,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() {
@@ -3692,83 +3938,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 (session.expiresAt < Date.now()) {
-      throw new Error("Invalid or expired leaderboard session");
+    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 (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)];
@@ -3784,7 +4096,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;
@@ -3797,7 +4109,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));
@@ -4608,7 +4920,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);
@@ -5289,6 +5601,6 @@ function initializeSocial(venusApi, host) {
   };
 }
 
-export { HapticFeedbackStyle, HostCdnApi, HostProfileApi, HostTimeApi, MockAdsApi, MockAiApi, MockAnalyticsApi, MockAvatarApi, MockCdnApi, MockFeaturesApi, MockHapticsApi, MockIapApi, MockLeaderboardApi, MockLifecycleApi, MockLoggingApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockPreloaderApi, MockProfileApi, MockSharedAssetsApi, MockSimulationApi, MockSocialApi, MockStorageApi, MockTimeApi, RemoteHost, RpcAdsApi, RpcAiApi, RpcAnalyticsApi, RpcAvatarApi, RpcClient, RpcFeaturesApi, RpcHapticsApi, RpcIapApi, RpcLeaderboardApi, RpcLifecycleApi, RpcLoggingApi, RpcNavigationApi, RpcNotificationsApi, RpcPopupsApi, RpcPreloaderApi, RpcSharedAssetsApi, RpcSimulationApi, RpcSocialApi, RpcStorageApi, SDK_VERSION, VenusMessageId, VenusRoom, createHost, createMockStorageApi, init_rooms, initializeAds, initializeAi, initializeAnalytics, initializeAvatar3d, initializeCdn, initializeFeaturesApi, initializeHaptics, initializeIap, initializeLeaderboard, initializeLifecycleApi, initializeLocalNotifications, initializeLoggingApi, initializePopups, initializePost, initializePreloader, initializeProfile, initializeRoomsApi, initializeSimulation, initializeSocial, initializeStackNavigation, initializeStorage, initializeTime, isPacificDaylightTime, setupRoomNotifications };
-//# sourceMappingURL=chunk-PXWCNWJ6.mjs.map
-//# sourceMappingURL=chunk-PXWCNWJ6.mjs.map
+export { DEFAULT_SHARED_LIB_CDN_BASE, EMBEDDED_LIBRARIES, EMBEDDED_LIBRARY_BY_KEY, HASH_ALGORITHM_NODE, HASH_ALGORITHM_WEB_CRYPTO, HapticFeedbackStyle, HostCdnApi, HostProfileApi, HostTimeApi, MODULE_TO_LIBRARY_SPECIFIERS, MockAdsApi, MockAiApi, MockAnalyticsApi, MockAvatarApi, MockCdnApi, MockFeaturesApi, MockHapticsApi, MockIapApi, MockLeaderboardApi, MockLifecycleApi, MockLoggingApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockPreloaderApi, MockProfileApi, MockSharedAssetsApi, MockSimulationApi, MockSocialApi, MockStorageApi, MockTimeApi, RemoteHost, RpcAdsApi, RpcAiApi, RpcAnalyticsApi, RpcAvatarApi, RpcClient, RpcFeaturesApi, RpcHapticsApi, RpcIapApi, RpcLeaderboardApi, RpcLifecycleApi, RpcLoggingApi, RpcNavigationApi, RpcNotificationsApi, RpcPopupsApi, RpcPreloaderApi, RpcSharedAssetsApi, RpcSimulationApi, RpcSocialApi, RpcStorageApi, SDK_VERSION, VenusMessageId, VenusRoom, base64ToArrayBuffer, base64ToUtf8, computeScoreHash, createHost, createMockStorageApi, getLibraryDefinition, init_rooms, initializeAds, initializeAi, initializeAnalytics, initializeAvatar3d, initializeCdn, initializeFeaturesApi, initializeHaptics, initializeIap, initializeLeaderboard, initializeLifecycleApi, initializeLocalNotifications, initializeLoggingApi, initializePopups, initializePost, initializePreloader, initializeProfile, initializeRoomsApi, initializeSimulation, initializeSocial, initializeStackNavigation, initializeStorage, initializeTime, isPacificDaylightTime, setupRoomNotifications };
+//# sourceMappingURL=chunk-EMVTVSGL.mjs.map
+//# sourceMappingURL=chunk-EMVTVSGL.mjs.map