@solvapay/react 1.0.6 → 1.0.7

package/dist/index.js

@@ -35,13 +35,26 @@ function isPaidPurchase(purchase) {
   return (purchase.amount ?? 0) > 0;
 }
 
-// src/SolvaPayProvider.tsx
-import { jsx } from "react/jsx-runtime";
-var SolvaPayContext = createContext(null);
+// src/utils/headers.ts
 var CUSTOMER_REF_KEY = "solvapay_customerRef";
 var CUSTOMER_REF_EXPIRY = "solvapay_customerRef_expiry";
 var CUSTOMER_REF_USER_ID_KEY = "solvapay_customerRef_userId";
-var CACHE_DURATION = 24 * 60 * 60 * 1e3;
+function getAuthAdapter(config) {
+  if (config?.auth?.adapter) {
+    return config.auth.adapter;
+  }
+  if (config?.auth?.getToken || config?.auth?.getUserId) {
+    return {
+      async getToken() {
+        return config?.auth?.getToken?.() || null;
+      },
+      async getUserId() {
+        return config?.auth?.getUserId?.() || null;
+      }
+    };
+  }
+  return defaultAuthAdapter;
+}
 function getCachedCustomerRef(userId) {
   if (typeof window === "undefined") return null;
   const cached = localStorage.getItem(CUSTOMER_REF_KEY);
@@ -62,6 +75,7 @@ function getCachedCustomerRef(userId) {
   }
   return cached;
 }
