@virex-tech/paywallo-sdk 1.1.1 → 1.3.0

package/dist/index.mjs

@@ -38,8 +38,17 @@ var CLIENT_ERROR_CODES = {
 };
 
 // src/domains/paywall/PaywallModal.tsx
-import { useEffect as useEffect3, useRef as useRef4 } from "react";
-import { Animated as Animated2, Dimensions as Dimensions2, Easing, Modal, StyleSheet as StyleSheet2, Text, View as View2 } from "react-native";
+import { useCallback as useCallback4, useEffect as useEffect3, useRef as useRef4, useState as useState4 } from "react";
+import {
+  Animated as Animated2,
+  Dimensions as Dimensions2,
+  Easing,
+  Modal,
+  Pressable,
+  StyleSheet as StyleSheet2,
+  Text,
+  View as View2
+} from "react-native";
 
 // src/domains/paywall/usePaywallActions.ts
 import { useCallback as useCallback2, useRef, useState } from "react";
@@ -136,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) {
@@ -154,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([
@@ -220,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;
@@ -251,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 ?? "";
   }
@@ -291,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;
@@ -320,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() {
@@ -354,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;
     }
@@ -388,11 +390,6 @@ var IdentityManager = class {
       );
     }
   }
-  log(...args) {
-    if (this.debug) {
-      console.warn("[Paywallo Identity]", ...args);
-    }
-  }
 };
 var identityManager = new IdentityManager();
 
@@ -477,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);
@@ -548,7 +544,6 @@ var IAPService = class {
       }
       return products;
     } catch (error) {
-      if (this.debug) console.warn("[Paywallo][Products] StoreKit error:", error);
       return [];
     }
   }
@@ -558,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")
@@ -597,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")
@@ -617,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 };
     }
   }
@@ -653,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 [];
     }
   }
@@ -728,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;
@@ -737,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 });
@@ -746,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);
@@ -764,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);
@@ -785,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);
@@ -860,11 +862,6 @@ function usePaywallLoader(placement, visible, preloadedConfig, preloadedProducts
             const storeProducts = await getIAPService().loadProducts(productIds);
             const map = /* @__PURE__ */ new Map();
             for (const p of storeProducts) map.set(p.productId, p);
-            if (PaywalloClient.getConfig()?.debug) {
-              for (const [id, p] of map) {
-                console.warn(`[Paywallo][CURRENCY-CHECK] product=${id} currency=${p.currency} price="${p.price}" localizedPrice="${p.localizedPrice}" priceValue=${p.priceValue} fallbackUSD=${!p.currency || p.currency === "USD" ? "POSSIBLE" : "NO"}`);
-              }
-            }
             setProducts(map);
           } catch {
             setProducts(/* @__PURE__ */ new Map());
@@ -885,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);
       }
     };
