@virex-tech/paywallo-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,4709 @@
+// src/errors/PaywalloError.ts
+var PaywalloError = class extends Error {
+  constructor(domain, code, message) {
+    super(message);
+    this.name = "PaywalloError";
+    this.domain = domain;
+    this.code = code;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/domains/analytics/AnalyticsError.ts
+var AnalyticsError = class extends PaywalloError {
+  constructor(code, message) {
+    super("analytics", code, message);
+    this.name = "AnalyticsError";
+  }
+};
+var ANALYTICS_ERROR_CODES = {
+  NOT_INITIALIZED: "ANALYTICS_NOT_INITIALIZED",
+  INVALID_STEP_INDEX: "ANALYTICS_INVALID_STEP_INDEX",
+  INVALID_ACTION_NAME: "ANALYTICS_INVALID_ACTION_NAME"
+};
+
+// src/errors/ClientError.ts
+var ClientError = class extends PaywalloError {
+  constructor(code, message) {
+    super("client", code, message);
+    this.name = "ClientError";
+  }
+};
+var CLIENT_ERROR_CODES = {
+  NOT_INITIALIZED: "CLIENT_NOT_INITIALIZED",
+  MISSING_APP_KEY: "CLIENT_MISSING_APP_KEY",
+  INVALID_EVENT_NAME: "CLIENT_INVALID_EVENT_NAME",
+  PROVIDER_MISSING: "CLIENT_PROVIDER_MISSING",
+  UNKNOWN: "CLIENT_UNKNOWN"
+};
+
+// 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";
+
+// src/domains/paywall/usePaywallActions.ts
+import { useCallback as useCallback2, useRef, useState } from "react";
+import { Animated, Dimensions } from "react-native";
+
+// src/domains/iap/IAPService.ts
+import { Platform as Platform2 } from "react-native";
+
+// src/domains/iap/PurchaseError.ts
+var PurchaseError = class extends PaywalloError {
+  constructor(code, message, userCancelled = false) {
+    super("purchase", code, message);
+    this.name = "PurchaseError";
+    this.userCancelled = userCancelled;
+  }
+};
+var PURCHASE_ERROR_CODES = {
+  NOT_INITIALIZED: "PURCHASE_NOT_INITIALIZED",
+  PRODUCT_NOT_FOUND: "PRODUCT_NOT_FOUND",
+  PURCHASE_FAILED: "PURCHASE_FAILED",
+  RESTORE_FAILED: "RESTORE_FAILED",
+  VALIDATION_FAILED: "VALIDATION_FAILED",
+  USER_CANCELLED: "USER_CANCELLED",
+  NETWORK_ERROR: "PURCHASE_NETWORK_ERROR",
+  STORE_ERROR: "PURCHASE_STORE_ERROR",
+  PENDING_PURCHASE: "PURCHASE_PENDING",
+  DEFERRED_PURCHASE: "PURCHASE_DEFERRED",
+  STORE_NOT_AVAILABLE: "PURCHASE_STORE_NOT_AVAILABLE"
+};
+var DEFAULT_MESSAGES = {
+  NOT_INITIALIZED: "Purchase controller not initialized. Call init() first.",
+  PRODUCT_NOT_FOUND: "Product not found in store.",
+  PURCHASE_FAILED: "Purchase failed. Please try again.",
+  RESTORE_FAILED: "Failed to restore purchases. Please try again.",
+  VALIDATION_FAILED: "Failed to validate purchase with server.",
+  USER_CANCELLED: "Purchase was cancelled.",
+  NETWORK_ERROR: "Network error. Please check your connection.",
+  STORE_ERROR: "Store error. Please try again later.",
+  PENDING_PURCHASE: "Purchase is pending approval.",
+  DEFERRED_PURCHASE: "Purchase is deferred (e.g., parental approval required).",
+  STORE_NOT_AVAILABLE: "In-app purchases are not available on this device."
+};
+function createPurchaseError(code, message) {
+  return new PurchaseError(
+    PURCHASE_ERROR_CODES[code],
+    message ?? DEFAULT_MESSAGES[code] ?? "Unknown purchase error",
+    code === "USER_CANCELLED"
+  );
+}
+
+// src/domains/iap/NativeStoreKit.ts
+import { NativeModules, Platform } from "react-native";
+
+// src/domains/identity/IdentityError.ts
+var IdentityError = class extends PaywalloError {
+  constructor(code, message) {
+    super("identity", code, message);
+    this.name = "IdentityError";
+  }
+};
+var IDENTITY_ERROR_CODES = {
+  NOT_INITIALIZED: "IDENTITY_NOT_INITIALIZED",
+  DEVICE_ID_UNAVAILABLE: "IDENTITY_DEVICE_ID_UNAVAILABLE",
+  STORAGE_READ_FAILED: "IDENTITY_STORAGE_READ_FAILED",
+  STORAGE_WRITE_FAILED: "IDENTITY_STORAGE_WRITE_FAILED",
+  IDENTIFY_FAILED: "IDENTITY_IDENTIFY_FAILED"
+};
+
+// src/utils/uuid.ts
+function generateUUID() {
+  const template = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";
+  return template.replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/core/storage/SecureStorage.ts
+import AsyncStorage from "@react-native-async-storage/async-storage";
+var _keychain = void 0;
+async function loadKeychain() {
+  if (_keychain !== void 0) return _keychain;
+  try {
+    const mod = await import("react-native-keychain");
+    _keychain = mod.default;
+  } catch {
+    _keychain = null;
+  }
+  return _keychain;
+}
+var KEYCHAIN_SERVICE_PREFIX = "com.paywallo.sdk.";
+var SecureStorage = class {
+  constructor(debug = false) {
+    this.debug = debug;
+  }
+  /**
+   * Get a value, trying Keychain first (survives reinstalls on iOS), then AsyncStorage.
+   */
+  async get(key) {
+    const keychainValue = await this.getFromKeychain(key);
+    if (keychainValue) {
+      this.log(`Retrieved ${key} from keychain`);
+      return keychainValue;
+    }
+    try {
+      const value = await AsyncStorage.getItem(`@paywallo:${key}`);
+      if (value) {
+        this.log(`Retrieved ${key} from async storage`);
+        await this.setToKeychain(key, value);
+      }
+      return value;
+    } catch (error) {
+      this.log(`Storage read failed for ${key}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Set a value in both Keychain (if available) and AsyncStorage.
+   */
+  async set(key, value) {
+    try {
+      await Promise.all([
+        AsyncStorage.setItem(`@paywallo:${key}`, value),
+        this.setToKeychain(key, value)
+      ]);
+      this.log(`Stored ${key} in storage`);
+      return true;
+    } catch (error) {
+      this.log(`Storage write failed for ${key}:`, error);
+      return false;
+    }
+  }
+  async remove(key) {
+    try {
+      await Promise.all([
+        AsyncStorage.removeItem(`@paywallo:${key}`),
+        this.removeFromKeychain(key)
+      ]);
+      this.log(`Removed ${key} from storage`);
+      return true;
+    } catch (error) {
+      this.log(`Storage remove failed for ${key}:`, error);
+      return false;
+    }
+  }
+  hasKeychainSupport() {
+    return _keychain !== null && _keychain !== void 0;
+  }
+  async getFromKeychain(key) {
+    const keychain = await loadKeychain();
+    if (!keychain) return null;
+    try {
+      const result = await keychain.getGenericPassword({ service: `${KEYCHAIN_SERVICE_PREFIX}${key}` });
+      if (result && result.password) {
+        return result.password;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async setToKeychain(key, value) {
+    const keychain = await loadKeychain();
+    if (!keychain) return false;
+    try {
+      await keychain.setGenericPassword("panel", value, { service: `${KEYCHAIN_SERVICE_PREFIX}${key}` });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async removeFromKeychain(key) {
+    const keychain = await loadKeychain();
+    if (!keychain) return false;
+    try {
+      await keychain.resetGenericPassword({ service: `${KEYCHAIN_SERVICE_PREFIX}${key}` });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  log(...args) {
+    if (this.debug) {
+      console.warn("[Panel Storage]", ...args);
+    }
+  }
+};
+var secureStorage = new SecureStorage();
+
+// src/domains/identity/IdentityManager.ts
+var DEVICE_ID_KEY = "device_id";
+var USER_EMAIL_KEY = "user_email";
+var USER_PROPERTIES_KEY = "user_properties";
+var IdentityManager = class {
+  constructor() {
+    this.deviceId = null;
+    this.email = null;
+    this.properties = {};
+    this.apiClient = null;
+    this.secureStorage = null;
+    this.debug = false;
+    this.initialized = false;
+  }
+  async initialize(apiClient, debug = false) {
+    if (this.initialized) {
+      return this.deviceId ?? "";
+    }
+    this.apiClient = apiClient;
+    this.debug = debug;
+    this.secureStorage = new SecureStorage(debug);
+    await this.loadPersistedState();
+    if (!this.deviceId) {
+      let DeviceInfo = null;
+      try {
+        const mod = await import("react-native-device-info");
+        DeviceInfo = mod.default;
+      } catch {
+        DeviceInfo = null;
+      }
+      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");
+        });
+      }
+    }
+    this.initialized = true;
+    return this.deviceId ?? "";
+  }
+  async identify(options) {
+    this.ensureInitialized();
+    let email;
+    let properties;
+    if (options) {
+      if ("email" in options || "properties" in options) {
+        email = options.email;
+        properties = options.properties;
+      } else {
+        properties = options;
+      }
+    }
+    if (email) {
+      this.email = email;
+      await this.secureStorage.set(USER_EMAIL_KEY, email);
+    }
+    if (properties) {
+      this.properties = { ...this.properties, ...properties };
+      await this.secureStorage.set(USER_PROPERTIES_KEY, JSON.stringify(this.properties));
+    }
+    if (this.apiClient && this.deviceId) {
+      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);
+      }
+    }
+  }
+  getDistinctId() {
+    if (!this.initialized || !this.deviceId) {
+      if (this.debug) console.warn("[Paywallo Identity] getDistinctId called before initialization");
+      return "";
+    }
+    return this.deviceId;
+  }
+  getDeviceId() {
+    return this.deviceId;
+  }
+  getEmail() {
+    return this.email;
+  }
+  getProperties() {
+    return { ...this.properties };
+  }
+  async updateProperties(properties) {
+    this.ensureInitialized();
+    this.properties = { ...this.properties, ...properties };
+    await this.secureStorage.set(USER_PROPERTIES_KEY, JSON.stringify(this.properties));
+    if (this.apiClient && this.deviceId) {
+      try {
+        await this.apiClient.identify(this.deviceId, this.properties, this.email ?? void 0);
+      } catch (error) {
+        this.log("Failed to update properties on server:", error);
+      }
+    }
+  }
+  async reset() {
+    this.email = null;
+    this.properties = {};
+    this.initialized = false;
+    this.apiClient = null;
+    this.deviceId = null;
+    await Promise.all([
+      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)
+    ]);
+  }
+  getState() {
+    return {
+      deviceId: this.deviceId ?? "",
+      email: this.email,
+      properties: this.getProperties()
+    };
+  }
+  isSecureStorageAvailable() {
+    return this.secureStorage !== null;
+  }
+  async loadPersistedState() {
+    if (!this.secureStorage) {
+      return;
+    }
+    const [storedDeviceId, storedEmail, storedPropertiesJson] = await Promise.all([
+      this.secureStorage.get(DEVICE_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 (storedEmail) {
+      this.email = storedEmail;
+    }
+    if (storedPropertiesJson) {
+      try {
+        this.properties = JSON.parse(storedPropertiesJson);
+      } catch {
+        this.properties = {};
+      }
+    }
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new IdentityError(
+        IDENTITY_ERROR_CODES.NOT_INITIALIZED,
+        "IdentityManager not initialized. Call initialize() first"
+      );
+    }
+  }
+  log(...args) {
+    if (this.debug) {
+      console.warn("[Paywallo Identity]", ...args);
+    }
+  }
+};
+var identityManager = new IdentityManager();
+
+// src/domains/iap/NativeStoreKit.ts
+var PaywalloStoreKitNative = NativeModules.PaywalloStoreKit ?? null;
+function isAvailable() {
+  return PaywalloStoreKitNative != null;
+}
+function mapNativeProduct(native) {
+  const product = {
+    productId: native.productId,
+    title: native.title,
+    description: native.description,
+    price: native.price,
+    priceValue: native.priceValue,
+    currency: native.currency ?? "USD",
+    localizedPrice: native.localizedPrice,
+    type: mapProductType(native.type),
+    subscriptionPeriod: native.subscriptionPeriod,
+    introductoryPrice: native.introductoryPrice,
+    introductoryPriceValue: native.introductoryPriceValue,
+    freeTrialPeriod: native.freeTrialPeriod
+  };
+  if (native.subscriptionPeriod) {
+    const prices = calculatePerPeriodPrices(native.priceValue, native.subscriptionPeriod);
+    product.pricePerMonth = prices.perMonth;
+    product.pricePerWeek = prices.perWeek;
+    product.pricePerDay = prices.perDay;
+  }
+  return product;
+}
+function mapProductType(type) {
+  switch (type) {
+    case "subscription":
+    case "autoRenewable":
+      return "subscription";
+    case "consumable":
+      return "consumable";
+    default:
+      return "non_consumable";
+  }
+}
+function calculatePerPeriodPrices(priceValue, period) {
+  const totalDays = periodToDays(period);
+  if (totalDays <= 0) return {};
+  const perDay = priceValue / totalDays;
+  const perWeek = perDay * 7;
+  const perMonth = perDay * 30;
+  return {
+    perDay: perDay.toFixed(2),
+    perWeek: perWeek.toFixed(2),
+    perMonth: perMonth.toFixed(2)
+  };
+}
+function periodToDays(period) {
+  const match = period.match(/^P(\d+)([DWMY])$/);
+  if (!match) return 0;
+  const value = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "D":
+      return value;
+    case "W":
+      return value * 7;
+    case "M":
+      return value * 30;
+    case "Y":
+      return value * 365;
+    default:
+      return 0;
+  }
+}
+function mapNativePurchase(native) {
+  return {
+    productId: native.productId,
+    transactionId: native.transactionId,
+    transactionDate: native.transactionDate,
+    receipt: native.receipt,
+    platform: Platform.OS
+  };
+}
+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);
+    return nativeProducts.map(mapNativeProduct);
+  },
+  async purchase(productId) {
+    if (!PaywalloStoreKitNative) {
+      throw new PurchaseError(
+        PURCHASE_ERROR_CODES.STORE_NOT_AVAILABLE,
+        "StoreKit native module not available"
+      );
+    }
+    const distinctId = identityManager.getDistinctId();
+    const result = await PaywalloStoreKitNative.purchase(productId, distinctId ?? null);
+    if (!result || result.pending) {
+      return null;
+    }
+    return mapNativePurchase(result);
+  },
+  async finishTransaction(transactionId) {
+    if (!PaywalloStoreKitNative) return;
+    await PaywalloStoreKitNative.finishTransaction(transactionId);
+  },
+  async getActiveTransactions() {
+    if (!PaywalloStoreKitNative) return [];
+    const results = await PaywalloStoreKitNative.getActiveTransactions();
+    return results.map(mapNativePurchase);
+  }
+};
+
+// src/domains/iap/IAPService.ts
+var IAPService = class {
+  constructor(apiClient) {
+    this.productsCache = /* @__PURE__ */ new Map();
+    this.apiClient = null;
+    this.apiClient = apiClient ?? null;
+  }
+  get debug() {
+    return PaywalloClient.getConfig()?.debug ?? false;
+  }
+  getDeviceCountry() {
+    try {
+      const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+      const parts = locale.split("-");
+      return parts[parts.length - 1]?.toUpperCase() || "US";
+    } catch {
+      return "US";
+    }
+  }
+  getApiClient() {
+    if (this.apiClient) return this.apiClient;
+    const client = PaywalloClient.getApiClient();
+    if (!client)
+      throw new PurchaseError(PURCHASE_ERROR_CODES.NOT_INITIALIZED, "SDK not initialized");
+    return client;
+  }
+  isAvailable() {
+    return nativeStoreKit.isAvailable();
+  }
+  async loadProducts(productIds) {
+    if (!nativeStoreKit.isAvailable()) {
+      if (this.debug) console.warn("[Paywallo][Products] StoreKit not available");
+      return [];
+    }
+    try {
+      if (this.debug) console.warn("[Paywallo][Products] Loading from StoreKit:", productIds);
+      const products = await nativeStoreKit.getProducts(productIds);
+      if (this.debug) console.warn("[Paywallo][Products] StoreKit returned:", products.length, "products");
+      for (const product of products) {
+        if (this.debug) console.warn("[Paywallo][Products]", product.productId, "\u2192", product.localizedPrice, "(", product.currency, ")");
+        this.productsCache.set(product.productId, product);
+      }
+      if (products.length < productIds.length) {
+        const missing = productIds.filter((id) => !products.find((p) => p.productId === id));
+        if (this.debug) console.warn("[Paywallo][Products] Missing from StoreKit:", missing);
+      }
+      return products;
+    } catch (error) {
+      if (this.debug) console.warn("[Paywallo][Products] StoreKit error:", error);
+      return [];
+    }
+  }
+  getProduct(productId) {
+    return this.productsCache.get(productId);
+  }
+  getCachedProducts() {
+    return new Map(this.productsCache);
+  }
+  async validateWithServer(purchase, productId, options) {
+    const apiClient = this.getApiClient();
+    const product = this.productsCache.get(productId);
+    const platform = Platform2.OS;
+    const distinctId = PaywalloClient.getDistinctId();
+    if (this.debug) console.warn("[Paywallo][Purchase] Validating with server:", purchase.productId, "tx:", purchase.transactionId, "price:", product?.priceValue, product?.currency);
+    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
+    );
+    if (this.debug) console.warn("[Paywallo][Purchase] Server validation result:", JSON.stringify(validation));
+    return validation;
+  }
+  async finishTransaction(transactionId) {
+    try {
+      if (this.debug) console.warn("[Paywallo][Purchase] Finishing transaction:", transactionId);
+      await nativeStoreKit.finishTransaction(transactionId);
+      if (this.debug) console.warn("[Paywallo][Purchase] Transaction finished OK");
+    } 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()) {
+      return {
+        success: false,
+        error: new PurchaseError(PURCHASE_ERROR_CODES.STORE_NOT_AVAILABLE, "In-app purchases are not available on this device")
+      };
+    }
+    try {
+      if (this.debug) console.warn("[Paywallo][Purchase] StoreKit purchase starting:", productId);
+      const purchase = await nativeStoreKit.purchase(productId);
+      if (!purchase) {
+        if (this.debug) console.warn("[Paywallo][Purchase] StoreKit returned null (user cancelled or pending)");
+        return { success: false };
+      }
+      if (this.debug) console.warn("[Paywallo][Purchase] StoreKit OK \u2014 tx:", purchase.transactionId, "product:", purchase.productId, "receipt length:", purchase.receipt?.length);
+      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")
+        };
+      }
+      if (!validation?.success) {
+        if (this.debug) console.warn("[Paywallo][Purchase] Validation returned failure:", validation?.error || "no validation result");
+        return {
+          success: false,
+          error: new PurchaseError(PURCHASE_ERROR_CODES.VALIDATION_FAILED, validation?.error ? `Server validation: ${validation.error}` : "Server validation failed")
+        };
+      }
+      await this.finishTransaction(purchase.transactionId);
+      if (this.debug) console.warn("[Paywallo][Purchase] COMPLETE \u2014 validated & finished:", purchase.productId);
+      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 };
+    }
+  }
+  async restore() {
+    if (!nativeStoreKit.isAvailable()) {
+      if (this.debug) console.warn("[Paywallo][Restore] StoreKit not available");
+      return [];
+    }
+    try {
+      if (this.debug) console.warn("[Paywallo][Restore] Getting active transactions...");
+      const transactions = await nativeStoreKit.getActiveTransactions();
+      if (this.debug) console.warn("[Paywallo][Restore] Found", transactions.length, "active transactions");
+      const apiClient = this.getApiClient();
+      const distinctId = PaywalloClient.getDistinctId();
+      const platform = Platform2.OS;
+      const results = await Promise.allSettled(
+        transactions.map((tx) => {
+          const product = this.productsCache.get(tx.productId);
+          if (this.debug) console.warn("[Paywallo][Restore] Validating tx:", tx.transactionId, "product:", tx.productId);
+          return apiClient.validatePurchase(
+            platform,
+            tx.receipt,
+            tx.productId,
+            tx.transactionId,
+            product?.priceValue ?? 0,
+            product?.currency ?? "USD",
+            this.getDeviceCountry(),
+            distinctId
+          );
+        })
+      );
+      const validated = [];
+      for (let i = 0; i < results.length; i++) {
+        const r = results[i];
+        const tx = transactions[i];
+        if (this.debug) console.warn("[Paywallo][Restore] Validation:", r.status, r.status === "fulfilled" ? JSON.stringify(r.value) : r.reason?.message);
+        if (r.status === "fulfilled" && r.value.success) {
+          try {
+            await nativeStoreKit.finishTransaction(tx.transactionId);
+            if (this.debug) console.warn("[Paywallo][Restore] Finished tx:", 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);
+        } else {
+          if (this.debug) console.warn("[Paywallo][Restore] Skipping unvalidated tx:", tx.transactionId);
+        }
+      }
+      return validated;
+    } catch (error) {
+      if (this.debug) console.warn("[Paywallo][Restore] FAILED:", error instanceof Error ? error.message : error);
+      return [];
+    }
+  }
+};
+var _instance = null;
+function getIAPService() {
+  if (!_instance) {
+    _instance = new IAPService();
+  }
+  return _instance;
+}
+
+// src/domains/paywall/usePaywallTracking.ts
+import { useCallback } from "react";
+function usePaywallTracking() {
+  const trackDismissed = useCallback(async (opts) => {
+    try {
+      const api = PaywalloClient.getApiClient();
+      if (!api) return;
+      const sessionId = PaywalloClient.getSessionId();
+      await api.trackEvent("$paywall_dismissed", PaywalloClient.getDistinctId(), {
+        placement: opts.placement,
+        paywallId: opts.paywallId,
+        durationSeconds: opts.durationSeconds,
+        action: opts.action,
+        ...opts.variantKey && { variantKey: opts.variantKey },
+        ...opts.campaignId && { campaignId: opts.campaignId },
+        ...sessionId && { sessionId }
+      });
+    } catch {
+    }
+  }, []);
+  const trackProductSelected = useCallback((opts) => {
+    const api = PaywalloClient.getApiClient();
+    if (!api) return;
+    const sessionId = PaywalloClient.getSessionId();
+    void api.trackEvent("$paywall_product_selected", PaywalloClient.getDistinctId(), {
+      placement: opts.placement,
+      paywallId: opts.paywallId,
+      productId: opts.productId,
+      ...opts.variantKey && { variantKey: opts.variantKey },
+      ...opts.campaignId && { campaignId: opts.campaignId },
+      ...sessionId && { sessionId }
+    }).catch(() => {
+    });
+  }, []);
+  const trackPurchased = useCallback(async (opts) => {
+    try {
+      const api = PaywalloClient.getApiClient();
+      if (!api) return;
+      const sessionId = PaywalloClient.getSessionId();
+      await api.trackEvent("$paywall_purchased", PaywalloClient.getDistinctId(), {
+        placement: opts.placement,
+        paywallId: opts.paywallId,
+        productId: opts.productId,
+        ...opts.variantKey && { variantKey: opts.variantKey },
+        ...opts.campaignId && { campaignId: opts.campaignId },
+        ...sessionId && { sessionId }
+      });
+    } catch {
+    }
+  }, []);
+  return { trackDismissed, trackProductSelected, trackPurchased };
+}
+
+// src/domains/paywall/usePaywallActions.ts
+var SCREEN_HEIGHT = Dimensions.get("window").height;
+function usePaywallActions(placement, paywallConfig, onResult, variantKey, campaignId) {
+  const [isPurchasing, setIsPurchasing] = useState(false);
+  const [isClosing, setIsClosing] = useState(false);
+  const slideAnim = useRef(new Animated.Value(0)).current;
+  const presentedAtRef = useRef(Date.now());
+  const { trackDismissed, trackProductSelected, trackPurchased } = usePaywallTracking();
+  const handleClose = useCallback2(() => {
+    if (isClosing) return;
+    setIsClosing(true);
+    Animated.timing(slideAnim, { toValue: SCREEN_HEIGHT, duration: 300, 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 });
+      }
+      slideAnim.setValue(0);
+      setIsClosing(false);
+      onResult({ presented: true, purchased: false, cancelled: true, restored: false });
+    });
+  }, [isClosing, onResult, paywallConfig, placement, slideAnim, trackDismissed, variantKey, campaignId]);
+  const handlePurchase = useCallback2(async (productId) => {
+    if (isPurchasing) return;
+    setIsPurchasing(true);
+    try {
+      if (paywallConfig) trackProductSelected({ placement, paywallId: paywallConfig.id, productId, variantKey, campaignId });
+      const result = await getIAPService().purchase(productId, { paywallPlacement: placement, variantKey });
+      if (result.success) {
+        if (paywallConfig) {
+          const durationSeconds = Math.round((Date.now() - presentedAtRef.current) / 1e3);
+          await trackDismissed({ placement, paywallId: paywallConfig.id, durationSeconds, action: "purchase", variantKey, campaignId });
+          await trackPurchased({ placement, paywallId: paywallConfig.id, productId, variantKey, campaignId });
+        }
+        onResult({ presented: true, purchased: true, cancelled: false, restored: false });
+      } else if (result.error) {
+        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);
+    }
+  }, [isPurchasing, onResult, paywallConfig, placement, trackDismissed, trackProductSelected, trackPurchased, variantKey, campaignId]);
+  const handleRestore = useCallback2(async () => {
+    if (isPurchasing) return;
+    setIsPurchasing(true);
+    try {
+      const transactions = await getIAPService().restore();
+      if (transactions.length > 0) {
+        if (paywallConfig) {
+          const durationSeconds = Math.round((Date.now() - presentedAtRef.current) / 1e3);
+          await trackDismissed({ placement, paywallId: paywallConfig.id, durationSeconds, action: "restore", variantKey, campaignId });
+        }
+        onResult({ presented: true, purchased: false, cancelled: false, restored: true });
+      } else {
+        if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] No purchases to restore");
+        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);
+    }
+  }, [isPurchasing, onResult, paywallConfig, placement, trackDismissed, variantKey, campaignId]);
+  return { isPurchasing, slideAnim, handleClose, handlePurchase, handleRestore };
+}
+
+// src/domains/paywall/usePaywallLoader.ts
+import { useEffect, useRef as useRef2, useState as useState2 } from "react";
+
+// src/domains/paywall/PaywallError.ts
+var PaywallError = class extends PaywalloError {
+  constructor(code, message) {
+    super("paywall", code, message);
+    this.name = "PaywallError";
+  }
+};
+var PAYWALL_ERROR_CODES = {
+  NOT_INITIALIZED: "PAYWALL_NOT_INITIALIZED",
+  NOT_FOUND: "PAYWALL_NOT_FOUND",
+  RENDER_FAILED: "PAYWALL_RENDER_FAILED",
+  LOAD_FAILED: "PAYWALL_LOAD_FAILED",
+  DISMISS_FAILED: "PAYWALL_DISMISS_FAILED",
+  INVALID_CONFIG: "PAYWALL_INVALID_CONFIG"
+};
+
+// src/domains/paywall/usePaywallLoader.ts
+function usePaywallLoader(placement, visible, preloadedConfig, preloadedProducts, variantKey, campaignId) {
+  const [error, setError] = useState2(null);
+  const [paywallConfig, setPaywallConfig] = useState2(null);
+  const [products, setProducts] = useState2(/* @__PURE__ */ new Map());
+  const preloadedConfigRef = useRef2(preloadedConfig);
+  preloadedConfigRef.current = preloadedConfig;
+  const preloadedProductsRef = useRef2(preloadedProducts);
+  preloadedProductsRef.current = preloadedProducts;
+  const trackingDoneRef = useRef2(false);
+  useEffect(() => {
+    if (!visible) {
+      trackingDoneRef.current = false;
+      return;
+    }
+    const load = async () => {
+      setError(null);
+      try {
+        const apiClient = PaywalloClient.getApiClient();
+        if (!apiClient) throw new PaywallError(PAYWALL_ERROR_CODES.NOT_INITIALIZED, "SDK not initialized");
+        let config;
+        const snap = preloadedConfigRef.current;
+        if (snap) {
+          config = {
+            id: snap.id,
+            placement: snap.placement,
+            config: snap.config,
+            primaryProductId: snap.primaryProductId,
+            secondaryProductId: snap.secondaryProductId
+          };
+        } else {
+          const fetched = await apiClient.getPaywall(placement);
+          if (!fetched) throw new PaywallError(PAYWALL_ERROR_CODES.NOT_FOUND, `Paywall not found for placement: ${placement}`);
+          config = fetched;
+        }
+        setPaywallConfig(config);
+        const productIds = [];
+        if (config.primaryProductId) productIds.push(config.primaryProductId);
+        if (config.secondaryProductId) productIds.push(config.secondaryProductId);
+        const snapProducts = preloadedProductsRef.current;
+        if (snapProducts && snapProducts.size > 0) {
+          setProducts(snapProducts);
+        } else if (productIds.length > 0) {
+          try {
+            const storeProducts = await getIAPService().loadProducts(productIds);
+            const map = /* @__PURE__ */ new Map();
+            for (const p of storeProducts) map.set(p.productId, p);
+            setProducts(map);
+          } catch {
+            setProducts(/* @__PURE__ */ new Map());
+          }
+        } else {
+          setProducts(/* @__PURE__ */ new Map());
+        }
+        if (!trackingDoneRef.current) {
+          trackingDoneRef.current = true;
+          const sessionId = PaywalloClient.getSessionId();
+          await apiClient.trackEvent("$paywall_viewed", PaywalloClient.getDistinctId(), {
+            placement,
+            paywallId: config.id,
+            ...sessionId && { sessionId },
+            ...variantKey && { variantKey },
+            ...campaignId && { campaignId }
+          });
+        }
+      } 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);
+      }
+    };
+    void load();
+  }, [placement, visible, variantKey, campaignId]);
+  return { paywallConfig, products, error };
+}
+
+// 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,
+  requireNativeComponent,
+  StyleSheet,
+  View
+} from "react-native";
+
+// src/domains/paywall/parseWebViewMessage.ts
+function parseWebViewMessage(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.type !== "string") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+// src/domains/paywall/paywallScripts.ts
+function buildPaywallInjectionScript(data) {
+  const paywallData = {
+    type: "paywall",
+    data: {
+      craftData: data.craftData,
+      products: data.products,
+      primaryProductId: data.primaryProductId,
+      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('[Panel WV] FAILED to inject after '+m+' attempts');}}t();})();true;`;
+}
+function buildPurchaseStateScript(isPurchasing) {
+  return `if(window.receiveNativeMessage){window.receiveNativeMessage({type:"purchaseState",data:{isPurchasing:${isPurchasing}}});}true;`;
+}
+
+// src/domains/paywall/PaywallWebView.tsx
+import { jsx } from "react/jsx-runtime";
+var NativeWebViewComponent = null;
+function getNativeWebView() {
+  if (!NativeWebViewComponent) {
+    NativeWebViewComponent = requireNativeComponent("PaywalloWebView");
+  }
+  return NativeWebViewComponent;
+}
+var webViewEmitter = null;
+function getWebViewEmitter() {
+  if (!webViewEmitter) {
+    webViewEmitter = new NativeEventEmitter(NativeModules2.PaywalloWebViewModule);
+  }
+  return webViewEmitter;
+}
+function PaywallWebView({
+  paywallId,
+  craftData,
+  products,
+  primaryProductId,
+  secondaryProductId,
+  isPurchasing,
+  onPurchase,
+  onClose,
+  onRestore,
+  onReady
+}) {
+  const paywallDataSent = useRef3(false);
+  const loadEndReceived = useRef3(false);
+  const [scriptToInject, setScriptToInject] = useState3(void 0);
+  const NativeWebView = useMemo(() => getNativeWebView(), []);
+  const webUrl = useMemo(() => PaywalloClient.getWebUrl() ?? "http://localhost:3000", []);
+  const buildAndSetInjectionScript = useCallback3(() => {
+    if (!craftData || paywallDataSent.current) return;
+    paywallDataSent.current = true;
+    const script = buildPaywallInjectionScript({
+      craftData,
+      products: Array.from(products.values()),
+      primaryProductId,
+      secondaryProductId
+    });
+    setScriptToInject(script);
+    onReady?.();
+  }, [craftData, products, primaryProductId, secondaryProductId, onReady]);
+  const lastProcessedRef = useRef3({ type: "", time: 0 });
+  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 };
+      switch (message.type) {
+        case "ready":
+          if (!paywallDataSent.current) buildAndSetInjectionScript();
+          break;
+        case "purchase":
+          if (message.payload?.productId) onPurchase(message.payload.productId);
+          break;
+        case "close":
+          onClose();
+          break;
+        case "restore":
+          onRestore();
+          break;
+        case "open-url":
+          if (message.payload?.url) {
+            const url = message.payload.url;
+            if (/^https?:\/\//i.test(url) || /^mailto:/i.test(url)) {
+              void Linking.openURL(url);
+            }
+          }
+          break;
+      }
+    },
+    [buildAndSetInjectionScript, onPurchase, onClose, onRestore]
+  );
+  useEffect2(() => {
+    const emitter = getWebViewEmitter();
+    const loadEndSub = emitter.addListener("PaywalloWebViewLoadEnd", () => {
+      if (!loadEndReceived.current) {
+        loadEndReceived.current = true;
+        buildAndSetInjectionScript();
+      }
+    });
+    const messageSub = emitter.addListener("PaywalloWebViewMessage", (event) => {
+      const message = parseWebViewMessage(event.data);
+      if (message) handleParsedMessage(message);
+    });
+    return () => {
+      loadEndSub.remove();
+      messageSub.remove();
+    };
+  }, [buildAndSetInjectionScript, handleParsedMessage]);
+  const handleLoadEnd = useCallback3(() => {
+    if (!loadEndReceived.current) {
+      loadEndReceived.current = true;
+      buildAndSetInjectionScript();
+    }
+  }, [buildAndSetInjectionScript]);
+  const handleMessage = useCallback3(
+    (event) => {
+      const message = parseWebViewMessage(event.nativeEvent.data);
+      if (message) handleParsedMessage(message);
+    },
+    [handleParsedMessage]
+  );
+  useEffect2(() => {
+    if (!paywallDataSent.current) return;
+    setScriptToInject(buildPurchaseStateScript(isPurchasing));
+  }, [isPurchasing]);
+  const paywallUrl = `${webUrl}/paywall/${paywallId}`;
+  return /* @__PURE__ */ jsx(View, { style: styles.container, children: /* @__PURE__ */ jsx(
+    NativeWebView,
+    {
+      sourceUrl: paywallUrl,
+      injectedJavaScript: scriptToInject,
+      onMessage: handleMessage,
+      onLoadEnd: handleLoadEnd,
+      style: styles.webview
+    }
+  ) });
+}
+var styles = StyleSheet.create({
+  container: { flex: 1 },
+  webview: { flex: 1, backgroundColor: "transparent" }
+});
+
+// src/domains/paywall/PaywallModal.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var SCREEN_HEIGHT2 = Dimensions2.get("window").height;
+function PaywallModal({
+  placement,
+  visible,
+  onResult,
+  paywallConfig: preloadedConfig,
+  preloadedProducts,
+  variantKey,
+  campaignId
+}) {
+  const { paywallConfig, products, error } = usePaywallLoader(
+    placement,
+    visible,
+    preloadedConfig,
+    preloadedProducts,
+    variantKey,
+    campaignId
+  );
+  const { isPurchasing, slideAnim, handleClose, handlePurchase, handleRestore } = usePaywallActions(placement, paywallConfig, onResult, variantKey, campaignId);
+  const openAnim = useRef4(new Animated2.Value(SCREEN_HEIGHT2)).current;
+  useEffect3(() => {
+    if (visible) {
+      if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] PaywallModal opening \u2014 starting slide-up animation (550ms)");
+      openAnim.setValue(SCREEN_HEIGHT2);
+      Animated2.timing(openAnim, {
+        toValue: 0,
+        duration: 550,
+        easing: Easing.out(Easing.cubic),
+        useNativeDriver: true
+      }).start(() => {
+        if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] PaywallModal slide-up animation completed");
+      });
+    }
+  }, [visible, openAnim]);
+  if (!visible) return null;
+  return /* @__PURE__ */ jsx2(
+    Modal,
+    {
+      visible,
+      animationType: "none",
+      presentationStyle: "overFullScreen",
+      onRequestClose: handleClose,
+      transparent: true,
+      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(
+          PaywallWebView,
+          {
+            paywallId: paywallConfig.id,
+            craftData: paywallConfig.config.craftData,
+            products,
+            primaryProductId: paywallConfig.primaryProductId,
+            secondaryProductId: paywallConfig.secondaryProductId,
+            isPurchasing,
+            onClose: handleClose,
+            onPurchase: handlePurchase,
+            onRestore: handleRestore
+          }
+        )
+      ] }) }) })
+    }
+  );
+}
+var styles2 = StyleSheet2.create({
+  overlay: {
+    flex: 1,
+    backgroundColor: "rgba(0,0,0,0.3)"
+  },
+  animatedContainer: {
+    flex: 1,
+    backgroundColor: "#fff",
+    borderTopLeftRadius: 0,
+    borderTopRightRadius: 0
+  },
+  container: {
+    flex: 1,
+    backgroundColor: "#fff"
+  },
+  errorContainer: {
+    flex: 1,
+    justifyContent: "center",
+    alignItems: "center",
+    padding: 20
+  },
+  errorText: {
+    fontSize: 16,
+    color: "#ef4444",
+    textAlign: "center"
+  }
+});
+
+// src/domains/paywall/PaywallErrorBoundary.tsx
+import { Component } from "react";
+var PaywallErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch(error) {
+    if (PaywalloClient.getConfig()?.debug) console.warn("[Paywallo] Paywall render error:", error.message);
+  }
+  render() {
+    return this.state.hasError ? null : this.props.children;
+  }
+};
+
+// src/domains/paywall/PaywallContext.ts
+import { createContext, useContext } from "react";
+var PaywallContext = createContext(null);
+function usePaywallContext() {
+  const context = useContext(PaywallContext);
+  if (!context) {
+    throw new PaywallError(
+      PAYWALL_ERROR_CODES.NOT_INITIALIZED,
+      "usePaywallContext must be used within a Paywall component"
+    );
+  }
+  return context;
+}
+
+// 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);
+  const resolverRef = useRef5(null);
+  const presentedAtRef = useRef5(Date.now());
+  useEffect4(() => {
+    return () => {
+      if (resolverRef.current) {
+        resolverRef.current({ presented: false, purchased: false, cancelled: true, restored: false });
+        resolverRef.current = null;
+      }
+    };
+  }, []);
+  const presentPreloadedWebView = useCallback4(() => {
+    return new Promise((resolve) => {
+      resolverRef.current = resolve;
+      presentedAtRef.current = Date.now();
+      setShowingPreloadedWebView(true);
+    });
+  }, []);
+  const resolvePreloadedPaywall = useCallback4((result) => {
+    if (resolverRef.current) {
+      resolverRef.current(result);
+      resolverRef.current = null;
+    }
+  }, []);
+  const handlePreloadedWebViewReady = useCallback4(() => {
+    setPreloadedWebView((prev) => prev ? { ...prev, loaded: true } : null);
+  }, [setPreloadedWebView]);
+  const handlePreloadedClose = useCallback4(() => {
+    const track = async () => {
+      try {
+        const apiClient = PaywalloClient.getApiClient();
+        if (!apiClient || !preloadedWebView) return;
+        const sessionId = PaywalloClient.getSessionId();
+        const durationSeconds = Math.round((Date.now() - presentedAtRef.current) / 1e3);
+        await apiClient.trackEvent("$paywall_dismissed", PaywalloClient.getDistinctId(), {
+          placement: preloadedWebView.placement,
+          paywallId: preloadedWebView.paywallId,
+          durationSeconds,
+          action: "close",
+          ...sessionId && { sessionId },
+          ...preloadedWebView.variantKey && { variantKey: preloadedWebView.variantKey },
+          ...preloadedWebView.campaignId && { campaignId: preloadedWebView.campaignId }
+        });
+      } catch {
+      }
+    };
+    void track();
+    setShowingPreloadedWebView(false);
+    clearPreloadedWebView();
+    resolvePreloadedPaywall({ presented: true, purchased: false, cancelled: true, restored: false });
+  }, [preloadedWebView, clearPreloadedWebView, resolvePreloadedPaywall]);
+  return { showingPreloadedWebView, presentPreloadedWebView, resolvePreloadedPaywall, handlePreloadedWebViewReady, handlePreloadedClose, setShowingPreloadedWebView, presentedAtRef };
+}
+
+// src/domains/affiliate/AffiliateError.ts
+var AffiliateError = class extends PaywalloError {
+  constructor(code, message) {
+    super("affiliate", code, message);
+    this.name = "AffiliateError";
+  }
+};
+var AFFILIATE_ERROR_CODES = {
+  NOT_INITIALIZED: "AFFILIATE_NOT_INITIALIZED",
+  COUPON_REGISTER_FAILED: "AFFILIATE_COUPON_REGISTER_FAILED",
+  COUPON_APPLY_FAILED: "AFFILIATE_COUPON_APPLY_FAILED",
+  BALANCE_FETCH_FAILED: "AFFILIATE_BALANCE_FETCH_FAILED",
+  WITHDRAWAL_FAILED: "AFFILIATE_WITHDRAWAL_FAILED",
+  NETWORK_ERROR: "AFFILIATE_NETWORK_ERROR"
+};
+
+// src/domains/affiliate/affiliateHttp.ts
+function buildQueryString(params) {
+  if (!params) return "";
+  const entries = Object.entries(params).filter(([, v]) => v !== void 0 && v !== null);
+  if (entries.length === 0) return "";
+  return `?${entries.map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`).join("&")}`;
+}
+async function affiliateGet(apiClient, path, params) {
+  const response = await apiClient.get(`${path}${buildQueryString(params)}`);
+  return response.data;
+}
+async function affiliatePost(apiClient, path, body) {
+  const response = await apiClient.post(path, body);
+  return response.data;
+}
+
+// src/domains/affiliate/affiliateDateMappers.ts
+function mapRawCoupon(raw) {
+  return { code: raw.code, status: raw.status, createdAt: new Date(raw.createdAt) };
+}
+function mapRawCommission(raw) {
+  return { ...raw, createdAt: new Date(raw.createdAt) };
+}
+function mapRawWithdrawal(raw) {
+  return { ...raw, createdAt: new Date(raw.createdAt) };
+}
+
+// src/domains/affiliate/AffiliateManager.ts
+var AffiliateManager = class {
+  constructor() {
+    this.apiClient = null;
+    this.debug = false;
+  }
+  initialize(apiClient, debug = false) {
+    this.apiClient = apiClient;
+    this.debug = debug;
+    this.log("AffiliateManager initialized");
+  }
+  async registerCoupon(code) {
+    this.ensureInitialized();
+    const distinctId = identityManager.getDistinctId();
+    try {
+      const response = await this.post("/api/v1/affiliate/register-coupon", {
+        code,
+        distinctId
+      });
+      if (response.success && response.coupon) {
+        this.log("Coupon registered:", code);
+        return { success: true, coupon: mapRawCoupon(response.coupon) };
+      }
+      return {
+        success: false,
+        error: response.error
+      };
+    } catch (error) {
+      this.log("Failed to register coupon:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async applyCoupon(code) {
+    this.ensureInitialized();
+    const distinctId = identityManager.getDistinctId();
+    try {
+      const response = await this.post("/api/v1/affiliate/apply-coupon", {
+        code,
+        distinctId
+      });
+      if (response.success) {
+        this.log("Coupon applied:", code);
+      }
+      return response;
+    } catch (error) {
+      this.log("Failed to apply coupon:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async getMyCoupon() {
+    this.ensureInitialized();
+    const distinctId = identityManager.getDistinctId();
+    try {
+      const response = await this.get("/api/v1/affiliate/my-coupon", { distinctId });
+      if (response.coupon) {
+        return { coupon: mapRawCoupon(response.coupon) };
+      }
+      return { coupon: null };
+    } catch (error) {
+      this.log("Failed to get my coupon:", error);
+      return { coupon: null };
+    }
+  }
+  async getAppliedCoupon() {
+    this.ensureInitialized();
+    const distinctId = identityManager.getDistinctId();
+    try {
+      const response = await this.get("/api/v1/affiliate/applied-coupon", { distinctId });
+      return response;
+    } catch (error) {
+      this.log("Failed to get applied coupon:", error);
+      return { coupon: null };
+    }
+  }
+  async getBalance() {
+    this.ensureInitialized();
+    const distinctId = identityManager.getDistinctId();
+    try {
+      const response = await this.get("/api/v1/affiliate/balance", {
+        distinctId
+      });
+      return response;
+    } catch (error) {
+      this.log("Failed to get balance:", error);
+      return {
+        total: 0,
+        pending: 0,
+        available: 0,
+        withdrawn: 0
+      };
+    }
+  }
+  async getCommissions() {
+    this.ensureInitialized();
+    const distinctId = identityManager.getDistinctId();
+    try {
+      const response = await this.get("/api/v1/affiliate/commissions", { distinctId });
+      return response.commissions.map(mapRawCommission);
+    } catch (error) {
+      this.log("Failed to get commissions:", error);
+      return [];
+    }
+  }
+  async requestWithdrawal(amount) {
+    this.ensureInitialized();
+    const distinctId = identityManager.getDistinctId();
+    try {
+      const response = await this.post("/api/v1/affiliate/withdraw", {
+        amount,
+        distinctId
+      });
+      if (response.success && response.withdrawal) {
+        this.log("Withdrawal requested:", amount);
+        return { success: true, withdrawal: mapRawWithdrawal(response.withdrawal) };
+      }
+      return {
+        success: false,
+        error: response.error
+      };
+    } catch (error) {
+      this.log("Failed to request withdrawal:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  async getWithdrawals() {
+    this.ensureInitialized();
+    const distinctId = identityManager.getDistinctId();
+    try {
+      const response = await this.get("/api/v1/affiliate/withdrawals", { distinctId });
+      return response.withdrawals.map(mapRawWithdrawal);
+    } catch (error) {
+      this.log("Failed to get withdrawals:", error);
+      return [];
+    }
+  }
+  async get(path, params) {
+    this.ensureInitialized();
+    return affiliateGet(this.apiClient, path, params);
+  }
+  async post(path, body) {
+    this.ensureInitialized();
+    return affiliatePost(this.apiClient, path, body);
+  }
+  ensureInitialized() {
+    if (!this.apiClient) {
+      throw new AffiliateError(
+        AFFILIATE_ERROR_CODES.NOT_INITIALIZED,
+        "AffiliateManager not initialized. Call initialize() first"
+      );
+    }
+  }
+  log(...args) {
+    if (this.debug) {
+      console.warn("[AffiliateManager]", ...args);
+    }
+  }
+};
+var affiliateManager = new AffiliateManager();
+
+// src/domains/affiliate/PaywalloAffiliate.ts
+var PaywalloAffiliate = {
+  registerCoupon: (code) => affiliateManager.registerCoupon(code),
+  applyCoupon: (code) => affiliateManager.applyCoupon(code),
+  getMyCoupon: () => affiliateManager.getMyCoupon(),
+  getAppliedCoupon: () => affiliateManager.getAppliedCoupon(),
+  getBalance: () => affiliateManager.getBalance(),
+  getCommissions: () => affiliateManager.getCommissions(),
+  requestWithdrawal: (amount) => affiliateManager.requestWithdrawal(amount),
+  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, debug) {
+  if (debug) console.warn("[Paywallo][API] POST /purchases/validate", { platform, productId, transactionId, priceLocal, currency, country, distinctId, paywallPlacement, variantKey, receiptLen: receipt?.length });
+  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
+  );
+  if (debug) console.warn("[Paywallo][API] Validation response:", JSON.stringify(response.data));
+  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);
+            this.log(`Retrying request (attempt ${state.attempt}/${retryConfig.maxRetries})`, {
+              url,
+              status: response.status,
+              delay
+            });
+            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);
+          this.log(`Network error, retrying (attempt ${state.attempt}/${retryConfig.maxRetries})`, {
+            url,
+            error: state.lastError.message,
+            delay
+          });
+          await this.sleep(delay);
+          continue;
+        }
+        throw state.lastError;
+      }
+    }
+    throw state.lastError ?? new ClientError(CLIENT_ERROR_CODES.UNKNOWN, "Max retries exceeded");
+  }
+  async executeRequest(url, options, timeout) {
+    const controller = new AbortController();
+    let timeoutId = null;
+    let isCompleted = false;
+    timeoutId = setTimeout(() => {
+      if (!isCompleted) {
+        controller.abort();
+      }
+    }, timeout);
+    this.log("Request starting", {
+      url,
+      method: options.method,
+      headers: options.headers
+    });
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      isCompleted = true;
+      let data;
+      const contentType = response.headers.get("content-type");
+      if (contentType?.includes("application/json")) {
+        data = await response.json();
+      } else {
+        const textData = await response.text();
+        this.log("Non-JSON response received", {
+          url,
+          status: response.status,
+          contentType,
+          bodyPreview: textData.substring(0, 200)
+        });
+        data = textData;
+      }
+      this.log("Request completed", {
+        url,
+        status: response.status,
+        ok: response.ok,
+        contentType
+      });
+      const headers = {};
+      response.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      return {
+        ok: response.ok,
+        status: response.status,
+        data,
+        headers
+      };
+    } catch (error) {
+      this.log("Request failed", {
+        url,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    } finally {
+      isCompleted = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+    }
+  }
+  buildUrl(path) {
+    if (path.startsWith("http://") || path.startsWith("https://")) {
+      return path;
+    }
+    return `${this.config.baseUrl}${path}`;
+  }
+  buildFetchOptions(options) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const fetchOptions = {
+      method: options.method,
+      headers
+    };
+    if (options.body !== void 0) {
+      fetchOptions.body = JSON.stringify(options.body);
+    }
+    return fetchOptions;
+  }
+  shouldRetry(status, config) {
+    return config.retryableStatusCodes.includes(status);
+  }
+  isNetworkError(error) {
+    const networkErrorPatterns = [
+      "network",
+      "fetch",
+      "ECONNREFUSED",
+      "ETIMEDOUT",
+      "ENOTFOUND",
+      "aborted",
+      "timeout"
+    ];
+    const message = error.message.toLowerCase();
+    return networkErrorPatterns.some((pattern) => message.includes(pattern.toLowerCase()));
+  }
+  calculateDelay(attempt, config) {
+    const exponentialDelay = config.baseDelay * Math.pow(2, attempt - 1);
+    const jitter = Math.random() * 0.3 * exponentialDelay;
+    return Math.min(exponentialDelay + jitter, config.maxDelay);
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  log(message, data) {
+    if (this.config.debug) {
+      console.warn("[HttpClient]", message, data ?? "");
+    }
+  }
+  setDebug(debug) {
+    this.config.debug = debug;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/core/network/NetworkMonitor.ts
+import { AppState } from "react-native";
+
+// src/core/network/types.ts
+var DEFAULT_NETWORK_CONFIG = {
+  debug: false,
+  checkInterval: 3e4,
+  checkUrl: "https://clients3.google.com/generate_204"
+};
+
+// src/core/network/NetworkMonitor.ts
+var NetworkMonitorClass = class {
+  constructor() {
+    this.config = DEFAULT_NETWORK_CONFIG;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.currentState = "unknown";
+    this.netInfoModule = null;
+    this.netInfoSubscription = null;
+    this.appStateSubscription = null;
+    this.initialized = false;
+    this.checkIntervalId = null;
+  }
+  async initialize(config) {
+    if (this.initialized) {
+      return;
+    }
+    this.config = { ...DEFAULT_NETWORK_CONFIG, ...config };
+    this.currentState = "unknown";
+    this.initialized = true;
+    this.log("Initialized (state: unknown, awaiting first connectivity check)");
+    void this.setupFallbackDetection();
+    this.setupAppStateListener();
+  }
+  setupNetInfoListener() {
+    if (!this.netInfoModule) return;
+    this.netInfoSubscription = this.netInfoModule.addEventListener((state) => {
+      const newState = this.netInfoStateToNetworkState(state);
+      this.updateState(newState);
+    });
+  }
+  async setupFallbackDetection() {
+    await this.checkConnectivity();
+    this.checkIntervalId = setInterval(() => {
+      void this.checkConnectivity();
+    }, this.config.checkInterval);
+  }
+  setupAppStateListener() {
+    this.appStateSubscription = AppState.addEventListener("change", (state) => {
+      if (state === "active") {
+        void this.checkConnectivity();
+      }
+    });
+  }
+  async checkConnectivity() {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 5e3);
+      const response = await fetch(this.config.checkUrl, {
+        method: "HEAD",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      this.updateState(response.ok ? "online" : "offline");
+    } catch {
+      this.updateState("offline");
+    }
+  }
+  netInfoStateToNetworkState(state) {
+    if (state.isConnected === null) {
+      return "unknown";
+    }
+    if (!state.isConnected) {
+      return "offline";
+    }
+    return "online";
+  }
+  updateState(newState) {
+    const previousState = this.currentState;
+    if (previousState === newState) {
+      return;
+    }
+    this.currentState = newState;
+    this.log("Network state changed", { from: previousState, to: newState });
+    this.notifyListeners(newState);
+  }
+  notifyListeners(state) {
+    for (const listener of this.listeners) {
+      try {
+        listener(state);
+      } catch (error) {
+        this.log("Listener error", error);
+      }
+    }
+  }
+  isOnline() {
+    if (!this.initialized || this.currentState === "unknown") {
+      return true;
+    }
+    return this.currentState === "online";
+  }
+  getState() {
+    return this.currentState;
+  }
+  isInitialized() {
+    return this.initialized;
+  }
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  removeListener(listener) {
+    this.listeners.delete(listener);
+  }
+  async forceCheck() {
+    await this.checkConnectivity();
+    return this.currentState;
+  }
+  dispose() {
+    if (this.netInfoSubscription) {
+      this.netInfoSubscription();
+      this.netInfoSubscription = null;
+    }
+    if (this.appStateSubscription) {
+      this.appStateSubscription.remove();
+      this.appStateSubscription = null;
+    }
+    if (this.checkIntervalId) {
+      clearInterval(this.checkIntervalId);
+      this.checkIntervalId = null;
+    }
+    this.listeners.clear();
+    this.initialized = false;
+    this.currentState = "unknown";
+  }
+  log(message, data) {
+    if (this.config.debug) {
+      console.warn("[NetworkMonitor]", message, data ?? "");
+    }
+  }
+  setDebug(debug) {
+    this.config.debug = debug;
+  }
+};
+var networkMonitor = new NetworkMonitorClass();
+
+// src/core/queue/OfflineQueue.ts
+import AsyncStorage2 from "@react-native-async-storage/async-storage";
+
+// src/core/queue/deduplication.ts
+function normalizeForComparison(obj) {
+  if (obj === null || obj === void 0) {
+    return String(obj);
+  }
+  if (typeof obj !== "object") {
+    return JSON.stringify(obj);
+  }
+  if (Array.isArray(obj)) {
+    return "[" + obj.map((item) => normalizeForComparison(item)).join(",") + "]";
+  }
+  const sortedKeys = Object.keys(obj).sort();
+  const pairs = sortedKeys.map((key) => {
+    const value = obj[key];
+    return `${JSON.stringify(key)}:${normalizeForComparison(value)}`;
+  });
+  return "{" + pairs.join(",") + "}";
+}
+function findDuplicateIndex(queue, item) {
+  const normalizedBody = normalizeForComparison(item.body);
+  return queue.findIndex(
+    (existing) => existing.url === item.url && normalizeForComparison(existing.body) === normalizedBody
+  );
+}
+
+// src/core/queue/types.ts
+var DEFAULT_QUEUE_CONFIG = {
+  maxItems: 100,
+  maxAge: 24 * 60 * 60 * 1e3,
+  maxAttempts: 3,
+  storageKey: "@paywallo:offline_queue",
+  debug: false
+};
+
+// src/core/queue/OfflineQueue.ts
+var OfflineQueueClass = class {
+  constructor() {
+    this.config = DEFAULT_QUEUE_CONFIG;
+    this.queue = [];
+    this.listeners = /* @__PURE__ */ new Set();
+    this.initialized = false;
+    this.processing = false;
+    this.processingLock = false;
+    this.cleanupTimer = null;
+  }
+  async initialize(config) {
+    if (this.initialized) {
+      return;
+    }
+    this.config = { ...DEFAULT_QUEUE_CONFIG, ...config };
+    await this.loadFromStorage();
+    this.cleanupExpired();
+    this.cleanupTimer = setInterval(() => this.cleanupExpired(), 60 * 60 * 1e3);
+    this.initialized = true;
+    this.log("OfflineQueue initialized", { queueSize: this.queue.length });
+  }
+  async loadFromStorage() {
+    try {
+      const stored = await AsyncStorage2.getItem(this.config.storageKey);
+      if (stored) {
+        this.queue = JSON.parse(stored);
+      }
+    } catch {
+      this.queue = [];
+    }
+  }
+  async saveToStorage() {
+    try {
+      await AsyncStorage2.setItem(this.config.storageKey, JSON.stringify(this.queue));
+      return true;
+    } catch (error) {
+      this.log("Failed to save queue to storage", error);
+      this.emit({
+        type: "item:failed",
+        error: new ClientError(CLIENT_ERROR_CODES.UNKNOWN, "Storage save failed - items may be lost on restart"),
+        queueSize: this.queue.length
+      });
+      return false;
+    }
+  }
+  cleanupExpired() {
+    const now = Date.now();
+    const before = this.queue.length;
+    this.queue = this.queue.filter((item) => Date.now() - item.timestamp < this.config.maxAge);
+    if (before !== this.queue.length) {
+      this.log("Cleaned up expired items", { removed: before - this.queue.length });
+      void this.saveToStorage();
+    }
+  }
+  async enqueue(method, url, body, headers) {
+    const item = {
+      id: generateUUID(),
+      method,
+      url,
+      body,
+      headers,
+      timestamp: Date.now(),
+      attempts: 0,
+      maxAttempts: this.config.maxAttempts
+    };
+    const existingIndex = this.findDuplicateIndex(item);
+    if (existingIndex !== -1) {
+      this.log("Duplicate item found, updating timestamp", { id: this.queue[existingIndex].id });
+      this.queue[existingIndex].timestamp = Date.now();
+      await this.saveToStorage();
+      return this.queue[existingIndex];
+    }
+    if (this.queue.length >= this.config.maxItems) {
+      const removed = this.queue.shift();
+      if (removed) {
+        this.log("Queue full, evicted oldest item:", removed.url);
+        this.emit({ type: "item:evicted", item: removed, queueSize: this.queue.length });
+      }
+    }
+    this.queue.push(item);
+    await this.saveToStorage();
+    this.emit({ type: "item:added", item, queueSize: this.queue.length });
+    this.log("Item enqueued", { id: item.id, url: item.url });
+    return item;
+  }
+  findDuplicateIndex(item) {
+    return findDuplicateIndex(this.queue, item);
+  }
+  async dequeue() {
+    const item = this.queue.shift() ?? null;
+    if (item) {
+      await this.saveToStorage();
+      this.emit({ type: "item:removed", item, queueSize: this.queue.length });
+    }
+    return item;
+  }
+  async removeItem(id) {
+    const index = this.queue.findIndex((item2) => item2.id === id);
+    if (index === -1) return false;
+    const [item] = this.queue.splice(index, 1);
+    await this.saveToStorage();
+    this.emit({ type: "item:removed", item, queueSize: this.queue.length });
+    return true;
+  }
+  async processQueue(processor, options) {
+    if (this.processingLock || this.queue.length === 0) {
+      return { processed: 0, failed: 0 };
+    }
+    this.processingLock = true;
+    this.processing = true;
+    this.emit({ type: "processing:start", queueSize: this.queue.length });
+    this.log("Processing queue", { items: this.queue.length });
+    let processed = 0;
+    let failed = 0;
+    const delayMs = options?.delayBetweenItems ?? 100;
+    const itemIds = this.queue.map((item) => item.id);
+    for (let i = 0; i < itemIds.length; i++) {
+      const item = this.queue.find((q) => q.id === itemIds[i]);
+      if (!item) continue;
+      item.attempts++;
+      try {
+        const result = await processor(item);
+        const success = typeof result === "boolean" ? result : result.success;
+        const permanent = typeof result === "object" ? result.permanent ?? false : false;
+        if (success) {
+          await this.removeItem(item.id);
+          processed++;
+          this.emit({ type: "item:success", item, queueSize: this.queue.length });
+          this.log("Item processed successfully", { id: item.id });
+        } else {
+          const didFail = await this.handleItemFailure(item, void 0, permanent);
+          if (didFail) failed++;
+        }
+      } catch (error) {
+        const err = error instanceof Error ? error : new ClientError(CLIENT_ERROR_CODES.UNKNOWN, String(error));
+        const didFail = await this.handleItemFailure(item, err, false);
+        if (didFail) failed++;
+      }
+      if (i < itemIds.length - 1 && delayMs > 0) await this.sleep(delayMs);
+    }
+    this.processing = false;
+    this.processingLock = false;
+    this.emit({ type: "processing:end", queueSize: this.queue.length });
+    this.log("Queue processing complete", { processed, failed, remaining: 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);
+      this.emit({
+        type: "item:failed",
+        item,
+        error: error ?? new ClientError(CLIENT_ERROR_CODES.UNKNOWN, permanent ? "Permanent failure" : "Max attempts reached"),
+        queueSize: this.queue.length
+      });
+      this.log(
+        permanent ? "Item failed permanently - removed" : "Item failed after max attempts",
+        { id: item.id, attempts: item.attempts }
+      );
+      return true;
+    }
+    await this.saveToStorage();
+    this.log("Item will be retried", { id: item.id, attempts: item.attempts });
+    return false;
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  getQueue() {
+    return [...this.queue];
+  }
+  getSize() {
+    return this.queue.length;
+  }
+  isEmpty() {
+    return this.queue.length === 0;
+  }
+  isProcessing() {
+    return this.processing;
+  }
+  async clear() {
+    this.queue = [];
+    await this.saveToStorage();
+    this.log("Queue cleared");
+  }
+  async clearItemsWithInvalidAppKey(validAppKey) {
+    const before = this.queue.length;
+    this.queue = this.queue.filter((item) => {
+      const itemAppKey = item.headers?.["X-App-Key"];
+      return itemAppKey === validAppKey || !itemAppKey;
+    });
+    const removed = before - this.queue.length;
+    if (removed > 0) {
+      await this.saveToStorage();
+      this.log("Cleared items with invalid app key", { removed, validAppKey });
+    }
+    return removed;
+  }
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  removeListener(listener) {
+    this.listeners.delete(listener);
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        this.log("Listener error", error);
+      }
+    }
+  }
+  log(message, data) {
+    if (this.config.debug) {
+      console.warn("[OfflineQueue]", message, data ?? "");
+    }
+  }
+  setDebug(debug) {
+    this.config.debug = debug;
+  }
+  dispose() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+    this.listeners.clear();
+    this.queue = [];
+    this.initialized = false;
+    this.processing = false;
+    this.processingLock = false;
+  }
+};
+var offlineQueue = new OfflineQueueClass();
+
+// src/core/queue/QueueProcessor.ts
+var DEFAULT_PROCESSOR_CONFIG = {
+  debounceMs: 2e3,
+  debug: false
+};
+var QueueProcessorClass = class {
+  constructor() {
+    this.config = DEFAULT_PROCESSOR_CONFIG;
+    this.httpClient = null;
+    this.networkUnsubscribe = null;
+    this.debounceTimeout = null;
+    this.retryIntervalId = null;
+    this.initialized = false;
+  }
+  initialize(httpClient, config) {
+    if (this.initialized) {
+      return;
+    }
+    this.httpClient = httpClient;
+    this.config = { ...DEFAULT_PROCESSOR_CONFIG, ...config };
+    this.networkUnsubscribe = networkMonitor.addListener((state) => {
+      if (state === "online") {
+        this.scheduleProcessing();
+      }
+    });
+    if (networkMonitor.isOnline() && !offlineQueue.isEmpty()) {
+      this.scheduleProcessing();
+    }
+    this.retryIntervalId = setInterval(() => {
+      if (networkMonitor.isOnline() && !offlineQueue.isEmpty()) {
+        this.scheduleProcessing();
+      }
+    }, 6e4);
+    this.initialized = true;
+    this.log("QueueProcessor initialized");
+  }
+  scheduleProcessing() {
+    if (this.debounceTimeout) {
+      clearTimeout(this.debounceTimeout);
+    }
+    this.debounceTimeout = setTimeout(() => {
+      void this.processQueue();
+    }, this.config.debounceMs);
+  }
+  async processQueue() {
+    if (!this.httpClient) {
+      this.log("HttpClient not initialized");
+      return { processed: 0, failed: 0 };
+    }
+    if (!networkMonitor.isOnline()) {
+      this.log("Offline, skipping queue processing");
+      return { processed: 0, failed: 0 };
+    }
+    return offlineQueue.processQueue(async (item) => {
+      return this.processItem(item);
+    });
+  }
+  async processItem(item) {
+    if (!this.httpClient) {
+      return { success: false, permanent: false };
+    }
+    this.log("Processing queue item", {
+      id: item.id,
+      url: item.url,
+      method: item.method,
+      headers: item.headers,
+      attempts: item.attempts
+    });
+    const response = await this.httpClient.request(item.url, {
+      method: item.method,
+      body: item.body,
+      headers: item.headers,
+      skipRetry: false
+    });
+    if (response.ok) {
+      this.log("Queue item processed successfully", { id: item.id });
+      return { success: true, permanent: false };
+    }
+    if (response.status >= 400 && response.status < 500) {
+      this.log("Request failed with permanent client error - removing from queue", {
+        id: item.id,
+        url: item.url,
+        status: response.status,
+        appKeyInHeaders: item.headers?.["X-App-Key"]
+      });
+      return { success: false, permanent: true, status: response.status };
+    }
+    this.log("Request failed with server error - will retry", {
+      id: item.id,
+      status: response.status
+    });
+    return { success: false, permanent: false, status: response.status };
+  }
+  async enqueueIfOffline(method, url, body, headers) {
+    if (networkMonitor.isOnline()) {
+      return { queued: false };
+    }
+    const item = await offlineQueue.enqueue(method, url, body, headers);
+    this.log("Request queued for offline", { id: item.id, url });
+    return { queued: true, item };
+  }
+  getQueueSize() {
+    return offlineQueue.getSize();
+  }
+  async clearQueue() {
+    await offlineQueue.clear();
+  }
+  dispose() {
+    if (this.debounceTimeout) {
+      clearTimeout(this.debounceTimeout);
+      this.debounceTimeout = null;
+    }
+    if (this.retryIntervalId) {
+      clearInterval(this.retryIntervalId);
+      this.retryIntervalId = null;
+    }
+    if (this.networkUnsubscribe) {
+      this.networkUnsubscribe();
+      this.networkUnsubscribe = null;
+    }
+    this.httpClient = null;
+    this.initialized = false;
+  }
+  log(message, data) {
+    if (this.config.debug) {
+      console.warn("[QueueProcessor]", message, data ?? "");
+    }
+  }
+  setDebug(debug) {
+    this.config.debug = debug;
+  }
+};
+var queueProcessor = new QueueProcessorClass();
+
+// src/core/ApiCache.ts
+var ApiCache = class {
+  constructor() {
+    this.CACHE_TTL = 3e5;
+    // 5 minutes
+    this.MAX_SIZE = 200;
+    this.variantCache = /* @__PURE__ */ new Map();
+    this.paywallCache = /* @__PURE__ */ new Map();
+    this.campaignCache = /* @__PURE__ */ new Map();
+  }
+  getCached(cache, key) {
+    const entry = cache.get(key);
+    if (!entry) return void 0;
+    if (Date.now() - entry.ts < this.CACHE_TTL) return entry.value;
+    cache.delete(key);
+    return void 0;
+  }
+  setCached(cache, key, value) {
+    cache.set(key, { value, ts: Date.now() });
+  }
+  evictExpiredEntries(cache) {
+    if (cache.size <= this.MAX_SIZE) return;
+    const now = Date.now();
+    for (const [key, entry] of cache) {
+      if (now - entry.ts > this.CACHE_TTL) cache.delete(key);
+    }
+  }
+  getVariant(key) {
+    return this.getCached(this.variantCache, key);
+  }
+  setVariant(key, value) {
+    this.setCached(this.variantCache, key, value);
+    this.evictExpiredEntries(this.variantCache);
+  }
+  getStaleVariant(key) {
+    const entry = this.variantCache.get(key);
+    if (entry && Date.now() - entry.ts < 864e5) return entry.value;
+    return void 0;
+  }
+  getPaywall(key) {
+    return this.getCached(this.paywallCache, key);
+  }
+  setPaywall(key, value) {
+    this.setCached(this.paywallCache, key, value);
+    this.evictExpiredEntries(this.paywallCache);
+  }
+  getStalePaywall(key) {
+    const entry = this.paywallCache.get(key);
+    if (entry && Date.now() - entry.ts < 864e5) return entry.value;
+    return void 0;
+  }
+  getCampaign(key) {
+    return this.getCached(this.campaignCache, key);
+  }
+  setCampaign(key, value) {
+    this.setCached(this.campaignCache, key, value);
+    this.evictExpiredEntries(this.campaignCache);
+  }
+  getStaleCampaign(key) {
+    const entry = this.campaignCache.get(key);
+    if (entry && Date.now() - entry.ts < 864e5) return entry.value;
+    return void 0;
+  }
+};
+
+// src/core/ApiClient.ts
+var SDK_VERSION = "1.0.0";
+var DEFAULT_BASE_URL = "https://panel.lucasqueiroga.shop";
+var ApiClient = class {
+  constructor(appKey, baseUrl, debug = false, environment = "Production", offlineQueueEnabled = true, timeout = 3e4) {
+    this.cache = new ApiCache();
+    this.appKey = appKey;
+    this.baseUrl = baseUrl ?? DEFAULT_BASE_URL;
+    this.webUrl = deriveWebUrl(this.baseUrl);
+    this.debug = debug;
+    this.environment = environment;
+    this.offlineQueueEnabled = offlineQueueEnabled;
+    this.httpClient = new HttpClient(this.baseUrl, { timeout, debug });
+    this.log("ApiClient initialized", { baseUrl: this.baseUrl, environment, offlineQueueEnabled });
+  }
+  // ─── Infrastructure ──────────────────────────────────────────────────────────
+  /** Exposed only for QueueProcessor initialization. Prefer get()/post() for requests. */
+  getHttpClient() {
+    return this.httpClient;
+  }
+  getWebUrl() {
+    return this.webUrl;
+  }
+  getEnvironment() {
+    return this.environment;
+  }
+  getQueueSize() {
+    return offlineQueue.getSize();
+  }
+  setofflineQueueEnabled(enabled) {
+    this.offlineQueueEnabled = enabled;
+  }
+  isofflineQueueEnabled() {
+    return this.offlineQueueEnabled;
+  }
+  setEnvironment(environment) {
+    this.environment = environment;
+    this.log("Environment set to:", environment);
+  }
+  setDebug(debug) {
+    this.debug = debug;
+    this.httpClient.setDebug(debug);
+  }
+  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 } });
+  }
+  async post(path, body, skipRetry = false) {
+    return this.httpClient.post(path, body, { headers: { "X-App-Key": this.appKey }, skipRetry });
+  }
+  async reportError(errorType, message, context) {
+    try {
+      await this.post("/api/v1/sdk/errors", {
+        errorType,
+        message,
+        context,
+        sdkVersion: SDK_VERSION,
+        platform: Platform3.OS
+      }, true);
+    } catch {
+    }
+  }
+  // ─── Business methods ────────────────────────────────────────────────────────
+  async trackEvent(eventName, distinctId, properties, timestamp) {
+    this.log("Tracking event:", eventName);
+    await this.postWithQueue("/api/v1/events", {
+      eventName,
+      distinctId,
+      properties: { ...properties, platform: Platform3.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");
+    this.log("Identity updated:", distinctId);
+  }
+  async startSession(distinctId, sessionId, platform) {
+    await this.postWithQueue("/api/v1/sessions/start", {
+      distinctId,
+      sessionId,
+      platform: platform ?? Platform3.OS,
+      environment: this.environment.toLowerCase()
+    }, `session.start:${sessionId}`);
+    this.log("Session started:", sessionId);
+    return { success: true };
+  }
+  async endSession(sessionId, durationSeconds) {
+    await this.postWithQueue("/api/v1/sessions/end", { sessionId, durationSeconds }, `session.end:${sessionId}`);
+    this.log("Session ended:", sessionId);
+    return { success: true };
+  }
+  async getVariant(flagKey, distinctId) {
+    const key = `${flagKey}:${distinctId}`;
+    const hit = this.cache.getVariant(key);
+    if (hit !== void 0) return hit;
+    try {
+      const url = new URL(`${this.baseUrl}/api/v1/flags/${flagKey}`);
+      url.searchParams.set("distinctId", distinctId);
+      const res = await this.get(url.toString());
+      if (res.status === 404) {
+        const v = { variant: null };
+        this.cache.setVariant(key, v);
+        return v;
+      }
+      this.log("Got variant:", flagKey, res.data);
+      this.cache.setVariant(key, res.data);
+      return res.data;
+    } catch (error) {
+      this.log("Failed to get variant:", flagKey, error);
+      const stale = this.cache.getStaleVariant(key);
+      if (stale !== void 0) return stale;
+      return { variant: null };
+    }
+  }
+  async getPaywall(placement) {
+    const hit = this.cache.getPaywall(placement);
+    if (hit !== void 0) return hit;
+    try {
+      const res = await this.get(`/api/v1/paywalls/${placement}`);
+      if (res.status === 404) {
+        this.cache.setPaywall(placement, null);
+        return null;
+      }
+      this.log("Got paywall:", placement);
+      this.cache.setPaywall(placement, res.data);
+      return res.data;
+    } catch (error) {
+      this.log("Failed to get paywall:", placement, error);
+      const stale = this.cache.getStalePaywall(placement);
+      if (stale !== void 0) return stale;
+      return null;
+    }
+  }
+  async getEmergencyPaywall() {
+    const result = await getEmergencyPaywall(this);
+    this.log("Got emergency paywall:", result.enabled);
+    return result;
+  }
+  async getCampaign(placement, distinctId, context) {
+    const key = `${placement}:${distinctId}`;
+    const hit = this.cache.getCampaign(key);
+    if (hit !== void 0) return hit;
+    try {
+      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);
+        return null;
+      }
+      this.log("Got campaign:", placement, result.variantKey);
+      this.cache.setCampaign(key, result);
+      return result;
+    } catch (error) {
+      this.log("Failed to get campaign:", placement, error);
+      const stale = this.cache.getStaleCampaign(key);
+      if (stale !== void 0) return stale;
+      return null;
+    }
+  }
+  async validatePurchase(platform, receipt, productId, transactionId, priceLocal, currency, country, distinctId, paywallPlacement, variantKey) {
+    const result = await validatePurchase(
+      this,
+      this.appKey,
+      platform,
+      receipt,
+      productId,
+      transactionId,
+      priceLocal,
+      currency,
+      country,
+      distinctId,
+      paywallPlacement,
+      variantKey,
+      this.debug
+    );
+    this.log("Purchase validated:", result.success);
+    return result;
+  }
+  async getSubscriptionStatus(distinctId) {
+    const result = await getSubscriptionStatus(this, this.baseUrl, this.appKey, distinctId);
+    this.log("Subscription status:", result.hasActiveSubscription);
+    return result;
+  }
+  async getConditionalFlag(flagKey, context) {
+    try {
+      const url = buildConditionalFlagUrl(this.baseUrl, flagKey, context);
+      const response = await this.get(url);
+      if (response.status === 404) return { value: false, flagKey };
+      this.log("Got conditional flag:", flagKey, response.data.value);
+      return { value: response.data.value, flagKey };
+    } catch {
+      this.log("Failed to get conditional flag:", flagKey);
+      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 postWithQueue(url, payload, label) {
+    if (this.offlineQueueEnabled && !networkMonitor.isOnline()) {
+      await offlineQueue.enqueue("POST", url, payload, { "X-App-Key": this.appKey });
+      this.log("Queued for offline:", label);
+      return;
+    }
+    try {
+      await this.post(url, payload);
+    } catch (error) {
+      this.log("Request failed:", label, error);
+      if (this.offlineQueueEnabled) {
+        await offlineQueue.enqueue("POST", url, payload, { "X-App-Key": this.appKey });
+        this.log("Queued after failure:", label);
+        return;
+      }
+      throw error;
+    }
+  }
+  log(...args) {
+    if (this.debug) console.warn("[Panel API]", ...args);
+  }
+};
+
+// src/domains/campaign/CampaignError.ts
+var CampaignError = class extends PaywalloError {
+  constructor(code, message) {
+    super("campaign", code, message);
+    this.name = "CampaignError";
+  }
+};
+var CAMPAIGN_ERROR_CODES = {
+  NOT_INITIALIZED: "CAMPAIGN_NOT_INITIALIZED",
+  FETCH_FAILED: "CAMPAIGN_FETCH_FAILED",
+  PRELOAD_FAILED: "CAMPAIGN_PRELOAD_FAILED",
+  NOT_FOUND: "CAMPAIGN_NOT_FOUND",
+  PRESENT_FAILED: "CAMPAIGN_PRESENT_FAILED"
+};
+
+// src/domains/campaign/CampaignGateService.ts
+var PRELOAD_CACHE_TTL_MS = 5 * 60 * 1e3;
+var CampaignGateService = class {
+  constructor() {
+    this.preloadedCampaigns = /* @__PURE__ */ new Map();
+  }
+  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);
+    if (!campaign) {
+      return { presented: false, purchased: false, cancelled: false, restored: false, error: new CampaignError(CAMPAIGN_ERROR_CODES.NOT_FOUND, "No campaign found") };
+    }
+    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);
+    return r.purchased || r.restored;
+  }
+  async preloadCampaign(apiClient, placement, context) {
+    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() });
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error : new PaywalloError("panel", "PANEL_UNKNOWN", String(error)) };
+    }
+  }
+  getPreloadedCampaign(placement) {
+    const cached = this.preloadedCampaigns.get(placement);
+    if (!cached) return null;
+    if (Date.now() - cached.preloadedAt >= PRELOAD_CACHE_TTL_MS) {
+      this.preloadedCampaigns.delete(placement);
+      return null;
+    }
+    return cached.campaign;
+  }
+  clearPreloaded() {
+    this.preloadedCampaigns.clear();
+  }
+};
+var campaignGateService = new CampaignGateService();
+
+// src/domains/identity/AdvertisingIdManager.ts
+import { Platform as Platform4 } from "react-native";
+var ZERO_IDFA = "00000000-0000-0000-0000-000000000000";
+var AdvertisingIdManager = class {
+  constructor() {
+    this.cached = null;
+  }
+  async collect(requestATT = false) {
+    if (this.cached) return this.cached;
+    const fallback = { idfv: null, idfa: null, gaid: null, attStatus: "unavailable" };
+    try {
+      const tracking = await import("expo-tracking-transparency");
+      if (Platform4.OS === "ios") {
+        if (!tracking.isAvailable()) {
+          const idfv2 = await this.collectIdfv();
+          this.cached = { ...fallback, idfv: idfv2 };
+          return this.cached;
+        }
+        const current = await tracking.getTrackingPermissionsAsync();
+        let status = current.status;
+        let granted = current.granted;
+        if (status === "undetermined" && requestATT) {
+          const result = await tracking.requestTrackingPermissionsAsync();
+          status = result.status;
+          granted = result.granted;
+        }
+        const idfv = await this.collectIdfv();
+        const idfa = granted ? this.sanitizeId(tracking.getAdvertisingId()) : null;
+        this.cached = { idfv, idfa, gaid: null, attStatus: status };
+        return this.cached;
+      }
+      if (Platform4.OS === "android") {
+        const androidStatus = await tracking.getTrackingPermissionsAsync();
+        const optedIn = androidStatus.granted;
+        const rawGaid = optedIn ? tracking.getAdvertisingId() : null;
+        const gaid = this.sanitizeId(rawGaid);
+        this.cached = { idfv: null, idfa: null, gaid, attStatus: "unavailable" };
+        return this.cached;
+      }
+      this.cached = fallback;
+      return this.cached;
+    } catch {
+      this.cached = fallback;
+      return this.cached;
+    }
+  }
+  async collectIdfv() {
+    try {
+      const app = await import("expo-application");
+      const idfv = await app.getIosIdForVendorAsync();
+      return this.sanitizeId(idfv);
+    } catch {
+      return null;
+    }
+  }
+  sanitizeId(id) {
+    if (!id || id === ZERO_IDFA) return null;
+    return id;
+  }
+};
+
+// src/domains/identity/FacebookIdManager.ts
+var TIMEOUT_MS = 2e3;
+var FacebookIdManager = class {
+  async getAnonId() {
+    try {
+      let timerId;
+      const timeoutPromise = new Promise((resolve) => {
+        timerId = setTimeout(() => resolve(null), TIMEOUT_MS);
+      });
+      const result = await Promise.race([this.fetchAnonId(), timeoutPromise]);
+      clearTimeout(timerId);
+      return result;
+    } catch {
+      return null;
+    }
+  }
+  async fetchAnonId() {
+    try {
+      const fbsdk = await import("react-native-fbsdk-next");
+      const anonId = await fbsdk.AppEventsLogger.getAnonymousID();
+      return anonId || null;
+    } catch {
+      return null;
+    }
+  }
+};
+var facebookIdManager = new FacebookIdManager();
+
+// src/domains/identity/InstallTracker.ts
+import { Dimensions as Dimensions3, Platform as Platform6 } from "react-native";
+
+// src/domains/identity/InstallReferrerManager.ts
+import { Platform as Platform5 } from "react-native";
+var REFERRER_TIMEOUT_MS = 5e3;
+var InstallReferrerManager = class {
+  async getReferrer() {
+    if (Platform5.OS !== "android") {
+      return this.emptyResult();
+    }
+    let timerId;
+    const timeoutPromise = new Promise((resolve) => {
+      timerId = setTimeout(() => resolve(this.emptyResult()), REFERRER_TIMEOUT_MS);
+    });
+    const fetchPromise = this.fetchReferrer();
+    const result = await Promise.race([fetchPromise, timeoutPromise]);
+    clearTimeout(timerId);
+    return result;
+  }
+  async fetchReferrer() {
+    try {
+      const Application = await import("expo-application");
+      const referrer = await Application.getInstallReferrerAsync();
+      if (!referrer) return this.emptyResult();
+      const capped = referrer.slice(0, 2048);
+      const params = this.parseReferrer(capped);
+      return {
+        rawReferrer: capped,
+        trackingId: params["tracking_id"] || null,
+        fbclid: params["fbclid"] || null,
+        utmSource: params["utm_source"] || null,
+        utmMedium: params["utm_medium"] || null,
+        utmCampaign: params["utm_campaign"] || null
+      };
+    } catch {
+      return this.emptyResult();
+    }
+  }
+  parseReferrer(referrer) {
+    const result = {};
+    for (const pair of referrer.split("&")) {
+      const eqIndex = pair.indexOf("=");
+      if (eqIndex === -1) continue;
+      try {
+        const key = decodeURIComponent(pair.slice(0, eqIndex).replace(/\+/g, " "));
+        const raw = pair.slice(eqIndex + 1).replace(/\+/g, " ");
+        const value = decodeURIComponent(raw);
+        if (key) result[key] = value;
+      } catch {
+      }
+    }
+    return result;
+  }
+  emptyResult() {
+    return {
+      rawReferrer: null,
+      trackingId: null,
+      fbclid: null,
+      utmSource: null,
+      utmMedium: null,
+      utmCampaign: null
+    };
+  }
+};
+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();
+  await apiClient.trackEvent("$session_start", distinctId, {
+    sessionId,
+    timestamp: sessionStartedAt?.toISOString() ?? null
+  }).catch(() => {
+  });
+}
+async function trackSessionEnd(apiClient, sessionId, durationSeconds, sessionStartedAt) {
+  const distinctId = identityManager.getDistinctId();
+  await apiClient.trackEvent("$session_end", distinctId, {
+    sessionId,
+    durationSeconds,
+    startedAt: sessionStartedAt?.toISOString() ?? null,
+    endedAt: (/* @__PURE__ */ new Date()).toISOString()
+  }).catch(() => {
+  });
+}
+async function trackAppOpen(apiClient, sessionId) {
+  const distinctId = identityManager.getDistinctId();
+  await apiClient.trackEvent("$app_open", distinctId, {
+    sessionId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  }).catch(() => {
+  });
+}
+async function trackAppBackground(apiClient, sessionId, durationSeconds) {
+  const distinctId = identityManager.getDistinctId();
+  await apiClient.trackEvent("$app_background", distinctId, {
+    sessionId,
+    durationSeconds,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  }).catch(() => {
+  });
+}
+
+// src/domains/session/SessionManager.ts
+var SESSION_ID_KEY = "current_session_id";
+var SESSION_START_KEY = "session_start";
+var EMERGENCY_PAYWALL_SHOWN_KEY = "emergency_paywall_shown";
+var SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+var SessionManager = class {
+  constructor() {
+    this.sessionId = null;
+    this.sessionStartedAt = null;
+    this.appState = "active";
+    this.apiClient = null;
+    this.debug = false;
+    this.initialized = false;
+    this.config = {};
+    this.backgroundTimestamp = null;
+    this.appStateSubscription = null;
+    this.emergencyPaywallHandler = null;
+    this.emergencyPaywallShownInSession = false;
+    this.secureStorage = null;
+    this.handleAppStateChange = async (nextAppState) => {
+      const previousState = this.appState;
+      this.appState = nextAppState;
+      if (nextAppState === "active" && previousState !== "active") {
+        await this.handleForeground();
+      } else if (nextAppState === "background" && previousState === "active") {
+        await this.handleBackground();
+      }
+    };
+  }
+  async initialize(apiClient, config = {}, debug = false) {
+    if (this.initialized) {
+      return;
+    }
+    this.apiClient = apiClient;
+    this.debug = debug;
+    this.secureStorage = new SecureStorage(debug);
+    this.config = {
+      sessionTimeoutMs: config.sessionTimeoutMs ?? SESSION_TIMEOUT_MS,
+      trackAppState: config.trackAppState ?? true
+    };
+    await this.restoreSession();
+    if (this.config.trackAppState) {
+      this.setupAppStateListener();
+    }
+    this.initialized = true;
+    this.log("SessionManager initialized");
+  }
+  async startSession() {
+    this.ensureInitialized();
+    if (this.sessionId) {
+      await this.endSession();
+    }
+    this.sessionId = generateUUID();
+    this.sessionStartedAt = /* @__PURE__ */ new Date();
+    this.emergencyPaywallShownInSession = false;
+    await Promise.all([
+      this.secureStorage.set(SESSION_ID_KEY, this.sessionId),
+      this.secureStorage.set(SESSION_START_KEY, this.sessionStartedAt.toISOString()),
+      this.secureStorage.remove(EMERGENCY_PAYWALL_SHOWN_KEY)
+    ]);
+    await this.trackSessionStart();
+    this.log("Session started:", this.sessionId);
+    return this.sessionId;
+  }
+  async endSession() {
+    this.ensureInitialized();
+    if (!this.sessionId || !this.sessionStartedAt) {
+      return;
+    }
+    await this.trackSessionEnd();
+    this.sessionId = null;
+    this.sessionStartedAt = null;
+    await Promise.all([
+      this.secureStorage.remove(SESSION_ID_KEY),
+      this.secureStorage.remove(SESSION_START_KEY)
+    ]);
+    this.log("Session ended");
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getSessionDuration() {
+    if (!this.sessionStartedAt) {
+      return 0;
+    }
+    return Math.floor((Date.now() - this.sessionStartedAt.getTime()) / 1e3);
+  }
+  isSessionActive() {
+    return this.sessionId !== null;
+  }
+  getState() {
+    return {
+      sessionId: this.sessionId,
+      startedAt: this.sessionStartedAt,
+      isActive: this.isSessionActive(),
+      duration: this.getSessionDuration()
+    };
+  }
+  destroy() {
+    if (this.appStateSubscription) {
+      this.appStateSubscription.remove();
+      this.appStateSubscription = null;
+    }
+    this.initialized = false;
+  }
+  registerEmergencyPaywallHandler(handler) {
+    this.emergencyPaywallHandler = handler;
+  }
+  async restoreSession() {
+    const [sessionId, sessionStart] = await Promise.all([
+      this.secureStorage.get(SESSION_ID_KEY),
+      this.secureStorage.get(SESSION_START_KEY)
+    ]).catch(() => [null, null]);
+    if (sessionId && sessionStart) {
+      const startedAt = new Date(sessionStart);
+      const elapsed = Date.now() - startedAt.getTime();
+      if (elapsed < (this.config.sessionTimeoutMs ?? SESSION_TIMEOUT_MS)) {
+        this.sessionId = sessionId;
+        this.sessionStartedAt = startedAt;
+        return;
+      }
+      await Promise.all([
+        this.secureStorage.remove(SESSION_ID_KEY),
+        this.secureStorage.remove(SESSION_START_KEY)
+      ]).catch(() => {
+      });
+    }
+  }
+  setupAppStateListener() {
+    if (this.appStateSubscription) {
+      this.appStateSubscription.remove();
+    }
+    this.appStateSubscription = AppState2.addEventListener("change", this.handleAppStateChange);
+  }
+  async handleForeground() {
+    if (this.backgroundTimestamp) {
+      const elapsed = Date.now() - this.backgroundTimestamp;
+      this.backgroundTimestamp = null;
+      if (elapsed > (this.config.sessionTimeoutMs ?? SESSION_TIMEOUT_MS)) {
+        await this.startSession();
+        await this.trackAppOpen();
+        await this.checkEmergencyPaywall();
+        return;
+      }
+    }
+    if (!this.sessionId) {
+      await this.startSession();
+    }
+    await this.trackAppOpen();
+    await this.checkEmergencyPaywall();
+  }
+  async handleBackground() {
+    this.backgroundTimestamp = Date.now();
+    await this.trackAppBackground();
+  }
+  async checkEmergencyPaywall() {
+    if (!this.apiClient || !this.emergencyPaywallHandler) {
+      return;
+    }
+    if (this.emergencyPaywallShownInSession) {
+      return;
+    }
+    const response = await this.apiClient.getEmergencyPaywall().catch(() => null);
+    if (response?.enabled && response.paywallId) {
+      this.emergencyPaywallShownInSession = true;
+      await this.secureStorage.set(EMERGENCY_PAYWALL_SHOWN_KEY, "true");
+      await this.emergencyPaywallHandler(response.paywallId);
+    }
+  }
+  async trackSessionStart() {
+    if (!this.apiClient || !this.sessionId) return;
+    await trackSessionStart(this.apiClient, this.sessionId, this.sessionStartedAt);
+  }
+  async trackSessionEnd() {
+    if (!this.apiClient || !this.sessionId) return;
+    await trackSessionEnd(this.apiClient, this.sessionId, this.getSessionDuration(), this.sessionStartedAt);
+  }
+  async trackAppOpen() {
+    if (!this.apiClient) return;
+    await trackAppOpen(this.apiClient, this.sessionId);
+  }
+  async trackAppBackground() {
+    if (!this.apiClient) return;
+    await trackAppBackground(this.apiClient, this.sessionId, this.getSessionDuration());
+  }
+  ensureInitialized() {
+    if (!this.initialized) {
+      throw new SessionError(
+        SESSION_ERROR_CODES.NOT_INITIALIZED,
+        "SessionManager not initialized. Call initialize() first"
+      );
+    }
+  }
+  log(...args) {
+    if (this.debug) {
+      console.warn("[Paywallo Session]", ...args);
+    }
+  }
+};
+var sessionManager = new SessionManager();
+
+// src/domains/identity/InstallTracker.ts
+var InstallTracker = class {
+  constructor(debug = false, advertisingIdManager) {
+    this.debug = debug;
+    this.advertisingIdManager = advertisingIdManager ?? new AdvertisingIdManager();
+  }
+  async trackIfNeeded(apiClient, requestATT = false) {
+    const storage = new SecureStorage(this.debug);
+    const alreadyTracked = await storage.get("install_tracked");
+    if (alreadyTracked) return;
+    const distinctId = identityManager.getDistinctId();
+    const sessionId = sessionManager.getSessionId();
+    const installedAt = Date.now();
+    if (!distinctId) return;
+    let deviceInfo = null;
+    try {
+      const mod = await import("react-native-device-info");
+      deviceInfo = mod.default;
+    } catch {
+      deviceInfo = null;
+    }
+    let deviceData = {};
+    try {
+      const screen = Dimensions3.get("screen");
+      const screenWidth = Math.round(screen.width ?? 0);
+      const screenHeight = Math.round(screen.height ?? 0);
+      const locale = Intl.DateTimeFormat().resolvedOptions().locale ?? "unknown";
+      const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone ?? "unknown";
+      const deviceModel = deviceInfo?.getModel() || "unknown";
+      const osVersion = deviceInfo?.getSystemVersion() || "unknown";
+      const appVersion = deviceInfo?.getVersion() || "unknown";
+      const buildNumber = deviceInfo?.getBuildNumber() || "0";
+      deviceData = {
+        deviceModel,
+        osVersion,
+        appVersion,
+        buildNumber,
+        ...screenWidth > 0 && { screenWidth },
+        ...screenHeight > 0 && { screenHeight },
+        timezone,
+        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(),
+      installReferrerManager.getReferrer(),
+      this.advertisingIdManager.collect(requestATT)
+    ]);
+    try {
+      await apiClient.trackEvent("$app_installed", distinctId, {
+        installedAt,
+        platform: Platform6.OS,
+        ...sessionId && { sessionId },
+        ...deviceData,
+        ...fbAnonId && { fbAnonId },
+        ...referrer.rawReferrer && { installReferrer: referrer.rawReferrer },
+        ...referrer.trackingId && { referrerTrackingId: referrer.trackingId },
+        ...referrer.fbclid && { referrerFbclid: referrer.fbclid },
+        ...referrer.utmSource && { referrerUtmSource: referrer.utmSource },
+        ...referrer.utmMedium && { referrerUtmMedium: referrer.utmMedium },
+        ...referrer.utmCampaign && { referrerUtmCampaign: referrer.utmCampaign },
+        ...adIds.idfa && { idfa: adIds.idfa },
+        ...adIds.idfv && { idfv: adIds.idfv },
+        ...adIds.gaid && { gaid: adIds.gaid },
+        attStatus: adIds.attStatus
+      });
+      const stored = await storage.set("install_tracked", String(installedAt));
+      if (this.debug) {
+        if (stored) {
+          console.warn("[Paywallo] Install event tracked");
+        } else {
+          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);
+      }
+    }
+  }
+};
+
+// src/core/PaywalloClient.ts
+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 PaywalloClientClass = class {
+  constructor() {
+    this.config = null;
+    this.apiClient = null;
+    this.initPromise = null;
+    this.paywallPresenter = null;
+    this.campaignPresenter = null;
+    this.subscriptionGetter = null;
+    this.activeChecker = null;
+    this.restoreHandler = null;
+    this.lastOnboardingStepTimestamp = null;
+  }
+  async init(config) {
+    if (this.config && this.apiClient) return;
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
+    }
+    if (!config.appKey) throw new ClientError(CLIENT_ERROR_CODES.MISSING_APP_KEY, "appKey is required");
+    this.initPromise = this.doInit(config);
+    try {
+      await this.initPromise;
+    } catch (error) {
+      this.initPromise = null;
+      this.config = null;
+      this.apiClient = null;
+      try {
+        const tempClient = new ApiClient(config.appKey, config.baseUrl, config.debug);
+        void tempClient.reportError("INIT_FAILED", error instanceof Error ? error.message : String(error));
+      } catch {
+      }
+      throw error;
+    }
+  }
+  async doInit(config) {
+    const environment = config.environment ?? (typeof __DEV__ !== "undefined" && __DEV__ ? "Sandbox" : "Production");
+    const offlineQueueEnabled = config.offlineQueueEnabled !== false;
+    await Promise.all([
+      networkMonitor.initialize({ debug: config.debug }),
+      offlineQueue.initialize({ debug: config.debug }).then(
+        () => offlineQueue.clearItemsWithInvalidAppKey(config.appKey)
+      )
+    ]);
+    this.apiClient = new ApiClient(config.appKey, config.baseUrl, config.debug, environment, offlineQueueEnabled, config.timeout);
+    queueProcessor.initialize(this.apiClient.getHttpClient(), { debug: config.debug });
+    affiliateManager.initialize(this.apiClient, config.debug);
+    await Promise.all([
+      identityManager.initialize(this.apiClient, config.debug),
+      sessionManager.initialize(this.apiClient, config.sessionConfig, config.debug)
+    ]);
+    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(() => {
+    });
+    this.config = config;
+  }
+  async identify(options) {
+    this.ensureInitialized();
+    await identityManager.identify(options);
+  }
+  async track(eventName, options) {
+    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 (!isValidEventName(eventName)) {
+      const msg = `Invalid event name: "${eventName}". Use snake_case or $reserved_name.`;
+      if (this.config?.debug) console.warn("[Paywallo]", msg);
+      throw new ClientError(CLIENT_ERROR_CODES.INVALID_EVENT_NAME, msg);
+    }
+    const sessionId = sessionManager.getSessionId();
+    await apiClient.trackEvent(eventName, distinctId, {
+      ...identityManager.getProperties(),
+      ...options?.properties,
+      ...sessionId && { sessionId }
+    }, options?.timestamp);
+  }
+  async onboardingStep(index, name) {
+    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) {
+      const msg = `Invalid stepIndex: "${index}". Must be a non-negative integer.`;
+      if (this.config?.debug) console.warn("[Paywallo]", msg);
+      throw new AnalyticsError(ANALYTICS_ERROR_CODES.INVALID_STEP_INDEX, msg);
+    }
+    const now = Date.now();
+    const timeOnPreviousStep = this.lastOnboardingStepTimestamp !== null ? Math.round((now - this.lastOnboardingStepTimestamp) / 1e3) : 0;
+    this.lastOnboardingStepTimestamp = now;
+    const sessionId = sessionManager.getSessionId();
+    await apiClient.trackEvent("$onboarding_step", distinctId, {
+      ...identityManager.getProperties(),
+      stepIndex: index,
+      stepName: name,
+      timestamp: now,
+      timeOnPreviousStep,
+      ...sessionId && { sessionId }
+    });
+  }
+  async coreAction(actionName) {
+    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") {
+      const msg = `Invalid actionName: "${actionName}". Must be a non-empty string.`;
+      if (this.config?.debug) console.warn("[Paywallo]", msg);
+      throw new AnalyticsError(ANALYTICS_ERROR_CODES.INVALID_ACTION_NAME, msg);
+    }
+    const sessionId = sessionManager.getSessionId();
+    await apiClient.trackEvent("$core_action", distinctId, {
+      ...identityManager.getProperties(),
+      actionName,
+      timestamp: Date.now(),
+      ...sessionId && { sessionId }
+    });
+  }
+  async getVariant(flagKey) {
+    const distinctId = identityManager.getDistinctId();
+    if (!distinctId) return { variant: null };
+    return this.getApiClientOrThrow().getVariant(flagKey, distinctId);
+  }
+  async getConditionalFlag(flagKey, context) {
+    const distinctId = identityManager.getDistinctId();
+    if (!distinctId) return false;
+    const result = await this.getApiClientOrThrow().getConditionalFlag(flagKey, { distinctId, ...context });
+    return result.value;
+  }
+  async getPaywall(placement) {
+    return this.getApiClientOrThrow().getPaywall(placement);
+  }
+  async presentPaywall(placement) {
+    this.ensureInitialized();
+    if (!this.paywallPresenter) throw new PaywallError(PAYWALL_ERROR_CODES.NOT_INITIALIZED, "PaywalloProvider not mounted. Wrap your app with <PaywalloProvider>");
+    return this.paywallPresenter(placement);
+  }
+  async getCampaign(placement, context) {
+    return campaignGateService.getCampaign(this.getApiClientOrThrow(), placement, context);
+  }
+  async presentCampaign(placement, context) {
+    this.ensureInitialized();
+    return campaignGateService.presentCampaign(this.getApiClientOrThrow(), placement, this.paywallPresenter, this.campaignPresenter, context);
+  }
+  async hasActiveSubscription() {
+    this.ensureInitialized();
+    try {
+      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");
+      return false;
+    }
+  }
+  async getSubscription() {
+    this.ensureInitialized();
+    try {
+      if (this.subscriptionGetter) return await this.subscriptionGetter();
+      const distinctId = identityManager.getDistinctId();
+      if (!distinctId || !this.apiClient) return null;
+      const status = await this.apiClient.getSubscriptionStatus(distinctId);
+      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;
+    }
+  }
+  async restorePurchases() {
+    this.ensureInitialized();
+    if (!this.restoreHandler) throw new PaywallError(PAYWALL_ERROR_CODES.NOT_INITIALIZED, "PaywalloProvider not mounted. Wrap your app with <PaywalloProvider>");
+    return this.restoreHandler();
+  }
+  async reset() {
+    await identityManager.reset();
+  }
+  async fullReset() {
+    const wasDebug = this.config?.debug ?? false;
+    await sessionManager.endSession();
+    await identityManager.reset();
+    queueProcessor.dispose();
+    offlineQueue.dispose();
+    networkMonitor.dispose();
+    campaignGateService.clearPreloaded();
+    this.apiClient = null;
+    this.config = null;
+    this.initPromise = null;
+    this.paywallPresenter = null;
+    this.campaignPresenter = null;
+    this.subscriptionGetter = null;
+    this.activeChecker = null;
+    this.restoreHandler = null;
+    this.lastOnboardingStepTimestamp = null;
+    if (wasDebug) console.warn("[Paywallo]", "Full reset complete");
+  }
+  getConfig() {
+    return this.config;
+  }
+  getDistinctId() {
+    return identityManager.getDistinctId();
+  }
+  getDeviceId() {
+    return identityManager.getDeviceId();
+  }
+  getEmail() {
+    return identityManager.getEmail();
+  }
+  getEnvironment() {
+    return this.apiClient?.getEnvironment() ?? "Production";
+  }
+  setEnvironment(environment) {
+    this.apiClient?.setEnvironment(environment);
+  }
+  getApiClient() {
+    return this.apiClient;
+  }
+  getWebUrl() {
+    return this.apiClient?.getWebUrl() ?? null;
+  }
+  getIdentityState() {
+    return identityManager.getState();
+  }
+  getSessionState() {
+    return sessionManager.getState();
+  }
+  getSessionId() {
+    return sessionManager.getSessionId();
+  }
+  async startSession() {
+    return sessionManager.startSession();
+  }
+  async endSession() {
+    return sessionManager.endSession();
+  }
+  registerPaywallPresenter(p) {
+    this.paywallPresenter = p;
+  }
+  registerCampaignPresenter(p) {
+    this.campaignPresenter = p;
+  }
+  registerSubscriptionGetter(g) {
+    this.subscriptionGetter = g;
+  }
+  registerActiveChecker(c) {
+    this.activeChecker = c;
+  }
+  registerRestoreHandler(h) {
+    this.restoreHandler = h;
+  }
+  registerEmergencyPaywallHandler(h) {
+    sessionManager.registerEmergencyPaywallHandler(h);
+  }
+  async requireSubscription(paywallPlacement) {
+    this.ensureInitialized();
+    if (await this.hasActiveSubscription()) return true;
+    if (!paywallPlacement) return false;
+    const r = await this.presentPaywall(paywallPlacement);
+    return r.purchased || r.restored;
+  }
+  async requireSubscriptionWithCampaign(placement, context) {
+    this.ensureInitialized();
+    return campaignGateService.requireSubscriptionWithCampaign(
+      this.getApiClientOrThrow(),
+      placement,
+      () => this.hasActiveSubscription(),
+      this.paywallPresenter,
+      this.campaignPresenter,
+      context
+    );
+  }
+  async gateContent(content, paywallPlacement) {
+    return await this.requireSubscription(paywallPlacement) ? content() : null;
+  }
+  async gateContentWithCampaign(content, placement, context) {
+    return await this.requireSubscriptionWithCampaign(placement, context) ? content() : null;
+  }
+  async preloadCampaign(placement, context) {
+    return campaignGateService.preloadCampaign(this.getApiClientOrThrow(), placement, context);
+  }
+  getPreloadedCampaign(placement) {
+    return campaignGateService.getPreloadedCampaign(placement);
+  }
+  isOnline() {
+    return networkMonitor.isOnline();
+  }
+  getOfflineQueueSize() {
+    return offlineQueue.getSize();
+  }
+  async clearOfflineQueue() {
+    await offlineQueue.clear();
+  }
+  async processOfflineQueue() {
+    return queueProcessor.processQueue();
+  }
+  getApiClientOrThrow() {
+    if (!this.config || !this.apiClient) throw new ClientError(CLIENT_ERROR_CODES.NOT_INITIALIZED, "SDK not initialized. Call Paywallo.init() first");
+    return this.apiClient;
+  }
+  ensureInitialized() {
+    if (!this.config || !this.apiClient) throw new ClientError(CLIENT_ERROR_CODES.NOT_INITIALIZED, "SDK not initialized. Call Paywallo.init() first");
+  }
+};
+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;
+  }
+}
+
+// src/hooks/usePaywallo.ts
+import { useContext as useContext2 } from "react";
+function usePaywallo() {
+  const context = useContext2(PaywalloContext);
+  if (!context) {
+    throw new ClientError(CLIENT_ERROR_CODES.PROVIDER_MISSING, "usePaywallo must be used within a PaywalloProvider");
+  }
+  return context;
+}
+
+// src/hooks/useProducts.ts
+import { useCallback as useCallback5, useEffect as useEffect5, useState as useState5 } from "react";
+
+// src/utils/productMappers.ts
+function mapToIAPProduct(product) {
+  return {
+    productId: product.productId,
+    price: product.price,
+    currency: product.currency,
+    localizedPrice: product.localizedPrice,
+    title: product.title,
+    description: product.description,
+    type: product.type === "subscription" ? "subs" : "inapp",
+    subscriptionPeriodAndroid: product.subscriptionPeriod,
+    introductoryPrice: product.introductoryPrice,
+    freeTrialPeriodAndroid: product.freeTrialPeriod
+  };
+}
+function mapToFormattedProduct(product) {
+  return {
+    productId: product.productId,
+    title: product.title,
+    description: product.description,
+    price: product.price,
+    priceValue: product.priceValue,
+    currency: product.currency,
+    localizedPrice: product.localizedPrice,
+    subscriptionPeriod: product.subscriptionPeriod,
+    introductoryPrice: product.introductoryPrice,
+    freeTrialPeriod: product.freeTrialPeriod,
+    pricePerMonth: product.pricePerMonth,
+    pricePerWeek: product.pricePerWeek,
+    pricePerDay: product.pricePerDay
+  };
+}
+
+// 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) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const iapService = getIAPService();
+      const storeProducts = await iapService.loadProducts(productIds);
+      setProducts(storeProducts.map(mapToIAPProduct));
+      setFormattedProducts(storeProducts.map(mapToFormattedProduct));
+    } catch (err) {
+      setError(err instanceof PurchaseError ? err : new PurchaseError(PURCHASE_ERROR_CODES.PURCHASE_FAILED, String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  useEffect5(() => {
+    if (initialProductIds && initialProductIds.length > 0) {
+      void loadProducts(initialProductIds);
+    }
+  }, []);
+  const getProduct = useCallback5(
+    (productId) => {
+      return products.find((p) => p.productId === productId);
+    },
+    [products]
+  );
+  const getFormattedProduct = useCallback5(
+    (productId) => {
+      return formattedProducts.find((p) => p.productId === productId);
+    },
+    [formattedProducts]
+  );
+  const getPriceInfo = useCallback5(
+    (productId) => {
+      const p = formattedProducts.find((fp) => fp.productId === productId);
+      if (!p) return void 0;
+      return {
+        price: p.price,
+        priceValue: p.priceValue,
+        currency: p.currency,
+        localizedPrice: p.localizedPrice,
+        pricePerMonth: p.pricePerMonth,
+        pricePerWeek: p.pricePerWeek,
+        pricePerDay: p.pricePerDay
+      };
+    },
+    [formattedProducts]
+  );
+  return {
+    products,
+    formattedProducts,
+    isLoading,
+    error,
+    loadProducts,
+    getProduct,
+    getFormattedProduct,
+    getPriceInfo
+  };
+}
+
+// src/hooks/usePurchase.ts
+import { useCallback as useCallback6, useState as useState6 } from "react";
+function usePurchase() {
+  const [state, setState] = useState6("idle");
+  const [error, setError] = useState6(null);
+  const purchase = useCallback6(async (productId) => {
+    setState("purchasing");
+    setError(null);
+    try {
+      const iapService = getIAPService();
+      const result = await iapService.purchase(productId);
+      if (result.success && result.purchase) {
+        setState("idle");
+        return {
+          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);
+        setState("error");
+        throw result.error;
+      }
+      setState("idle");
+      throw new PurchaseError(PURCHASE_ERROR_CODES.USER_CANCELLED, "Purchase cancelled by user", true);
+    } catch (err) {
+      setState("error");
+      throw err;
+    }
+  }, []);
+  const restore = useCallback6(async () => {
+    setState("restoring");
+    setError(null);
+    try {
+      const iapService = getIAPService();
+      const transactions = await iapService.restore();
+      setState("idle");
+      return transactions.map((tx) => ({
+        productId: tx.productId,
+        transactionId: tx.transactionId,
+        transactionDate: tx.transactionDate,
+        transactionReceipt: tx.receipt
+      }));
+    } catch (err) {
+      const e = err instanceof PurchaseError ? err : createPurchaseError("RESTORE_FAILED", String(err));
+      setError(e);
+      setState("error");
+      throw e;
+    }
+  }, []);
+  return {
+    state,
+    purchase,
+    restore,
+    error,
+    isLoading: state === "loading",
+    isPurchasing: state === "purchasing",
+    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);
+    }
+    this.log("SubscriptionManager initialized");
+  }
+  setUserId(userId) {
+    if (this.userId !== userId) {
+      this.userId = userId;
+      void this.cache.invalidate();
+    }
+  }
+  async hasActiveSubscription(forceRefresh = false) {
+    const status = await this.getSubscriptionStatus(forceRefresh);
+    return status.hasActiveSubscription;
+  }
+  async getSubscription(forceRefresh = false) {
+    const status = await this.getSubscriptionStatus(forceRefresh);
+    return status.subscription;
+  }
+  async getEntitlements(forceRefresh = false) {
+    const status = await this.getSubscriptionStatus(forceRefresh);
+    return status.entitlements;
+  }
+  async getSubscriptionStatus(forceRefresh = false) {
+    if (!this.config) {
+      return this.getEmptyStatus();
+    }
+    if (!forceRefresh) {
+      const cached = await this.cache.get();
+      if (cached && !cached.isStale) {
+        return cached.data;
+      }
+    }
+    try {
+      const status = await this.fetchSubscriptionStatus();
+      await this.cache.set(status);
+      this.notifyListeners(status);
+      return status;
+    } catch (error) {
+      this.log("Failed to fetch subscription status", error);
+      const cached = await this.cache.get();
+      if (cached) {
+        return cached.data;
+      }
+      return this.getEmptyStatus();
+    }
+  }
+  async restorePurchases() {
+    if (!this.config) {
+      throw new SessionError(
+        SESSION_ERROR_CODES.NOT_INITIALIZED,
+        "SubscriptionManager not initialized"
+      );
+    }
+    await this.cache.invalidate();
+    return this.getSubscriptionStatus(true);
+  }
+  async fetchSubscriptionStatus() {
+    if (!this.config) {
+      return this.getEmptyStatus();
+    }
+    const url = new URL(`${this.config.serverUrl}/subscriptions/status`);
+    if (this.userId) {
+      url.searchParams.set("userId", this.userId);
+    }
+    url.searchParams.set("platform", Platform8.OS);
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "X-App-Key": this.config.appKey
+      }
+    });
+    if (!response.ok) {
+      throw new SessionError(
+        SESSION_ERROR_CODES.RESTORE_FAILED,
+        `Failed to fetch subscription status: ${response.status}`
+      );
+    }
+    const data = await response.json();
+    if (data.subscription) {
+      data.subscription.expiresAt = new Date(data.subscription.expiresAt);
+      data.subscription.originalPurchaseDate = new Date(data.subscription.originalPurchaseDate);
+      data.subscription.latestPurchaseDate = new Date(data.subscription.latestPurchaseDate);
+      if (data.subscription.cancellationDate) {
+        data.subscription.cancellationDate = new Date(data.subscription.cancellationDate);
+      }
+      if (data.subscription.gracePeriodExpiresAt) {
+        data.subscription.gracePeriodExpiresAt = new Date(data.subscription.gracePeriodExpiresAt);
+      }
+    }
+    return data;
+  }
+  getEmptyStatus() {
+    return {
+      hasActiveSubscription: false,
+      subscription: null,
+      entitlements: []
+    };
+  }
+  addListener(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  notifyListeners(status) {
+    for (const listener of this.listeners) {
+      listener(status);
+    }
+  }
+  async onPurchaseComplete() {
+    await this.cache.invalidate();
+    await this.getSubscriptionStatus(true);
+  }
+  log(message, data) {
+    if (this.config?.debug) {
+      console.warn(`[SubscriptionManager] ${message}`, data ?? "");
+    }
+  }
+};
+var subscriptionManager = new SubscriptionManagerClass();
+
+// src/hooks/useSubscription.ts
+function useSubscription() {
+  const [status, setStatus] = useState7(null);
+  const [isLoading, setIsLoading] = useState7(true);
+  const [error, setError] = useState7(null);
+  const refresh = useCallback7(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const newStatus = await subscriptionManager.getSubscriptionStatus(true);
+      setStatus(newStatus);
+    } catch (err) {
+      const e = err instanceof PurchaseError ? err : new PurchaseError(PURCHASE_ERROR_CODES.PURCHASE_FAILED, String(err));
+      setError(e);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const restore = useCallback7(async () => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const newStatus = await subscriptionManager.restorePurchases();
+      setStatus(newStatus);
+    } catch (err) {
+      const e = err instanceof PurchaseError ? err : new PurchaseError(PURCHASE_ERROR_CODES.RESTORE_FAILED, String(err));
+      setError(e);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  useEffect6(() => {
+    void subscriptionManager.getSubscriptionStatus().then((s) => {
+      setStatus(s);
+      setIsLoading(false);
+    });
+    const removeListener = subscriptionManager.addListener((newStatus) => {
+      setStatus(newStatus);
+    });
+    return () => {
+      removeListener();
+    };
+  }, []);
+  return {
+    subscription: status?.subscription ?? null,
+    isActive: status?.hasActiveSubscription ?? false,
+    isLoading,
+    error,
+    entitlements: status?.entitlements ?? [],
+    refresh,
+    restore
+  };
+}
+
+// src/PaywalloProvider.tsx
+import { useCallback as useCallback12, useEffect as useEffect7, useMemo as useMemo2, useRef as useRef8, useState as useState11 } 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";
+
+// src/utils/serverProduct.ts
+var PERIOD_MAP = {
+  P1Y: "ano",
+  P1M: "m\xEAs",
+  P1W: "semana",
+  P3M: "trimestre",
+  P6M: "semestre"
+};
+function buildProductFromServerInfo(info) {
+  const period = PERIOD_MAP[info.billingPeriod ?? ""] ?? "";
+  const priceStr = info.price != null ? `R$ ${info.price.toFixed(2).replace(".", ",")}` : "";
+  return {
+    productId: info.storeProductId,
+    title: info.name,
+    description: "",
+    price: priceStr,
+    priceValue: info.price ?? 0,
+    currency: "BRL",
+    localizedPrice: priceStr,
+    type: "subscription",
+    subscriptionPeriod: period,
+    freeTrialPeriod: info.trialDays ? `${info.trialDays} dias` : void 0
+  };
+}
+
+// src/utils/loadCampaignProducts.ts
+async function loadCampaignProducts(serverProducts, storeProductIds) {
+  const productsMap = /* @__PURE__ */ new Map();
+  if (storeProductIds.length > 0) {
+    for (let attempt = 1; attempt <= 3; attempt++) {
+      try {
+        const storeProducts = await getIAPService().loadProducts(storeProductIds);
+        if (storeProducts.length > 0) {
+          for (const p of storeProducts) productsMap.set(p.productId, p);
+        }
+        if (productsMap.size >= storeProductIds.length) break;
+        if (attempt < 3) await new Promise((r) => setTimeout(r, 250 * Math.pow(2, attempt)));
+      } catch {
+        if (attempt < 3) await new Promise((r) => setTimeout(r, 250 * Math.pow(2, attempt)));
+      }
+    }
+  }
+  for (const sp of serverProducts) {
+    if (!productsMap.has(sp.storeProductId)) {
+      const prod = buildProductFromServerInfo(sp);
+      productsMap.set(prod.productId, prod);
+    }
+  }
+  return productsMap;
+}
+
+// src/utils/preloadCache.ts
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+function isCacheEntryValid(entry) {
+  return !!entry && Date.now() - entry.preloadedAt < CACHE_TTL_MS;
+}
+function consumeCacheEntry(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 preloadedCampaignsRef = useRef6(/* @__PURE__ */ new Map());
+  const isPreloadValid = useCallback8(
+    (placement) => isCacheEntryValid(preloadedCampaignsRef.current.get(placement)),
+    []
+  );
+  const consumePreloadedCampaign = useCallback8(
+    (placement) => consumeCacheEntry(preloadedCampaignsRef.current, placement),
+    []
+  );
+  const preloadCampaign = useCallback8(
+    async (placement, context) => {
+      try {
+        const campaign = await PaywalloClient.getCampaign(placement, context);
+        if (!campaign?.paywall) {
+          return {
+            success: false,
+            error: new CampaignError(
+              CAMPAIGN_ERROR_CODES.NOT_FOUND,
+              `Campaign or paywall not found: ${placement}`
+            )
+          };
+        }
+        const { paywall } = campaign;
+        const serverProducts = [paywall.primaryProduct, paywall.secondaryProduct].filter(Boolean);
+        const storeProductIds = serverProducts.map((p) => p.storeProductId).filter(Boolean);
+        const productsMap = await loadCampaignProducts(
+          serverProducts.map((p) => p),
+          storeProductIds
+        );
+        preloadedCampaignsRef.current.set(placement, {
+          campaignId: campaign.campaignId,
+          variantKey: campaign.variantKey,
+          paywall: {
+            id: paywall.id,
+            placement: paywall.placement,
+            config: paywall.config,
+            primaryProductId: paywall.primaryProductId,
+            secondaryProductId: paywall.secondaryProductId
+          },
+          products: productsMap,
+          preloadedAt: Date.now()
+        });
+        const craftData = paywall.config?.craftData ?? "";
+        setPreloadedWebView({
+          placement,
+          paywallId: paywall.id,
+          craftData,
+          products: productsMap,
+          primaryProductId: paywall.primaryProductId,
+          secondaryProductId: paywall.secondaryProductId,
+          loaded: false,
+          campaignId: campaign.campaignId,
+          variantKey: campaign.variantKey
+        });
+        return { success: true };
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error : new CampaignError(CAMPAIGN_ERROR_CODES.FETCH_FAILED, String(error))
+        };
+      }
+    },
+    []
+  );
+  return {
+    preloadedCampaignsRef,
+    preloadedWebView,
+    setPreloadedWebView,
+    preloadCampaign,
+    consumePreloadedCampaign,
+    isPreloadValid
+  };
+}
+
+// src/hooks/useProductLoader.ts
+import { useCallback as useCallback9, useState as useState9 } from "react";
+function useProductLoader() {
+  const [products, setProducts] = useState9(/* @__PURE__ */ new Map());
+  const [isLoadingProducts, setIsLoadingProducts] = useState9(false);
+  const refreshProducts = useCallback9(async (productIds) => {
+    setIsLoadingProducts(true);
+    try {
+      const iapService = getIAPService();
+      const loaded = await iapService.loadProducts(productIds);
+      const map = /* @__PURE__ */ new Map();
+      for (const p of loaded) map.set(p.productId, p);
+      setProducts(map);
+    } catch (error) {
+      if (PaywalloClient.getConfig()?.debug) console.warn("[Panel] Product load failed:", error);
+    } finally {
+      setIsLoadingProducts(false);
+    }
+  }, []);
+  return { products, isLoadingProducts, refreshProducts };
+}
+
+// src/hooks/usePurchaseOrchestrator.ts
+import { useCallback as useCallback10 } from "react";
+function usePurchaseOrchestrator(preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef) {
+  const { trackDismissed, trackProductSelected, trackPurchased } = usePaywallTracking();
+  const handlePreloadedPurchase = useCallback10(
+    async (productId) => {
+      try {
+        if (preloadedWebView) {
+          trackProductSelected({ placement: preloadedWebView.placement, paywallId: preloadedWebView.paywallId, productId, variantKey: preloadedWebView.variantKey, campaignId: preloadedWebView.campaignId });
+        }
+        const result = await getIAPService().purchase(productId, {
+          paywallPlacement: preloadedWebView?.placement,
+          variantKey: preloadedWebView?.variantKey
+        });
+        if (!result.success) {
+          if (result.error) {
+            setShowingPreloadedWebView(false);
+            clearPreloadedWebView();
+            resolvePreloadedPaywall({ presented: true, purchased: false, cancelled: false, restored: false });
+          }
+          return;
+        }
+        if (preloadedWebView) {
+          const durationSeconds = Math.round((Date.now() - presentedAtRef.current) / 1e3);
+          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 });
+        }
+        setShowingPreloadedWebView(false);
+        clearPreloadedWebView();
+        resolvePreloadedPaywall({ presented: true, purchased: true, cancelled: false, restored: false });
+      } catch (error) {
+        if (PaywalloClient.getConfig()?.debug) console.warn("[Panel] Preloaded purchase error:", error);
+        setShowingPreloadedWebView(false);
+        clearPreloadedWebView();
+        resolvePreloadedPaywall({ presented: true, purchased: false, cancelled: false, restored: false });
+      }
+    },
+    [preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef, trackDismissed, trackProductSelected, trackPurchased]
+  );
+  const handlePreloadedRestore = useCallback10(async () => {
+    try {
+      const transactions = await getIAPService().restore();
+      if (transactions.length === 0) return;
+      if (preloadedWebView) {
+        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 });
+      }
+      setShowingPreloadedWebView(false);
+      clearPreloadedWebView();
+      resolvePreloadedPaywall({ presented: true, purchased: false, cancelled: false, restored: true });
+    } catch (error) {
+      if (PaywalloClient.getConfig()?.debug) console.warn("[Panel] Preloaded restore error:", error);
+      setShowingPreloadedWebView(false);
+      clearPreloadedWebView();
+      resolvePreloadedPaywall({ presented: true, purchased: false, cancelled: false, restored: false });
+    }
+  }, [preloadedWebView, resolvePreloadedPaywall, clearPreloadedWebView, setShowingPreloadedWebView, presentedAtRef, trackDismissed]);
+  return { handlePreloadedPurchase, handlePreloadedRestore };
+}
+
+// src/hooks/useSubscriptionSync.ts
+import { useCallback as useCallback11, useRef as useRef7, useState as useState10 } from "react";
+var CACHE_TTL_MS2 = 5 * 60 * 1e3;
+var ACTIVE_STATUSES = ["active", "in_grace_period"];
+function useSubscriptionSync() {
+  const [subscription, setSubscription] = useState10(null);
+  const cacheRef = useRef7(null);
+  const invalidateCache = useCallback11(() => {
+    cacheRef.current = null;
+  }, []);
+  const fetchAndCache = useCallback11(async () => {
+    const apiClient = PaywalloClient.getApiClient();
+    const distinctId = PaywalloClient.getDistinctId();
+    if (!apiClient || !distinctId) return null;
+    const status = await apiClient.getSubscriptionStatus(distinctId);
+    const sub = status.subscription ? {
+      ...status.subscription,
+      expiresAt: status.subscription.expiresAt ? new Date(status.subscription.expiresAt) : null
+    } : null;
+    cacheRef.current = { data: sub, expiresAt: Date.now() + CACHE_TTL_MS2 };
+    setSubscription(sub);
+    return sub;
+  }, []);
+  const hasActiveSubscription = useCallback11(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;
+    }
+    try {
+      const status = await apiClient.getSubscriptionStatus(distinctId);
+      const sub = status.subscription ? {
+        ...status.subscription,
+        expiresAt: status.subscription.expiresAt ? new Date(status.subscription.expiresAt) : null
+      } : null;
+      cacheRef.current = { data: sub, expiresAt: Date.now() + CACHE_TTL_MS2 };
+      setSubscription(sub);
+      return status.hasActiveSubscription;
+    } catch {
+      return false;
+    }
+  }, []);
+  const getSubscription = useCallback11(async () => {
+    const apiClient = PaywalloClient.getApiClient();
+    const distinctId = PaywalloClient.getDistinctId();
+    if (!apiClient || !distinctId) return null;
+    const cached = cacheRef.current;
+    if (cached && cached.expiresAt > Date.now()) return cached.data;
+    try {
+      return await fetchAndCache();
+    } catch {
+      return null;
+    }
+  }, [fetchAndCache]);
+  return { subscription, hasActiveSubscription, getSubscription, invalidateCache };
+}
+
+// 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 { 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 { handlePreloadedPurchase: rawPreloadedPurchase, handlePreloadedRestore } = usePurchaseOrchestrator(
+    preloadedWebView,
+    resolvePreloadedPaywall,
+    clearPreloadedWebView,
+    setShowingPreloadedWebView,
+    presentedAtRef
+  );
+  const [isPreloadPurchasing, setIsPreloadPurchasing] = useState11(false);
+  const handlePreloadedPurchase = useCallback12(async (productId) => {
+    setIsPreloadPurchasing(true);
+    try {
+      await rawPreloadedPurchase(productId);
+    } finally {
+      setIsPreloadPurchasing(false);
+    }
+  }, [rawPreloadedPurchase]);
+  useEffect7(() => {
+    initLocalization({ detectDevice: true });
+    PaywalloClient.init(config).then(() => {
+      setDistinctId(PaywalloClient.getDistinctId());
+      setIsInitialized(true);
+    }).catch((err) => {
+      setInitError(err instanceof Error ? err : new ClientError(CLIENT_ERROR_CODES.NOT_INITIALIZED, String(err)));
+    });
+  }, [config]);
+  const getPaywallConfig = useCallback12(async (p) => {
+    const api = PaywalloClient.getApiClient();
+    return api ? api.getPaywall(p) : null;
+  }, []);
+  const presentPaywall = useCallback12((placement) => {
+    return new Promise((resolve) => setActivePaywall({ placement, resolver: resolve }));
+  }, []);
+  const trackCampaignImpression = useCallback12((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(
+    async (placement, context) => {
+      try {
+        if (preloadedWebView?.placement === placement && preloadedWebView.loaded && isPreloadValid(placement)) {
+          consumePreloadedCampaign(placement);
+          const apiClient = PaywalloClient.getApiClient();
+          if (apiClient) {
+            const sessionId = PaywalloClient.getSessionId();
+            void apiClient.trackEvent("$paywall_viewed", PaywalloClient.getDistinctId(), {
+              placement,
+              paywallId: preloadedWebView.paywallId,
+              preloaded: true,
+              variantKey: preloadedWebView.variantKey ?? "",
+              campaignId: preloadedWebView.campaignId ?? "",
+              ...sessionId && { sessionId }
+            });
+          }
+          trackCampaignImpression(placement, preloadedWebView.variantKey ?? "", preloadedWebView.campaignId ?? "");
+          const r2 = await presentPreloadedWebView();
+          return { ...r2, campaignId: preloadedWebView.campaignId ?? "", variantKey: preloadedWebView.variantKey ?? "" };
+        }
+        const preloaded = consumePreloadedCampaign(placement);
+        if (preloaded) {
+          trackCampaignImpression(placement, preloaded.variantKey, preloaded.campaignId);
+          const r2 = await new Promise((resolve) => setActivePaywall({
+            placement: preloaded.paywall.placement,
+            resolver: resolve,
+            paywallConfig: preloaded.paywall,
+            preloadedProducts: preloaded.products,
+            variantKey: preloaded.variantKey,
+            campaignId: preloaded.campaignId
+          }));
+          return { ...r2, campaignId: preloaded.campaignId, variantKey: preloaded.variantKey };
+        }
+        const campaign = PaywalloClient.getPreloadedCampaign(placement) ?? await PaywalloClient.getCampaign(placement, context);
+        if (!campaign?.paywall) return {
+          presented: false,
+          purchased: false,
+          cancelled: false,
+          restored: false,
+          error: new CampaignError(campaign ? CAMPAIGN_ERROR_CODES.PRELOAD_FAILED : CAMPAIGN_ERROR_CODES.NOT_FOUND, campaign ? `No paywall: ${placement}` : `Campaign not found: ${placement}`)
+        };
+        trackCampaignImpression(placement, campaign.variantKey, campaign.campaignId);
+        const r = await new Promise((resolve) => setActivePaywall({
+          placement: campaign.paywall.placement,
+          resolver: resolve,
+          paywallConfig: {
+            id: campaign.paywall.id,
+            placement: campaign.paywall.placement,
+            config: campaign.paywall.config,
+            primaryProductId: campaign.paywall.primaryProductId,
+            secondaryProductId: campaign.paywall.secondaryProductId
+          },
+          variantKey: campaign.variantKey,
+          campaignId: campaign.campaignId
+        }));
+        return { ...r, campaignId: campaign.campaignId, variantKey: campaign.variantKey };
+      } catch (error) {
+        return {
+          presented: false,
+          purchased: false,
+          cancelled: false,
+          restored: false,
+          error: error instanceof Error ? error : new CampaignError(CAMPAIGN_ERROR_CODES.PRESENT_FAILED, String(error))
+        };
+      }
+    },
+    [preloadedWebView, isPreloadValid, consumePreloadedCampaign, presentPreloadedWebView, trackCampaignImpression]
+  );
+  const restorePurchases = useCallback12(async () => {
+    invalidateCache();
+    try {
+      const txs = await getIAPService().restore();
+      return txs.length > 0 ? { success: true, restoredProducts: txs.map((tx) => tx.productId) } : { success: false, restoredProducts: [] };
+    } catch (error) {
+      return { success: false, restoredProducts: [], error: error instanceof Error ? error : new PurchaseError(PURCHASE_ERROR_CODES.RESTORE_FAILED, String(error)) };
+    }
+  }, [invalidateCache]);
+  const handlePaywallResult = useCallback12((result) => {
+    if (activePaywall) {
+      activePaywall.resolver(result);
+      setActivePaywall(null);
+    }
+  }, [activePaywall]);
+  useEffect7(() => {
+    if (!isInitialized) return;
+    const onEmergency = async (id) => {
+      try {
+        await presentPaywall(id);
+      } catch {
+      }
+    };
+    PaywalloClient.registerPaywallPresenter(presentPaywall);
+    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(() => {
+  }, []);
+  const contextValue = useMemo2(() => ({
+    config: PaywalloClient.getConfig(),
+    isInitialized,
+    initError,
+    distinctId,
+    subscription,
+    products,
+    isLoadingProducts,
+    presentPaywall,
+    presentCampaign,
+    preloadCampaign,
+    hasActiveSubscription,
+    getSubscription,
+    restorePurchases,
+    getPaywallConfig,
+    refreshProducts
+  }), [
+    isInitialized,
+    initError,
+    distinctId,
+    subscription,
+    products,
+    isLoadingProducts,
+    presentPaywall,
+    presentCampaign,
+    preloadCampaign,
+    hasActiveSubscription,
+    getSubscription,
+    restorePurchases,
+    getPaywallConfig,
+    refreshProducts
+  ]);
+  const SCREEN_HEIGHT3 = useMemo2(() => Dimensions4.get("window").height, []);
+  const slideAnim = useRef8(new Animated3.Value(SCREEN_HEIGHT3)).current;
+  useEffect7(() => {
+    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);
+    }
+  }, [showingPreloadedWebView, slideAnim, SCREEN_HEIGHT3]);
+  const preloadStyle = [
+    styles3.preloadOverlay,
+    showingPreloadedWebView ? styles3.visible : styles3.hidden,
+    { transform: [{ translateY: showingPreloadedWebView ? slideAnim : SCREEN_HEIGHT3 }] }
+  ];
+  return /* @__PURE__ */ jsxs2(PaywalloContext.Provider, { value: contextValue, children: [
+    children,
+    /* @__PURE__ */ jsx3(PaywallErrorBoundary, { children: !!preloadedWebView?.craftData && /* @__PURE__ */ jsx3(Animated3.View, { style: preloadStyle, pointerEvents: showingPreloadedWebView ? "auto" : "none", children: /* @__PURE__ */ jsx3(
+      PaywallWebView,
+      {
+        paywallId: preloadedWebView.paywallId,
+        craftData: preloadedWebView.craftData,
+        products: preloadedWebView.products,
+        primaryProductId: preloadedWebView.primaryProductId,
+        secondaryProductId: preloadedWebView.secondaryProductId,
+        isPurchasing: isPreloadPurchasing,
+        onReady: handlePreloadedWebViewReady,
+        onClose: showingPreloadedWebView ? handlePreloadedClose : noOp,
+        onPurchase: showingPreloadedWebView ? handlePreloadedPurchase : noOp,
+        onRestore: showingPreloadedWebView ? handlePreloadedRestore : noOp
+      }
+    ) }) }),
+    /* @__PURE__ */ jsx3(PaywallErrorBoundary, { children: activePaywall && /* @__PURE__ */ jsx3(
+      PaywallModal,
+      {
+        placement: activePaywall.placement,
+        visible: true,
+        onResult: handlePaywallResult,
+        paywallConfig: activePaywall.paywallConfig,
+        preloadedProducts: activePaywall.preloadedProducts,
+        variantKey: activePaywall.variantKey,
+        campaignId: activePaywall.campaignId
+      }
+    ) })
+  ] });
+}
+var styles3 = StyleSheet3.create({
+  preloadOverlay: { position: "absolute", top: 0, left: 0, right: 0, bottom: 0, backgroundColor: "#ffffff" },
+  hidden: { zIndex: -1 },
+  visible: { zIndex: 9999 }
+});
+
+// src/utils/productVariableResolver.ts
+function getProductVariable(product, property) {
+  if (!product) return "";
+  switch (property) {
+    case "id":
+      return product.productId;
+    case "name":
+      return product.title;
+    case "price":
+      return product.localizedPrice;
+    case "pricePerMonth":
+      return product.pricePerMonth ?? product.localizedPrice;
+    case "pricePerWeek":
+      return product.pricePerWeek ?? "";
+    case "pricePerDay":
+      return product.pricePerDay ?? "";
+    case "period":
+      return product.subscriptionPeriod ?? "";
+    case "trialPeriod":
+      return product.freeTrialPeriod ?? "";
+    case "introPrice":
+      return product.introductoryPrice ?? "";
+    case "savings":
+      return product.savings ?? "";
+    case "savingsPercent":
+      return product.savingsPercent ?? "";
+    case "hasFreeTrial":
+      return product.freeTrialPeriod ? "true" : "false";
+    case "hasIntroOffer":
+      return product.introductoryPrice ? "true" : "false";
+    case "renewalPeriod":
+      return product.subscriptionPeriod ?? "";
+    default:
+      return "";
+  }
+}
+function resolveProductsVariable(parts, context) {
+  if (parts[0] !== "products") return null;
+  if (parts[1] === "selected" && context.selectedProductId) {
+    return getProductVariable(context.products.get(context.selectedProductId), parts[2]);
+  }
+  if (parts[1] === "primary" && context.primaryProductId) {
+    return getProductVariable(context.products.get(context.primaryProductId), parts[2]);
+  }
+  if (parts[1] === "secondary" && context.secondaryProductId) {
+    return getProductVariable(context.products.get(context.secondaryProductId), parts[2]);
+  }
+  if (parts[1] === "hasIntroductoryOffer") {
+    return Array.from(context.products.values()).some((p) => p.introductoryPrice) ? "true" : "false";
+  }
+  return null;
+}
+function resolveLegacyVariable(variableName, context) {
+  if (variableName === "device_name") return context.deviceInfo?.name ?? "";
+  if (variableName === "product_price" && context.selectedProductId) {
+    return context.products.get(context.selectedProductId)?.localizedPrice ?? "";
+  }
+  if (variableName === "trial_period" && context.selectedProductId) {
+    return context.products.get(context.selectedProductId)?.freeTrialPeriod ?? "";
+  }
+  return null;
+}
+
+// src/utils/variableResolver.ts
+function resolveVariable(variableName, context) {
+  const parts = variableName.split(".");
+  if (parts[0] === "device" && context.deviceInfo) {
+    switch (parts[1]) {
+      case "name":
+        return context.deviceInfo.name ?? "";
+      case "model":
+        return context.deviceInfo.model ?? "";
+      case "os":
+        return context.deviceInfo.os ?? "";
+      case "osVersion":
+        return context.deviceInfo.osVersion ?? "";
+      case "locale":
+        return context.deviceInfo.locale ?? "";
+      default:
+        return "";
+    }
+  }
+  if (parts[0] === "user" && context.userInfo) {
+    switch (parts[1]) {
+      case "id":
+        return context.userInfo.id ?? "";
+      case "name":
+        return context.userInfo.name ?? "";
+      case "email":
+        return context.userInfo.email ?? "";
+      default:
+        return "";
+    }
+  }
+  if (parts[0] === "products") {
+    return resolveProductsVariable(parts, context) ?? "";
+  }
+  return resolveLegacyVariable(variableName, context) ?? context.customVariables?.[variableName] ?? "";
+}
+function resolveText(text, context) {
+  const regex = /\{\{([^}]+)\}\}/g;
+  return text.replace(regex, (_, variableName) => {
+    return resolveVariable(variableName.trim(), context);
+  });
+}
+function parseVariables(text) {
+  const regex = /\{\{([^}]+)\}\}/g;
+  const variables = [];
+  let match;
+  while ((match = regex.exec(text)) !== null) {
+    variables.push(match[1].trim());
+  }
+  return variables;
+}
+function hasVariables(text) {
+  return /\{\{[^}]+\}\}/.test(text);
+}
+
+// src/index.ts
+var Paywallo = PaywalloClient;
+var index_default = Paywallo;
+export {
+  AFFILIATE_ERROR_CODES,
+  ANALYTICS_ERROR_CODES,
+  AffiliateError,
+  AffiliateManager,
+  AnalyticsError,
+  ApiClient,
+  CAMPAIGN_ERROR_CODES,
+  CampaignError,
+  PURCHASE_ERROR_CODES as ERROR_CODES,
+  HttpClient,
+  IAPService,
+  IDENTITY_ERROR_CODES,
+  IdentityError,
+  IdentityManager,
+  PAYWALL_ERROR_CODES,
+  PURCHASE_ERROR_CODES,
+  PaywallContext,
+  PaywallError,
+  PaywallModal,
+  Paywallo,
+  PaywalloAffiliate,
+  PaywalloClient,
+  PaywalloContext,
+  PaywalloError,
+  PaywalloProvider,
+  PurchaseError,
+  SESSION_ERROR_CODES,
+  SessionError,
+  SessionManager,
+  SubscriptionCache,
+  affiliateManager,
+  createPurchaseError,
+  index_default as default,
+  detectDeviceLanguage,
+  getCurrentLanguage,
+  getDefaultLanguage,
+  getIAPService,
+  getLocalizedString,
+  hasVariables,
+  identityManager,
+  initLocalization,
+  nativeStoreKit,
+  networkMonitor,
+  offlineQueue,
+  parseVariables,
+  queueProcessor,
+  resolveText,
+  sessionManager,
+  setCurrentLanguage,
+  setDefaultLanguage,
+  subscriptionManager,
+  usePaywallContext,
+  usePaywallo,
+  useProducts,
+  usePurchase,
+  useSubscription
+};
+//# sourceMappingURL=index.mjs.map