@virex-tech/paywallo-sdk 1.1.3 → 1.3.0

package/dist/index.mjs

@@ -145,9 +145,6 @@ var SecureStorage = class {
   // eslint-disable-next-line @typescript-eslint/no-useless-constructor
   constructor(_debug = false) {
   }
-  /**
-   * Get a value, trying Keychain first (survives reinstalls on iOS), then AsyncStorage.
-   */
   async get(key) {
     const keychainValue = await this.getFromKeychain(key);
     if (keychainValue) {
@@ -163,9 +160,6 @@ var SecureStorage = class {
       return null;
     }
   }
-  /**
-   * Set a value in both Keychain (if available) and AsyncStorage.
-   */
   async set(key, value) {
     try {
       await Promise.all([
@@ -229,11 +223,13 @@ var secureStorage = new SecureStorage();
 
 // src/domains/identity/IdentityManager.ts
 var DEVICE_ID_KEY = "device_id";
+var ANON_ID_KEY = "anon_id";
 var USER_EMAIL_KEY = "user_email";
 var USER_PROPERTIES_KEY = "user_properties";
 var IdentityManager = class {
   constructor() {
     this.deviceId = null;
+    this.anonId = null;
     this.email = null;
     this.properties = {};
     this.apiClient = null;
@@ -260,23 +256,23 @@ var IdentityManager = class {
       try {
         if (DeviceInfo) {
           this.deviceId = await DeviceInfo.getUniqueId();
-          this.log("Got device ID from DeviceInfo:", this.deviceId);
         } else {
           this.deviceId = generateUUID();
-          this.log("DeviceInfo not installed, using generated UUID:", this.deviceId);
         }
       } catch {
         this.deviceId = generateUUID();
-        this.log("DeviceInfo unavailable, using generated UUID:", this.deviceId);
       }
       const stored = await this.secureStorage.set(DEVICE_ID_KEY, this.deviceId);
       if (!stored) {
-        this.log("Failed to persist device ID to secure storage, using fallback");
         await this.secureStorage.set("device_id_fallback", this.deviceId).catch(() => {
-          this.log("Fallback also failed \u2014 device ID only in memory");
         });
       }
     }
+    if (!this.anonId) {
+      this.anonId = "$paywallo_anon:" + generateUUID();
+      await this.secureStorage.set(ANON_ID_KEY, this.anonId).catch(() => {
+      });
+    }
     this.initialized = true;
     return this.deviceId ?? "";
   }
@@ -300,21 +296,18 @@ var IdentityManager = class {
       this.properties = { ...this.properties, ...properties };
       await this.secureStorage.set(USER_PROPERTIES_KEY, JSON.stringify(this.properties));
     }
-    if (this.apiClient && this.deviceId) {
+    if (this.apiClient && this.anonId) {
       try {
-        await this.apiClient.identify(this.deviceId, properties, email);
-        this.log("Identity updated on server");
-      } catch (error) {
-        this.log("Failed to update identity on server:", error);
+        await this.apiClient.identify(this.anonId, properties, email, this.deviceId ?? void 0);
+      } catch {
       }
     }
   }
   getDistinctId() {
-    if (!this.initialized || !this.deviceId) {
-      if (this.debug) console.warn("[Paywallo Identity] getDistinctId called before initialization");
+    if (!this.initialized || !this.anonId) {
       return "";
     }
-    return this.deviceId;
+    return this.anonId;
   }
   getDeviceId() {
     return this.deviceId;
@@ -329,24 +322,22 @@ var IdentityManager = class {
     this.ensureInitialized();
     this.properties = { ...this.properties, ...properties };
     await this.secureStorage.set(USER_PROPERTIES_KEY, JSON.stringify(this.properties));
-    if (this.apiClient && this.deviceId) {
+    if (this.apiClient && this.anonId) {
       try {
-        await this.apiClient.identify(this.deviceId, this.properties, this.email ?? void 0);
-      } catch (error) {
-        this.log("Failed to update properties on server:", error);
+        await this.apiClient.identify(this.anonId, this.properties, this.email ?? void 0, this.deviceId ?? void 0);
+      } catch {
       }
     }
   }
   async reset() {
+    const newAnonId = "$paywallo_anon:" + generateUUID();
+    this.anonId = newAnonId;
     this.email = null;
     this.properties = {};
-    this.initialized = false;
-    this.apiClient = null;
-    this.deviceId = null;
     await Promise.all([
+      this.secureStorage?.set(ANON_ID_KEY, newAnonId) ?? Promise.resolve(false),
       this.secureStorage?.remove(USER_EMAIL_KEY) ?? Promise.resolve(false),
-      this.secureStorage?.remove(USER_PROPERTIES_KEY) ?? Promise.resolve(false),
-      this.secureStorage?.remove("device_id_fallback") ?? Promise.resolve(false)
+      this.secureStorage?.remove(USER_PROPERTIES_KEY) ?? Promise.resolve(false)
     ]);
   }
   getState() {
@@ -363,21 +354,23 @@ var IdentityManager = class {
     if (!this.secureStorage) {
       return;
     }
-    const [storedDeviceId, storedEmail, storedPropertiesJson] = await Promise.all([
+    const [storedDeviceId, storedAnonId, storedEmail, storedPropertiesJson] = await Promise.all([
       this.secureStorage.get(DEVICE_ID_KEY),
+      this.secureStorage.get(ANON_ID_KEY),
       this.secureStorage.get(USER_EMAIL_KEY),
       this.secureStorage.get(USER_PROPERTIES_KEY)
     ]);
     if (storedDeviceId) {
       this.deviceId = storedDeviceId;
-      this.log("Loaded device ID from storage:", this.deviceId);
     } else {
       const fallbackDeviceId = await this.secureStorage.get("device_id_fallback");
       if (fallbackDeviceId) {
         this.deviceId = fallbackDeviceId;
-        this.log("Loaded device ID from fallback storage:", this.deviceId);
       }
     }
+    if (storedAnonId) {
+      this.anonId = storedAnonId;
+    }
     if (storedEmail) {
       this.email = storedEmail;
     }
@@ -397,11 +390,6 @@ var IdentityManager = class {
       );
     }
   }
-  log(...args) {
-    if (this.debug) {
-      console.warn("[Paywallo Identity]", ...args);
-    }
-  }
 };
 var identityManager = new IdentityManager();
 
@@ -486,7 +474,6 @@ var nativeStoreKit = {
   isAvailable,
   async getProducts(productIds) {
     if (!PaywalloStoreKitNative) {
-      if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] StoreKit native module not available");
       return [];
     }
     const nativeProducts = await PaywalloStoreKitNative.getProducts(productIds);
@@ -557,7 +544,6 @@ var IAPService = class {
       }
       return products;
     } catch (error) {
-      if (this.debug) console.warn("[Paywallo][Products] StoreKit error:", error);
       return [];
     }
   }
@@ -567,35 +553,46 @@ var IAPService = class {
   getCachedProducts() {
     return new Map(this.productsCache);
   }
+  async validateWithRetry(attempt, maxRetries = 2, delayMs = 3e3) {
+    let lastError;
+    for (let i = 0; i <= maxRetries; i++) {
+      try {
+        return await attempt();
+      } catch (error) {
+        lastError = error;
+        if (i < maxRetries) await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+    throw lastError;
+  }
   async validateWithServer(purchase, productId, options) {
     const apiClient = this.getApiClient();
     const product = this.productsCache.get(productId);
     const platform = Platform2.OS;
     const distinctId = PaywalloClient.getDistinctId();
-    const validation = await apiClient.validatePurchase(
-      platform,
-      purchase.receipt,
-      purchase.productId,
-      purchase.transactionId,
-      product?.priceValue ?? 0,
-      product?.currency ?? "USD",
-      this.getDeviceCountry(),
-      distinctId,
-      options?.paywallPlacement,
-      options?.variantKey
+    return this.validateWithRetry(
+      () => apiClient.validatePurchase(
+        platform,
+        purchase.receipt,
+        purchase.productId,
+        purchase.transactionId,
+        product?.priceValue ?? 0,
+        product?.currency ?? "USD",
+        this.getDeviceCountry(),
+        distinctId,
+        options?.paywallPlacement,
+        options?.variantKey
+      )
     );
-    return validation;
   }
   async finishTransaction(transactionId) {
     try {
       await nativeStoreKit.finishTransaction(transactionId);
     } catch (finishError) {
-      if (this.debug) console.warn("[Paywallo][Purchase] Failed to finish transaction:", finishError instanceof Error ? finishError.message : finishError);
     }
   }
   async purchase(productId, options) {
     if (!nativeStoreKit.isAvailable()) {
-      if (this.debug) console.warn("[Paywallo][Purchase] StoreKit not available");
       return {
         success: false,
         error: new PurchaseError(PURCHASE_ERROR_CODES.STORE_NOT_AVAILABLE, "In-app purchases are not available on this device")
@@ -606,11 +603,11 @@ var IAPService = class {
       if (!purchase) {
         return { success: false };
       }
+      options?.onValidating?.();
       let validation = null;
       try {
         validation = await this.validateWithServer(purchase, productId, options);
       } catch (validationError) {
-        if (this.debug) console.warn("[Paywallo][Purchase] Server validation FAILED:", validationError instanceof Error ? validationError.message : validationError);
         return {
           success: false,
           error: new PurchaseError(PURCHASE_ERROR_CODES.VALIDATION_FAILED, validationError instanceof Error ? validationError.message : "Server validation failed")
@@ -626,7 +623,6 @@ var IAPService = class {
       return { success: true, purchase };
     } catch (error) {
       const e = error instanceof PurchaseError ? error : new PurchaseError(PURCHASE_ERROR_CODES.PURCHASE_FAILED, error instanceof Error ? error.message : String(error));
-      if (this.debug) console.warn("[Paywallo][Purchase] FAILED:", e.message);
       return { success: false, error: e };
     }
   }
@@ -662,14 +658,12 @@ var IAPService = class {
           try {
             await nativeStoreKit.finishTransaction(tx.transactionId);
           } catch (finishError) {
-            if (this.debug) console.warn("[Paywallo][Restore] Failed to finish tx:", tx.transactionId, finishError instanceof Error ? finishError.message : finishError);
           }
           validated.push(tx);
         }
       }
       return validated;
     } catch (error) {
-      if (this.debug) console.warn("[Paywallo][Restore] \u274C FAILED:", error instanceof Error ? error.message : error);
       return [];
     }
   }
@@ -737,7 +731,7 @@ function usePaywallTracking() {
 
 // src/domains/paywall/usePaywallActions.ts
 var SCREEN_HEIGHT = Dimensions.get("window").height;
-function usePaywallActions(placement, paywallConfig, onResult, variantKey, campaignId) {
+function usePaywallActions(placement, paywallConfig, onResult, variantKey, campaignId, openAnim) {
   const [isPurchasing, setIsPurchasing] = useState(false);
   const [isClosing, setIsClosing] = useState(false);
   const slideAnim = useRef(new Animated.Value(0)).current;
@@ -746,7 +740,8 @@ function usePaywallActions(placement, paywallConfig, onResult, variantKey, campa
   const handleClose = useCallback2(() => {
     if (isClosing) return;
     setIsClosing(true);
-    Animated.timing(slideAnim, { toValue: SCREEN_HEIGHT, duration: 300, useNativeDriver: true }).start(() => {
+    const animTarget = openAnim ?? slideAnim;
+    Animated.timing(animTarget, { toValue: SCREEN_HEIGHT, duration: 350, useNativeDriver: true }).start(() => {
       if (paywallConfig) {
         const durationSeconds = Math.round((Date.now() - presentedAtRef.current) / 1e3);
         void trackDismissed({ placement, paywallId: paywallConfig.id, durationSeconds, action: "close", variantKey, campaignId });
@@ -755,7 +750,7 @@ function usePaywallActions(placement, paywallConfig, onResult, variantKey, campa
       setIsClosing(false);
       onResult({ presented: true, purchased: false, cancelled: true, restored: false });
     });
-  }, [isClosing, onResult, paywallConfig, placement, slideAnim, trackDismissed, variantKey, campaignId]);
+  }, [isClosing, openAnim, onResult, paywallConfig, placement, slideAnim, trackDismissed, variantKey, campaignId]);
   const handlePurchase = useCallback2(async (productId) => {
     if (isPurchasing) return;
     setIsPurchasing(true);
@@ -773,7 +768,6 @@ function usePaywallActions(placement, paywallConfig, onResult, variantKey, campa
         onResult({ presented: true, purchased: false, cancelled: false, restored: false });
       }
     } catch (error) {
-      if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] Purchase error:", error);
       onResult({ presented: true, purchased: false, cancelled: false, restored: false });
     } finally {
       setIsPurchasing(false);
@@ -794,7 +788,6 @@ function usePaywallActions(placement, paywallConfig, onResult, variantKey, campa
         onResult({ presented: true, purchased: false, cancelled: false, restored: false });
       }
     } catch (error) {
-      if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] Restore error:", error);
       onResult({ presented: true, purchased: false, cancelled: false, restored: false });
     } finally {
       setIsPurchasing(false);
@@ -889,7 +882,6 @@ function usePaywallLoader(placement, visible, preloadedConfig, preloadedProducts
         }
       } catch (err) {
         const e = err instanceof Error ? err : new PaywallError(PAYWALL_ERROR_CODES.LOAD_FAILED, String(err));
-        if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] Error loading paywall:", e.message);
         setError(e);
       }
     };
@@ -898,18 +890,103 @@ function usePaywallLoader(placement, visible, preloadedConfig, preloadedProducts
   return { paywallConfig, products, error };
 }
 
+// src/utils/localization.ts
+import { NativeModules as NativeModules2, Platform as Platform3 } from "react-native";
+var currentLanguage = "pt-BR";
+var defaultLanguage = "pt-BR";
+function setCurrentLanguage(language) {
+  currentLanguage = language;
+}
+function setDefaultLanguage(language) {
+  defaultLanguage = language;
+}
+function getCurrentLanguage() {
+  return currentLanguage;
+}
+function getDefaultLanguage() {
+  return defaultLanguage;
+}
+function getLocalizedString(text) {
+  if (!text) return "";
+  if (typeof text === "string") return text;
+  return text[currentLanguage] ?? text[defaultLanguage] ?? Object.values(text)[0] ?? "";
+}
+function detectDeviceLanguage() {
+  try {
+    if (Platform3.OS === "ios") {
+      const settings = NativeModules2.SettingsManager?.settings;
+      return settings?.AppleLocale ?? settings?.AppleLanguages?.[0] ?? "en-US";
+    }
+    return NativeModules2.I18nManager?.localeIdentifier ?? "en-US";
+  } catch {
+    return "en-US";
+  }
+}
+var SDK_STRINGS = {
+  paywallErrorTitle: {
+    "pt-BR": "Algo deu errado",
+    "pt": "Algo deu errado",
+    "en": "Something went wrong",
+    "en-US": "Something went wrong",
+    "en-GB": "Something went wrong",
+    "es": "Algo sali\xF3 mal",
+    "es-419": "Algo sali\xF3 mal"
+  },
+  paywallRetryButton: {
+    "pt-BR": "Tentar novamente",
+    "pt": "Tentar novamente",
+    "en": "Try again",
+    "en-US": "Try again",
+    "en-GB": "Try again",
+    "es": "Reintentar",
+    "es-419": "Reintentar"
+  },
+  paywallCloseButton: {
+    "pt-BR": "Fechar",
+    "pt": "Fechar",
+    "en": "Close",
+    "en-US": "Close",
+    "en-GB": "Close",
+    "es": "Cerrar",
+    "es-419": "Cerrar"
+  }
+};
+function getSdkString(key) {
+  const map = SDK_STRINGS[key];
+  const lang = currentLanguage;
+  if (lang in map) return map[lang];
+  const base = lang.split("-")[0];
+  if (base && base in map) return map[base];
+  if (defaultLanguage in map) return map[defaultLanguage];
+  return Object.values(map)[0];
+}
+function initLocalization(options) {
+  if (options?.defaultLanguage) {
+    defaultLanguage = options.defaultLanguage;
+  }
+  if (options?.detectDevice !== false) {
+    const deviceLanguage = detectDeviceLanguage();
+    currentLanguage = deviceLanguage;
+  }
+}
+
 // src/domains/paywall/PaywallWebView.tsx
 import { useCallback as useCallback3, useEffect as useEffect2, useMemo, useRef as useRef3, useState as useState3 } from "react";
 import {
   Linking,
   NativeEventEmitter,
-  NativeModules as NativeModules2,
+  NativeModules as NativeModules3,
   requireNativeComponent,
   StyleSheet,
   View
 } from "react-native";
 
 // src/domains/paywall/parseWebViewMessage.ts
+function deriveMessageId(message) {
+  if (message.id) return message.id;
+  const payloadKey = message.payload?.productId ?? message.payload?.url ?? (message.payload?.timestamp != null ? String(message.payload.timestamp) : "");
+  return `${message.type}:${payloadKey}`;
+}
 function parseWebViewMessage(raw) {
   try {
     const parsed = JSON.parse(raw);
@@ -933,7 +1010,7 @@ function buildPaywallInjectionScript(data) {
       secondaryProductId: data.secondaryProductId
     }
   };
-  return `(function(){var d=${JSON.stringify(paywallData)},a=0,m=50;function t(){a++;if(window.receiveNativeMessage){window.receiveNativeMessage(d);return;}if(a<m){setTimeout(t,100);}else{console.warn('[Paywallo WV] FAILED to inject after '+m+' attempts');}}t();})();true;`;
+  return `(function(){var d=${JSON.stringify(paywallData)},a=0,m=50;function t(){a++;if(window.receiveNativeMessage){window.receiveNativeMessage(d);return;}if(a<m){setTimeout(t,100);}}t();})();true;`;
 }
 function buildPurchaseStateScript(isPurchasing) {
   return `if(window.receiveNativeMessage){window.receiveNativeMessage({type:"purchaseState",data:{isPurchasing:${isPurchasing}}});}true;`;
@@ -951,7 +1028,7 @@ function getNativeWebView() {
 var webViewEmitter = null;
 function getWebViewEmitter() {
   if (!webViewEmitter) {
-    webViewEmitter = new NativeEventEmitter(NativeModules2.PaywalloWebViewModule);
+    webViewEmitter = new NativeEventEmitter(NativeModules3.PaywalloWebViewModule);
   }
   return webViewEmitter;
 }
@@ -969,6 +1046,7 @@ function PaywallWebView({
   primaryProductId,
   secondaryProductId,
   isPurchasing,
+  webUrl: webUrlProp,
   onPurchase,
   onClose,
   onRestore,
@@ -980,8 +1058,39 @@ function PaywallWebView({
   const [scriptToInject, setScriptToInject] = useState3(void 0);
   const onErrorRef = useRef3(onError);
   onErrorRef.current = onError;
+  const onReadyRef = useRef3(onReady);
+  onReadyRef.current = onReady;
   const NativeWebView = useMemo(() => getNativeWebView(), []);
-  const webUrl = useMemo(() => PaywalloClient.getWebUrl() ?? "http://localhost:3000", []);
+  const [resolvedWebUrl, setResolvedWebUrl] = useState3(
+    () => webUrlProp ?? PaywalloClient.getWebUrl()
+  );
+  useEffect2(() => {
+    if (webUrlProp !== void 0) {
+      setResolvedWebUrl(webUrlProp ?? null);
+      return;
+    }
+    const url = PaywalloClient.getWebUrl();
+    if (url) {
+      setResolvedWebUrl(url);
+      return;
+    }
+    const interval = setInterval(() => {
+      const u = PaywalloClient.getWebUrl();
+      if (u) {
+        setResolvedWebUrl(u);
+        clearInterval(interval);
+      }
+    }, 200);
+    return () => clearInterval(interval);
+  }, [webUrlProp]);
+  useEffect2(() => {
+    if (!resolvedWebUrl) {
+      onErrorRef.current?.({
+        code: -1,
+        description: "Paywall URL not configured. SDK may not be initialized."
+      });
+    }
+  }, []);
   const buildAndSetInjectionScript = useCallback3(() => {
     if (!craftData || paywallDataSent.current) return;
     paywallDataSent.current = true;
@@ -992,19 +1101,21 @@ function PaywallWebView({
       secondaryProductId
     });
     setScriptToInject(script);
-    onReady?.();
-  }, [craftData, products, primaryProductId, secondaryProductId, onReady]);
-  const lastProcessedRef = useRef3({ type: "", time: 0 });
+  }, [craftData, products, primaryProductId, secondaryProductId]);
+  const processedIdsRef = useRef3(/* @__PURE__ */ new Set());
   const handleParsedMessage = useCallback3(
     (message) => {
-      const now = Date.now();
-      if (message.type === lastProcessedRef.current.type && now - lastProcessedRef.current.time < 500) {
-        return;
-      }
-      lastProcessedRef.current = { type: message.type, time: now };
+      const msgId = deriveMessageId(message);
+      if (processedIdsRef.current.has(msgId)) return;
+      processedIdsRef.current.add(msgId);
+      setTimeout(() => processedIdsRef.current.delete(msgId), 5e3);
       switch (message.type) {
         case "ready":
-          if (!paywallDataSent.current) buildAndSetInjectionScript();
+          if (!paywallDataSent.current) {
+            buildAndSetInjectionScript();
+          } else {
+            onReadyRef.current?.();
+          }
           break;
         case "purchase":
           if (message.payload?.productId) onPurchase(message.payload.productId);
@@ -1095,7 +1206,8 @@ function PaywallWebView({
     if (!paywallDataSent.current) return;
     setScriptToInject(buildPurchaseStateScript(isPurchasing));
   }, [isPurchasing]);
-  const paywallUrl = `${webUrl}/paywall/${paywallId}`;
+  if (!resolvedWebUrl) return null;
+  const paywallUrl = `${resolvedWebUrl}/paywall/${paywallId}`;
   return /* @__PURE__ */ jsx(View, { style: styles.container, children: /* @__PURE__ */ jsx(
     NativeWebView,
     {
@@ -1116,6 +1228,18 @@ var styles = StyleSheet.create({
 // src/domains/paywall/PaywallModal.tsx
 import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
 var SCREEN_HEIGHT2 = Dimensions2.get("window").height;
+function ErrorFallback({ description, onRetry, onClose }) {
+  const overrides = PaywalloClient.getConfig()?.errorStrings;
+  const title = overrides?.title ?? getSdkString("paywallErrorTitle");
+  const retryLabel = overrides?.retry ?? getSdkString("paywallRetryButton");
+  const closeLabel = overrides?.close ?? getSdkString("paywallCloseButton");
+  return /* @__PURE__ */ jsx2(View2, { style: styles2.fallbackContainer, children: /* @__PURE__ */ jsxs(View2, { style: styles2.fallbackCard, children: [
+    /* @__PURE__ */ jsx2(Text, { style: styles2.fallbackTitle, children: title }),
+    /* @__PURE__ */ jsx2(Text, { style: styles2.fallbackDescription, children: description }),
+    /* @__PURE__ */ jsx2(Pressable, { style: styles2.retryButton, onPress: onRetry, children: /* @__PURE__ */ jsx2(Text, { style: styles2.retryButtonText, children: retryLabel }) }),
+    /* @__PURE__ */ jsx2(Pressable, { style: styles2.closeButton, onPress: onClose, children: /* @__PURE__ */ jsx2(Text, { style: styles2.closeButtonText, children: closeLabel }) })
+  ] }) });
+}
 function PaywallModal({
   placement,
   visible,
@@ -1133,7 +1257,13 @@ function PaywallModal({
     variantKey,
     campaignId
   );
-  const { isPurchasing, slideAnim, handleClose, handlePurchase, handleRestore } = usePaywallActions(placement, paywallConfig, onResult, variantKey, campaignId);
+  const openAnim = useRef4(new Animated2.Value(SCREEN_HEIGHT2)).current;
+  const [modalVisible, setModalVisible] = useState4(false);
+  const handleResult = useCallback4((result) => {
+    setModalVisible(false);
+    onResult(result);
+  }, [onResult]);
+  const { isPurchasing, slideAnim, handleClose, handlePurchase, handleRestore } = usePaywallActions(placement, paywallConfig, handleResult, variantKey, campaignId, openAnim);
   const [webViewError, setWebViewError] = useState4(null);
   const [retryCount, setRetryCount] = useState4(0);
   const retryCountRef = useRef4(0);
@@ -1153,9 +1283,9 @@ function PaywallModal({
     setWebViewError(null);
     setRetryCount(0);
   }, []);
-  const openAnim = useRef4(new Animated2.Value(SCREEN_HEIGHT2)).current;
   useEffect3(() => {
     if (visible) {
+      setModalVisible(true);
       openAnim.setValue(SCREEN_HEIGHT2);
       Animated2.timing(openAnim, {
         toValue: 0,
@@ -1165,11 +1295,11 @@ function PaywallModal({
       }).start();
     }
   }, [visible, openAnim]);
-  if (!visible) return null;
+  if (!modalVisible && !visible) return null;
   return /* @__PURE__ */ jsx2(
     Modal,
     {
-      visible,
+      visible: modalVisible,
       animationType: "none",
       presentationStyle: "overFullScreen",
       onRequestClose: handleClose,
@@ -1177,12 +1307,14 @@ function PaywallModal({
       statusBarTranslucent: true,
       children: /* @__PURE__ */ jsx2(View2, { style: styles2.overlay, children: /* @__PURE__ */ jsx2(Animated2.View, { style: [styles2.animatedContainer, { transform: [{ translateY: openAnim }] }], children: /* @__PURE__ */ jsxs(View2, { style: styles2.container, children: [
         error && /* @__PURE__ */ jsx2(View2, { style: styles2.errorContainer, children: /* @__PURE__ */ jsx2(Text, { style: styles2.errorText, children: error.message }) }),
-        !error && paywallConfig && "craftData" in paywallConfig.config && /* @__PURE__ */ jsx2(Fragment, { children: webViewError ? /* @__PURE__ */ jsx2(View2, { style: styles2.fallbackContainer, children: /* @__PURE__ */ jsxs(View2, { style: styles2.fallbackCard, children: [
-          /* @__PURE__ */ jsx2(Text, { style: styles2.fallbackTitle, children: "Algo deu errado" }),
-          /* @__PURE__ */ jsx2(Text, { style: styles2.fallbackDescription, children: webViewError.description }),
-          /* @__PURE__ */ jsx2(Pressable, { style: styles2.retryButton, onPress: handleRetry, children: /* @__PURE__ */ jsx2(Text, { style: styles2.retryButtonText, children: "Tentar novamente" }) }),
-          /* @__PURE__ */ jsx2(Pressable, { style: styles2.closeButton, onPress: handleClose, children: /* @__PURE__ */ jsx2(Text, { style: styles2.closeButtonText, children: "Fechar" }) })
-        ] }) }) : /* @__PURE__ */ jsx2(
+        !error && paywallConfig && "craftData" in paywallConfig.config && /* @__PURE__ */ jsx2(Fragment, { children: webViewError ? /* @__PURE__ */ jsx2(
+          ErrorFallback,
+          {
+            description: webViewError.description,
+            onRetry: handleRetry,
+            onClose: handleClose
+          }
+        ) : /* @__PURE__ */ jsx2(
           PaywallWebView,
           {
             paywallId: paywallConfig.id,
@@ -1266,8 +1398,7 @@ var PaywallErrorBoundary = class extends Component {
   static getDerivedStateFromError() {
     return { hasError: true };
   }
-  componentDidCatch(error) {
-    if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] Paywall render error:", error.message);
+  componentDidCatch(_error) {
   }
   render() {
     return this.state.hasError ? null : this.props.children;
@@ -1290,7 +1421,7 @@ function usePaywallContext() {
 
 // src/domains/paywall/usePaywallPresenter.ts
 import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef5, useState as useState5 } from "react";
-function usePaywallPresenter(preloadedWebView, clearPreloadedWebView, setPreloadedWebView) {
+function usePaywallPresenter(preloadedWebView, setPreloadedWebView) {
   const [showingPreloadedWebView, setShowingPreloadedWebView] = useState5(false);
   const resolverRef = useRef5(null);
   const presentedAtRef = useRef5(Date.now());
@@ -1339,9 +1470,8 @@ function usePaywallPresenter(preloadedWebView, clearPreloadedWebView, setPreload
     };
     void track();
     setShowingPreloadedWebView(false);
-    clearPreloadedWebView();
     resolvePreloadedPaywall({ presented: true, purchased: false, cancelled: true, restored: false });
-  }, [preloadedWebView, clearPreloadedWebView, resolvePreloadedPaywall]);
+  }, [preloadedWebView, resolvePreloadedPaywall]);
   return { showingPreloadedWebView, presentPreloadedWebView, resolvePreloadedPaywall, handlePreloadedWebViewReady, handlePreloadedClose, setShowingPreloadedWebView, presentedAtRef };
 }
 
@@ -1548,10 +1678,7 @@ var AffiliateManager = class {
       );
     }
   }
-  log(...args) {
-    if (this.debug) {
-      console.warn("[AffiliateManager]", ...args);
-    }
+  log(..._args) {
   }
 };
 var affiliateManager = new AffiliateManager();
@@ -1569,26 +1696,42 @@ var PaywalloAffiliate = {
 };
 
 // src/domains/subscription/SubscriptionCache.ts
-var CACHE_KEY = "subscription_cache";
+var LEGACY_CACHE_KEY = "subscription_cache";
+var CACHE_KEY_PREFIX = "subscription_cache:";
 var DEFAULT_TTL = 24 * 60 * 60 * 1e3;
+function keyFor(distinctId) {
+  return `${CACHE_KEY_PREFIX}${distinctId}`;
+}
 var SubscriptionCache = class {
   constructor(ttl = DEFAULT_TTL) {
-    this.memoryCache = null;
+    this.memoryCache = /* @__PURE__ */ new Map();
+    this.legacyCleanupDone = false;
     this.ttl = ttl;
     this.storage = new SecureStorage();
   }
-  async get() {
-    if (this.memoryCache && !this.isExpired(this.memoryCache)) {
-      return this.memoryCache;
+  async cleanupLegacyCache() {
+    if (this.legacyCleanupDone) return;
+    this.legacyCleanupDone = true;
+    try {
+      await this.storage.remove(LEGACY_CACHE_KEY);
+    } catch {
+    }
+  }
+  async get(distinctId) {
+    await this.cleanupLegacyCache();
+    if (!distinctId) return null;
+    const memEntry = this.memoryCache.get(distinctId);
+    if (memEntry && !this.isExpired(memEntry)) {
+      return memEntry;
     }
     try {
-      const stored = await this.storage.get(CACHE_KEY);
+      const stored = await this.storage.get(keyFor(distinctId));
       if (!stored) {
         return null;
       }
       const parsed = JSON.parse(stored);
       if (typeof parsed !== "object" || parsed === null || !("data" in parsed) || typeof parsed.data !== "object" || parsed.data === null || !("cachedAt" in parsed) || typeof parsed.cachedAt !== "number") {
-        await this.storage.remove(CACHE_KEY);
+        await this.storage.remove(keyFor(distinctId));
         return null;
       }
       const cached = parsed;
@@ -1617,32 +1760,39 @@ var SubscriptionCache = class {
       }
       cached.isStale = this.isExpired(cached);
       if (!cached.isStale) {
-        this.memoryCache = cached;
+        this.memoryCache.set(distinctId, cached);
       }
       return cached;
     } catch {
       return null;
     }
   }
-  async set(data) {
+  async set(distinctId, data) {
+    if (!distinctId) return;
     const cached = {
       data,
       cachedAt: Date.now(),
       isStale: false
     };
-    this.memoryCache = cached;
+    this.memoryCache.set(distinctId, cached);
     try {
-      await this.storage.set(CACHE_KEY, JSON.stringify(cached));
-    } catch (error) {
-      if (__DEV__) console.warn("[SubscriptionCache] set() failed:", error instanceof Error ? error.message : String(error));
+      await this.storage.set(keyFor(distinctId), JSON.stringify(cached));
+    } catch {
     }
   }
-  async invalidate() {
-    this.memoryCache = null;
+  async invalidate(distinctId) {
+    if (!distinctId) return;
+    this.memoryCache.delete(distinctId);
     try {
-      await this.storage.remove(CACHE_KEY);
-    } catch (error) {
-      if (__DEV__) console.warn("[SubscriptionCache] invalidate() failed:", error instanceof Error ? error.message : String(error));
+      await this.storage.remove(keyFor(distinctId));
+    } catch {
+    }
+  }
+  async invalidateAll() {
+    this.memoryCache.clear();
+    try {
+      await this.storage.remove(LEGACY_CACHE_KEY);
+    } catch {
     }
   }
   isExpired(cached) {
@@ -1654,8 +1804,155 @@ var SubscriptionCache = class {
 };
 var subscriptionCache = new SubscriptionCache();
 
+// src/domains/subscription/SubscriptionManager.ts
+import { Platform as Platform4 } from "react-native";
+
+// src/domains/session/SessionError.ts
+var SessionError = class extends PaywalloError {
+  constructor(code, message) {
+    super("session", code, message);
+    this.name = "SessionError";
+  }
+};
+var SESSION_ERROR_CODES = {
+  NOT_INITIALIZED: "SESSION_NOT_INITIALIZED",
+  START_FAILED: "SESSION_START_FAILED",
+  END_FAILED: "SESSION_END_FAILED",
+  RESTORE_FAILED: "SESSION_RESTORE_FAILED"
+};
+
+// src/domains/subscription/SubscriptionManager.ts
+var SubscriptionManagerClass = class {
+  constructor() {
+    this.config = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.userId = null;
+    this.cache = new SubscriptionCache();
+  }
+  cacheKey() {
+    return this.userId ?? "__anonymous__";
+  }
+  init(config) {
+    this.config = config;
+    if (config.cacheTTL) {
+      this.cache.setTTL(config.cacheTTL);
+    }
+  }
+  setUserId(userId) {
+    if (this.userId !== userId) {
+      this.userId = userId;
+      void this.cache.invalidateAll();
+    }
+  }
+  async hasActiveSubscription(forceRefresh = false) {
+    const status = await this.getSubscriptionStatus(forceRefresh);
+    return status.hasActiveSubscription;
+  }
+  async getSubscription(forceRefresh = false) {
+    const status = await this.getSubscriptionStatus(forceRefresh);
+    return status.subscription;
+  }
+  async getEntitlements(forceRefresh = false) {
+    const status = await this.getSubscriptionStatus(forceRefresh);
+    return status.entitlements;
+  }
+  async getSubscriptionStatus(forceRefresh = false) {
+    if (!this.config) {
+      return this.getEmptyStatus();
+    }
+    if (!forceRefresh) {
+      const cached = await this.cache.get(this.cacheKey());
+      if (cached && !cached.isStale) {
+        return cached.data;
+      }
+    }
+    try {
+      const status = await this.fetchSubscriptionStatus();
+      await this.cache.set(this.cacheKey(), status);
+      this.notifyListeners(status);
+      return status;
+    } catch (error) {
+      this.log("Failed to fetch subscription status", error);
+      const cached = await this.cache.get(this.cacheKey());
+      if (cached) {
+        return cached.data;
+      }
+      return this.getEmptyStatus();
+    }
+  }
+  async restorePurchases() {
+    if (!this.config) {
+      throw new SessionError(
+        SESSION_ERROR_CODES.NOT_INITIALIZED,
+        "SubscriptionManager not initialized"
+      );
+    }
+    await this.cache.invalidate(this.cacheKey());
+    return this.getSubscriptionStatus(true);
+  }
+  async fetchSubscriptionStatus() {
+    if (!this.config) {
+      return this.getEmptyStatus();
+    }
+    const url = new URL(`${this.config.serverUrl}/subscriptions/status`);
+    if (this.userId) {
+      url.searchParams.set("userId", this.userId);
+    }
+    url.searchParams.set("platform", Platform4.OS);
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Key": this.config.appKey
+      }
+    });
+    if (!response.ok) {
+      throw new SessionError(
+        SESSION_ERROR_CODES.RESTORE_FAILED,
+        `Failed to fetch subscription status: ${response.status}`
+      );
+    }
+    const data = await response.json();
+    if (data.subscription) {
+      data.subscription.expiresAt = new Date(data.subscription.expiresAt);
+      data.subscription.originalPurchaseDate = new Date(data.subscription.originalPurchaseDate);
+      data.subscription.latestPurchaseDate = new Date(data.subscription.latestPurchaseDate);
+      if (data.subscription.cancellationDate) {
+        data.subscription.cancellationDate = new Date(data.subscription.cancellationDate);
+      }
+      if (data.subscription.gracePeriodExpiresAt) {
+        data.subscription.gracePeriodExpiresAt = new Date(data.subscription.gracePeriodExpiresAt);
+      }
+    }
+    return data;
+  }
+  getEmptyStatus() {
+    return {
+      hasActiveSubscription: false,
+      subscription: null,
+      entitlements: []
+    };
+  }
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notifyListeners(status) {
+    for (const listener of this.listeners) {
+      listener(status);
+    }
+  }
+  async onPurchaseComplete() {
+    await this.cache.invalidate(this.cacheKey());
+    await this.getSubscriptionStatus(true);
+  }
+  log(..._args) {
+  }
+};
+var subscriptionManager = new SubscriptionManagerClass();
+
 // src/core/ApiClient.ts
-import { Platform as Platform3 } from "react-native";
+import { Platform as Platform5 } from "react-native";
 
 // src/core/apiUrlUtils.ts
 var DEFAULT_WEB_URL = "https://paywallo.com.br";
@@ -1887,10 +2184,7 @@ var HttpClient = class {
   sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
-  log(message, data) {
-    if (this.config.debug) {
-      console.warn("[HttpClient]", message, data ?? "");
-    }
+  log(..._args) {
   }
   setDebug(debug) {
     this.config.debug = debug;
@@ -2034,10 +2328,7 @@ var NetworkMonitorClass = class {
     this.initialized = false;
     this.currentState = "unknown";
   }
-  log(message, data) {
-    if (this.config.debug) {
-      console.warn("[NetworkMonitor]", message, data ?? "");
-    }
+  log(..._args) {
   }
   setDebug(debug) {
     this.config.debug = debug;
@@ -2067,6 +2358,8 @@ function normalizeForComparison(obj) {
   return "{" + pairs.join(",") + "}";
 }
 function findDuplicateIndex(queue, item) {
+  const byId = queue.findIndex((existing) => existing.id === item.id);
+  if (byId !== -1) return byId;
   const normalizedBody = normalizeForComparison(item.body);
   return queue.findIndex(
     (existing) => existing.url === item.url && normalizeForComparison(existing.body) === normalizedBody
@@ -2135,9 +2428,9 @@ var OfflineQueueClass = class {
       void this.saveToStorage();
     }
   }
-  async enqueue(method, url, body, headers) {
+  async enqueue(method, url, body, headers, id) {
     const item = {
-      id: generateUUID(),
+      id: id ?? generateUUID(),
       method,
       url,
       body,
@@ -2221,7 +2514,6 @@ var OfflineQueueClass = class {
     this.emit({ type: "processing:end", queueSize: this.queue.length });
     return { processed, failed };
   }
-  /** Returns true if the item was permanently removed (counted as failed). */
   async handleItemFailure(item, error, permanent = false) {
     if (permanent || item.attempts >= item.maxAttempts) {
       await this.removeItem(item.id);
@@ -2283,10 +2575,7 @@ var OfflineQueueClass = class {
       }
     }
   }
-  log(message, data) {
-    if (this.config.debug) {
-      console.warn("[OfflineQueue]", message, data ?? "");
-    }
+  log(..._args) {
   }
   setDebug(debug) {
     this.config.debug = debug;
@@ -2428,10 +2717,7 @@ var QueueProcessorClass = class {
     this.httpClient = null;
     this.initialized = false;
   }
-  log(message, data) {
-    if (this.config.debug) {
-      console.warn("[QueueProcessor]", message, data ?? "");
-    }
+  log(..._args) {
   }
   setDebug(debug) {
     this.config.debug = debug;
@@ -2443,10 +2729,9 @@ var queueProcessor = new QueueProcessorClass();
 var ApiCache = class {
   constructor() {
     this.CACHE_TTL = 3e5;
-    // 5 minutes
     this.CACHE_NULL_TTL = 3e4;
-    // 30 seconds — for null/404 variants
     this.MAX_SIZE = 200;
+    this.STALE_WINDOW_MS = 864e5;
     this.variantCache = /* @__PURE__ */ new Map();
     this.paywallCache = /* @__PURE__ */ new Map();
     this.campaignCache = /* @__PURE__ */ new Map();
@@ -2484,7 +2769,7 @@ var ApiCache = class {
   }
   getStaleVariant(key) {
     const entry = this.variantCache.get(key);
-    if (entry && Date.now() - entry.ts < 864e5) return entry.value;
+    if (entry && Date.now() - entry.ts < this.STALE_WINDOW_MS) return entry.value;
     return void 0;
   }
   getPaywall(key) {
@@ -2496,19 +2781,19 @@ var ApiCache = class {
   }
   getStalePaywall(key) {
     const entry = this.paywallCache.get(key);
-    if (entry && Date.now() - entry.ts < 864e5) return entry.value;
+    if (entry && Date.now() - entry.ts < this.STALE_WINDOW_MS) return entry.value;
     return void 0;
   }
   getCampaign(key) {
     return this.getCached(this.campaignCache, key);
   }
-  setCampaign(key, value) {
-    this.setCached(this.campaignCache, key, value);
+  setCampaign(key, value, ttlOverride) {
+    this.setCached(this.campaignCache, key, value, ttlOverride);
     this.evictExpiredEntries(this.campaignCache);
   }
   getStaleCampaign(key) {
     const entry = this.campaignCache.get(key);
-    if (entry && Date.now() - entry.ts < 864e5) return entry.value;
+    if (entry && Date.now() - entry.ts < this.STALE_WINDOW_MS) return entry.value;
     return void 0;
   }
 };
@@ -2527,11 +2812,12 @@ var _ApiClient = class _ApiClient {
     this.offlineQueueEnabled = offlineQueueEnabled;
     this.httpClient = new HttpClient(this.baseUrl, { timeout, debug });
   }
-  // ─── Infrastructure ──────────────────────────────────────────────────────────
-  /** Exposed only for QueueProcessor initialization. Prefer get()/post() for requests. */
   getHttpClient() {
     return this.httpClient;
   }
+  getBaseUrl() {
+    return this.baseUrl;
+  }
   getWebUrl() {
     return this.webUrl;
   }
@@ -2557,7 +2843,6 @@ var _ApiClient = class _ApiClient {
   async clearQueue() {
     await offlineQueue.clear();
   }
-  // ─── Public HTTP facade (headers injected automatically) ─────────────────────
   async get(path) {
     return this.httpClient.get(path, { headers: { "X-App-Key": this.appKey } });
   }
@@ -2571,29 +2856,28 @@ var _ApiClient = class _ApiClient {
         message,
         context,
         sdkVersion: SDK_VERSION,
-        platform: Platform3.OS
+        platform: Platform5.OS
       }, true);
     } catch {
     }
   }
-  // ─── Business methods ────────────────────────────────────────────────────────
   async trackEvent(eventName, distinctId, properties, timestamp) {
     await this.postWithQueue("/api/v1/events", {
       eventName,
       distinctId,
-      properties: { ...properties, platform: Platform3.OS },
+      properties: { ...properties, platform: Platform5.OS },
       timestamp: timestamp ?? Date.now(),
       environment: this.environment.toLowerCase()
     }, `event:${eventName}`);
   }
-  async identify(distinctId, properties, email) {
-    await this.postWithQueue("/api/v1/identify", { distinctId, properties: properties ?? {}, email, platform: Platform3.OS }, "identify");
+  async identify(distinctId, properties, email, deviceId) {
+    await this.postWithQueue("/api/v1/identify", { distinctId, properties: properties ?? {}, email, platform: Platform5.OS, ...deviceId && { deviceId } }, "identify");
   }
   async startSession(distinctId, sessionId, platform) {
     await this.postWithQueue("/api/v1/sessions/start", {
       distinctId,
       sessionId,
-      platform: platform ?? Platform3.OS,
+      platform: platform ?? Platform5.OS,
       environment: this.environment.toLowerCase()
     }, `session.start:${sessionId}`);
     return { success: true };
@@ -2671,7 +2955,7 @@ var _ApiClient = class _ApiClient {
       const result = await getCampaignData(this, this.baseUrl, placement, distinctId, context);
       if (!result) {
         this.log("No campaign found for placement:", placement);
-        this.cache.setCampaign(key, null);
+        this.cache.setCampaign(key, null, this.cache.nullTTL);
         return null;
       }
       this.log("Got campaign:", placement, result.variantKey);
@@ -2684,18 +2968,44 @@ var _ApiClient = class _ApiClient {
       return null;
     }
   }
-  async validatePurchase(platform, receipt, productId, transactionId, priceLocal, currency, country, distinctId, paywallPlacement, variantKey) {
-    const result = await validatePurchase(
-      this,
-      this.appKey,
-      platform,
-      receipt,
-      productId,
-      transactionId,
-      priceLocal,
-      currency,
-      country,
-      distinctId,
+  async getPrimaryCampaign(distinctId) {
+    const key = `primary:${distinctId}`;
+    const hit = this.cache.getCampaign(key);
+    if (hit !== void 0) return hit;
+    try {
+      const res = await this.get(`/campaigns/public/primary?distinctId=${encodeURIComponent(distinctId)}`);
+      if (res.status === 404) {
+        this.cache.setCampaign(key, null, this.cache.nullTTL);
+        return null;
+      }
+      if (!res.ok) {
+        this.log("Non-OK response for primary campaign:", res.status);
+        const stale = this.cache.getStaleCampaign(key);
+        if (stale !== void 0) return stale;
+        return null;
+      }
+      this.log("Got primary campaign:", res.data?.campaignId);
+      this.cache.setCampaign(key, res.data);
+      return res.data;
+    } catch (error) {
+      this.log("Failed to get primary campaign:", error);
+      const stale = this.cache.getStaleCampaign(key);
+      if (stale !== void 0) return stale;
+      return null;
+    }
+  }
+  async validatePurchase(platform, receipt, productId, transactionId, priceLocal, currency, country, distinctId, paywallPlacement, variantKey) {
+    const result = await validatePurchase(
+      this,
+      this.appKey,
+      platform,
+      receipt,
+      productId,
+      transactionId,
+      priceLocal,
+      currency,
+      country,
+      distinctId,
       paywallPlacement,
       variantKey
     );
@@ -2752,12 +3062,6 @@ var _ApiClient = class _ApiClient {
       return { value: false, flagKey };
     }
   }
-  // ─── Cache-only reads ────────────────────────────────────────────────────────
-  /**
-   * Reads a flag variant from cache layers only — no network call.
-   * Checks in-memory cache first, then SecureStorage.
-   * Returns null when both layers miss.
-   */
   async getVariantFromCache(flagKey, distinctId) {
     const key = `${flagKey}:${distinctId}`;
     const hit = this.cache.getVariant(key);
@@ -2789,10 +3093,6 @@ var _ApiClient = class _ApiClient {
     } catch {
     }
   }
-  /**
-   * POST with offline queue fallback. Enqueues when offline or on network failure.
-   * Throws only when offlineQueueEnabled is false and the request fails.
-   */
   async postWithQueue(url, payload, label) {
     if (this.offlineQueueEnabled && !networkMonitor.isOnline()) {
       await offlineQueue.enqueue("POST", url, payload, { "X-App-Key": this.appKey });
@@ -2811,11 +3111,9 @@ var _ApiClient = class _ApiClient {
       throw error;
     }
   }
-  log(...args) {
-    if (this.debug) console.warn("[Paywallo API]", ...args);
+  log(..._args) {
   }
 };
-// ─── Private helpers ─────────────────────────────────────────────────────────
 _ApiClient.FLAG_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
 var ApiClient = _ApiClient;
 
@@ -2836,42 +3134,72 @@ var CAMPAIGN_ERROR_CODES = {
 
 // src/domains/campaign/CampaignGateService.ts
 var PRELOAD_CACHE_TTL_MS = 5 * 60 * 1e3;
+var PRELOAD_WAIT_MAX_MS = 2e3;
+var PRELOAD_WAIT_INTERVAL_MS = 100;
 var CampaignGateService = class {
   constructor() {
     this.preloadedCampaigns = /* @__PURE__ */ new Map();
+    this.pendingPreloads = /* @__PURE__ */ new Set();
   }
   async getCampaign(apiClient, placement, context) {
     const distinctId = identityManager.getDistinctId();
     if (!distinctId) return null;
     return apiClient.getCampaign(placement, distinctId, context);
   }
+  async waitForPreload(placement) {
+    if (!this.pendingPreloads.has(placement)) return;
+    const deadline = Date.now() + PRELOAD_WAIT_MAX_MS;
+    await new Promise((resolve) => {
+      const check = () => {
+        if (!this.pendingPreloads.has(placement) || Date.now() >= deadline) {
+          resolve();
+          return;
+        }
+        setTimeout(check, PRELOAD_WAIT_INTERVAL_MS);
+      };
+      check();
+    });
+  }
   async presentCampaign(apiClient, placement, hasActive, paywallPresenter, campaignPresenter, context) {
-    const campaign = await this.getCampaign(apiClient, placement, context);
+    await this.waitForPreload(placement);
+    const preloaded = this.getPreloadedCampaign(placement);
+    const campaign = preloaded ?? await this.getCampaign(apiClient, placement, context);
     if (!campaign) {
       return { presented: false, purchased: false, cancelled: false, restored: false, error: new CampaignError(CAMPAIGN_ERROR_CODES.NOT_FOUND, "No campaign found") };
     }
-    if (!context?.forceShow && await hasActive()) {
-      return { presented: false, purchased: false, cancelled: false, restored: false, skippedReason: "subscriber" };
+    if (!context?.forceShow) {
+      const isActive = await hasActive();
+      if (isActive) {
+        return { presented: false, purchased: false, cancelled: false, restored: false, skippedReason: "subscriber" };
+      }
     }
     if (campaignPresenter) return campaignPresenter(campaign);
     if (!paywallPresenter) throw new PaywallError(PAYWALL_ERROR_CODES.NOT_INITIALIZED, "PaywalloProvider not mounted. Wrap your app with <PaywalloProvider>");
-    return { ...await paywallPresenter(campaign.paywall.placement), campaignId: campaign.campaignId, variantKey: campaign.variantKey };
+    return { ...await paywallPresenter(placement), campaignId: campaign.campaignId, variantKey: campaign.variantKey };
   }
   async requireSubscriptionWithCampaign(apiClient, placement, hasActive, paywallPresenter, campaignPresenter, context) {
-    if (await hasActive()) return true;
+    const isActive = await hasActive();
+    if (PaywalloClient.getConfig()?.debug) console.info(`[Paywallo] requireSubscription \u2014 hasActive: ${isActive}`);
+    if (isActive) return true;
     const r = await this.presentCampaign(apiClient, placement, hasActive, paywallPresenter, campaignPresenter, context);
     return r.purchased || r.restored;
   }
   async preloadCampaign(apiClient, placement, context) {
+    this.pendingPreloads.add(placement);
     try {
       const campaign = await this.getCampaign(apiClient, placement, context);
       if (!campaign?.paywall) {
         return { success: false, error: new CampaignError(CAMPAIGN_ERROR_CODES.NOT_FOUND, `Campaign or paywall not found: ${placement}`) };
       }
       this.preloadedCampaigns.set(placement, { campaign, preloadedAt: Date.now() });
+      if (PaywalloClient.getConfig()?.debug) {
+        console.info(`[Paywallo PRELOAD] data cached \u2014 placement: ${placement}`);
+      }
       return { success: true };
     } catch (error) {
       return { success: false, error: error instanceof Error ? error : new PaywalloError("panel", "PANEL_UNKNOWN", String(error)) };
+    } finally {
+      this.pendingPreloads.delete(placement);
     }
   }
   getPreloadedCampaign(placement) {
@@ -2885,12 +3213,13 @@ var CampaignGateService = class {
   }
   clearPreloaded() {
     this.preloadedCampaigns.clear();
+    this.pendingPreloads.clear();
   }
 };
 var campaignGateService = new CampaignGateService();
 
 // src/domains/identity/AdvertisingIdManager.ts
-import { Platform as Platform4 } from "react-native";
+import { Platform as Platform6 } from "react-native";
 var ZERO_IDFA = "00000000-0000-0000-0000-000000000000";
 var AdvertisingIdManager = class {
   constructor() {
@@ -2901,7 +3230,7 @@ var AdvertisingIdManager = class {
     const fallback = { idfv: null, idfa: null, gaid: null, attStatus: "unavailable" };
     try {
       const tracking = await import("expo-tracking-transparency");
-      if (Platform4.OS === "ios") {
+      if (Platform6.OS === "ios") {
         if (!tracking.isAvailable()) {
           const idfv2 = await this.collectIdfv();
           this.cached = { ...fallback, idfv: idfv2 };
@@ -2920,7 +3249,7 @@ var AdvertisingIdManager = class {
         this.cached = { idfv, idfa, gaid: null, attStatus: status };
         return this.cached;
       }
-      if (Platform4.OS === "android") {
+      if (Platform6.OS === "android") {
         const androidStatus = await tracking.getTrackingPermissionsAsync();
         const optedIn = androidStatus.granted;
         const rawGaid = optedIn ? tracking.getAdvertisingId() : null;
@@ -2979,14 +3308,14 @@ var FacebookIdManager = class {
 var facebookIdManager = new FacebookIdManager();
 
 // src/domains/identity/InstallTracker.ts
-import { Dimensions as Dimensions3, Platform as Platform6 } from "react-native";
+import { Dimensions as Dimensions3, Platform as Platform8 } from "react-native";
 
 // src/domains/identity/InstallReferrerManager.ts
-import { Platform as Platform5 } from "react-native";
+import { Platform as Platform7 } from "react-native";
 var REFERRER_TIMEOUT_MS = 5e3;
 var InstallReferrerManager = class {
   async getReferrer() {
-    if (Platform5.OS !== "android") {
+    if (Platform7.OS !== "android") {
       return this.emptyResult();
     }
     let timerId;
@@ -3048,20 +3377,6 @@ var installReferrerManager = new InstallReferrerManager();
 // src/domains/session/SessionManager.ts
 import { AppState as AppState2 } from "react-native";
 
-// src/domains/session/SessionError.ts
-var SessionError = class extends PaywalloError {
-  constructor(code, message) {
-    super("session", code, message);
-    this.name = "SessionError";
-  }
-};
-var SESSION_ERROR_CODES = {
-  NOT_INITIALIZED: "SESSION_NOT_INITIALIZED",
-  START_FAILED: "SESSION_START_FAILED",
-  END_FAILED: "SESSION_END_FAILED",
-  RESTORE_FAILED: "SESSION_RESTORE_FAILED"
-};
-
 // src/domains/session/sessionTracking.ts
 async function trackSessionStart(apiClient, sessionId, sessionStartedAt) {
   const distinctId = identityManager.getDistinctId();
@@ -3289,10 +3604,7 @@ var SessionManager = class {
       );
     }
   }
-  log(...args) {
-    if (this.debug) {
-      console.warn("[Paywallo Session]", ...args);
-    }
+  log(..._args) {
   }
 };
 var sessionManager = new SessionManager();
@@ -3347,9 +3659,6 @@ var InstallTracker = class {
         locale
       };
     } catch {
-      if (this.debug) {
-        console.warn("[Paywallo] Failed to collect device data for install event");
-      }
     }
     const [fbAnonId, referrer, adIds] = await Promise.all([
       facebookIdManager.getAnonId(),
@@ -3359,7 +3668,7 @@ var InstallTracker = class {
     try {
       await apiClient.trackEvent("$app_installed", distinctId, {
         installedAt,
-        platform: Platform6.OS,
+        platform: Platform8.OS,
         ...sessionId && { sessionId },
         ...deviceData,
         ...fbAnonId && { fbAnonId },
@@ -3380,13 +3689,7 @@ var InstallTracker = class {
         await AsyncStorage3.setItem("@paywallo:install_tracked", String(installedAt));
       } catch {
       }
-      if (this.debug && !stored) {
-        console.warn("[Paywallo] Install event tracked but flag storage failed \u2014 may re-track on next launch");
-      }
-    } catch (error) {
-      if (this.debug) {
-        console.warn("[Paywallo] Failed to track install:", error);
-      }
+    } catch {
     }
   }
 };
@@ -3396,25 +3699,13 @@ function isValidEventName(name) {
   if (name.startsWith("$")) return /^\$[a-z][a-z0-9]*(_[a-z0-9]+)*$/.test(name);
   return /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/.test(name);
 }
-var OFFLINE_ACTIVE_STATUSES = ["active", "grace_period"];
-async function resolveClientOfflineFromCache() {
-  try {
-    const cached = await subscriptionCache.get();
-    if (!cached) return false;
-    const sub = cached.data.subscription;
-    if (!sub) return false;
-    if (!OFFLINE_ACTIVE_STATUSES.includes(sub.status)) return false;
-    if (!sub.expiresAt) return true;
-    return sub.expiresAt > /* @__PURE__ */ new Date();
-  } catch {
-    return false;
-  }
-}
 var _PaywalloClientClass = class _PaywalloClientClass {
   constructor() {
     this.config = null;
     this.apiClient = null;
     this.initPromise = null;
+    this.readyPromise = null;
+    this.resolveReady = null;
     this.paywallPresenter = null;
     this.campaignPresenter = null;
     this.subscriptionGetter = null;
@@ -3424,29 +3715,30 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     this.pendingConfig = null;
     this.networkCleanup = null;
     this.initAttempts = 0;
+    this.autoPreloadedPlacement = null;
+    this.autoPreloadPlacementPromise = null;
+    this.sessionFlagsMap = /* @__PURE__ */ new Map();
   }
   async init(config) {
-    if (config.debug) console.warn("[Paywallo INIT]", "init() called \u2014 appKey:", config.appKey ? config.appKey.substring(0, 8) + "..." : "MISSING");
+    if (!this.readyPromise) {
+      this.readyPromise = new Promise((resolve) => {
+        this.resolveReady = resolve;
+      });
+    }
     if (this.config && this.apiClient) {
-      if (config.debug) console.warn("[Paywallo INIT]", "Already initialized \u2014 skipping");
       return;
     }
     if (this.initPromise) {
-      if (config.debug) console.warn("[Paywallo INIT]", "Init already in progress \u2014 awaiting...");
       await this.initPromise;
-      if (config.debug) console.warn("[Paywallo INIT]", "Awaited existing init \u2014 done");
       return;
     }
     if (!config.appKey) throw new ClientError(CLIENT_ERROR_CODES.MISSING_APP_KEY, "appKey is required");
-    if (config.debug) console.warn("[Paywallo INIT]", "Starting fresh init...");
     this.pendingConfig = config;
     this.initAttempts = 0;
     this.initPromise = this.initWithRetry(config);
     try {
       await this.initPromise;
-      if (config.debug) console.warn("[Paywallo INIT]", "init() SUCCESS");
     } catch (error) {
-      if (config.debug) console.warn("[Paywallo INIT]", "init() FAILED:", error instanceof Error ? error.message : String(error));
       this.initPromise = null;
       this.config = null;
       this.apiClient = null;
@@ -3455,6 +3747,18 @@ var _PaywalloClientClass = class _PaywalloClientClass {
       throw error;
     }
   }
+  isReady() {
+    return this.config !== null && this.apiClient !== null;
+  }
+  waitUntilReady() {
+    if (this.isReady()) return Promise.resolve();
+    if (!this.readyPromise) {
+      this.readyPromise = new Promise((resolve) => {
+        this.resolveReady = resolve;
+      });
+    }
+    return this.readyPromise;
+  }
   async initWithRetry(config) {
     while (this.initAttempts <= _PaywalloClientClass.MAX_INIT_RETRIES) {
       try {
@@ -3469,7 +3773,6 @@ var _PaywalloClientClass = class _PaywalloClientClass {
         this.initAttempts++;
         if (this.initAttempts > _PaywalloClientClass.MAX_INIT_RETRIES) throw error;
         const delay = _PaywalloClientClass.RETRY_DELAYS[this.initAttempts - 1] ?? 1e4;
-        if (config.debug) console.warn("[Paywallo]", `Init attempt ${this.initAttempts} failed, retrying in ${delay}ms`, error);
         await new Promise((resolve) => setTimeout(resolve, delay));
       }
     }
@@ -3480,11 +3783,8 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     this.networkCleanup = networkMonitor.addListener((state) => {
       if (state !== "online") return;
       if (this.config && this.apiClient) return;
-      if (config.debug) console.warn("[Paywallo]", "Network recovered \u2014 retrying init");
       this.initPromise = this.initWithRetry(config);
-      this.initPromise.then(() => {
-        if (config.debug) console.warn("[Paywallo]", "Init succeeded after network recovery");
-      }).catch(() => {
+      this.initPromise.catch(() => {
         this.reportInitFailure(config, null, "NETWORK_RECOVERY_FAILED");
       });
     });
@@ -3513,38 +3813,79 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     } catch {
     }
   }
+  async resolveSessionFlags(keys, apiClient, distinctId) {
+    try {
+      const results = await apiClient.evaluateFlags(keys, distinctId);
+      this.sessionFlagsMap.clear();
+      for (const key of keys) {
+        this.sessionFlagsMap.set(key, key in results ? results[key] : null);
+      }
+    } catch (error) {
+      for (const key of keys) {
+        this.sessionFlagsMap.set(key, null);
+      }
+    }
+  }
   async doInit(config) {
     const environment = config.environment ?? (typeof __DEV__ !== "undefined" && __DEV__ ? "Sandbox" : "Production");
     const offlineQueueEnabled = config.offlineQueueEnabled !== false;
-    if (config.debug) console.warn("[Paywallo INIT]", "Step 1: networkMonitor + offlineQueue...");
     await Promise.all([
       networkMonitor.initialize({ debug: config.debug }),
       offlineQueue.initialize({ debug: config.debug }).then(
         () => offlineQueue.clearItemsWithInvalidAppKey(config.appKey)
       )
     ]);
-    if (config.debug) console.warn("[Paywallo INIT]", "Step 1 DONE");
-    if (config.debug) console.warn("[Paywallo INIT]", "Step 2: ApiClient + queueProcessor + affiliate...");
     this.apiClient = new ApiClient(config.appKey, config.debug, environment, offlineQueueEnabled, config.timeout);
     queueProcessor.initialize(this.apiClient.getHttpClient(), { debug: config.debug });
     affiliateManager.initialize(this.apiClient, config.debug);
-    if (config.debug) console.warn("[Paywallo INIT]", "Step 2 DONE");
-    if (config.debug) console.warn("[Paywallo INIT]", "Step 3: identityManager + sessionManager...");
+    subscriptionManager.init({
+      serverUrl: this.apiClient.getBaseUrl(),
+      appKey: config.appKey,
+      cacheTTL: config.subscriptionCacheTTL,
+      debug: config.debug
+    });
     await Promise.all([
       identityManager.initialize(this.apiClient, config.debug),
       sessionManager.initialize(this.apiClient, config.sessionConfig, config.debug)
     ]);
     const distinctId = identityManager.getDistinctId();
-    if (config.debug) console.warn("[Paywallo INIT]", "Step 3 DONE \u2014 distinctId:", distinctId ? distinctId.substring(0, 8) + "..." : "EMPTY");
     if (config.autoStartSession !== false) {
       sessionManager.startSession().catch(() => {
-        if (config.debug) console.warn("[Paywallo]", "Session start failed during init \u2014 continuing");
       });
     }
     new InstallTracker(config.debug).trackIfNeeded(this.apiClient, config.requestATT === true).catch(() => {
     });
+    if (config.sessionFlags && config.sessionFlags.length > 0) {
+      await this.resolveSessionFlags(config.sessionFlags, this.apiClient, distinctId);
+    }
     this.config = config;
-    if (config.debug) console.warn("[Paywallo INIT]", "COMPLETE \u2014 SDK ready, environment:", environment);
+    if (this.resolveReady) {
+      this.resolveReady();
+      this.resolveReady = null;
+    }
+    if (config.debug) console.info("[Paywallo INIT] complete");
+    if (this.apiClient) {
+      const apiClientRef = this.apiClient;
+      if (config.autoPreloadCampaign) {
+        this.autoPreloadedPlacement = config.autoPreloadCampaign;
+        this.autoPreloadPlacementPromise = Promise.resolve(config.autoPreloadCampaign);
+        if (config.debug) console.info(`[Paywallo PRELOAD] started \u2014 placement: ${config.autoPreloadCampaign}`);
+        void campaignGateService.preloadCampaign(apiClientRef, config.autoPreloadCampaign).catch(() => {
+        });
+      } else {
+        this.autoPreloadPlacementPromise = apiClientRef.getPrimaryCampaign(distinctId).then((primary) => {
+          const placement = primary?.placement ?? primary?.paywall?.placement;
+          if (placement) {
+            this.autoPreloadedPlacement = placement;
+            if (config.debug) console.info(`[Paywallo PRELOAD] started \u2014 placement: ${placement}`);
+            void campaignGateService.preloadCampaign(apiClientRef, placement).catch(() => {
+            });
+            return placement;
+          }
+          return null;
+        }).catch(() => null);
+      }
+    }
   }
   async identify(options) {
     this.ensureInitialized();
@@ -3554,7 +3895,6 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     const apiClient = this.getApiClientOrThrow();
     const distinctId = identityManager.getDistinctId();
     if (!distinctId) {
-      if (this.config?.debug) console.warn("[Paywallo TRACK]", "SKIPPED \u2014 no distinctId", eventName);
       return;
     }
     if (!isValidEventName(eventName)) {
@@ -3562,25 +3902,6 @@ var _PaywalloClientClass = class _PaywalloClientClass {
       throw new ClientError(CLIENT_ERROR_CODES.INVALID_EVENT_NAME, msg);
     }
     const sessionId = sessionManager.getSessionId();
-    if (eventName === "$purchase_completed") {
-      if (this.config?.debug) console.warn("[Paywallo PURCHASE]", "tracking purchase:", JSON.stringify({
-        distinctId: distinctId.substring(0, 8) + "...",
-        productId: options?.properties?.productId,
-        priceUsd: options?.properties?.priceUsd,
-        price: options?.properties?.price,
-        currency: options?.properties?.currency,
-        placement: options?.properties?.placement
-      }));
-    } else if (eventName === "$paywall_viewed" || eventName === "$paywall_closed") {
-      if (this.config?.debug) console.warn("[Paywallo PAYWALL]", eventName, JSON.stringify({
-        distinctId: distinctId.substring(0, 8) + "...",
-        placement: options?.properties?.placement,
-        variantKey: options?.properties?.variantKey,
-        timeOnPaywall: options?.properties?.timeOnPaywall
-      }));
-    } else {
-      if (this.config?.debug) console.warn("[Paywallo TRACK]", eventName, "distinctId:", distinctId.substring(0, 8) + "...");
-    }
     await apiClient.trackEvent(eventName, distinctId, {
       ...identityManager.getProperties(),
       ...options?.properties,
@@ -3591,7 +3912,6 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     const apiClient = this.getApiClientOrThrow();
     const distinctId = identityManager.getDistinctId();
     if (!distinctId) {
-      if (this.config?.debug) console.warn("[Paywallo] Skipping event \u2014 no distinctId available");
       return;
     }
     if (!Number.isInteger(index) || index < 0) {
@@ -3615,7 +3935,6 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     const apiClient = this.getApiClientOrThrow();
     const distinctId = identityManager.getDistinctId();
     if (!distinctId) {
-      if (this.config?.debug) console.warn("[Paywallo] Skipping event \u2014 no distinctId available");
       return;
     }
     if (!actionName || typeof actionName !== "string") {
@@ -3644,14 +3963,10 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     try {
       const distinctId = identityManager.getDistinctId();
       if (!distinctId) {
-        if (this.config?.debug) console.warn("[Paywallo AB]", "getVariant SKIPPED \u2014 no distinctId", flagKey);
         return { variant: null };
       }
-      const result = await this.getApiClientOrThrow().getVariant(flagKey, distinctId);
-      if (this.config?.debug) console.warn("[Paywallo AB]", `getVariant("${flagKey}") =`, result.variant);
-      return result;
+      return await this.getApiClientOrThrow().getVariant(flagKey, distinctId);
     } catch (error) {
-      if (this.config?.debug) console.warn("[Paywallo]", "getVariant failed \u2014 returning null", error);
       if (this.apiClient) void this.apiClient.reportError("GET_VARIANT_FAILED", error instanceof Error ? error.message : String(error));
       return { variant: null };
     }
@@ -3667,7 +3982,6 @@ var _PaywalloClientClass = class _PaywalloClientClass {
       const result = await this.getApiClientOrThrow().getConditionalFlag(flagKey, { distinctId, ...context });
       return result.value;
     } catch (error) {
-      if (this.config?.debug) console.warn("[Paywallo]", "getConditionalFlag failed \u2014 returning false", error);
       if (this.apiClient) void this.apiClient.reportError("GET_CONDITIONAL_FLAG_FAILED", error instanceof Error ? error.message : String(error));
       return false;
     }
@@ -3690,15 +4004,18 @@ var _PaywalloClientClass = class _PaywalloClientClass {
   async hasActiveSubscription() {
     this.ensureInitialized();
     try {
-      if (this.activeChecker) return await this.activeChecker();
+      if (this.activeChecker) {
+        return await this.activeChecker();
+      }
       const distinctId = identityManager.getDistinctId();
-      if (!distinctId || !this.apiClient) return false;
+      if (!distinctId || !this.apiClient) {
+        return false;
+      }
       const status = await this.apiClient.getSubscriptionStatus(distinctId);
       return status.hasActiveSubscription;
-    } catch {
-      if (this.config?.debug) console.warn("[Paywallo]", "hasActiveSubscription failed \u2014 using persistent cache");
-      if (this.apiClient) void this.apiClient.reportError("SUBSCRIPTION_CHECK_FAILED", "hasActiveSubscription failed");
-      return resolveClientOfflineFromCache();
+    } catch (error) {
+      if (this.apiClient) void this.apiClient.reportError("SUBSCRIPTION_CHECK_FAILED", error instanceof Error ? error.message : "hasActiveSubscription failed");
+      return false;
     }
   }
   async getSubscription() {
@@ -3711,7 +4028,6 @@ var _PaywalloClientClass = class _PaywalloClientClass {
       if (!status.subscription) return null;
       return { ...status.subscription, expiresAt: status.subscription.expiresAt ? new Date(status.subscription.expiresAt) : null };
     } catch {
-      if (this.config?.debug) console.warn("[Paywallo]", "getSubscription failed \u2014 returning null");
       return null;
     }
   }
@@ -3722,20 +4038,24 @@ var _PaywalloClientClass = class _PaywalloClientClass {
   }
   async reset() {
     await identityManager.reset();
+    await subscriptionCache.invalidateAll();
   }
   async fullReset() {
     const wasDebug = this.config?.debug ?? false;
     await sessionManager.endSession();
     await identityManager.reset();
-    await subscriptionCache.invalidate();
+    await subscriptionCache.invalidateAll();
     queueProcessor.dispose();
     offlineQueue.dispose();
     networkMonitor.dispose();
     campaignGateService.clearPreloaded();
     this.cleanupNetworkRecovery();
+    this.sessionFlagsMap.clear();
     this.apiClient = null;
     this.config = null;
     this.initPromise = null;
+    this.readyPromise = null;
+    this.resolveReady = null;
     this.pendingConfig = null;
     this.initAttempts = 0;
     this.paywallPresenter = null;
@@ -3744,7 +4064,13 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     this.activeChecker = null;
     this.restoreHandler = null;
     this.lastOnboardingStepTimestamp = null;
-    if (wasDebug) console.warn("[Paywallo]", "Full reset complete");
+    this.autoPreloadedPlacement = null;
+    this.autoPreloadPlacementPromise = null;
+  }
+  getSessionFlag(key) {
+    if (!this.config || !this.apiClient) return null;
+    const value = this.sessionFlagsMap.get(key);
+    return value !== void 0 ? value : null;
   }
   getConfig() {
     return this.config;
@@ -3833,6 +4159,15 @@ var _PaywalloClientClass = class _PaywalloClientClass {
   getPreloadedCampaign(placement) {
     return campaignGateService.getPreloadedCampaign(placement);
   }
+  isPreloaded(placement) {
+    return campaignGateService.getPreloadedCampaign(placement) !== null;
+  }
+  getAutoPreloadedPlacement() {
+    return this.autoPreloadedPlacement;
+  }
+  waitForAutoPreloadedPlacement() {
+    return this.autoPreloadPlacementPromise ?? Promise.resolve(null);
+  }
   isOnline() {
     return networkMonitor.isOnline();
   }
@@ -3862,48 +4197,6 @@ var PaywalloClient = new PaywalloClientClass();
 import { createContext as createContext2 } from "react";
 var PaywalloContext = createContext2(null);
 
-// src/utils/localization.ts
-import { NativeModules as NativeModules3, Platform as Platform7 } from "react-native";
-var currentLanguage = "pt-BR";
-var defaultLanguage = "pt-BR";
-function setCurrentLanguage(language) {
-  currentLanguage = language;
-}
-function setDefaultLanguage(language) {
-  defaultLanguage = language;
-}
-function getCurrentLanguage() {
-  return currentLanguage;
-}
-function getDefaultLanguage() {
-  return defaultLanguage;
-}
-function getLocalizedString(text) {
-  if (!text) return "";
-  if (typeof text === "string") return text;
-  return text[currentLanguage] ?? text[defaultLanguage] ?? Object.values(text)[0] ?? "";
-}
-function detectDeviceLanguage() {
-  try {
-    if (Platform7.OS === "ios") {
-      const settings = NativeModules3.SettingsManager?.settings;
-      return settings?.AppleLocale ?? settings?.AppleLanguages?.[0] ?? "en-US";
-    }
-    return NativeModules3.I18nManager?.localeIdentifier ?? "en-US";
-  } catch {
-    return "en-US";
-  }
-}
-function initLocalization(options) {
-  if (options?.defaultLanguage) {
-    defaultLanguage = options.defaultLanguage;
-  }
-  if (options?.detectDevice !== false) {
-    const deviceLanguage = detectDeviceLanguage();
-    currentLanguage = deviceLanguage;
-  }
-}
-
 // src/hooks/usePaywallo.ts
 import { useContext as useContext2 } from "react";
 function usePaywallo() {
@@ -3929,7 +4222,8 @@ function mapToIAPProduct(product) {
     type: product.type === "subscription" ? "subs" : "inapp",
     subscriptionPeriodAndroid: product.subscriptionPeriod,
     introductoryPrice: product.introductoryPrice,
-    freeTrialPeriodAndroid: product.freeTrialPeriod
+    freeTrialPeriodAndroid: product.freeTrialPeriod,
+    trialDays: product.trialDays ?? 0
   };
 }
 function mapToFormattedProduct(product) {
@@ -3944,6 +4238,7 @@ function mapToFormattedProduct(product) {
     subscriptionPeriod: product.subscriptionPeriod,
     introductoryPrice: product.introductoryPrice,
     freeTrialPeriod: product.freeTrialPeriod,
+    trialDays: product.trialDays ?? 0,
     pricePerMonth: product.pricePerMonth,
     pricePerWeek: product.pricePerWeek,
     pricePerDay: product.pricePerDay
@@ -4025,27 +4320,37 @@ function usePurchase() {
     setError(null);
     try {
       const iapService = getIAPService();
-      const result = await iapService.purchase(productId);
+      const result = await iapService.purchase(productId, {
+        onValidating: () => setState("validating")
+      });
       if (result.success && result.purchase) {
         setState("idle");
         return {
-          productId: result.purchase.productId,
-          transactionId: result.purchase.transactionId,
-          transactionDate: result.purchase.transactionDate,
-          transactionReceipt: result.purchase.receipt
+          status: "success",
+          purchase: {
+            productId: result.purchase.productId,
+            transactionId: result.purchase.transactionId,
+            transactionDate: result.purchase.transactionDate,
+            transactionReceipt: result.purchase.receipt
+          }
         };
       }
       if (result.error) {
-        const purchaseError = createPurchaseError("PURCHASE_FAILED", result.error.message);
-        setError(purchaseError);
+        setError(result.error);
         setState("error");
-        throw result.error;
+        return { status: "failed", error: result.error };
       }
       setState("idle");
-      throw new PurchaseError(PURCHASE_ERROR_CODES.USER_CANCELLED, "Purchase cancelled by user", true);
+      return { status: "cancelled" };
     } catch (err) {
+      const purchaseError = err instanceof PurchaseError ? err : createPurchaseError("PURCHASE_FAILED", err instanceof Error ? err.message : String(err));
+      if (purchaseError.userCancelled) {
+        setState("idle");
+        return { status: "cancelled" };
+      }
+      setError(purchaseError);
       setState("error");
-      throw err;
+      return { status: "failed", error: purchaseError };
     }
   }, []);
   const restore = useCallback7(async () => {
@@ -4074,146 +4379,14 @@ function usePurchase() {
     restore,
     error,
     isLoading: state === "loading",
-    isPurchasing: state === "purchasing",
+    isPurchasing: state === "purchasing" || state === "validating",
+    isValidating: state === "validating",
     isRestoring: state === "restoring"
   };
 }
 
 // src/hooks/useSubscription.ts
 import { useCallback as useCallback8, useEffect as useEffect6, useState as useState8 } from "react";
-
-// src/domains/subscription/SubscriptionManager.ts
-import { Platform as Platform8 } from "react-native";
-var SubscriptionManagerClass = class {
-  constructor() {
-    this.config = null;
-    this.listeners = /* @__PURE__ */ new Set();
-    this.userId = null;
-    this.cache = new SubscriptionCache();
-  }
-  init(config) {
-    this.config = config;
-    if (config.cacheTTL) {
-      this.cache.setTTL(config.cacheTTL);
-    }
-  }
-  setUserId(userId) {
-    if (this.userId !== userId) {
-      this.userId = userId;
-      void this.cache.invalidate();
-    }
-  }
-  async hasActiveSubscription(forceRefresh = false) {
-    const status = await this.getSubscriptionStatus(forceRefresh);
-    return status.hasActiveSubscription;
-  }
-  async getSubscription(forceRefresh = false) {
-    const status = await this.getSubscriptionStatus(forceRefresh);
-    return status.subscription;
-  }
-  async getEntitlements(forceRefresh = false) {
-    const status = await this.getSubscriptionStatus(forceRefresh);
-    return status.entitlements;
-  }
-  async getSubscriptionStatus(forceRefresh = false) {
-    if (!this.config) {
-      return this.getEmptyStatus();
-    }
-    if (!forceRefresh) {
-      const cached = await this.cache.get();
-      if (cached && !cached.isStale) {
-        return cached.data;
-      }
-    }
-    try {
-      const status = await this.fetchSubscriptionStatus();
-      await this.cache.set(status);
-      this.notifyListeners(status);
-      return status;
-    } catch (error) {
-      this.log("Failed to fetch subscription status", error);
-      const cached = await this.cache.get();
-      if (cached) {
-        return cached.data;
-      }
-      return this.getEmptyStatus();
-    }
-  }
-  async restorePurchases() {
-    if (!this.config) {
-      throw new SessionError(
-        SESSION_ERROR_CODES.NOT_INITIALIZED,
-        "SubscriptionManager not initialized"
-      );
-    }
-    await this.cache.invalidate();
-    return this.getSubscriptionStatus(true);
-  }
-  async fetchSubscriptionStatus() {
-    if (!this.config) {
-      return this.getEmptyStatus();
-    }
-    const url = new URL(`${this.config.serverUrl}/subscriptions/status`);
-    if (this.userId) {
-      url.searchParams.set("userId", this.userId);
-    }
-    url.searchParams.set("platform", Platform8.OS);
-    const response = await fetch(url.toString(), {
-      method: "GET",
-      headers: {
-        "Content-Type": "application/json",
-        "X-App-Key": this.config.appKey
-      }
-    });
-    if (!response.ok) {
-      throw new SessionError(
-        SESSION_ERROR_CODES.RESTORE_FAILED,
-        `Failed to fetch subscription status: ${response.status}`
-      );
-    }
-    const data = await response.json();
-    if (data.subscription) {
-      data.subscription.expiresAt = new Date(data.subscription.expiresAt);
-      data.subscription.originalPurchaseDate = new Date(data.subscription.originalPurchaseDate);
-      data.subscription.latestPurchaseDate = new Date(data.subscription.latestPurchaseDate);
-      if (data.subscription.cancellationDate) {
-        data.subscription.cancellationDate = new Date(data.subscription.cancellationDate);
-      }
-      if (data.subscription.gracePeriodExpiresAt) {
-        data.subscription.gracePeriodExpiresAt = new Date(data.subscription.gracePeriodExpiresAt);
-      }
-    }
-    return data;
-  }
-  getEmptyStatus() {
-    return {
-      hasActiveSubscription: false,
-      subscription: null,
-      entitlements: []
-    };
-  }
-  addListener(listener) {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-  notifyListeners(status) {
-    for (const listener of this.listeners) {
-      listener(status);
-    }
-  }
-  async onPurchaseComplete() {
-    await this.cache.invalidate();
-    await this.getSubscriptionStatus(true);
-  }
-  log(message, data) {
-    if (this.config?.debug) {
-      console.warn(`[SubscriptionManager] ${message}`, data ?? "");
-    }
-  }
-};
-var subscriptionManager = new SubscriptionManagerClass();
-
-// src/hooks/useSubscription.ts
 function useSubscription() {
   const [status, setStatus] = useState8(null);
   const [isLoading, setIsLoading] = useState8(true);
@@ -4268,7 +4441,7 @@ function useSubscription() {
 }
 
 // src/PaywalloProvider.tsx
-import { useCallback as useCallback13, useEffect as useEffect7, useMemo as useMemo2, useRef as useRef8, useState as useState12 } from "react";
+import { useCallback as useCallback13, useEffect as useEffect7, useLayoutEffect, useMemo as useMemo2, useRef as useRef8, useState as useState12 } from "react";
 import { Animated as Animated3, Dimensions as Dimensions4, Easing as Easing2, StyleSheet as StyleSheet3 } from "react-native";
 
 // src/hooks/useCampaignPreload.ts
@@ -4330,10 +4503,9 @@ var CACHE_TTL_MS = 5 * 60 * 1e3;
 function isCacheEntryValid(entry) {
   return !!entry && Date.now() - entry.preloadedAt < CACHE_TTL_MS;
 }
-function consumeCacheEntry(cache, placement) {
+function getCacheEntry(cache, placement) {
   const entry = cache.get(placement);
   if (!isCacheEntryValid(entry)) return null;
-  cache.delete(placement);
   return entry ?? null;
 }
 
@@ -4346,7 +4518,7 @@ function useCampaignPreload() {
     []
   );
   const consumePreloadedCampaign = useCallback9(
-    (placement) => consumeCacheEntry(preloadedCampaignsRef.current, placement),
+    (placement) => getCacheEntry(preloadedCampaignsRef.current, placement),
     []
   );
   const preloadCampaign = useCallback9(
@@ -4394,6 +4566,7 @@ function useCampaignPreload() {
           campaignId: campaign.campaignId,
           variantKey: campaign.variantKey
         });
+        if (PaywalloClient.getConfig()?.debug) console.info(`[Paywallo WEBVIEW] mounting hidden \u2014 placement: ${placement}`);
         return { success: true };
       } catch (error) {
         return {
@@ -4428,7 +4601,6 @@ function useProductLoader() {
       for (const p of loaded) map.set(p.productId, p);
       setProducts(map);
     } catch (error) {
-      if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] Product load failed:", error);
     } finally {
       setIsLoadingProducts(false);
     }
@@ -4438,7 +4610,7 @@ function useProductLoader() {
 
 // src/hooks/usePurchaseOrchestrator.ts
 import { useCallback as useCallback11 } from "react";
-function usePurchaseOrchestrator(preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef) {
+function usePurchaseOrchestrator(preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef, invalidateSubscriptionCache) {
   const { trackDismissed, trackProductSelected, trackPurchased } = usePaywallTracking();
   const handlePreloadedPurchase = useCallback11(
     async (productId) => {
@@ -4463,17 +4635,17 @@ function usePurchaseOrchestrator(preloadedWebView, resolvePreloadedPaywall, clea
           await trackDismissed({ placement: preloadedWebView.placement, paywallId: preloadedWebView.paywallId, durationSeconds, action: "purchase", variantKey: preloadedWebView.variantKey, campaignId: preloadedWebView.campaignId });
           await trackPurchased({ placement: preloadedWebView.placement, paywallId: preloadedWebView.paywallId, productId, variantKey: preloadedWebView.variantKey, campaignId: preloadedWebView.campaignId });
         }
+        invalidateSubscriptionCache();
         setShowingPreloadedWebView(false);
         clearPreloadedWebView();
         resolvePreloadedPaywall({ presented: true, purchased: true, cancelled: false, restored: false });
       } catch (error) {
-        if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] Preloaded purchase error:", error);
         setShowingPreloadedWebView(false);
         clearPreloadedWebView();
         resolvePreloadedPaywall({ presented: true, purchased: false, cancelled: false, restored: false });
       }
     },
-    [preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef, trackDismissed, trackProductSelected, trackPurchased]
+    [preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef, trackDismissed, trackProductSelected, trackPurchased, invalidateSubscriptionCache]
   );
   const handlePreloadedRestore = useCallback11(async () => {
     try {
@@ -4483,16 +4655,16 @@ function usePurchaseOrchestrator(preloadedWebView, resolvePreloadedPaywall, clea
         const durationSeconds = Math.round((Date.now() - presentedAtRef.current) / 1e3);
         await trackDismissed({ placement: preloadedWebView.placement, paywallId: preloadedWebView.paywallId, durationSeconds, action: "restore", variantKey: preloadedWebView.variantKey, campaignId: preloadedWebView.campaignId });
       }
+      invalidateSubscriptionCache();
       setShowingPreloadedWebView(false);
       clearPreloadedWebView();
       resolvePreloadedPaywall({ presented: true, purchased: false, cancelled: false, restored: true });
     } catch (error) {
-      if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] Preloaded restore error:", error);
       setShowingPreloadedWebView(false);
       clearPreloadedWebView();
       resolvePreloadedPaywall({ presented: true, purchased: false, cancelled: false, restored: false });
     }
-  }, [preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef, trackDismissed]);
+  }, [preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef, trackDismissed, invalidateSubscriptionCache]);
   return { handlePreloadedPurchase, handlePreloadedRestore };
 }
 
@@ -4504,7 +4676,6 @@ function toDomainSubscriptionInfo(sub) {
   return {
     id: "",
     productId: sub.productId,
-    // The hook's SubscriptionStatus is a subset of the domain's — cast is safe
     status: sub.status,
     expiresAt: sub.expiresAt ?? /* @__PURE__ */ new Date(0),
     originalPurchaseDate: /* @__PURE__ */ new Date(0),
@@ -4522,31 +4693,32 @@ function toDomainResponse(status) {
     entitlements: []
   };
 }
-async function resolveOfflineFromCache() {
+function isSubscriptionStillActive(sub) {
+  if (!sub) return false;
+  if (!ACTIVE_STATUSES.includes(sub.status)) return false;
+  if (sub.expiresAt && sub.expiresAt.getTime() !== 0 && sub.expiresAt < /* @__PURE__ */ new Date()) return false;
+  return true;
+}
+async function resolveOfflineFromCache(distinctId) {
   try {
-    const cached = await subscriptionCache.get();
+    const cached = await subscriptionCache.get(distinctId);
     if (!cached) return false;
     const sub = cached.data.subscription;
-    if (!sub) return false;
-    if (!ACTIVE_STATUSES.includes(sub.status)) return false;
-    const hasValidExpiry = sub.expiresAt.getTime() === 0 || sub.expiresAt > /* @__PURE__ */ new Date();
-    return hasValidExpiry;
+    return isSubscriptionStillActive(sub ? { status: sub.status, expiresAt: sub.expiresAt ?? null } : null);
   } catch {
     return false;
   }
 }
 function isActiveCacheEntry(entry) {
-  if (!entry.data) return false;
-  if (!ACTIVE_STATUSES.includes(entry.data.status)) return false;
-  if (entry.data.expiresAt && entry.data.expiresAt < /* @__PURE__ */ new Date()) return false;
-  return true;
+  return isSubscriptionStillActive(entry.data);
 }
 function useSubscriptionSync() {
   const [subscription, setSubscription] = useState11(null);
   const cacheRef = useRef7(null);
   const invalidateCache = useCallback12(() => {
     cacheRef.current = null;
-    void subscriptionCache.invalidate();
+    const distinctId = PaywalloClient.getDistinctId();
+    if (distinctId) void subscriptionCache.invalidate(distinctId);
   }, []);
   const fetchAndCache = useCallback12(async () => {
     const apiClient = PaywalloClient.getApiClient();
@@ -4559,7 +4731,7 @@ function useSubscriptionSync() {
     } : null;
     cacheRef.current = { data: sub, expiresAt: Date.now() + CACHE_TTL_MS2 };
     setSubscription(sub);
-    void subscriptionCache.set(toDomainResponse(status));
+    void subscriptionCache.set(distinctId, toDomainResponse(status));
     return sub;
   }, []);
   const hasActiveSubscription = useCallback12(async () => {
@@ -4571,23 +4743,23 @@ function useSubscriptionSync() {
       return isActiveCacheEntry(cached);
     }
     try {
-      const persisted = await subscriptionCache.get();
-      if (persisted) {
-        if (!persisted.isStale) {
-          const sub = persisted.data.subscription ? {
-            productId: persisted.data.subscription.productId,
-            status: persisted.data.subscription.status,
-            expiresAt: persisted.data.subscription.expiresAt ?? null,
-            platform: persisted.data.subscription.platform,
-            autoRenewEnabled: persisted.data.subscription.willRenew,
-            inGracePeriod: persisted.data.subscription.status === "grace_period"
-          } : null;
+      const persisted = await subscriptionCache.get(distinctId);
+      if (persisted && !persisted.isStale) {
+        const persistedSub = persisted.data.subscription;
+        const sub = persistedSub ? {
+          productId: persistedSub.productId,
+          status: persistedSub.status,
+          expiresAt: persistedSub.expiresAt ?? null,
+          platform: persistedSub.platform,
+          autoRenewEnabled: persistedSub.willRenew,
+          inGracePeriod: persistedSub.status === "grace_period"
+        } : null;
+        const stillActive = isSubscriptionStillActive(sub);
+        if (stillActive) {
           cacheRef.current = { data: sub, expiresAt: Date.now() + CACHE_TTL_MS2 };
           setSubscription(sub);
-          return persisted.data.hasActiveSubscription;
+          return true;
         }
-        void fetchAndCache();
-        return persisted.data.hasActiveSubscription;
       }
     } catch {
     }
@@ -4599,12 +4771,12 @@ function useSubscriptionSync() {
       } : null;
       cacheRef.current = { data: sub, expiresAt: Date.now() + CACHE_TTL_MS2 };
       setSubscription(sub);
-      void subscriptionCache.set(toDomainResponse(status));
+      void subscriptionCache.set(distinctId, toDomainResponse(status));
       return status.hasActiveSubscription;
     } catch {
-      return await resolveOfflineFromCache();
+      return await resolveOfflineFromCache(distinctId);
     }
-  }, [fetchAndCache]);
+  }, []);
   const getSubscription = useCallback12(async () => {
     const apiClient = PaywalloClient.getApiClient();
     const distinctId = PaywalloClient.getDistinctId();
@@ -4615,7 +4787,7 @@ function useSubscriptionSync() {
       return await fetchAndCache();
     } catch {
       try {
-        const persisted = await subscriptionCache.get();
+        const persisted = await subscriptionCache.get(distinctId);
         if (!persisted?.data.subscription) return null;
         const s = persisted.data.subscription;
         const normalisedStatus = s.status === "grace_period" ? "in_grace_period" : s.status;
@@ -4646,13 +4818,38 @@ function PaywalloProvider({ children, config }) {
   const { subscription, hasActiveSubscription, getSubscription, invalidateCache } = useSubscriptionSync();
   const { preloadedWebView, setPreloadedWebView, preloadCampaign, consumePreloadedCampaign, isPreloadValid } = useCampaignPreload();
   const clearPreloadedWebView = useCallback13(() => setPreloadedWebView(null), [setPreloadedWebView]);
-  const { showingPreloadedWebView, presentPreloadedWebView, resolvePreloadedPaywall, handlePreloadedWebViewReady, handlePreloadedClose, setShowingPreloadedWebView, presentedAtRef } = usePaywallPresenter(preloadedWebView, clearPreloadedWebView, setPreloadedWebView);
+  const autoPreloadTriggeredRef = useRef8(false);
+  const preloadedWebViewRef = useRef8(preloadedWebView);
+  useEffect7(() => {
+    preloadedWebViewRef.current = preloadedWebView;
+  }, [preloadedWebView]);
+  const triggerRepreload = useCallback13((placement) => {
+    void PaywalloClient.preloadCampaign(placement).catch(() => {
+    });
+  }, []);
+  const { showingPreloadedWebView, presentPreloadedWebView, resolvePreloadedPaywall, handlePreloadedWebViewReady: baseHandlePreloadedWebViewReady, handlePreloadedClose: baseHandlePreloadedClose, setShowingPreloadedWebView, presentedAtRef } = usePaywallPresenter(preloadedWebView, setPreloadedWebView);
+  const SCREEN_HEIGHT3 = useMemo2(() => Dimensions4.get("window").height, []);
+  const slideAnim = useRef8(new Animated3.Value(SCREEN_HEIGHT3)).current;
+  const handlePreloadedWebViewReady = useCallback13(() => {
+    if (PaywalloClient.getConfig()?.debug) {
+      console.info(`[Paywallo WEBVIEW] loaded \u2014 placement: ${preloadedWebView?.placement}`);
+    }
+    baseHandlePreloadedWebViewReady();
+  }, [config?.debug, preloadedWebView?.placement, baseHandlePreloadedWebViewReady]);
+  const handlePreloadedClose = useCallback13(() => {
+    const placement = preloadedWebView?.placement;
+    Animated3.timing(slideAnim, { toValue: SCREEN_HEIGHT3, duration: 200, easing: Easing2.in(Easing2.cubic), useNativeDriver: true }).start(() => {
+      baseHandlePreloadedClose();
+      if (placement) triggerRepreload(placement);
+    });
+  }, [baseHandlePreloadedClose, preloadedWebView, triggerRepreload, slideAnim, SCREEN_HEIGHT3]);
   const { handlePreloadedPurchase: rawPreloadedPurchase, handlePreloadedRestore } = usePurchaseOrchestrator(
     preloadedWebView,
     resolvePreloadedPaywall,
     clearPreloadedWebView,
     setShowingPreloadedWebView,
-    presentedAtRef
+    presentedAtRef,
+    invalidateCache
   );
   const [isPreloadPurchasing, setIsPreloadPurchasing] = useState12(false);
   const handlePreloadedPurchase = useCallback13(async (productId) => {
@@ -4665,13 +4862,19 @@ function PaywalloProvider({ children, config }) {
   }, [rawPreloadedPurchase]);
   useEffect7(() => {
     initLocalization({ detectDevice: true });
-    PaywalloClient.init(config).then(() => {
+    PaywalloClient.init(config).then(async () => {
       setDistinctId(PaywalloClient.getDistinctId());
       setIsInitialized(true);
+      if (!autoPreloadTriggeredRef.current) {
+        autoPreloadTriggeredRef.current = true;
+        const placement = await PaywalloClient.waitForAutoPreloadedPlacement();
+        if (placement) void preloadCampaign(placement).catch(() => {
+        });
+      }
     }).catch((err) => {
       setInitError(err instanceof Error ? err : new ClientError(CLIENT_ERROR_CODES.NOT_INITIALIZED, String(err)));
     });
-  }, [config]);
+  }, [config, preloadCampaign]);
   const getPaywallConfig = useCallback13(async (p) => {
     const api = PaywalloClient.getApiClient();
     return api ? api.getPaywall(p) : null;
@@ -4770,28 +4973,54 @@ function PaywalloProvider({ children, config }) {
       setActivePaywall(null);
     }
   }, [activePaywall]);
+  const bridgePaywallPresenter = useCallback13((placement) => {
+    if (PaywalloClient.getConfig()?.debug) {
+      console.info(`[Paywallo PRESENT] called \u2014 preloaded: ${preloadedWebViewRef.current?.loaded === true} placement: ${placement}`);
+    }
+    if (preloadedWebViewRef.current?.placement === placement) {
+      if (preloadedWebViewRef.current.loaded) {
+        return presentPreloadedWebView();
+      }
+      return new Promise((resolve) => {
+        let elapsed = 0;
+        const poll = () => {
+          if (preloadedWebViewRef.current?.loaded) {
+            resolve(presentPreloadedWebView());
+            return;
+          }
+          elapsed += 100;
+          if (elapsed >= 500) {
+            resolve(presentCampaign(placement));
+            return;
+          }
+          setTimeout(poll, 100);
+        };
+        setTimeout(poll, 100);
+      });
+    }
+    return presentCampaign(placement);
+  }, [presentPreloadedWebView, presentCampaign]);
   useEffect7(() => {
     if (!isInitialized) return;
     const onEmergency = async (id) => {
       try {
-        await presentPaywall(id);
+        await bridgePaywallPresenter(id);
       } catch {
       }
     };
-    PaywalloClient.registerPaywallPresenter(presentPaywall);
+    PaywalloClient.registerPaywallPresenter(bridgePaywallPresenter);
     PaywalloClient.registerSubscriptionGetter(getSubscription);
     PaywalloClient.registerActiveChecker(hasActiveSubscription);
     PaywalloClient.registerRestoreHandler(restorePurchases);
     PaywalloClient.registerEmergencyPaywallHandler(onEmergency);
-  }, [isInitialized, presentPaywall, getSubscription, hasActiveSubscription, restorePurchases]);
-  useEffect7(() => {
-    if (activePaywall) setPreloadedWebView(null);
-  }, [activePaywall, setPreloadedWebView]);
+  }, [isInitialized, bridgePaywallPresenter, getSubscription, hasActiveSubscription, restorePurchases]);
+  const isReady = isInitialized && !isLoadingProducts;
   const noOp = useCallback13(() => {
   }, []);
   const contextValue = useMemo2(() => ({
     config: PaywalloClient.getConfig(),
     isInitialized,
+    isReady,
     initError,
     distinctId,
     subscription,
@@ -4807,6 +5036,7 @@ function PaywalloProvider({ children, config }) {
     refreshProducts
   }), [
     isInitialized,
+    isReady,
     initError,
     distinctId,
     subscription,
@@ -4821,20 +5051,16 @@ function PaywalloProvider({ children, config }) {
     getPaywallConfig,
     refreshProducts
   ]);
-  const SCREEN_HEIGHT3 = useMemo2(() => Dimensions4.get("window").height, []);
-  const slideAnim = useRef8(new Animated3.Value(SCREEN_HEIGHT3)).current;
-  useEffect7(() => {
+  useLayoutEffect(() => {
     if (showingPreloadedWebView) {
       slideAnim.setValue(SCREEN_HEIGHT3);
-      Animated3.timing(slideAnim, { toValue: 0, duration: 320, easing: Easing2.out(Easing2.cubic), useNativeDriver: true }).start();
-    } else {
-      slideAnim.setValue(SCREEN_HEIGHT3);
+      Animated3.timing(slideAnim, { toValue: 0, duration: 200, easing: Easing2.out(Easing2.cubic), useNativeDriver: true }).start();
     }
   }, [showingPreloadedWebView, slideAnim, SCREEN_HEIGHT3]);
   const preloadStyle = [
     styles3.preloadOverlay,
     showingPreloadedWebView ? styles3.visible : styles3.hidden,
-    { transform: [{ translateY: showingPreloadedWebView ? slideAnim : SCREEN_HEIGHT3 }] }
+    showingPreloadedWebView ? { transform: [{ translateY: slideAnim }] } : void 0
   ];
   return /* @__PURE__ */ jsxs2(PaywalloContext.Provider, { value: contextValue, children: [
     children,
@@ -4847,6 +5073,7 @@ function PaywalloProvider({ children, config }) {
         primaryProductId: preloadedWebView.primaryProductId,
         secondaryProductId: preloadedWebView.secondaryProductId,
         isPurchasing: isPreloadPurchasing,
+        webUrl: isInitialized ? PaywalloClient.getWebUrl() : null,
         onReady: handlePreloadedWebViewReady,
         onClose: showingPreloadedWebView ? handlePreloadedClose : noOp,
         onPurchase: showingPreloadedWebView ? handlePreloadedPurchase : noOp,
@@ -4869,8 +5096,8 @@ function PaywalloProvider({ children, config }) {
 }
 var styles3 = StyleSheet3.create({
   preloadOverlay: { position: "absolute", top: 0, left: 0, right: 0, bottom: 0, backgroundColor: "#ffffff" },
-  hidden: { zIndex: -1 },
-  visible: { zIndex: 9999 }
+  hidden: { zIndex: -1, opacity: 0, width: 1, height: 1, overflow: "hidden" },
+  visible: { zIndex: 9999, opacity: 1 }
 });
 
 // src/utils/productVariableResolver.ts