@@ -894,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);
@@ -929,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;`;
@@ -947,10 +1028,17 @@ function getNativeWebView() {
 var webViewEmitter = null;
 function getWebViewEmitter() {
   if (!webViewEmitter) {
-    webViewEmitter = new NativeEventEmitter(NativeModules2.PaywalloWebViewModule);
+    webViewEmitter = new NativeEventEmitter(NativeModules3.PaywalloWebViewModule);
   }
   return webViewEmitter;
 }
+function parseErrorEvent(raw) {
+  return {
+    code: typeof raw["code"] === "number" ? raw["code"] : -1,
+    description: typeof raw["description"] === "string" ? raw["description"] : "WebView error",
+    url: typeof raw["url"] === "string" ? raw["url"] : void 0
+  };
+}
 function PaywallWebView({
   paywallId,
   craftData,
@@ -958,16 +1046,51 @@ function PaywallWebView({
   primaryProductId,
   secondaryProductId,
   isPurchasing,
+  webUrl: webUrlProp,
   onPurchase,
   onClose,
   onRestore,
-  onReady
+  onReady,
+  onError
 }) {
   const paywallDataSent = useRef3(false);
   const loadEndReceived = useRef3(false);
   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;
@@ -978,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);
@@ -1025,17 +1150,51 @@ function PaywallWebView({
       const message = parseWebViewMessage(event.data);
       if (message) handleParsedMessage(message);
     });
+    const errorSub = emitter.addListener(
+      "PaywalloWebViewError",
+      (event) => {
+        onErrorRef.current?.(parseErrorEvent(event));
+      }
+    );
     return () => {
       loadEndSub.remove();
       messageSub.remove();
+      errorSub.remove();
     };
   }, [buildAndSetInjectionScript, handleParsedMessage]);
+  useEffect2(() => {
+    const timer = setTimeout(() => {
+      if (!paywallDataSent.current) {
+        onErrorRef.current?.({
+          code: -1001,
+          description: "Paywall load timed out after 10 seconds"
+        });
+      }
+    }, 1e4);
+    return () => clearTimeout(timer);
+  }, []);
   const handleLoadEnd = useCallback3(() => {
     if (!loadEndReceived.current) {
       loadEndReceived.current = true;
       buildAndSetInjectionScript();
     }
   }, [buildAndSetInjectionScript]);
+  const handleNativeError = useCallback3((event) => {
+    const ne = event.nativeEvent;
+    let errorData;
+    if (ne["payload"] && typeof ne["payload"] === "object") {
+      errorData = ne["payload"];
+    } else if (typeof ne["data"] === "string") {
+      try {
+        errorData = JSON.parse(ne["data"]);
+      } catch {
+        errorData = {};
+      }
+    } else {
+      errorData = {};
+    }
+    onErrorRef.current?.(parseErrorEvent(errorData));
+  }, []);
   const handleMessage = useCallback3(
     (event) => {
       const message = parseWebViewMessage(event.nativeEvent.data);
@@ -1047,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,
     {
@@ -1055,6 +1215,7 @@ function PaywallWebView({
       injectedJavaScript: scriptToInject,
       onMessage: handleMessage,
       onLoadEnd: handleLoadEnd,
+      onError: handleNativeError,
       style: styles.webview
     }
   ) });
@@ -1065,8 +1226,20 @@ var styles = StyleSheet.create({
 });
 
 // src/domains/paywall/PaywallModal.tsx
-import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+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,
@@ -1084,10 +1257,35 @@ 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);
+  const handleWebViewError = useCallback4(
+    (err) => {
+      if (retryCountRef.current >= 1) {
+        setWebViewError({ code: err.code, description: err.description });
+      } else {
+        retryCountRef.current += 1;
+        setRetryCount(retryCountRef.current);
+      }
+    },
+    []
+  );
+  const handleRetry = useCallback4(() => {
+    retryCountRef.current = 0;
+    setWebViewError(null);
+    setRetryCount(0);
+  }, []);
   useEffect3(() => {
     if (visible) {
+      setModalVisible(true);
       openAnim.setValue(SCREEN_HEIGHT2);
       Animated2.timing(openAnim, {
         toValue: 0,
@@ -1097,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,
@@ -1109,7 +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(
+        !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,
@@ -1120,39 +1325,67 @@ function PaywallModal({
             isPurchasing,
             onClose: handleClose,
             onPurchase: handlePurchase,
-            onRestore: handleRestore
-          }
-        )
+            onRestore: handleRestore,
+            onError: handleWebViewError
+          },
+          retryCount
+        ) })
       ] }) }) })
     }
   );
 }
 var styles2 = StyleSheet2.create({
-  overlay: {
+  overlay: { flex: 1, backgroundColor: "rgba(0,0,0,0.3)" },
+  animatedContainer: { flex: 1, backgroundColor: "#fff" },
+  container: { flex: 1, backgroundColor: "#fff" },
+  errorContainer: { flex: 1, justifyContent: "center", alignItems: "center", padding: 20 },
+  errorText: { fontSize: 16, color: "#ef4444", textAlign: "center" },
+  fallbackContainer: {
     flex: 1,
-    backgroundColor: "rgba(0,0,0,0.3)"
+    justifyContent: "center",
+    alignItems: "center",
+    backgroundColor: "#111010",
+    padding: 24
   },
-  animatedContainer: {
-    flex: 1,
-    backgroundColor: "#fff",
-    borderTopLeftRadius: 0,
-    borderTopRightRadius: 0
+  fallbackCard: {
+    width: "100%",
+    maxWidth: 360,
+    alignItems: "center",
+    backgroundColor: "rgba(255,255,255,0.07)",
+    borderRadius: 16,
+    padding: 28
   },
-  container: {
-    flex: 1,
-    backgroundColor: "#fff"
+  fallbackTitle: {
+    fontSize: 18,
+    fontWeight: "600",
+    color: "#f5f5f5",
+    marginBottom: 10,
+    textAlign: "center"
   },
-  errorContainer: {
-    flex: 1,
-    justifyContent: "center",
+  fallbackDescription: {
+    fontSize: 14,
+    color: "rgba(255,255,255,0.55)",
+    textAlign: "center",
+    marginBottom: 28,
+    lineHeight: 20
+  },
+  retryButton: {
+    width: "100%",
+    backgroundColor: "#ffffff",
+    borderRadius: 10,
+    paddingVertical: 14,
     alignItems: "center",
-    padding: 20
+    marginBottom: 12
   },
-  errorText: {
-    fontSize: 16,
-    color: "#ef4444",
-    textAlign: "center"
-  }
+  retryButtonText: { fontSize: 15, fontWeight: "600", color: "#111010" },
+  closeButton: {
+    width: "100%",
+    borderRadius: 10,
+    paddingVertical: 14,
+    alignItems: "center",
+    backgroundColor: "rgba(255,255,255,0.1)"
+  },
+  closeButtonText: { fontSize: 15, fontWeight: "500", color: "rgba(255,255,255,0.7)" }
 });
 
 // src/domains/paywall/PaywallErrorBoundary.tsx
@@ -1165,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;
@@ -1188,9 +1420,9 @@ function usePaywallContext() {
 }
 
 // src/domains/paywall/usePaywallPresenter.ts
-import { useCallback as useCallback4, useEffect as useEffect4, useRef as useRef5, useState as useState4 } from "react";
-function usePaywallPresenter(preloadedWebView, clearPreloadedWebView, setPreloadedWebView) {
-  const [showingPreloadedWebView, setShowingPreloadedWebView] = useState4(false);
+import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef5, useState as useState5 } from "react";
+function usePaywallPresenter(preloadedWebView, setPreloadedWebView) {
+  const [showingPreloadedWebView, setShowingPreloadedWebView] = useState5(false);
   const resolverRef = useRef5(null);
   const presentedAtRef = useRef5(Date.now());
   useEffect4(() => {
@@ -1201,23 +1433,23 @@ function usePaywallPresenter(preloadedWebView, clearPreloadedWebView, setPreload
       }
     };
   }, []);
-  const presentPreloadedWebView = useCallback4(() => {
+  const presentPreloadedWebView = useCallback5(() => {
     return new Promise((resolve) => {
       resolverRef.current = resolve;
       presentedAtRef.current = Date.now();
       setShowingPreloadedWebView(true);
     });
   }, []);
-  const resolvePreloadedPaywall = useCallback4((result) => {
+  const resolvePreloadedPaywall = useCallback5((result) => {
     if (resolverRef.current) {
       resolverRef.current(result);
       resolverRef.current = null;
     }
   }, []);
-  const handlePreloadedWebViewReady = useCallback4(() => {
+  const handlePreloadedWebViewReady = useCallback5(() => {
     setPreloadedWebView((prev) => prev ? { ...prev, loaded: true } : null);
   }, [setPreloadedWebView]);
-  const handlePreloadedClose = useCallback4(() => {
+  const handlePreloadedClose = useCallback5(() => {
     const track = async () => {
       try {
         const apiClient = PaywalloClient.getApiClient();
@@ -1238,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 };
 }
 
@@ -1447,10 +1678,7 @@ var AffiliateManager = class {
       );
     }
   }
-  log(...args) {
-    if (this.debug) {
-      console.warn("[AffiliateManager]", ...args);
-    }
+  log(..._args) {
   }
 };
 var affiliateManager = new AffiliateManager();
@@ -1467,138 +1695,394 @@ var PaywalloAffiliate = {
   getWithdrawals: () => affiliateManager.getWithdrawals()
 };
 
-// src/core/ApiClient.ts
-import { Platform as Platform3 } from "react-native";
-
-// src/core/apiUrlUtils.ts
-var DEFAULT_WEB_URL = "https://paywallo.com.br";
-function deriveWebUrl(baseUrl) {
-  try {
-    const url = new URL(baseUrl);
-    if (url.hostname.startsWith("192.168") || url.hostname === "localhost") {
-      url.port = "3000";
-      return url.toString().replace(/\/$/, "");
-    }
-    if (url.hostname.startsWith("api.")) {
-      url.hostname = url.hostname.replace("api.", "app.");
-      return url.toString().replace(/\/$/, "");
-    }
-    return DEFAULT_WEB_URL;
-  } catch {
-    return DEFAULT_WEB_URL;
-  }
-}
-function buildConditionalFlagUrl(baseUrl, flagKey, context) {
-  const url = new URL(`${baseUrl}/api/v1/conditional-flags/${flagKey}`);
-  if (context.platform) url.searchParams.set("platform", context.platform);
-  if (context.appVersion) url.searchParams.set("appVersion", context.appVersion);
-  if (context.country) url.searchParams.set("country", context.country);
-  if (context.distinctId) url.searchParams.set("distinctId", context.distinctId);
-  return url.toString();
-}
-
-// src/domains/iap/apiPurchaseMethods.ts
-async function validatePurchase(client, appKey, platform, receipt, productId, transactionId, priceLocal, currency, country, distinctId, paywallPlacement, variantKey) {
-  const response = await client.post(
-    `/purchases/validate/${appKey}`,
-    {
-      platform,
-      receipt,
-      productId,
-      transactionId,
-      priceLocal,
-      currency,
-      country,
-      distinctId,
-      ...paywallPlacement !== void 0 && { paywallPlacement },
-      ...variantKey !== void 0 && { variantKey }
-    },
-    false
-  );
-  return response.data;
-}
-async function getSubscriptionStatus(client, baseUrl, appKey, distinctId) {
-  const url = new URL(`${baseUrl}/purchases/status/${appKey}`);
-  url.searchParams.set("distinctId", distinctId);
-  const response = await client.get(url.toString());
-  return response.data;
-}
-async function getEmergencyPaywall(client) {
-  try {
-    const response = await client.get("/api/v1/emergency-paywall");
-    if (response.status === 404) return { enabled: false };
-    return response.data;
-  } catch {
-    return { enabled: false };
-  }
-}
-async function getCampaignData(client, baseUrl, placement, distinctId, context) {
-  const url = new URL(`${baseUrl}/api/v1/campaigns/${placement}`);
-  url.searchParams.set("distinctId", distinctId);
-  if (context) url.searchParams.set("context", JSON.stringify(context));
-  const response = await client.get(url.toString());
-  if (response.status === 404) return null;
-  const data = response.data;
-  if ("paywall" in data && data.paywall === null && !("campaignId" in data)) return null;
-  return data;
+// src/domains/subscription/SubscriptionCache.ts
+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}`;
 }