+var CACHE_DURATION = 24 * 60 * 60 * 1e3;
 function setCachedCustomerRef(customerRef, userId) {
   if (typeof window === "undefined") return;
   if (userId === void 0 || userId === null) {
@@ -77,41 +91,62 @@ function clearCachedCustomerRef() {
   localStorage.removeItem(CUSTOMER_REF_EXPIRY);
   localStorage.removeItem(CUSTOMER_REF_USER_ID_KEY);
 }
-function getAuthAdapter(config) {
-  if (config?.auth?.adapter) {
-    return config.auth.adapter;
+async function buildRequestHeaders(config) {
+  const adapter = getAuthAdapter(config);
+  const token = await adapter.getToken();
+  const userId = await adapter.getUserId();
+  const cachedRef = getCachedCustomerRef(userId);
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
   }
-  if (config?.auth?.getToken || config?.auth?.getUserId) {
-    return {
-      async getToken() {
-        return config?.auth?.getToken?.() || null;
-      },
-      async getUserId() {
-        return config?.auth?.getUserId?.() || null;
-      }
-    };
+  if (cachedRef) {
+    headers["x-solvapay-customer-ref"] = cachedRef;
   }
-  return defaultAuthAdapter;
+  if (config?.headers) {
+    const custom = typeof config.headers === "function" ? await config.headers() : config.headers;
+    Object.assign(headers, custom);
+  }
+  return { headers, userId };
 }
+
+// src/SolvaPayProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var SolvaPayContext = createContext(null);
 var SolvaPayProvider = ({
   config,
   createPayment: customCreatePayment,
   checkPurchase: customCheckPurchase,
   processPayment: customProcessPayment,
+  createTopupPayment: customCreateTopupPayment,
   children
 }) => {
   const [purchaseData, setPurchaseData] = useState({
     purchases: []
   });
   const [loading, setLoading] = useState(false);
+  const [isRefetching, setIsRefetching] = useState(false);
+  const [purchaseError, setPurchaseError] = useState(null);
   const [internalCustomerRef, setInternalCustomerRef] = useState(void 0);
   const [userId, setUserId] = useState(null);
   const [isAuthenticated, setIsAuthenticated] = useState(false);
+  const [creditsValue, setCreditsValue] = useState(null);
+  const [displayCurrencyValue, setDisplayCurrencyValue] = useState(null);
+  const [creditsPerMinorUnitValue, setCreditsPerMinorUnitValue] = useState(null);
+  const [displayExchangeRateValue, setDisplayExchangeRateValue] = useState(null);
+  const [balanceLoading, setBalanceLoading] = useState(false);
+  const balanceInFlightRef = useRef(false);
+  const balanceLoadedRef = useRef(false);
+  const optimisticUntilRef = useRef(0);
+  const optimisticTimerRef = useRef(null);
+  const fetchBalanceRef = useRef(null);
   const inFlightRef = useRef(null);
-  const lastFetchedRef = useRef(null);
   const checkPurchaseRef = useRef(null);
   const createPaymentRef = useRef(null);
   const processPaymentRef = useRef(null);
+  const createTopupPaymentRef = useRef(null);
   const configRef = useRef(config);
   const buildDefaultCheckPurchaseRef = useRef(
     null
@@ -128,31 +163,15 @@ var SolvaPayProvider = ({
   useEffect(() => {
     processPaymentRef.current = customProcessPayment || null;
   }, [customProcessPayment]);
+  useEffect(() => {
+    createTopupPaymentRef.current = customCreateTopupPayment || null;
+  }, [customCreateTopupPayment]);
   const buildDefaultCheckPurchase = useCallback(async () => {
     const currentConfig = configRef.current;
-    const adapter = getAuthAdapter(currentConfig);
-    const token = await adapter.getToken();
-    const detectedUserId = await adapter.getUserId();
+    const { headers } = await buildRequestHeaders(currentConfig);
     const route = currentConfig?.api?.checkPurchase || "/api/check-purchase";
     const fetchFn = currentConfig?.fetch || fetch;
-    const cachedRef = getCachedCustomerRef(detectedUserId);
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    if (cachedRef) {
-      headers["x-solvapay-customer-ref"] = cachedRef;
-    }
-    if (currentConfig?.headers) {
-      const customHeaders = typeof currentConfig.headers === "function" ? await currentConfig.headers() : currentConfig.headers;
-      Object.assign(headers, customHeaders);
-    }
-    const res = await fetchFn(route, {
-      method: "GET",
-      headers
-    });
+    const res = await fetchFn(route, { method: "GET", headers });
     if (!res.ok) {
       const error = new Error(`Failed to check purchase: ${res.statusText}`);
       currentConfig?.onError?.(error, "checkPurchase");
@@ -166,26 +185,13 @@ var SolvaPayProvider = ({
   const buildDefaultCreatePayment = useCallback(
     async (params) => {
       const currentConfig = configRef.current;
-      const adapter = getAuthAdapter(currentConfig);
-      const token = await adapter.getToken();
-      const detectedUserId = await adapter.getUserId();
+      const { headers } = await buildRequestHeaders(currentConfig);
       const route = currentConfig?.api?.createPayment || "/api/create-payment-intent";
       const fetchFn = currentConfig?.fetch || fetch;
-      const cachedRef = getCachedCustomerRef(detectedUserId);
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (token) {
-        headers["Authorization"] = `Bearer ${token}`;
-      }
-      if (cachedRef) {
-        headers["x-solvapay-customer-ref"] = cachedRef;
+      const body = {};
+      if (params.planRef) {
+        body.planRef = params.planRef;
       }
-      if (currentConfig?.headers) {
-        const customHeaders = typeof currentConfig.headers === "function" ? await currentConfig.headers() : currentConfig.headers;
-        Object.assign(headers, customHeaders);
-      }
-      const body = { planRef: params.planRef };
       if (params.productRef) {
         body.productRef = params.productRef;
       }
@@ -206,25 +212,9 @@ var SolvaPayProvider = ({
   const buildDefaultProcessPayment = useCallback(
     async (params) => {
       const currentConfig = configRef.current;
-      const adapter = getAuthAdapter(currentConfig);
-      const token = await adapter.getToken();
-      const detectedUserId = await adapter.getUserId();
+      const { headers } = await buildRequestHeaders(currentConfig);
       const route = currentConfig?.api?.processPayment || "/api/process-payment";
       const fetchFn = currentConfig?.fetch || fetch;
-      const cachedRef = getCachedCustomerRef(detectedUserId);
-      const headers = {
-        "Content-Type": "application/json"
-      };
-      if (token) {
-        headers["Authorization"] = `Bearer ${token}`;
-      }
-      if (cachedRef) {
-        headers["x-solvapay-customer-ref"] = cachedRef;
-      }
-      if (currentConfig?.headers) {
-        const customHeaders = typeof currentConfig.headers === "function" ? await currentConfig.headers() : currentConfig.headers;
-        Object.assign(headers, customHeaders);
-      }
       const res = await fetchFn(route, {
         method: "POST",
         headers,
@@ -239,6 +229,86 @@ var SolvaPayProvider = ({
     },
     []
   );
+  const buildDefaultCreateTopupPayment = useCallback(
+    async (params) => {
+      const currentConfig = configRef.current;
+      const { headers } = await buildRequestHeaders(currentConfig);
+      const route = currentConfig?.api?.createTopupPayment || "/api/create-topup-payment-intent";
+      const fetchFn = currentConfig?.fetch || fetch;
+      const res = await fetchFn(route, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          amount: params.amount,
+          currency: params.currency
+        })
+      });
+      if (!res.ok) {
+        const error = new Error(`Failed to create topup payment: ${res.statusText}`);
+        currentConfig?.onError?.(error, "createTopupPayment");
+        throw error;
+      }
+      return res.json();
+    },
+    []
+  );
+  const fetchBalanceImpl = useCallback(async () => {
+    if (optimisticUntilRef.current > Date.now()) return;
+    if (!isAuthenticated && !internalCustomerRef) {
+      setCreditsValue(null);
+      setDisplayCurrencyValue(null);
+      setCreditsPerMinorUnitValue(null);
+      setDisplayExchangeRateValue(null);
+      setBalanceLoading(false);
+      balanceLoadedRef.current = false;
+      return;
+    }
+    if (balanceInFlightRef.current) return;
+    balanceInFlightRef.current = true;
+    if (!balanceLoadedRef.current) {
+      setBalanceLoading(true);
+    }
+    try {
+      const currentConfig = configRef.current;
+      const { headers } = await buildRequestHeaders(currentConfig);
+      const route = currentConfig?.api?.customerBalance || "/api/customer-balance";
+      const fetchFn = currentConfig?.fetch || fetch;
+      const res = await fetchFn(route, { method: "GET", headers });
+      if (!res.ok) {
+        console.error("[SolvaPayProvider] Failed to fetch balance:", res.statusText);
+        return;
+      }
+      const data = await res.json();
+      setCreditsValue(data.credits ?? null);
+      setDisplayCurrencyValue(data.displayCurrency ?? null);
+      setCreditsPerMinorUnitValue(data.creditsPerMinorUnit ?? null);
+      setDisplayExchangeRateValue(data.displayExchangeRate ?? null);
+      balanceLoadedRef.current = true;
+    } catch (error) {
+      console.error("[SolvaPayProvider] Failed to fetch balance:", error);
+    } finally {
+      setBalanceLoading(false);
+      balanceInFlightRef.current = false;
+    }
+  }, [isAuthenticated, internalCustomerRef]);
+  useEffect(() => {
+    fetchBalanceRef.current = fetchBalanceImpl;
+  }, [fetchBalanceImpl]);
+  useEffect(() => {
+    return () => {
+      if (optimisticTimerRef.current) clearTimeout(optimisticTimerRef.current);
+    };
+  }, []);
+  const OPTIMISTIC_GRACE_MS = 8e3;
+  const adjustBalanceImpl = useCallback((credits) => {
+    setCreditsValue((prev) => (prev ?? 0) + credits);
+    optimisticUntilRef.current = Date.now() + OPTIMISTIC_GRACE_MS;
+    if (optimisticTimerRef.current) clearTimeout(optimisticTimerRef.current);
+    optimisticTimerRef.current = setTimeout(() => {
+      optimisticUntilRef.current = 0;
+      fetchBalanceRef.current?.();
+    }, OPTIMISTIC_GRACE_MS);
+  }, []);
   const _checkPurchase = useCallback(async () => {
     if (checkPurchaseRef.current) {
       return checkPurchaseRef.current();
@@ -266,6 +336,15 @@ var SolvaPayProvider = ({
     },
     [buildDefaultProcessPayment]
   );
+  const createTopupPayment = useCallback(
+    async (params) => {
+      if (createTopupPaymentRef.current) {
+        return createTopupPaymentRef.current(params);
+      }
+      return buildDefaultCreateTopupPayment(params);
+    },
+    [buildDefaultCreateTopupPayment]
+  );
   useEffect(() => {
     const detectAuth = async () => {
       const currentConfig = configRef.current;
@@ -291,27 +370,30 @@ var SolvaPayProvider = ({
       }
     };
     detectAuth();
-    const interval = setInterval(detectAuth, 5e3);
+    const interval = setInterval(detectAuth, 3e4);
     return () => clearInterval(interval);
   }, [userId]);
   const fetchPurchase = useCallback(
     async (force = false) => {
       if (!isAuthenticated && !internalCustomerRef) {
         setPurchaseData({ purchases: [] });
+        setPurchaseError(null);
         setLoading(false);
+        setIsRefetching(false);
         inFlightRef.current = null;
-        lastFetchedRef.current = null;
         return;
       }
       const cacheKey = internalCustomerRef || userId || "anonymous";
-      if (!force && lastFetchedRef.current === cacheKey && inFlightRef.current !== cacheKey) {
-        return;
-      }
-      if (inFlightRef.current === cacheKey) {
+      if (inFlightRef.current === cacheKey && !force) {
         return;
       }
       inFlightRef.current = cacheKey;
-      setLoading(true);
+      const hasExistingData = purchaseData.purchases.length > 0;
+      if (hasExistingData) {
+        setIsRefetching(true);
+      } else {
+        setLoading(true);
+      }
       try {
         const checkFn = checkPurchaseRef.current || buildDefaultCheckPurchaseRef.current;
         if (!checkFn) {
@@ -330,43 +412,111 @@ var SolvaPayProvider = ({
             purchases: filterPurchases(data.purchases || [])
           };
           setPurchaseData(filteredData);
-          lastFetchedRef.current = cacheKey;
+          setPurchaseError(null);
         }
-      } catch (error) {
-        console.error("[SolvaPayProvider] Failed to fetch purchase:", error);
+      } catch (err) {
+        console.error("[SolvaPayProvider] Failed to fetch purchase:", err);
         if (inFlightRef.current === cacheKey) {
-          setPurchaseData({
-            purchases: []
-          });
-          lastFetchedRef.current = cacheKey;
+          setPurchaseError(err instanceof Error ? err : new Error(String(err)));
         }
       } finally {
         if (inFlightRef.current === cacheKey) {
           setLoading(false);
+          setIsRefetching(false);
           inFlightRef.current = null;
         }
       }
     },
-    [isAuthenticated, internalCustomerRef, userId]
+    [isAuthenticated, internalCustomerRef, userId, purchaseData.purchases.length]
   );
   const fetchPurchaseRef = useRef(fetchPurchase);
   useEffect(() => {
     fetchPurchaseRef.current = fetchPurchase;
   }, [fetchPurchase]);
   const refetchPurchase = useCallback(async () => {
-    lastFetchedRef.current = null;
     inFlightRef.current = null;
-    setPurchaseData({ purchases: [] });
     await fetchPurchaseRef.current(true);
   }, []);
+  const cancelRenewal = useCallback(
+    async (params) => {
+      const currentConfig = configRef.current;
+      const { headers } = await buildRequestHeaders(currentConfig);
+      const route = currentConfig?.api?.cancelRenewal || "/api/cancel-renewal";
+      const fetchFn = currentConfig?.fetch || fetch;
+      const res = await fetchFn(route, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        const error = new Error(data.error || `Failed to cancel renewal: ${res.statusText}`);
+        currentConfig?.onError?.(error, "cancelRenewal");
+        throw error;
+      }
+      const result = await res.json();
+      await refetchPurchase();
+      return result;
+    },
+    [refetchPurchase]
+  );
+  const reactivateRenewal = useCallback(
+    async (params) => {
+      const currentConfig = configRef.current;
+      const { headers } = await buildRequestHeaders(currentConfig);
+      const route = currentConfig?.api?.reactivateRenewal || "/api/reactivate-renewal";
+      const fetchFn = currentConfig?.fetch || fetch;
+      const res = await fetchFn(route, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        const error = new Error(data.error || `Failed to reactivate renewal: ${res.statusText}`);
+        currentConfig?.onError?.(error, "reactivateRenewal");
+        throw error;
+      }
+      const result = await res.json();
+      await refetchPurchase();
+      return result;
+    },
+    [refetchPurchase]
+  );
+  const activatePlan = useCallback(
+    async (params) => {
+      const currentConfig = configRef.current;
+      const { headers } = await buildRequestHeaders(currentConfig);
+      const route = currentConfig?.api?.activatePlan || "/api/activate-plan";
+      const fetchFn = currentConfig?.fetch || fetch;
+      const res = await fetchFn(route, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const data = await res.json().catch(() => ({}));
+        const error = new Error(data.error || `Failed to activate plan: ${res.statusText}`);
+        currentConfig?.onError?.(error, "activatePlan");
+        throw error;
+      }
+      const result = await res.json();
+      if (result.status === "activated" || result.status === "already_active") {
+        await refetchPurchase();
+      }
+      return result;
+    },
+    [refetchPurchase]
+  );
   useEffect(() => {
-    lastFetchedRef.current = null;
     inFlightRef.current = null;
     if (isAuthenticated || internalCustomerRef) {
       fetchPurchase();
     } else {
       setPurchaseData({ purchases: [] });
+      setPurchaseError(null);
       setLoading(false);
+      setIsRefetching(false);
     }
   }, [isAuthenticated, internalCustomerRef, userId]);
   const updateCustomerRef = useCallback(
@@ -387,6 +537,8 @@ var SolvaPayProvider = ({
     )[0] || null;
     return {
       loading,
+      isRefetching,
+      error: purchaseError,
       customerRef: purchaseData.customerRef || internalCustomerRef,
       email: purchaseData.email,
       name: purchaseData.name,
@@ -405,24 +557,47 @@ var SolvaPayProvider = ({
       hasPaidPurchase: activePaidPurchases.length > 0,
       activePaidPurchase
     };
-  }, [loading, purchaseData, internalCustomerRef]);
+  }, [loading, isRefetching, purchaseError, purchaseData, internalCustomerRef]);
+  const balance = useMemo(
+    () => ({
+      loading: balanceLoading,
+      credits: creditsValue,
+      displayCurrency: displayCurrencyValue,
+      creditsPerMinorUnit: creditsPerMinorUnitValue,
+      displayExchangeRate: displayExchangeRateValue,
+      refetch: fetchBalanceImpl,
+      adjustBalance: adjustBalanceImpl
+    }),
+    [balanceLoading, creditsValue, displayCurrencyValue, creditsPerMinorUnitValue, displayExchangeRateValue, fetchBalanceImpl, adjustBalanceImpl]
+  );
   const contextValue = useMemo(
     () => ({
       purchase,
       refetchPurchase,
       createPayment,
       processPayment,
+      createTopupPayment,
+      cancelRenewal,
+      reactivateRenewal,
+      activatePlan,
       customerRef: purchaseData.customerRef || internalCustomerRef,
-      updateCustomerRef
+      updateCustomerRef,
+      balance,
+      _config: configRef.current
     }),
     [
       purchase,
       refetchPurchase,
       createPayment,
       processPayment,
+      createTopupPayment,
+      cancelRenewal,
+      reactivateRenewal,
+      activatePlan,
       purchaseData.customerRef,
       internalCustomerRef,
-      updateCustomerRef
+      updateCustomerRef,
+      balance
     ]
   );
   return /* @__PURE__ */ jsx(SolvaPayContext.Provider, { value: contextValue, children });
@@ -453,29 +628,66 @@ var stripePromiseCache = /* @__PURE__ */ new Map();
 function getStripeCacheKey(publishableKey, accountId) {
   return accountId ? `${publishableKey}:${accountId}` : publishableKey;
 }
+async function resolvePlanRef(productRef, fetchFn, headers, listPlansRoute) {
+  const url = `${listPlansRoute}?productRef=${encodeURIComponent(productRef)}`;
+  const res = await fetchFn(url, { method: "GET", headers });
+  if (!res.ok) {
+    throw new Error(`Failed to fetch plans for product "${productRef}": ${res.statusText}`);
+  }
+  const data = await res.json();
+  const allPlans = data.plans ?? [];
+  const activePlans = allPlans.filter((p) => p.isActive !== false && p.status !== "inactive");
+  if (activePlans.length === 0) {
+    throw new Error(
+      `No active plans found for product "${productRef}". Configure at least one plan in the SolvaPay Console.`
+    );
+  }
+  if (activePlans.length === 1) {
+    return activePlans[0].reference;
+  }
+  const defaultPlan = activePlans.find((p) => p.default === true);
+  if (defaultPlan) {
+    return defaultPlan.reference;
+  }
+  throw new Error(
+    `Product "${productRef}" has ${activePlans.length} active plans but none is marked as default. Either pass planRef explicitly, use <PricingSelector> for user selection, or mark one plan as default in the SolvaPay Console.`
+  );
+}
 function useCheckout(options) {
   const { planRef, productRef } = options;
-  const { createPayment, customerRef, updateCustomerRef } = useSolvaPay();
+  const { createPayment, customerRef, updateCustomerRef, _config } = useSolvaPay();
   const [loading, setLoading] = useState2(false);
-  const [error, setError] = useState2(
-    !planRef || typeof planRef !== "string" ? new Error("useCheckout: planRef parameter is required and must be a string") : null
-  );
+  const [error, setError] = useState2(null);
   const [stripePromise, setStripePromise] = useState2(null);
   const [clientSecret, setClientSecret] = useState2(null);
+  const [resolvedPlanRef, setResolvedPlanRef] = useState2(planRef || null);
   const isStartingRef = useRef2(false);
   const startCheckout = useCallback2(async () => {
     if (isStartingRef.current || loading) {
       return;
     }
-    if (!planRef || typeof planRef !== "string") {
-      setError(new Error("useCheckout: planRef parameter is required and must be a string"));
+    if (!planRef && !productRef) {
+      setError(
+        new Error(
+          "useCheckout: either planRef or productRef is required. Pass planRef directly, or pass productRef to auto-resolve the plan."
+        )
+      );
       return;
     }
     isStartingRef.current = true;
     setLoading(true);
     setError(null);
     try {
-      const result = await createPayment({ planRef, productRef });
+      let effectivePlanRef = planRef;
+      if (!effectivePlanRef && productRef) {
+        const listPlansRoute = _config?.api?.listPlans || "/api/list-plans";
+        effectivePlanRef = await resolvePlanRef(productRef, fetch, {}, listPlansRoute);
+        setResolvedPlanRef(effectivePlanRef);
+      }
+      if (!effectivePlanRef) {
+        throw new Error("Could not determine plan reference for checkout");
+      }
+      const result = await createPayment({ planRef: effectivePlanRef, productRef });
       if (!result || typeof result !== "object") {
         throw new Error("Invalid payment intent response from server");
       }
@@ -504,19 +716,21 @@ function useCheckout(options) {
       setLoading(false);
       isStartingRef.current = false;
     }
-  }, [planRef, productRef, createPayment, updateCustomerRef, loading]);
+  }, [planRef, productRef, createPayment, updateCustomerRef, loading, _config]);
   const reset = useCallback2(() => {
     isStartingRef.current = false;
     setLoading(false);
     setError(null);
     setStripePromise(null);
     setClientSecret(null);
-  }, []);
+    setResolvedPlanRef(planRef || null);
+  }, [planRef]);
   return {
     loading,
     error,
     stripePromise,
     clientSecret,
+    resolvedPlanRef,
     startCheckout,
     reset
   };
@@ -684,14 +898,16 @@ var StripePaymentFormWrapper = ({
   const cardElementOptions = {
     style: {
       base: {
-        fontSize: "16px",
-        color: "#424770",
+        fontSize: "17px",
+        lineHeight: "24px",
+        color: "#1e293b",
+        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
         "::placeholder": {
-          color: "#aab7c4"
+          color: "#94a3b8"
         }
       },
       invalid: {
-        color: "#9e2146"
+        color: "#dc2626"
       }
     },
     hidePostalCode: true
@@ -711,22 +927,7 @@ var StripePaymentFormWrapper = ({
           }
         }
       }
-    ) : /* @__PURE__ */ jsx3(
-      "div",
-      {
-        style: {
-          padding: "12px",
-          border: "1px solid #cbd5e1",
-          borderRadius: "0.375rem",
-          backgroundColor: "white",
-          display: "flex",
-          alignItems: "center",
-          justifyContent: "center",
-          minHeight: "40px"
-        },
-        children: /* @__PURE__ */ jsx3(Spinner, { size: "sm" })
-      }
-    ),
+    ) : /* @__PURE__ */ jsx3("div", { style: { display: "flex", alignItems: "center", justifyContent: "center", minHeight: "52px" }, children: /* @__PURE__ */ jsx3(Spinner, { size: "sm" }) }),
     message && !isSuccess && /* @__PURE__ */ jsx3("div", { role: "alert", "aria-live": "assertive", "aria-atomic": "true", children: message }),
     /* @__PURE__ */ jsx3(
       "button",
@@ -758,88 +959,62 @@ var PaymentForm = ({
   className,
   buttonClassName
 }) => {
-  const validPlanRef = planRef && typeof planRef === "string" ? planRef : "";
   const {
     loading: checkoutLoading,
     error: checkoutError,
     clientSecret,
     startCheckout,
-    stripePromise
-  } = useCheckout({ planRef: validPlanRef, productRef });
+    stripePromise,
+    resolvedPlanRef
+  } = useCheckout({ planRef, productRef });
   const { refetch } = usePurchase();
   const { processPayment } = useSolvaPay();
   const hasInitializedRef = useRef3(false);
+  const hasPlanOrProduct = !!(planRef || productRef);
   useEffect2(() => {
-    if (!hasInitializedRef.current && validPlanRef && !checkoutLoading && !checkoutError && !clientSecret) {
+    if (!hasInitializedRef.current && hasPlanOrProduct && !checkoutLoading && !checkoutError && !clientSecret) {
       hasInitializedRef.current = true;
       startCheckout().catch(() => {
         hasInitializedRef.current = false;
       });
     }
-    if (validPlanRef && clientSecret) {
+    if (hasPlanOrProduct && clientSecret) {
       hasInitializedRef.current = true;
     }
-  }, [validPlanRef, checkoutLoading, checkoutError, clientSecret, startCheckout]);
+  }, [hasPlanOrProduct, checkoutLoading, checkoutError, clientSecret, startCheckout]);
+  const effectivePlanRef = planRef || resolvedPlanRef;
   const handleSuccess = useCallback3(
     async (paymentIntent) => {
-      let processingTimeout = false;
-      let processingResult = null;
       const paymentIntentAny = paymentIntent;
       if (processPayment && productRef) {
         try {
           const result = await processPayment({
             paymentIntentId: paymentIntentAny.id,
             productRef,
-            planRef
+            planRef: effectivePlanRef || void 0
           });
-          processingResult = result;
           const isTimeout = result?.status === "timeout";
-          processingTimeout = isTimeout;
           if (isTimeout) {
             for (let attempt = 1; attempt <= 5; attempt++) {
-              const delay = attempt * 1e3;
-              await new Promise((resolve) => setTimeout(resolve, delay));
+              await new Promise((resolve) => setTimeout(resolve, attempt * 1e3));
               await refetch();
             }
-            if (onSuccess) {
-              await onSuccess({
-                ...paymentIntentAny,
-                _processingTimeout: processingTimeout,
-                _processingResult: processingResult
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              });
-            }
-            throw new Error("Payment processing timed out");
-          } else {
-            await refetch();
+            const err = new Error("Payment processing timed out \u2014 webhooks may not be configured");
+            onError?.(err);
+            return;
           }
+          await refetch();
         } catch (error) {
           console.error("[PaymentForm] Failed to process payment:", error);
-          if (onSuccess) {
-            try {
-              await onSuccess({
-                ...paymentIntentAny,
-                _processingError: error
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              });
-            } catch {
-            }
-          }
-          throw error;
+          onError?.(error instanceof Error ? error : new Error(String(error)));
+          return;
         }
       } else {
         await refetch();
       }
-      if (onSuccess && !processingTimeout) {
-        await onSuccess({
-          ...paymentIntentAny,
-          _processingTimeout: processingTimeout,
-          _processingResult: processingResult
-          // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        });
-      }
+      onSuccess?.(paymentIntentAny);
     },
-    [processPayment, productRef, planRef, refetch, onSuccess]
+    [processPayment, productRef, effectivePlanRef, refetch, onSuccess, onError]
   );
   const handleError = useCallback3(
     (err) => {
@@ -850,7 +1025,6 @@ var PaymentForm = ({
     [onError]
   );
   const finalReturnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
-  const isValidPlanRef = planRef && typeof planRef === "string";
   const hasError = !!checkoutError;
   const hasStripeData = !!(stripePromise && clientSecret);
   const elementsOptions = useMemo2(() => {
@@ -864,72 +1038,246 @@ var PaymentForm = ({
     }
   }, [hasStripeData]);
   const shouldRenderElements = hasStripeData || hasMountedElements && stripePromise && clientSecret;
-  return /* @__PURE__ */ jsx4("div", { className, children: !isValidPlanRef ? /* @__PURE__ */ jsx4("div", { children: "PaymentForm: planRef is required and must be a string" }) : hasError ? /* @__PURE__ */ jsxs3("div", { children: [
+  return /* @__PURE__ */ jsx4("div", { className, children: !hasPlanOrProduct ? /* @__PURE__ */ jsx4("div", { children: "PaymentForm: either planRef or productRef is required" }) : hasError ? /* @__PURE__ */ jsxs3("div", { children: [
     /* @__PURE__ */ jsx4("div", { children: "Payment initialization failed" }),
     /* @__PURE__ */ jsx4("div", { children: checkoutError?.message || "Unknown error" })
-  ] }) : shouldRenderElements && elementsOptions ? (
-    // Once we have Stripe data, always render Elements to maintain hook consistency
-    // This prevents hook count mismatches when transitioning between states
+  ] }) : shouldRenderElements && elementsOptions ? /* @__PURE__ */ jsx4(
+    Elements,
+    {
+      stripe: stripePromise,
+      options: elementsOptions,
+      children: /* @__PURE__ */ jsx4(
+        StripePaymentFormWrapper,
+        {
+          onSuccess: handleSuccess,
+          onError: handleError,
+          returnUrl: finalReturnUrl,
+          submitButtonText,
+          buttonClassName,
+          clientSecret
+        }
+      )
+    },
+    clientSecret
+  ) : /* @__PURE__ */ jsxs3("div", { children: [
     /* @__PURE__ */ jsx4(
-      Elements,
+      "div",
       {
-        stripe: stripePromise,
-        options: elementsOptions,
-        children: /* @__PURE__ */ jsx4(
-          StripePaymentFormWrapper,
-          {
-            onSuccess: handleSuccess,
-            onError: handleError,
-            returnUrl: finalReturnUrl,
-            submitButtonText,
-            buttonClassName,
-            clientSecret
-          }
-        )
-      },
-      clientSecret
+        style: {
+          minHeight: "40px",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center"
+        },
+        children: /* @__PURE__ */ jsx4(Spinner, { size: "md" })
+      }
+    ),
+    /* @__PURE__ */ jsx4(
+      "button",
+      {
+        type: "submit",
+        disabled: true,
+        className: buttonClassName,
+        "aria-busy": "false",
+        "aria-disabled": "true",
+        children: submitButtonText
+      }
     )
-  ) : (
-    // Loading state before Stripe data is available
-    /* @__PURE__ */ jsxs3("div", { children: [
-      /* @__PURE__ */ jsx4(
-        "div",
-        {
-          style: {
-            minHeight: "40px",
-            display: "flex",
-            alignItems: "center",
-            justifyContent: "center"
-          },
-          children: /* @__PURE__ */ jsx4(Spinner, { size: "md" })
-        }
-      ),
-      /* @__PURE__ */ jsx4(
-        "button",
+  ] }) });
+};
+
+// src/TopupForm.tsx
+import { useEffect as useEffect3, useCallback as useCallback5, useRef as useRef5, useMemo as useMemo3 } from "react";
+import { Elements as Elements2 } from "@stripe/react-stripe-js";
+
+// src/hooks/useTopup.ts
+import { useState as useState5, useCallback as useCallback4, useRef as useRef4 } from "react";
+import { loadStripe as loadStripe2 } from "@stripe/stripe-js";
+var stripePromiseCache2 = /* @__PURE__ */ new Map();
+function getStripeCacheKey2(publishableKey, accountId) {
+  return accountId ? `${publishableKey}:${accountId}` : publishableKey;
+}
+function useTopup(options) {
+  const { amount, currency } = options;
+  const { createTopupPayment, customerRef, updateCustomerRef } = useSolvaPay();
+  const [loading, setLoading] = useState5(false);
+  const [error, setError] = useState5(null);
+  const [stripePromise, setStripePromise] = useState5(null);
+  const [clientSecret, setClientSecret] = useState5(null);
+  const isStartingRef = useRef4(false);
+  const startTopup = useCallback4(async () => {
+    if (isStartingRef.current || loading) {
+      return;
+    }
+    if (!amount || amount <= 0) {
+      setError(new Error("useTopup: amount must be a positive number"));
+      return;
+    }
+    isStartingRef.current = true;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await createTopupPayment({ amount, currency });
+      if (!result || typeof result !== "object") {
+        throw new Error("Invalid topup payment intent response from server");
+      }
+      if (!result.clientSecret || typeof result.clientSecret !== "string") {
+        throw new Error("Invalid client secret in topup payment intent response");
+      }
+      if (!result.publishableKey || typeof result.publishableKey !== "string") {
+        throw new Error("Invalid publishable key in topup payment intent response");
+      }
+      if (result.customerRef && result.customerRef !== customerRef && updateCustomerRef) {
+        updateCustomerRef(result.customerRef);
+      }
+      const stripeOptions = result.accountId ? { stripeAccount: result.accountId } : {};
+      const cacheKey = getStripeCacheKey2(result.publishableKey, result.accountId);
+      let stripe = stripePromiseCache2.get(cacheKey);
+      if (!stripe) {
+        stripe = loadStripe2(result.publishableKey, stripeOptions);
+        stripePromiseCache2.set(cacheKey, stripe);
+      }
+      setStripePromise(stripe);
+      setClientSecret(result.clientSecret);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to start topup");
+      setError(error2);
+    } finally {
+      setLoading(false);
+      isStartingRef.current = false;
+    }
+  }, [amount, currency, createTopupPayment, customerRef, updateCustomerRef, loading]);
+  const reset = useCallback4(() => {
+    isStartingRef.current = false;
+    setLoading(false);
+    setError(null);
+    setStripePromise(null);
+    setClientSecret(null);
+  }, []);
+  return {
+    loading,
+    error,
+    stripePromise,
+    clientSecret,
+    startTopup,
+    reset
+  };
+}
+
+// src/TopupForm.tsx
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var TopupForm = ({
+  amount,
+  currency,
+  onSuccess,
+  onError,
+  returnUrl,
+  submitButtonText = "Top Up",
+  className,
+  buttonClassName
+}) => {
+  const {
+    loading: topupLoading,
+    error: topupError,
+    clientSecret,
+    startTopup,
+    stripePromise
+  } = useTopup({ amount, currency });
+  const hasInitializedRef = useRef5(false);
+  const hasAmount = amount > 0;
+  useEffect3(() => {
+    if (!hasInitializedRef.current && hasAmount && !topupLoading && !topupError && !clientSecret) {
+      hasInitializedRef.current = true;
+      startTopup().catch(() => {
+        hasInitializedRef.current = false;
+      });
+    }
+    if (hasAmount && clientSecret) {
+      hasInitializedRef.current = true;
+    }
+  }, [hasAmount, topupLoading, topupError, clientSecret, startTopup]);
+  const handleSuccess = useCallback5(
+    async (paymentIntent) => {
+      if (onSuccess) {
+        await onSuccess(paymentIntent);
+      }
+    },
+    [onSuccess]
+  );
+  const handleError = useCallback5(
+    (err) => {
+      if (onError) {
+        onError(err);
+      }
+    },
+    [onError]
+  );
+  const finalReturnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
+  const hasError = !!topupError;
+  const hasStripeData = !!(stripePromise && clientSecret);
+  const elementsOptions = useMemo3(() => {
+    if (!clientSecret) return void 0;
+    return { clientSecret };
+  }, [clientSecret]);
+  return /* @__PURE__ */ jsx5("div", { className, children: !hasAmount ? /* @__PURE__ */ jsx5("div", { children: "TopupForm: amount must be a positive number" }) : hasError ? /* @__PURE__ */ jsxs4("div", { children: [
+    /* @__PURE__ */ jsx5("div", { children: "Top-up initialization failed" }),
+    /* @__PURE__ */ jsx5("div", { children: topupError?.message || "Unknown error" })
+  ] }) : hasStripeData && elementsOptions ? /* @__PURE__ */ jsx5(
+    Elements2,
+    {
+      stripe: stripePromise,
+      options: elementsOptions,
+      children: /* @__PURE__ */ jsx5(
+        StripePaymentFormWrapper,
         {
-          type: "submit",
-          disabled: true,
-          className: buttonClassName,
-          "aria-busy": "false",
-          "aria-disabled": "true",
-          children: submitButtonText
+          onSuccess: handleSuccess,
+          onError: handleError,
+          returnUrl: finalReturnUrl,
+          submitButtonText,
+          buttonClassName,
+          clientSecret
         }
       )
-    ] })
-  ) });
+    },
+    clientSecret
+  ) : /* @__PURE__ */ jsxs4("div", { children: [
+    /* @__PURE__ */ jsx5(
+      "div",
+      {
+        style: {
+          minHeight: "40px",
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center"
+        },
+        children: /* @__PURE__ */ jsx5(Spinner, { size: "md" })
+      }
+    ),
+    /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "submit",
+        disabled: true,
+        className: buttonClassName,
+        "aria-busy": "false",
+        "aria-disabled": "true",
+        children: submitButtonText
+      }
+    )
+  ] }) });
 };
 
 // src/components/ProductBadge.tsx
-import React4 from "react";
-import { Fragment as Fragment2, jsx as jsx5 } from "react/jsx-runtime";
+import React5 from "react";
+import { Fragment as Fragment2, jsx as jsx6 } from "react/jsx-runtime";
 var ProductBadge = ({
   children,
   as: Component = "div",
   className
 }) => {
   const { purchases, loading, hasPaidPurchase, activePurchase } = usePurchase();
-  const [hasLoadedOnce, setHasLoadedOnce] = React4.useState(false);
-  React4.useEffect(() => {
+  const [hasLoadedOnce, setHasLoadedOnce] = React5.useState(false);
+  React5.useEffect(() => {
     if (!loading) {
       setHasLoadedOnce(true);
     }
@@ -937,13 +1285,13 @@ var ProductBadge = ({
   const planToDisplay = activePurchase?.productName || null;
   const shouldShow = planToDisplay !== null && (!loading || hasLoadedOnce);
   if (children) {
-    return /* @__PURE__ */ jsx5(Fragment2, { children: children({ purchases, loading, displayPlan: planToDisplay, shouldShow }) });
+    return /* @__PURE__ */ jsx6(Fragment2, { children: children({ purchases, loading, displayPlan: planToDisplay, shouldShow }) });
   }
   if (!shouldShow) {
     return null;
   }
   const computedClassName = typeof className === "function" ? className({ purchases }) : className;
-  return /* @__PURE__ */ jsx5(
+  return /* @__PURE__ */ jsx6(
     Component,
     {
       className: computedClassName,
@@ -961,12 +1309,12 @@ var ProductBadge = ({
 var PlanBadge = ProductBadge;
 
 // src/components/PurchaseGate.tsx
-import { Fragment as Fragment3, jsx as jsx6 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx7 } from "react/jsx-runtime";
 var PurchaseGate = ({ requirePlan, requireProduct, children }) => {
   const { purchases, loading, hasProduct } = usePurchase();
   const productToCheck = requireProduct || requirePlan;
   const hasAccess = productToCheck ? hasProduct(productToCheck) : purchases.some((p) => p.status === "active");
-  return /* @__PURE__ */ jsx6(Fragment3, { children: children({
+  return /* @__PURE__ */ jsx7(Fragment3, { children: children({
     hasAccess,
     purchases,
     loading
@@ -974,35 +1322,103 @@ var PurchaseGate = ({ requirePlan, requireProduct, children }) => {
 };
 
 // src/components/PricingSelector.tsx
-import { useCallback as useCallback5, useMemo as useMemo4 } from "react";
+import { useCallback as useCallback7, useMemo as useMemo5 } from "react";
 
 // src/hooks/usePlans.ts
-import { useState as useState5, useEffect as useEffect3, useCallback as useCallback4, useMemo as useMemo3, useRef as useRef4 } from "react";
+import { useState as useState6, useEffect as useEffect4, useCallback as useCallback6, useMemo as useMemo4, useRef as useRef6 } from "react";
 var plansCache = /* @__PURE__ */ new Map();
 var CACHE_DURATION2 = 5 * 60 * 1e3;
+function processPlans(raw, filter, sortBy) {
+  let result = sortBy ? [...raw].sort(sortBy) : raw;
+  if (filter) result = result.filter(filter);
+  return result;
+}
+function computeInitialIndex(plans, initialPlanRef, autoSelectFirstPaid) {
+  if (plans.length === 0) return 0;
+  if (initialPlanRef) {
+    const idx = plans.findIndex((p) => p.reference === initialPlanRef);
+    if (idx >= 0) return idx;
+  }
+  if (autoSelectFirstPaid) {
+    const idx = plans.findIndex((p) => p.requiresPayment !== false);
+    return idx >= 0 ? idx : 0;
+  }
+  return 0;
+}
 function usePlans(options) {
-  const { fetcher, productRef, filter, sortBy, autoSelectFirstPaid = false } = options;
-  const [plans, setPlans] = useState5([]);
-  const [loading, setLoading] = useState5(true);
-  const [error, setError] = useState5(null);
-  const [selectedPlanIndex, setSelectedPlanIndex] = useState5(0);
-  const fetcherRef = useRef4(fetcher);
-  const filterRef = useRef4(filter);
-  const sortByRef = useRef4(sortBy);
-  const autoSelectFirstPaidRef = useRef4(autoSelectFirstPaid);
-  useEffect3(() => {
+  const {
+    fetcher,
+    productRef,
+    filter,
+    sortBy,
+    autoSelectFirstPaid = false,
+    initialPlanRef,
+    selectionReady = true
+  } = options;
+  const fetcherRef = useRef6(fetcher);
+  const filterRef = useRef6(filter);
+  const sortByRef = useRef6(sortBy);
+  const autoSelectFirstPaidRef = useRef6(autoSelectFirstPaid);
+  const initialPlanRefRef = useRef6(initialPlanRef);
+  const selectionReadyRef = useRef6(selectionReady);
+  const hasAppliedInitialRef = useRef6(false);
+  const userHasSelectedRef = useRef6(false);
+  const [selectedPlanIndex, setSelectedPlanIndexState] = useState6(() => {
+    if (!selectionReady || !productRef) return 0;
+    const cached = plansCache.get(productRef);
+    if (!cached || Date.now() - cached.timestamp >= CACHE_DURATION2 || cached.plans.length === 0) {
+      return 0;
+    }
+    const processed = processPlans(cached.plans, filter, sortBy);
+    if (processed.length === 0) return 0;
+    const idx = computeInitialIndex(processed, initialPlanRef, autoSelectFirstPaid);
+    hasAppliedInitialRef.current = true;
+    return idx;
+  });
+  const [plans, setPlans] = useState6(() => {
+    if (!productRef) return [];
+    const cached = plansCache.get(productRef);
+    if (!cached || Date.now() - cached.timestamp >= CACHE_DURATION2 || cached.plans.length === 0) {
+      return [];
+    }
+    return processPlans(cached.plans, filter, sortBy);
+  });
+  const [loading, setLoading] = useState6(() => plans.length === 0);
+  const [error, setError] = useState6(null);
+  useEffect4(() => {
     fetcherRef.current = fetcher;
   }, [fetcher]);
-  useEffect3(() => {
+  useEffect4(() => {
     filterRef.current = filter;
   }, [filter]);
-  useEffect3(() => {
+  useEffect4(() => {
     sortByRef.current = sortBy;
   }, [sortBy]);
-  useEffect3(() => {
+  useEffect4(() => {
     autoSelectFirstPaidRef.current = autoSelectFirstPaid;
   }, [autoSelectFirstPaid]);
-  const fetchPlans = useCallback4(
+  useEffect4(() => {
+    initialPlanRefRef.current = initialPlanRef;
+  }, [initialPlanRef]);
+  useEffect4(() => {
+    selectionReadyRef.current = selectionReady;
+  }, [selectionReady]);
+  const setSelectedPlanIndex = useCallback6((index) => {
+    userHasSelectedRef.current = true;
+    setSelectedPlanIndexState(index);
+  }, []);
+  const applyInitialSelection = useCallback6((processedPlans) => {
+    if (hasAppliedInitialRef.current || userHasSelectedRef.current) return;
+    if (!selectionReadyRef.current || processedPlans.length === 0) return;
+    hasAppliedInitialRef.current = true;
+    const idx = computeInitialIndex(
+      processedPlans,
+      initialPlanRefRef.current,
+      autoSelectFirstPaidRef.current
+    );
+    setSelectedPlanIndexState(idx);
+  }, []);
+  const fetchPlans = useCallback6(
     async (force = false) => {
       if (!productRef) {
         setError(new Error("Product reference not configured"));
@@ -1012,34 +1428,29 @@ function usePlans(options) {
       const cached = plansCache.get(productRef);
       const now = Date.now();
       if (!force && cached && now - cached.timestamp < CACHE_DURATION2) {
-        const cachedPlans = cached.plans;
-        let processedPlans = filterRef.current ? cachedPlans.filter(filterRef.current) : cachedPlans;
-        if (sortByRef.current) {
-          processedPlans = [...processedPlans].sort(sortByRef.current);
-        }
+        const processedPlans = processPlans(
+          cached.plans,
+          filterRef.current,
+          sortByRef.current
+        );
         setPlans(processedPlans);
         setLoading(false);
         setError(null);
-        if (autoSelectFirstPaidRef.current && processedPlans.length > 0) {
-          const firstPaidIndex = processedPlans.findIndex((plan) => plan.price && plan.price > 0);
-          setSelectedPlanIndex(firstPaidIndex >= 0 ? firstPaidIndex : 0);
-        }
+        applyInitialSelection(processedPlans);
         return;
       }
       if (cached?.promise) {
         try {
           setLoading(true);
           const fetchedPlans = await cached.promise;
-          let processedPlans = filterRef.current ? fetchedPlans.filter(filterRef.current) : fetchedPlans;
-          if (sortByRef.current) {
-            processedPlans = [...processedPlans].sort(sortByRef.current);
-          }
+          const processedPlans = processPlans(
+            fetchedPlans,
+            filterRef.current,
+            sortByRef.current
+          );
           setPlans(processedPlans);
           setError(null);
-          if (autoSelectFirstPaidRef.current && processedPlans.length > 0) {
-            const firstPaidIndex = processedPlans.findIndex((plan) => plan.price && plan.price > 0);
-            setSelectedPlanIndex(firstPaidIndex >= 0 ? firstPaidIndex : 0);
-          }
+          applyInitialSelection(processedPlans);
         } catch (err) {
           setError(err instanceof Error ? err : new Error("Failed to load plans"));
         } finally {
@@ -1051,26 +1462,16 @@ function usePlans(options) {
         setLoading(true);
         setError(null);
         const fetchPromise = fetcherRef.current(productRef);
-        plansCache.set(productRef, {
-          plans: [],
-          timestamp: now,
-          promise: fetchPromise
-        });
+        plansCache.set(productRef, { plans: [], timestamp: now, promise: fetchPromise });
         const fetchedPlans = await fetchPromise;
-        plansCache.set(productRef, {
-          plans: fetchedPlans,
-          timestamp: now,
-          promise: null
-        });
-        let processedPlans = filterRef.current ? fetchedPlans.filter(filterRef.current) : fetchedPlans;
-        if (sortByRef.current) {
-          processedPlans = [...processedPlans].sort(sortByRef.current);
-        }
+        plansCache.set(productRef, { plans: fetchedPlans, timestamp: now, promise: null });
+        const processedPlans = processPlans(
+          fetchedPlans,
+          filterRef.current,
+          sortByRef.current
+        );
         setPlans(processedPlans);
-        if (autoSelectFirstPaidRef.current && processedPlans.length > 0) {
-          const firstPaidIndex = processedPlans.findIndex((plan) => plan.price && plan.price > 0);
-          setSelectedPlanIndex(firstPaidIndex >= 0 ? firstPaidIndex : 0);
-        }
+        applyInitialSelection(processedPlans);
       } catch (err) {
         plansCache.delete(productRef);
         setError(err instanceof Error ? err : new Error("Failed to load plans"));
@@ -1078,22 +1479,25 @@ function usePlans(options) {
         setLoading(false);
       }
     },
-    [productRef]
+    [productRef, applyInitialSelection]
   );
-  useEffect3(() => {
+  useEffect4(() => {
     fetchPlans();
   }, [fetchPlans]);
-  const selectedPlan = useMemo3(() => {
-    return plans[selectedPlanIndex] || null;
-  }, [plans, selectedPlanIndex]);
-  const selectPlan = useCallback4(
+  useEffect4(() => {
+    if (hasAppliedInitialRef.current || userHasSelectedRef.current) return;
+    if (!selectionReady || plans.length === 0) return;
+    applyInitialSelection(plans);
+  }, [selectionReady, plans, applyInitialSelection]);
+  const selectedPlan = useMemo4(() => plans[selectedPlanIndex] || null, [plans, selectedPlanIndex]);
+  const selectPlan = useCallback6(
     (planRef) => {
       const index = plans.findIndex((p) => p.reference === planRef);
       if (index >= 0) {
         setSelectedPlanIndex(index);
       }
     },
-    [plans]
+    [plans, setSelectedPlanIndex]
   );
   return {
     plans,
@@ -1103,13 +1507,13 @@ function usePlans(options) {
     selectedPlan,
     setSelectedPlanIndex,
     selectPlan,
-    refetch: () => fetchPlans(true)
-    // Force refetch
+    refetch: () => fetchPlans(true),
+    isSelectionReady: hasAppliedInitialRef.current
   };
 }
 
 // src/components/PricingSelector.tsx
-import { Fragment as Fragment4, jsx as jsx7 } from "react/jsx-runtime";
+import { Fragment as Fragment4, jsx as jsx8 } from "react/jsx-runtime";
 var PricingSelector = ({
   productRef,
   fetcher,
@@ -1127,26 +1531,26 @@ var PricingSelector = ({
     autoSelectFirstPaid
   });
   const { plans } = plansHook;
-  const isPaidPlan = useCallback5(
+  const isPaidPlan = useCallback7(
     (planRef) => {
       const plan = plans.find((p) => p.reference === planRef);
-      return plan ? (plan.price ?? 0) > 0 && !plan.isFreeTier : true;
+      return plan ? plan.requiresPayment !== false : true;
     },
     [plans]
   );
-  const activePurchase = useMemo4(() => {
+  const activePurchase = useMemo5(() => {
     const activePurchases = purchases.filter((p) => p.status === "active");
     return activePurchases.sort(
       (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
     )[0] || null;
   }, [purchases]);
-  const isCurrentPlan = useCallback5(
+  const isCurrentPlan = useCallback7(
     (planRef) => {
       return activePurchase?.planSnapshot?.reference === planRef;
     },
     [activePurchase]
   );
-  return /* @__PURE__ */ jsx7(Fragment4, { children: children({
+  return /* @__PURE__ */ jsx8(Fragment4, { children: children({
     ...plansHook,
     purchases,
     isPaidPlan,
@@ -1155,14 +1559,58 @@ var PricingSelector = ({
 };
 var PlanSelector = PricingSelector;
 
+// src/hooks/useBalance.ts
+import { useEffect as useEffect5 } from "react";
+function useBalance() {
+  const { balance } = useSolvaPay();
+  useEffect5(() => {
+    balance.refetch();
+  }, [balance.refetch]);
+  return balance;
+}
+
+// src/components/BalanceBadge.tsx
+import { Fragment as Fragment5, jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+function BalanceBadge({ className, numberOnly, children }) {
+  const { credits, displayCurrency, creditsPerMinorUnit, displayExchangeRate, loading } = useBalance();
+  if (children) {
+    return /* @__PURE__ */ jsx9(Fragment5, { children: children({ credits, loading, displayCurrency, creditsPerMinorUnit }) });
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsx9("span", { className, "aria-busy": "true" });
+  }
+  if (credits == null) {
+    return null;
+  }
+  const formattedCredits = new Intl.NumberFormat().format(credits);
+  if (numberOnly) {
+    return /* @__PURE__ */ jsx9("span", { className, children: formattedCredits });
+  }
+  let currencyEquivalent = "";
+  if (displayCurrency && creditsPerMinorUnit) {
+    const usdCents = credits / creditsPerMinorUnit;
+    const displayMajorUnits = usdCents * (displayExchangeRate ?? 1) / 100;
+    currencyEquivalent = ` (~${new Intl.NumberFormat(void 0, {
+      style: "currency",
+      currency: displayCurrency,
+      minimumFractionDigits: 2
+    }).format(displayMajorUnits)})`;
+  }
+  return /* @__PURE__ */ jsxs5("span", { className, children: [
+    formattedCredits,
+    " credits",
+    currencyEquivalent
+  ] });
+}
+
 // src/hooks/usePurchaseStatus.ts
-import { useMemo as useMemo5, useCallback as useCallback6 } from "react";
+import { useMemo as useMemo6, useCallback as useCallback8 } from "react";
 function usePurchaseStatus() {
   const { purchases } = usePurchase();
-  const isPaidPurchase2 = useCallback6((p) => {
+  const isPaidPurchase2 = useCallback8((p) => {
     return (p.amount ?? 0) > 0;
   }, []);
-  const purchaseData = useMemo5(() => {
+  const purchaseData = useMemo6(() => {
     const cancelledPaidPurchases = purchases.filter((p) => {
       return p.status === "active" && p.cancelledAt && isPaidPurchase2(p);
     });
@@ -1175,7 +1623,7 @@ function usePurchaseStatus() {
       shouldShowCancelledNotice
     };
   }, [purchases, isPaidPurchase2]);
-  const formatDate = useCallback6((dateString) => {
+  const formatDate = useCallback8((dateString) => {
     if (!dateString) return null;
     return new Date(dateString).toLocaleDateString("en-US", {
       year: "numeric",
@@ -1183,7 +1631,7 @@ function usePurchaseStatus() {
       day: "numeric"
     });
   }, []);
-  const getDaysUntilExpiration = useCallback6((endDate) => {
+  const getDaysUntilExpiration = useCallback8((endDate) => {
     if (!endDate) return null;
     const now = /* @__PURE__ */ new Date();
     const expiration = new Date(endDate);
@@ -1198,7 +1646,206 @@ function usePurchaseStatus() {
     getDaysUntilExpiration
   };
 }
+
+// src/hooks/usePurchaseActions.ts
+import { useState as useState7, useCallback as useCallback9 } from "react";
+function usePurchaseActions() {
+  const ctx = useSolvaPay();
+  const [isCancelling, setIsCancelling] = useState7(false);
+  const [isReactivating, setIsReactivating] = useState7(false);
+  const [isActivating, setIsActivating] = useState7(false);
+  const cancelRenewal = useCallback9(
+    async (params) => {
+      setIsCancelling(true);
+      try {
+        return await ctx.cancelRenewal(params);
+      } finally {
+        setIsCancelling(false);
+      }
+    },
+    [ctx.cancelRenewal]
+  );
+  const reactivateRenewal = useCallback9(
+    async (params) => {
+      setIsReactivating(true);
+      try {
+        return await ctx.reactivateRenewal(params);
+      } finally {
+        setIsReactivating(false);
+      }
+    },
+    [ctx.reactivateRenewal]
+  );
+  const activatePlan = useCallback9(
+    async (params) => {
+      setIsActivating(true);
+      try {
+        return await ctx.activatePlan(params);
+      } finally {
+        setIsActivating(false);
+      }
+    },
+    [ctx.activatePlan]
+  );
+  return {
+    cancelRenewal,
+    reactivateRenewal,
+    activatePlan,
+    isCancelling,
+    isReactivating,
+    isActivating
+  };
+}
+
+// src/hooks/useActivation.ts
+import { useState as useState8, useCallback as useCallback10 } from "react";
+function useActivation() {
+  const { activatePlan } = useSolvaPay();
+  const [state, setState] = useState8("idle");
+  const [error, setError] = useState8(null);
+  const [result, setResult] = useState8(null);
+  const activate = useCallback10(
+    async (params) => {
+      setState("activating");
+      setError(null);
+      setResult(null);
+      try {
+        const data = await activatePlan(params);
+        setResult(data);
+        switch (data.status) {
+          case "activated":
+          case "already_active":
+            setState("activated");
+            break;
+          case "topup_required":
+            setState("topup_required");
+            break;
+          case "payment_required":
+            setError("This plan requires payment. Please select a different plan.");
+            setState("payment_required");
+            break;
+          case "invalid":
+            setError(data.message || "Invalid plan configuration.");
+            setState("error");
+            break;
+          default:
+            setError("Unexpected response from server.");
+            setState("error");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Activation failed");
+        setState("error");
+      }
+    },
+    [activatePlan]
+  );
+  const reset = useCallback10(() => {
+    setState("idle");
+    setError(null);
+    setResult(null);
+  }, []);
+  return { activate, state, error, result, reset };
+}
+
+// src/hooks/useTopupAmountSelector.ts
+import { useState as useState9, useCallback as useCallback11, useMemo as useMemo7 } from "react";
+function getQuickAmounts(currency) {
+  switch (currency.toUpperCase()) {
+    case "SEK":
+    case "NOK":
+    case "DKK":
+      return [100, 500, 1e3, 5e3];
+    case "JPY":
+      return [1e3, 5e3, 1e4, 5e4];
+    case "KRW":
+      return [1e4, 5e4, 1e5, 5e5];
+    case "ISK":
+    case "HUF":
+      return [1e3, 5e3, 1e4, 5e4];
+    default:
+      return [10, 50, 100, 500];
+  }
+}
+function getCurrencySymbol(currency) {
+  try {
+    const parts = new Intl.NumberFormat("en", { style: "currency", currency }).formatToParts(0);
+    const sym = parts.find((p) => p.type === "currency");
+    return sym?.value || currency;
+  } catch {
+    return currency;
+  }
+}
+var DEFAULT_MIN = 1;
+var DEFAULT_MAX = 1e5;
+function useTopupAmountSelector(options) {
+  const { currency, minAmount = DEFAULT_MIN, maxAmount = DEFAULT_MAX } = options;
+  const [selectedAmount, setSelectedAmount] = useState9(null);
+  const [customAmount, setCustomAmountRaw] = useState9("");
+  const [error, setError] = useState9(null);
+  const quickAmounts = useMemo7(() => getQuickAmounts(currency), [currency]);
+  const currencySymbol = useMemo7(() => getCurrencySymbol(currency), [currency]);
+  const resolvedAmount = useMemo7(() => {
+    if (customAmount) {
+      const parsed = parseFloat(customAmount);
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+    }
+    return selectedAmount;
+  }, [selectedAmount, customAmount]);
+  const selectQuickAmount = useCallback11(
+    (amount) => {
+      setSelectedAmount(amount);
+      setCustomAmountRaw("");
+      setError(null);
+    },
+    []
+  );
+  const setCustomAmount = useCallback11(
+    (value) => {
+      const sanitized = value.replace(/[^0-9.]/g, "");
+      const dotIndex = sanitized.indexOf(".");
+      const cleaned = dotIndex === -1 ? sanitized : sanitized.slice(0, dotIndex + 1) + sanitized.slice(dotIndex + 1).replace(/\./g, "");
+      setCustomAmountRaw(cleaned);
+      setSelectedAmount(null);
+      setError(null);
+    },
+    []
+  );
+  const validate = useCallback11(() => {
+    if (resolvedAmount == null) {
+      setError("Please select or enter an amount");
+      return false;
+    }
+    if (resolvedAmount < minAmount) {
+      setError(`Minimum amount is ${currencySymbol}${minAmount}`);
+      return false;
+    }
+    if (resolvedAmount > maxAmount) {
+      setError(`Maximum amount is ${currencySymbol}${maxAmount.toLocaleString()}`);
+      return false;
+    }
+    setError(null);
+    return true;
+  }, [resolvedAmount, minAmount, maxAmount, currencySymbol]);
+  const reset = useCallback11(() => {
+    setSelectedAmount(null);
+    setCustomAmountRaw("");
+    setError(null);
+  }, []);
+  return {
+    quickAmounts,
+    selectedAmount,
+    customAmount,
+    resolvedAmount,
+    selectQuickAmount,
+    setCustomAmount,
+    error,
+    validate,
+    reset,
+    currencySymbol
+  };
+}
 export {
+  BalanceBadge,
   PaymentForm,
   PlanBadge,
   PlanSelector,
@@ -1208,6 +1855,7 @@ export {
   SolvaPayProvider,
   Spinner,
   StripePaymentFormWrapper,
+  TopupForm,
   defaultAuthAdapter,
   filterPurchases,
   getActivePurchases,
@@ -1215,10 +1863,15 @@ export {
   getMostRecentPurchase,
   getPrimaryPurchase,
   isPaidPurchase,
+  useActivation,
+  useBalance,
   useCheckout,
   useCustomer,
   usePlans,
   usePurchase,
+  usePurchaseActions,
   usePurchaseStatus,
-  useSolvaPay
+  useSolvaPay,
+  useTopup,
+  useTopupAmountSelector
 };