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

package/dist/SandboxHost-JNX5UBGL.js

@@ -0,0 +1,1889 @@
+import { MockAdsApi, MockLifecycleApi, MockAnalyticsApi, getSandboxConfig, createMockStorageApi, MockAvatarApi, MockNavigationApi, MockNotificationsApi, MockPopupsApi, MockProfileApi, MockDeviceApi, MockEnvironmentApi, MockSystemApi, MockCdnApi, MockTimeApi, MockAiApi, MockHapticsApi, MockFeaturesApi, MockLoggingApi, MockIapApi, MockSocialApi, initializeRoomsApi, MockPreloaderApi, MockSharedAssetsApi, VenusRoom, buildFunctionsBaseUrl } from './chunk-Q7SNANYR.js';
+import './chunk-3APM3V2M.js';
+
+// src/firebase/firebaseClient.ts
+var APP_NAME = "venus-sandbox";
+var firebaseClientPromise = null;
+var cachedClient = null;
+async function getFirebaseClient() {
+  if (cachedClient) {
+    return cachedClient;
+  }
+  if (!firebaseClientPromise) {
+    firebaseClientPromise = initializeFirebaseClient();
+  }
+  cachedClient = await firebaseClientPromise;
+  return cachedClient;
+}
+async function initializeFirebaseClient() {
+  console.log("[Venus SDK] === FIREBASE CLIENT BUILD #4 ===");
+  const config = getSandboxConfig();
+  console.log("[Venus SDK] Config:", config?.target, config?.gameId);
+  if (!config || !config.firebaseConfig) {
+    throw new Error(
+      "[Venus SDK] Cannot initialize Firebase: Sandbox config not available. Make sure the Vite plugin is configured correctly."
+    );
+  }
+  console.log("[Venus SDK] Importing Firebase modules...");
+  const [
+    firebaseApp,
+    firebaseAuth,
+    firebaseFirestore
+  ] = await Promise.all([
+    import('firebase/app'),
+    import('firebase/auth'),
+    import('firebase/firestore')
+  ]);
+  const { initializeApp, getApps, getApp } = firebaseApp;
+  const { getAuth, GoogleAuthProvider, signInWithPopup, signInWithRedirect, getRedirectResult, signInWithEmailAndPassword, createUserWithEmailAndPassword, browserLocalPersistence, setPersistence, connectAuthEmulator } = firebaseAuth;
+  const { getFirestore, connectFirestoreEmulator, doc, collection, getDoc, setDoc, updateDoc, deleteDoc, addDoc, query, where, orderBy, limit, onSnapshot, serverTimestamp, deleteField } = firebaseFirestore;
+  console.log("[Venus SDK] Firebase modules imported");
+  console.log("[Venus SDK] Getting/creating Firebase app...");
+  const existingApps = getApps();
+  const existingApp = existingApps.find((app2) => app2.name === APP_NAME);
+  const app = existingApp ?? initializeApp(config.firebaseConfig, APP_NAME);
+  console.log("[Venus SDK] Firebase app ready:", app.name);
+  console.log("[Venus SDK] Getting auth...");
+  const auth = getAuth(app);
+  console.log("[Venus SDK] Auth ready");
+  const isLocalMode = config.target === "local";
+  if (isLocalMode && config.authEmulatorHost) {
+    console.log("[Venus SDK] Connecting to Auth emulator:", config.authEmulatorHost);
+    try {
+      connectAuthEmulator(auth, `http://${config.authEmulatorHost}`, { disableWarnings: true });
+      console.log("[Venus SDK] Auth emulator connected");
+    } catch (e) {
+      console.log("[Venus SDK] Auth emulator connection error (may already be connected):", e);
+    }
+  } else {
+    console.log("[Venus SDK] Using real Firebase Auth (target:", config.target, ")");
+  }
+  console.log("[Venus SDK] Setting persistence...");
+  try {
+    await setPersistence(auth, browserLocalPersistence);
+    console.log("[Venus SDK] Persistence set");
+  } catch (e) {
+    console.log("[Venus SDK] Persistence error:", e);
+  }
+  console.log("[Venus SDK] Waiting for auth state restoration...");
+  const initialUser = await new Promise((resolve) => {
+    const unsubscribe = auth.onAuthStateChanged((user) => {
+      console.log("[Venus SDK] onAuthStateChanged fired, user:", user?.uid ?? "null");
+      unsubscribe();
+      resolve(user);
+    });
+    setTimeout(() => {
+      unsubscribe();
+      resolve(null);
+    }, 3e3);
+  });
+  console.log("[Venus SDK] Auth state restored, user:", initialUser?.uid ?? "none");
+  const googleProvider = new GoogleAuthProvider();
+  if (!initialUser) {
+    console.log("[Venus SDK] No persisted user, checking for redirect result...");
+    try {
+      const redirectResult = await getRedirectResult(auth);
+      if (redirectResult?.user) {
+        console.log("[Venus SDK] Sign-in redirect completed successfully, user:", redirectResult.user.uid);
+      } else {
+        console.log("[Venus SDK] No redirect result (normal page load or redirect state lost)");
+      }
+    } catch (error) {
+      console.error("[Venus SDK] Redirect sign-in error:", error);
+    }
+  } else {
+    console.log("[Venus SDK] User already restored from persistence, skipping redirect check");
+  }
+  console.log("[Venus SDK] Current auth state:", auth.currentUser ? `signed in as ${auth.currentUser.uid}` : "not signed in");
+  console.log("[Venus SDK] Getting Firestore...");
+  const firestore = getFirestore(app);
+  if (config.target === "local" && config.firestoreEmulatorHost) {
+    console.log("[Venus SDK] Connecting to Firestore emulator:", config.firestoreEmulatorHost);
+    try {
+      const [host, port] = config.firestoreEmulatorHost.split(":");
+      connectFirestoreEmulator(firestore, host, parseInt(port, 10));
+      console.log("[Venus SDK] Firestore emulator connected");
+    } catch (e) {
+      console.log("[Venus SDK] Firestore emulator already connected or error:", e);
+    }
+  }
+  const client = {
+    app,
+    auth,
+    firestore,
+    config,
+    // Auth helpers
+    isSignedIn() {
+      return auth.currentUser !== null;
+    },
+    getProfileId() {
+      return auth.currentUser?.uid ?? null;
+    },
+    async signInWithGoogle() {
+      if (isLocalMode) {
+        console.log("[Venus SDK] Local mode: signing in with test user...");
+        const testEmail = "dev@series.ai";
+        const testPassword = "venus-dev-password";
+        try {
+          const result2 = await signInWithEmailAndPassword(auth, testEmail, testPassword);
+          console.log("[Venus SDK] Sign-in successful, user:", result2.user.uid);
+          return result2;
+        } catch (error) {
+          const authError = error;
+          if (authError.code === "auth/user-not-found" || authError.code === "auth/invalid-credential") {
+            console.log("[Venus SDK] Test user not found, creating...");
+            const result2 = await createUserWithEmailAndPassword(auth, testEmail, testPassword);
+            console.log("[Venus SDK] Test user created, user:", result2.user.uid);
+            return result2;
+          }
+          throw error;
+        }
+      }
+      console.log("[Venus SDK] Signing in with Google popup...");
+      const result = await signInWithPopup(auth, googleProvider);
+      console.log("[Venus SDK] Sign-in successful, user:", result.user.uid);
+      return result;
+    },
+    async signOut() {
+      return auth.signOut();
+    },
+    async getIdToken() {
+      const user = auth.currentUser;
+      if (!user) {
+        console.log("[Venus SDK] getIdToken: No current user");
+        return null;
+      }
+      console.log("[Venus SDK] getIdToken: Refreshing token for user:", user.uid);
+      const token = await user.getIdToken(true);
+      console.log("[Venus SDK] getIdToken: Got token, length:", token?.length);
+      return token;
+    },
+    async getIdTokenOrThrow() {
+      const user = auth.currentUser;
+      console.log("[Venus SDK] getIdTokenOrThrow: currentUser =", user ? user.uid : null);
+      if (!user) {
+        throw new Error(
+          "[Venus SDK] Not signed in. Click the Venus Sandbox toolbar to sign in."
+        );
+      }
+      console.log("[Venus SDK] getIdTokenOrThrow: Forcing token refresh...");
+      try {
+        const token = await user.getIdToken(true);
+        console.log("[Venus SDK] getIdTokenOrThrow: Got fresh token, length:", token?.length);
+        return token;
+      } catch (error) {
+        console.error("[Venus SDK] getIdTokenOrThrow: Token refresh failed:", error);
+        console.log("[Venus SDK] getIdTokenOrThrow: Signing out stale session...");
+        await auth.signOut();
+        throw new Error(
+          "[Venus SDK] Session expired. Please sign in again via the Venus toolbar."
+        );
+      }
+    },
+    getCurrentUser() {
+      return auth.currentUser;
+    },
+    onAuthStateChanged(callback) {
+      return auth.onAuthStateChanged(callback);
+    },
+    // Firestore helpers
+    doc,
+    collection,
+    getDoc,
+    setDoc,
+    updateDoc,
+    deleteDoc,
+    addDoc,
+    query,
+    where,
+    orderBy,
+    limit,
+    onSnapshot,
+    serverTimestamp,
+    deleteField
+  };
+  console.log("[Venus SDK] Firebase client initialization complete!");
+  return client;
+}
+async function observeFirestoreDocument(path, onChange) {
+  const client = await getFirebaseClient();
+  const segments = path.split("/").filter((segment) => segment.length > 0);
+  if (segments.length === 0) {
+    throw new Error(`[Venus SDK] Invalid Firestore path "${path}".`);
+  }
+  const ref = client.doc(client.firestore, segments.join("/"));
+  const unsubscribe = client.onSnapshot(
+    ref,
+    (snapshot) => {
+      onChange(snapshot.exists() ? snapshot.data() : null);
+    },
+    (error) => {
+      console.error("[Venus SDK] Firestore subscription error:", error);
+    }
+  );
+  return unsubscribe;
+}
+async function observeFirestoreCollection(collectionPath, options, onChange) {
+  const client = await getFirebaseClient();
+  const collectionRef = client.collection(client.firestore, collectionPath);
+  const constraints = [];
+  if (options.filters) {
+    for (const filter of options.filters) {
+      constraints.push(client.where(filter.field, filter.op, filter.value));
+    }
+  }
+  if (options.orderBy) {
+    for (const order of options.orderBy) {
+      constraints.push(client.orderBy(order.field, order.direction));
+    }
+  }
+  if (options.limitCount) {
+    constraints.push(client.limit(options.limitCount));
+  }
+  const q = client.query(collectionRef, ...constraints);
+  const unsubscribe = client.onSnapshot(
+    q,
+    (snapshot) => {
+      const docs = snapshot.docs.map((doc) => ({
+        id: doc.id,
+        ...doc.data()
+      }));
+      onChange(docs);
+    },
+    (error) => {
+      console.error("[Venus SDK] Firestore collection subscription error:", error);
+    }
+  );
+  return unsubscribe;
+}
+
+// src/storage/FirestoreStorageApi.ts
+var FirestoreStorageApi = class {
+  type;
+  appId;
+  client = null;
+  constructor(type, appId) {
+    this.type = type;
+    this.appId = appId;
+    if (type === "app" && !appId) {
+      throw new Error("[Venus SDK] App storage requires an appId");
+    }
+  }
+  async getClient() {
+    if (!this.client) {
+      this.client = await getFirebaseClient();
+    }
+    return this.client;
+  }
+  getProfileId() {
+    if (!this.client) {
+      throw new Error("[Venus SDK] Firebase not initialized. Call getClient() first.");
+    }
+    const profileId = this.client.getProfileId();
+    if (!profileId) {
+      throw new Error("[Venus SDK] Not signed in. Click the Venus toolbar to sign in with Google.");
+    }
+    return profileId;
+  }
+  async getDocRef() {
+    const client = await this.getClient();
+    const profileId = this.getProfileId();
+    if (this.type === "app") {
+      return client.doc(client.firestore, `profiles/${profileId}/h5AppStorage/${this.appId}`);
+    } else {
+      return client.doc(client.firestore, `profiles/${profileId}/h5GlobalStorage/data`);
+    }
+  }
+  async getItem(key) {
+    const client = await this.getClient();
+    const docRef = await this.getDocRef();
+    const snapshot = await client.getDoc(docRef);
+    if (!snapshot.exists()) {
+      return null;
+    }
+    const data = snapshot.data();
+    const value = data?.[key];
+    if (value === void 0 || value === null) {
+      return null;
+    }
+    return typeof value === "string" ? value : JSON.stringify(value);
+  }
+  async setItem(key, value) {
+    const client = await this.getClient();
+    const docRef = await this.getDocRef();
+    await client.setDoc(
+      docRef,
+      {
+        [key]: value,
+        lastUpdated: client.serverTimestamp()
+      },
+      { merge: true }
+    );
+  }
+  async removeItem(key) {
+    const client = await this.getClient();
+    const docRef = await this.getDocRef();
+    try {
+      await client.updateDoc(docRef, {
+        [key]: client.deleteField()
+      });
+    } catch (error) {
+      const err = error;
+      if (err.code !== "not-found") {
+        throw error;
+      }
+    }
+  }
+  async clear() {
+    const client = await this.getClient();
+    const docRef = await this.getDocRef();
+    try {
+      await client.deleteDoc(docRef);
+    } catch (error) {
+      const err = error;
+      if (err.code !== "not-found") {
+        throw error;
+      }
+    }
+  }
+  async key(index) {
+    const client = await this.getClient();
+    const docRef = await this.getDocRef();
+    const snapshot = await client.getDoc(docRef);
+    if (!snapshot.exists()) {
+      return null;
+    }
+    const data = snapshot.data() || {};
+    const keys = Object.keys(data).filter((k) => k !== "lastUpdated");
+    if (index < 0 || index >= keys.length) {
+      return null;
+    }
+    return keys[index];
+  }
+  async length() {
+    const client = await this.getClient();
+    const docRef = await this.getDocRef();
+    const snapshot = await client.getDoc(docRef);
+    if (!snapshot.exists()) {
+      return 0;
+    }
+    const data = snapshot.data() || {};
+    return Object.keys(data).filter((k) => k !== "lastUpdated").length;
+  }
+  async getAllItems() {
+    const client = await this.getClient();
+    const docRef = await this.getDocRef();
+    const snapshot = await client.getDoc(docRef);
+    if (!snapshot.exists()) {
+      return [];
+    }
+    const data = snapshot.data() || {};
+    return Object.keys(data).filter((k) => k !== "lastUpdated");
+  }
+  async getAllData() {
+    const client = await this.getClient();
+    const docRef = await this.getDocRef();
+    const snapshot = await client.getDoc(docRef);
+    if (!snapshot.exists()) {
+      return {};
+    }
+    const data = snapshot.data() || {};
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (key === "lastUpdated") continue;
+      result[key] = typeof value === "string" ? value : JSON.stringify(value);
+    }
+    return result;
+  }
+  async setMultipleItems(items) {
+    const client = await this.getClient();
+    const docRef = await this.getDocRef();
+    const updates = {
+      lastUpdated: client.serverTimestamp()
+    };
+    for (const item of items) {
+      updates[item.key] = item.value;
+    }
+    await client.setDoc(docRef, updates, { merge: true });
+  }
+  async removeMultipleItems(keys) {
+    const client = await this.getClient();
+    const docRef = await this.getDocRef();
+    const updates = {};
+    for (const key of keys) {
+      updates[key] = client.deleteField();
+    }
+    try {
+      await client.updateDoc(docRef, updates);
+    } catch (error) {
+      const err = error;
+      if (err.code !== "not-found") {
+        throw error;
+      }
+    }
+  }
+};
+
+// src/http/callRemoteFunction.ts
+async function callRemoteFunction(functionName, payload) {
+  console.log("[Venus SDK] callRemoteFunction:", functionName);
+  const config = getSandboxConfig();
+  if (!config) {
+    throw new Error(
+      "[Venus SDK] Sandbox mode is not enabled. Make sure the Vite plugin is configured and you are running in dev mode."
+    );
+  }
+  console.log("[Venus SDK] callRemoteFunction: Getting Firebase client...");
+  const client = await getFirebaseClient();
+  console.log("[Venus SDK] callRemoteFunction: Getting ID token...");
+  const idToken = await client.getIdTokenOrThrow();
+  console.log("[Venus SDK] callRemoteFunction: Got token, making request...");
+  const baseUrl = buildFunctionsBaseUrl(config);
+  const url = `${baseUrl}/${functionName}`;
+  const response = await fetchWithRetry(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${idToken}`
+    },
+    body: JSON.stringify(payload ?? {})
+  }, config.rpcMaxRetries ?? 0, config.rpcRetryDelayMs ?? 1e3);
+  if (!response.ok) {
+    const errorMessage = await extractErrorMessage(response, functionName);
+    throw new Error(errorMessage);
+  }
+  const text = await response.text();
+  if (!text || text.trim().length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(
+      `[Venus SDK] Backend call to ${functionName} returned invalid JSON: ${text.substring(0, 100)}`
+    );
+  }
+}
+async function fetchWithRetry(url, options, maxRetries, retryDelayMs) {
+  let lastError = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const response = await fetch(url, options);
+      if (response.ok || response.status >= 400 && response.status < 500) {
+        return response;
+      }
+      if (attempt < maxRetries) {
+        await delay(retryDelayMs);
+        continue;
+      }
+      return response;
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt < maxRetries) {
+        await delay(retryDelayMs);
+        continue;
+      }
+      throw lastError;
+    }
+  }
+  throw lastError ?? new Error("[Venus SDK] Request failed with no error details");
+}
+async function extractErrorMessage(response, functionName) {
+  try {
+    const errorBody = await response.json();
+    const message = errorBody.error || errorBody.message || response.statusText;
+    return `[Venus SDK] Backend call to ${functionName} failed (${response.status}): ${message}`;
+  } catch {
+    return `[Venus SDK] Backend call to ${functionName} failed (${response.status}): ${response.statusText}`;
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/simulation/HttpSimulationApi.ts
+var HttpSimulationApi = class {
+  appId;
+  _simulationConfig = null;
+  callRemote;
+  getProfileId;
+  activeSubscriptions = /* @__PURE__ */ new Set();
+  constructor(appId, options) {
+    this.appId = appId;
+    this.callRemote = options.callRemote ?? callRemoteFunction;
+    this.getProfileId = options.getProfileId;
+  }
+  isEnabled() {
+    return true;
+  }
+  // ===== SUBSCRIPTION (FIRESTORE) =====
+  async subscribeAsync(options) {
+    this.ensureValidSubscribeOptions(options);
+    const roomId = options.roomId;
+    const unsubscribers = [];
+    let lastInventorySignature = null;
+    let lastRunsSignature = null;
+    let latestInventory = {};
+    let latestRuns = [];
+    const sendUpdate = () => {
+      const snapshot = {
+        type: "snapshot",
+        entities: Object.entries(latestInventory).map(([entityId, quantity]) => ({
+          entityId,
+          quantity
+        })),
+        activeRuns: latestRuns,
+        timestamp: Date.now()
+      };
+      options.onUpdate(snapshot);
+    };
+    const statePath = roomId ? `h5_rooms/${roomId}/h5_simulation/${this.appId}` : `profiles/${this.getProfileId()}/h5_simulation/${this.appId}`;
+    const unsubscribeState = await observeFirestoreDocument(
+      statePath,
+      (doc) => {
+        const inventory = doc?.inventory ?? {};
+        const signature = JSON.stringify(inventory);
+        if (signature !== lastInventorySignature) {
+          lastInventorySignature = signature;
+          latestInventory = inventory;
+          sendUpdate();
+        }
+      }
+    );
+    unsubscribers.push(unsubscribeState);
+    if (options.activeRuns) {
+      const filters = roomId ? [
+        { field: "roomId", op: "==", value: roomId },
+        { field: "appId", op: "==", value: this.appId },
+        { field: "status", op: "in", value: ["running", "awaiting_collection"] }
+      ] : [
+        { field: "profileId", op: "==", value: this.getProfileId() },
+        { field: "appId", op: "==", value: this.appId },
+        { field: "status", op: "in", value: ["running", "awaiting_collection"] }
+      ];
+      const unsubscribeRuns = await observeFirestoreCollection(
+        "h5_simulation_runs",
+        {
+          filters,
+          orderBy: [{ field: "expiresAt", direction: "desc" }]
+        },
+        (docs) => {
+          const runs = docs.map((doc) => ({
+            id: doc.id,
+            recipeId: doc.recipeId,
+            status: doc.status,
+            startTime: normalizeTimestamp(doc.startTime),
+            expiresAt: normalizeTimestamp(doc.expiresAt),
+            entity: doc.entity,
+            inputs: doc.inputs,
+            outputs: doc.outputs
+          }));
+          const signature = JSON.stringify(runs);
+          if (signature !== lastRunsSignature) {
+            lastRunsSignature = signature;
+            latestRuns = runs;
+            sendUpdate();
+          }
+        }
+      );
+      unsubscribers.push(unsubscribeRuns);
+    }
+    const unsubscribe = () => {
+      for (const unsub of unsubscribers) {
+        unsub();
+      }
+      this.activeSubscriptions.delete(unsubscribe);
+    };
+    this.activeSubscriptions.add(unsubscribe);
+    return unsubscribe;
+  }
+  // ===== STATE & CONFIG (HTTP) =====
+  async getStateAsync(roomId) {
+    return this.callRemote("apiGetSimulationState", {
+      appId: this.appId,
+      roomId
+    });
+  }
+  async getConfigAsync(roomId) {
+    if (this._simulationConfig) {
+      return this._simulationConfig;
+    }
+    const config = await this.callRemote("apiGetSimulationConfig", {
+      appId: this.appId,
+      roomId
+    });
+    if (config) {
+      this._simulationConfig = config;
+      return config;
+    }
+    throw new Error("No simulation configuration available");
+  }
+  // ===== RECIPE EXECUTION (HTTP) =====
+  executeRecipeAsync(recipeId, inputs, options) {
+    return this.callRemote("apiExecuteSimulationRecipe", {
+      appId: this.appId,
+      recipeId,
+      inputs,
+      roomId: options?.roomId,
+      batchAmount: options?.batchAmount,
+      allowPartialBatch: options?.allowPartialBatch,
+      entity: options?.entity
+    });
+  }
+  collectRecipeAsync(runId) {
+    return this.callRemote("apiCollectRecipeRewards", {
+      appId: this.appId,
+      runId
+    });
+  }
+  getActiveRunsAsync(options) {
+    return this.callRemote("apiGetSimulationActiveRuns", {
+      appId: this.appId,
+      roomId: options?.roomId
+    });
+  }
+  executeScopedRecipeAsync(recipeId, entity, inputs, options) {
+    return this.callRemote("apiExecuteScopedRecipe", {
+      appId: this.appId,
+      recipeId,
+      entity,
+      inputs,
+      roomId: options?.roomId ?? null,
+      options
+    });
+  }
+  getAvailableRecipesAsync(options) {
+    return this.callRemote("apiGetAvailableRecipes", {
+      appId: this.appId,
+      roomId: options?.roomId || null,
+      includeActorRecipes: options?.includeActorRecipes || false
+    });
+  }
+  getRecipeRequirementsAsync(recipe) {
+    return this.callRemote("apiGetRecipeRequirements", {
+      appId: this.appId,
+      recipeId: recipe.recipeId,
+      entity: recipe.entity,
+      batchAmount: recipe.batchAmount
+    });
+  }
+  getBatchRecipeRequirementsAsync(recipes) {
+    return this.callRemote("apiGetBatchRecipeRequirements", {
+      appId: this.appId,
+      recipes
+    });
+  }
+  triggerRecipeChainAsync(recipeId, options) {
+    return this.callRemote("apiTriggerRecipeChain", {
+      appId: this.appId,
+      triggerRecipeId: recipeId,
+      context: options?.context,
+      roomId: options?.roomId
+    });
+  }
+  // ===== FIELD RESOLUTION & METADATA (HTTP) =====
+  async resolveFieldValueAsync(entityId, fieldPath, entity) {
+    const response = await this.callRemote("apiResolveFieldValue", {
+      appId: this.appId,
+      entityId,
+      fieldPath,
+      entity
+    });
+    return response.value;
+  }
+  getEntityMetadataAsync(entityId) {
+    return this.callRemote("apiGetEntityMetadata", {
+      appId: this.appId,
+      entityId
+    });
+  }
+  // ===== SLOT MANAGEMENT (HTTP) =====
+  async getSlotContainersAsync() {
+    const response = await this.callRemote(
+      "apiGetSlotContainers",
+      { appId: this.appId }
+    );
+    return response.containers || [];
+  }
+  async getSlotAssignmentsAsync(containerId) {
+    const response = await this.callRemote("apiGetSlotAssignments", {
+      appId: this.appId,
+      containerId
+    });
+    return Array.isArray(response) ? response : response.assignments || [];
+  }
+  assignItemToSlotAsync(containerId, slotId, itemId) {
+    return this.callRemote("apiAssignItemToSlot", {
+      appId: this.appId,
+      containerId,
+      slotId,
+      itemId
+    });
+  }
+  removeItemFromSlotAsync(containerId, slotId) {
+    return this.callRemote("apiRemoveItemFromSlot", {
+      appId: this.appId,
+      containerId,
+      slotId
+    });
+  }
+  async getAvailableItemsAsync(containerId, slotId) {
+    const response = await this.callRemote(
+      "apiGetAvailableItemsForSlot",
+      {
+        appId: this.appId,
+        containerId,
+        slotId
+      }
+    );
+    return response.availableItems || [];
+  }
+  calculatePowerPreviewAsync(containerId, slotId, candidateItemId) {
+    return this.callRemote("apiCalculatePowerPreview", {
+      appId: this.appId,
+      containerId,
+      slotId,
+      candidateItemId
+    });
+  }
+  validateSlotAssignmentAsync(containerId, slotId, itemId) {
+    return this.callRemote("apiValidateSlotAssignment", {
+      appId: this.appId,
+      containerId,
+      slotId,
+      itemId
+    });
+  }
+  executeBatchOperationsAsync(operations, validateOnly) {
+    return this.callRemote("apiBatchSlotOperations", {
+      appId: this.appId,
+      operations,
+      validateOnly
+    });
+  }
+  // ===== HELPERS =====
+  ensureValidSubscribeOptions(options) {
+    if (typeof options !== "object" || options === null) {
+      throw new Error("Simulation subscribe requires an options object");
+    }
+    const opts = options;
+    if (typeof opts.onUpdate !== "function") {
+      throw new Error("Simulation subscribe requires an onUpdate callback");
+    }
+    const hasFilter = Array.isArray(opts.entities) && opts.entities.length > 0 || Array.isArray(opts.tags) && opts.tags.length > 0 || Boolean(opts.activeRuns);
+    if (!hasFilter) {
+      throw new Error(
+        "Simulation subscribe requires at least one filter (entities, tags, activeRuns)"
+      );
+    }
+  }
+  destroy() {
+    for (const unsubscribe of this.activeSubscriptions) {
+      unsubscribe();
+    }
+    this.activeSubscriptions.clear();
+  }
+};
+function normalizeTimestamp(value) {
+  if (value === null || value === void 0) {
+    return 0;
+  }
+  if (typeof value === "object" && "toMillis" in value && typeof value.toMillis === "function") {
+    return value.toMillis();
+  }
+  if (typeof value === "object" && "_seconds" in value) {
+    const ts = value;
+    return ts._seconds * 1e3 + Math.floor((ts._nanoseconds ?? 0) / 1e6);
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  return 0;
+}
+
+// src/rooms/HttpRoomsApi.ts
+var HttpRoomsApi = class {
+  appId;
+  callRemote;
+  getProfileId;
+  constructor(appId, options) {
+    this.appId = appId;
+    this.callRemote = options.callRemote ?? callRemoteFunction;
+    this.getProfileId = options.getProfileId;
+  }
+  async createRoomAsync(options) {
+    const response = await this.callRemote("apiCreateH5Room", {
+      appId: this.appId,
+      maxPlayers: options.maxPlayers ?? 4,
+      gameType: options.gameType,
+      isPrivate: options.isPrivate ?? false,
+      roomCode: options.roomCode,
+      name: options.name,
+      description: options.description,
+      customMetadata: options.customMetadata,
+      data: options.data
+    });
+    return this.wrapRoomResponse(response);
+  }
+  async joinOrCreateRoomAsync(options) {
+    const response = await this.callRemote("apiJoinOrCreateH5Room", {
+      appId: this.appId,
+      matchCriteria: options.matchCriteria,
+      createOptions: {
+        maxPlayers: options.createOptions.maxPlayers ?? 4,
+        gameType: options.createOptions.gameType,
+        isPrivate: options.createOptions.isPrivate ?? false,
+        name: options.createOptions.name,
+        description: options.createOptions.description,
+        customMetadata: options.createOptions.customMetadata,
+        data: options.createOptions.data
+      }
+    });
+    return {
+      action: response.action,
+      room: this.wrapRoomResponse(response),
+      playersJoined: response.playersJoined
+    };
+  }
+  async joinRoomByCodeAsync(roomCode) {
+    const response = await this.callRemote("apiJoinH5RoomByCode", {
+      appId: this.appId,
+      roomCode
+    });
+    return this.wrapRoomResponse(response);
+  }
+  async getUserRoomsAsync(options) {
+    const response = await this.callRemote("apiGetUserH5Rooms", {
+      appId: this.appId,
+      includeArchived: options?.includeArchived ?? false
+    });
+    const rooms = response.rooms || [];
+    return rooms.map((roomPayload) => new VenusRoom(roomPayload));
+  }
+  async leaveRoomAsync(room) {
+    await this.callRemote("apiLeaveH5Room", {
+      appId: this.appId,
+      roomId: room.id
+    });
+  }
+  async kickPlayerAsync(room, targetProfileId, options) {
+    await this.callRemote("apiKickH5RoomPlayer", {
+      appId: this.appId,
+      roomId: room.id,
+      targetProfileId,
+      reason: options?.reason
+    });
+  }
+  async startRoomGameAsync(room, options) {
+    await this.callRemote("apiStartH5Game", {
+      appId: this.appId,
+      roomId: room.id,
+      gameConfig: options?.gameConfig,
+      turnOrder: options?.turnOrder
+    });
+  }
+  /**
+   * Wrap a room response into a VenusRoom instance.
+   */
+  wrapRoomResponse(response) {
+    if (response.room) {
+      return new VenusRoom(response.room);
+    }
+    return new VenusRoom({
+      id: response.roomId || "",
+      roomCode: response.roomCode || "",
+      ...response
+    });
+  }
+};
+
+// src/rooms/FirestoreRoomsApi.ts
+var FirestoreRoomsApi = class {
+  client = null;
+  activeSubscriptions = /* @__PURE__ */ new Set();
+  async getClient() {
+    if (!this.client) {
+      this.client = await getFirebaseClient();
+    }
+    return this.client;
+  }
+  getProfileId() {
+    if (!this.client) {
+      throw new Error("[Venus SDK] Firebase not initialized. Call getClient() first.");
+    }
+    const profileId = this.client.getProfileId();
+    if (!profileId) {
+      throw new Error("[Venus SDK] Not signed in. Click the Venus toolbar to sign in with Google.");
+    }
+    return profileId;
+  }
+  // ===== ROOM DATA OPERATIONS =====
+  async getRoomDataAsync(room) {
+    const client = await this.getClient();
+    const roomRef = client.doc(client.firestore, `h5_rooms/${room.id}`);
+    const snapshot = await client.getDoc(roomRef);
+    if (!snapshot.exists()) {
+      throw new Error(`Room ${room.id} not found`);
+    }
+    const roomData = snapshot.data();
+    return roomData?.data || {};
+  }
+  async updateRoomDataAsync(room, updates, options) {
+    const client = await this.getClient();
+    const roomRef = client.doc(client.firestore, `h5_rooms/${room.id}`);
+    const merge = options?.merge !== false;
+    const updateData = {
+      data: merge ? updates : updates,
+      updatedAt: client.serverTimestamp()
+    };
+    await client.updateDoc(roomRef, updateData);
+  }
+  // ===== MESSAGE OPERATIONS =====
+  async sendRoomMessageAsync(room, request) {
+    const client = await this.getClient();
+    const messagesRef = client.collection(client.firestore, `h5_rooms/${room.id}/messages`);
+    const messageDoc = await client.addDoc(messagesRef, {
+      roomId: room.id,
+      senderId: this.getProfileId(),
+      content: request.message.content || "",
+      type: request.message.type || "chat",
+      metadata: request.metadata || {},
+      timestamp: client.serverTimestamp()
+    });
+    return messageDoc.id;
+  }
+  // ===== PROPOSED MOVES =====
+  async proposeMoveAsync(room, request) {
+    const client = await this.getClient();
+    const movesRef = client.collection(client.firestore, `h5_rooms/${room.id}/proposed_moves`);
+    const moveDoc = await client.addDoc(movesRef, {
+      proposerProfileId: this.getProfileId(),
+      roomId: room.id,
+      gameSpecificState: request.gameSpecificState,
+      moveType: request.moveType,
+      clientContext: request.clientContext || {},
+      clientProposalId: request.clientProposalId,
+      timestamp: client.serverTimestamp(),
+      serverGenericValidationStatus: "pending"
+    });
+    return { proposedMoveId: moveDoc.id };
+  }
+  async validateMoveAsync(room, moveId, verdict) {
+    const client = await this.getClient();
+    const moveRef = client.doc(client.firestore, `h5_rooms/${room.id}/proposed_moves/${moveId}`);
+    await client.updateDoc(moveRef, {
+      serverGenericValidationStatus: verdict.isValid ? "valid" : "invalid",
+      serverGenericValidationReason: verdict.reason || null,
+      validatorId: verdict.validatorId || this.getProfileId(),
+      updatedAt: client.serverTimestamp()
+    });
+    return {
+      success: true,
+      moveId,
+      isValid: verdict.isValid,
+      reason: verdict.reason
+    };
+  }
+  // ===== SUBSCRIPTIONS =====
+  async subscribeAsync(room, options) {
+    const client = await this.getClient();
+    const unsubscribers = [];
+    if (options?.onData) {
+      const roomRef = client.doc(client.firestore, `h5_rooms/${room.id}`);
+      const unsubscribeData = client.onSnapshot(
+        roomRef,
+        (snapshot) => {
+          if (snapshot.exists()) {
+            const roomData = {
+              id: snapshot.id,
+              ...snapshot.data()
+            };
+            const update = {
+              type: "H5_ROOM_DATA_UPDATED",
+              roomId: room.id,
+              roomData,
+              timestamp: Date.now()
+            };
+            options.onData(update);
+          }
+        },
+        (error) => {
+          console.error("[Venus SDK] Room subscription error:", error);
+        }
+      );
+      unsubscribers.push(unsubscribeData);
+    }
+    if (options?.onMessages) {
+      const messagesRef = client.collection(client.firestore, `h5_rooms/${room.id}/messages`);
+      const messagesQuery = client.query(
+        messagesRef,
+        client.orderBy("timestamp", "desc"),
+        client.limit(50)
+      );
+      const unsubscribeMessages = client.onSnapshot(
+        messagesQuery,
+        (snapshot) => {
+          snapshot.docChanges().forEach((change) => {
+            const messageData = {
+              id: change.doc.id,
+              ...change.doc.data()
+            };
+            let eventType;
+            if (change.type === "added") {
+              eventType = "H5_ROOM_MESSAGE_RECEIVED";
+            } else if (change.type === "modified") {
+              eventType = "H5_ROOM_MESSAGE_UPDATED";
+            } else {
+              eventType = "H5_ROOM_MESSAGE_DELETED";
+            }
+            const event = {
+              type: eventType,
+              roomId: room.id,
+              message: messageData,
+              timestamp: Date.now()
+            };
+            options.onMessages(event);
+          });
+        },
+        (error) => {
+          console.error("[Venus SDK] Messages subscription error:", error);
+        }
+      );
+      unsubscribers.push(unsubscribeMessages);
+    }
+    if (options?.onGameEvents) {
+      const movesRef = client.collection(client.firestore, `h5_rooms/${room.id}/proposed_moves`);
+      const movesQuery = client.query(
+        movesRef,
+        client.orderBy("timestamp", "desc"),
+        client.limit(10)
+      );
+      const unsubscribeMoves = client.onSnapshot(
+        movesQuery,
+        (snapshot) => {
+          snapshot.docChanges().forEach((change) => {
+            const moveData = {
+              id: change.doc.id,
+              ...change.doc.data()
+            };
+            const event = {
+              type: "app:h5:proposedMoveValidationUpdated",
+              roomId: room.id,
+              proposedMoveData: moveData,
+              proposedMoveId: change.doc.id,
+              changeType: change.type,
+              timestamp: Date.now()
+            };
+            options.onGameEvents(event);
+          });
+        },
+        (error) => {
+          console.error("[Venus SDK] Proposed moves subscription error:", error);
+        }
+      );
+      unsubscribers.push(unsubscribeMoves);
+    }
+    const unsubscribe = () => {
+      for (const unsub of unsubscribers) {
+        unsub();
+      }
+      this.activeSubscriptions.delete(unsubscribe);
+    };
+    this.activeSubscriptions.add(unsubscribe);
+    return unsubscribe;
+  }
+  /**
+   * Clean up all active subscriptions.
+   */
+  destroy() {
+    for (const unsubscribe of this.activeSubscriptions) {
+      unsubscribe();
+    }
+    this.activeSubscriptions.clear();
+  }
+};
+
+// src/rooms/CompositeRemoteRoomsApi.ts
+var CompositeRemoteRoomsApi = class {
+  httpApi;
+  firestoreApi;
+  constructor(httpApi, firestoreApi) {
+    this.httpApi = httpApi;
+    this.firestoreApi = firestoreApi;
+  }
+  // ===== HTTP-backed lifecycle operations =====
+  async createRoomAsync(options) {
+    return this.httpApi.createRoomAsync(options);
+  }
+  async joinOrCreateRoomAsync(options) {
+    return this.httpApi.joinOrCreateRoomAsync(options);
+  }
+  async joinRoomByCodeAsync(roomCode) {
+    return this.httpApi.joinRoomByCodeAsync(roomCode);
+  }
+  async getUserRoomsAsync(options) {
+    return this.httpApi.getUserRoomsAsync(options);
+  }
+  async leaveRoomAsync(room) {
+    return this.httpApi.leaveRoomAsync(room);
+  }
+  async kickPlayerAsync(room, targetProfileId, options) {
+    return this.httpApi.kickPlayerAsync(room, targetProfileId, options);
+  }
+  async startRoomGameAsync(room, options) {
+    return this.httpApi.startRoomGameAsync(room, options);
+  }
+  // ===== Firestore-backed data operations =====
+  async subscribeAsync(room, options) {
+    return this.firestoreApi.subscribeAsync(room, options);
+  }
+  async updateRoomDataAsync(room, updates, options) {
+    return this.firestoreApi.updateRoomDataAsync(room, updates, options);
+  }
+  async getRoomDataAsync(room) {
+    return this.firestoreApi.getRoomDataAsync(room);
+  }
+  async sendRoomMessageAsync(room, message) {
+    return this.firestoreApi.sendRoomMessageAsync(room, message);
+  }
+  async proposeMoveAsync(room, request) {
+    return this.firestoreApi.proposeMoveAsync(room, request);
+  }
+  async validateMoveAsync(room, moveId, verdict) {
+    return this.firestoreApi.validateMoveAsync(room, moveId, verdict);
+  }
+  /**
+   * Clean up all active subscriptions.
+   */
+  destroy() {
+    this.firestoreApi.destroy();
+  }
+};
+
+// src/leaderboard/HttpLeaderboardApi.ts
+var HttpLeaderboardApi = class {
+  appId;
+  callRemote;
+  getProfileId;
+  constructor(appId, options) {
+    this.appId = appId;
+    this.callRemote = options.callRemote ?? callRemoteFunction;
+    this.getProfileId = options.getProfileId;
+  }
+  async createScoreToken(mode) {
+    return this.callRemote("apiCreateScoreToken", {
+      appId: this.appId,
+      mode: mode || "default"
+    });
+  }
+  async submitScore(params) {
+    return this.callRemote("apiSubmitScore", {
+      appId: this.appId,
+      token: params.token,
+      score: params.score,
+      duration: params.duration,
+      mode: params.mode || "default",
+      telemetry: params.telemetry,
+      metadata: params.metadata
+    });
+  }
+  async getPagedScores(options) {
+    return this.callRemote("apiGetPagedScores", {
+      appId: this.appId,
+      mode: options?.mode || "default",
+      period: options?.period || "alltime",
+      periodDate: options?.periodDate,
+      cursor: options?.cursor,
+      limit: options?.limit,
+      variant: options?.variant || "standard",
+      topCount: options?.topCount,
+      contextAhead: options?.contextAhead,
+      contextBehind: options?.contextBehind
+    });
+  }
+  async getMyRank(options) {
+    return this.callRemote("apiGetMyRank", {
+      appId: this.appId,
+      mode: options?.mode || "default",
+      period: options?.period || "alltime",
+      periodDate: options?.periodDate
+    });
+  }
+  async getPodiumScores(options) {
+    return this.callRemote("apiGetPodiumScores", {
+      appId: this.appId,
+      mode: options?.mode || "default",
+      period: options?.period || "alltime",
+      periodDate: options?.periodDate,
+      topCount: options?.topCount,
+      contextAhead: options?.contextAhead,
+      contextBehind: options?.contextBehind
+    });
+  }
+};
+
+// src/SandboxHost.ts
+var SandboxHost = class {
+  ads;
+  analytics;
+  deviceCache;
+  appStorage;
+  globalStorage;
+  avatar3d;
+  navigation;
+  notifications;
+  popups;
+  profile;
+  system;
+  cdn;
+  time;
+  ai;
+  haptics;
+  features;
+  lifecycle;
+  simulation;
+  rooms;
+  logging;
+  iap;
+  leaderboard;
+  preloader;
+  social;
+  context;
+  state = 0 /* PLAYING */;
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  venusApi;
+  _isInitialized = false;
+  _overlay;
+  _mockLifecyclesApi;
+  _mockAdsApi;
+  client = null;
+  clientReady = null;
+  authUnsubscribe = null;
+  cleanupFunctions = [];
+  constructor(venusApi) {
+    this.venusApi = venusApi;
+    this._overlay = this.createOverlay();
+    this._mockAdsApi = new MockAdsApi(this._overlay);
+    this._mockLifecyclesApi = new MockLifecycleApi();
+    this.ads = this._mockAdsApi;
+    this.analytics = new MockAnalyticsApi();
+    const sandboxConfig = getSandboxConfig();
+    const gameId = sandboxConfig.gameId;
+    console.log("[Venus SDK] SandboxHost: Connecting to:", sandboxConfig.target);
+    const getProfileId = () => {
+      if (this.client && this.client.isSignedIn()) {
+        return this.client.getProfileId() || "unknown-user";
+      }
+      return "unknown-user";
+    };
+    this.deviceCache = createMockStorageApi("deviceCache", "");
+    this.appStorage = new FirestoreStorageApi("app", gameId);
+    this.globalStorage = new FirestoreStorageApi("global");
+    this.simulation = new HttpSimulationApi(gameId, { getProfileId });
+    this.leaderboard = new HttpLeaderboardApi(gameId, { getProfileId });
+    const httpRoomsApi = new HttpRoomsApi(gameId, { getProfileId });
+    const firestoreRoomsApi = new FirestoreRoomsApi();
+    this.rooms = new CompositeRemoteRoomsApi(httpRoomsApi, firestoreRoomsApi);
+    this.avatar3d = new MockAvatarApi(venusApi);
+    this.navigation = new MockNavigationApi(venusApi);
+    this.notifications = new MockNotificationsApi(venusApi);
+    this.popups = new MockPopupsApi(this._overlay);
+    this.profile = new MockProfileApi(venusApi);
+    const deviceApi = new MockDeviceApi(venusApi);
+    const environmentApi = new MockEnvironmentApi(venusApi);
+    this.system = new MockSystemApi(deviceApi, environmentApi, venusApi);
+    this.cdn = new MockCdnApi(venusApi);
+    this.time = new MockTimeApi(venusApi);
+    this.ai = new MockAiApi();
+    this.haptics = new MockHapticsApi(venusApi);
+    this.features = new MockFeaturesApi();
+    this.lifecycle = this._mockLifecyclesApi;
+    this.logging = new MockLoggingApi();
+    this.iap = new MockIapApi();
+    this.social = new MockSocialApi();
+    initializeRoomsApi(this.venusApi, this);
+    this.preloader = new MockPreloaderApi();
+    venusApi.isMock = () => true;
+    this.venusApi.sharedAssets = new MockSharedAssetsApi(this.venusApi);
+    this.setupSandboxSignIn();
+  }
+  /**
+   * Set up global sign-in/sign-out functions and auth state broadcasting.
+   */
+  setupSandboxSignIn() {
+    if (typeof window === "undefined") return;
+    const broadcastAuthState = (user) => {
+      window.dispatchEvent(
+        new CustomEvent("venus-auth-state-changed", {
+          detail: {
+            signedIn: user !== null,
+            user: user ? {
+              uid: user.uid,
+              email: user.email,
+              displayName: user.displayName
+            } : null
+          }
+        })
+      );
+    };
+    console.log("[Venus SDK] SandboxHost: Initializing Firebase client...");
+    this.clientReady = getFirebaseClient().then((client) => {
+      this.client = client;
+      console.log("[Venus SDK] SandboxHost: Firebase client initialized, currentUser:", client.getCurrentUser()?.uid ?? "none");
+      this.authUnsubscribe = client.onAuthStateChanged(async (user) => {
+        console.log("[Venus SDK] SandboxHost: Auth state changed, user:", user?.uid ?? "signed out");
+        broadcastAuthState(user);
+        if (user) {
+          await this.ensureProfileExists(user);
+        }
+      });
+      return client;
+    });
+    this.clientReady.catch((error) => {
+      console.error("[Venus SDK] SandboxHost: Firebase client init failed:", error);
+    });
+    const checkAuthHandler = async () => {
+      const client = await getFirebaseClient();
+      broadcastAuthState(client.getCurrentUser());
+    };
+    window.addEventListener("venus-check-auth-state", checkAuthHandler);
+    this.cleanupFunctions.push(() => window.removeEventListener("venus-check-auth-state", checkAuthHandler));
+    window.__VENUS_SANDBOX_SIGN_IN__ = () => {
+      if (this.client) {
+        return this.client.signInWithGoogle().then(() => console.log("[Venus SDK] Google sign-in successful")).catch((error) => {
+          console.error("[Venus SDK] Google sign-in failed:", error);
+          throw error;
+        });
+      }
+      if (!this.clientReady) {
+        throw new Error("[Venus SDK] Firebase not configured.");
+      }
+      console.warn("[Venus SDK] Firebase client still initializing, please wait a moment...");
+      throw new Error("[Venus SDK] Firebase client still initializing. Please wait a moment and try again.");
+    };
+    window.__VENUS_SANDBOX_SIGN_OUT__ = async () => {
+      try {
+        const client = await getFirebaseClient();
+        await client.signOut();
+        console.log("[Venus SDK] Sign-out successful");
+      } catch (error) {
+        console.error("[Venus SDK] Sign-out failed:", error);
+        throw error;
+      }
+    };
+    this.cleanupFunctions.push(() => {
+      delete window.__VENUS_SANDBOX_SIGN_IN__;
+      delete window.__VENUS_SANDBOX_SIGN_OUT__;
+    });
+  }
+  /**
+   * Ensure a profile exists for the signed-in user.
+   * Checks if profile exists first to avoid overwriting existing profiles on staging/dev.
+   * Only creates a new profile if one doesn't exist.
+   */
+  async ensureProfileExists(user) {
+    try {
+      console.log("[Venus SDK] Checking if profile exists for user:", user.uid);
+      try {
+        const existingProfile = await callRemoteFunction("getProfile", {});
+        if (existingProfile?.id) {
+          console.log("[Venus SDK] Profile already exists:", existingProfile.id);
+          return;
+        }
+      } catch (checkError) {
+        const err = checkError;
+        if (!err?.message?.includes("not found") && err?.status !== 404) {
+          console.warn("[Venus SDK] Error checking profile, will attempt creation:", err?.message);
+        }
+      }
+      console.log("[Venus SDK] No profile found, creating one for user:", user.uid);
+      const shortId = user.uid.slice(-8);
+      const timestamp = Date.now();
+      await callRemoteFunction("createUserProfile", {
+        name: user.displayName || `Dev User ${shortId}`,
+        username: `dev_${shortId}_${timestamp}`,
+        description: "Auto-created for sandbox development",
+        isAnonymous: true,
+        // Uses retry logic for username conflicts
+        onboardingCompleted: true
+      });
+      console.log("[Venus SDK] Profile created for user:", user.uid);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn("[Venus SDK] Could not ensure profile exists:", message);
+    }
+  }
+  initialize(_options) {
+    this._isInitialized = true;
+    this.venusApi._profileData = this.profile.getCurrentProfile();
+    this.venusApi._deviceData = this.system.getDevice();
+    this.venusApi._environmentData = this.system.getEnvironment();
+    this.venusApi._localeData = this.venusApi._mock?.locale || "en-US";
+    this.venusApi._languageCodeData = this.venusApi._mock?.languageCode || "en";
+    this.context = {
+      initializeAsleep: false,
+      safeArea: this.venusApi._safeAreaData
+    };
+    return Promise.resolve(this.context);
+  }
+  // ============================================================
+  // Overlay and UI methods (shared with MockHost)
+  // ============================================================
+  createOverlay() {
+    const overlayContainer = document.createElement("div");
+    overlayContainer.id = "venus-sandbox-overlay";
+    overlayContainer.style.cssText = `
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      pointer-events: none;
+      z-index: 10000;
+    `;
+    document.body.appendChild(overlayContainer);
+    const menuButton = this.createOverlayButton(
+      "close",
+      "Menu",
+      { x: window.innerWidth - 48, y: 16, width: 32, height: 32 },
+      () => {
+        this.handleMenuButtonClicked();
+      },
+      "rgba(59, 130, 246, 0.7)",
+      "#FFFFFF"
+    );
+    overlayContainer.appendChild(menuButton);
+    const adOverlay = this.setupAdOverlay();
+    const actionSheet = this.setupActionSheetOverlay();
+    const resizeHandler = () => {
+      this.updateOverlayLayout();
+    };
+    window.addEventListener("resize", resizeHandler);
+    this.cleanupFunctions.push(() => window.removeEventListener("resize", resizeHandler));
+    return {
+      container: overlayContainer,
+      elements: {
+        menuButton
+      },
+      appVisibilityState: "visible",
+      actionSheetOverlay: actionSheet,
+      adOverlay,
+      showAdOverlay: () => {
+        return this.showAdOverlay("rewarded");
+      },
+      showActionSheet: (items, options) => {
+        return this.showActionSheetOverlay(items, options);
+      }
+    };
+  }
+  async handleMenuButtonClicked() {
+    if (this.state === 0 /* PLAYING */) {
+      this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
+      this.state = 1 /* PAUSED */;
+    }
+    const actionSheetItems = [];
+    const awakeAction = { label: "\u23F0 Awake", id: "awakeAction" };
+    const sleepAction = { label: "\u{1F4A4} Sleep", id: "sleepAction" };
+    const quitAction = { label: "\u{1F6D1} Quit", id: "quitAction" };
+    const playAction = { label: "\u25B6\uFE0F Play", id: "playAction" };
+    if (this.state === 1 /* PAUSED */) {
+      actionSheetItems.push(sleepAction);
+    } else if (this.state === 2 /* SLEEPING */) {
+      actionSheetItems.push(awakeAction);
+    }
+    if (this.state !== 3 /* TERMINATED */) {
+      actionSheetItems.push(quitAction);
+    } else if (this.state === 3 /* TERMINATED */) {
+      actionSheetItems.push(playAction);
+    }
+    const action = await this.showActionSheetOverlay(actionSheetItems);
+    if (action === awakeAction.id) {
+      this.tryAwake();
+    } else if (action === sleepAction.id) {
+      this.trySleep();
+    } else if (action === playAction.id) {
+      this.tryPlay();
+    } else if (action === quitAction.id) {
+      this.tryQuit();
+    } else {
+      this.tryResume();
+    }
+  }
+  tryAwake() {
+    if (this.state === 2 /* SLEEPING */) {
+      this.triggerLifecycleEvent("AWAKE" /* AWAKE */);
+      this.state = 1 /* PAUSED */;
+    }
+  }
+  trySleep() {
+    if (this.state === 1 /* PAUSED */) {
+      this.triggerLifecycleEvent("SLEEP" /* SLEEP */);
+      this.state = 2 /* SLEEPING */;
+    }
+  }
+  tryPlay() {
+    if (this.state === 3 /* TERMINATED */) {
+      this.triggerLifecycleEvent("AWAKE" /* AWAKE */);
+      this.state = 1 /* PAUSED */;
+      this.triggerLifecycleEvent("RESUME" /* RESUME */);
+      this.state = 0 /* PLAYING */;
+    }
+  }
+  tryQuit() {
+    if (this.state === 0 /* PLAYING */) {
+      this.triggerLifecycleEvent("PAUSE" /* PAUSE */);
+      this.state = 1 /* PAUSED */;
+    }
+    if (this.state === 1 /* PAUSED */) {
+      this.triggerLifecycleEvent("SLEEP" /* SLEEP */);
+      this.state = 2 /* SLEEPING */;
+    }
+    if (this.state === 2 /* SLEEPING */) {
+      this.triggerLifecycleEvent("QUIT" /* QUIT */);
+      this.state = 3 /* TERMINATED */;
+    }
+  }
+  tryResume() {
+    if (this.state === 1 /* PAUSED */) {
+      this.triggerLifecycleEvent("RESUME" /* RESUME */);
+      this.state = 0 /* PLAYING */;
+    }
+  }
+  async showAdOverlay(type) {
+    return new Promise((resolve) => {
+      const overlay = this._overlay;
+      const adOverlay = overlay.adOverlay;
+      overlay.adOverlay.innerHTML = "";
+      const heading = document.createElement("h1");
+      heading.style.cssText = `
+        font-size: 24px;
+        margin-bottom: 20px;
+        text-align: center;
+      `;
+      heading.innerText = type === "interstitial" ? "INTERSTITIAL AD" : "REWARDED VIDEO AD";
+      overlay.adOverlay.appendChild(heading);
+      const content = document.createElement("div");
+      content.style.cssText = `
+        width: 300px;
+        height: 250px;
+        background-color: #1e40af;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        margin-bottom: 20px;
+        border-radius: 8px;
+      `;
+      content.innerText = "Mock Ad Content";
+      adOverlay.appendChild(content);
+      const timer = document.createElement("p");
+      timer.style.cssText = `
+        margin-bottom: 20px;
+        font-size: 16px;
+      `;
+      timer.innerText = "Normally ads would have a timer...";
+      adOverlay.appendChild(timer);
+      const okButton = document.createElement("button");
+      okButton.style.cssText = `
+        padding: 10px 40px;
+        background-color: #2563eb;
+        color: white;
+        border: none;
+        border-radius: 4px;
+        font-size: 16px;
+        cursor: pointer;
+      `;
+      okButton.innerText = "Close Ad";
+      adOverlay.appendChild(okButton);
+      adOverlay.style.display = "flex";
+      okButton.onclick = () => {
+        this.hideAdOverlay();
+        resolve(true);
+      };
+    });
+  }
+  hideAdOverlay() {
+    const overlay = this._overlay;
+    if (overlay.adOverlay) {
+      overlay.adOverlay.style.display = "none";
+    }
+  }
+  setupActionSheetOverlay() {
+    const actionSheetOverlay = document.createElement("div");
+    actionSheetOverlay.id = "venus-action-sheet-overlay";
+    actionSheetOverlay.style.cssText = `
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      background-color: rgba(0, 0, 0, 0.5);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      z-index: 10600;
+      font-family: sans-serif;
+      display: none;
+    `;
+    document.body.appendChild(actionSheetOverlay);
+    return actionSheetOverlay;
+  }
+  createOverlayButton(id, text, position, onClick, background, color) {
+    const button = document.createElement("button");
+    button.id = `venus-sandbox-${id}-button`;
+    button.innerText = text;
+    button.style.cssText = `
+      position: absolute;
+      left: ${position.x}px;
+      top: ${position.y}px;
+      width: ${position.width}px;
+      min-width: ${position.width}px;
+      height: ${position.height}px;
+      background: ${background};
+      color: ${color};
+      border: none;
+      border-radius: 8px;
+      font-family: sans-serif;
+      font-weight: bold;
+      font-size: ${Math.min(position.width, position.height) / 3}px;
+      cursor: pointer;
+      pointer-events: auto;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      opacity: 0.9;
+      transition: opacity 0.2s;
+    `;
+    button.addEventListener("click", onClick);
+    button.addEventListener("mouseover", () => {
+      button.style.opacity = "1";
+    });
+    button.addEventListener("mouseout", () => {
+      button.style.opacity = "0.9";
+    });
+    return button;
+  }
+  updateOverlayLayout() {
+    const overlay = this._overlay;
+    const menuBtn = overlay.elements.menuButton;
+    menuBtn.style.left = `${window.innerWidth - 48}px`;
+    menuBtn.style.top = "16px";
+    menuBtn.style.width = "32px";
+    menuBtn.style.minWidth = "32px";
+    menuBtn.style.height = "32px";
+  }
+  triggerLifecycleEvent(name) {
+    console.log("Trigger Lifecycle Event: ", name);
+    if (name === "PAUSE" /* PAUSE */) {
+      this._mockLifecyclesApi.triggerPauseCallbacks();
+    } else if (name === "RESUME" /* RESUME */) {
+      this._mockLifecyclesApi.triggerResumeCallbacks();
+    } else if (name === "QUIT" /* QUIT */) {
+      this._mockLifecyclesApi.triggerQuitCallbacks();
+    } else if (name === "AWAKE" /* AWAKE */) {
+      this._mockLifecyclesApi.triggerAwakeCallbacks();
+    } else if (name === "SLEEP" /* SLEEP */) {
+      this._mockLifecyclesApi.triggerSleepCallbacks();
+    }
+  }
+  setupAdOverlay() {
+    const adOverlay = document.createElement("div");
+    adOverlay.id = "venus-ad-overlay";
+    adOverlay.style.cssText = `
+      position: fixed;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      background-color: rgba(37, 99, 235, 0.9);
+      color: white;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      z-index: 10500;
+      font-family: sans-serif;
+      display: none;
+    `;
+    document.body.appendChild(adOverlay);
+    return adOverlay;
+  }
+  showActionSheetOverlay(items, options) {
+    return new Promise((resolve) => {
+      const overlay = this._overlay;
+      overlay.actionSheetOverlay.innerHTML = "";
+      overlay.actionSheetOverlay.style.display = "flex";
+      const actionSheet = document.createElement("div");
+      actionSheet.className = "venus-action-sheet";
+      actionSheet.style.cssText = `
+        background-color: white;
+        border-radius: 8px;
+        width: 80%;
+        max-width: 400px;
+        max-height: 80%;
+        display: flex;
+        flex-direction: column;
+        overflow: hidden;
+        color: black;
+      `;
+      if (options?.title) {
+        const titleContainer = document.createElement("div");
+        titleContainer.style.cssText = `
+          padding: 16px;
+          border-bottom: 1px solid #eaeaea;
+          font-weight: bold;
+          font-size: 18px;
+          text-align: center;
+          color: black;
+        `;
+        titleContainer.innerText = options.title;
+        actionSheet.appendChild(titleContainer);
+      }
+      if (options?.message) {
+        const messageContainer = document.createElement("div");
+        messageContainer.style.cssText = `
+          padding: 8px 16px;
+          color: #666;
+          font-size: 14px;
+          text-align: center;
+        `;
+        messageContainer.innerText = options.message;
+        actionSheet.appendChild(messageContainer);
+      }
+      const optionsContainer = document.createElement("div");
+      optionsContainer.style.cssText = `
+        overflow-y: auto;
+        max-height: 300px;
+      `;
+      items.forEach((item, index) => {
+        const optionItem = document.createElement("div");
+        optionItem.style.cssText = `
+          padding: 12px 16px;
+          border-bottom: 1px solid #eaeaea;
+          cursor: pointer;
+          display: flex;
+          align-items: center;
+          transition: background-color 0.2s;
+          color: black;
+        `;
+        optionItem.addEventListener("mouseover", () => {
+          optionItem.style.backgroundColor = "#f5f5f5";
+        });
+        optionItem.addEventListener("mouseout", () => {
+          optionItem.style.backgroundColor = "white";
+        });
+        if (item.icon) {
+          const iconSpan = document.createElement("span");
+          iconSpan.style.cssText = `
+            margin-right: 12px;
+            font-size: 16px;
+          `;
+          iconSpan.innerText = item.icon;
+          optionItem.appendChild(iconSpan);
+        }
+        const labelSpan = document.createElement("span");
+        labelSpan.style.cssText = `color: black;`;
+        labelSpan.innerText = item.label;
+        optionItem.appendChild(labelSpan);
+        optionItem.addEventListener("click", () => {
+          this.hideActionSheetOverlay();
+          const optionId = item.id !== void 0 ? item.id : index;
+          resolve(optionId);
+        });
+        optionsContainer.appendChild(optionItem);
+      });
+      actionSheet.appendChild(optionsContainer);
+      if (!options?.disableCancel) {
+        const cancelButton = document.createElement("div");
+        cancelButton.style.cssText = `
+          padding: 14px 16px;
+          text-align: center;
+          font-weight: bold;
+          cursor: pointer;
+          color: #3b82f6;
+          border-top: 1px solid #eaeaea;
+        `;
+        cancelButton.innerText = options?.cancelButtonText || "Cancel";
+        cancelButton.addEventListener("click", () => {
+          this.hideActionSheetOverlay();
+          resolve(null);
+        });
+        actionSheet.appendChild(cancelButton);
+      }
+      if (!options?.disableCancel) {
+        const closeButton = document.createElement("div");
+        closeButton.style.cssText = `
+          position: absolute;
+          top: 8px;
+          right: 8px;
+          width: 24px;
+          height: 24px;
+          border-radius: 12px;
+          background-color: rgba(0,0,0,0.1);
+          color: #666;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          cursor: pointer;
+          font-size: 14px;
+        `;
+        closeButton.innerText = "\u2715";
+        closeButton.addEventListener("click", () => {
+          this.hideActionSheetOverlay();
+          resolve(null);
+        });
+        actionSheet.appendChild(closeButton);
+        overlay.actionSheetOverlay.appendChild(actionSheet);
+      }
+    });
+  }
+  hideActionSheetOverlay() {
+    const overlay = this._overlay;
+    if (overlay.actionSheetOverlay) {
+      overlay.actionSheetOverlay.style.display = "none";
+    }
+  }
+  /**
+   * Clean up all resources held by SandboxHost.
+   * Call this when the host is no longer needed to prevent memory leaks.
+   */
+  destroy() {
+    if (this.authUnsubscribe) {
+      this.authUnsubscribe();
+      this.authUnsubscribe = null;
+    }
+    for (const cleanup of this.cleanupFunctions) {
+      try {
+        cleanup();
+      } catch (e) {
+        console.warn("[Venus SDK] Cleanup error:", e);
+      }
+    }
+    this.cleanupFunctions.length = 0;
+    if (this.simulation && "destroy" in this.simulation) {
+      this.simulation.destroy();
+    }
+    if (this.rooms && "destroy" in this.rooms) {
+      this.rooms.destroy();
+    }
+    if (typeof document !== "undefined") {
+      const overlay = this._overlay;
+      if (overlay.container?.parentNode) {
+        overlay.container.parentNode.removeChild(overlay.container);
+      }
+      if (overlay.adOverlay?.parentNode) {
+        overlay.adOverlay.parentNode.removeChild(overlay.adOverlay);
+      }
+      if (overlay.actionSheetOverlay?.parentNode) {
+        overlay.actionSheetOverlay.parentNode.removeChild(overlay.actionSheetOverlay);
+      }
+    }
+    this.client = null;
+    this.clientReady = null;
+  }
+};
+
+export { SandboxHost };
+//# sourceMappingURL=SandboxHost-JNX5UBGL.js.map
+//# sourceMappingURL=SandboxHost-JNX5UBGL.js.map