-
-// src/core/http/types.ts
-var DEFAULT_RETRY_CONFIG = {
-  maxRetries: 2,
-  baseDelay: 500,
-  maxDelay: 4e3,
-  retryableStatusCodes: [408, 429, 500, 502, 503, 504]
-};
-var DEFAULT_HTTP_CONFIG = {
-  timeout: 1e4,
-  retry: DEFAULT_RETRY_CONFIG,
-  debug: false
-};
-
-// src/core/http/HttpClient.ts
-var HttpClient = class {
-  constructor(baseUrl, config) {
-    this.config = {
-      baseUrl,
-      timeout: config?.timeout ?? DEFAULT_HTTP_CONFIG.timeout,
-      retry: { ...DEFAULT_RETRY_CONFIG, ...config?.retry },
-      debug: config?.debug ?? false
-    };
-  }
-  async get(path, options) {
-    return this.request(path, { ...options, method: "GET" });
-  }
-  async post(path, body, options) {
-    return this.request(path, { ...options, method: "POST", body });
+var SubscriptionCache = class {
+  constructor(ttl = DEFAULT_TTL) {
+    this.memoryCache = /* @__PURE__ */ new Map();
+    this.legacyCleanupDone = false;
+    this.ttl = ttl;
+    this.storage = new SecureStorage();
   }
-  async request(path, options) {
-    const url = this.buildUrl(path);
-    const fetchOptions = this.buildFetchOptions(options);
-    const timeout = options.timeout ?? this.config.timeout;
-    if (options.skipRetry) {
-      return this.executeRequest(url, fetchOptions, timeout);
+  async cleanupLegacyCache() {
+    if (this.legacyCleanupDone) return;
+    this.legacyCleanupDone = true;
+    try {
+      await this.storage.remove(LEGACY_CACHE_KEY);
+    } catch {
     }
-    return this.executeWithRetry(url, fetchOptions, options);
   }
-  async executeWithRetry(url, fetchOptions, options) {
-    const retryConfig = this.config.retry;
-    const timeout = options.timeout ?? this.config.timeout;
-    const state = { attempt: 0, lastError: null };
-    while (state.attempt <= retryConfig.maxRetries) {
-      try {
-        const response = await this.executeRequest(url, fetchOptions, timeout);
-        if (this.shouldRetry(response.status, retryConfig)) {
-          if (state.attempt < retryConfig.maxRetries) {
-            state.attempt++;
-            const delay = this.calculateDelay(state.attempt, retryConfig);
-            await this.sleep(delay);
-            continue;
-          }
-        }
-        return response;
-      } catch (error) {
-        state.lastError = error instanceof Error ? error : new ClientError(CLIENT_ERROR_CODES.UNKNOWN, String(error));
+  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(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(keyFor(distinctId));
+        return null;
+      }
+      const cached = parsed;
+      if (cached.data.subscription?.expiresAt) {
+        cached.data.subscription.expiresAt = new Date(cached.data.subscription.expiresAt);
+      }
+      if (cached.data.subscription?.originalPurchaseDate) {
+        cached.data.subscription.originalPurchaseDate = new Date(
+          cached.data.subscription.originalPurchaseDate
+        );
+      }
+      if (cached.data.subscription?.latestPurchaseDate) {
+        cached.data.subscription.latestPurchaseDate = new Date(
+          cached.data.subscription.latestPurchaseDate
+        );
+      }
+      if (cached.data.subscription?.cancellationDate) {
+        cached.data.subscription.cancellationDate = new Date(
+          cached.data.subscription.cancellationDate
+        );
+      }
+      if (cached.data.subscription?.gracePeriodExpiresAt) {
+        cached.data.subscription.gracePeriodExpiresAt = new Date(
+          cached.data.subscription.gracePeriodExpiresAt
+        );
+      }
+      cached.isStale = this.isExpired(cached);
+      if (!cached.isStale) {
+        this.memoryCache.set(distinctId, cached);
+      }
+      return cached;
+    } catch {
+      return null;
+    }
+  }
+  async set(distinctId, data) {
+    if (!distinctId) return;
+    const cached = {
+      data,
+      cachedAt: Date.now(),
+      isStale: false
+    };
+    this.memoryCache.set(distinctId, cached);
+    try {
+      await this.storage.set(keyFor(distinctId), JSON.stringify(cached));
+    } catch {
+    }
+  }
+  async invalidate(distinctId) {
+    if (!distinctId) return;
+    this.memoryCache.delete(distinctId);
+    try {
+      await this.storage.remove(keyFor(distinctId));
+    } catch {
+    }
+  }
+  async invalidateAll() {
+    this.memoryCache.clear();
+    try {
+      await this.storage.remove(LEGACY_CACHE_KEY);
+    } catch {
+    }
+  }
+  isExpired(cached) {
+    return Date.now() - cached.cachedAt > this.ttl;
+  }
+  setTTL(ttl) {
+    this.ttl = ttl;
+  }
+};
+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 Platform5 } from "react-native";
+
+// src/core/apiUrlUtils.ts
+var DEFAULT_WEB_URL = "https://paywallo.com.br";
+function deriveWebUrl(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    if (url.hostname.startsWith("192.168") || url.hostname === "localhost") {
+      url.port = "3000";
+      return url.toString().replace(/\/$/, "");
+    }
+    if (url.hostname.startsWith("api.")) {
+      url.hostname = url.hostname.replace("api.", "app.");
+      return url.toString().replace(/\/$/, "");
+    }
+    return DEFAULT_WEB_URL;
+  } catch {
+    return DEFAULT_WEB_URL;
+  }
+}
+function buildConditionalFlagUrl(baseUrl, flagKey, context) {
+  const url = new URL(`${baseUrl}/api/v1/conditional-flags/${flagKey}`);
+  if (context.platform) url.searchParams.set("platform", context.platform);
+  if (context.appVersion) url.searchParams.set("appVersion", context.appVersion);
+  if (context.country) url.searchParams.set("country", context.country);
+  if (context.distinctId) url.searchParams.set("distinctId", context.distinctId);
+  return url.toString();
+}
+
+// src/domains/iap/apiPurchaseMethods.ts
+async function validatePurchase(client, appKey, platform, receipt, productId, transactionId, priceLocal, currency, country, distinctId, paywallPlacement, variantKey) {
+  const response = await client.post(
+    `/purchases/validate/${appKey}`,
+    {
+      platform,
+      receipt,
+      productId,
+      transactionId,
+      priceLocal,
+      currency,
+      country,
+      distinctId,
+      ...paywallPlacement !== void 0 && { paywallPlacement },
+      ...variantKey !== void 0 && { variantKey }
+    },
+    false
+  );
+  return response.data;
+}
+async function getSubscriptionStatus(client, baseUrl, appKey, distinctId) {
+  const url = new URL(`${baseUrl}/purchases/status/${appKey}`);
+  url.searchParams.set("distinctId", distinctId);
+  const response = await client.get(url.toString());
+  return response.data;
+}
+async function getEmergencyPaywall(client) {
+  try {
+    const response = await client.get("/api/v1/emergency-paywall");
+    if (response.status === 404) return { enabled: false };
+    return response.data;
+  } catch {
+    return { enabled: false };
+  }
+}
+async function getCampaignData(client, baseUrl, placement, distinctId, context) {
+  const url = new URL(`${baseUrl}/api/v1/campaigns/${placement}`);
+  url.searchParams.set("distinctId", distinctId);
+  if (context) url.searchParams.set("context", JSON.stringify(context));
+  const response = await client.get(url.toString());
+  if (response.status === 404) return null;
+  const data = response.data;
+  if ("paywall" in data && data.paywall === null && !("campaignId" in data)) return null;
+  return data;
+}
+
+// src/core/http/types.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxRetries: 2,
+  baseDelay: 500,
+  maxDelay: 4e3,
+  retryableStatusCodes: [408, 429, 500, 502, 503, 504]
+};
+var DEFAULT_HTTP_CONFIG = {
+  timeout: 1e4,
+  retry: DEFAULT_RETRY_CONFIG,
+  debug: false
+};
+
+// src/core/http/HttpClient.ts
+var HttpClient = class {
+  constructor(baseUrl, config) {
+    this.config = {
+      baseUrl,
+      timeout: config?.timeout ?? DEFAULT_HTTP_CONFIG.timeout,
+      retry: { ...DEFAULT_RETRY_CONFIG, ...config?.retry },
+      debug: config?.debug ?? false
+    };
+  }
+  async get(path, options) {
+    return this.request(path, { ...options, method: "GET" });
+  }
+  async post(path, body, options) {
+    return this.request(path, { ...options, method: "POST", body });
+  }
+  async request(path, options) {
+    const url = this.buildUrl(path);
+    const fetchOptions = this.buildFetchOptions(options);
+    const timeout = options.timeout ?? this.config.timeout;
+    if (options.skipRetry) {
+      return this.executeRequest(url, fetchOptions, timeout);
+    }
+    return this.executeWithRetry(url, fetchOptions, options);
+  }
+  async executeWithRetry(url, fetchOptions, options) {
+    const retryConfig = this.config.retry;
+    const timeout = options.timeout ?? this.config.timeout;
+    const state = { attempt: 0, lastError: null };
+    while (state.attempt <= retryConfig.maxRetries) {
+      try {
+        const response = await this.executeRequest(url, fetchOptions, timeout);
+        if (this.shouldRetry(response.status, retryConfig)) {
+          if (state.attempt < retryConfig.maxRetries) {
+            state.attempt++;
+            const delay = this.calculateDelay(state.attempt, retryConfig);
+            await this.sleep(delay);
+            continue;
+          }
+        }
+        return response;
+      } catch (error) {
+        state.lastError = error instanceof Error ? error : new ClientError(CLIENT_ERROR_CODES.UNKNOWN, String(error));
         if (this.isNetworkError(state.lastError) && state.attempt < retryConfig.maxRetries) {
           state.attempt++;
           const delay = this.calculateDelay(state.attempt, retryConfig);
@@ -1700,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;
@@ -1847,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;
@@ -1880,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
@@ -1948,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,
@@ -2034,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);
@@ -2096,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;
@@ -2241,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;
@@ -2256,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();
@@ -2297,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) {
@@ -2309,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;
   }
 };
@@ -2329,7 +2801,7 @@ var ApiCache = class {
 // src/core/ApiClient.ts
 var SDK_VERSION = "1.0.0";
 var DEFAULT_BASE_URL = "https://panel.lucasqueiroga.shop";
-var ApiClient = class {
+var _ApiClient = class _ApiClient {
   constructor(appKey, debug = false, environment = "Production", offlineQueueEnabled = true, timeout = 3e4) {
     this.cache = new ApiCache();
     this.appKey = appKey;
@@ -2340,11 +2812,12 @@ var ApiClient = class {
     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;
   }
@@ -2370,7 +2843,6 @@ var ApiClient = class {
   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 } });
   }
@@ -2384,29 +2856,28 @@ var ApiClient = class {
         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 };
@@ -2419,6 +2890,11 @@ var ApiClient = class {
     const key = `${flagKey}:${distinctId}`;
     const hit = this.cache.getVariant(key);
     if (hit !== void 0) return hit;
+    const persisted = await this.readFlagFromStorage(flagKey, distinctId);
+    if (persisted !== null) {
+      this.cache.setVariant(key, persisted);
+      return persisted;
+    }
     try {
       const res = await this.get(`/api/v1/flags/${flagKey}?distinctId=${encodeURIComponent(distinctId)}`);
       if (res.status === 404) {
@@ -2433,6 +2909,7 @@ var ApiClient = class {
         return { variant: null };
       }
       this.cache.setVariant(key, res.data);
+      await this.writeFlagToStorage(flagKey, distinctId, res.data);
       return res.data;
     } catch (error) {
       this.log("Failed to get variant:", flagKey, error);
@@ -2478,7 +2955,7 @@ var ApiClient = class {
       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);
@@ -2491,6 +2968,32 @@ var ApiClient = class {
       return null;
     }
   }
+  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,
@@ -2514,6 +3017,35 @@ var ApiClient = class {
     this.log("Subscription status:", result.hasActiveSubscription);
     return result;
   }
+  async evaluateFlags(keys, distinctId) {
+    const query = keys.map(encodeURIComponent).join(",");
+    const path = `/api/v1/flags/evaluate?keys=${query}`;
+    try {
+      const res = await this.httpClient.get(path, {
+        headers: { "X-App-Key": this.appKey, "x-distinct-id": distinctId }
+      });
+      if (!res.ok) {
+        this.log("Non-OK response for evaluateFlags:", res.status);
+        return {};
+      }
+      const raw = res.data;
+      if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return {};
+      const record = raw;
+      const result = {};
+      for (const key of Object.keys(record)) {
+        const value = record[key];
+        const variant = typeof value === "boolean" ? String(value) : typeof value === "string" ? value : null;
+        result[key] = variant;
+        const flagVariant = { variant };
+        this.cache.setVariant(`${key}:${distinctId}`, flagVariant);
+        await this.writeFlagToStorage(key, distinctId, flagVariant);
+      }
+      return result;
+    } catch (error) {
+      this.log("Failed to evaluateFlags:", error);
+      return {};
+    }
+  }
   async getConditionalFlag(flagKey, context) {
     try {
       const url = buildConditionalFlagUrl(this.baseUrl, flagKey, context);
@@ -2530,11 +3062,37 @@ var ApiClient = class {
       return { value: false, flagKey };
     }
   }
-  // ─── Private helpers ─────────────────────────────────────────────────────────
-  /**
-   * POST with offline queue fallback. Enqueues when offline or on network failure.
-   * Throws only when offlineQueueEnabled is false and the request fails.
-   */
+  async getVariantFromCache(flagKey, distinctId) {
+    const key = `${flagKey}:${distinctId}`;
+    const hit = this.cache.getVariant(key);
+    if (hit !== void 0) return hit;
+    const persisted = await this.readFlagFromStorage(flagKey, distinctId);
+    if (persisted !== null) {
+      this.cache.setVariant(key, persisted);
+      return persisted;
+    }
+    return null;
+  }
+  async readFlagFromStorage(flagKey, distinctId) {
+    try {
+      const raw = await secureStorage.get(`flag:${flagKey}:${distinctId}`);
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if (typeof parsed !== "object" || parsed === null || !("variant" in parsed) || !("cachedAt" in parsed) || typeof parsed.cachedAt !== "number") return null;
+      const { variant, payload, cachedAt } = parsed;
+      if (Date.now() - cachedAt > _ApiClient.FLAG_MAX_AGE_MS) return null;
+      return { variant, payload };
+    } catch {
+      return null;
+    }
+  }
+  async writeFlagToStorage(flagKey, distinctId, flag) {
+    try {
+      const value = JSON.stringify({ variant: flag.variant, payload: flag.payload, cachedAt: Date.now() });
+      await secureStorage.set(`flag:${flagKey}:${distinctId}`, value);
+    } catch {
+    }
+  }
   async postWithQueue(url, payload, label) {
     if (this.offlineQueueEnabled && !networkMonitor.isOnline()) {
       await offlineQueue.enqueue("POST", url, payload, { "X-App-Key": this.appKey });
@@ -2553,10 +3111,11 @@ var ApiClient = class {
       throw error;
     }
   }
-  log(...args) {
-    if (this.debug) console.warn("[Paywallo API]", ...args);
+  log(..._args) {
   }
 };
+_ApiClient.FLAG_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var ApiClient = _ApiClient;
 
 // src/domains/campaign/CampaignError.ts
 var CampaignError = class extends PaywalloError {
@@ -2575,39 +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 presentCampaign(apiClient, placement, paywallPresenter, campaignPresenter, context) {
-    const campaign = await this.getCampaign(apiClient, placement, 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) {
+    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) {
+      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 r = await this.presentCampaign(apiClient, placement, paywallPresenter, campaignPresenter, context);
+    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) {
@@ -2621,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() {
@@ -2637,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 };
@@ -2656,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;
@@ -2715,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;
@@ -2784,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();
@@ -3025,10 +3604,7 @@ var SessionManager = class {
       );
     }
   }
-  log(...args) {
-    if (this.debug) {
-      console.warn("[Paywallo Session]", ...args);
-    }
+  log(..._args) {
   }
 };
 var sessionManager = new SessionManager();
@@ -3083,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(),
@@ -3095,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 },
@@ -3116,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 {
     }
   }
 };
@@ -3137,6 +3704,8 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     this.config = null;
     this.apiClient = null;
     this.initPromise = null;
+    this.readyPromise = null;
+    this.resolveReady = null;
     this.paywallPresenter = null;
     this.campaignPresenter = null;
     this.subscriptionGetter = null;
@@ -3146,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) {
-    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) {
-      console.warn("[Paywallo INIT]", "Already initialized \u2014 skipping");
       return;
     }
     if (this.initPromise) {
-      console.warn("[Paywallo INIT]", "Init already in progress \u2014 awaiting...");
       await this.initPromise;
-      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");
-    console.warn("[Paywallo INIT]", "Starting fresh init...");
     this.pendingConfig = config;
     this.initAttempts = 0;
     this.initPromise = this.initWithRetry(config);
     try {
       await this.initPromise;
-      console.warn("[Paywallo INIT]", "init() SUCCESS");
     } catch (error) {
-      console.warn("[Paywallo INIT]", "init() FAILED:", error instanceof Error ? error.message : String(error));
       this.initPromise = null;
       this.config = null;
       this.apiClient = null;
@@ -3177,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 {
@@ -3191,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));
       }
     }
@@ -3202,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");
       });
     });
@@ -3235,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;
-    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)
       )
     ]);
