@virex-tech/paywallo-sdk 1.1.1 → 1.1.3

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";
@@ -860,11 +869,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());
@@ -951,6 +955,13 @@ function getWebViewEmitter() {
   }
   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,
@@ -961,11 +972,14 @@ function PaywallWebView({
   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 NativeWebView = useMemo(() => getNativeWebView(), []);
   const webUrl = useMemo(() => PaywalloClient.getWebUrl() ?? "http://localhost:3000", []);
   const buildAndSetInjectionScript = useCallback3(() => {
@@ -1025,17 +1039,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);
@@ -1055,6 +1103,7 @@ function PaywallWebView({
       injectedJavaScript: scriptToInject,
       onMessage: handleMessage,
       onLoadEnd: handleLoadEnd,
+      onError: handleNativeError,
       style: styles.webview
     }
   ) });
@@ -1065,7 +1114,7 @@ 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 PaywallModal({
   placement,
@@ -1085,6 +1134,25 @@ function PaywallModal({
     campaignId
   );
   const { isPurchasing, slideAnim, handleClose, handlePurchase, handleRestore } = usePaywallActions(placement, paywallConfig, onResult, variantKey, campaignId);
+  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);
+  }, []);
   const openAnim = useRef4(new Animated2.Value(SCREEN_HEIGHT2)).current;
   useEffect3(() => {
     if (visible) {
@@ -1109,7 +1177,12 @@ 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(View2, { style: styles2.fallbackContainer, children: /* @__PURE__ */ jsxs(View2, { style: styles2.fallbackCard, children: [
+          /* @__PURE__ */ jsx2(Text, { style: styles2.fallbackTitle, children: "Algo deu errado" }),
+          /* @__PURE__ */ jsx2(Text, { style: styles2.fallbackDescription, children: webViewError.description }),
+          /* @__PURE__ */ jsx2(Pressable, { style: styles2.retryButton, onPress: handleRetry, children: /* @__PURE__ */ jsx2(Text, { style: styles2.retryButtonText, children: "Tentar novamente" }) }),
+          /* @__PURE__ */ jsx2(Pressable, { style: styles2.closeButton, onPress: handleClose, children: /* @__PURE__ */ jsx2(Text, { style: styles2.closeButtonText, children: "Fechar" }) })
+        ] }) }) : /* @__PURE__ */ jsx2(
           PaywallWebView,
           {
             paywallId: paywallConfig.id,
@@ -1120,39 +1193,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
@@ -1188,9 +1289,9 @@ function usePaywallContext() {
 }
 
 // src/domains/paywall/usePaywallPresenter.ts
-import { useCallback as useCallback4, useEffect as useEffect4, useRef as useRef5, useState as useState4 } from "react";
+import { useCallback as useCallback5, useEffect as useEffect4, useRef as useRef5, useState as useState5 } from "react";
 function usePaywallPresenter(preloadedWebView, clearPreloadedWebView, setPreloadedWebView) {
-  const [showingPreloadedWebView, setShowingPreloadedWebView] = useState4(false);
+  const [showingPreloadedWebView, setShowingPreloadedWebView] = useState5(false);
   const resolverRef = useRef5(null);
   const presentedAtRef = useRef5(Date.now());
   useEffect4(() => {
@@ -1201,23 +1302,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();
@@ -1467,6 +1568,92 @@ var PaywalloAffiliate = {
   getWithdrawals: () => affiliateManager.getWithdrawals()
 };
 
+// src/domains/subscription/SubscriptionCache.ts
+var CACHE_KEY = "subscription_cache";
+var DEFAULT_TTL = 24 * 60 * 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 parsed = JSON.parse(stored);
+      if (typeof parsed !== "object" || parsed === null || !("data" in parsed) || typeof parsed.data !== "object" || parsed.data === null || !("cachedAt" in parsed) || typeof parsed.cachedAt !== "number") {
+        await this.storage.remove(CACHE_KEY);
+        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 = 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 (error) {
+      if (__DEV__) console.warn("[SubscriptionCache] set() failed:", error instanceof Error ? error.message : String(error));
+    }
+  }
+  async invalidate() {
+    this.memoryCache = null;
+    try {
+      await this.storage.remove(CACHE_KEY);
+    } catch (error) {
+      if (__DEV__) console.warn("[SubscriptionCache] invalidate() failed:", error instanceof Error ? error.message : String(error));
+    }
+  }
+  isExpired(cached) {
+    return Date.now() - cached.cachedAt > this.ttl;
+  }
+  setTTL(ttl) {
+    this.ttl = ttl;
+  }
+};
+var subscriptionCache = new SubscriptionCache();
+
 // src/core/ApiClient.ts
 import { Platform as Platform3 } from "react-native";
 
@@ -2329,7 +2516,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;
@@ -2419,6 +2606,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 +2625,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);
@@ -2514,6 +2707,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,7 +2752,43 @@ var ApiClient = class {
       return { value: false, flagKey };
     }
   }
-  // ─── Private helpers ─────────────────────────────────────────────────────────
+  // ─── Cache-only reads ────────────────────────────────────────────────────────
+  /**
+   * Reads a flag variant from cache layers only — no network call.
+   * Checks in-memory cache first, then SecureStorage.
+   * Returns null when both layers miss.
+   */
+  async getVariantFromCache(flagKey, distinctId) {
+    const key = `${flagKey}:${distinctId}`;
+    const hit = this.cache.getVariant(key);
+    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 {
+    }
+  }
   /**
    * POST with offline queue fallback. Enqueues when offline or on network failure.
    * Throws only when offlineQueueEnabled is false and the request fails.
@@ -2557,6 +2815,9 @@ var ApiClient = class {
     if (this.debug) console.warn("[Paywallo API]", ...args);
   }
 };
+// ─── Private helpers ─────────────────────────────────────────────────────────
+_ApiClient.FLAG_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+var ApiClient = _ApiClient;
 
 // src/domains/campaign/CampaignError.ts
 var CampaignError = class extends PaywalloError {
@@ -2584,18 +2845,21 @@ var CampaignGateService = class {
     if (!distinctId) return null;
     return apiClient.getCampaign(placement, distinctId, context);
   }
-  async presentCampaign(apiClient, placement, paywallPresenter, campaignPresenter, context) {
+  async presentCampaign(apiClient, placement, hasActive, paywallPresenter, campaignPresenter, context) {
     const campaign = await this.getCampaign(apiClient, placement, context);
     if (!campaign) {
       return { presented: false, purchased: false, cancelled: false, restored: false, error: new CampaignError(CAMPAIGN_ERROR_CODES.NOT_FOUND, "No campaign found") };
     }
+    if (!context?.forceShow && await hasActive()) {
+      return { presented: false, purchased: false, cancelled: false, restored: false, skippedReason: "subscriber" };
+    }
     if (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 };
   }
   async requireSubscriptionWithCampaign(apiClient, placement, hasActive, paywallPresenter, campaignPresenter, context) {
     if (await hasActive()) return true;
-    const r = await this.presentCampaign(apiClient, placement, paywallPresenter, campaignPresenter, context);
+    const r = await this.presentCampaign(apiClient, placement, hasActive, paywallPresenter, campaignPresenter, context);
     return r.purchased || r.restored;
   }
   async preloadCampaign(apiClient, placement, context) {
@@ -3132,6 +3396,20 @@ function isValidEventName(name) {
   if (name.startsWith("$")) return /^\$[a-z][a-z0-9]*(_[a-z0-9]+)*$/.test(name);
   return /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/.test(name);
 }
+var OFFLINE_ACTIVE_STATUSES = ["active", "grace_period"];
+async function resolveClientOfflineFromCache() {
+  try {
+    const cached = await subscriptionCache.get();
+    if (!cached) return false;
+    const sub = cached.data.subscription;
+    if (!sub) return false;
+    if (!OFFLINE_ACTIVE_STATUSES.includes(sub.status)) return false;
+    if (!sub.expiresAt) return true;
+    return sub.expiresAt > /* @__PURE__ */ new Date();
+  } catch {
+    return false;
+  }
+}
 var _PaywalloClientClass = class _PaywalloClientClass {
   constructor() {
     this.config = null;
@@ -3148,27 +3426,27 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     this.initAttempts = 0;
   }
   async init(config) {
-    console.warn("[Paywallo INIT]", "init() called \u2014 appKey:", config.appKey ? config.appKey.substring(0, 8) + "..." : "MISSING");
+    if (config.debug) console.warn("[Paywallo INIT]", "init() called \u2014 appKey:", config.appKey ? config.appKey.substring(0, 8) + "..." : "MISSING");
     if (this.config && this.apiClient) {
-      console.warn("[Paywallo INIT]", "Already initialized \u2014 skipping");
+      if (config.debug) console.warn("[Paywallo INIT]", "Already initialized \u2014 skipping");
       return;
     }
     if (this.initPromise) {
-      console.warn("[Paywallo INIT]", "Init already in progress \u2014 awaiting...");
+      if (config.debug) console.warn("[Paywallo INIT]", "Init already in progress \u2014 awaiting...");
       await this.initPromise;
-      console.warn("[Paywallo INIT]", "Awaited existing init \u2014 done");
+      if (config.debug) console.warn("[Paywallo INIT]", "Awaited existing init \u2014 done");
       return;
     }
     if (!config.appKey) throw new ClientError(CLIENT_ERROR_CODES.MISSING_APP_KEY, "appKey is required");
-    console.warn("[Paywallo INIT]", "Starting fresh init...");
+    if (config.debug) console.warn("[Paywallo INIT]", "Starting fresh init...");
     this.pendingConfig = config;
     this.initAttempts = 0;
     this.initPromise = this.initWithRetry(config);
     try {
       await this.initPromise;
-      console.warn("[Paywallo INIT]", "init() SUCCESS");
+      if (config.debug) console.warn("[Paywallo INIT]", "init() SUCCESS");
     } catch (error) {
-      console.warn("[Paywallo INIT]", "init() FAILED:", error instanceof Error ? error.message : String(error));
+      if (config.debug) console.warn("[Paywallo INIT]", "init() FAILED:", error instanceof Error ? error.message : String(error));
       this.initPromise = null;
       this.config = null;
       this.apiClient = null;
@@ -3238,26 +3516,26 @@ var _PaywalloClientClass = class _PaywalloClientClass {
   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...");
+    if (config.debug) console.warn("[Paywallo INIT]", "Step 1: networkMonitor + offlineQueue...");
     await Promise.all([
       networkMonitor.initialize({ debug: config.debug }),
       offlineQueue.initialize({ debug: config.debug }).then(
         () => offlineQueue.clearItemsWithInvalidAppKey(config.appKey)
       )
     ]);
-    console.warn("[Paywallo INIT]", "Step 1 DONE");
-    console.warn("[Paywallo INIT]", "Step 2: ApiClient + queueProcessor + affiliate...");
+    if (config.debug) console.warn("[Paywallo INIT]", "Step 1 DONE");
+    if (config.debug) console.warn("[Paywallo INIT]", "Step 2: ApiClient + queueProcessor + affiliate...");
     this.apiClient = new ApiClient(config.appKey, config.debug, environment, offlineQueueEnabled, config.timeout);
     queueProcessor.initialize(this.apiClient.getHttpClient(), { debug: config.debug });
     affiliateManager.initialize(this.apiClient, config.debug);
-    console.warn("[Paywallo INIT]", "Step 2 DONE");
-    console.warn("[Paywallo INIT]", "Step 3: identityManager + sessionManager...");
+    if (config.debug) console.warn("[Paywallo INIT]", "Step 2 DONE");
+    if (config.debug) console.warn("[Paywallo INIT]", "Step 3: identityManager + sessionManager...");
     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.debug) console.warn("[Paywallo INIT]", "Step 3 DONE \u2014 distinctId:", distinctId ? distinctId.substring(0, 8) + "..." : "EMPTY");
     if (config.autoStartSession !== false) {
       sessionManager.startSession().catch(() => {
         if (config.debug) console.warn("[Paywallo]", "Session start failed during init \u2014 continuing");
@@ -3266,7 +3544,7 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     new InstallTracker(config.debug).trackIfNeeded(this.apiClient, config.requestATT === true).catch(() => {
     });
     this.config = config;
-    console.warn("[Paywallo INIT]", "COMPLETE \u2014 SDK ready, environment:", environment);
+    if (config.debug) console.warn("[Paywallo INIT]", "COMPLETE \u2014 SDK ready, environment:", environment);
   }
   async identify(options) {
     this.ensureInitialized();
@@ -3276,7 +3554,7 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     const apiClient = this.getApiClientOrThrow();
     const distinctId = identityManager.getDistinctId();
     if (!distinctId) {
-      console.warn("[Paywallo TRACK]", "SKIPPED \u2014 no distinctId", eventName);
+      if (this.config?.debug) console.warn("[Paywallo TRACK]", "SKIPPED \u2014 no distinctId", eventName);
       return;
     }
     if (!isValidEventName(eventName)) {
@@ -3285,7 +3563,7 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     }
     const sessionId = sessionManager.getSessionId();
     if (eventName === "$purchase_completed") {
-      console.warn("[Paywallo PURCHASE]", "tracking purchase:", JSON.stringify({
+      if (this.config?.debug) console.warn("[Paywallo PURCHASE]", "tracking purchase:", JSON.stringify({
         distinctId: distinctId.substring(0, 8) + "...",
         productId: options?.properties?.productId,
         priceUsd: options?.properties?.priceUsd,
@@ -3294,14 +3572,14 @@ var _PaywalloClientClass = class _PaywalloClientClass {
         placement: options?.properties?.placement
       }));
     } else if (eventName === "$paywall_viewed" || eventName === "$paywall_closed") {
-      console.warn("[Paywallo PAYWALL]", eventName, JSON.stringify({
+      if (this.config?.debug) console.warn("[Paywallo PAYWALL]", eventName, JSON.stringify({
         distinctId: distinctId.substring(0, 8) + "...",
         placement: options?.properties?.placement,
         variantKey: options?.properties?.variantKey,
         timeOnPaywall: options?.properties?.timeOnPaywall
       }));
     } else {
-      console.warn("[Paywallo TRACK]", eventName, "distinctId:", distinctId.substring(0, 8) + "...");
+      if (this.config?.debug) console.warn("[Paywallo TRACK]", eventName, "distinctId:", distinctId.substring(0, 8) + "...");
     }
     await apiClient.trackEvent(eventName, distinctId, {
       ...identityManager.getProperties(),
@@ -3352,15 +3630,25 @@ 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);
+        if (this.config?.debug) console.warn("[Paywallo AB]", "getVariant SKIPPED \u2014 no distinctId", flagKey);
         return { variant: null };
       }
       const result = await this.getApiClientOrThrow().getVariant(flagKey, distinctId);
-      console.warn("[Paywallo AB]", `getVariant("${flagKey}") =`, result.variant);
+      if (this.config?.debug) console.warn("[Paywallo AB]", `getVariant("${flagKey}") =`, result.variant);
       return result;
     } catch (error) {
       if (this.config?.debug) console.warn("[Paywallo]", "getVariant failed \u2014 returning null", error);
@@ -3368,6 +3656,10 @@ var _PaywalloClientClass = class _PaywalloClientClass {
       return { variant: null };
     }
   }
+  async evaluateFlags(keys) {
+    this.ensureInitialized();
+    return this.getApiClientOrThrow().evaluateFlags(keys, identityManager.getDistinctId());
+  }
   async getConditionalFlag(flagKey, context) {
     try {
       const distinctId = identityManager.getDistinctId();
@@ -3393,7 +3685,7 @@ 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();
@@ -3401,11 +3693,12 @@ var _PaywalloClientClass = class _PaywalloClientClass {
       if (this.activeChecker) return await this.activeChecker();
       const distinctId = identityManager.getDistinctId();
       if (!distinctId || !this.apiClient) return false;
-      return (await this.apiClient.getSubscriptionStatus(distinctId)).hasActiveSubscription;
+      const status = await this.apiClient.getSubscriptionStatus(distinctId);
+      return status.hasActiveSubscription;
     } catch {
-      if (this.config?.debug) console.warn("[Paywallo]", "hasActiveSubscription failed \u2014 returning false");
+      if (this.config?.debug) console.warn("[Paywallo]", "hasActiveSubscription failed \u2014 using persistent cache");
       if (this.apiClient) void this.apiClient.reportError("SUBSCRIPTION_CHECK_FAILED", "hasActiveSubscription failed");
-      return false;
+      return resolveClientOfflineFromCache();
     }
   }
   async getSubscription() {
@@ -3434,6 +3727,7 @@ var _PaywalloClientClass = class _PaywalloClientClass {
     const wasDebug = this.config?.debug ?? false;
     await sessionManager.endSession();
     await identityManager.reset();
+    await subscriptionCache.invalidate();
     queueProcessor.dispose();
     offlineQueue.dispose();
     networkMonitor.dispose();
@@ -3621,7 +3915,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) {
@@ -3658,11 +3952,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 +3975,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,11 +4016,11 @@ 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 {
@@ -3754,7 +4048,7 @@ function usePurchase() {
       throw err;
     }
   }, []);
-  const restore = useCallback6(async () => {
+  const restore = useCallback7(async () => {
     setState("restoring");
     setError(null);
     try {
@@ -3786,90 +4080,10 @@ function usePurchase() {
 }
 
 // src/hooks/useSubscription.ts
-import { useCallback as useCallback7, useEffect as useEffect6, useState as useState7 } from "react";
+import { useCallback as useCallback8, useEffect as useEffect6, useState as useState8 } 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;
@@ -4001,10 +4215,10 @@ var subscriptionManager = new SubscriptionManagerClass();
 
 // src/hooks/useSubscription.ts
 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 +4231,7 @@ function useSubscription() {
       setIsLoading(false);
     }
   }, []);
-  const restore = useCallback7(async () => {
+  const restore = useCallback8(async () => {
     setIsLoading(true);
     setError(null);
     try {
@@ -4054,11 +4268,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, 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 = {
@@ -4125,17 +4339,17 @@ function consumeCacheEntry(cache, placement) {
 
 // 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(
+  const consumePreloadedCampaign = useCallback9(
     (placement) => consumeCacheEntry(preloadedCampaignsRef.current, placement),
     []
   );
-  const preloadCampaign = useCallback8(
+  const preloadCampaign = useCallback9(
     async (placement, context) => {
       try {
         const campaign = await PaywalloClient.getCampaign(placement, context);
@@ -4201,11 +4415,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();
@@ -4223,10 +4437,10 @@ function useProductLoader() {
 }
 
 // src/hooks/usePurchaseOrchestrator.ts
-import { useCallback as useCallback10 } from "react";
+import { useCallback as useCallback11 } from "react";
 function usePurchaseOrchestrator(preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef) {
   const { trackDismissed, trackProductSelected, trackPurchased } = usePaywallTracking();
-  const handlePreloadedPurchase = useCallback10(
+  const handlePreloadedPurchase = useCallback11(
     async (productId) => {
       try {
         if (preloadedWebView) {
@@ -4261,7 +4475,7 @@ function usePurchaseOrchestrator(preloadedWebView, resolvePreloadedPaywall, clea
     },
     [preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef, trackDismissed, trackProductSelected, trackPurchased]
   );
-  const handlePreloadedRestore = useCallback10(async () => {
+  const handlePreloadedRestore = useCallback11(async () => {
     try {
       const transactions = await getIAPService().restore();
       if (transactions.length === 0) return;
@@ -4283,16 +4497,58 @@ function usePurchaseOrchestrator(preloadedWebView, resolvePreloadedPaywall, clea
 }
 
 // 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,
+    // The hook's SubscriptionStatus is a subset of the domain's — cast is safe
+    status: sub.status,
+    expiresAt: sub.expiresAt ?? /* @__PURE__ */ new Date(0),
+    originalPurchaseDate: /* @__PURE__ */ new Date(0),
+    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: []
+  };
+}
+async function resolveOfflineFromCache() {
+  try {
+    const cached = await subscriptionCache.get();
+    if (!cached) return false;
+    const sub = cached.data.subscription;
+    if (!sub) return false;
+    if (!ACTIVE_STATUSES.includes(sub.status)) return false;
+    const hasValidExpiry = sub.expiresAt.getTime() === 0 || sub.expiresAt > /* @__PURE__ */ new Date();
+    return hasValidExpiry;
+  } catch {
+    return false;
+  }
+}
+function isActiveCacheEntry(entry) {
+  if (!entry.data) return false;
+  if (!ACTIVE_STATUSES.includes(entry.data.status)) return false;
+  if (entry.data.expiresAt && entry.data.expiresAt < /* @__PURE__ */ new Date()) return false;
+  return true;
+}
 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;
+    void subscriptionCache.invalidate();
   }, []);
-  const fetchAndCache = useCallback11(async () => {
+  const fetchAndCache = useCallback12(async () => {
     const apiClient = PaywalloClient.getApiClient();
     const distinctId = PaywalloClient.getDistinctId();
     if (!apiClient || !distinctId) return null;
@@ -4303,18 +4559,37 @@ function useSubscriptionSync() {
     } : null;
     cacheRef.current = { data: sub, expiresAt: Date.now() + CACHE_TTL_MS2 };
     setSubscription(sub);
+    void subscriptionCache.set(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();
+      if (persisted) {
+        if (!persisted.isStale) {
+          const sub = persisted.data.subscription ? {
+            productId: persisted.data.subscription.productId,
+            status: persisted.data.subscription.status,
+            expiresAt: persisted.data.subscription.expiresAt ?? null,
+            platform: persisted.data.subscription.platform,
+            autoRenewEnabled: persisted.data.subscription.willRenew,
+            inGracePeriod: persisted.data.subscription.status === "grace_period"
+          } : null;
+          cacheRef.current = { data: sub, expiresAt: Date.now() + CACHE_TTL_MS2 };
+          setSubscription(sub);
+          return persisted.data.hasActiveSubscription;
+        }
+        void fetchAndCache();
+        return persisted.data.hasActiveSubscription;
+      }
+    } catch {
     }
     try {
       const status = await apiClient.getSubscriptionStatus(distinctId);
@@ -4324,12 +4599,13 @@ function useSubscriptionSync() {
       } : null;
       cacheRef.current = { data: sub, expiresAt: Date.now() + CACHE_TTL_MS2 };
       setSubscription(sub);
+      void subscriptionCache.set(toDomainResponse(status));
       return status.hasActiveSubscription;
     } catch {
-      return false;
+      return await resolveOfflineFromCache();
     }
-  }, []);
-  const getSubscription = useCallback11(async () => {
+  }, [fetchAndCache]);
+  const getSubscription = useCallback12(async () => {
     const apiClient = PaywalloClient.getApiClient();
     const distinctId = PaywalloClient.getDistinctId();
     if (!apiClient || !distinctId) return null;
@@ -4338,7 +4614,22 @@ function useSubscriptionSync() {
     try {
       return await fetchAndCache();
     } catch {
-      return null;
+      try {
+        const persisted = await subscriptionCache.get();
+        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,14 +4638,14 @@ 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 clearPreloadedWebView = useCallback13(() => setPreloadedWebView(null), [setPreloadedWebView]);
   const { showingPreloadedWebView, presentPreloadedWebView, resolvePreloadedPaywall, handlePreloadedWebViewReady, handlePreloadedClose, setShowingPreloadedWebView, presentedAtRef } = usePaywallPresenter(preloadedWebView, clearPreloadedWebView, setPreloadedWebView);
   const { handlePreloadedPurchase: rawPreloadedPurchase, handlePreloadedRestore } = usePurchaseOrchestrator(
     preloadedWebView,
@@ -4363,8 +4654,8 @@ function PaywalloProvider({ children, config }) {
     setShowingPreloadedWebView,
     presentedAtRef
   );
-  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);
@@ -4381,21 +4672,21 @@ function PaywalloProvider({ children, config }) {
       setInitError(err instanceof Error ? err : new ClientError(CLIENT_ERROR_CODES.NOT_INITIALIZED, String(err)));
     });
   }, [config]);
-  const getPaywallConfig = useCallback12(async (p) => {
+  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 +4755,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,7 +4764,7 @@ 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);
@@ -4496,7 +4787,7 @@ function PaywalloProvider({ children, config }) {
   useEffect7(() => {
     if (activePaywall) setPreloadedWebView(null);
   }, [activePaywall, setPreloadedWebView]);
-  const noOp = useCallback12(() => {
+  const noOp = useCallback13(() => {
   }, []);
   const contextValue = useMemo2(() => ({
     config: PaywalloClient.getConfig(),