@series-inc/venus-sdk 2.2.0

package/dist/index.cjs

@@ -0,0 +1,3205 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/ads/RpcAdsApi.ts
+var RpcAdsApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async showInterstitialAd() {
+    console.log(`[Venus SDK] [RpcAdsApi] showInterstitialAd`);
+    return await this.rpcClient.call(
+      "H5_SHOW_INTERSTITIAL_AD" /* SHOW_INTERSTITIAL_AD */
+    );
+  }
+  async isRewardedAdReadyAsync() {
+    console.log(`[Venus SDK] [RpcAdsApi] isRewardedAdReadyAsync`);
+    return await this.rpcClient.call(
+      "H5_IS_REWARDED_AD_READY" /* IS_REWARDED_AD_READY */
+    );
+  }
+  async showRewardedAdAsync() {
+    console.log("[Venus SDK] [RpcAdsApi] showRewardedAdAsync");
+    const result = await this.rpcClient.call(
+      "H5_SHOW_REWARDED_AD" /* SHOW_REWARDED_AD */
+    );
+    const resultAsString = JSON.stringify(result, null, 2);
+    console.log(
+      `[Venus SDK] [RpcAdsApi] rewarded ad shown with result as JSON:
+${resultAsString}`
+    );
+    return result.rewardEarned;
+  }
+};
+
+// src/venus-api/systems/core.js
+function isWebPlatform() {
+  return typeof window !== "undefined" && !window.ReactNativeWebView;
+}
+var MOCK_DELAYS = {
+  short: 100,
+  // Quick operations (get/set preferences, etc.)
+  medium: 500};
+function createMockDelay(ms = MOCK_DELAYS.short) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/ads/MockAdsApi.ts
+var MockAdsApi = class {
+  constructor(mockOverlay) {
+    __publicField(this, "mockOverlay");
+    this.mockOverlay = mockOverlay;
+  }
+  async isRewardedAdReadyAsync() {
+    this.log("[MockAdsApi] isRewardedAdReadyAsync called");
+    await createMockDelay(MOCK_DELAYS.short);
+    return true;
+  }
+  async showRewardedAdAsync() {
+    this.log("[MockAdsApi] showRewardedAdAsync called");
+    await this.mockOverlay.showAdOverlay();
+    this.log("[MockAdsApi] Rewarded ad completed");
+    return true;
+  }
+  async showInterstitialAd() {
+    this.log(`[MockAdsApi] showInterstitialAd`);
+    return true;
+  }
+  log(message, ...args) {
+    console.log(`[Venus SDK] ${message}`, ...args);
+  }
+};
+
+// src/ads/index.ts
+function initializeAds(venusApiInstance, host) {
+  venusApiInstance.isRewardedAdReadyAsync = host.ads.isRewardedAdReadyAsync.bind(host.ads);
+  venusApiInstance.showRewardedAdAsync = host.ads.showRewardedAdAsync.bind(
+    host.ads
+  );
+  venusApiInstance.ads = host.ads;
+}
+
+// src/ai/RpcAiApi.ts
+var RpcAiApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async requestChatCompletionAsync(request) {
+    const response = await this.rpcClient.call(
+      "H5_AI_CHAT_COMPLETION" /* AI_CHAT_COMPLETION */,
+      {
+        request: (() => {
+          const { apiKey, ...requestWithoutApiKey } = request;
+          return requestWithoutApiKey;
+        })()
+      }
+    );
+    return response;
+  }
+  async getAvailableCompletionModels() {
+    const response = await this.rpcClient.call(
+      "H5_AI_GET_AVAILABLE_MODELS" /* AI_GET_AVAILABLE_MODELS */
+    );
+    return response;
+  }
+};
+
+// src/ai/MockAiApi.ts
+var MockAiApi = class {
+  async requestChatCompletionAsync(request) {
+    const { apiKey, ...requestBody } = request;
+    if (!apiKey) {
+      throw new Error("An API key is required for a chat completion request when developing locally.");
+    }
+    const response = await fetch("https://series.ullm.rho.live/api/v1/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async getAvailableCompletionModels() {
+    const response = await fetch("https://series.ullm.rho.live/api/v1/models", {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+};
+
+// src/ai/index.ts
+function initializeAi(venusApi, host) {
+  venusApi.ai = host.ai;
+}
+
+// src/analytics/MockAnalyticsApi.ts
+var MockAnalyticsApi = class {
+  async recordCustomEvent(eventName, payload) {
+    console.log(
+      `[Venus Mock] Logging event with ${eventName}, params ${payload}`
+    );
+    await createMockDelay(MOCK_DELAYS.short);
+  }
+  async trackFunnelStep(stepNumber, stepName, funnelName) {
+    console.log(`[Venus Mock] tracking funnel step ${stepName} (step ${stepNumber}) for funnel ${funnelName ?? "game"}`);
+    await createMockDelay(MOCK_DELAYS.short);
+  }
+};
+
+// src/analytics/RpcAnalyticsApi.ts
+var RpcAnalyticsApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async recordCustomEvent(eventName, payload) {
+    console.log(
+      `[Venus SDK] [RpcAnalyticsApi] recordCustomEvent: ${eventName} payload:
+${JSON.stringify(payload, null, 2)}`
+    );
+    await this.rpcClient.call("H5_LOG_ANALYTICS_EVENT" /* LOG_ANALYTICS_EVENT */, {
+      eventName,
+      params: payload
+    });
+  }
+  async trackFunnelStep(stepNumber, stepName, funnelName) {
+    console.log(
+      `[Venus SDK] [RpcAnalyticsApi] trackFunnelStep: stepNumber: ${stepNumber} stepName: ${stepName} funnelName: ${funnelName}`
+    );
+    await this.rpcClient.call("H5_TRACK_FUNNEL_STEP" /* TRACK_FUNNEL_STEP */, {
+      stepNumber,
+      stepName,
+      funnelName
+    });
+  }
+};
+
+// src/analytics/index.ts
+function initializeAnalytics(venusApiInstance, host) {
+  venusApiInstance.logCustomEvent = async (options) => {
+    await host.analytics.recordCustomEvent(
+      options.eventName,
+      options.params
+    );
+  };
+  venusApiInstance.analytics = host.analytics;
+}
+
+// src/avatar3d/MockAvatarApi.ts
+var MockAvatarApi = class {
+  constructor(venusApi) {
+    __publicField(this, "_venusApi");
+    __publicField(this, "cachedAssets", null);
+    __publicField(this, "cachedVersion", "");
+    this._venusApi = venusApi;
+  }
+  downloadAssetPaths() {
+    console.log("[Venus Mock] Downloading avatar3d asset paths...");
+    return this.getAllAssetPaths();
+  }
+  async deleteAvatar() {
+    console.log(`[Venus Mock] Deleting avatar3d config`);
+    const venusApi = this._venusApi;
+    const currentProfile = venusApi.getCurrentProfile();
+    const profileId = currentProfile?.id || "default_profile";
+    localStorage.removeItem(`venus-mock-avatar3d-${profileId}`);
+    console.log(
+      `[Venus Mock] Avatar3d config deleted from localStorage for profile: ${profileId}`
+    );
+  }
+  async loadAvatar(avatar3dId) {
+    console.log(`[Venus Mock] Loading avatar3d`, { avatar3dId });
+    const venusApi = this._venusApi;
+    let config;
+    if (avatar3dId) {
+      console.log(`[Venus Mock] Loading shared avatar3d by ID: ${avatar3dId}`);
+      config = await this.selectAvatarConfig(avatar3dId, false);
+    } else {
+      const currentProfile = venusApi.getCurrentProfile();
+      const profileId = currentProfile?.id || "default_profile";
+      console.log(`[Venus Mock] Loading avatar3d for profile: ${profileId}`);
+      console.log(
+        "[Venus Mock] Generating fresh avatar config with current CDN URLs"
+      );
+      if (profileId === "default_profile") {
+        config = await this.selectAvatarConfig(null, true);
+      } else {
+        config = await this.selectAvatarConfig(profileId, false);
+      }
+    }
+    return config || null;
+  }
+  async saveAvatar(config) {
+    console.log(`[Venus Mock] Saving avatar3d config:`, config);
+    const venusApi = this._venusApi;
+    const currentProfile = venusApi.getCurrentProfile();
+    const profileId = currentProfile?.id || "default_profile";
+    localStorage.setItem(
+      `venus-mock-avatar3d-${profileId}`,
+      JSON.stringify(config)
+    );
+    const mockAvatar3dId = `mock_avatar3d_${profileId}_${Date.now()}`;
+    console.log(
+      `[Venus Mock] Avatar3d config saved to localStorage with mock ID: ${mockAvatar3dId}`
+    );
+    return mockAvatar3dId;
+  }
+  downloadManifest() {
+    return this.loadAssetsManifest();
+  }
+  async showEditor(options) {
+    console.log(
+      `[Venus Mock] showAvatar3dEditorAsync called with options:`,
+      options
+    );
+    if (window.VenusPrototyping) {
+      return new Promise((resolve) => {
+        window.VenusPrototyping.showAvatarEditorOverlay(options, resolve);
+      });
+    }
+    console.log("[Venus Mock] Simulating avatar editor opening...");
+    await createMockDelay(MOCK_DELAYS.medium);
+    const mockAvatarConfig = await this.selectAvatarConfig(null, false);
+    const userSavedChanges = Math.random() > 0.3;
+    console.log(
+      "[Venus Mock] Avatar editor simulation complete - user would use requestPopOrQuit() with result data"
+    );
+    if (userSavedChanges) {
+      const mockAvatarId = `mock_avatar_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+      return {
+        wasChanged: true,
+        config: mockAvatarConfig,
+        savedAvatarId: mockAvatarId
+      };
+    } else {
+      return {
+        wasChanged: false,
+        config: null,
+        savedAvatarId: null
+      };
+    }
+  }
+  async getAssets() {
+    let cachedAssets = this.cachedAssets;
+    if (!cachedAssets) {
+      this.log("No cached assets found, loading new manifest...");
+      cachedAssets = (await this.loadAssetsManifest()).categories;
+    }
+    return cachedAssets;
+  }
+  async loadAssetsManifest() {
+    this.log("Loading avatar3d assets manifest from CDN...");
+    const venusApi = this._venusApi;
+    const baseManifestUrl = venusApi.resolveAvatarAssetUrl("assets.json");
+    const separator = baseManifestUrl.includes("?") ? "&" : "?";
+    const manifestUrl = `${baseManifestUrl}${separator}v=${Date.now()}`;
+    console.log("[Venus Mock] Fetching manifest from URL:", manifestUrl);
+    try {
+      const response = await fetch(manifestUrl, {
+        method: "GET",
+        headers: {
+          Accept: "application/json, text/plain, */*",
+          "Content-Type": "application/json"
+        },
+        mode: "cors",
+        cache: "no-cache"
+      });
+      console.log(
+        "[Venus Mock] Fetch response status:",
+        response.status,
+        response.statusText
+      );
+      console.log(
+        "[Venus Mock] Response headers:",
+        Object.fromEntries(response.headers.entries())
+      );
+      if (!response.ok) {
+        throw new Error(
+          `Failed to fetch assets manifest: ${response.status} ${response.statusText}`
+        );
+      }
+      const manifest = await response.json();
+      console.log("[Venus Mock] Loaded assets manifest:", {
+        version: manifest.version,
+        generatedAt: manifest.generatedAt,
+        categories: Object.keys(manifest.categories || {})
+      });
+      this.cachedAssets = manifest.categories || {};
+      this.cachedVersion = manifest.version;
+      return manifest;
+    } catch (error) {
+      console.error("[Venus Mock] Failed to load assets manifest:", error);
+      console.log(
+        "[Venus Mock] Using fallback minimal manifest for development"
+      );
+      const fallbackManifest = {
+        version: "dev-fallback",
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        categories: {
+          head: {
+            type: "mesh",
+            assets: [
+              {
+                id: "head_default",
+                filename: "head_default.glb",
+                displayName: "Default Head"
+              },
+              {
+                id: "head_variant1",
+                filename: "head_variant1.glb",
+                displayName: "Head Variant 1"
+              }
+            ]
+          },
+          outfit: {
+            type: "mesh",
+            assets: [
+              {
+                id: "outfit_default",
+                filename: "outfit_default.glb",
+                displayName: "Default Outfit"
+              },
+              {
+                id: "outfit_casual",
+                filename: "outfit_casual.glb",
+                displayName: "Casual Outfit"
+              }
+            ]
+          },
+          hat: {
+            type: "mesh",
+            assets: [
+              {
+                id: "hat_none",
+                filename: "hat_none.glb",
+                displayName: "No Hat"
+              },
+              {
+                id: "hat_cap",
+                filename: "hat_cap.glb",
+                displayName: "Baseball Cap"
+              }
+            ]
+          },
+          hair: {
+            type: "mesh",
+            assets: [
+              {
+                id: "hair_default",
+                filename: "hair_default.glb",
+                displayName: "Default Hair"
+              },
+              {
+                id: "hair_long",
+                filename: "hair_long.glb",
+                displayName: "Long Hair"
+              }
+            ]
+          },
+          "face-accessory": {
+            type: "mesh",
+            assets: [
+              {
+                id: "glasses_none",
+                filename: "glasses_none.glb",
+                displayName: "No Glasses"
+              },
+              {
+                id: "glasses_regular",
+                filename: "glasses_regular.glb",
+                displayName: "Regular Glasses"
+              }
+            ]
+          },
+          animation: {
+            type: "mesh",
+            assets: [
+              {
+                id: "idle_default",
+                filename: "idle_default.glb",
+                displayName: "Default Idle"
+              },
+              {
+                id: "wave",
+                filename: "wave.glb",
+                displayName: "Wave Animation"
+              }
+            ]
+          }
+        }
+      };
+      this.cachedAssets = fallbackManifest.categories;
+      this.cachedVersion = fallbackManifest.version;
+      return fallbackManifest;
+    }
+  }
+  async selectAvatarConfig(avatarId = null, useDefaults = false) {
+    const categories = await this.getAssets();
+    this.log(`Manifest ${JSON.stringify(categories, null, 2)}`);
+    const rng = avatarId ? this.seededRandom(avatarId) : () => Math.random();
+    const headAsset = this.selectAsset(
+      categories,
+      "head",
+      rng,
+      avatarId,
+      useDefaults
+    );
+    const outfitAsset = this.selectAsset(
+      categories,
+      "outfit",
+      rng,
+      avatarId,
+      useDefaults
+    );
+    const hatAsset = this.selectAsset(
+      categories,
+      "hat",
+      rng,
+      avatarId,
+      useDefaults
+    );
+    const hairAsset = this.selectAsset(
+      categories,
+      "hair",
+      rng,
+      avatarId,
+      useDefaults
+    );
+    const faceAccessoryAsset = this.selectAsset(
+      categories,
+      "face-accessory",
+      rng,
+      avatarId,
+      useDefaults
+    );
+    const animationAsset = this.selectAsset(
+      categories,
+      "animation",
+      rng,
+      avatarId,
+      useDefaults
+    );
+    const config = {
+      headAsset: headAsset.filename,
+      outfitAsset: outfitAsset.filename,
+      animationAsset: animationAsset.filename,
+      faceAccessoryAsset: faceAccessoryAsset.filename,
+      hairAsset: hairAsset.filename,
+      hatAsset: hatAsset.filename,
+      skinColor: null
+      // NOTE(Zee): This was not selected anywhere?
+    };
+    console.log(
+      `[Venus Mock] Selected avatar config for ${avatarId || "default"}:`,
+      config
+    );
+    return config;
+  }
+  selectAsset(manifest, categoryId, rng, avatarId, useDefaults = false) {
+    const categoryAssets = manifest[categoryId].assets;
+    if (useDefaults) {
+      const selectedAsset2 = categoryAssets[0];
+      console.log(
+        `[Venus Mock] Using default asset for ${categoryId}:`,
+        selectedAsset2.id
+      );
+      return selectedAsset2;
+    }
+    if (avatarId) {
+      const index = Math.floor(rng() * categoryAssets.length);
+      const selectedAsset2 = categoryAssets[index];
+      console.log(
+        `[Venus Mock] Seeded selection for ${avatarId} ${categoryId}:`,
+        selectedAsset2.id,
+        `(index ${index}/${categoryAssets.length})`
+      );
+      return selectedAsset2;
+    }
+    const selectedAsset = categoryAssets[0];
+    this.log(`Fallback to first asset for ${categoryId}:`, selectedAsset.id);
+    return selectedAsset;
+  }
+  seededRandom(seed) {
+    const hash = this.simpleHash(seed);
+    let state = hash;
+    return function() {
+      state = (state * 1664525 + 1013904223) % 4294967296;
+      return state / 4294967296;
+    };
+  }
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash);
+  }
+  async getAllAssetPaths() {
+    const venusApi = this._venusApi;
+    const assets = await this.getAssets();
+    const allPaths = {};
+    for (const [category, categoryData] of Object.entries(assets)) {
+      allPaths[category] = (categoryData?.assets || []).map(
+        (asset) => venusApi.resolveAvatarAssetUrl(`${category}/${asset.filename}`)
+      );
+    }
+    this.log("All available asset paths:", allPaths);
+    return allPaths;
+  }
+  log(message, ...args) {
+    console.log(`"[Venus Mock] ${message}`, args);
+  }
+};
+
+// src/avatar3d/RpcAvatarApi.ts
+var RpcAvatarApi = class {
+  constructor(rpcClient, venusApi) {
+    __publicField(this, "venusApi");
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+    this.venusApi = venusApi;
+  }
+  async downloadAssetPaths() {
+    const venusApi = this.venusApi;
+    console.log("[Venus] Downloading avatar3d asset paths...");
+    const manifestUrl = venusApi.resolveAvatarAssetUrl("assets.json");
+    console.log("[Venus] \u{1F50D} Manifest URL resolved to:", manifestUrl);
+    const manifest = await this.fetchFromCdn(manifestUrl);
+    console.log("[Venus] \u{1F4E6} Manifest loaded successfully:", {
+      version: manifest.version,
+      categories: Object.keys(manifest.categories || {}),
+      totalAssets: Object.values(manifest.categories || {}).reduce(function(sum, cat) {
+        return sum + (cat.assets?.length || 0);
+      }, 0)
+    });
+    const categories = manifest.categories || {};
+    const assetPaths = {};
+    for (const categoryKey in categories) {
+      const categoryData = categories[categoryKey];
+      const categoryPath = categoryKey;
+      const assetUrls = (categoryData?.assets || []).map((asset) => {
+        const url = venusApi.resolveAvatarAssetUrl(
+          categoryPath + "/" + asset.filename
+        );
+        console.log("[Venus] \u{1F3A8} Asset URL:", asset.filename, "->", url);
+        return url;
+      });
+      assetPaths[categoryKey] = assetUrls;
+      console.log(
+        "[Venus] \u{1F4C1} Category",
+        categoryKey,
+        "has",
+        assetUrls.length,
+        "assets"
+      );
+    }
+    console.log("[Venus] Avatar3d asset paths downloaded successfully");
+    return assetPaths;
+  }
+  async downloadManifest() {
+    console.log("[Venus] Downloading avatar3d manifest...");
+    const venusApi = this.venusApi;
+    const manifestUrl = venusApi.resolveAvatarAssetUrl("assets.json");
+    const manifest = await this.fetchFromCdn(manifestUrl);
+    console.log("[Venus] Avatar3d manifest downloaded successfully");
+    return manifest;
+  }
+  async loadAvatar(avatarId) {
+    const result = await this.rpcClient.call("H5_AVATAR3D_LOAD" /* AVATAR3D_LOAD */, {
+      avatar3dId: avatarId
+    });
+    this.log(
+      `Avatar loaded with the following result:
+${JSON.stringify(result, null, 2)}`
+    );
+    return result;
+  }
+  saveAvatar(config) {
+    return this.rpcClient.call("H5_AVATAR3D_SAVE" /* AVATAR3D_SAVE */, {
+      config
+    });
+  }
+  deleteAvatar() {
+    return this.rpcClient.call("H5_AVATAR3D_DELETE" /* AVATAR3D_DELETE */);
+  }
+  async showEditor(options) {
+    const rpcClient = this.rpcClient;
+    console.log(
+      "[Venus] \u{1F3A8} showAvatar3dEditorAsync called with options:",
+      options
+    );
+    console.log(
+      "[Venus] \u{1F4E4} Sending H5_STACK_PUSH_REQUEST for avatar3d using _sendRequest..."
+    );
+    const rawResult = await rpcClient.call(
+      "H5_STACK_PUSH_REQUEST" /* H5_STACK_PUSH_REQUEST */,
+      {
+        targetAppId: "AVATAR3D",
+        contextData: options?.contextData || {},
+        appParams: {
+          currentAvatar: options?.currentAvatar,
+          onSave: options?.onSave,
+          onCancel: options?.onCancel
+        }
+      }
+    );
+    console.log(
+      "[Venus] \u2705 Avatar editor completed with raw result:",
+      rawResult
+    );
+    return {
+      wasChanged: rawResult.wasChanged || false,
+      config: rawResult.config || null,
+      savedAvatarId: rawResult.savedAvatarId || null
+    };
+  }
+  async fetchFromCdn(url) {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json, text/plain, */*",
+        "Content-Type": "application/json"
+      },
+      mode: "cors",
+      cache: "no-cache"
+    });
+    if (!response.ok) {
+      throw new Error(
+        `CDN fetch failed: ${response.status} ${response.statusText}`
+      );
+    }
+    return await response.json();
+  }
+  log(message, ...options) {
+    console.log(`[Venus] ${message}`, options);
+  }
+};
+
+// src/avatar3d/index.ts
+function initializeAvatar3d(venusApi, host) {
+  venusApi.loadAvatar3dAsync = host.avatar3d.loadAvatar.bind(host.avatar3d);
+  venusApi.saveAvatar3dAsync = host.avatar3d.saveAvatar.bind(host.avatar3d);
+  venusApi.deleteAvatar3dAsync = host.avatar3d.deleteAvatar.bind(host.avatar3d);
+  venusApi.downloadAvatar3dManifestAsync = host.avatar3d.downloadManifest.bind(
+    host.avatar3d
+  );
+  venusApi.showAvatar3dEditorAsync = host.avatar3d.showEditor.bind(
+    host.avatar3d
+  );
+  venusApi.downloadAvatar3dAssetPathsAsync = host.avatar3d.downloadAssetPaths.bind(host.avatar3d);
+}
+
+// src/cdn/HostCdnApi.ts
+var HostCdnApi = class {
+  constructor(baseUrl) {
+    __publicField(this, "baseUrl");
+    this.baseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  }
+  async fetchBlob(path, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      options?.timeout ?? 3e4
+    );
+    try {
+      const url = this.resolveAssetUrl(path);
+      const response = await fetch(url, {
+        mode: "cors",
+        credentials: "omit",
+        headers: { Accept: "/*" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return await response.blob();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  async fetchFromCdn(url, request) {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Accept: "application/json, text/plain, */*",
+        "Content-Type": "application/json"
+      },
+      mode: "cors",
+      cache: "no-cache"
+    });
+    if (!response.ok) {
+      throw new Error(
+        `CDN fetch failed: \${response.status} \${response.statusText}`
+      );
+    }
+    return response;
+  }
+  getAssetCdnBaseUrl() {
+    return this.baseUrl;
+  }
+  resolveAssetUrl(subPath) {
+    const cleanSubPath = subPath.startsWith("/") ? subPath.slice(1) : subPath;
+    const pathParts = cleanSubPath.split("/");
+    const encodedParts = pathParts.map((part, index) => {
+      return index === pathParts.length - 1 ? encodeURIComponent(part) : part;
+    });
+    const encodedSubPath = encodedParts.join("/");
+    const fullUrl = this.baseUrl + "/" + encodedSubPath;
+    return fullUrl;
+  }
+  resolveAvatarAssetUrl(subPath) {
+    const avatarSubPath = "avatar3d/" + subPath;
+    return this.resolveAssetUrl(avatarSubPath);
+  }
+  resolveSharedLibUrl(subPath) {
+    const libSubPath = "libs/" + subPath;
+    return this.resolveAssetUrl(libSubPath);
+  }
+};
+
+// src/cdn/MockCdnApi.ts
+var MockCdnApi = class {
+  constructor() {
+    __publicField(this, "baseUrl");
+    this.baseUrl = "https://venus-static-01293ak.web.app/";
+  }
+  async fetchBlob(path, options) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      options?.timeout ?? 3e4
+    );
+    try {
+      const url = this.resolveAssetUrl(path);
+      const response = await fetch(url, {
+        mode: "cors",
+        credentials: "omit",
+        headers: { Accept: "/*" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return await response.blob();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  getAssetCdnBaseUrl() {
+    return this.baseUrl;
+  }
+  resolveAssetUrl(subPath) {
+    if (subPath.startsWith("http://") || subPath.startsWith("https://")) {
+      return subPath;
+    }
+    if (subPath.startsWith("cdn/")) {
+      return subPath;
+    }
+    const cleanSubPath = subPath.startsWith("/") ? subPath.slice(1) : subPath;
+    const pathParts = cleanSubPath.split("/");
+    const encodedParts = pathParts.map((part, index) => {
+      return index === pathParts.length - 1 ? encodeURIComponent(part) : part;
+    });
+    const encodedSubPath = encodedParts.join("/");
+    const fullUrl = `${this.baseUrl}${encodedSubPath}`;
+    return fullUrl;
+  }
+  resolveAvatarAssetUrl(subPath) {
+    if (subPath.startsWith("http://") || subPath.startsWith("https://")) {
+      return subPath;
+    }
+    const avatarSubPath = `avatar3d/${subPath}`;
+    return this.resolveAssetUrl(avatarSubPath);
+  }
+  resolveSharedLibUrl(subPath) {
+    if (subPath.startsWith("http://") || subPath.startsWith("https://")) {
+      return subPath;
+    }
+    const libSubPath = `libs/${subPath}`;
+    return this.resolveAssetUrl(libSubPath);
+  }
+  async fetchFromCdn(url, options) {
+    const allowedDomains = [
+      "venus-static-01293ak.web.app",
+      "firebasestorage.googleapis.com",
+      "cdn.venusapp.com",
+      "storage.googleapis.com"
+    ];
+    let urlObj = null;
+    try {
+      let isAllowed = true;
+      if (url.startsWith("http://") || url.startsWith("https://")) {
+        urlObj = new URL(url);
+        isAllowed = allowedDomains.some(
+          (domain) => urlObj.hostname === domain || urlObj.hostname.endsWith("." + domain)
+        );
+        if (!isAllowed) {
+          const error = `Domain not allowed: ${urlObj.hostname}. Allowed domains: ${allowedDomains.join(", ")}`;
+          console.error("[Venus Network Mock] Security error:", error);
+          throw new Error(error);
+        }
+      } else {
+        urlObj = null;
+      }
+      const fetchUrl = urlObj ? urlObj.href : url;
+      const response = await fetch(fetchUrl, {
+        method: options?.method || "GET",
+        headers: {
+          Accept: "text/plain, application/octet-stream, application/json, */*",
+          ...options?.headers
+        },
+        cache: options?.cache || "default",
+        mode: "cors"
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return response;
+    } catch (error) {
+      if (error instanceof Error && error.message && (error.message.includes("CORS") || error.message.includes("preflight") || error.message.includes("Access-Control") || error.message.includes("cache-control"))) {
+        try {
+          const fallbackUrl = urlObj ? urlObj.href : url;
+          const fallbackResponse = await fetch(fallbackUrl, {
+            method: "GET",
+            mode: "cors",
+            cache: "default"
+          });
+          if (!fallbackResponse.ok) {
+            throw new Error(
+              `HTTP ${fallbackResponse.status}: ${fallbackResponse.statusText}`
+            );
+          }
+          const fallbackText = await fallbackResponse.text();
+          return fallbackResponse;
+        } catch (fallbackError) {
+          console.error(
+            "[Venus Network Mock] CORS fallback also failed (from network.js):",
+            {
+              url,
+              originalError: error.message,
+              fallbackError,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          );
+          throw new Error(
+            `CORS error: ${error.message}. Fallback also failed: ${fallbackError}`
+          );
+        }
+      }
+      console.error("[Venus Network Mock] Fetch failed (from network.js):", {
+        url,
+        error,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      throw error;
+    }
+  }
+};
+
+// src/cdn/index.ts
+function initializeCdn(venusApi, host) {
+  venusApi.resolveAssetUrl = function(subPath) {
+    return host.cdn.resolveAssetUrl(subPath);
+  };
+  venusApi.resolveAvatarAssetUrl = function(subPath) {
+    return host.cdn.resolveAvatarAssetUrl(subPath);
+  };
+  venusApi.resolveSharedLibUrl = function(subPath) {
+    return host.cdn.resolveSharedLibUrl(subPath);
+  };
+  venusApi.getAssetCdnBaseUrl = function() {
+    return host.cdn.getAssetCdnBaseUrl();
+  };
+  venusApi.fetchFromCdn = (url, options) => {
+    return host.cdn.fetchFromCdn(url, options);
+  };
+  venusApi.cdn = host.cdn;
+}
+
+// src/features/RpcFeaturesApi.ts
+var RpcFeaturesApi = class {
+  constructor(rcpClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rcpClient;
+  }
+  async getExperiment(experimentName) {
+    console.log("[Venus] Getting Experiment", experimentName);
+    return await this.rpcClient.call("H5_GET_EXPERIMENT" /* GET_EXPERIMENT */, {
+      experimentName
+    });
+  }
+  async getFeatureFlag(flagName) {
+    console.log("[Venus] Getting Feature Flag", flagName);
+    return await this.rpcClient.call("H5_GET_FEATURE_FLAG" /* GET_FEATURE_FLAG */, {
+      flagName
+    });
+  }
+  async getFeatureGate(gateName) {
+    console.log("[Venus] Getting Feature Gate", gateName);
+    return await this.rpcClient.call("H5_GET_FEATURE_GATE" /* GET_FEATURE_GATE */, {
+      gateName
+    });
+  }
+};
+
+// src/features/MockFeaturesApi.ts
+var MockFeaturesApi = class {
+  async getExperiment(experimentName) {
+    return null;
+  }
+  async getFeatureFlag(flagName) {
+    return Promise.resolve(false);
+  }
+  getFeatureGate(gateName) {
+    return Promise.resolve(false);
+  }
+};
+
+// src/features/index.ts
+function initializeFeaturesApi(venusApi, host) {
+  venusApi.getExperiment = (options) => {
+    return host.features.getExperiment(options.experimentName);
+  };
+  venusApi.getFeatureGate = (options) => {
+    return host.features.getFeatureGate(options.gateName);
+  };
+  venusApi.getFeatureFlag = (options) => {
+    return host.features.getFeatureFlag(options.flagName);
+  };
+}
+
+// src/haptics/HapticsApi.ts
+var HapticFeedbackStyle = /* @__PURE__ */ ((HapticFeedbackStyle2) => {
+  HapticFeedbackStyle2["Light"] = "light";
+  HapticFeedbackStyle2["Medium"] = "medium";
+  HapticFeedbackStyle2["Heavy"] = "heavy";
+  HapticFeedbackStyle2["Success"] = "success";
+  HapticFeedbackStyle2["Warning"] = "warning";
+  HapticFeedbackStyle2["Error"] = "error";
+  return HapticFeedbackStyle2;
+})(HapticFeedbackStyle || {});
+
+// src/haptics/RpcHapticsApi.ts
+var RpcHapticsApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async triggerHapticAsync(style) {
+    await this.rpcClient.call("H5_TRIGGER_HAPTIC" /* TRIGGER_HAPTIC */, {
+      style
+    });
+  }
+};
+
+// src/haptics/MockHapticsApi.ts
+var MockHapticsApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  async triggerHapticAsync(style) {
+    const venusApi = this.venusApi;
+    if (!venusApi._mock.device.supportsHaptics) {
+      return;
+    }
+  }
+};
+
+// src/haptics/index.ts
+function initializeHaptics(venusApi, host) {
+  venusApi.triggerHapticAsync = (style) => {
+    return host.haptics.triggerHapticAsync(style);
+  };
+}
+
+// src/iap/RpcIapApi.ts
+var RpcIapApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async getHardCurrencyBalance() {
+    const response = await this.rpcClient.call(
+      "H5_IAP_GET_WALLET" /* H5_IAP_GET_WALLET */
+    );
+    return response;
+  }
+  async spendCurrency(productId, cost, options) {
+    const result = await this.rpcClient.callT("H5_IAP_SPEND_CURRENCY" /* H5_IAP_SPEND_CURRENCY */, {
+      amount: cost,
+      productId,
+      screenName: options?.screenName
+    });
+    if (!result.success) {
+      throw new Error(result.error);
+    }
+  }
+};
+
+// src/iap/MockIapApi.ts
+var MockIapApi = class {
+  constructor() {
+    __publicField(this, "_hardCurrency", 100);
+  }
+  get hardCurrency() {
+    return this._hardCurrency;
+  }
+  set hardCurrency(value) {
+    this._hardCurrency = value;
+  }
+  async spendCurrency(productId, cost, options) {
+    console.log(`[Mock IAP] Spending ${cost} on ${productId})`);
+    const remainingHardCurrency = this._hardCurrency - cost;
+    if (remainingHardCurrency < 0) {
+      throw new Error(
+        `Not enough hard currency. Expected ${cost}, found ${this._hardCurrency}`
+      );
+    }
+    this._hardCurrency = remainingHardCurrency;
+  }
+  async getHardCurrencyBalance() {
+    console.log("[Mock IAP] get hard currency called");
+    return this._hardCurrency;
+  }
+};
+
+// src/iap/index.ts
+function initializeIap(venusApiInstance, host) {
+  venusApiInstance.iap = host.iap;
+}
+
+// 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);
+  }
+  onHide(callback) {
+    this.hideCallbacks.push(callback);
+  }
+  onPause(callback) {
+    this.pauseCallbacks.push(callback);
+  }
+  onPlay(callback) {
+    this.playCallbacks.push(callback);
+  }
+  onQuit(callback) {
+    this.quitCallbacks.push(callback);
+  }
+  onResume(callback) {
+    this.resumeCallbacks.push(callback);
+  }
+  triggerOnPlayCallbacks(context) {
+    for (const callback of this.playCallbacks) {
+      callback(context);
+    }
+  }
+  triggerOnPauseCallbacks() {
+    for (const callback of this.pauseCallbacks) {
+      callback();
+    }
+  }
+  triggerOnResumeCallbacks() {
+    for (const callback of this.resumeCallbacks) {
+      callback();
+    }
+  }
+  triggerOnShowCallbacks(context) {
+    for (const callback of this.showCallbacks) {
+      callback(context);
+    }
+  }
+  triggerOnHideCallbacks() {
+    for (const callback of this.hideCallbacks) {
+      callback();
+    }
+  }
+  triggerOnQuitCallbacks() {
+    for (const callback of this.quitCallbacks) {
+      callback();
+    }
+  }
+};
+
+// src/lifecycles/RpcLifecycleApi.ts
+var RpcLifecycleApi = class {
+  constructor(rpcClient) {
+    __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);
+  }
+  onPlay(callback) {
+    this.rpcClient.onNotification("PLAY" /* PLAY */, callback);
+  }
+  onQuit(callback) {
+    this.rpcClient.onNotification("QUIT" /* QUIT */, callback);
+  }
+  onResume(callback) {
+    this.rpcClient.onNotification("RESUME" /* RESUME */, callback);
+  }
+  onShow(callback) {
+    this.rpcClient.onNotification("SHOWN" /* SHOWN */, 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);
+  };
+}
+
+// src/logging/MockLoggingApi.ts
+var MockLoggingApi = class {
+  logDebug(message, ...args) {
+    console.log(`[Venus Mock] ${message}`, args);
+  }
+  logError(message, ...args) {
+    console.error(`[Venus Mock] ${message}`, args);
+  }
+};
+
+// src/logging/RpcLoggingApi.ts
+var RpcLoggingApi = class {
+  constructor(host, rpcClient) {
+    __publicField(this, "host");
+    __publicField(this, "rpcClient");
+    this.host = host;
+    this.rpcClient = rpcClient;
+  }
+  logDebug(message, ...args) {
+    if (!this.host.isInitialized) {
+      console.log(message, args);
+    } else {
+      message = this.buildMessage(message, ...args);
+      this.rpcClient.call("H5_DEBUG" /* DEBUG */, { level: "log", message });
+    }
+  }
+  logError(message, ...args) {
+    if (!this.host.isInitialized) {
+      console.log(message, ...args);
+    } else {
+      message = this.buildMessage(message, ...args);
+      this.rpcClient.call("H5_DEBUG" /* DEBUG */, {
+        level: "error",
+        message
+      });
+    }
+  }
+  buildMessage(message, ...args) {
+    if (args && args.length > 0) {
+      const stringArgs = [];
+      for (const arg of args) {
+        const argAsString = this.toStringArg(arg);
+        if (argAsString) {
+          stringArgs.push(argAsString);
+        }
+      }
+      message += stringArgs.join(" ");
+    }
+    return message;
+  }
+  toStringArg(arg) {
+    if (arg) {
+      if (typeof arg === "object") {
+        try {
+          return JSON.stringify(arg);
+        } catch (e) {
+          return String(arg);
+        }
+      }
+      return String(arg);
+    }
+    return void 0;
+  }
+};
+
+// src/logging/index.ts
+function initializeLoggingApi(venusApi, host) {
+  venusApi.log = (message, ...args) => {
+    return host.logging.logDebug(message, ...args);
+  };
+  venusApi.error = (message, ...args) => {
+    return host.logging.logError(message, ...args);
+  };
+}
+
+// src/navigation/MockNavigationApi.ts
+var MockNavigationApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  async requestPopOrQuit(options) {
+    return true;
+  }
+  getStackInfo() {
+    const venusApi = this.venusApi;
+    const info = {
+      isInStack: venusApi._mock.stackState.isInStack,
+      stackPosition: venusApi._mock.stackState.stackPosition,
+      isTopOfStack: venusApi._mock.stackState.isTopOfStack,
+      stackDepth: venusApi._mock.stackState.stackDepth,
+      parentInstanceId: venusApi._mock.stackState.parentInstanceId
+    };
+    return info;
+  }
+  async popApp() {
+    const venusApi = this.venusApi;
+    if (venusApi._mock.stackState.stackDepth <= 1) {
+      console.warn("[Venus Mock] Cannot pop - at base of stack or not in stack");
+      return;
+    }
+    await createMockDelay(MOCK_DELAYS.short);
+    const poppedApp = venusApi._mock.stackState.stackHistory.pop();
+    venusApi._mock.stackState.stackDepth--;
+    venusApi._mock.stackState.stackPosition = Math.max(
+      0,
+      venusApi._mock.stackState.stackDepth - 1
+    );
+    if (venusApi._mock.stackState.stackDepth === 0) {
+      venusApi._mock.stackState.isInStack = false;
+      venusApi._mock.stackState.isTopOfStack = false;
+      venusApi._mock.stackState.parentInstanceId = null;
+    }
+    this.log("App popped: ", poppedApp);
+  }
+  async pushApp(appId, options) {
+    const venusApi = this.venusApi;
+    await createMockDelay(MOCK_DELAYS.medium);
+    venusApi._mock.stackState.stackHistory.push({
+      appId,
+      pushedAt: Date.now(),
+      contextData: options?.contextData,
+      appParams: options?.appParams
+    });
+    venusApi._mock.stackState.isInStack = true;
+    venusApi._mock.stackState.stackDepth++;
+    venusApi._mock.stackState.stackPosition = venusApi._mock.stackState.stackDepth - 1;
+    venusApi._mock.stackState.isTopOfStack = true;
+    const pushedInstanceId = `mock-stack-${appId}-${Date.now()}`;
+    this.log("PushedInstanceId: ", pushedInstanceId);
+  }
+  log(message, ...args) {
+    console.log(`[Venus Mock] ${message}`, ...args);
+  }
+};
+
+// src/navigation/RpcNavigationApi.ts
+var RpcNavigationApi = class {
+  constructor(rpcClient, venusApi) {
+    __publicField(this, "venusApi");
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+    this.venusApi = venusApi;
+  }
+  async requestPopOrQuit(options) {
+    const result = await this.rpcClient.call(
+      "QUIT" /* QUIT */,
+      options
+    );
+    return result.success;
+  }
+  getStackInfo() {
+    this.venusApi;
+    console.log("[Venus] getStackInfo called");
+    const config = window.venus._config;
+    const stackInfo = config.context?.stack || {
+      isInStack: false,
+      stackPosition: 0,
+      parentInstanceId: null,
+      appType: "standalone"
+    };
+    return stackInfo;
+  }
+  popApp() {
+    const rpcClient = this.rpcClient;
+    console.log("[Venus] popAppAsync called");
+    return rpcClient.call("H5_STACK_POP_REQUEST" /* H5_STACK_POP_REQUEST */);
+  }
+  pushApp(appId, options) {
+    const rpcClient = this.rpcClient;
+    console.log("[Venus] pushAppAsync called", { appId, options });
+    return rpcClient.call("H5_STACK_PUSH_REQUEST" /* H5_STACK_PUSH_REQUEST */, {
+      targetAppId: appId,
+      contextData: options?.contextData,
+      appParams: options?.appParams
+    });
+  }
+};
+
+// src/navigation/index.ts
+function initializeStackNavigation(venusApi, host) {
+  venusApi._mock.stackState = {
+    isInStack: false,
+    stackPosition: 0,
+    stackDepth: 0,
+    isTopOfStack: false,
+    parentInstanceId: null,
+    stackHistory: []
+    // Track navigation history for mock
+  };
+  venusApi.pushAppAsync = host.navigation.pushApp.bind(host.navigation);
+  venusApi.popAppAsync = host.navigation.popApp.bind(host.navigation);
+  venusApi.getStackInfo = host.navigation.getStackInfo.bind(host.navigation);
+  venusApi.requestPopOrQuit = (options) => {
+    return host.navigation.requestPopOrQuit(options);
+  };
+}
+
+// src/notifications/MockNotificationsApi.ts
+var MockNotificationsApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  async cancelLocalNotification(notificationId) {
+    const venusApi = this.venusApi;
+    if (isWebPlatform()) {
+      console.log(
+        "[Venus Mock] Cancel notification on web platform (simulated):",
+        notificationId
+      );
+      return true;
+    }
+    console.log("[Venus Mock] Cancel local notification:", notificationId);
+    await createMockDelay(MOCK_DELAYS.short);
+    if (venusApi._mock.scheduledNotifications && venusApi._mock.scheduledNotifications[notificationId]) {
+      delete venusApi._mock.scheduledNotifications[notificationId];
+      return true;
+    }
+    return false;
+  }
+  async getAllScheduledLocalNotifications() {
+    if (isWebPlatform()) {
+      console.log(
+        "[Venus Mock] Get notifications on web platform (returning empty list)"
+      );
+      return [];
+    }
+    console.log("[Venus Mock] Get all scheduled local notifications");
+    await createMockDelay(MOCK_DELAYS.short);
+    const venusApi = this.venusApi;
+    const notifications = venusApi._mock.scheduledNotifications || {};
+    return Object.values(notifications);
+  }
+  async isLocalNotificationsEnabled() {
+    if (isWebPlatform()) {
+      console.log("[Venus Mock] Notifications not available on web platform");
+      return false;
+    }
+    console.log("[Venus Mock] Check if local notifications are enabled");
+    await createMockDelay(MOCK_DELAYS.short);
+    const venusApi = this.venusApi;
+    const isEnabled = venusApi._mock.notificationsEnabled !== false;
+    return isEnabled;
+  }
+  async scheduleLocalNotification(title, body, 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:",
+        title || "Untitled",
+        "\n   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);
+    const venusApi = this.venusApi;
+    if (!venusApi._mock.pendingRequests) {
+      console.log("[Venus Mock] Initializing pendingRequests");
+      venusApi._mock.pendingRequests = {};
+    }
+    const requestId = Date.now().toString();
+    console.log("[Venus Mock] Creating request with ID:", requestId);
+    return new Promise((resolve) => {
+      venusApi._mock.pendingRequests[requestId] = { resolve };
+      const notificationId = `mock-notification-${Date.now()}`;
+      if (!venusApi._mock.scheduledNotifications) {
+        venusApi._mock.scheduledNotifications = {};
+      }
+      venusApi._mock.scheduledNotifications[notificationId] = {
+        ...options,
+        id: notificationId,
+        createdAt: Date.now()
+      };
+      setTimeout(() => {
+        resolve(notificationId);
+      }, MOCK_DELAYS.short);
+    });
+  }
+  async setLocalNotificationsEnabled(enabled) {
+    const venusApi = this.venusApi;
+    if (isWebPlatform()) {
+      console.log(
+        "[Venus Mock] Set notifications enabled on web platform (simulated):",
+        enabled
+      );
+      return true;
+    }
+    console.log("[Venus Mock] Set local notifications enabled:", enabled);
+    await createMockDelay(MOCK_DELAYS.short);
+    venusApi._mock.notificationsEnabled = enabled;
+    return enabled;
+  }
+};
+
+// src/notifications/index.ts
+function initializeLocalNotifications(venusApi, host) {
+  venusApi.setLocalNotifEnabledAsync = async (enable) => {
+    await host.notifications.setLocalNotificationsEnabled(enable);
+  };
+  venusApi.isLocalNotifEnabledAsync = async () => {
+    return host.notifications.isLocalNotificationsEnabled();
+  };
+  venusApi.getAllLocalNotifsAsync = async () => {
+    return host.notifications.getAllScheduledLocalNotifications();
+  };
+  venusApi.cancelLocalNotifAsync = async (notificationId) => {
+    await host.notifications.cancelLocalNotification(notificationId);
+  };
+  venusApi.scheduleLocalNotifAsync = async (options) => {
+    const id = await host.notifications.scheduleLocalNotification(
+      options.title,
+      options.body
+    );
+    if (id) {
+      return id;
+    }
+    return "";
+  };
+}
+
+// src/popups/RpcPopupsApi.ts
+var RpcPopupsApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async showActionSheet(items, options) {
+    const result = await this.rpcClient.call(
+      "H5_ACTION_SHEET_SHOW" /* ACTION_SHEET_SHOW */,
+      {
+        title: options?.title || "",
+        message: options?.message || "",
+        options: items,
+        cancelButtonText: options?.cancelButtonText || "Cancel"
+      }
+    );
+    return result;
+  }
+  async showAlert(title, message, options) {
+    const buttonText = options?.buttonText || "OK";
+    await this.rpcClient.call("H5_ALERT_DIALOG" /* ALERT_DIALOG */, {
+      title,
+      message,
+      buttonText
+    });
+  }
+  async showConfirm(title, message, options) {
+    const confirmText = options?.confirmText || "OK";
+    const cancelText = options?.cancelText || "Cancel";
+    const result = await this.rpcClient.call(
+      "H5_CONFIRM_DIALOG" /* CONFIRM_DIALOG */,
+      {
+        title,
+        message,
+        confirmText,
+        cancelText
+      }
+    );
+    return result;
+  }
+  async showToast(message, options) {
+    const duration = options?.duration ?? 3e3;
+    const variant = options?.variant ?? "info";
+    const response = await this.rpcClient.call(
+      "H5_TOAST" /* TOAST */,
+      {
+        message,
+        duration,
+        variant,
+        action: options?.action
+      },
+      duration + 2e3
+    );
+    return response.actionTriggered;
+  }
+};
+
+// src/popups/MockPopupsApi.ts
+var MockPopupsApi = class {
+  constructor(override) {
+    __publicField(this, "overlay");
+    this.overlay = override;
+  }
+  showActionSheet(items, options) {
+    console.log(
+      `[Venus Mock] Show Action sheet, items: ${JSON.stringify(items, null, 2)}, options: ${JSON.stringify(options, null, 2)}`
+    );
+    return this.overlay.showActionSheet(items, options);
+  }
+  async showAlert(title, message, options) {
+    window.alert(`${title}
+${message}`);
+  }
+  async showConfirm(title, message, options) {
+    const result = window.confirm(`${title || "Confirm"}
+${message}`);
+    return result;
+  }
+  async showToast(message, options) {
+    const variant = options?.variant ?? "info";
+    const duration = options?.duration ?? 3e3;
+    const action = options?.action;
+    console.log("[Venus Mock] Toast:", message, {
+      variant,
+      duration,
+      hasAction: !!action
+    });
+    if (action) {
+      const actionResult = window.confirm(
+        `${message}
+
+[${action.label}] or [Cancel]`
+      );
+      if (actionResult) {
+        console.log("[Venus Mock] Toast action triggered:", action.label);
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/popups/index.ts
+function initializePopups(venusApi, host) {
+  venusApi.showToast = async (input) => {
+    if (typeof input === "string") {
+      return await host.popups.showToast(input);
+    } else {
+      return await host.popups.showToast(input.message, {
+        duration: input.duration,
+        action: input.action,
+        variant: "success"
+      });
+    }
+  };
+  venusApi.showAlert = async (input) => {
+    await host.popups.showAlert(input.title, input.message, {
+      buttonText: input.buttonText
+    });
+  };
+  venusApi.showConfirm = async (input) => {
+    const confirmed = await host.popups.showConfirm(
+      input.title,
+      input.message,
+      {
+        confirmText: input.confirmText,
+        cancelText: input.cancelText
+      }
+    );
+    return confirmed;
+  };
+  venusApi.showActionSheet = async (input) => {
+    return await host.popups.showActionSheet(input.options, {
+      title: input.title,
+      message: input.message,
+      cancelButtonText: input.cancelButtonText,
+      disableCancel: input.disableCancel
+    });
+  };
+  venusApi.popups = host.popups;
+}
+
+// src/profile/HostProfileApi.ts
+var HostProfileApi = class {
+  getCurrentProfile() {
+    if (window.venus._config && window.venus._config.profile) {
+      return {
+        id: window.venus._config.profile.id || "unknown",
+        name: window.venus._config.profile.username || "Unknown User",
+        username: window.venus._config.profile.username || "unknown"
+      };
+    }
+    return {
+      id: "mock_profile_123",
+      name: "Mock User",
+      username: "mockuser"
+    };
+  }
+};
+
+// src/profile/MockProfileApi.ts
+var MockProfileApi = class {
+  getCurrentProfile() {
+    return {
+      id: "mock_profile_123",
+      name: "Mock User",
+      username: "mockuser"
+    };
+  }
+};
+
+// src/profile/index.ts
+function initializeProfile(venusApi, host) {
+  venusApi.getCurrentProfile = () => {
+    return host.profile.getCurrentProfile();
+  };
+}
+
+// src/rpc/RpcClient.ts
+var RpcClient = class {
+  constructor() {
+    __publicField(this, "pendingCalls", /* @__PURE__ */ new Map());
+    __publicField(this, "notificationCallbacks", /* @__PURE__ */ new Map());
+    __publicField(this, "onResponseSub", null);
+    __publicField(this, "onNotificationSub", null);
+    __publicField(this, "transport", null);
+  }
+  start(transport) {
+    this.transport = transport;
+    this.onResponseSub = transport.onResponse(async (response) => {
+      return this.handleRpcResponse(response);
+    });
+    this.onNotificationSub = transport.onNotification(async (notification) => {
+      return this.handleRpcNotification(notification);
+    });
+  }
+  stop() {
+    if (this.onResponseSub) {
+      this.onResponseSub.unsubscribe();
+      this.onResponseSub = null;
+    }
+    if (this.onNotificationSub) {
+      this.onNotificationSub.unsubscribe();
+      this.onNotificationSub = null;
+    }
+    this.transport = null;
+  }
+  onNotification(id, callback) {
+    this.notificationCallbacks.set(id, callback);
+    return {
+      unsubscribe: () => {
+        this.notificationCallbacks.delete(id);
+      }
+    };
+  }
+  callT(method, args, timeout = 5e3) {
+    return this.call(method, args, timeout);
+  }
+  async call(method, args, timeout = 5e3) {
+    return new Promise((resolve, reject) => {
+      const id = this.generateId();
+      this.addPendingCall(id, resolve, reject);
+      const request = {
+        type: "rpc-request",
+        id,
+        method,
+        args
+      };
+      if (this.transport) {
+        this.transport.sendRequest(request);
+      }
+      setTimeout(() => {
+        if (this.hasPendingCall(id)) {
+          this.removePendingCall(id);
+          reject(new Error(`RPC call ${method} timed out`));
+        }
+      }, timeout);
+    });
+  }
+  hasPendingCall(id) {
+    return this.pendingCalls.has(id);
+  }
+  addPendingCall(id, resolve, reject) {
+    this.pendingCalls.set(id, {
+      id,
+      resolve,
+      reject
+    });
+  }
+  removePendingCall(id) {
+    this.pendingCalls.delete(id);
+  }
+  getPendingCall(id) {
+    return this.pendingCalls.get(id);
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+  }
+  handleRpcResponse(response) {
+    const pending = this.getPendingCall(response.id);
+    if (!pending) {
+      return false;
+    }
+    this.removePendingCall(response.id);
+    if (response.error) {
+      pending.reject(new Error(response.error.message));
+      return true;
+    }
+    pending.resolve(response.result);
+    return true;
+  }
+  handleRpcNotification(notification) {
+    const callback = this.notificationCallbacks.get(notification.id);
+    if (callback) {
+      callback(notification.payload);
+    }
+  }
+};
+
+// src/storage/MockStorageApi.ts
+function createMockStorageApi(storageType, appUrl) {
+  const appIdentifier = appUrl ? generateAppIdentifier(appUrl) : null;
+  let prefix;
+  let syncDelay = 0;
+  switch (storageType) {
+    case "deviceCache":
+      prefix = "venus:app";
+      syncDelay = 0;
+      break;
+    case "appStorage":
+      prefix = "venus:app";
+      syncDelay = 100;
+      break;
+    case "globalStorage":
+      prefix = "venus:global";
+      syncDelay = 100;
+      break;
+    default:
+      throw new Error(`Unknown storage type: ${storageType}`);
+  }
+  prefix = storageType === "globalStorage" || !appIdentifier ? `${prefix}:` : `${prefix}:${appIdentifier}:`;
+  return new MockStorageApi(prefix, syncDelay);
+}
+var MockStorageApi = class {
+  constructor(prefix, syncDelay) {
+    __publicField(this, "prefix");
+    __publicField(this, "syncDelay");
+    this.prefix = prefix;
+    this.syncDelay = syncDelay;
+  }
+  async clear() {
+    const fullLength = localStorage.length;
+    for (let i = 0; i < fullLength; i++) {
+      const fullKey = localStorage.key(i);
+      if (fullKey && fullKey.startsWith(this.prefix)) {
+        localStorage.removeItem(fullKey);
+      }
+    }
+    await this.simulateSyncDelay();
+  }
+  async getAllItems() {
+    const items = new Array();
+    const fullLength = localStorage.length;
+    for (let i = 0; i < fullLength; i++) {
+      const fullKey = localStorage.key(i);
+      if (fullKey && fullKey.startsWith(this.prefix)) {
+        const item = localStorage.getItem(fullKey);
+        if (item) {
+          items.push(item);
+        }
+      }
+    }
+    return items;
+  }
+  async getItem(key) {
+    const fullKey = this.buildKey(key);
+    await this.simulateSyncDelay();
+    return localStorage.getItem(fullKey);
+  }
+  async key(index) {
+    const keys = this.keys();
+    if (index < 0 || index >= keys.length) {
+      return null;
+    }
+    await this.simulateSyncDelay();
+    return keys[index];
+  }
+  async length() {
+    return this.keys().length;
+  }
+  async removeItem(key) {
+    const fullKey = this.buildKey(key);
+    await this.simulateSyncDelay();
+    localStorage.removeItem(fullKey);
+  }
+  async setItem(key, item) {
+    const fullKey = this.buildKey(key);
+    await this.simulateSyncDelay();
+    localStorage.setItem(fullKey, item);
+  }
+  async setMultipleItems(entries) {
+    for (const entry of entries) {
+      const fullKey = this.buildKey(entry.key);
+      localStorage.setItem(fullKey, entry.value);
+    }
+    await this.simulateSyncDelay();
+  }
+  async removeMultipleItems(keys) {
+    for (const key of keys) {
+      const fullKey = this.buildKey(key);
+      localStorage.removeItem(fullKey);
+    }
+    await this.simulateSyncDelay();
+  }
+  buildKey(key) {
+    const prefix = this.prefix;
+    return `${prefix}${key}`;
+  }
+  extractKey(fullKey) {
+    const prefix = this.prefix;
+    return fullKey.substring(prefix.length);
+  }
+  keys() {
+    const keys = new Array();
+    let length = localStorage.length;
+    for (let i = 0; i < length; i++) {
+      const fullKey = localStorage.key(i);
+      if (fullKey && fullKey.startsWith(this.prefix)) {
+        length++;
+        const key = this.extractKey(fullKey);
+        keys.push(key);
+      }
+    }
+    return keys;
+  }
+  async simulateSyncDelay() {
+    const syncDelay = this.syncDelay;
+    if (syncDelay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, syncDelay));
+    }
+  }
+};
+function generateAppIdentifier(appUrl) {
+  if (!appUrl) appUrl = "";
+  const normalizedId = normalizeAppIdentifier(appUrl);
+  let hash = 0;
+  for (let i = 0; i < normalizedId.length; i++) {
+    const char = normalizedId.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(16);
+}
+function normalizeAppIdentifier(input) {
+  if (input.startsWith("http")) {
+    try {
+      const url = new URL(input);
+      const pathParts = url.pathname.split("/");
+      const h5Index = pathParts.findIndex((part) => part === "H5");
+      if (h5Index !== -1 && h5Index < pathParts.length - 1) {
+        const appId = pathParts[h5Index + 1];
+        return appId;
+      }
+      return url.hostname;
+    } catch (error) {
+      console.error(`[Venus Mock] Error parsing URL: ${error}`, { input });
+      return input;
+    }
+  }
+  if (input.includes("/H5/")) {
+    try {
+      const pathParts = input.split("/");
+      const h5Index = pathParts.findIndex((part) => part === "H5");
+      if (h5Index !== -1 && h5Index < pathParts.length - 1) {
+        const appId = pathParts[h5Index + 1];
+        return appId;
+      }
+    } catch (error) {
+      console.error(`[Venus Mock] Error parsing path-based URL: ${error}`, {
+        input
+      });
+    }
+  }
+  return input;
+}
+
+// src/storage/RpcStorageApi.ts
+var RpcStorageApi = class {
+  constructor(rpcClient, methodIds) {
+    __publicField(this, "rpcClient");
+    __publicField(this, "methodIds");
+    this.rpcClient = rpcClient;
+    this.methodIds = methodIds;
+  }
+  clear() {
+    return this.rpcClient.call(this.methodIds.clear);
+  }
+  getItem(key) {
+    return this.rpcClient.call(this.methodIds.getItem, {
+      key
+    });
+  }
+  setItem(key, value) {
+    return this.rpcClient.call(this.methodIds.setItem, {
+      key,
+      value
+    });
+  }
+  key(index) {
+    return this.rpcClient.call(this.methodIds.getKey, {
+      index
+    });
+  }
+  length() {
+    return this.rpcClient.call(this.methodIds.length);
+  }
+  removeItem(key) {
+    return this.rpcClient.call(this.methodIds.removeItem, {
+      key
+    });
+  }
+  removeMultipleItems(keys) {
+    if (!this.methodIds.removeMultipleItems) {
+      throw new Error("Method not implemented");
+    }
+    return this.rpcClient.call(this.methodIds.removeMultipleItems, {
+      keys
+    });
+  }
+  getAllItems() {
+    if (!this.methodIds.getAllItems) {
+      throw new Error("Method not implemented");
+    }
+    return this.rpcClient.call(this.methodIds.getAllItems);
+  }
+  setMultipleItems(items) {
+    if (!this.methodIds.setMultipleItems) {
+      throw new Error("Method not implemented");
+    }
+    return this.rpcClient.call(this.methodIds.setMultipleItems, {
+      items
+    });
+  }
+};
+
+// src/storage/index.ts
+function initializeStorage(venusApiInstance, host) {
+  venusApiInstance.deviceCache = host.deviceCache;
+  venusApiInstance.appStorage = host.appStorage;
+  venusApiInstance.globalStorage = host.globalStorage;
+}
+
+// src/simulation/utils.ts
+function sumContributions(contributions) {
+  const totals = {};
+  for (const profileId in contributions) {
+    for (const entityId in contributions[profileId]) {
+      const amount = contributions[profileId][entityId] || 0;
+      totals[entityId] = (totals[entityId] || 0) + amount;
+    }
+  }
+  return totals;
+}
+
+// src/simulation/RpcSimulationApi.ts
+var RpcSimulationApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    __publicField(this, "_simulationConfig", null);
+    this.rpcClient = rpcClient;
+  }
+  async validateSlotAssignmentAsync(containerId, slotId, itemId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_VALIDATE_ASSIGNMENT" /* H5_SIMULATION_VALIDATE_ASSIGNMENT */,
+      {
+        containerId,
+        slotId,
+        itemId
+      }
+    );
+  }
+  sumContributions(contributions) {
+    return sumContributions(contributions);
+  }
+  executeBatchOperationsAsync(operations, validateOnly) {
+    return this.rpcClient.call("H5_SIMULATION_BATCH_OPERATIONS" /* H5_SIMULATION_BATCH_OPERATIONS */, {
+      operations,
+      validateOnly
+    });
+  }
+  async getAvailableItemsAsync(containerId, slotId) {
+    const response = await this.rpcClient.call(
+      "H5_SIMULATION_GET_AVAILABLE_ITEMS" /* H5_SIMULATION_GET_AVAILABLE_ITEMS */,
+      {
+        containerId,
+        slotId
+      }
+    );
+    return response.availableItems || [];
+  }
+  calculatePowerPreviewAsync(containerId, slotId, candidateItemId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_CALCULATE_POWER_PREVIEW" /* H5_SIMULATION_CALCULATE_POWER_PREVIEW */,
+      {
+        containerId,
+        slotId,
+        candidateItemId
+      }
+    );
+  }
+  assignItemToSlotAsync(containerId, slotId, itemId) {
+    return this.rpcClient.call("H5_SIMULATION_ASSIGN_ITEM" /* H5_SIMULATION_ASSIGN_ITEM */, {
+      containerId,
+      slotId,
+      itemId
+    });
+  }
+  removeItemFromSlotAsync(containerId, slotId) {
+    return this.rpcClient.call("H5_SIMULATION_REMOVE_ITEM" /* H5_SIMULATION_REMOVE_ITEM */, {
+      containerId,
+      slotId
+    });
+  }
+  async getSlotContainersAsync() {
+    const response = await this.rpcClient.call(
+      "H5_SIMULATION_GET_CONTAINERS" /* H5_SIMULATION_GET_CONTAINERS */,
+      {}
+    );
+    return response.containers || [];
+  }
+  async getSlotAssignmentsAsync(containerId) {
+    const response = await this.rpcClient.call(
+      "H5_SIMULATION_GET_ASSIGNMENTS" /* H5_SIMULATION_GET_ASSIGNMENTS */,
+      {
+        containerId
+      }
+    );
+    return Array.isArray(response) ? response : response.assignments || [];
+  }
+  async getStateAsync(roomId) {
+    const response = await this.rpcClient.call(
+      "H5_SIMULATION_GET_STATE" /* H5_SIMULATION_GET_STATE */,
+      {
+        roomId
+      }
+    );
+    console.log("[Venus SDK] getStateAsync", response);
+    if (response.configuration) {
+      this._simulationConfig = response.configuration;
+    }
+    return response;
+  }
+  async getConfigAsync(roomId) {
+    if (this._simulationConfig) {
+      return this._simulationConfig;
+    }
+    const config = await this.rpcClient.call(
+      "H5_SIMULATION_GET_CONFIG" /* H5_SIMULATION_GET_CONFIG */,
+      {}
+    );
+    console.log("[Venus SDK] getConfigAsync", config);
+    if (config) {
+      this._simulationConfig = config;
+      return config;
+    }
+    throw new Error("No simulation configuration available");
+  }
+  executeRecipeAsync(recipeId, inputs, options) {
+    return this.rpcClient.call("H5_SIMULATION_EXECUTE_RECIPE" /* H5_SIMULATION_EXECUTE_RECIPE */, {
+      recipeId,
+      inputs,
+      roomId: options?.roomId,
+      batchAmount: options?.batchAmount,
+      allowPartialBatch: options?.allowPartialBatch,
+      entity: options?.entity
+    });
+  }
+  collectRecipeAsync(runId) {
+    return this.rpcClient.call("H5_SIMULATION_COLLECT_RECIPE" /* H5_SIMULATION_COLLECT_RECIPE */, {
+      runId
+    });
+  }
+  getActiveRunsAsync(options) {
+    return this.rpcClient.call("H5_SIMULATION_GET_ACTIVE_RUNS" /* H5_SIMULATION_GET_ACTIVE_RUNS */, {
+      roomId: options?.roomId
+    });
+  }
+  executeScopedRecipeAsync(recipeId, entity, inputs, options) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_EXECUTE_SCOPED_RECIPE" /* H5_SIMULATION_EXECUTE_SCOPED_RECIPE */,
+      {
+        recipeId,
+        entity,
+        inputs,
+        roomId: options?.roomId ?? null,
+        options
+      }
+    );
+  }
+  getAvailableRecipesAsync(options) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_AVAILABLE_RECIPES" /* H5_SIMULATION_GET_AVAILABLE_RECIPES */,
+      {
+        roomId: options?.roomId || null,
+        includeActorRecipes: options?.includeActorRecipes || false
+      }
+    );
+  }
+  getRecipeRequirementsAsync(recipe) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_RECIPE_REQUIREMENTS */,
+      {
+        recipeId: recipe.recipeId,
+        entity: recipe.entity,
+        batchAmount: recipe.batchAmount
+      }
+    );
+  }
+  getBatchRecipeRequirementsAsync(recipes) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS" /* H5_SIMULATION_GET_BATCH_RECIPE_REQUIREMENTS */,
+      {
+        recipes
+      }
+    );
+  }
+  triggerRecipeChainAsync(recipeId, options) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_TRIGGER_RECIPE_CHAIN" /* H5_SIMULATION_TRIGGER_RECIPE_CHAIN */,
+      {
+        triggerRecipeId: recipeId,
+        context: options?.context,
+        roomId: options?.roomId
+      }
+    );
+  }
+  getEntityMetadataAsync(entityId) {
+    return this.rpcClient.call(
+      "H5_SIMULATION_GET_ENTITY_METADATA" /* H5_SIMULATION_GET_ENTITY_METADATA */,
+      {
+        entityId
+      }
+    );
+  }
+  async resolveFieldValueAsync(entityId, fieldPath, entity) {
+    const response = await this.rpcClient.call(
+      "H5_SIMULATION_RESOLVE_VALUE" /* H5_SIMULATION_RESOLVE_VALUE */,
+      {
+        entityId,
+        fieldPath,
+        entity
+      }
+    );
+    return response.value;
+  }
+};
+
+// src/simulation/MockSimulationApi.ts
+function generateAppIdentifier2() {
+  if (typeof window === "undefined") return "unknown-app";
+  const url = window.location.href;
+  const match = url.match(/\/H5\/([^\/]+)/);
+  return match ? match[1] : "unknown-app";
+}
+var MockSimulationApi = class {
+  constructor(simulationConfig = null) {
+    __publicField(this, "mockSimulationConfigs", /* @__PURE__ */ new Map());
+    // appIdentifier -> config
+    __publicField(this, "mockSimulationStates", /* @__PURE__ */ new Map());
+    // appIdentifier -> config
+    __publicField(this, "mockActiveTimers", /* @__PURE__ */ new Map());
+    // appIdentifier -> timers[]
+    __publicField(this, "appId");
+    __publicField(this, "providedSimulationConfig");
+    this.appId = generateAppIdentifier2();
+    this.providedSimulationConfig = simulationConfig;
+  }
+  sumContributions(contributions) {
+    return sumContributions(contributions);
+  }
+  async validateSlotAssignmentAsync(containerId, slotId, itemId) {
+    this.log("validateSlotAssignmentAsync called:", {
+      containerId,
+      slotId,
+      itemId
+    });
+    return { valid: true, message: "Mock validation successful" };
+  }
+  async executeBatchOperationsAsync(operations, validateOnly) {
+    this.log("executeBatchOperationsAsync called:", {
+      operations,
+      validateOnly
+    });
+    return {
+      success: true,
+      results: operations.map(() => ({ success: true }))
+    };
+  }
+  async getAvailableItemsAsync(containerId, slotId) {
+    console.log("[Venus Simulation Mock] getAvailableItemsAsync called:", {
+      containerId,
+      slotId
+    });
+    const appIdentifier = generateAppIdentifier2();
+    const mockSimulationConfigs = this.mockSimulationConfigs;
+    const config = mockSimulationConfigs.get(appIdentifier) || {
+      entities: {}
+    };
+    const availableItems = Object.entries(config.entities).slice(0, 3).map(([entityId, entity]) => ({
+      entityId,
+      quantity: 1,
+      metadata: entity.metadata,
+      powerPreview: 100
+      // Mock power value
+    }));
+    return availableItems;
+  }
+  async calculatePowerPreviewAsync(containerId, slotId, candidateItemId) {
+    this.log("calculatePowerPreviewAsync called:", {
+      containerId,
+      slotId,
+      candidateItemId
+    });
+    return {
+      currentPower: 1e3,
+      previewPower: 1200,
+      powerDelta: 200,
+      breakdown: { base: 800, weapon: 200, armor: 200 }
+    };
+  }
+  async getSlotContainersAsync() {
+    this.log("getSlotContainersAsync called");
+    const appIdentifier = this.appId;
+    const mockSimulationConfigs = this.mockSimulationConfigs;
+    const config = mockSimulationConfigs.get(appIdentifier) || {
+      entities: {}
+    };
+    const containers = Object.entries(config.entities).filter(([_, entity]) => entity.metadata?.slots).map(([entityId, entity]) => ({
+      entityId,
+      slots: entity.metadata?.slots,
+      isOwned: true
+      // Mock: assume all containers are owned
+    }));
+    return containers;
+  }
+  async getSlotAssignmentsAsync(containerId) {
+    this.log("getSlotAssignmentsAsync called for:", containerId);
+    return [];
+  }
+  async resolveFieldValueAsync(entityId, fieldPath, entity) {
+    this.log("resolveFieldValueAsync called:", {
+      entityId,
+      fieldPath,
+      entity
+    });
+    const mockValues = {
+      basePower: 850,
+      weaponPower: 300,
+      armorPower: 150,
+      total_power: 1300,
+      total_defense_power: 5e3
+    };
+    return mockValues[fieldPath] || 100;
+  }
+  async getEntityMetadataAsync(entityId) {
+    this.log("getEntityMetadataAsync called for:", entityId);
+    const mockSimulationConfigs = this.mockSimulationConfigs;
+    const appIdentifier = this.appId;
+    const config = mockSimulationConfigs.get(
+      appIdentifier
+    ) || {
+      entities: {}};
+    const entity = config.entities[entityId];
+    return entity?.metadata || {};
+  }
+  async collectRecipeAsync(runId) {
+    this.log("collectRecipeAsync called:", { runId });
+    const mockRewards = {
+      cash: Math.floor(Math.random() * 1e3) + 500,
+      experience: Math.floor(Math.random() * 50) + 25
+    };
+    return {
+      success: true,
+      runId,
+      rewards: mockRewards,
+      message: "Rewards collected successfully"
+    };
+  }
+  executeRecipeAsync(recipeId, inputs, options) {
+    this.log("executeRecipeAsync called:", {
+      recipeId,
+      inputs,
+      options
+    });
+    const appIdentifier = this.appId;
+    return this.executeRecipe(appIdentifier, recipeId, inputs);
+  }
+  async executeScopedRecipeAsync(recipeId, entity, inputs, options) {
+    this.log("executeScopedRecipeAsync called:", {
+      recipeId,
+      entity,
+      inputs,
+      roomId: options?.roomId,
+      options
+    });
+    return {
+      success: true,
+      message: "Mock scoped recipe execution successful"
+    };
+  }
+  async getActiveRunsAsync(options) {
+    this.log("getActiveRunsAsync called:", options);
+    const appIdentifier = this.appId;
+    let state = this.mockSimulationStates.get(appIdentifier);
+    if (!state) {
+      state = await this.initializeSimulationState(appIdentifier);
+    }
+    return state.activeRuns || [];
+  }
+  async getAvailableRecipesAsync(options) {
+    this.log("getAvailableRecipesAsync called:", options);
+    const baseRecipes = [
+      { id: "collect_resources", scope: "player", clientViewable: true },
+      { id: "upgrade_equipment", scope: "player", clientViewable: true }
+    ];
+    if (options?.roomId) {
+      baseRecipes.push(
+        { id: "room_upgrade", scope: "room", clientViewable: true },
+        { id: "cooperative_project", scope: "room", clientViewable: true }
+      );
+    }
+    if (options?.includeActorRecipes && options?.roomId) {
+      baseRecipes.push(
+        { id: "trade_with_npc", scope: "actor", clientViewable: true },
+        { id: "attack_monster", scope: "actor", clientViewable: true }
+      );
+    }
+    return { success: true, recipes: baseRecipes };
+  }
+  async getBatchRecipeRequirementsAsync(recipes) {
+    this.log("getBatchRecipeRequirementsAsync called:", {
+      count: recipes?.length
+    });
+    const results = (recipes || []).map((q) => ({
+      recipeId: q.recipeId,
+      entity: q.entity || null,
+      amount: q.batchAmount || 1,
+      inputs: { cash: "BE:0" },
+      canAfford: true,
+      disabled: false
+    }));
+    return { success: true, results };
+  }
+  async getRecipeRequirementsAsync(recipe) {
+    this.log("getRecipeRequirementsAsync called:", recipe);
+    return {
+      recipeId: recipe.recipeId,
+      entity: recipe.entity || null,
+      amount: recipe.batchAmount,
+      inputs: { cash: "BE:0" },
+      canAfford: true,
+      disabled: false
+    };
+  }
+  async triggerRecipeChainAsync(recipeId, options) {
+    this.log("triggerRecipeChainAsync called:", { recipeId, ...options });
+    return {
+      success: true,
+      message: "Mock recipe chain triggered successfully"
+    };
+  }
+  log(message, ...args) {
+    console.log(`[Venus Sim Mock] ${message}`, args);
+  }
+  async executeRecipe(appIdentifier, recipeId, inputs) {
+    this.log(`Executing recipe ${recipeId} for ${appIdentifier}`, inputs);
+    const mockSimulationConfigs = this.mockSimulationConfigs;
+    const mockSimulationStates = this.mockSimulationStates;
+    let config = mockSimulationConfigs.get(appIdentifier);
+    let state = mockSimulationStates.get(appIdentifier);
+    if (!config || !state) {
+      state = await this.initializeSimulationState(appIdentifier);
+      config = mockSimulationConfigs.get(appIdentifier);
+      if (!config) {
+        throw new Error("Failed to initialize simulation config");
+      }
+    }
+    const recipe = config.recipes?.[recipeId];
+    if (!recipe) {
+      throw new Error(`Recipe ${recipeId} not found`);
+    }
+    if (state.disabledRecipes?.includes(recipeId)) {
+      throw new Error(`Recipe ${recipeId} is disabled`);
+    }
+    if (recipe.inputs) {
+      for (const [entityId, required] of Object.entries(recipe.inputs)) {
+        const available = state.inventory[entityId] || 0;
+        if (available < required) {
+          throw new Error(
+            `Insufficient ${entityId}: required ${required}, available ${available}`
+          );
+        }
+      }
+    }
+    if (recipe.inputs) {
+      for (const [entityId, input] of Object.entries(recipe.inputs)) {
+        const inventoryValue = state.inventory[entityId] || 0;
+        if (typeof input === "number" && typeof inventoryValue === "number") {
+          state.inventory[entityId] = inventoryValue - input;
+        }
+      }
+    }
+    if (recipe.beginEffects) {
+      this.applyEffects(state, recipe.beginEffects);
+    }
+    const runId = this.generateRunId();
+    const now = Date.now();
+    const expiresAt = now + (recipe.duration || 0);
+    const run = {
+      id: runId,
+      recipeId,
+      status: "running",
+      startTime: now,
+      expiresAt,
+      inputs: recipe.inputs || {}
+    };
+    state.activeRuns.push(run);
+    if (recipe.duration === 0) {
+      this.completeRun(appIdentifier, runId);
+      return { status: "completed", runId };
+    } else {
+      const mockActiveTimers = this.mockActiveTimers;
+      const timer = setTimeout(() => {
+        this.completeRun(appIdentifier, runId);
+      }, recipe.duration);
+      const timers = mockActiveTimers.get(appIdentifier) || [];
+      timers.push(timer);
+      mockActiveTimers.set(appIdentifier, timers);
+      return {
+        status: "running",
+        runId,
+        expiresAt: new Date(expiresAt).toISOString()
+      };
+    }
+  }
+  async initializeSimulationState(appIdentifier) {
+    this.log(`Initializing simulation state for ${appIdentifier}`);
+    const providedSimulationConfig = this.providedSimulationConfig;
+    const mockSimulationConfigs = this.mockSimulationConfigs;
+    const mockSimulationStates = this.mockSimulationStates;
+    const mockActiveTimers = this.mockActiveTimers;
+    const config = providedSimulationConfig || {
+      version: "1.0",
+      entities: {},
+      recipes: {}
+    };
+    mockSimulationConfigs.set(appIdentifier, config);
+    const initialInventory = {};
+    if (providedSimulationConfig && config.entities) {
+      Object.keys(config.entities).forEach((entityId) => {
+        initialInventory[entityId] = 0;
+      });
+    }
+    const state = {
+      inventory: initialInventory,
+      activeRuns: [],
+      disabledRecipes: new Array()
+    };
+    if (config.recipes) {
+      Object.entries(config.recipes).forEach(([recipeId, recipe]) => {
+        if (recipe.metadata?.startsDisabled) {
+          state.disabledRecipes.push(recipeId);
+        }
+      });
+    }
+    mockSimulationStates.set(appIdentifier, state);
+    mockActiveTimers.set(appIdentifier, []);
+    console.log(
+      `[Venus Simulation Mock] Initialized state for ${appIdentifier}:`,
+      state
+    );
+    if (config.recipes) {
+      Object.entries(config.recipes).forEach(([recipeId, recipe]) => {
+        const isAutoRestart = recipe.autoRestart || recipe.metadata?.autoRestart;
+        if (isAutoRestart && recipe.outputs) {
+          this.log(`Found auto-restart recipe: ${recipeId}`, {
+            topLevelAutoRestart: recipe.autoRestart,
+            metadataAutoRestart: recipe.metadata?.autoRestart,
+            hasOutputs: !!recipe.outputs,
+            duration: recipe.duration
+          });
+          const condition = recipe.maxRestartCondition || recipe.metadata?.maxRestartCondition;
+          if (condition && condition.entity) {
+            const currentAmount = initialInventory[condition.entity] || 0;
+            if (currentAmount < condition.maxValue) {
+              console.log(
+                `[Venus Simulation Mock] Auto-starting ${recipeId} at initialization`,
+                {
+                  currentAmount,
+                  maxValue: condition.maxValue,
+                  entity: condition.entity
+                }
+              );
+              setTimeout(() => {
+                this.executeRecipe(appIdentifier, recipeId, {});
+              }, 1e3);
+            }
+          } else {
+            console.log(
+              `[Venus Simulation Mock] Auto-starting ${recipeId} at initialization (no condition)`
+            );
+            setTimeout(() => {
+              this.executeRecipe(appIdentifier, recipeId, {});
+            }, 1e3);
+          }
+        }
+      });
+    }
+    return state;
+  }
+  generateRunId() {
+    return "run_" + Date.now() + "_" + Math.random().toString(36).substr(2, 9);
+  }
+  completeRun(appIdentifier, runId) {
+    this.log(`Completing run ${runId} for ${appIdentifier}`);
+    const mockSimulationConfigs = this.mockSimulationConfigs;
+    const mockSimulationStates = this.mockSimulationStates;
+    const config = mockSimulationConfigs.get(appIdentifier);
+    const state = mockSimulationStates.get(appIdentifier);
+    if (!config || !state) return;
+    const runIndex = state.activeRuns.findIndex((r) => r.id === runId);
+    if (runIndex === -1) return;
+    const run = state.activeRuns[runIndex];
+    const recipe = config.recipes?.[run.recipeId];
+    if (!recipe) return;
+    const outputs = {};
+    const rng = this.createSeededRandom(runId);
+    if (recipe.outputs) {
+      for (const [entityId, value] of Object.entries(recipe.outputs)) {
+        if (typeof value === "number") {
+          outputs[entityId] = value;
+        } else if (typeof value === "object" && value != null && "min" in value && "max" in value && typeof value.min == "number" && typeof value.max === "number") {
+          outputs[entityId] = Math.floor(rng() * (value.max - value.min + 1)) + value.min;
+        }
+      }
+    }
+    for (const [entityId, amount] of Object.entries(outputs)) {
+      state.inventory[entityId] = (state.inventory[entityId] || 0) + amount;
+    }
+    if (recipe.endEffects) {
+      this.applyEffects(state, recipe.endEffects);
+    }
+    run.status = "completed";
+    run.outputs = outputs;
+    state.activeRuns.splice(runIndex, 1);
+    const isAutoRestart = recipe.autoRestart || recipe.metadata?.autoRestart;
+    if (isAutoRestart) {
+      console.log(
+        `[Venus Simulation Mock] Checking auto-restart for ${run.recipeId}`,
+        {
+          topLevelAutoRestart: recipe.autoRestart,
+          metadataAutoRestart: recipe.metadata?.autoRestart,
+          hasCondition: !!(recipe.maxRestartCondition || recipe.metadata?.maxRestartCondition)
+        }
+      );
+      const condition = recipe.maxRestartCondition || recipe.metadata?.maxRestartCondition;
+      if (condition) {
+        const currentAmount = state.inventory[condition.entity] || 0;
+        if (currentAmount < condition.maxValue) {
+          console.log(
+            `[Venus Simulation Mock] Auto-restarting ${run.recipeId}`,
+            {
+              currentAmount,
+              maxValue: condition.maxValue,
+              entity: condition.entity
+            }
+          );
+          setTimeout(() => {
+            this.executeRecipe(appIdentifier, run.recipeId, recipe.inputs || {});
+          }, 1e3);
+        }
+      } else {
+        console.log(
+          `[Venus Simulation Mock] Auto-restarting ${run.recipeId} (no condition)`
+        );
+        setTimeout(() => {
+          this.executeRecipe(appIdentifier, run.recipeId, recipe.inputs || {});
+        }, 1e3);
+      }
+    }
+    console.log(
+      `[Venus Simulation Mock] Completed run ${runId}, outputs:`,
+      outputs
+    );
+  }
+  createSeededRandom(seed) {
+    let hash = 0;
+    for (let i = 0; i < seed.length; i++) {
+      const char = seed.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash = hash & hash;
+    }
+    return () => {
+      hash = (hash * 9301 + 49297) % 233280;
+      return hash / 233280;
+    };
+  }
+  applyEffects(state, effects) {
+    if (!effects || !Array.isArray(effects)) return;
+    for (const effect of effects) {
+      switch (effect.type) {
+        case "set":
+          state.inventory[effect.target] = effect.value;
+          console.log(
+            `[Venus Simulation Mock] Effect: Set ${effect.target} = ${effect.value}`
+          );
+          break;
+        case "add":
+          state.inventory[effect.target] = (state.inventory[effect.target] || 0) + effect.value;
+          console.log(
+            `[Venus Simulation Mock] Effect: Add ${effect.value} to ${effect.target} (new value: ${state.inventory[effect.target]})`
+          );
+          break;
+        case "multiply":
+          state.inventory[effect.target] = (state.inventory[effect.target] || 0) * effect.value;
+          console.log(
+            `[Venus Simulation Mock] Effect: Multiply ${effect.target} by ${effect.value} (new value: ${state.inventory[effect.target]})`
+          );
+          break;
+        case "min":
+          state.inventory[effect.target] = Math.max(
+            state.inventory[effect.target] || 0,
+            effect.value
+          );
+          console.log(
+            `[Venus Simulation Mock] Effect: Set ${effect.target} min ${effect.value} (new value: ${state.inventory[effect.target]})`
+          );
+          break;
+        case "max":
+          state.inventory[effect.target] = Math.min(
+            state.inventory[effect.target] || 0,
+            effect.value
+          );
+          console.log(
+            `[Venus Simulation Mock] Effect: Set ${effect.target} max ${effect.value} (new value: ${state.inventory[effect.target]})`
+          );
+          break;
+        case "enable_recipe":
+          if (state.disabledRecipes?.includes(effect.target)) {
+            state.disabledRecipes = state.disabledRecipes.filter(
+              (r) => r !== effect.target
+            );
+            console.log(
+              `[Venus Simulation Mock] Effect: Enabled recipe ${effect.target}`
+            );
+          }
+          break;
+        case "disable_recipe":
+          if (!state.disabledRecipes) state.disabledRecipes = [];
+          if (!state.disabledRecipes.includes(effect.target)) {
+            state.disabledRecipes.push(effect.target);
+            console.log(
+              `[Venus Simulation Mock] Effect: Disabled recipe ${effect.target}`
+            );
+          }
+          break;
+        case "trigger_recipe":
+          console.log(
+            `[Venus Simulation Mock] Effect: Trigger recipe ${effect.target} (not implemented)`
+          );
+          break;
+        default:
+          console.warn(
+            `[Venus Simulation Mock] Unknown effect type: ${effect.type}`
+          );
+      }
+    }
+  }
+  async getConfigAsync() {
+    console.log("[Venus Simulation Mock] getConfigAsync called");
+    const appIdentifier = this.appId;
+    const mockSimulationConfigs = this.mockSimulationConfigs;
+    const config = mockSimulationConfigs.get(appIdentifier) || {
+      version: "1.0",
+      entities: {},
+      recipes: {}
+    };
+    return config;
+  }
+  async getStateAsync(roomId) {
+    this.log("getStateAsync called:", roomId);
+    const appIdentifier = this.appId;
+    const mockSimulationStates = this.mockSimulationStates;
+    let state = mockSimulationStates.get(appIdentifier);
+    if (!state) {
+      state = await this.initializeSimulationState(appIdentifier);
+    }
+    const mockSimulationConfigs = this.mockSimulationConfigs;
+    return {
+      ...state,
+      roomId,
+      configuration: mockSimulationConfigs.get(appIdentifier)
+    };
+  }
+  async assignItemToSlotAsync(containerId, slotId, itemId) {
+    this.log("assignItemToSlotAsync called:", {
+      containerId,
+      slotId,
+      itemId
+    });
+    return { success: true, message: "Mock assignment successful" };
+  }
+  async removeItemFromSlotAsync(containerId, slotId) {
+    this.log("removeItemFromSlotAsync called:", {
+      containerId,
+      slotId
+    });
+    return { success: true, message: "Mock removal successful" };
+  }
+};
+
+// src/simulation/index.ts
+function initializeSimulation(venusApi, host) {
+  console.log("[Venus SDK] Initializing new Simulation Api");
+  venusApi.simulation = {
+    isEnabled: () => true
+  };
+  venusApi.simulation.getConfigAsync = () => {
+    return host.simulation.getConfigAsync();
+  };
+  venusApi.simulation.getStateAsync = (options) => {
+    return host.simulation.getStateAsync(options?.roomId);
+  };
+  venusApi.simulation.executeRecipeAsync = (recipeId, inputs, options) => {
+    return host.simulation.executeRecipeAsync(recipeId, inputs, options);
+  };
+  venusApi.simulation.getActiveRunsAsync = () => {
+    return host.simulation.getActiveRunsAsync();
+  };
+  venusApi.simulation.collectRecipeAsync = (runId) => {
+    return host.simulation.collectRecipeAsync(runId);
+  };
+  venusApi.simulation.executeScopedRecipeAsync = (recipeId, entity, inputs, roomId, options) => {
+    return host.simulation.executeScopedRecipeAsync(recipeId, entity, inputs, {
+      roomId,
+      ...options
+    });
+  };
+  venusApi.simulation.triggerRecipeChainAsync = (recipeId, context, roomId) => {
+    return host.simulation.triggerRecipeChainAsync(recipeId, {
+      context,
+      roomId
+    });
+  };
+  venusApi.simulation.getAvailableRecipesAsync = async (roomId, includeActorRecipes) => {
+    const result = await host.simulation.getAvailableRecipesAsync({
+      roomId,
+      includeActorRecipes
+    });
+    return result.recipes;
+  };
+  venusApi.simulation.getRecipeRequirementsAsync = (recipeId, entity, amount) => {
+    return host.simulation.getRecipeRequirementsAsync({
+      recipeId,
+      entity,
+      batchAmount: amount
+    });
+  };
+  venusApi.simulation.getBatchRecipeRequirementsAsync = (recipes) => {
+    return host.simulation.getBatchRecipeRequirementsAsync(recipes);
+  };
+  venusApi.simulation.resolveFieldValueAsync = (entityId, fieldPath, entity) => {
+    return host.simulation.resolveFieldValueAsync(entityId, fieldPath, entity);
+  };
+  venusApi.simulation.getEntityMetadataAsync = (entityId) => {
+    return host.simulation.getEntityMetadataAsync(entityId);
+  };
+  venusApi.simulation.getSlotAssignmentsAsync = (containerId) => {
+    return host.simulation.getSlotAssignmentsAsync(containerId);
+  };
+  venusApi.simulation.getSlotContainersAsync = () => {
+    return host.simulation.getSlotContainersAsync();
+  };
+  venusApi.simulation.assignItemToSlotAsync = (containerId, slotId, itemId) => {
+    return host.simulation.assignItemToSlotAsync(containerId, slotId, itemId);
+  };
+  venusApi.simulation.removeItemFromSlotAsync = (containerId, slotId) => {
+    return host.simulation.removeItemFromSlotAsync(containerId, slotId);
+  };
+  venusApi.simulation.getAvailableItemsAsync = (containerId, slotId) => {
+    return host.simulation.getAvailableItemsAsync(containerId, slotId);
+  };
+  venusApi.simulation.calculatePowerPreviewAsync = (containerId, slotId, candidateItemId) => {
+    return host.simulation.calculatePowerPreviewAsync(
+      containerId,
+      slotId,
+      candidateItemId
+    );
+  };
+  venusApi.simulation.executeBatchOperationsAsync = (operations, validateOnly) => {
+    return host.simulation.executeBatchOperationsAsync(operations, validateOnly);
+  };
+  venusApi.simulation.validateSlotAssignmentAsync = (containerId, slotId, itemId) => {
+    return host.simulation.validateSlotAssignmentAsync(
+      containerId,
+      slotId,
+      itemId
+    );
+  };
+  venusApi.simulation.sumContributions = (contributions) => {
+    return host.simulation.sumContributions(contributions);
+  };
+}
+
+// src/time/utils.ts
+function isPacificDaylightTime(date) {
+  const year = date.getFullYear();
+  const marchStart = new Date(year, 2, 8);
+  const daysUntilSundayInMarch = (7 - marchStart.getDay()) % 7;
+  const dstStart = new Date(year, 2, 8 + daysUntilSundayInMarch);
+  dstStart.setHours(2, 0, 0, 0);
+  const novemberStart = new Date(year, 10, 1);
+  const daysUntilSundayInNov = (7 - novemberStart.getDay()) % 7;
+  const dstEnd = new Date(year, 10, 1 + daysUntilSundayInNov);
+  dstEnd.setHours(2, 0, 0, 0);
+  return date >= dstStart && date < dstEnd;
+}
+
+// src/time/HostTimeApi.ts
+var HostTimeApi = class {
+  constructor(rpcClient) {
+    __publicField(this, "rpcClient");
+    this.rpcClient = rpcClient;
+  }
+  async requestTimeAsync() {
+    const response = await this.rpcClient.call(
+      "H5_REQUEST_SERVER_TIME" /* REQUEST_SERVER_TIME */,
+      {}
+    );
+    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 date = new Date(timestamp);
+    const dateTimeOptions = {
+      dateStyle: options.dateStyle || "medium",
+      timeStyle: options.timeStyle || "medium",
+      hour12: options.hour12 !== void 0 ? options.hour12 : true,
+      ...options
+    };
+    return date.toLocaleString(locale, dateTimeOptions);
+  }
+  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 numberOptions = {
+        style: options?.style || "decimal",
+        minimumFractionDigits: options?.minimumFractionDigits || 0,
+        maximumFractionDigits: options?.maximumFractionDigits || 2,
+        ...options
+      };
+      return value.toLocaleString(locale, numberOptions);
+    } catch (error) {
+      console.error("[Venus] Error formatting number:", error);
+      return String(value);
+    }
+  }
+  async getFutureTimeAsync(options) {
+    const timeInfo = await this.requestTimeAsync();
+    const serverTime = new Date(timeInfo.serverTime);
+    const result = new Date(serverTime);
+    if (options?.days) {
+      result.setDate(result.getDate() + options.days);
+    }
+    if (options?.hours) {
+      result.setHours(result.getHours() + options.hours);
+    }
+    if (options?.minutes) {
+      result.setMinutes(result.getMinutes() + options.minutes);
+    }
+    if (options?.timeOfDay) {
+      const { hour = 0, minute = 0, second = 0 } = options.timeOfDay;
+      timeInfo.timezoneOffset || (/* @__PURE__ */ new Date()).getTimezoneOffset();
+      const localHour = hour;
+      result.setHours(localHour, minute, second, 0);
+    }
+    if (options?.timezone) {
+      switch (options.timezone.toUpperCase()) {
+        case "PT":
+        case "PST":
+        case "PDT": {
+          const isPDT = isPacificDaylightTime(result);
+          const ptOffset = isPDT ? -7 : -8;
+          result.setUTCHours(0, 0, 0, 0);
+          const { hour = 0, minute = 0, second = 0 } = options.timeOfDay || {};
+          const utcHour = (hour - ptOffset) % 24;
+          result.setUTCHours(utcHour, minute, second, 0);
+          break;
+        }
+        // Add other timezone cases as needed
+        default:
+          console.warn(
+            "[Venus] Timezone " + options.timezone + " not supported, using local time"
+          );
+      }
+    }
+    return result.getTime();
+  }
+};
+
+// src/time/MockTimeApi.ts
+var MockTimeApi = class {
+  constructor(venusApi) {
+    __publicField(this, "venusApi");
+    this.venusApi = venusApi;
+  }
+  formatNumber(value, options) {
+    const locale = this.getLocale();
+    const numberOptions = {
+      style: options?.style || "decimal",
+      minimumFractionDigits: options?.minimumFractionDigits || 0,
+      maximumFractionDigits: options?.maximumFractionDigits || 2,
+      ...options
+    };
+    console.log(`[Venus Mock] Formatting number ${value} with locale ${locale}`);
+    return value.toLocaleString(locale, numberOptions);
+  }
+  formatTime(timestamp, options) {
+    const locale = this.getLocale();
+    const date = new Date(timestamp);
+    const dateTimeOptions = {
+      dateStyle: options.dateStyle || "medium",
+      timeStyle: options.timeStyle || "medium",
+      hour12: options.hour12 !== void 0 ? options.hour12 : true,
+      ...options
+    };
+    console.log(
+      `[Venus Mock] Formatting time ${timestamp} with locale ${locale}`
+    );
+    return date.toLocaleString(locale, dateTimeOptions);
+  }
+  async getFutureTimeAsync(options) {
+    console.log("[Venus Mock] Getting future time with options:", options);
+    const timeInfo = await this.requestTimeAsync();
+    const serverTime = new Date(timeInfo.serverTime);
+    const result = new Date(serverTime);
+    if (options?.days) {
+      result.setDate(result.getDate() + options.days);
+    }
+    if (options?.hours) {
+      result.setHours(result.getHours() + options.hours);
+    }
+    if (options?.minutes) {
+      result.setMinutes(result.getMinutes() + options.minutes);
+    }
+    if (options?.timeOfDay) {
+      const { hour = 0, minute = 0, second = 0 } = options.timeOfDay;
+      timeInfo.timezoneOffset || (/* @__PURE__ */ new Date()).getTimezoneOffset();
+      const localHour = hour;
+      result.setHours(localHour, minute, second, 0);
+    }
+    if (options?.timezone) {
+      switch (options?.timezone.toUpperCase()) {
+        case "PT":
+        case "PST":
+        case "PDT": {
+          const isPDT = isPacificDaylightTime(result);
+          const ptOffset = isPDT ? -7 : -8;
+          result.getUTCDate();
+          result.getUTCMonth();
+          result.getUTCFullYear();
+          result.setUTCHours(0, 0, 0, 0);
+          const { hour = 0, minute = 0, second = 0 } = options.timeOfDay || {};
+          const utcHour = (hour - ptOffset) % 24;
+          result.setUTCHours(utcHour, minute, second, 0);
+          break;
+        }
+        // Add other timezone cases as needed
+        default:
+          console.warn(
+            `[Venus Mock] Timezone ${options.timezone} not supported, using local time`
+          );
+      }
+    }
+    return result.getTime();
+  }
+  async requestTimeAsync() {
+    console.log("[Venus Mock] Requesting time");
+    await createMockDelay(MOCK_DELAYS.short);
+    const venusApi = this.venusApi;
+    const mockOffset = venusApi._mock.serverTimeOffset || 2500;
+    const mockServerTime = Date.now() + mockOffset;
+    const timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+    const localTime = mockServerTime - timezoneOffset * 6e4;
+    const timeInfo = {
+      serverTime: mockServerTime,
+      localTime,
+      timezoneOffset,
+      formattedTime: new Date(localTime).toISOString(),
+      locale: venusApi._mock.user?.locale || "en-US"
+    };
+    console.log("[Venus Mock] Time response:", {
+      serverTime: new Date(timeInfo.serverTime).toISOString(),
+      localTime: new Date(timeInfo.localTime).toISOString(),
+      timezoneOffset: timeInfo.timezoneOffset
+    });
+    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
+function initializeTime(venusApi, host) {
+  venusApi.requestTimeAsync = () => {
+    return host.time.requestTimeAsync();
+  };
+  venusApi.getFutureTimeAsync = (options) => {
+    return host.time.getFutureTimeAsync(options);
+  };
+  venusApi.formatTime = (timestamp, options) => {
+    return host.time.formatTime(timestamp, options);
+  };
+  venusApi.formatNumber = (value, options) => {
+    return host.time.formatNumber(value, options);
+  };
+}
+
+// src/version.ts
+var SDK_VERSION = "2.2.0";
+
+exports.HapticFeedbackStyle = HapticFeedbackStyle;
+exports.HostCdnApi = HostCdnApi;
+exports.HostProfileApi = HostProfileApi;
+exports.HostTimeApi = HostTimeApi;
+exports.MockAdsApi = MockAdsApi;
+exports.MockAiApi = MockAiApi;
+exports.MockAnalyticsApi = MockAnalyticsApi;
+exports.MockAvatarApi = MockAvatarApi;
+exports.MockCdnApi = MockCdnApi;
+exports.MockFeaturesApi = MockFeaturesApi;
+exports.MockHapticsApi = MockHapticsApi;
+exports.MockIapApi = MockIapApi;
+exports.MockLifecycleApi = MockLifecycleApi;
+exports.MockLoggingApi = MockLoggingApi;
+exports.MockNavigationApi = MockNavigationApi;
+exports.MockNotificationsApi = MockNotificationsApi;
+exports.MockPopupsApi = MockPopupsApi;
+exports.MockProfileApi = MockProfileApi;
+exports.MockSimulationApi = MockSimulationApi;
+exports.MockStorageApi = MockStorageApi;
+exports.MockTimeApi = MockTimeApi;
+exports.RpcAdsApi = RpcAdsApi;
+exports.RpcAiApi = RpcAiApi;
+exports.RpcAnalyticsApi = RpcAnalyticsApi;
+exports.RpcAvatarApi = RpcAvatarApi;
+exports.RpcClient = RpcClient;
+exports.RpcFeaturesApi = RpcFeaturesApi;
+exports.RpcHapticsApi = RpcHapticsApi;
+exports.RpcIapApi = RpcIapApi;
+exports.RpcLifecycleApi = RpcLifecycleApi;
+exports.RpcLoggingApi = RpcLoggingApi;
+exports.RpcNavigationApi = RpcNavigationApi;
+exports.RpcPopupsApi = RpcPopupsApi;
+exports.RpcSimulationApi = RpcSimulationApi;
+exports.RpcStorageApi = RpcStorageApi;
+exports.SDK_VERSION = SDK_VERSION;
+exports.createMockStorageApi = createMockStorageApi;
+exports.initializeAds = initializeAds;
+exports.initializeAi = initializeAi;
+exports.initializeAnalytics = initializeAnalytics;
+exports.initializeAvatar3d = initializeAvatar3d;
+exports.initializeCdn = initializeCdn;
+exports.initializeFeaturesApi = initializeFeaturesApi;
+exports.initializeHaptics = initializeHaptics;
+exports.initializeIap = initializeIap;
+exports.initializeLifecycleApi = initializeLifecycleApi;
+exports.initializeLocalNotifications = initializeLocalNotifications;
+exports.initializeLoggingApi = initializeLoggingApi;
+exports.initializePopups = initializePopups;
+exports.initializeProfile = initializeProfile;
+exports.initializeSimulation = initializeSimulation;
+exports.initializeStackNavigation = initializeStackNavigation;
+exports.initializeStorage = initializeStorage;
+exports.initializeTime = initializeTime;
+exports.isPacificDaylightTime = isPacificDaylightTime;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map