-    console.warn("[Paywallo INIT]", "Step 1 DONE");
-    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);
-    console.warn("[Paywallo INIT]", "Step 2 DONE");
-    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();
-    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;
-    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();
@@ -3276,7 +3895,6 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     const apiClient = this.getApiClientOrThrow();
     const distinctId = identityManager.getDistinctId();
     if (!distinctId) {
-      console.warn("[Paywallo TRACK]", "SKIPPED \u2014 no distinctId", eventName);
       return;
     }
     if (!isValidEventName(eventName)) {
@@ -3284,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") {
-      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") {
-      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 {
-      console.warn("[Paywallo TRACK]", eventName, "distinctId:", distinctId.substring(0, 8) + "...");
-    }
     await apiClient.trackEvent(eventName, distinctId, {
       ...identityManager.getProperties(),
       ...options?.properties,
@@ -3313,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) {
@@ -3337,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") {
@@ -3352,22 +3949,32 @@ var _PaywalloClientClass = class _PaywalloClientClass {
       ...sessionId && { sessionId }
     });
   }
+  async getVariantCached(flagKey, defaultValue) {
+    this.ensureInitialized();
+    const apiClient = this.getApiClientOrThrow();
+    const distinctId = identityManager.getDistinctId();
+    const result = await apiClient.getVariantFromCache(flagKey, distinctId);
+    if (result) return result;
+    void apiClient.getVariant(flagKey, distinctId).catch(() => {
+    });
+    return { variant: defaultValue ?? null, payload: void 0 };
+  }
   async getVariant(flagKey) {
     try {
       const distinctId = identityManager.getDistinctId();
       if (!distinctId) {
-        console.warn("[Paywallo AB]", "getVariant SKIPPED \u2014 no distinctId", flagKey);
         return { variant: null };
       }
-      const result = await this.getApiClientOrThrow().getVariant(flagKey, distinctId);
-      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 };
     }
   }
+  async evaluateFlags(keys) {
+    this.ensureInitialized();
+    return this.getApiClientOrThrow().evaluateFlags(keys, identityManager.getDistinctId());
+  }
   async getConditionalFlag(flagKey, context) {
     try {
       const distinctId = identityManager.getDistinctId();
@@ -3375,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;
     }
@@ -3393,18 +3999,22 @@ var _PaywalloClientClass = class _PaywalloClientClass {
   }
   async presentCampaign(placement, context) {
     this.ensureInitialized();
-    return campaignGateService.presentCampaign(this.getApiClientOrThrow(), placement, this.paywallPresenter, this.campaignPresenter, context);
+    return campaignGateService.presentCampaign(this.getApiClientOrThrow(), placement, () => this.hasActiveSubscription(), this.paywallPresenter, this.campaignPresenter, context);
   }
   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;
-      return (await this.apiClient.getSubscriptionStatus(distinctId)).hasActiveSubscription;
-    } catch {
-      if (this.config?.debug) console.warn("[Paywallo]", "hasActiveSubscription failed \u2014 returning false");
-      if (this.apiClient) void this.apiClient.reportError("SUBSCRIPTION_CHECK_FAILED", "hasActiveSubscription failed");
+      if (!distinctId || !this.apiClient) {
+        return false;
+      }
+      const status = await this.apiClient.getSubscriptionStatus(distinctId);
+      return status.hasActiveSubscription;
+    } catch (error) {
+      if (this.apiClient) void this.apiClient.reportError("SUBSCRIPTION_CHECK_FAILED", error instanceof Error ? error.message : "hasActiveSubscription failed");
       return false;
     }
   }
@@ -3418,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;
     }
   }
@@ -3429,19 +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.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;
@@ -3450,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;
@@ -3539,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();
   }
@@ -3558,57 +4187,15 @@ var _PaywalloClientClass = class _PaywalloClientClass {
   ensureInitialized() {
     if (!this.config || !this.apiClient) throw new ClientError(CLIENT_ERROR_CODES.NOT_INITIALIZED, "SDK not initialized. Call Paywallo.init() first");
   }
-};
-_PaywalloClientClass.MAX_INIT_RETRIES = 3;
-_PaywalloClientClass.RETRY_DELAYS = [2e3, 5e3, 1e4];
-var PaywalloClientClass = _PaywalloClientClass;
-var PaywalloClient = new PaywalloClientClass();
-
-// src/context/PaywalloContext.ts
-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;
-  }
-}
+};
+_PaywalloClientClass.MAX_INIT_RETRIES = 3;
+_PaywalloClientClass.RETRY_DELAYS = [2e3, 5e3, 1e4];
+var PaywalloClientClass = _PaywalloClientClass;
+var PaywalloClient = new PaywalloClientClass();
+
+// src/context/PaywalloContext.ts
+import { createContext as createContext2 } from "react";
+var PaywalloContext = createContext2(null);
 
 // src/hooks/usePaywallo.ts
 import { useContext as useContext2 } from "react";
@@ -3621,7 +4208,7 @@ function usePaywallo() {
 }
 
 // src/hooks/useProducts.ts
-import { useCallback as useCallback5, useEffect as useEffect5, useState as useState5 } from "react";
+import { useCallback as useCallback6, useEffect as useEffect5, useState as useState6 } from "react";
 
 // src/utils/productMappers.ts
 function mapToIAPProduct(product) {
@@ -3635,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) {
@@ -3650,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
@@ -3658,11 +4247,11 @@ function mapToFormattedProduct(product) {
 
 // src/hooks/useProducts.ts
 function useProducts(initialProductIds) {
-  const [products, setProducts] = useState5([]);
-  const [formattedProducts, setFormattedProducts] = useState5([]);
-  const [isLoading, setIsLoading] = useState5(false);
-  const [error, setError] = useState5(null);
-  const loadProducts = useCallback5(async (productIds) => {
+  const [products, setProducts] = useState6([]);
+  const [formattedProducts, setFormattedProducts] = useState6([]);
+  const [isLoading, setIsLoading] = useState6(false);
+  const [error, setError] = useState6(null);
+  const loadProducts = useCallback6(async (productIds) => {
     setIsLoading(true);
     setError(null);
     try {
@@ -3681,19 +4270,19 @@ function useProducts(initialProductIds) {
       void loadProducts(initialProductIds);
     }
   }, []);
-  const getProduct = useCallback5(
+  const getProduct = useCallback6(
     (productId) => {
       return products.find((p) => p.productId === productId);
     },
     [products]
   );
-  const getFormattedProduct = useCallback5(
+  const getFormattedProduct = useCallback6(
     (productId) => {
       return formattedProducts.find((p) => p.productId === productId);
     },
     [formattedProducts]
   );
-  const getPriceInfo = useCallback5(
+  const getPriceInfo = useCallback6(
     (productId) => {
       const p = formattedProducts.find((fp) => fp.productId === productId);
       if (!p) return void 0;
@@ -3722,39 +4311,49 @@ function useProducts(initialProductIds) {
 }
 
 // src/hooks/usePurchase.ts
-import { useCallback as useCallback6, useState as useState6 } from "react";
+import { useCallback as useCallback7, useState as useState7 } from "react";
 function usePurchase() {
-  const [state, setState] = useState6("idle");
-  const [error, setError] = useState6(null);
-  const purchase = useCallback6(async (productId) => {
+  const [state, setState] = useState7("idle");
+  const [error, setError] = useState7(null);
+  const purchase = useCallback7(async (productId) => {
     setState("purchasing");
     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 = useCallback6(async () => {
+  const restore = useCallback7(async () => {
     setState("restoring");
     setError(null);
     try {
@@ -3780,231 +4379,19 @@ 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 useCallback7, useEffect as useEffect6, useState as useState7 } from "react";
-
-// src/domains/subscription/SubscriptionManager.ts
-import { Platform as Platform8 } from "react-native";
-
-// src/domains/subscription/SubscriptionCache.ts
-var CACHE_KEY = "subscription_cache";
-var DEFAULT_TTL = 5 * 60 * 1e3;
-var SubscriptionCache = class {
-  constructor(ttl = DEFAULT_TTL) {
-    this.memoryCache = null;
-    this.ttl = ttl;
-    this.storage = new SecureStorage();
-  }
-  async get() {
-    if (this.memoryCache && !this.isExpired(this.memoryCache)) {
-      return this.memoryCache;
-    }
-    try {
-      const stored = await this.storage.get(CACHE_KEY);
-      if (!stored) {
-        return null;
-      }
-      const cached = JSON.parse(stored);
-      if (cached.data.subscription?.expiresAt) {
-        cached.data.subscription.expiresAt = new Date(cached.data.subscription.expiresAt);
-      }
-      if (cached.data.subscription?.originalPurchaseDate) {
-        cached.data.subscription.originalPurchaseDate = new Date(
-          cached.data.subscription.originalPurchaseDate
-        );
-      }
-      if (cached.data.subscription?.latestPurchaseDate) {
-        cached.data.subscription.latestPurchaseDate = new Date(
-          cached.data.subscription.latestPurchaseDate
-        );
-      }
-      if (cached.data.subscription?.cancellationDate) {
-        cached.data.subscription.cancellationDate = new Date(
-          cached.data.subscription.cancellationDate
-        );
-      }
-      if (cached.data.subscription?.gracePeriodExpiresAt) {
-        cached.data.subscription.gracePeriodExpiresAt = new Date(
-          cached.data.subscription.gracePeriodExpiresAt
-        );
-      }
-      cached.isStale = this.isExpired(cached);
-      if (!cached.isStale) {
-        this.memoryCache = cached;
-      }
-      return cached;
-    } catch {
-      return null;
-    }
-  }
-  async set(data) {
-    const cached = {
-      data,
-      cachedAt: Date.now(),
-      isStale: false
-    };
-    this.memoryCache = cached;
-    try {
-      await this.storage.set(CACHE_KEY, JSON.stringify(cached));
-    } catch {
-    }
-  }
-  async invalidate() {
-    this.memoryCache = null;
-    try {
-      await this.storage.remove(CACHE_KEY);
-    } catch {
-    }
-  }
-  isExpired(cached) {
-    return Date.now() - cached.cachedAt > this.ttl;
-  }
-  setTTL(ttl) {
-    this.ttl = ttl;
-  }
-};
-
-// src/domains/subscription/SubscriptionManager.ts
-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
+import { useCallback as useCallback8, useEffect as useEffect6, useState as useState8 } from "react";
 function useSubscription() {
-  const [status, setStatus] = useState7(null);
-  const [isLoading, setIsLoading] = useState7(true);
-  const [error, setError] = useState7(null);
-  const refresh = useCallback7(async () => {
+  const [status, setStatus] = useState8(null);
+  const [isLoading, setIsLoading] = useState8(true);
+  const [error, setError] = useState8(null);
+  const refresh = useCallback8(async () => {
     setIsLoading(true);
     setError(null);
     try {
@@ -4017,7 +4404,7 @@ function useSubscription() {
       setIsLoading(false);
     }
   }, []);
-  const restore = useCallback7(async () => {
+  const restore = useCallback8(async () => {
     setIsLoading(true);
     setError(null);
     try {
@@ -4054,11 +4441,11 @@ function useSubscription() {
 }
 
 // src/PaywalloProvider.tsx
-import { useCallback as useCallback12, useEffect as useEffect7, useMemo as useMemo2, useRef as useRef8, useState as useState11 } 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
-import { useCallback as useCallback8, useRef as useRef6, useState as useState8 } from "react";
+import { useCallback as useCallback9, useRef as useRef6, useState as useState9 } from "react";
 
 // src/utils/serverProduct.ts
 var PERIOD_MAP = {
@@ -4116,26 +4503,25 @@ 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;
 }
 
 // src/hooks/useCampaignPreload.ts
 function useCampaignPreload() {
-  const [preloadedWebView, setPreloadedWebView] = useState8(null);
+  const [preloadedWebView, setPreloadedWebView] = useState9(null);
   const preloadedCampaignsRef = useRef6(/* @__PURE__ */ new Map());
-  const isPreloadValid = useCallback8(
+  const isPreloadValid = useCallback9(
     (placement) => isCacheEntryValid(preloadedCampaignsRef.current.get(placement)),
     []
   );
-  const consumePreloadedCampaign = useCallback8(
-    (placement) => consumeCacheEntry(preloadedCampaignsRef.current, placement),
+  const consumePreloadedCampaign = useCallback9(
+    (placement) => getCacheEntry(preloadedCampaignsRef.current, placement),
     []
   );
-  const preloadCampaign = useCallback8(
+  const preloadCampaign = useCallback9(
     async (placement, context) => {
       try {
         const campaign = await PaywalloClient.getCampaign(placement, context);
@@ -4180,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 {
@@ -4201,11 +4588,11 @@ function useCampaignPreload() {
 }
 
 // src/hooks/useProductLoader.ts
-import { useCallback as useCallback9, useState as useState9 } from "react";
+import { useCallback as useCallback10, useState as useState10 } from "react";
 function useProductLoader() {
-  const [products, setProducts] = useState9(/* @__PURE__ */ new Map());
-  const [isLoadingProducts, setIsLoadingProducts] = useState9(false);
-  const refreshProducts = useCallback9(async (productIds) => {
+  const [products, setProducts] = useState10(/* @__PURE__ */ new Map());
+  const [isLoadingProducts, setIsLoadingProducts] = useState10(false);
+  const refreshProducts = useCallback10(async (productIds) => {
     setIsLoadingProducts(true);
     try {
       const iapService = getIAPService();
@@ -4214,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);
     }
@@ -4223,10 +4609,10 @@ function useProductLoader() {
 }
 
 // src/hooks/usePurchaseOrchestrator.ts
-import { useCallback as useCallback10 } from "react";
-function usePurchaseOrchestrator(preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef) {
+import { useCallback as useCallback11 } from "react";
+function usePurchaseOrchestrator(preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef, invalidateSubscriptionCache) {
   const { trackDismissed, trackProductSelected, trackPurchased } = usePaywallTracking();
-  const handlePreloadedPurchase = useCallback10(
+  const handlePreloadedPurchase = useCallback11(
     async (productId) => {
       try {
         if (preloadedWebView) {
@@ -4249,19 +4635,19 @@ 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 = useCallback10(async () => {
+  const handlePreloadedRestore = useCallback11(async () => {
     try {
       const transactions = await getIAPService().restore();
       if (transactions.length === 0) return;
@@ -4269,30 +4655,72 @@ 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 };
 }
 
 // src/hooks/useSubscriptionSync.ts
-import { useCallback as useCallback11, useRef as useRef7, useState as useState10 } from "react";
+import { useCallback as useCallback12, useRef as useRef7, useState as useState11 } from "react";
 var CACHE_TTL_MS2 = 5 * 60 * 1e3;
-var ACTIVE_STATUSES = ["active", "in_grace_period"];
+var ACTIVE_STATUSES = ["active", "grace_period"];
+function toDomainSubscriptionInfo(sub) {
+  return {
+    id: "",
+    productId: sub.productId,
+    status: sub.status,
+    expiresAt: sub.expiresAt ?? /* @__PURE__ */ new Date(0),
+    originalPurchaseDate: /* @__PURE__ */ new Date(0),
+    latestPurchaseDate: /* @__PURE__ */ new Date(0),
+    willRenew: sub.autoRenewEnabled,
+    isTrial: false,
+    isIntroductoryPeriod: false,
+    platform: sub.platform
+  };
+}
+function toDomainResponse(status) {
+  return {
+    hasActiveSubscription: status.hasActiveSubscription,
+    subscription: status.subscription ? toDomainSubscriptionInfo(status.subscription) : null,
+    entitlements: []
+  };
+}
+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(distinctId);
+    if (!cached) return false;
+    const sub = cached.data.subscription;
+    return isSubscriptionStillActive(sub ? { status: sub.status, expiresAt: sub.expiresAt ?? null } : null);
+  } catch {
+    return false;
+  }
+}
+function isActiveCacheEntry(entry) {
+  return isSubscriptionStillActive(entry.data);
+}
 function useSubscriptionSync() {
-  const [subscription, setSubscription] = useState10(null);
+  const [subscription, setSubscription] = useState11(null);
   const cacheRef = useRef7(null);
-  const invalidateCache = useCallback11(() => {
+  const invalidateCache = useCallback12(() => {
     cacheRef.current = null;
+    const distinctId = PaywalloClient.getDistinctId();
+    if (distinctId) void subscriptionCache.invalidate(distinctId);
   }, []);
-  const fetchAndCache = useCallback11(async () => {
+  const fetchAndCache = useCallback12(async () => {
     const apiClient = PaywalloClient.getApiClient();
     const distinctId = PaywalloClient.getDistinctId();
     if (!apiClient || !distinctId) return null;
@@ -4303,18 +4731,37 @@ function useSubscriptionSync() {
     } : null;
     cacheRef.current = { data: sub, expiresAt: Date.now() + CACHE_TTL_MS2 };
     setSubscription(sub);
+    void subscriptionCache.set(distinctId, toDomainResponse(status));
     return sub;
   }, []);
-  const hasActiveSubscription = useCallback11(async () => {
+  const hasActiveSubscription = useCallback12(async () => {
     const apiClient = PaywalloClient.getApiClient();
     const distinctId = PaywalloClient.getDistinctId();
     if (!apiClient || !distinctId) return false;
     const cached = cacheRef.current;
     if (cached && cached.expiresAt > Date.now()) {
-      if (!cached.data) return false;
-      if (!ACTIVE_STATUSES.includes(cached.data.status)) return false;
-      if (cached.data.expiresAt && cached.data.expiresAt < /* @__PURE__ */ new Date()) return false;
-      return true;
+      return isActiveCacheEntry(cached);
+    }
+    try {
+      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 true;
+        }
+      }
+    } catch {
     }
     try {
       const status = await apiClient.getSubscriptionStatus(distinctId);
@@ -4324,12 +4771,13 @@ function useSubscriptionSync() {
       } : null;
       cacheRef.current = { data: sub, expiresAt: Date.now() + CACHE_TTL_MS2 };
       setSubscription(sub);
+      void subscriptionCache.set(distinctId, toDomainResponse(status));
       return status.hasActiveSubscription;
     } catch {
-      return false;
+      return await resolveOfflineFromCache(distinctId);
     }
   }, []);
-  const getSubscription = useCallback11(async () => {
+  const getSubscription = useCallback12(async () => {
     const apiClient = PaywalloClient.getApiClient();
     const distinctId = PaywalloClient.getDistinctId();
     if (!apiClient || !distinctId) return null;
@@ -4338,7 +4786,22 @@ function useSubscriptionSync() {
     try {
       return await fetchAndCache();
     } catch {
-      return null;
+      try {
+        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;
+        return {
+          productId: s.productId,
+          status: normalisedStatus,
+          expiresAt: s.expiresAt ?? null,
+          platform: s.platform,
+          autoRenewEnabled: s.willRenew,
+          inGracePeriod: normalisedStatus === "in_grace_period"
+        };
+      } catch {
+        return null;
+      }
     }
   }, [fetchAndCache]);
   return { subscription, hasActiveSubscription, getSubscription, invalidateCache };
@@ -4347,24 +4810,49 @@ function useSubscriptionSync() {
 // src/PaywalloProvider.tsx
 import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 function PaywalloProvider({ children, config }) {
-  const [isInitialized, setIsInitialized] = useState11(false);
-  const [initError, setInitError] = useState11(null);
-  const [distinctId, setDistinctId] = useState11(null);
-  const [activePaywall, setActivePaywall] = useState11(null);
+  const [isInitialized, setIsInitialized] = useState12(false);
+  const [initError, setInitError] = useState12(null);
+  const [distinctId, setDistinctId] = useState12(null);
+  const [activePaywall, setActivePaywall] = useState12(null);
   const { products, isLoadingProducts, refreshProducts } = useProductLoader();
   const { subscription, hasActiveSubscription, getSubscription, invalidateCache } = useSubscriptionSync();
   const { preloadedWebView, setPreloadedWebView, preloadCampaign, consumePreloadedCampaign, isPreloadValid } = useCampaignPreload();
-  const clearPreloadedWebView = useCallback12(() => setPreloadedWebView(null), [setPreloadedWebView]);
-  const { showingPreloadedWebView, presentPreloadedWebView, resolvePreloadedPaywall, handlePreloadedWebViewReady, handlePreloadedClose, setShowingPreloadedWebView, presentedAtRef } = usePaywallPresenter(preloadedWebView, clearPreloadedWebView, setPreloadedWebView);
+  const clearPreloadedWebView = useCallback13(() => setPreloadedWebView(null), [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] = useState11(false);
-  const handlePreloadedPurchase = useCallback12(async (productId) => {
+  const [isPreloadPurchasing, setIsPreloadPurchasing] = useState12(false);
+  const handlePreloadedPurchase = useCallback13(async (productId) => {
     setIsPreloadPurchasing(true);
     try {
       await rawPreloadedPurchase(productId);
@@ -4374,28 +4862,34 @@ 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]);
-  const getPaywallConfig = useCallback12(async (p) => {
+  }, [config, preloadCampaign]);
+  const getPaywallConfig = useCallback13(async (p) => {
     const api = PaywalloClient.getApiClient();
     return api ? api.getPaywall(p) : null;
   }, []);
-  const presentPaywall = useCallback12((placement) => {
+  const presentPaywall = useCallback13((placement) => {
     return new Promise((resolve) => setActivePaywall({ placement, resolver: resolve }));
   }, []);
-  const trackCampaignImpression = useCallback12((placement, variantKey, campaignId) => {
+  const trackCampaignImpression = useCallback13((placement, variantKey, campaignId) => {
     const api = PaywalloClient.getApiClient();
     if (!api) return;
     const sessionId = PaywalloClient.getSessionId();
     void api.trackEvent("$campaign_impression", PaywalloClient.getDistinctId(), { placement, variantKey, campaignId, ...sessionId && { sessionId } }).catch(() => {
     });
   }, []);
-  const presentCampaign = useCallback12(
+  const presentCampaign = useCallback13(
     async (placement, context) => {
       try {
         if (preloadedWebView?.placement === placement && preloadedWebView.loaded && isPreloadValid(placement)) {
@@ -4464,7 +4958,7 @@ function PaywalloProvider({ children, config }) {
     },
     [preloadedWebView, isPreloadValid, consumePreloadedCampaign, presentPreloadedWebView, trackCampaignImpression]
   );
-  const restorePurchases = useCallback12(async () => {
+  const restorePurchases = useCallback13(async () => {
     invalidateCache();
     try {
       const txs = await getIAPService().restore();
@@ -4473,34 +4967,60 @@ function PaywalloProvider({ children, config }) {
       return { success: false, restoredProducts: [], error: error instanceof Error ? error : new PurchaseError(PURCHASE_ERROR_CODES.RESTORE_FAILED, String(error)) };
     }
   }, [invalidateCache]);
-  const handlePaywallResult = useCallback12((result) => {
+  const handlePaywallResult = useCallback13((result) => {
     if (activePaywall) {
       activePaywall.resolver(result);
       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]);
-  const noOp = useCallback12(() => {
+  }, [isInitialized, bridgePaywallPresenter, getSubscription, hasActiveSubscription, restorePurchases]);
+  const isReady = isInitialized && !isLoadingProducts;
+  const noOp = useCallback13(() => {
   }, []);
   const contextValue = useMemo2(() => ({
     config: PaywalloClient.getConfig(),
     isInitialized,
+    isReady,
     initError,
     distinctId,
     subscription,
@@ -4516,6 +5036,7 @@ function PaywalloProvider({ children, config }) {
     refreshProducts
   }), [
     isInitialized,
+    isReady,
     initError,
     distinctId,
     subscription,
@@ -4530,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,
@@ -4556,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,
@@ -4578,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