@solvapay/react 1.0.8-preview.6 → 1.0.8-preview.8

package/dist/chunk-MOP3ZBGC.js

@@ -0,0 +1,4749 @@
+import {
+  defaultAuthAdapter
+} from "./chunk-OUSEQRCT.js";
+
+// src/utils/purchases.ts
+function filterPurchases(purchases) {
+  return purchases.filter((purchase) => purchase.status === "active");
+}
+function getActivePurchases(purchases) {
+  return purchases.filter((purchase) => purchase.status === "active");
+}
+function getCancelledPurchasesWithEndDate(purchases) {
+  const now = /* @__PURE__ */ new Date();
+  return purchases.filter((purchase) => {
+    return purchase.status === "active" && purchase.cancelledAt && purchase.endDate && new Date(purchase.endDate) > now;
+  });
+}
+function getMostRecentPurchase(purchases) {
+  if (purchases.length === 0) return null;
+  return purchases.reduce((latest, current) => {
+    return new Date(current.startDate) > new Date(latest.startDate) ? current : latest;
+  });
+}
+function getPrimaryPurchase(purchases) {
+  const filtered = filterPurchases(purchases);
+  if (filtered.length > 0) {
+    return getMostRecentPurchase(filtered);
+  }
+  return null;
+}
+function isPaidPurchase(purchase) {
+  return (purchase.amount ?? 0) > 0;
+}
+
+// src/i18n/en.ts
+function intervalPhrase(ctx) {
+  const interval = ctx.plan?.interval;
+  const count = ctx.plan?.intervalCount ?? 1;
+  if (!interval) return "";
+  return count > 1 ? `${count} ${interval}s` : interval;
+}
+function trialPhrase(ctx) {
+  const trialDays = ctx.plan?.trialDays ?? ctx.trialDays;
+  return trialDays ? ` after your ${trialDays}-day free trial` : "";
+}
+function termsSentence(ctx) {
+  const { termsUrl, privacyUrl } = ctx.merchant;
+  if (termsUrl && privacyUrl) {
+    return ` See ${termsUrl} and ${privacyUrl}.`;
+  }
+  if (termsUrl) return ` See ${termsUrl}.`;
+  if (privacyUrl) return ` See ${privacyUrl}.`;
+  return "";
+}
+var enCopy = {
+  mandate: {
+    recurring: (ctx) => {
+      const period = intervalPhrase(ctx);
+      const trial = trialPhrase(ctx);
+      const every = period ? ` every ${period}` : "";
+      return `By subscribing, you authorize ${ctx.merchant.legalName} to charge ${ctx.amountFormatted}${every}${trial} until you cancel. You can cancel any time. Payments are processed by SolvaPay.${termsSentence(ctx)}`;
+    },
+    oneTime: (ctx) => {
+      const product = ctx.product?.name ? ` for ${ctx.product.name}` : "";
+      return `By confirming, you authorize ${ctx.merchant.legalName} to charge ${ctx.amountFormatted}${product}. Payments are processed by SolvaPay.${termsSentence(ctx)}`;
+    },
+    topup: (ctx) => {
+      const product = ctx.product?.name ? ` to add credits to your ${ctx.product.name} balance` : " to add credits to your balance";
+      return `By confirming, you authorize ${ctx.merchant.legalName} to charge ${ctx.amountFormatted}${product}. Credits are non-refundable once used. Payments are processed by SolvaPay.${termsSentence(ctx)}`;
+    },
+    usageMetered: (ctx) => {
+      const measures = ctx.plan?.measures ?? "unit";
+      const cycle = ctx.plan?.billingCycle ?? "monthly";
+      const product = ctx.product?.name ?? "the service";
+      return `By confirming, you authorize ${ctx.merchant.legalName} to charge your payment method for metered usage of ${product} at ${ctx.amountFormatted} per ${measures}, billed ${cycle}. You can cancel any time. Payments are processed by SolvaPay.${termsSentence(ctx)}`;
+    },
+    freeTier: (ctx) => {
+      const product = ctx.product?.name ?? "this plan";
+      const planPhrase = ctx.plan?.name ? ` on ${ctx.plan.name}` : "";
+      return `By confirming, you activate ${product}${planPhrase}. Payments are processed by SolvaPay.${termsSentence(ctx)}`;
+    }
+  },
+  cta: {
+    payNow: "Pay Now",
+    topUp: "Top Up",
+    subscribe: "Subscribe",
+    trialStart: "Start {trialDays}-day free trial",
+    payAmount: "Pay {amount}",
+    addAmount: "Add {amount}",
+    startUsing: "Start using {product}",
+    processing: "Processing..."
+  },
+  interval: {
+    day: "day",
+    week: "week",
+    month: "month",
+    year: "year",
+    every: "every {n} {unit}",
+    free: "Free",
+    trial: "{trialDays}-day free trial"
+  },
+  terms: {
+    checkboxLabel: "I agree to the terms and privacy policy"
+  },
+  customer: {
+    chargingTo: "Charging to {email}",
+    emailLabel: "Email",
+    nameLabel: "Name"
+  },
+  balance: {
+    credits: " credits",
+    currencyEquivalent: " (~{amount})"
+  },
+  product: {
+    currentProductLabel: "Current product: {name}"
+  },
+  topup: {
+    selectOrEnterAmount: "Please select or enter an amount",
+    minAmount: "Minimum amount is {amount}",
+    maxAmount: "Maximum amount is {amount}"
+  },
+  activation: {
+    paymentRequired: "This plan requires payment. Please select a different plan.",
+    invalidConfiguration: "Invalid plan configuration.",
+    unexpectedResponse: "Unexpected response from server.",
+    failed: "Activation failed"
+  },
+  planSelector: {
+    heading: "Choose your pricing",
+    currentBadge: "Current",
+    popularBadge: "Popular",
+    freeBadge: "Free",
+    perIntervalShort: "/{interval}",
+    continueButton: "Continue",
+    backButton: "\u2190 Back to plans",
+    trialBadge: "{trialDays}-day free trial"
+  },
+  amountPicker: {
+    selectAmountLabel: "Select an amount",
+    customAmountLabel: "Or enter a custom amount",
+    creditEstimateExact: "= {credits} credits",
+    creditEstimateApprox: "~ {credits} credits"
+  },
+  activationFlow: {
+    heading: "Confirm your plan",
+    activateButton: "Activate",
+    activatingLabel: "Activating...",
+    topupHeading: "Add credits",
+    topupSubheading: "Top up your credits to activate this plan.",
+    continueToPayment: "Continue to payment",
+    changeAmountButton: "Change amount",
+    retryingHeading: "Activating your plan...",
+    retryingSubheading: "Payment received. Setting up your plan.",
+    activatedHeading: "Plan selected",
+    activatedSubheading: "Your plan is now active.",
+    tryAgainButton: "Try Again",
+    backButton: "\u2190 Back to plan selection"
+  },
+  cancelPlan: {
+    button: "Cancel plan",
+    buttonLoading: "Cancelling...",
+    confirmRecurring: "Are you sure you want to cancel your subscription?",
+    confirmUsageBased: "Are you sure you want to deactivate your plan? This will take effect immediately."
+  },
+  cancelledNotice: {
+    heading: "Your purchase has been cancelled",
+    expiresLabel: "Purchase Expires: {date}",
+    daysRemaining: "{days} days remaining",
+    dayRemaining: "1 day remaining",
+    accessUntil: "You'll continue to have access to {product} features until this date",
+    accessEnded: "Your purchase access has ended",
+    cancelledOn: "Cancelled on {date}",
+    reactivateButton: "Undo Cancellation",
+    reactivateButtonLoading: "Reactivating..."
+  },
+  creditGate: {
+    lowBalanceHeading: "You're out of credits",
+    lowBalanceSubheading: "Top up to continue using {product}",
+    topUpCta: "Top up now"
+  },
+  errors: {
+    paymentInitFailed: "Payment initialization failed",
+    topupInitFailed: "Top-up initialization failed",
+    configMissingPlanOrProduct: "PaymentForm: either planRef or productRef is required",
+    configMissingAmount: "TopupForm: amount must be a positive number",
+    unknownError: "Unknown error",
+    stripeUnavailable: "Stripe is not available. Please refresh the page.",
+    paymentIntentUnavailable: "Payment intent not available. Please refresh the page.",
+    cardElementMissing: "Card element not found",
+    paymentUnexpected: "An unexpected error occurred.",
+    paymentProcessingFailed: "Payment processing failed. Please try again or contact support.",
+    paymentRequires3ds: "Payment requires additional authentication. Please complete the verification.",
+    paymentProcessingTimeout: "Payment processing timed out \u2014 webhooks may not be configured",
+    paymentStatusPrefix: "Payment status: {status}"
+  }
+};
+
+// src/i18n/merge.ts
+function mergeCopy(defaults, overrides) {
+  if (!overrides) return defaults;
+  const merged = { ...defaults };
+  for (const sectionKey of Object.keys(overrides)) {
+    const defaultSection = defaults[sectionKey];
+    const overrideSection = overrides[sectionKey];
+    if (!overrideSection) continue;
+    const combined = { ...defaultSection, ...overrideSection };
+    merged[sectionKey] = combined;
+  }
+  return merged;
+}
+
+// src/i18n/context.tsx
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var CopyContext = createContext({
+  locale: void 0,
+  copy: enCopy
+});
+var CopyProvider = ({
+  locale,
+  copy: overrides,
+  children
+}) => {
+  const value = useMemo(
+    () => ({
+      locale,
+      copy: mergeCopy(enCopy, overrides)
+    }),
+    [locale, overrides]
+  );
+  return /* @__PURE__ */ jsx(CopyContext.Provider, { value, children });
+};
+function useCopyContext() {
+  return useContext(CopyContext);
+}
+
+// src/SolvaPayProvider.tsx
+import { createContext as createContext2, useState, useEffect, useCallback, useMemo as useMemo2, useRef } from "react";
+
+// 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";
+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);
+  const expiry = localStorage.getItem(CUSTOMER_REF_EXPIRY);
+  const cachedUserId = localStorage.getItem(CUSTOMER_REF_USER_ID_KEY);
+  if (!cached || !expiry) return null;
+  if (Date.now() > parseInt(expiry)) {
+    localStorage.removeItem(CUSTOMER_REF_KEY);
+    localStorage.removeItem(CUSTOMER_REF_EXPIRY);
+    localStorage.removeItem(CUSTOMER_REF_USER_ID_KEY);
+    return null;
+  }
+  if (userId !== void 0 && userId !== null) {
+    if (cachedUserId !== userId) {
+      clearCachedCustomerRef();
+      return null;
+    }
+  }
+  return cached;
+}
+var CACHE_DURATION = 24 * 60 * 60 * 1e3;
+function setCachedCustomerRef(customerRef, userId) {
+  if (typeof window === "undefined") return;
+  if (userId === void 0 || userId === null) {
+    return;
+  }
+  localStorage.setItem(CUSTOMER_REF_KEY, customerRef);
+  localStorage.setItem(CUSTOMER_REF_EXPIRY, String(Date.now() + CACHE_DURATION));
+  localStorage.setItem(CUSTOMER_REF_USER_ID_KEY, userId);
+}
+function clearCachedCustomerRef() {
+  if (typeof window === "undefined") return;
+  localStorage.removeItem(CUSTOMER_REF_KEY);
+  localStorage.removeItem(CUSTOMER_REF_EXPIRY);
+  localStorage.removeItem(CUSTOMER_REF_USER_ID_KEY);
+}
+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 (cachedRef) {
+    headers["x-solvapay-customer-ref"] = cachedRef;
+  }
+  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 as jsx2 } from "react/jsx-runtime";
+var SolvaPayContext = createContext2(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 checkPurchaseRef = useRef(null);
+  const createPaymentRef = useRef(null);
+  const processPaymentRef = useRef(null);
+  const createTopupPaymentRef = useRef(null);
+  const configRef = useRef(config);
+  const buildDefaultCheckPurchaseRef = useRef(
+    null
+  );
+  useEffect(() => {
+    configRef.current = config;
+  }, [config]);
+  useEffect(() => {
+    checkPurchaseRef.current = customCheckPurchase || null;
+  }, [customCheckPurchase]);
+  useEffect(() => {
+    createPaymentRef.current = customCreatePayment || null;
+  }, [customCreatePayment]);
+  useEffect(() => {
+    processPaymentRef.current = customProcessPayment || null;
+  }, [customProcessPayment]);
+  useEffect(() => {
+    createTopupPaymentRef.current = customCreateTopupPayment || null;
+  }, [customCreateTopupPayment]);
+  const buildDefaultCheckPurchase = useCallback(async () => {
+    const currentConfig = configRef.current;
+    const { headers } = await buildRequestHeaders(currentConfig);
+    const route = currentConfig?.api?.checkPurchase || "/api/check-purchase";
+    const fetchFn = currentConfig?.fetch || fetch;
+    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");
+      throw error;
+    }
+    return res.json();
+  }, []);
+  useEffect(() => {
+    buildDefaultCheckPurchaseRef.current = buildDefaultCheckPurchase;
+  }, [buildDefaultCheckPurchase]);
+  const buildDefaultCreatePayment = useCallback(
+    async (params) => {
+      const currentConfig = configRef.current;
+      const { headers } = await buildRequestHeaders(currentConfig);
+      const route = currentConfig?.api?.createPayment || "/api/create-payment-intent";
+      const fetchFn = currentConfig?.fetch || fetch;
+      const body = {};
+      if (params.planRef) {
+        body.planRef = params.planRef;
+      }
+      if (params.productRef) {
+        body.productRef = params.productRef;
+      }
+      if (params.customer && (params.customer.name || params.customer.email)) {
+        body.customer = params.customer;
+      }
+      const res = await fetchFn(route, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (!res.ok) {
+        const error = new Error(`Failed to create payment: ${res.statusText}`);
+        currentConfig?.onError?.(error, "createPayment");
+        throw error;
+      }
+      return res.json();
+    },
+    []
+  );
+  const buildDefaultProcessPayment = useCallback(
+    async (params) => {
+      const currentConfig = configRef.current;
+      const { headers } = await buildRequestHeaders(currentConfig);
+      const route = currentConfig?.api?.processPayment || "/api/process-payment";
+      const fetchFn = currentConfig?.fetch || fetch;
+      const res = await fetchFn(route, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(params)
+      });
+      if (!res.ok) {
+        const error = new Error(`Failed to process payment: ${res.statusText}`);
+        currentConfig?.onError?.(error, "processPayment");
+        throw error;
+      }
+      return res.json();
+    },
+    []
+  );
+  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();
+    }
+    if (buildDefaultCheckPurchaseRef.current) {
+      return buildDefaultCheckPurchaseRef.current();
+    }
+    return buildDefaultCheckPurchase();
+  }, [buildDefaultCheckPurchase]);
+  const createPayment = useCallback(
+    async (params) => {
+      if (createPaymentRef.current) {
+        return createPaymentRef.current(params);
+      }
+      return buildDefaultCreatePayment(params);
+    },
+    [buildDefaultCreatePayment]
+  );
+  const processPayment = useCallback(
+    async (params) => {
+      if (processPaymentRef.current) {
+        return processPaymentRef.current(params);
+      }
+      return buildDefaultProcessPayment(params);
+    },
+    [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;
+      const adapter = getAuthAdapter(currentConfig);
+      const token = await adapter.getToken();
+      const detectedUserId = await adapter.getUserId();
+      const prevUserId = userId;
+      setIsAuthenticated(!!token);
+      setUserId(detectedUserId);
+      if (prevUserId !== null && detectedUserId !== prevUserId) {
+        clearCachedCustomerRef();
+        setInternalCustomerRef(void 0);
+        return;
+      }
+      const cachedRef = getCachedCustomerRef(detectedUserId);
+      if (cachedRef && token) {
+        setInternalCustomerRef(cachedRef);
+      } else if (!token) {
+        clearCachedCustomerRef();
+        setInternalCustomerRef(void 0);
+      } else if (token && !cachedRef) {
+        setInternalCustomerRef(void 0);
+      }
+    };
+    detectAuth();
+    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;
+        return;
+      }
+      const cacheKey = internalCustomerRef || userId || "anonymous";
+      if (inFlightRef.current === cacheKey && !force) {
+        return;
+      }
+      inFlightRef.current = cacheKey;
+      const hasExistingData = purchaseData.purchases.length > 0;
+      if (hasExistingData) {
+        setIsRefetching(true);
+      } else {
+        setLoading(true);
+      }
+      try {
+        const checkFn = checkPurchaseRef.current || buildDefaultCheckPurchaseRef.current;
+        if (!checkFn) {
+          throw new Error("checkPurchase function not available");
+        }
+        const data = await checkFn();
+        if (data.customerRef) {
+          setInternalCustomerRef(data.customerRef);
+          const currentAdapter = getAuthAdapter(configRef.current);
+          const currentUserId = await currentAdapter.getUserId();
+          setCachedCustomerRef(data.customerRef, currentUserId);
+        }
+        if (inFlightRef.current === cacheKey) {
+          const filteredData = {
+            ...data,
+            purchases: filterPurchases(data.purchases || [])
+          };
+          setPurchaseData(filteredData);
+          setPurchaseError(null);
+        }
+      } catch (err) {
+        console.error("[SolvaPayProvider] Failed to fetch purchase:", err);
+        if (inFlightRef.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, purchaseData.purchases.length]
+  );
+  const fetchPurchaseRef = useRef(fetchPurchase);
+  useEffect(() => {
+    fetchPurchaseRef.current = fetchPurchase;
+  }, [fetchPurchase]);
+  const refetchPurchase = useCallback(async () => {
+    inFlightRef.current = null;
+    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(() => {
+    inFlightRef.current = null;
+    if (isAuthenticated || internalCustomerRef) {
+      fetchPurchase();
+    } else {
+      setPurchaseData({ purchases: [] });
+      setPurchaseError(null);
+      setLoading(false);
+      setIsRefetching(false);
+    }
+  }, [isAuthenticated, internalCustomerRef, userId]);
+  const updateCustomerRef = useCallback(
+    (newCustomerRef) => {
+      setInternalCustomerRef(newCustomerRef);
+      setCachedCustomerRef(newCustomerRef, userId);
+      fetchPurchase(true);
+    },
+    [fetchPurchase, userId]
+  );
+  const purchase = useMemo2(() => {
+    const activePurchase = getPrimaryPurchase(purchaseData.purchases);
+    const activePaidPurchases = purchaseData.purchases.filter(
+      (p) => p.status === "active" && isPaidPurchase(p)
+    );
+    const activePaidPurchase = activePaidPurchases.sort(
+      (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
+    )[0] || null;
+    return {
+      loading,
+      isRefetching,
+      error: purchaseError,
+      customerRef: purchaseData.customerRef || internalCustomerRef,
+      email: purchaseData.email,
+      name: purchaseData.name,
+      purchases: purchaseData.purchases,
+      hasProduct: (productName) => {
+        return purchaseData.purchases.some(
+          (p) => p.productName.toLowerCase() === productName.toLowerCase() && p.status === "active"
+        );
+      },
+      hasPlan: (productName) => {
+        return purchaseData.purchases.some(
+          (p) => p.productName.toLowerCase() === productName.toLowerCase() && p.status === "active"
+        );
+      },
+      activePurchase,
+      hasPaidPurchase: activePaidPurchases.length > 0,
+      activePaidPurchase
+    };
+  }, [loading, isRefetching, purchaseError, purchaseData, internalCustomerRef]);
+  const balance = useMemo2(
+    () => ({
+      loading: balanceLoading,
+      credits: creditsValue,
+      displayCurrency: displayCurrencyValue,
+      creditsPerMinorUnit: creditsPerMinorUnitValue,
+      displayExchangeRate: displayExchangeRateValue,
+      refetch: fetchBalanceImpl,
+      adjustBalance: adjustBalanceImpl
+    }),
+    [balanceLoading, creditsValue, displayCurrencyValue, creditsPerMinorUnitValue, displayExchangeRateValue, fetchBalanceImpl, adjustBalanceImpl]
+  );
+  const contextValue = useMemo2(
+    () => ({
+      purchase,
+      refetchPurchase,
+      createPayment,
+      processPayment,
+      createTopupPayment,
+      cancelRenewal,
+      reactivateRenewal,
+      activatePlan,
+      customerRef: purchaseData.customerRef || internalCustomerRef,
+      updateCustomerRef,
+      balance,
+      _config: configRef.current
+    }),
+    [
+      purchase,
+      refetchPurchase,
+      createPayment,
+      processPayment,
+      createTopupPayment,
+      cancelRenewal,
+      reactivateRenewal,
+      activatePlan,
+      purchaseData.customerRef,
+      internalCustomerRef,
+      updateCustomerRef,
+      balance
+    ]
+  );
+  return /* @__PURE__ */ jsx2(SolvaPayContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx2(CopyProvider, { locale: config?.locale, copy: config?.copy, children }) });
+};
+
+// src/primitives/composeRefs.ts
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref !== null && ref !== void 0) {
+    ;
+    ref.current = value;
+  }
+}
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      setRef(ref, node);
+    }
+  };
+}
+
+// src/primitives/slot.tsx
+import React3 from "react";
+import { Fragment, jsx as jsx3 } from "react/jsx-runtime";
+var Slot = React3.forwardRef((props, forwardedRef) => {
+  const { children, ...slotProps } = props;
+  const childrenArray = React3.Children.toArray(children);
+  const slottable = childrenArray.find(isSlottable);
+  if (slottable) {
+    const newElement = slottable.props.children;
+    const newChildren = childrenArray.map((child) => {
+      if (child === slottable) {
+        if (React3.Children.count(newElement) > 1) return React3.Children.only(null);
+        return React3.isValidElement(newElement) ? newElement.props.children : null;
+      }
+      return child;
+    });
+    return /* @__PURE__ */ jsx3(SlotClone, { ...slotProps, ref: forwardedRef, children: React3.isValidElement(newElement) ? React3.cloneElement(newElement, void 0, newChildren) : null });
+  }
+  return /* @__PURE__ */ jsx3(SlotClone, { ...slotProps, ref: forwardedRef, children });
+});
+Slot.displayName = "Slot";
+var SlotClone = React3.forwardRef(
+  (props, forwardedRef) => {
+    const { children, ...slotProps } = props;
+    if (React3.isValidElement(children)) {
+      const childProps = children.props ?? {};
+      const childRef = getElementRef(children);
+      const props2 = mergeProps(slotProps, childProps);
+      const cloneProps = { ...props2 };
+      if (forwardedRef) {
+        cloneProps.ref = childRef ? composeRefs(forwardedRef, childRef) : forwardedRef;
+      } else {
+        cloneProps.ref = childRef;
+      }
+      return React3.cloneElement(children, cloneProps);
+    }
+    return React3.Children.count(children) > 1 ? React3.Children.only(null) : null;
+  }
+);
+SlotClone.displayName = "SlotClone";
+var Slottable = ({ children }) => {
+  return /* @__PURE__ */ jsx3(Fragment, { children });
+};
+function isSlottable(child) {
+  return React3.isValidElement(child) && child.type === Slottable;
+}
+function mergeProps(slotProps, childProps) {
+  const overrideProps = { ...childProps };
+  for (const propName in slotProps) {
+    const slotPropValue = slotProps[propName];
+    const childPropValue = childProps[propName];
+    const isHandler = /^on[A-Z]/.test(propName);
+    if (isHandler) {
+      if (slotPropValue && childPropValue) {
+        overrideProps[propName] = (...args) => {
+          ;
+          childPropValue(...args);
+          const first = args[0];
+          if (!first?.defaultPrevented) {
+            ;
+            slotPropValue(...args);
+          }
+        };
+      } else if (slotPropValue) {
+        overrideProps[propName] = slotPropValue;
+      }
+    } else if (propName === "style") {
+      overrideProps[propName] = {
+        ...slotPropValue,
+        ...childPropValue
+      };
+    } else if (propName === "className") {
+      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+    } else if (propName === "ref") {
+    } else if (childPropValue === void 0) {
+      overrideProps[propName] = slotPropValue;
+    }
+  }
+  return overrideProps;
+}
+function getElementRef(element) {
+  const el = element;
+  return el.props?.ref ?? el.ref ?? null;
+}
+
+// src/primitives/composeEventHandlers.ts
+function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+  return function handleEvent(event) {
+    originalEventHandler?.(event);
+    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+      ourEventHandler?.(event);
+    }
+  };
+}
+
+// src/hooks/useSolvaPay.ts
+import { useContext as useContext2 } from "react";
+function useSolvaPay() {
+  const context = useContext2(SolvaPayContext);
+  if (!context) {
+    throw new Error(
+      "useSolvaPay must be used within a SolvaPayProvider. Wrap your component tree with <SolvaPayProvider> to use this hook."
+    );
+  }
+  return context;
+}
+
+// src/hooks/useCheckout.ts
+import { useState as useState2, useCallback as useCallback2, useRef as useRef2 } from "react";
+import { loadStripe } from "@stripe/stripe-js";
+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, customer } = options;
+  const { createPayment, customerRef, updateCustomerRef, _config } = useSolvaPay();
+  const [loading, setLoading] = useState2(false);
+  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 && !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 {
+      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,
+        customer
+      });
+      if (!result || typeof result !== "object") {
+        throw new Error("Invalid payment intent response from server");
+      }
+      if (!result.clientSecret || typeof result.clientSecret !== "string") {
+        throw new Error("Invalid client secret in payment intent response");
+      }
+      if (!result.publishableKey || typeof result.publishableKey !== "string") {
+        throw new Error("Invalid publishable key in payment intent response");
+      }
+      if (result.customerRef && result.customerRef !== customerRef && updateCustomerRef) {
+        updateCustomerRef(result.customerRef);
+      }
+      const stripeOptions = result.accountId ? { stripeAccount: result.accountId } : {};
+      const cacheKey = getStripeCacheKey(result.publishableKey, result.accountId);
+      let stripe = stripePromiseCache.get(cacheKey);
+      if (!stripe) {
+        stripe = loadStripe(result.publishableKey, stripeOptions);
+        stripePromiseCache.set(cacheKey, stripe);
+      }
+      setStripePromise(stripe);
+      setClientSecret(result.clientSecret);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to start checkout");
+      setError(error2);
+    } finally {
+      setLoading(false);
+      isStartingRef.current = false;
+    }
+  }, [planRef, productRef, customer, 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
+  };
+}
+
+// src/hooks/usePurchase.ts
+function usePurchase() {
+  const { purchase, refetchPurchase } = useSolvaPay();
+  return {
+    ...purchase,
+    refetch: refetchPurchase
+  };
+}
+
+// src/hooks/useCustomer.ts
+function useCustomer() {
+  const { purchase, customerRef } = useSolvaPay();
+  return {
+    customerRef: purchase.customerRef || customerRef,
+    email: purchase.email,
+    name: purchase.name,
+    loading: purchase.loading
+  };
+}
+
+// src/hooks/useCopy.ts
+function useCopy() {
+  return useCopyContext().copy;
+}
+function useLocale() {
+  return useCopyContext().locale;
+}
+
+// src/hooks/usePlans.ts
+import { useState as useState3, useEffect as useEffect2, useCallback as useCallback3, useMemo as useMemo3, useRef as useRef3 } 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,
+    initialPlanRef,
+    selectionReady = true
+  } = options;
+  const fetcherRef = useRef3(fetcher);
+  const filterRef = useRef3(filter);
+  const sortByRef = useRef3(sortBy);
+  const autoSelectFirstPaidRef = useRef3(autoSelectFirstPaid);
+  const initialPlanRefRef = useRef3(initialPlanRef);
+  const selectionReadyRef = useRef3(selectionReady);
+  const hasAppliedInitialRef = useRef3(false);
+  const userHasSelectedRef = useRef3(false);
+  const [selectedPlanIndex, setSelectedPlanIndexState] = useState3(() => {
+    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] = useState3(() => {
+    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] = useState3(() => plans.length === 0);
+  const [error, setError] = useState3(null);
+  useEffect2(() => {
+    fetcherRef.current = fetcher;
+  }, [fetcher]);
+  useEffect2(() => {
+    filterRef.current = filter;
+  }, [filter]);
+  useEffect2(() => {
+    sortByRef.current = sortBy;
+  }, [sortBy]);
+  useEffect2(() => {
+    autoSelectFirstPaidRef.current = autoSelectFirstPaid;
+  }, [autoSelectFirstPaid]);
+  useEffect2(() => {
+    initialPlanRefRef.current = initialPlanRef;
+  }, [initialPlanRef]);
+  useEffect2(() => {
+    selectionReadyRef.current = selectionReady;
+  }, [selectionReady]);
+  const setSelectedPlanIndex = useCallback3((index) => {
+    userHasSelectedRef.current = true;
+    setSelectedPlanIndexState(index);
+  }, []);
+  const applyInitialSelection = useCallback3((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 = useCallback3(
+    async (force = false) => {
+      if (!productRef) {
+        setError(new Error("Product reference not configured"));
+        setLoading(false);
+        return;
+      }
+      const cached = plansCache.get(productRef);
+      const now = Date.now();
+      if (!force && cached && now - cached.timestamp < CACHE_DURATION2) {
+        const processedPlans = processPlans(
+          cached.plans,
+          filterRef.current,
+          sortByRef.current
+        );
+        setPlans(processedPlans);
+        setLoading(false);
+        setError(null);
+        applyInitialSelection(processedPlans);
+        return;
+      }
+      if (cached?.promise) {
+        try {
+          setLoading(true);
+          const fetchedPlans = await cached.promise;
+          const processedPlans = processPlans(
+            fetchedPlans,
+            filterRef.current,
+            sortByRef.current
+          );
+          setPlans(processedPlans);
+          setError(null);
+          applyInitialSelection(processedPlans);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error("Failed to load plans"));
+        } finally {
+          setLoading(false);
+        }
+        return;
+      }
+      try {
+        setLoading(true);
+        setError(null);
+        const fetchPromise = fetcherRef.current(productRef);
+        plansCache.set(productRef, { plans: [], timestamp: now, promise: fetchPromise });
+        const fetchedPlans = await fetchPromise;
+        plansCache.set(productRef, { plans: fetchedPlans, timestamp: now, promise: null });
+        const processedPlans = processPlans(
+          fetchedPlans,
+          filterRef.current,
+          sortByRef.current
+        );
+        setPlans(processedPlans);
+        applyInitialSelection(processedPlans);
+      } catch (err) {
+        plansCache.delete(productRef);
+        setError(err instanceof Error ? err : new Error("Failed to load plans"));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [productRef, applyInitialSelection]
+  );
+  useEffect2(() => {
+    fetchPlans();
+  }, [fetchPlans]);
+  useEffect2(() => {
+    if (hasAppliedInitialRef.current || userHasSelectedRef.current) return;
+    if (!selectionReady || plans.length === 0) return;
+    applyInitialSelection(plans);
+  }, [selectionReady, plans, applyInitialSelection]);
+  const selectedPlan = useMemo3(() => plans[selectedPlanIndex] || null, [plans, selectedPlanIndex]);
+  const selectPlan = useCallback3(
+    (planRef) => {
+      const index = plans.findIndex((p) => p.reference === planRef);
+      if (index >= 0) {
+        setSelectedPlanIndex(index);
+      }
+    },
+    [plans, setSelectedPlanIndex]
+  );
+  return {
+    plans,
+    loading,
+    error,
+    selectedPlanIndex,
+    selectedPlan,
+    setSelectedPlanIndex,
+    selectPlan,
+    refetch: () => fetchPlans(true),
+    isSelectionReady: hasAppliedInitialRef.current
+  };
+}
+
+// src/hooks/usePlan.ts
+import { useCallback as useCallback4, useEffect as useEffect3, useState as useState4 } from "react";
+async function listPlans(productRef, config) {
+  const base = config?.api?.listPlans || "/api/list-plans";
+  const url = `${base}?productRef=${encodeURIComponent(productRef)}`;
+  const fetchFn = config?.fetch || fetch;
+  const { headers } = await buildRequestHeaders(config);
+  const res = await fetchFn(url, { method: "GET", headers });
+  if (!res.ok) {
+    const error = new Error(`Failed to fetch plans: ${res.statusText || res.status}`);
+    config?.onError?.(error, "listPlans");
+    throw error;
+  }
+  const data = await res.json();
+  return data.plans ?? [];
+}
+function usePlan(options) {
+  const { planRef, productRef } = options;
+  const { _config } = useSolvaPay();
+  const findPlan = useCallback4(
+    (plans) => {
+      if (!planRef) return null;
+      return plans.find((p) => p.reference === planRef) || null;
+    },
+    [planRef]
+  );
+  const [plan, setPlan] = useState4(() => {
+    if (!planRef || !productRef) return null;
+    const cached = plansCache.get(productRef);
+    if (!cached || Date.now() - cached.timestamp >= CACHE_DURATION2) return null;
+    return findPlan(cached.plans);
+  });
+  const [loading, setLoading] = useState4(() => !!(planRef && !plan));
+  const [error, setError] = useState4(null);
+  const load = useCallback4(
+    async (force = false) => {
+      if (!planRef) {
+        setPlan(null);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+      if (!productRef) {
+        setLoading(false);
+        setError(
+          new Error("usePlan: productRef is required to resolve a plan reference")
+        );
+        return;
+      }
+      const cached = plansCache.get(productRef);
+      const now = Date.now();
+      if (!force && cached?.plans.length && now - cached.timestamp < CACHE_DURATION2) {
+        const p = findPlan(cached.plans);
+        setPlan(p);
+        setLoading(false);
+        setError(
+          p ? null : new Error(
+            `Plan "${planRef}" not found in product "${productRef}"`
+          )
+        );
+        return;
+      }
+      if (!force && cached?.promise) {
+        try {
+          setLoading(true);
+          const plans = await cached.promise;
+          const p = findPlan(plans);
+          setPlan(p);
+          setError(
+            p ? null : new Error(
+              `Plan "${planRef}" not found in product "${productRef}"`
+            )
+          );
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error("Failed to load plan"));
+        } finally {
+          setLoading(false);
+        }
+        return;
+      }
+      try {
+        setLoading(true);
+        setError(null);
+        const promise = listPlans(productRef, _config);
+        plansCache.set(productRef, { plans: [], timestamp: now, promise });
+        const plans = await promise;
+        plansCache.set(productRef, { plans, timestamp: now, promise: null });
+        const p = findPlan(plans);
+        setPlan(p);
+        if (!p) {
+          setError(new Error(`Plan "${planRef}" not found in product "${productRef}"`));
+        }
+      } catch (err) {
+        plansCache.delete(productRef);
+        setError(err instanceof Error ? err : new Error("Failed to load plan"));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [planRef, productRef, _config, findPlan]
+  );
+  useEffect3(() => {
+    load();
+  }, [load]);
+  return {
+    plan,
+    loading,
+    error,
+    refetch: () => load(true)
+  };
+}
+
+// src/hooks/useProduct.ts
+import { useCallback as useCallback5, useEffect as useEffect4, useState as useState5 } from "react";
+var productCache = /* @__PURE__ */ new Map();
+var CACHE_DURATION3 = 5 * 60 * 1e3;
+function routeFor(config) {
+  return config?.api?.getProduct || "/api/get-product";
+}
+async function fetchProduct(productRef, config) {
+  const base = routeFor(config);
+  const url = `${base}?productRef=${encodeURIComponent(productRef)}`;
+  const fetchFn = config?.fetch || fetch;
+  const { headers } = await buildRequestHeaders(config);
+  const res = await fetchFn(url, { method: "GET", headers });
+  if (!res.ok) {
+    const error = new Error(`Failed to fetch product: ${res.statusText || res.status}`);
+    config?.onError?.(error, "getProduct");
+    throw error;
+  }
+  return await res.json();
+}
+function useProduct(productRef) {
+  const { _config } = useSolvaPay();
+  const cacheKey = productRef || "";
+  const [product, setProduct] = useState5(
+    () => productRef ? productCache.get(cacheKey)?.product ?? null : null
+  );
+  const [loading, setLoading] = useState5(() => {
+    if (!productRef) return false;
+    const cached = productCache.get(cacheKey);
+    return !cached || !cached.product && !cached.promise;
+  });
+  const [error, setError] = useState5(null);
+  const load = useCallback5(
+    async (force = false) => {
+      if (!productRef) {
+        setProduct(null);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+      const cached = productCache.get(productRef);
+      const now = Date.now();
+      if (!force && cached?.product && now - cached.timestamp < CACHE_DURATION3) {
+        setProduct(cached.product);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+      if (!force && cached?.promise) {
+        try {
+          setLoading(true);
+          const p = await cached.promise;
+          setProduct(p);
+          setError(null);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error("Failed to load product"));
+        } finally {
+          setLoading(false);
+        }
+        return;
+      }
+      try {
+        setLoading(true);
+        setError(null);
+        const promise = fetchProduct(productRef, _config);
+        productCache.set(productRef, { product: null, promise, timestamp: now });
+        const p = await promise;
+        productCache.set(productRef, { product: p, promise: null, timestamp: now });
+        setProduct(p);
+      } catch (err) {
+        productCache.delete(productRef);
+        setError(err instanceof Error ? err : new Error("Failed to load product"));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [productRef, _config]
+  );
+  useEffect4(() => {
+    load();
+  }, [load]);
+  return {
+    product,
+    loading,
+    error,
+    refetch: () => load(true)
+  };
+}
+
+// src/hooks/useActivation.ts
+import { useState as useState6, useCallback as useCallback6 } from "react";
+function useActivation() {
+  const { activatePlan } = useSolvaPay();
+  const copy = useCopy();
+  const [state, setState] = useState6("idle");
+  const [error, setError] = useState6(null);
+  const [result, setResult] = useState6(null);
+  const activate = useCallback6(
+    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(copy.activation.paymentRequired);
+            setState("payment_required");
+            break;
+          case "invalid":
+            setError(data.message || copy.activation.invalidConfiguration);
+            setState("error");
+            break;
+          default:
+            setError(copy.activation.unexpectedResponse);
+            setState("error");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : copy.activation.failed);
+        setState("error");
+      }
+    },
+    [activatePlan, copy]
+  );
+  const reset = useCallback6(() => {
+    setState("idle");
+    setError(null);
+    setResult(null);
+  }, []);
+  return { activate, state, error, result, reset };
+}
+
+// src/components/PaymentFormContext.tsx
+import { createContext as createContext3, useContext as useContext3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var PaymentFormContext = createContext3(null);
+function usePaymentForm() {
+  const ctx = useContext3(PaymentFormContext);
+  if (!ctx) {
+    throw new Error(
+      "PaymentForm subcomponents must be used inside a <PaymentForm>. Wrap the slots with <PaymentForm planRef=... productRef=...>."
+    );
+  }
+  return ctx;
+}
+var PaymentFormProvider = ({ value, children }) => /* @__PURE__ */ jsx4(PaymentFormContext.Provider, { value, children });
+
+// src/utils/format.ts
+var ZERO_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set([
+  "bif",
+  "clp",
+  "djf",
+  "gnf",
+  "jpy",
+  "kmf",
+  "krw",
+  "mga",
+  "pyg",
+  "rwf",
+  "ugx",
+  "vnd",
+  "vuv",
+  "xaf",
+  "xof",
+  "xpf"
+]);
+function getFractionDigits(currency) {
+  return ZERO_DECIMAL_CURRENCIES.has(currency.toLowerCase()) ? 0 : 2;
+}
+function toMajorUnits(amountMinor, currency) {
+  const fractionDigits = getFractionDigits(currency);
+  return fractionDigits === 0 ? amountMinor : amountMinor / 100;
+}
+function formatPrice(amountMinor, currency, opts = {}) {
+  const { locale, interval, intervalCount = 1, free = "Free" } = opts;
+  if (amountMinor === 0 && free !== "") {
+    return free;
+  }
+  const fractionDigits = getFractionDigits(currency);
+  const major = toMajorUnits(amountMinor, currency);
+  const formatter = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currency.toUpperCase(),
+    minimumFractionDigits: fractionDigits,
+    maximumFractionDigits: fractionDigits
+  });
+  const formatted = formatter.format(major);
+  if (!interval) return formatted;
+  const suffix = intervalCount > 1 ? `${intervalCount} ${interval}s` : interval;
+  return `${formatted} / ${suffix}`;
+}
+
+// src/i18n/interpolate.ts
+function interpolate(template, vars) {
+  return template.replace(/\{(\w+)\}/g, (match, key) => {
+    const value = vars[key];
+    if (value === void 0 || value === null) return match;
+    return String(value);
+  });
+}
+
+// src/primitives/CheckoutSummary.tsx
+import { createContext as createContext5, forwardRef, useContext as useContext5, useMemo as useMemo4 } from "react";
+
+// src/components/PlanSelectionContext.tsx
+import { createContext as createContext4, useContext as useContext4 } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var PlanSelectionContext = createContext4(null);
+var PlanSelectionProvider = ({
+  value,
+  children
+}) => /* @__PURE__ */ jsx5(PlanSelectionContext.Provider, { value, children });
+function usePlanSelection() {
+  return useContext4(PlanSelectionContext);
+}
+
+// src/utils/errors.ts
+var DOCS_BASE_URL = "https://solvapay.com/docs";
+var SolvaPayError = class extends Error {
+  code;
+  docsUrl;
+  constructor(code, message, docsUrl) {
+    super(message);
+    this.name = "SolvaPayError";
+    this.code = code;
+    this.docsUrl = docsUrl;
+  }
+};
+var MissingProviderError = class extends SolvaPayError {
+  constructor(primitiveName) {
+    const docsUrl = `${DOCS_BASE_URL}/troubleshooting/missing-provider`;
+    super(
+      "MISSING_PROVIDER",
+      `${primitiveName} must be rendered inside <SolvaPayProvider>. Wrap your app (or the section using ${primitiveName}) with <SolvaPayProvider config={{ ... }}>. See ${docsUrl}`,
+      docsUrl
+    );
+    this.name = "MissingProviderError";
+  }
+};
+var MissingProductRefError = class extends SolvaPayError {
+  constructor(primitiveName) {
+    const docsUrl = `${DOCS_BASE_URL}/primitives/product-ref`;
+    super(
+      "MISSING_PRODUCT_REF",
+      `${primitiveName} requires a productRef. Pass the \`productRef\` prop (or set NEXT_PUBLIC_SOLVAPAY_PRODUCT_REF). See ${docsUrl}`,
+      docsUrl
+    );
+    this.name = "MissingProductRefError";
+  }
+};
+
+// src/primitives/CheckoutSummary.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var CheckoutSummaryContext = createContext5(null);
+function useCheckoutSummaryContext(part) {
+  const ctx = useContext5(CheckoutSummaryContext);
+  if (!ctx) {
+    throw new Error(
+      `CheckoutSummary.${part} must be rendered inside <CheckoutSummary.Root>.`
+    );
+  }
+  return ctx;
+}
+var Root = forwardRef(function CheckoutSummaryRoot({ planRef, productRef, asChild, children, ...rest }, forwardedRef) {
+  const solva = useContext5(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("CheckoutSummary");
+  const locale = useLocale();
+  const copy = useCopy();
+  const planSelection = usePlanSelection();
+  const resolvedPlanRef = planRef ?? planSelection?.selectedPlanRef ?? void 0;
+  const resolvedProductRef = productRef ?? planSelection?.productRef;
+  const { plan, loading: planLoading } = usePlan({
+    planRef: resolvedPlanRef,
+    productRef: resolvedProductRef
+  });
+  const { product, loading: productLoading } = useProduct(resolvedProductRef);
+  const loading = planLoading || productLoading;
+  const priceFormatted = useMemo4(() => {
+    const price = plan?.price ?? 0;
+    const currency = plan?.currency ?? "usd";
+    return formatPrice(price, currency, {
+      locale,
+      interval: plan?.interval,
+      intervalCount: 1,
+      free: copy.interval.free
+    });
+  }, [plan, locale, copy.interval.free]);
+  const trialBanner = useMemo4(() => {
+    const trialDays = plan?.trialDays;
+    if (!trialDays || trialDays <= 0) return null;
+    return interpolate(copy.interval.trial, { trialDays });
+  }, [plan?.trialDays, copy.interval.trial]);
+  const ctx = useMemo4(
+    () => ({ plan, product, priceFormatted, trialBanner, loading }),
+    [plan, product, priceFormatted, trialBanner, loading]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary": "", ...rest, children: /* @__PURE__ */ jsx6(CheckoutSummaryContext.Provider, { value: ctx, children }) });
+});
+var ProductSlot = forwardRef(function CheckoutSummaryProduct({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useCheckoutSummaryContext("Product");
+  const name = ctx.product?.name;
+  if (!name) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-product": "", ...rest, children: children ?? name });
+});
+var PlanSlot = forwardRef(function CheckoutSummaryPlan({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useCheckoutSummaryContext("Plan");
+  const name = ctx.plan?.name;
+  if (!name) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-plan": "", ...rest, children: children ?? name });
+});
+var PriceSlot = forwardRef(function CheckoutSummaryPrice({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useCheckoutSummaryContext("Price");
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-price": "", ...rest, children: children ?? ctx.priceFormatted });
+});
+var TrialSlot = forwardRef(function CheckoutSummaryTrial({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useCheckoutSummaryContext("Trial");
+  if (!ctx.trialBanner) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-trial": "", ...rest, children: children ?? ctx.trialBanner });
+});
+var TaxNoteSlot = forwardRef(function CheckoutSummaryTaxNote({ asChild, children, ...rest }, forwardedRef) {
+  useCheckoutSummaryContext("TaxNote");
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-tax-note": "", ...rest, children: children ?? "Taxes calculated at checkout" });
+});
+var CheckoutSummaryRoot2 = Root;
+var CheckoutSummaryProduct2 = ProductSlot;
+var CheckoutSummaryPlan2 = PlanSlot;
+var CheckoutSummaryPrice2 = PriceSlot;
+var CheckoutSummaryTrial2 = TrialSlot;
+var CheckoutSummaryTaxNote2 = TaxNoteSlot;
+var CheckoutSummary = {
+  Root,
+  Product: ProductSlot,
+  Plan: PlanSlot,
+  Price: PriceSlot,
+  Trial: TrialSlot,
+  TaxNote: TaxNoteSlot
+};
+function useCheckoutSummary() {
+  return useCheckoutSummaryContext("useCheckoutSummary");
+}
+
+// src/components/CheckoutSummary.tsx
+import { jsx as jsx7, jsxs } from "react/jsx-runtime";
+var CheckoutSummary2 = ({
+  planRef,
+  productRef,
+  showTrial = true,
+  showTaxNote = false,
+  className
+}) => {
+  const rootClass = ["solvapay-checkout-summary", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs(CheckoutSummary.Root, { planRef, productRef, className: rootClass, children: [
+    /* @__PURE__ */ jsx7(CheckoutSummary.Product, { className: "solvapay-checkout-summary-product" }),
+    /* @__PURE__ */ jsxs("div", { className: "solvapay-checkout-summary-row", children: [
+      /* @__PURE__ */ jsx7(CheckoutSummary.Plan, { className: "solvapay-checkout-summary-plan" }),
+      /* @__PURE__ */ jsx7(CheckoutSummary.Price, { className: "solvapay-checkout-summary-price" })
+    ] }),
+    showTrial && /* @__PURE__ */ jsx7(CheckoutSummary.Trial, { className: "solvapay-checkout-summary-trial" }),
+    showTaxNote && /* @__PURE__ */ jsx7(CheckoutSummary.TaxNote, { className: "solvapay-checkout-summary-tax-note" })
+  ] });
+};
+
+// src/hooks/useMerchant.ts
+import { useCallback as useCallback7, useEffect as useEffect5, useState as useState7 } from "react";
+var merchantCache = /* @__PURE__ */ new Map();
+var CACHE_DURATION4 = 5 * 60 * 1e3;
+function cacheKeyFor(config) {
+  return config?.api?.getMerchant || "/api/merchant";
+}
+async function fetchMerchant(config) {
+  const route = cacheKeyFor(config);
+  const fetchFn = config?.fetch || fetch;
+  const { headers } = await buildRequestHeaders(config);
+  const res = await fetchFn(route, { method: "GET", headers });
+  if (!res.ok) {
+    const error = new Error(`Failed to fetch merchant: ${res.statusText || res.status}`);
+    config?.onError?.(error, "getMerchant");
+    throw error;
+  }
+  return await res.json();
+}
+function useMerchant() {
+  const { _config } = useSolvaPay();
+  const key = cacheKeyFor(_config);
+  const [merchant, setMerchant] = useState7(
+    () => merchantCache.get(key)?.merchant ?? null
+  );
+  const [loading, setLoading] = useState7(() => {
+    const cached = merchantCache.get(key);
+    return !cached || !cached.merchant && !cached.promise;
+  });
+  const [error, setError] = useState7(null);
+  const load = useCallback7(
+    async (force = false) => {
+      const cached = merchantCache.get(key);
+      const now = Date.now();
+      if (!force && cached?.merchant && now - cached.timestamp < CACHE_DURATION4) {
+        setMerchant(cached.merchant);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+      if (!force && cached?.promise) {
+        try {
+          setLoading(true);
+          const m = await cached.promise;
+          setMerchant(m);
+          setError(null);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error("Failed to load merchant"));
+        } finally {
+          setLoading(false);
+        }
+        return;
+      }
+      try {
+        setLoading(true);
+        setError(null);
+        const promise = fetchMerchant(_config);
+        merchantCache.set(key, { merchant: null, promise, timestamp: now });
+        const m = await promise;
+        merchantCache.set(key, { merchant: m, promise: null, timestamp: now });
+        setMerchant(m);
+      } catch (err) {
+        merchantCache.delete(key);
+        setError(err instanceof Error ? err : new Error("Failed to load merchant"));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [_config, key]
+  );
+  useEffect5(() => {
+    load();
+  }, [load]);
+  return {
+    merchant,
+    loading,
+    error,
+    refetch: () => load(true)
+  };
+}
+
+// src/utils/checkoutVariant.ts
+function deriveVariant(plan, mode) {
+  if (mode === "topup") return "topup";
+  if (!plan?.type) return "oneTime";
+  if (plan.type === "usage-based") {
+    return plan.billingModel === "post-paid" ? "usageMetered" : "topup";
+  }
+  if (plan.requiresPayment === false) return "freeTier";
+  switch (plan.type) {
+    case "recurring":
+      return "recurring";
+    case "one-time":
+    default:
+      return "oneTime";
+  }
+}
+
+// src/primitives/MandateText.tsx
+import { forwardRef as forwardRef2, useContext as useContext6, useMemo as useMemo5 } from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var MandateText = forwardRef2(
+  function MandateText2({
+    planRef,
+    productRef,
+    variant,
+    mode,
+    amountMinor,
+    currency,
+    asChild,
+    children,
+    ...rest
+  }, forwardedRef) {
+    const solva = useContext6(SolvaPayContext);
+    if (!solva) throw new MissingProviderError("MandateText");
+    const locale = useLocale();
+    const copy = useCopy();
+    const planSelection = usePlanSelection();
+    const resolvedPlanRef = planRef ?? planSelection?.selectedPlanRef ?? void 0;
+    const resolvedProductRef = productRef ?? planSelection?.productRef;
+    const { plan } = usePlan({ planRef: resolvedPlanRef, productRef: resolvedProductRef });
+    const { product } = useProduct(resolvedProductRef);
+    const { merchant } = useMerchant();
+    const resolvedVariant = variant || deriveVariant(plan, mode);
+    const effectiveAmount = amountMinor ?? plan?.price ?? 0;
+    const effectiveCurrency = currency ?? plan?.currency ?? merchant?.defaultCurrency ?? "usd";
+    const amountFormatted = formatPrice(effectiveAmount, effectiveCurrency, {
+      locale,
+      free: copy.interval.free
+    });
+    const ctx = useMemo5(
+      () => ({
+        merchant: {
+          legalName: merchant?.legalName ?? merchant?.displayName ?? "",
+          displayName: merchant?.displayName,
+          supportEmail: merchant?.supportEmail,
+          termsUrl: merchant?.termsUrl,
+          privacyUrl: merchant?.privacyUrl
+        },
+        plan: plan ? {
+          name: plan.name,
+          interval: plan.interval,
+          intervalCount: 1,
+          trialDays: plan.trialDays,
+          measures: plan.measures,
+          billingCycle: plan.billingCycle
+        } : void 0,
+        product: product ? { name: product.name } : void 0,
+        amountFormatted,
+        trialDays: plan?.trialDays
+      }),
+      [merchant, plan, product, amountFormatted]
+    );
+    const template = copy.mandate[resolvedVariant];
+    const text = typeof template === "function" ? template(ctx) : template;
+    if (!text) return null;
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ jsx8(
+      Comp,
+      {
+        ref: forwardedRef,
+        "data-solvapay-mandate-text": "",
+        "data-variant": resolvedVariant,
+        ...rest,
+        children: children ?? text
+      }
+    );
+  }
+);
+
+// src/components/Spinner.tsx
+import { jsx as jsx9, jsxs as jsxs2 } from "react/jsx-runtime";
+var Spinner = ({
+  className = "",
+  size = "md"
+}) => {
+  const sizeClasses = {
+    sm: "h-4 w-4",
+    md: "h-5 w-5",
+    lg: "h-6 w-6"
+  };
+  return /* @__PURE__ */ jsxs2(
+    "svg",
+    {
+      className: `animate-spin ${sizeClasses[size]} ${className}`,
+      xmlns: "http://www.w3.org/2000/svg",
+      fill: "none",
+      viewBox: "0 0 24 24",
+      role: "status",
+      "aria-busy": "true",
+      children: [
+        /* @__PURE__ */ jsx9("circle", { className: "opacity-25", cx: "12", cy: "12", r: "10", stroke: "currentColor", strokeWidth: "4" }),
+        /* @__PURE__ */ jsx9(
+          "path",
+          {
+            className: "opacity-75",
+            fill: "currentColor",
+            d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/utils/confirmPayment.ts
+async function confirmPayment(input) {
+  const { stripe, elements, clientSecret, mode, returnUrl, billingDetails, copy } = input;
+  try {
+    if (mode === "payment-element") {
+      const paymentElement = elements.getElement("payment");
+      if (!paymentElement) {
+        return { status: "error", message: copy.errors.cardElementMissing };
+      }
+      const { error: error2, paymentIntent: paymentIntent2 } = await stripe.confirmPayment({
+        elements,
+        clientSecret,
+        confirmParams: {
+          return_url: returnUrl,
+          payment_method_data: billingDetails ? { billing_details: billingDetails } : void 0
+        },
+        redirect: "if_required"
+      });
+      if (error2) {
+        return { status: "error", message: error2.message || copy.errors.paymentUnexpected };
+      }
+      return mapIntent(paymentIntent2, copy);
+    }
+    const cardElement = elements.getElement("card");
+    if (!cardElement) {
+      return { status: "error", message: copy.errors.cardElementMissing };
+    }
+    const { error, paymentIntent } = await stripe.confirmCardPayment(clientSecret, {
+      payment_method: {
+        card: cardElement,
+        billing_details: billingDetails
+      }
+    });
+    if (error) {
+      return { status: "error", message: error.message || copy.errors.paymentUnexpected };
+    }
+    return mapIntent(paymentIntent, copy);
+  } catch (err) {
+    return {
+      status: "error",
+      message: err instanceof Error ? err.message : copy.errors.paymentUnexpected
+    };
+  }
+}
+function mapIntent(paymentIntent, copy) {
+  if (!paymentIntent) {
+    return { status: "error", message: copy.errors.paymentUnexpected };
+  }
+  if (paymentIntent.status === "succeeded") {
+    return { status: "succeeded", paymentIntent };
+  }
+  if (paymentIntent.status === "requires_action") {
+    return { status: "requires_action", message: copy.errors.paymentRequires3ds };
+  }
+  return {
+    status: "other",
+    message: interpolate(copy.errors.paymentStatusPrefix, {
+      status: paymentIntent.status || "processing"
+    }),
+    paymentIntent
+  };
+}
+
+// src/utils/checkoutCta.ts
+function resolveCta(input) {
+  if (input.override) return input.override;
+  const { variant, plan, product, amountFormatted, copy } = input;
+  if (variant === "recurring") {
+    if (plan?.trialDays && plan.trialDays > 0) {
+      return interpolate(copy.cta.trialStart, { trialDays: plan.trialDays });
+    }
+    return copy.cta.subscribe;
+  }
+  if (variant === "oneTime") {
+    return interpolate(copy.cta.payAmount, { amount: amountFormatted });
+  }
+  if (variant === "topup") {
+    return interpolate(copy.cta.addAmount, { amount: amountFormatted });
+  }
+  if (variant === "usageMetered" || variant === "freeTier") {
+    const productName = product?.name ?? (typeof plan?.metadata?.productName === "string" ? plan.metadata.productName : plan?.name ?? "service");
+    return interpolate(copy.cta.startUsing, { product: productName });
+  }
+  return copy.cta.payNow;
+}
+
+// src/primitives/PaymentForm.tsx
+import {
+  forwardRef as forwardRef3,
+  useCallback as useCallback8,
+  useContext as useContext7,
+  useEffect as useEffect6,
+  useMemo as useMemo6,
+  useRef as useRef4,
+  useState as useState8
+} from "react";
+import {
+  Elements,
+  useStripe,
+  useElements,
+  PaymentElement as StripePaymentElement,
+  CardElement as StripeCardElement
+} from "@stripe/react-stripe-js";
+
+// src/utils/processPaymentResult.ts
+async function reconcilePayment(input) {
+  const { paymentIntentId, productRef, planRef, processPayment, refetchPurchase, copy } = input;
+  if (!processPayment || !productRef) {
+    try {
+      await refetchPurchase();
+      return { status: "success" };
+    } catch (err) {
+      return {
+        status: "error",
+        error: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+  }
+  try {
+    const result = await processPayment({ paymentIntentId, productRef, planRef });
+    const isTimeout = result?.status === "timeout";
+    if (isTimeout) {
+      for (let attempt = 1; attempt <= 5; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, attempt * 1e3));
+        await refetchPurchase();
+      }
+      return {
+        status: "timeout",
+        error: new Error(copy.errors.paymentProcessingTimeout)
+      };
+    }
+    await refetchPurchase();
+    return { status: "success" };
+  } catch (err) {
+    return {
+      status: "error",
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  }
+}
+
+// src/primitives/PaymentForm.tsx
+import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs3 } from "react/jsx-runtime";
+function toSubmitVariant(variant) {
+  switch (variant) {
+    case "freeTier":
+      return "free";
+    case "topup":
+      return "topup";
+    case "usageMetered":
+      return "activate";
+    default:
+      return "paid";
+  }
+}
+var Root2 = forwardRef3(function PaymentFormRoot(props, forwardedRef) {
+  const {
+    planRef,
+    productRef,
+    onSuccess,
+    onResult,
+    onFreePlan,
+    onError,
+    returnUrl,
+    submitButtonText,
+    className,
+    buttonClassName,
+    prefillCustomer,
+    requireTermsAcceptance = false,
+    children
+  } = props;
+  const solva = useContext7(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("PaymentForm");
+  const copy = useCopy();
+  const locale = useLocale();
+  const planSelection = usePlanSelection();
+  const effectivePlanRef = planRef ?? planSelection?.selectedPlanRef ?? void 0;
+  const effectiveProductRef = productRef ?? planSelection?.productRef;
+  const { plan: resolvedPlan } = usePlan({
+    planRef: effectivePlanRef,
+    productRef: effectiveProductRef
+  });
+  const isFreePlan = resolvedPlan?.requiresPayment === false;
+  const {
+    loading: checkoutLoading,
+    error: checkoutError,
+    clientSecret,
+    startCheckout,
+    stripePromise,
+    resolvedPlanRef
+  } = useCheckout({
+    planRef: effectivePlanRef,
+    productRef: effectiveProductRef,
+    customer: prefillCustomer
+  });
+  const hasInitializedRef = useRef4(false);
+  const hasPlanOrProduct = !!(effectivePlanRef || effectiveProductRef);
+  useEffect6(() => {
+    if (isFreePlan) return;
+    if (!hasInitializedRef.current && hasPlanOrProduct && !checkoutLoading && !checkoutError && !clientSecret) {
+      hasInitializedRef.current = true;
+      startCheckout().catch(() => {
+        hasInitializedRef.current = false;
+      });
+    }
+    if (hasPlanOrProduct && clientSecret) {
+      hasInitializedRef.current = true;
+    }
+  }, [
+    hasPlanOrProduct,
+    checkoutLoading,
+    checkoutError,
+    clientSecret,
+    startCheckout,
+    isFreePlan
+  ]);
+  const finalReturnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
+  const elementsOptions = useMemo6(() => {
+    if (!clientSecret) return void 0;
+    return { clientSecret, locale };
+  }, [clientSecret, locale]);
+  const shouldRenderElements = !!(stripePromise && clientSecret);
+  if (!hasPlanOrProduct) {
+    return /* @__PURE__ */ jsx10(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "error",
+        children: /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-error": "", children: copy.errors.configMissingPlanOrProduct })
+      }
+    );
+  }
+  if (checkoutError) {
+    return /* @__PURE__ */ jsx10(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "error",
+        children: /* @__PURE__ */ jsxs3("div", { "data-solvapay-payment-form-error": "", children: [
+          copy.errors.paymentInitFailed,
+          " ",
+          checkoutError.message || copy.errors.unknownError
+        ] })
+      }
+    );
+  }
+  if (isFreePlan && resolvedPlan) {
+    return /* @__PURE__ */ jsx10(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "ready",
+        "data-variant": "free",
+        children: /* @__PURE__ */ jsx10(
+          FreeInner,
+          {
+            planRef: effectivePlanRef,
+            productRef: effectiveProductRef,
+            plan: resolvedPlan,
+            resolvedPlanRef,
+            requireTermsAcceptance,
+            submitButtonText,
+            buttonClassName,
+            onFreePlan,
+            onResult,
+            onError,
+            children
+          }
+        )
+      }
+    );
+  }
+  if (shouldRenderElements && elementsOptions) {
+    return /* @__PURE__ */ jsx10(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "ready",
+        "data-variant": "paid",
+        children: /* @__PURE__ */ jsx10(Elements, { stripe: stripePromise, options: elementsOptions, children: /* @__PURE__ */ jsx10(
+          PaidInner,
+          {
+            planRef: effectivePlanRef,
+            productRef: effectiveProductRef,
+            prefillCustomer,
+            resolvedPlanRef,
+            plan: resolvedPlan ?? null,
+            clientSecret,
+            returnUrl: finalReturnUrl,
+            submitButtonText,
+            buttonClassName,
+            requireTermsAcceptance,
+            onSuccess,
+            onResult,
+            onError,
+            children
+          }
+        ) }, clientSecret)
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx10(
+    "div",
+    {
+      ref: forwardedRef,
+      className,
+      "data-solvapay-payment-form": "",
+      "data-state": "loading",
+      children: /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-loading": "", children: /* @__PURE__ */ jsx10(Spinner, { size: "md" }) })
+    }
+  );
+});
+var PaidInner = ({
+  planRef,
+  productRef,
+  prefillCustomer,
+  resolvedPlanRef,
+  plan,
+  clientSecret,
+  returnUrl,
+  submitButtonText,
+  buttonClassName,
+  requireTermsAcceptance,
+  onSuccess,
+  onResult,
+  onError,
+  children
+}) => {
+  const stripe = useStripe();
+  const elements = useElements();
+  const copy = useCopy();
+  const customer = useCustomer();
+  const { processPayment } = useSolvaPay();
+  const { refetch } = usePurchase();
+  const [elementKind, setElementKind] = useState8(
+    children ? null : "payment-element"
+  );
+  const [paymentInputComplete, setPaymentInputComplete] = useState8(false);
+  const [termsAccepted, setTermsAccepted] = useState8(false);
+  const [isProcessing, setIsProcessing] = useState8(false);
+  const [error, setError] = useState8(null);
+  const isReady = !!(stripe && elements);
+  const canSubmit = isReady && !!clientSecret && !!elementKind && paymentInputComplete && (!requireTermsAcceptance || termsAccepted) && !isProcessing;
+  const submit = useCallback8(async () => {
+    if (!stripe || !elements || !clientSecret || !elementKind) {
+      const msg2 = !stripe || !elements ? copy.errors.stripeUnavailable : copy.errors.paymentIntentUnavailable;
+      setError(msg2);
+      onError?.(new Error(msg2));
+      return;
+    }
+    setError(null);
+    setIsProcessing(true);
+    const result = await confirmPayment({
+      stripe,
+      elements,
+      clientSecret,
+      mode: elementKind,
+      returnUrl,
+      billingDetails: {
+        name: customer.name ?? prefillCustomer?.name,
+        email: customer.email ?? prefillCustomer?.email
+      },
+      copy
+    });
+    if (result.status === "error") {
+      setError(result.message);
+      setIsProcessing(false);
+      onError?.(new Error(result.message));
+      return;
+    }
+    if (result.status === "requires_action" || result.status === "other") {
+      setError(result.message);
+      setIsProcessing(false);
+      return;
+    }
+    const paymentIntent = result.paymentIntent;
+    const reconcileResult = await reconcilePayment({
+      paymentIntentId: paymentIntent.id,
+      productRef,
+      planRef: planRef || resolvedPlanRef || void 0,
+      processPayment,
+      refetchPurchase: refetch,
+      copy
+    });
+    setIsProcessing(false);
+    if (reconcileResult.status === "success") {
+      const pi = paymentIntent;
+      onSuccess?.(pi);
+      const paid = { kind: "paid", paymentIntent: pi };
+      onResult?.(paid);
+      return;
+    }
+    const msg = reconcileResult.status === "timeout" ? reconcileResult.error.message : copy.errors.paymentProcessingFailed;
+    setError(msg);
+    onError?.(reconcileResult.error);
+  }, [
+    stripe,
+    elements,
+    clientSecret,
+    elementKind,
+    returnUrl,
+    customer,
+    prefillCustomer,
+    copy,
+    processPayment,
+    productRef,
+    planRef,
+    resolvedPlanRef,
+    refetch,
+    onSuccess,
+    onResult,
+    onError
+  ]);
+  const contextValue = useMemo6(
+    () => ({
+      planRef,
+      productRef,
+      prefillCustomer,
+      resolvedPlanRef,
+      plan,
+      clientSecret,
+      stripe: stripe ?? null,
+      elements: elements ?? null,
+      isProcessing,
+      isReady,
+      paymentInputComplete,
+      termsAccepted,
+      requireTermsAcceptance,
+      canSubmit,
+      error,
+      elementKind,
+      returnUrl,
+      submitButtonText,
+      buttonClassName,
+      setElementKind,
+      setPaymentInputComplete,
+      setTermsAccepted,
+      submit
+    }),
+    [
+      planRef,
+      productRef,
+      prefillCustomer,
+      resolvedPlanRef,
+      plan,
+      clientSecret,
+      stripe,
+      elements,
+      isProcessing,
+      isReady,
+      paymentInputComplete,
+      termsAccepted,
+      requireTermsAcceptance,
+      canSubmit,
+      error,
+      elementKind,
+      returnUrl,
+      submitButtonText,
+      buttonClassName,
+      submit
+    ]
+  );
+  return /* @__PURE__ */ jsx10(PaymentFormProvider, { value: contextValue, children });
+};
+var FreeInner = ({
+  planRef,
+  productRef,
+  plan,
+  resolvedPlanRef,
+  requireTermsAcceptance,
+  submitButtonText,
+  buttonClassName,
+  onFreePlan,
+  onResult,
+  onError,
+  children
+}) => {
+  const copy = useCopy();
+  const { refetch } = usePurchase();
+  const { activate, state, error: activationError, result: activationResult } = useActivation();
+  const [termsAccepted, setTermsAccepted] = useState8(false);
+  const [localError, setLocalError] = useState8(null);
+  const resultFiredRef = useRef4(false);
+  useEffect6(() => {
+    if (state === "activated" && activationResult && !resultFiredRef.current) {
+      resultFiredRef.current = true;
+      const res = { kind: "activated", result: activationResult };
+      onResult?.(res);
+      refetch().catch(() => {
+      });
+    }
+  }, [state, activationResult, onResult, refetch]);
+  const isProcessing = state === "activating";
+  const canSubmit = !isProcessing && (!requireTermsAcceptance || termsAccepted) && !!productRef;
+  const submit = useCallback8(async () => {
+    if (!productRef) {
+      const msg = copy.errors.configMissingPlanOrProduct;
+      setLocalError(msg);
+      onError?.(new Error(msg));
+      return;
+    }
+    setLocalError(null);
+    try {
+      if (onFreePlan) {
+        await onFreePlan(plan);
+        onResult?.({
+          kind: "activated",
+          result: {
+            status: "activated",
+            productRef,
+            planRef: plan.reference
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          }
+        });
+        return;
+      }
+      await activate({ productRef, planRef: plan.reference });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : copy.activation.failed;
+      setLocalError(msg);
+      onError?.(err instanceof Error ? err : new Error(msg));
+    }
+  }, [productRef, plan, onFreePlan, activate, onResult, onError, copy]);
+  const error = localError ?? activationError;
+  const contextValue = useMemo6(
+    () => ({
+      planRef,
+      productRef,
+      prefillCustomer: void 0,
+      resolvedPlanRef,
+      plan,
+      clientSecret: null,
+      stripe: null,
+      elements: null,
+      isProcessing,
+      isReady: true,
+      paymentInputComplete: true,
+      termsAccepted,
+      requireTermsAcceptance,
+      canSubmit,
+      error,
+      elementKind: null,
+      returnUrl: "",
+      submitButtonText,
+      buttonClassName,
+      setElementKind: () => {
+      },
+      setPaymentInputComplete: () => {
+      },
+      setTermsAccepted,
+      submit
+    }),
+    [
+      planRef,
+      productRef,
+      resolvedPlanRef,
+      plan,
+      isProcessing,
+      termsAccepted,
+      requireTermsAcceptance,
+      canSubmit,
+      error,
+      submitButtonText,
+      buttonClassName,
+      submit
+    ]
+  );
+  return /* @__PURE__ */ jsx10(PaymentFormProvider, { value: contextValue, children });
+};
+var Summary = (props) => {
+  const ctx = usePaymentForm();
+  return /* @__PURE__ */ jsx10(
+    CheckoutSummary2,
+    {
+      ...props,
+      planRef: ctx.planRef || ctx.resolvedPlanRef || void 0,
+      productRef: ctx.productRef
+    }
+  );
+};
+var MandateTextPrimitive = (props) => {
+  const ctx = usePaymentForm();
+  return /* @__PURE__ */ jsx10(
+    MandateText,
+    {
+      ...props,
+      planRef: ctx.planRef || ctx.resolvedPlanRef || void 0,
+      productRef: ctx.productRef
+    }
+  );
+};
+var CustomerFields = forwardRef3(
+  function PaymentFormCustomerFields({ asChild, readOnly: _readOnly = true, children, ...rest }, ref) {
+    const copy = useCopy();
+    const customer = useCustomer();
+    const { prefillCustomer } = usePaymentForm();
+    const email = customer.email ?? prefillCustomer?.email;
+    const name = customer.name ?? prefillCustomer?.name;
+    if (!email && !name) return null;
+    const Comp = asChild ? Slot : "div";
+    return /* @__PURE__ */ jsx10(Comp, { ref, "data-solvapay-payment-form-customer-fields": "", ...rest, children: children ?? /* @__PURE__ */ jsxs3(Fragment2, { children: [
+      email && /* @__PURE__ */ jsxs3("div", { "data-solvapay-payment-form-customer-email": "", children: [
+        /* @__PURE__ */ jsxs3("span", { children: [
+          copy.customer.emailLabel,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx10("span", { children: email })
+      ] }),
+      name && /* @__PURE__ */ jsxs3("div", { "data-solvapay-payment-form-customer-name": "", children: [
+        /* @__PURE__ */ jsxs3("span", { children: [
+          copy.customer.nameLabel,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx10("span", { children: name })
+      ] })
+    ] }) });
+  }
+);
+var PaymentElementSlot = ({ options }) => {
+  const { setElementKind, setPaymentInputComplete, isReady, stripe, elements } = usePaymentForm();
+  const locale = useLocale();
+  useEffect6(() => {
+    if (stripe && elements) setElementKind("payment-element");
+  }, [setElementKind, stripe, elements]);
+  if (!stripe || !elements) return null;
+  if (!isReady) {
+    return /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-loading": "", children: /* @__PURE__ */ jsx10(Spinner, { size: "sm" }) });
+  }
+  return /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-payment-element": "", children: /* @__PURE__ */ jsx10(
+    StripePaymentElement,
+    {
+      options,
+      onChange: (e) => setPaymentInputComplete(e.complete)
+    },
+    locale || "default"
+  ) });
+};
+var CardElementSlot = ({ options }) => {
+  const { setElementKind, setPaymentInputComplete, isReady, stripe, elements } = usePaymentForm();
+  useEffect6(() => {
+    if (stripe && elements) setElementKind("card-element");
+  }, [setElementKind, stripe, elements]);
+  if (!stripe || !elements) return null;
+  if (!isReady) {
+    return /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-loading": "", children: /* @__PURE__ */ jsx10(Spinner, { size: "sm" }) });
+  }
+  return /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-card-element": "", children: /* @__PURE__ */ jsx10(
+    StripeCardElement,
+    {
+      options,
+      onChange: (e) => setPaymentInputComplete(e.complete)
+    }
+  ) });
+};
+var TermsCheckbox = forwardRef3(
+  function PaymentFormTermsCheckbox({ asChild, label, children, ...rest }, ref) {
+    const { termsAccepted, setTermsAccepted } = usePaymentForm();
+    const copy = useCopy();
+    const id = "solvapay-terms-checkbox";
+    if (asChild) {
+      return /* @__PURE__ */ jsx10(Slot, { ref, "data-solvapay-payment-form-terms": "", ...rest, children });
+    }
+    return /* @__PURE__ */ jsxs3(
+      "label",
+      {
+        ref,
+        htmlFor: id,
+        "data-solvapay-payment-form-terms": "",
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsx10(
+            "input",
+            {
+              id,
+              type: "checkbox",
+              checked: termsAccepted,
+              onChange: (e) => setTermsAccepted(e.target.checked)
+            }
+          ),
+          /* @__PURE__ */ jsx10("span", { children: label ?? copy.terms.checkboxLabel })
+        ]
+      }
+    );
+  }
+);
+var SubmitButton = forwardRef3(
+  function PaymentFormSubmitButton({ asChild, onClick, children, ...rest }, ref) {
+    const ctx = usePaymentForm();
+    const copy = useCopy();
+    const locale = useLocale();
+    const { plan } = usePlan({
+      planRef: ctx.planRef || ctx.resolvedPlanRef || void 0,
+      productRef: ctx.productRef
+    });
+    const { product } = useProduct(ctx.productRef);
+    const variant = deriveVariant(plan ?? ctx.plan ?? void 0);
+    const dataVariant = toSubmitVariant(variant);
+    const dataState = ctx.isProcessing ? "processing" : !ctx.canSubmit ? "disabled" : "idle";
+    const amountFormatted = formatPrice(
+      plan?.price ?? ctx.plan?.price ?? 0,
+      plan?.currency ?? ctx.plan?.currency ?? "usd",
+      { locale, free: copy.interval.free }
+    );
+    const label = resolveCta({
+      variant,
+      plan: plan ?? ctx.plan,
+      product,
+      amountFormatted,
+      copy,
+      override: typeof children === "string" ? children : ctx.submitButtonText
+    });
+    const content = ctx.isProcessing ? /* @__PURE__ */ jsxs3(Fragment2, { children: [
+      /* @__PURE__ */ jsx10(Spinner, { size: "sm" }),
+      /* @__PURE__ */ jsx10("span", { children: copy.cta.processing })
+    ] }) : children && typeof children !== "string" ? children : label;
+    const buttonProps = {
+      "data-solvapay-payment-form-submit": "",
+      "data-state": dataState,
+      "data-variant": dataVariant,
+      "aria-busy": ctx.isProcessing,
+      "aria-disabled": !ctx.canSubmit,
+      "aria-label": label,
+      disabled: !ctx.canSubmit,
+      className: rest.className ?? ctx.buttonClassName,
+      onClick: composeEventHandlers(onClick, (e) => {
+        e.preventDefault();
+        ctx.submit();
+      }),
+      ...rest
+    };
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ jsx10(Slot, { ref, ...buttonProps, children: content })
+      );
+    }
+    return /* @__PURE__ */ jsx10("button", { ref, type: "submit", ...buttonProps, children: content });
+  }
+);
+var Loading = forwardRef3(function PaymentFormLoading({ asChild, children, ...rest }, ref) {
+  const ctx = usePaymentForm();
+  if (ctx.isReady && ctx.clientSecret) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx10(Comp, { ref, "data-solvapay-payment-form-loading": "", ...rest, children: children ?? /* @__PURE__ */ jsx10(Spinner, { size: "sm" }) });
+});
+var ErrorSlot = forwardRef3(function PaymentFormError({ asChild, children, ...rest }, ref) {
+  const ctx = usePaymentForm();
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx10(
+    Comp,
+    {
+      ref,
+      role: "alert",
+      "aria-live": "assertive",
+      "aria-atomic": "true",
+      "data-solvapay-payment-form-error": "",
+      ...rest,
+      children: children ?? ctx.error
+    }
+  );
+});
+var PaymentFormRoot2 = Root2;
+var PaymentFormSummary = Summary;
+var PaymentFormCustomerFields2 = CustomerFields;
+var PaymentFormPaymentElement = PaymentElementSlot;
+var PaymentFormCardElement = CardElementSlot;
+var PaymentFormMandateText = MandateTextPrimitive;
+var PaymentFormTermsCheckbox2 = TermsCheckbox;
+var PaymentFormSubmitButton2 = SubmitButton;
+var PaymentFormLoading2 = Loading;
+var PaymentFormError2 = ErrorSlot;
+var PaymentForm = {
+  Root: Root2,
+  Summary,
+  CustomerFields,
+  PaymentElement: PaymentElementSlot,
+  CardElement: CardElementSlot,
+  MandateText: MandateTextPrimitive,
+  TermsCheckbox,
+  SubmitButton,
+  Loading,
+  Error: ErrorSlot
+};
+
+// src/hooks/useTopupAmountSelector.ts
+import { useState as useState9, useCallback as useCallback9, 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 copy = useCopy();
+  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 = useCallback9(
+    (amount) => {
+      setSelectedAmount(amount);
+      setCustomAmountRaw("");
+      setError(null);
+    },
+    []
+  );
+  const setCustomAmount = useCallback9(
+    (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 = useCallback9(() => {
+    if (resolvedAmount == null) {
+      setError(copy.topup.selectOrEnterAmount);
+      return false;
+    }
+    if (resolvedAmount < minAmount) {
+      setError(
+        interpolate(copy.topup.minAmount, {
+          amount: `${currencySymbol}${minAmount}`
+        })
+      );
+      return false;
+    }
+    if (resolvedAmount > maxAmount) {
+      setError(
+        interpolate(copy.topup.maxAmount, {
+          amount: `${currencySymbol}${maxAmount.toLocaleString()}`
+        })
+      );
+      return false;
+    }
+    setError(null);
+    return true;
+  }, [resolvedAmount, minAmount, maxAmount, currencySymbol, copy]);
+  const reset = useCallback9(() => {
+    setSelectedAmount(null);
+    setCustomAmountRaw("");
+    setError(null);
+  }, []);
+  return {
+    quickAmounts,
+    selectedAmount,
+    customAmount,
+    resolvedAmount,
+    selectQuickAmount,
+    setCustomAmount,
+    error,
+    validate,
+    reset,
+    currencySymbol
+  };
+}
+
+// src/hooks/useBalance.ts
+import { useEffect as useEffect7 } from "react";
+function useBalance() {
+  const { balance } = useSolvaPay();
+  useEffect7(() => {
+    balance.refetch();
+  }, [balance.refetch]);
+  return balance;
+}
+
+// src/primitives/AmountPicker.tsx
+import {
+  createContext as createContext6,
+  forwardRef as forwardRef4,
+  useCallback as useCallback10,
+  useContext as useContext8,
+  useEffect as useEffect8,
+  useMemo as useMemo8
+} from "react";
+import { Fragment as Fragment3, jsx as jsx11, jsxs as jsxs4 } from "react/jsx-runtime";
+var AmountPickerContext = createContext6(null);
+function usePickerCtx(part) {
+  const ctx = useContext8(AmountPickerContext);
+  if (!ctx) {
+    throw new Error(`AmountPicker.${part} must be rendered inside <AmountPicker.Root>.`);
+  }
+  return ctx;
+}
+var Root3 = forwardRef4(function AmountPickerRoot({ currency, minAmount, maxAmount, onChange, asChild, children, ...rest }, forwardedRef) {
+  const solva = useContext8(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("AmountPicker");
+  const selector = useTopupAmountSelector({ currency, minAmount, maxAmount });
+  const { creditsPerMinorUnit, displayExchangeRate } = useBalance();
+  useEffect8(() => {
+    onChange?.(selector.resolvedAmount);
+  }, [selector.resolvedAmount, onChange]);
+  const resolvedAmountMinor = selector.resolvedAmount != null && selector.resolvedAmount > 0 ? Math.round(selector.resolvedAmount * 100) : null;
+  const rate = displayExchangeRate ?? 1;
+  const estimatedCredits = creditsPerMinorUnit != null && creditsPerMinorUnit > 0 && resolvedAmountMinor != null ? Math.floor(resolvedAmountMinor / rate * creditsPerMinorUnit) : null;
+  const isApproximate = rate !== 1;
+  const ctx = useMemo8(
+    () => ({
+      ...selector,
+      currency,
+      creditsPerMinorUnit,
+      displayExchangeRate,
+      estimatedCredits,
+      isApproximate
+    }),
+    [selector, currency, creditsPerMinorUnit, displayExchangeRate, estimatedCredits, isApproximate]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx11(AmountPickerContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx11(Comp, { ref: forwardedRef, "data-solvapay-amount-picker": "", ...rest, children }) });
+});
+var Option = forwardRef4(function AmountPickerOption({ asChild, amount, onClick, children, ...rest }, forwardedRef) {
+  const ctx = usePickerCtx("Option");
+  const isActive = ctx.selectedAmount === amount && !ctx.customAmount;
+  const state = rest.disabled ? "disabled" : isActive ? "selected" : "idle";
+  const commonProps = {
+    "data-solvapay-amount-picker-option": "",
+    "data-state": state,
+    "data-amount": String(amount),
+    "aria-pressed": isActive,
+    onClick: composeEventHandlers(onClick, () => {
+      ctx.selectQuickAmount(amount);
+    }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx11(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsxs4(Fragment3, { children: [
+        ctx.currencySymbol,
+        amount.toLocaleString()
+      ] }) })
+    );
+  }
+  return /* @__PURE__ */ jsx11("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? /* @__PURE__ */ jsxs4(Fragment3, { children: [
+    ctx.currencySymbol,
+    amount.toLocaleString()
+  ] }) });
+});
+var Custom = forwardRef4(function AmountPickerCustom({ asChild, onChange, onFocus, ...rest }, forwardedRef) {
+  const ctx = usePickerCtx("Custom");
+  const state = ctx.customAmount ? "active" : "dormant";
+  const commonProps = {
+    "data-solvapay-amount-picker-custom": "",
+    "data-state": state,
+    type: "text",
+    inputMode: "decimal",
+    placeholder: "0.00",
+    value: ctx.customAmount,
+    onChange: composeEventHandlers(onChange, (e) => {
+      ctx.setCustomAmount(e.target.value);
+    }),
+    onFocus: composeEventHandlers(onFocus, () => {
+      if (ctx.selectedAmount != null) ctx.selectQuickAmount(0);
+    }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx11(Slot, { ref: forwardedRef, ...commonProps })
+    );
+  }
+  return /* @__PURE__ */ jsx11("input", { ref: forwardedRef, ...commonProps });
+});
+var Confirm = forwardRef4(function AmountPickerConfirm({ asChild, onClick, onConfirm, disabled, children, ...rest }, forwardedRef) {
+  const ctx = usePickerCtx("Confirm");
+  const isDisabled = disabled || !ctx.resolvedAmount;
+  const handleConfirm = useCallback10(() => {
+    if (ctx.validate() && ctx.resolvedAmount != null) {
+      onConfirm?.(ctx.resolvedAmount);
+    }
+  }, [ctx, onConfirm]);
+  const commonProps = {
+    "data-solvapay-amount-picker-confirm": "",
+    "data-state": isDisabled ? "disabled" : "idle",
+    disabled: isDisabled,
+    "aria-disabled": isDisabled || void 0,
+    onClick: composeEventHandlers(onClick, handleConfirm),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx11(Slot, { ref: forwardedRef, ...commonProps, children })
+    );
+  }
+  return /* @__PURE__ */ jsx11("button", { ref: forwardedRef, type: "button", ...commonProps, children });
+});
+var AmountPickerRoot2 = Root3;
+var AmountPickerOption2 = Option;
+var AmountPickerCustom2 = Custom;
+var AmountPickerConfirm2 = Confirm;
+var AmountPicker = {
+  Root: Root3,
+  Option,
+  Custom,
+  Confirm
+};
+function useAmountPicker() {
+  return usePickerCtx("useAmountPicker");
+}
+function useAmountPickerCopy() {
+  const copy = useCopy();
+  const ctx = usePickerCtx("useAmountPickerCopy");
+  return {
+    selectAmountLabel: copy.amountPicker.selectAmountLabel,
+    customAmountLabel: copy.amountPicker.customAmountLabel,
+    creditEstimate: (credits) => interpolate(
+      ctx.isApproximate ? copy.amountPicker.creditEstimateApprox : copy.amountPicker.creditEstimateExact,
+      { credits: new Intl.NumberFormat().format(credits) }
+    )
+  };
+}
+
+// src/hooks/useTopup.ts
+import { useState as useState10, useCallback as useCallback11, useRef as useRef5 } 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] = useState10(false);
+  const [error, setError] = useState10(null);
+  const [stripePromise, setStripePromise] = useState10(null);
+  const [clientSecret, setClientSecret] = useState10(null);
+  const isStartingRef = useRef5(false);
+  const startTopup = useCallback11(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 = useCallback11(() => {
+    isStartingRef.current = false;
+    setLoading(false);
+    setError(null);
+    setStripePromise(null);
+    setClientSecret(null);
+  }, []);
+  return {
+    loading,
+    error,
+    stripePromise,
+    clientSecret,
+    startTopup,
+    reset
+  };
+}
+
+// src/primitives/TopupForm.tsx
+import {
+  createContext as createContext7,
+  forwardRef as forwardRef5,
+  useCallback as useCallback12,
+  useContext as useContext9,
+  useEffect as useEffect9,
+  useMemo as useMemo9,
+  useRef as useRef6,
+  useState as useState11
+} from "react";
+import {
+  Elements as Elements2,
+  useStripe as useStripe2,
+  useElements as useElements2,
+  PaymentElement as StripePaymentElement2
+} from "@stripe/react-stripe-js";
+import { Fragment as Fragment4, jsx as jsx12, jsxs as jsxs5 } from "react/jsx-runtime";
+var TopupFormContext = createContext7(null);
+function useTopupCtx(part) {
+  const ctx = useContext9(TopupFormContext);
+  if (!ctx) {
+    throw new Error(`TopupForm.${part} must be rendered inside <TopupForm.Root>.`);
+  }
+  return ctx;
+}
+var Root4 = forwardRef5(function TopupFormRoot(props, forwardedRef) {
+  const {
+    amount,
+    currency,
+    onSuccess,
+    onError,
+    returnUrl,
+    submitButtonText: _submitButtonText,
+    buttonClassName: _buttonClassName,
+    className,
+    asChild,
+    children,
+    ...rest
+  } = props;
+  const solva = useContext9(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("TopupForm");
+  const copy = useCopy();
+  const locale = useLocale();
+  const { loading, error: topupError, clientSecret, startTopup, stripePromise } = useTopup({
+    amount,
+    currency
+  });
+  const hasInitializedRef = useRef6(false);
+  const hasAmount = amount > 0;
+  useEffect9(() => {
+    if (!hasInitializedRef.current && hasAmount && !loading && !topupError && !clientSecret) {
+      hasInitializedRef.current = true;
+      startTopup().catch(() => {
+        hasInitializedRef.current = false;
+      });
+    }
+    if (hasAmount && clientSecret) hasInitializedRef.current = true;
+  }, [hasAmount, loading, topupError, clientSecret, startTopup]);
+  const finalReturnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
+  const elementsOptions = useMemo9(() => {
+    if (!clientSecret) return void 0;
+    return { clientSecret, locale };
+  }, [clientSecret, locale]);
+  const Comp = asChild ? Slot : "div";
+  const outerError = !hasAmount ? copy.errors.configMissingAmount : topupError ? `${copy.errors.topupInitFailed} ${topupError.message || copy.errors.unknownError}` : null;
+  const dataState = outerError ? "error" : clientSecret && stripePromise ? "ready" : "loading";
+  const canMountElements = !!(stripePromise && clientSecret && elementsOptions);
+  const innerCommon = {
+    amount,
+    currency,
+    clientSecret,
+    returnUrl: finalReturnUrl,
+    outerError,
+    state: dataState,
+    onSuccess,
+    onError
+  };
+  const shell = /* @__PURE__ */ jsx12(
+    Comp,
+    {
+      ref: forwardedRef,
+      className,
+      "data-solvapay-topup-form": "",
+      "data-state": dataState,
+      ...rest,
+      children
+    }
+  );
+  if (canMountElements) {
+    return /* @__PURE__ */ jsx12(Elements2, { stripe: stripePromise, options: elementsOptions, children: /* @__PURE__ */ jsx12(Inner, { ...innerCommon, children: shell }) }, clientSecret);
+  }
+  return /* @__PURE__ */ jsx12(OfflineInner, { ...innerCommon, children: shell });
+});
+var Inner = ({
+  amount,
+  currency,
+  clientSecret,
+  returnUrl,
+  outerError,
+  state,
+  onSuccess,
+  onError,
+  children
+}) => {
+  const stripe = useStripe2();
+  const elements = useElements2();
+  const copy = useCopy();
+  const [paymentInputComplete, setPaymentInputComplete] = useState11(false);
+  const [isProcessing, setIsProcessing] = useState11(false);
+  const [error, setError] = useState11(null);
+  const isReady = !!(stripe && elements);
+  const canSubmit = isReady && paymentInputComplete && !isProcessing && !!clientSecret;
+  const submit = useCallback12(async () => {
+    if (!stripe || !elements || !clientSecret) {
+      const msg = copy.errors.stripeUnavailable;
+      setError(msg);
+      onError?.(new Error(msg));
+      return;
+    }
+    setError(null);
+    setIsProcessing(true);
+    const { error: confirmError, paymentIntent } = await stripe.confirmPayment({
+      elements,
+      clientSecret,
+      confirmParams: { return_url: returnUrl },
+      redirect: "if_required"
+    });
+    if (confirmError) {
+      const msg = confirmError.message || copy.errors.paymentUnexpected;
+      setError(msg);
+      setIsProcessing(false);
+      onError?.(new Error(msg));
+      return;
+    }
+    setIsProcessing(false);
+    if (paymentIntent) {
+      await onSuccess?.(paymentIntent);
+    }
+  }, [stripe, elements, clientSecret, returnUrl, copy, onSuccess, onError]);
+  const effectiveError = error ?? outerError;
+  const ctx = useMemo9(
+    () => ({
+      amount,
+      currency,
+      state,
+      clientSecret,
+      stripe: stripe ?? null,
+      elements: elements ?? null,
+      isReady,
+      isProcessing,
+      paymentInputComplete,
+      canSubmit,
+      error: effectiveError,
+      returnUrl,
+      setPaymentInputComplete,
+      submit
+    }),
+    [
+      amount,
+      currency,
+      state,
+      clientSecret,
+      stripe,
+      elements,
+      isReady,
+      isProcessing,
+      paymentInputComplete,
+      canSubmit,
+      effectiveError,
+      returnUrl,
+      submit
+    ]
+  );
+  return /* @__PURE__ */ jsx12(TopupFormContext.Provider, { value: ctx, children });
+};
+var OfflineInner = ({
+  amount,
+  currency,
+  clientSecret,
+  returnUrl,
+  outerError,
+  state,
+  children
+}) => {
+  const noopSubmit = useCallback12(async () => {
+  }, []);
+  const noopSet = useCallback12(() => {
+  }, []);
+  const ctx = useMemo9(
+    () => ({
+      amount,
+      currency,
+      state,
+      clientSecret,
+      stripe: null,
+      elements: null,
+      isReady: false,
+      isProcessing: false,
+      paymentInputComplete: false,
+      canSubmit: false,
+      error: outerError,
+      returnUrl,
+      setPaymentInputComplete: noopSet,
+      submit: noopSubmit
+    }),
+    [amount, currency, state, clientSecret, outerError, returnUrl, noopSet, noopSubmit]
+  );
+  return /* @__PURE__ */ jsx12(TopupFormContext.Provider, { value: ctx, children });
+};
+var PaymentElementSlot2 = ({ options }) => {
+  const { setPaymentInputComplete, isReady, stripe, elements } = useTopupCtx("PaymentElement");
+  const locale = useLocale();
+  if (!stripe || !elements) return null;
+  if (!isReady) {
+    return /* @__PURE__ */ jsx12("div", { "data-solvapay-topup-form-loading": "", children: /* @__PURE__ */ jsx12(Spinner, { size: "sm" }) });
+  }
+  return /* @__PURE__ */ jsx12("div", { "data-solvapay-topup-form-payment-element": "", children: /* @__PURE__ */ jsx12(
+    StripePaymentElement2,
+    {
+      options,
+      onChange: (e) => setPaymentInputComplete(e.complete)
+    },
+    locale || "default"
+  ) });
+};
+var SubmitButton2 = forwardRef5(function TopupFormSubmitButton({ asChild, onClick, children, ...rest }, forwardedRef) {
+  const ctx = useTopupCtx("SubmitButton");
+  const copy = useCopy();
+  const dataState = ctx.isProcessing ? "processing" : !ctx.canSubmit ? "disabled" : "idle";
+  const content = ctx.isProcessing ? /* @__PURE__ */ jsxs5(Fragment4, { children: [
+    /* @__PURE__ */ jsx12(Spinner, { size: "sm" }),
+    /* @__PURE__ */ jsx12("span", { children: copy.cta.processing })
+  ] }) : children ? children : copy.cta.topUp;
+  const commonProps = {
+    "data-solvapay-topup-form-submit": "",
+    "data-state": dataState,
+    "aria-busy": ctx.isProcessing,
+    "aria-disabled": !ctx.canSubmit,
+    disabled: !ctx.canSubmit,
+    onClick: composeEventHandlers(onClick, (e) => {
+      e.preventDefault();
+      void ctx.submit();
+    }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx12(Slot, { ref: forwardedRef, ...commonProps, children: content })
+    );
+  }
+  return /* @__PURE__ */ jsx12("button", { ref: forwardedRef, type: "submit", ...commonProps, children: content });
+});
+var Loading2 = forwardRef5(function TopupFormLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useTopupCtx("Loading");
+  if (ctx.state !== "loading") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx12(Comp, { ref: forwardedRef, "data-solvapay-topup-form-loading": "", ...rest, children: children ?? /* @__PURE__ */ jsx12(Spinner, { size: "sm" }) });
+});
+var ErrorSlot2 = forwardRef5(function TopupFormError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useTopupCtx("Error");
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx12(
+    Comp,
+    {
+      ref: forwardedRef,
+      role: "alert",
+      "aria-live": "assertive",
+      "aria-atomic": "true",
+      "data-solvapay-topup-form-error": "",
+      ...rest,
+      children: children ?? ctx.error
+    }
+  );
+});
+var TopupFormRoot2 = Root4;
+var TopupFormPaymentElement = PaymentElementSlot2;
+var TopupFormSubmitButton2 = SubmitButton2;
+var TopupFormLoading2 = Loading2;
+var TopupFormError2 = ErrorSlot2;
+var TopupForm = {
+  Root: Root4,
+  AmountPicker: AmountPicker.Root,
+  PaymentElement: PaymentElementSlot2,
+  SubmitButton: SubmitButton2,
+  Loading: Loading2,
+  Error: ErrorSlot2
+};
+function useTopupForm() {
+  return useTopupCtx("useTopupForm");
+}
+
+// src/TopupForm.tsx
+import { jsx as jsx13, jsxs as jsxs6 } from "react/jsx-runtime";
+var TopupForm2 = (props) => {
+  const { className, buttonClassName, submitButtonText, ...rootProps } = props;
+  const rootClass = ["solvapay-topup-form", className].filter(Boolean).join(" ");
+  const buttonClass = ["solvapay-topup-form-submit", buttonClassName].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs6(TopupForm.Root, { ...rootProps, className: rootClass, children: [
+    /* @__PURE__ */ jsx13(TopupForm.PaymentElement, {}),
+    /* @__PURE__ */ jsx13(TopupForm.Error, { className: "solvapay-topup-form-error" }),
+    /* @__PURE__ */ jsx13(TopupForm.Loading, { className: "solvapay-topup-form-loading" }),
+    /* @__PURE__ */ jsx13(TopupForm.SubmitButton, { className: buttonClass, children: submitButtonText })
+  ] });
+};
+
+// src/primitives/ProductBadge.tsx
+import { forwardRef as forwardRef6, useContext as useContext10, useEffect as useEffect10, useState as useState12 } from "react";
+import { Fragment as Fragment5, jsx as jsx14 } from "react/jsx-runtime";
+var ProductBadgeImpl = forwardRef6(function ProductBadge({ asChild, children, ...rest }, forwardedRef) {
+  const solva = useContext10(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("ProductBadge");
+  const { purchases, loading, hasPaidPurchase, activePurchase } = usePurchase();
+  const copy = useCopy();
+  const [hasLoadedOnce, setHasLoadedOnce] = useState12(false);
+  useEffect10(() => {
+    if (!loading) setHasLoadedOnce(true);
+  }, [loading]);
+  const planToDisplay = activePurchase?.productName ?? null;
+  const shouldShow = planToDisplay !== null && (!loading || hasLoadedOnce);
+  if (!shouldShow) return null;
+  const commonProps = {
+    "data-solvapay-product-badge": "",
+    "data-loading": loading ? "" : void 0,
+    "data-has-purchase": activePurchase ? "" : void 0,
+    "data-has-paid-purchase": hasPaidPurchase ? "" : void 0,
+    role: "status",
+    "aria-live": "polite",
+    "aria-busy": loading,
+    "aria-label": interpolate(copy.product.currentProductLabel, { name: planToDisplay }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx14(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx14(Fragment5, { children: planToDisplay }) })
+    );
+  }
+  void purchases;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    /* @__PURE__ */ jsx14("div", { ref: forwardedRef, ...commonProps, children: children ?? planToDisplay })
+  );
+});
+var ProductBadge2 = ProductBadgeImpl;
+var PlanBadge = ProductBadgeImpl;
+
+// src/primitives/PurchaseGate.tsx
+import {
+  createContext as createContext8,
+  forwardRef as forwardRef7,
+  useContext as useContext11,
+  useMemo as useMemo10
+} from "react";
+import { jsx as jsx15 } from "react/jsx-runtime";
+var PurchaseGateContext = createContext8(null);
+function useGateCtx(part) {
+  const ctx = useContext11(PurchaseGateContext);
+  if (!ctx) {
+    throw new Error(`PurchaseGate.${part} must be rendered inside <PurchaseGate.Root>.`);
+  }
+  return ctx;
+}
+var Root5 = forwardRef7(function PurchaseGateRoot({ requirePlan, requireProduct, asChild, children, ...rest }, forwardedRef) {
+  const solva = useContext11(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("PurchaseGate");
+  const { purchases, loading, hasProduct, error } = usePurchase();
+  const productToCheck = requireProduct || requirePlan;
+  const hasAccess = productToCheck ? hasProduct(productToCheck) : purchases.some((p) => p.status === "active");
+  const state = loading ? "loading" : hasAccess ? "allowed" : "blocked";
+  const ctx = useMemo10(
+    () => ({ state, loading, hasAccess, error }),
+    [state, loading, hasAccess, error]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx15(PurchaseGateContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx15(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-purchase-gate": "",
+      "data-state": state,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Allowed = forwardRef7(function PurchaseGateAllowed({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Allowed");
+  if (ctx.state !== "allowed") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx15(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-allowed": "", ...rest, children });
+});
+var Blocked = forwardRef7(function PurchaseGateBlocked({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Blocked");
+  if (ctx.state !== "blocked") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx15(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-blocked": "", ...rest, children });
+});
+var Loading3 = forwardRef7(function PurchaseGateLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Loading");
+  if (ctx.state !== "loading") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx15(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-loading": "", ...rest, children });
+});
+var ErrorSlot3 = forwardRef7(function PurchaseGateError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Error");
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx15(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-error": "", role: "alert", ...rest, children: children ?? ctx.error.message });
+});
+var PurchaseGateRoot2 = Root5;
+var PurchaseGateAllowed2 = Allowed;
+var PurchaseGateBlocked2 = Blocked;
+var PurchaseGateLoading2 = Loading3;
+var PurchaseGateError2 = ErrorSlot3;
+var PurchaseGate = {
+  Root: Root5,
+  Allowed,
+  Blocked,
+  Loading: Loading3,
+  Error: ErrorSlot3
+};
+function usePurchaseGate() {
+  return useGateCtx("usePurchaseGate");
+}
+
+// src/primitives/BalanceBadge.tsx
+import { forwardRef as forwardRef8, useContext as useContext12 } from "react";
+import { Fragment as Fragment6, jsx as jsx16, jsxs as jsxs7 } from "react/jsx-runtime";
+var BalanceBadge = forwardRef8(function BalanceBadge2({ asChild, numberOnly, lowThreshold = 10, children, ...rest }, forwardedRef) {
+  const solva = useContext12(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("BalanceBadge");
+  const { credits, displayCurrency, creditsPerMinorUnit, displayExchangeRate, loading } = useBalance();
+  const copy = useCopy();
+  const locale = useLocale();
+  const state = loading ? "loading" : credits == null || credits === 0 ? "zero" : credits <= lowThreshold ? "low" : "ok";
+  const commonProps = {
+    "data-solvapay-balance-badge": "",
+    "data-state": state,
+    "data-credits": credits == null ? void 0 : String(credits),
+    "aria-busy": loading,
+    ...rest
+  };
+  if (state === "loading") {
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ jsx16(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx16(Fragment6, {}) })
+      );
+    }
+    return /* @__PURE__ */ jsx16("span", { ref: forwardedRef, ...commonProps });
+  }
+  if (credits == null) return null;
+  const formattedCredits = new Intl.NumberFormat(locale).format(credits);
+  let currencyEquivalent = "";
+  if (!numberOnly && displayCurrency && creditsPerMinorUnit) {
+    const usdCents = credits / creditsPerMinorUnit;
+    const displayMajorUnits = usdCents * (displayExchangeRate ?? 1) / 100;
+    const formatted = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: displayCurrency,
+      minimumFractionDigits: 2
+    }).format(displayMajorUnits);
+    currencyEquivalent = interpolate(copy.balance.currencyEquivalent, { amount: formatted });
+  }
+  const content = children ?? /* @__PURE__ */ jsxs7(Fragment6, { children: [
+    formattedCredits,
+    !numberOnly && copy.balance.credits,
+    !numberOnly && currencyEquivalent
+  ] });
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx16(Slot, { ref: forwardedRef, ...commonProps, children: content })
+    );
+  }
+  return /* @__PURE__ */ jsx16("span", { ref: forwardedRef, ...commonProps, children: content });
+});
+
+// src/primitives/PlanSelector.tsx
+import {
+  createContext as createContext9,
+  forwardRef as forwardRef9,
+  useCallback as useCallback13,
+  useContext as useContext13,
+  useMemo as useMemo11
+} from "react";
+import { jsx as jsx17 } from "react/jsx-runtime";
+var PlanSelectorContext = createContext9(null);
+function usePlanSelectorContext(part) {
+  const ctx = useContext13(PlanSelectorContext);
+  if (!ctx) {
+    throw new Error(`PlanSelector.${part} must be rendered inside <PlanSelector.Root>.`);
+  }
+  return ctx;
+}
+var CardContext = createContext9(null);
+function useCardContext(part) {
+  const ctx = useContext13(CardContext);
+  if (!ctx) {
+    throw new Error(`PlanSelector.${part} must be rendered inside <PlanSelector.Card>.`);
+  }
+  return ctx;
+}
+async function defaultListPlans(productRef, config) {
+  const base = config?.api?.listPlans || "/api/list-plans";
+  const url = `${base}?productRef=${encodeURIComponent(productRef)}`;
+  const fetchFn = config?.fetch || fetch;
+  const { headers } = await buildRequestHeaders(config);
+  const res = await fetchFn(url, { method: "GET", headers });
+  if (!res.ok) {
+    const error = new Error(`Failed to fetch plans: ${res.statusText || res.status}`);
+    config?.onError?.(error, "listPlans");
+    throw error;
+  }
+  const data = await res.json();
+  return data.plans ?? [];
+}
+var Root6 = forwardRef9(function PlanSelectorRoot(props, forwardedRef) {
+  const {
+    productRef,
+    fetcher,
+    filter,
+    sortBy,
+    autoSelectFirstPaid = true,
+    initialPlanRef,
+    currentPlanRef,
+    popularPlanRef,
+    onSelect,
+    children,
+    ...rest
+  } = props;
+  const solva = useContext13(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("PlanSelector");
+  if (!productRef) throw new MissingProductRefError("PlanSelector");
+  const { _config } = solva;
+  const { purchases } = usePurchase();
+  const effectiveFetcher = useMemo11(
+    () => fetcher ?? ((ref) => defaultListPlans(ref, _config)),
+    [fetcher, _config]
+  );
+  const { plans, selectedPlan, selectPlan, loading, error } = usePlans({
+    productRef,
+    fetcher: effectiveFetcher,
+    filter,
+    sortBy,
+    autoSelectFirstPaid,
+    initialPlanRef
+  });
+  const autoCurrentPlanRef = useMemo11(() => {
+    const active = purchases.filter((p) => p.status === "active").sort((a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime())[0];
+    return active?.planSnapshot?.reference ?? null;
+  }, [purchases]);
+  const resolvedCurrentPlanRef = currentPlanRef === null ? null : currentPlanRef ?? autoCurrentPlanRef;
+  const isCurrent = useCallback13(
+    (ref) => resolvedCurrentPlanRef === ref,
+    [resolvedCurrentPlanRef]
+  );
+  const isFree = useCallback13(
+    (ref) => plans.find((p) => p.reference === ref)?.requiresPayment === false,
+    [plans]
+  );
+  const isPopular = useCallback13(
+    (ref) => popularPlanRef === ref,
+    [popularPlanRef]
+  );
+  const select = useCallback13(
+    (ref) => {
+      const plan = plans.find((p) => p.reference === ref);
+      if (!plan) return;
+      if (plan.requiresPayment === false) return;
+      selectPlan(ref);
+      onSelect?.(ref, plan);
+    },
+    [plans, selectPlan, onSelect]
+  );
+  const selectedPlanRef = selectedPlan?.reference ?? null;
+  const ctx = useMemo11(
+    () => ({
+      plans,
+      loading,
+      error,
+      selectedPlan: selectedPlan ?? null,
+      selectedPlanRef,
+      popularPlanRef,
+      currentPlanRef: resolvedCurrentPlanRef,
+      isCurrent,
+      isFree,
+      isPopular,
+      select
+    }),
+    [
+      plans,
+      loading,
+      error,
+      selectedPlan,
+      selectedPlanRef,
+      popularPlanRef,
+      resolvedCurrentPlanRef,
+      isCurrent,
+      isFree,
+      isPopular,
+      select
+    ]
+  );
+  return /* @__PURE__ */ jsx17(
+    PlanSelectionProvider,
+    {
+      value: {
+        productRef,
+        selectedPlanRef,
+        setSelectedPlanRef: (ref) => {
+          if (ref) select(ref);
+        },
+        plans,
+        loading,
+        error
+      },
+      children: /* @__PURE__ */ jsx17("div", { ref: forwardedRef, "data-solvapay-plan-selector": "", ...rest, children: /* @__PURE__ */ jsx17(PlanSelectorContext.Provider, { value: ctx, children }) })
+    }
+  );
+});
+var Heading = forwardRef9(function PlanSelectorHeading({ asChild, children, ...rest }, forwardedRef) {
+  usePlanSelectorContext("Heading");
+  const copy = useCopy();
+  const Comp = asChild ? Slot : "h3";
+  return /* @__PURE__ */ jsx17(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-heading": "", ...rest, children: children ?? copy.planSelector.heading });
+});
+var Grid = forwardRef9(function PlanSelectorGrid({ children, ...rest }, forwardedRef) {
+  const ctx = usePlanSelectorContext("Grid");
+  return /* @__PURE__ */ jsx17("div", { ref: forwardedRef, "data-solvapay-plan-selector-grid": "", ...rest, children: ctx.plans.map((plan) => {
+    const isCurrent = ctx.isCurrent(plan.reference);
+    const isFree = ctx.isFree(plan.reference);
+    const isPopular = ctx.isPopular(plan.reference);
+    const selected = ctx.selectedPlanRef === plan.reference;
+    const disabled = isCurrent || isFree;
+    const state = isCurrent ? "current" : isFree ? "disabled" : selected ? "selected" : "idle";
+    const cardCtx = {
+      plan,
+      state,
+      isCurrent,
+      isFree,
+      isPopular,
+      disabled,
+      select: () => ctx.select(plan.reference)
+    };
+    return /* @__PURE__ */ jsx17(CardContext.Provider, { value: cardCtx, children }, plan.reference);
+  }) });
+});
+var Card = forwardRef9(function PlanSelectorCard({ asChild, onClick, children, ...rest }, forwardedRef) {
+  const card = useCardContext("Card");
+  const dataTrial = !!(card.plan.trialDays && card.plan.trialDays > 0);
+  const commonProps = {
+    "data-solvapay-plan-selector-card": "",
+    "data-state": card.state,
+    "data-free": card.isFree ? "" : void 0,
+    "data-popular": card.isPopular ? "" : void 0,
+    "data-trial": dataTrial ? "" : void 0,
+    "aria-disabled": card.disabled || void 0,
+    onClick: composeEventHandlers(onClick, () => {
+      if (!card.disabled) card.select();
+    }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx17(Slot, { ref: forwardedRef, ...commonProps, children })
+    );
+  }
+  return /* @__PURE__ */ jsx17(
+    "button",
+    {
+      ref: forwardedRef,
+      type: "button",
+      disabled: card.disabled,
+      ...commonProps,
+      children
+    }
+  );
+});
+var CardName = forwardRef9(function PlanSelectorCardName({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardName");
+  if (!card.plan.name) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx17(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-name": "", ...rest, children: children ?? card.plan.name });
+});
+var CardPrice = forwardRef9(function PlanSelectorCardPrice({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardPrice");
+  const locale = useLocale();
+  const copy = useCopy();
+  const formatted = useMemo11(() => {
+    if (card.isFree) return copy.planSelector.freeBadge;
+    return formatPrice(card.plan.price ?? 0, card.plan.currency ?? "usd", {
+      locale,
+      free: copy.interval.free
+    });
+  }, [
+    card.isFree,
+    card.plan.price,
+    card.plan.currency,
+    locale,
+    copy.planSelector.freeBadge,
+    copy.interval.free
+  ]);
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx17(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-price": "", ...rest, children: children ?? formatted });
+});
+var CardInterval = forwardRef9(function PlanSelectorCardInterval({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardInterval");
+  const copy = useCopy();
+  if (card.isFree || !card.plan.interval) return null;
+  const text = interpolate(copy.planSelector.perIntervalShort, { interval: card.plan.interval });
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx17(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-interval": "", ...rest, children: children ?? text });
+});
+var CardBadge = forwardRef9(function PlanSelectorCardBadge({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardBadge");
+  const copy = useCopy();
+  let variant = null;
+  let label = "";
+  if (card.isCurrent) {
+    variant = "current";
+    label = copy.planSelector.currentBadge;
+  } else if (card.isPopular && !card.isFree) {
+    variant = "popular";
+    label = copy.planSelector.popularBadge;
+  }
+  if (!variant) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx17(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-plan-selector-card-badge": "",
+      "data-variant": variant,
+      ...rest,
+      children: children ?? label
+    }
+  );
+});
+var Loading4 = forwardRef9(function PlanSelectorLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = usePlanSelectorContext("Loading");
+  if (!ctx.loading || ctx.plans.length > 0) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx17(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-loading": "", ...rest, children });
+});
+var ErrorSlot4 = forwardRef9(function PlanSelectorError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = usePlanSelectorContext("Error");
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx17(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-error": "", role: "alert", ...rest, children: children ?? ctx.error.message });
+});
+var PlanSelectorRoot2 = Root6;
+var PlanSelectorHeading2 = Heading;
+var PlanSelectorGrid2 = Grid;
+var PlanSelectorCard2 = Card;
+var PlanSelectorCardName2 = CardName;
+var PlanSelectorCardPrice2 = CardPrice;
+var PlanSelectorCardInterval2 = CardInterval;
+var PlanSelectorCardBadge2 = CardBadge;
+var PlanSelectorLoading2 = Loading4;
+var PlanSelectorError2 = ErrorSlot4;
+var PlanSelector = {
+  Root: Root6,
+  Heading,
+  Grid,
+  Card,
+  CardName,
+  CardPrice,
+  CardInterval,
+  CardBadge,
+  Loading: Loading4,
+  Error: ErrorSlot4
+};
+function usePlanSelector() {
+  return usePlanSelectorContext("usePlanSelector");
+}
+
+// src/primitives/ActivationFlow.tsx
+import {
+  createContext as createContext10,
+  forwardRef as forwardRef10,
+  useCallback as useCallback14,
+  useContext as useContext14,
+  useEffect as useEffect11,
+  useMemo as useMemo12,
+  useRef as useRef7,
+  useState as useState13
+} from "react";
+import { Fragment as Fragment7, jsx as jsx18 } from "react/jsx-runtime";
+var ActivationFlowContext = createContext10(null);
+function useFlowCtx(part) {
+  const ctx = useContext14(ActivationFlowContext);
+  if (!ctx) {
+    throw new Error(`ActivationFlow.${part} must be rendered inside <ActivationFlow.Root>.`);
+  }
+  return ctx;
+}
+var Root7 = forwardRef10(function ActivationFlowRoot({
+  productRef,
+  planRef: planRefProp,
+  onSuccess,
+  onError,
+  retryDelayMs = 1500,
+  retryBackoffMs = 2e3,
+  asChild,
+  children,
+  ...rest
+}, forwardedRef) {
+  const solva = useContext14(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("ActivationFlow");
+  if (!productRef) throw new MissingProductRefError("ActivationFlow");
+  const planSelection = usePlanSelection();
+  const resolvedPlanRef = planRefProp ?? planSelection?.selectedPlanRef ?? void 0;
+  const { plan } = usePlan({ planRef: resolvedPlanRef, productRef });
+  const { activate, state, error, result, reset } = useActivation();
+  const currency = plan?.currency ?? "USD";
+  const amountSelector = useTopupAmountSelector({ currency });
+  const { adjustBalance, creditsPerMinorUnit, displayExchangeRate } = useBalance();
+  const [step, setStep] = useState13("summary");
+  const calledSuccessRef = useRef7(false);
+  const retryTimeoutRef = useRef7(null);
+  useEffect11(() => {
+    if (state === "activated" && !calledSuccessRef.current) {
+      calledSuccessRef.current = true;
+      setStep("activated");
+      if (result) {
+        const activationResult = { kind: "activated", result };
+        onSuccess?.(activationResult);
+      }
+    }
+  }, [state, result, onSuccess]);
+  useEffect11(() => {
+    if (state === "topup_required" && (step === "summary" || step === "activating")) {
+      setStep("selectAmount");
+    }
+  }, [state, step]);
+  useEffect11(() => {
+    if ((state === "error" || state === "payment_required") && error) {
+      setStep("error");
+      if (state === "error") onError?.(new Error(error));
+    }
+  }, [state, error, onError]);
+  const handleActivate = useCallback14(async () => {
+    if (!resolvedPlanRef) return;
+    setStep("activating");
+    await activate({ productRef, planRef: resolvedPlanRef });
+  }, [activate, productRef, resolvedPlanRef]);
+  const goToTopupPayment = useCallback14(() => {
+    if (amountSelector.validate()) setStep("topupPayment");
+  }, [amountSelector]);
+  const backToSelectAmount = useCallback14(() => {
+    setStep("selectAmount");
+  }, []);
+  const retryActivation = useCallback14(async () => {
+    if (!resolvedPlanRef) return;
+    setStep("retrying");
+    const amountMinor = Math.round((amountSelector.resolvedAmount || 0) * 100);
+    const rate = displayExchangeRate ?? 1;
+    if (creditsPerMinorUnit) {
+      adjustBalance(Math.floor(amountMinor / rate * creditsPerMinorUnit));
+    }
+    await new Promise((r) => setTimeout(r, retryDelayMs));
+    await activate({ productRef, planRef: resolvedPlanRef });
+  }, [
+    resolvedPlanRef,
+    amountSelector.resolvedAmount,
+    displayExchangeRate,
+    creditsPerMinorUnit,
+    adjustBalance,
+    retryDelayMs,
+    activate,
+    productRef
+  ]);
+  const handleTopupSuccess = useCallback14(async () => {
+    await retryActivation();
+  }, [retryActivation]);
+  useEffect11(() => {
+    if (step !== "retrying") return;
+    if (state !== "topup_required") return;
+    if (!resolvedPlanRef) return;
+    retryTimeoutRef.current = setTimeout(async () => {
+      await activate({ productRef, planRef: resolvedPlanRef });
+    }, retryBackoffMs);
+    return () => {
+      if (retryTimeoutRef.current) clearTimeout(retryTimeoutRef.current);
+    };
+  }, [step, state, resolvedPlanRef, retryBackoffMs, activate, productRef]);
+  const resetFlow = useCallback14(() => {
+    reset();
+    calledSuccessRef.current = false;
+    setStep("summary");
+  }, [reset]);
+  const amountCents = Math.round((amountSelector.resolvedAmount || 0) * 100);
+  const ctx = useMemo12(
+    () => ({
+      step,
+      plan,
+      productRef,
+      planRef: resolvedPlanRef ?? "",
+      amountSelector,
+      amountCents,
+      currency,
+      activate: handleActivate,
+      reset: resetFlow,
+      goToTopupPayment,
+      backToSelectAmount,
+      onTopupSuccess: handleTopupSuccess,
+      error,
+      onError
+    }),
+    [
+      step,
+      plan,
+      productRef,
+      resolvedPlanRef,
+      amountSelector,
+      amountCents,
+      currency,
+      handleActivate,
+      resetFlow,
+      goToTopupPayment,
+      backToSelectAmount,
+      handleTopupSuccess,
+      error,
+      onError
+    ]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx18(ActivationFlowContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx18(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-activation-flow": "",
+      "data-state": step,
+      ...rest,
+      children
+    }
+  ) });
+});
+function matchStep(step, allowed) {
+  return allowed.includes(step);
+}
+var Summary2 = forwardRef10(function ActivationFlowSummary({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Summary");
+  if (!matchStep(ctx.step, ["summary", "activating"])) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx18(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-summary": "", ...rest, children });
+});
+var ActivateButton = forwardRef10(
+  function ActivationFlowActivateButton({ asChild, onClick, children, ...rest }, forwardedRef) {
+    const ctx = useFlowCtx("ActivateButton");
+    const copy = useCopy();
+    if (!matchStep(ctx.step, ["summary", "activating"])) return null;
+    const isActivating = ctx.step === "activating";
+    const disabled = isActivating;
+    const commonProps = {
+      "data-solvapay-activation-flow-activate": "",
+      "data-state": isActivating ? "activating" : "idle",
+      "aria-busy": isActivating,
+      disabled,
+      onClick: composeEventHandlers(onClick, () => {
+        void ctx.activate();
+      }),
+      ...rest
+    };
+    const label = isActivating ? copy.activationFlow.activatingLabel : copy.activationFlow.activateButton;
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ jsx18(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx18(Fragment7, { children: label }) })
+      );
+    }
+    return /* @__PURE__ */ jsx18("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? label });
+  }
+);
+var AmountPickerMount = ({ children }) => {
+  const ctx = useFlowCtx("AmountPicker");
+  if (ctx.step !== "selectAmount") return null;
+  return /* @__PURE__ */ jsx18("div", { "data-solvapay-activation-flow-amount-picker": "", children: /* @__PURE__ */ jsx18(AmountPicker.Root, { currency: ctx.currency, children }) });
+};
+var ContinueButton = forwardRef10(
+  function ActivationFlowContinueButton({ asChild, onClick, children, ...rest }, forwardedRef) {
+    const ctx = useFlowCtx("ContinueButton");
+    const copy = useCopy();
+    if (ctx.step !== "selectAmount") return null;
+    const disabled = !ctx.amountSelector.resolvedAmount;
+    const commonProps = {
+      "data-solvapay-activation-flow-continue": "",
+      "data-state": disabled ? "disabled" : "idle",
+      disabled,
+      "aria-disabled": disabled || void 0,
+      onClick: composeEventHandlers(onClick, () => {
+        ctx.goToTopupPayment();
+      }),
+      ...rest
+    };
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ jsx18(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx18(Fragment7, { children: copy.activationFlow.continueToPayment }) })
+      );
+    }
+    return /* @__PURE__ */ jsx18("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? copy.activationFlow.continueToPayment });
+  }
+);
+var Retrying = forwardRef10(function ActivationFlowRetrying({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Retrying");
+  if (ctx.step !== "retrying") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx18(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-retrying": "", ...rest, children });
+});
+var Activated = forwardRef10(function ActivationFlowActivated({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Activated");
+  if (ctx.step !== "activated") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx18(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-activated": "", ...rest, children });
+});
+var Loading5 = forwardRef10(function ActivationFlowLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Loading");
+  if (ctx.plan) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx18(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-loading": "", ...rest, children });
+});
+var ErrorSlot5 = forwardRef10(function ActivationFlowError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Error");
+  if (ctx.step !== "error") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx18(
+    Comp,
+    {
+      ref: forwardedRef,
+      role: "alert",
+      "data-solvapay-activation-flow-error": "",
+      ...rest,
+      children: children ?? ctx.error
+    }
+  );
+});
+var ActivationFlowRoot2 = Root7;
+var ActivationFlowSummary2 = Summary2;
+var ActivationFlowActivateButton2 = ActivateButton;
+var ActivationFlowAmountPicker = AmountPickerMount;
+var ActivationFlowContinueButton2 = ContinueButton;
+var ActivationFlowRetrying2 = Retrying;
+var ActivationFlowActivated2 = Activated;
+var ActivationFlowLoading2 = Loading5;
+var ActivationFlowError2 = ErrorSlot5;
+var ActivationFlow = {
+  Root: Root7,
+  Summary: Summary2,
+  ActivateButton,
+  AmountPicker: AmountPickerMount,
+  ContinueButton,
+  Retrying,
+  Activated,
+  Loading: Loading5,
+  Error: ErrorSlot5
+};
+function useActivationFlow() {
+  return useFlowCtx("useActivationFlow");
+}
+
+// src/hooks/usePurchaseActions.ts
+import { useState as useState14, useCallback as useCallback15 } from "react";
+function usePurchaseActions() {
+  const ctx = useSolvaPay();
+  const [isCancelling, setIsCancelling] = useState14(false);
+  const [isReactivating, setIsReactivating] = useState14(false);
+  const [isActivating, setIsActivating] = useState14(false);
+  const cancelRenewal = useCallback15(
+    async (params) => {
+      setIsCancelling(true);
+      try {
+        return await ctx.cancelRenewal(params);
+      } finally {
+        setIsCancelling(false);
+      }
+    },
+    [ctx.cancelRenewal]
+  );
+  const reactivateRenewal = useCallback15(
+    async (params) => {
+      setIsReactivating(true);
+      try {
+        return await ctx.reactivateRenewal(params);
+      } finally {
+        setIsReactivating(false);
+      }
+    },
+    [ctx.reactivateRenewal]
+  );
+  const activatePlan = useCallback15(
+    async (params) => {
+      setIsActivating(true);
+      try {
+        return await ctx.activatePlan(params);
+      } finally {
+        setIsActivating(false);
+      }
+    },
+    [ctx.activatePlan]
+  );
+  return {
+    cancelRenewal,
+    reactivateRenewal,
+    activatePlan,
+    isCancelling,
+    isReactivating,
+    isActivating
+  };
+}
+
+// src/primitives/CancelPlanButton.tsx
+import { forwardRef as forwardRef11, useCallback as useCallback16, useContext as useContext15 } from "react";
+import { Fragment as Fragment8, jsx as jsx19 } from "react/jsx-runtime";
+function resolveConfirmText(confirm, purchase, defaults) {
+  if (confirm === false) return null;
+  if (typeof confirm === "string") return confirm;
+  const planType = purchase?.planSnapshot?.planType;
+  if (planType === "usage-based") return defaults.usageBased;
+  return defaults.recurring;
+}
+var CancelPlanButton = forwardRef11(
+  function CancelPlanButton2({
+    asChild,
+    purchaseRef,
+    reason,
+    confirm = true,
+    onCancelled,
+    onError,
+    onClick,
+    children,
+    ...rest
+  }, forwardedRef) {
+    const solva = useContext15(SolvaPayContext);
+    if (!solva) throw new MissingProviderError("CancelPlanButton");
+    const copy = useCopy();
+    const { activePurchase } = usePurchase();
+    const { cancelRenewal, isCancelling } = usePurchaseActions();
+    const effectivePurchase = purchaseRef ? activePurchase && activePurchase.reference === purchaseRef ? activePurchase : { reference: purchaseRef } : activePurchase;
+    const effectiveRef = purchaseRef ?? effectivePurchase?.reference;
+    const cancel = useCallback16(async () => {
+      if (!effectiveRef) return;
+      const confirmText = resolveConfirmText(confirm, effectivePurchase, {
+        recurring: copy.cancelPlan.confirmRecurring,
+        usageBased: copy.cancelPlan.confirmUsageBased
+      });
+      if (confirmText && typeof window !== "undefined" && !window.confirm(confirmText)) {
+        return;
+      }
+      try {
+        await cancelRenewal({ purchaseRef: effectiveRef, reason });
+        onCancelled?.();
+      } catch (err) {
+        onError?.(err instanceof Error ? err : new Error(String(err)));
+      }
+    }, [effectiveRef, effectivePurchase, confirm, copy, cancelRenewal, reason, onCancelled, onError]);
+    const disabled = isCancelling || !effectiveRef;
+    const state = isCancelling ? "cancelling" : "idle";
+    const commonProps = {
+      "data-solvapay-cancel-plan": "",
+      "data-state": state,
+      "aria-busy": isCancelling,
+      "aria-disabled": disabled || void 0,
+      disabled,
+      onClick: composeEventHandlers(onClick, () => {
+        void cancel();
+      }),
+      ...rest
+    };
+    const label = isCancelling ? copy.cancelPlan.buttonLoading : copy.cancelPlan.button;
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ jsx19(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx19(Fragment8, { children: label }) })
+      );
+    }
+    return /* @__PURE__ */ jsx19("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? label });
+  }
+);
+
+// src/hooks/usePurchaseStatus.ts
+import { useMemo as useMemo13, useCallback as useCallback17 } from "react";
+function usePurchaseStatus() {
+  const { purchases } = usePurchase();
+  const locale = useLocale();
+  const isPaidPurchase2 = useCallback17((p) => {
+    return (p.amount ?? 0) > 0;
+  }, []);
+  const purchaseData = useMemo13(() => {
+    const cancelledPaidPurchases = purchases.filter((p) => {
+      return p.status === "active" && p.cancelledAt && isPaidPurchase2(p);
+    });
+    const cancelledPurchase = cancelledPaidPurchases.sort(
+      (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
+    )[0] || null;
+    const shouldShowCancelledNotice = !!cancelledPurchase;
+    return {
+      cancelledPurchase,
+      shouldShowCancelledNotice
+    };
+  }, [purchases, isPaidPurchase2]);
+  const formatDate = useCallback17(
+    (dateString) => {
+      if (!dateString) return null;
+      return new Date(dateString).toLocaleDateString(locale || "en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+    },
+    [locale]
+  );
+  const getDaysUntilExpiration = useCallback17((endDate) => {
+    if (!endDate) return null;
+    const now = /* @__PURE__ */ new Date();
+    const expiration = new Date(endDate);
+    const diffTime = expiration.getTime() - now.getTime();
+    const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+    return diffDays > 0 ? diffDays : 0;
+  }, []);
+  return {
+    cancelledPurchase: purchaseData.cancelledPurchase,
+    shouldShowCancelledNotice: purchaseData.shouldShowCancelledNotice,
+    formatDate,
+    getDaysUntilExpiration
+  };
+}
+
+// src/primitives/CancelledPlanNotice.tsx
+import {
+  createContext as createContext11,
+  forwardRef as forwardRef12,
+  useCallback as useCallback18,
+  useContext as useContext16,
+  useMemo as useMemo14
+} from "react";
+import { Fragment as Fragment9, jsx as jsx20 } from "react/jsx-runtime";
+var CancelledPlanNoticeContext = createContext11(null);
+function useNoticeCtx(part) {
+  const ctx = useContext16(CancelledPlanNoticeContext);
+  if (!ctx) {
+    throw new Error(
+      `CancelledPlanNotice.${part} must be rendered inside <CancelledPlanNotice.Root>.`
+    );
+  }
+  return ctx;
+}
+var Root8 = forwardRef12(function CancelledPlanNoticeRoot({ onReactivated, onError, asChild, children, ...rest }, forwardedRef) {
+  const solva = useContext16(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("CancelledPlanNotice");
+  const {
+    cancelledPurchase,
+    shouldShowCancelledNotice,
+    formatDate,
+    getDaysUntilExpiration
+  } = usePurchaseStatus();
+  const { reactivateRenewal, isReactivating } = usePurchaseActions();
+  const reactivate = useCallback18(async () => {
+    if (!cancelledPurchase) return;
+    try {
+      await reactivateRenewal({ purchaseRef: cancelledPurchase.reference });
+      onReactivated?.();
+    } catch (err) {
+      onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [cancelledPurchase, reactivateRenewal, onReactivated, onError]);
+  const daysRemaining = useMemo14(
+    () => cancelledPurchase ? getDaysUntilExpiration(cancelledPurchase.endDate) : null,
+    [cancelledPurchase, getDaysUntilExpiration]
+  );
+  const ctx = useMemo14(() => {
+    if (!cancelledPurchase) return null;
+    const state = daysRemaining != null && daysRemaining > 0 ? "active" : "expired";
+    return {
+      purchase: cancelledPurchase,
+      state,
+      daysRemaining,
+      hasReason: !!cancelledPurchase.cancellationReason,
+      formatDate,
+      reactivate,
+      isReactivating
+    };
+  }, [cancelledPurchase, daysRemaining, formatDate, reactivate, isReactivating]);
+  if (!shouldShowCancelledNotice || !ctx) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx20(CancelledPlanNoticeContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx20(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-cancelled-notice": "",
+      "data-state": ctx.state,
+      "data-has-reason": ctx.hasReason ? "" : void 0,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Heading2 = forwardRef12(function CancelledPlanNoticeHeading({ asChild, children, ...rest }, forwardedRef) {
+  useNoticeCtx("Heading");
+  const copy = useCopy();
+  const Comp = asChild ? Slot : "p";
+  return /* @__PURE__ */ jsx20(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-heading": "", ...rest, children: children ?? copy.cancelledNotice.heading });
+});
+var Expires = forwardRef12(function CancelledPlanNoticeExpires({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useNoticeCtx("Expires");
+  const copy = useCopy();
+  const date = ctx.formatDate(ctx.purchase.endDate);
+  if (!ctx.purchase.endDate) {
+    const Comp2 = asChild ? Slot : "p";
+    return /* @__PURE__ */ jsx20(Comp2, { ref: forwardedRef, "data-solvapay-cancelled-notice-expires": "", ...rest, children: children ?? copy.cancelledNotice.accessEnded });
+  }
+  const Comp = asChild ? Slot : "p";
+  return /* @__PURE__ */ jsx20(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-expires": "", ...rest, children: children ?? interpolate(copy.cancelledNotice.expiresLabel, { date: date ?? "" }) });
+});
+var DaysRemaining = forwardRef12(
+  function CancelledPlanNoticeDaysRemaining({ asChild, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("DaysRemaining");
+    const copy = useCopy();
+    if (ctx.daysRemaining == null || ctx.daysRemaining <= 0) return null;
+    const template = ctx.daysRemaining === 1 ? copy.cancelledNotice.dayRemaining : copy.cancelledNotice.daysRemaining;
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ jsx20(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-days-remaining": "", ...rest, children: children ?? interpolate(template, { days: ctx.daysRemaining }) });
+  }
+);
+var AccessUntil = forwardRef12(
+  function CancelledPlanNoticeAccessUntil({ asChild, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("AccessUntil");
+    const copy = useCopy();
+    if (!ctx.purchase.endDate) return null;
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ jsx20(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-access-until": "", ...rest, children: children ?? interpolate(copy.cancelledNotice.accessUntil, {
+      product: ctx.purchase.productName
+    }) });
+  }
+);
+var CancelledOn = forwardRef12(
+  function CancelledPlanNoticeCancelledOn({ asChild, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("CancelledOn");
+    const copy = useCopy();
+    if (!ctx.purchase.cancelledAt) return null;
+    const date = ctx.formatDate(ctx.purchase.cancelledAt);
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ jsx20(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-cancelled-on": "", ...rest, children: children ?? interpolate(copy.cancelledNotice.cancelledOn, { date: date ?? "" }) });
+  }
+);
+var Reason = forwardRef12(function CancelledPlanNoticeReason({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useNoticeCtx("Reason");
+  if (!ctx.hasReason) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx20(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-reason": "", ...rest, children: children ?? ctx.purchase.cancellationReason });
+});
+var ReactivateButton = forwardRef12(
+  function CancelledPlanNoticeReactivateButton({ asChild, onClick, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("ReactivateButton");
+    const copy = useCopy();
+    const disabled = ctx.isReactivating;
+    const commonProps = {
+      "data-solvapay-cancelled-notice-reactivate": "",
+      "data-state": ctx.isReactivating ? "reactivating" : "idle",
+      "aria-busy": ctx.isReactivating,
+      "aria-disabled": disabled || void 0,
+      disabled,
+      onClick: composeEventHandlers(onClick, () => {
+        void ctx.reactivate();
+      }),
+      ...rest
+    };
+    const label = ctx.isReactivating ? copy.cancelledNotice.reactivateButtonLoading : copy.cancelledNotice.reactivateButton;
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ jsx20(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx20(Fragment9, { children: label }) })
+      );
+    }
+    return /* @__PURE__ */ jsx20("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? label });
+  }
+);
+var CancelledPlanNoticeRoot2 = Root8;
+var CancelledPlanNoticeHeading2 = Heading2;
+var CancelledPlanNoticeExpires2 = Expires;
+var CancelledPlanNoticeDaysRemaining2 = DaysRemaining;
+var CancelledPlanNoticeAccessUntil2 = AccessUntil;
+var CancelledPlanNoticeCancelledOn2 = CancelledOn;
+var CancelledPlanNoticeReason2 = Reason;
+var CancelledPlanNoticeReactivateButton2 = ReactivateButton;
+var CancelledPlanNotice = {
+  Root: Root8,
+  Heading: Heading2,
+  Expires,
+  DaysRemaining,
+  AccessUntil,
+  CancelledOn,
+  Reason,
+  ReactivateButton
+};
+function useCancelledPlanNotice() {
+  return useNoticeCtx("useCancelledPlanNotice");
+}
+
+// src/primitives/CreditGate.tsx
+import {
+  createContext as createContext12,
+  forwardRef as forwardRef13,
+  useContext as useContext17,
+  useMemo as useMemo15
+} from "react";
+import { jsx as jsx21 } from "react/jsx-runtime";
+var CreditGateContext = createContext12(null);
+function useGateCtx2(part) {
+  const ctx = useContext17(CreditGateContext);
+  if (!ctx) {
+    throw new Error(`CreditGate.${part} must be rendered inside <CreditGate.Root>.`);
+  }
+  return ctx;
+}
+var Root9 = forwardRef13(function CreditGateRoot({
+  minCredits = 1,
+  productRef,
+  topupAmount = 1e3,
+  topupCurrency = "usd",
+  asChild,
+  children,
+  ...rest
+}, forwardedRef) {
+  const solva = useContext17(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("CreditGate");
+  const { credits, loading } = useBalance();
+  const { product } = useProduct(productRef);
+  const hasCredits = credits != null && credits >= minCredits;
+  const state = loading && credits == null ? "loading" : hasCredits ? "allowed" : "blocked";
+  const ctx = useMemo15(
+    () => ({
+      state,
+      loading,
+      hasCredits,
+      balance: credits,
+      productName: product?.name ?? null,
+      topupAmount,
+      topupCurrency
+    }),
+    [state, loading, hasCredits, credits, product?.name, topupAmount, topupCurrency]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx21(CreditGateContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx21(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-credit-gate": "",
+      "data-state": state,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Heading3 = forwardRef13(function CreditGateHeading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx2("Heading");
+  const copy = useCopy();
+  if (ctx.state !== "blocked") return null;
+  const Comp = asChild ? Slot : "h3";
+  return /* @__PURE__ */ jsx21(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-heading": "", ...rest, children: children ?? copy.creditGate.lowBalanceHeading });
+});
+var Subheading = forwardRef13(function CreditGateSubheading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx2("Subheading");
+  const copy = useCopy();
+  if (ctx.state !== "blocked") return null;
+  const text = interpolate(copy.creditGate.lowBalanceSubheading, {
+    product: ctx.productName ?? "this product"
+  });
+  const Comp = asChild ? Slot : "p";
+  return /* @__PURE__ */ jsx21(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-subheading": "", ...rest, children: children ?? text });
+});
+var Topup = ({ amount, currency }) => {
+  const ctx = useGateCtx2("Topup");
+  if (ctx.state !== "blocked") return null;
+  return /* @__PURE__ */ jsx21(
+    TopupForm2,
+    {
+      amount: amount ?? ctx.topupAmount,
+      currency: currency ?? ctx.topupCurrency
+    }
+  );
+};
+var Loading6 = forwardRef13(function CreditGateLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx2("Loading");
+  if (ctx.state !== "loading") return null;
+  const Comp = asChild ? Slot : "div";
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    /* @__PURE__ */ jsx21(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-loading": "", ...rest, children })
+  );
+});
+var ErrorSlot6 = forwardRef13(function CreditGateError({ asChild, children, ...rest }, forwardedRef) {
+  if (!children) return null;
+  const Comp = asChild ? Slot : "div";
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    /* @__PURE__ */ jsx21(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-error": "", role: "alert", ...rest, children })
+  );
+});
+var CreditGateRoot2 = Root9;
+var CreditGateHeading2 = Heading3;
+var CreditGateSubheading2 = Subheading;
+var CreditGateTopup = Topup;
+var CreditGateLoading2 = Loading6;
+var CreditGateError2 = ErrorSlot6;
+var CreditGate = {
+  Root: Root9,
+  Heading: Heading3,
+  Subheading,
+  Topup,
+  Loading: Loading6,
+  Error: ErrorSlot6
+};
+function useCreditGate() {
+  return useGateCtx2("useCreditGate");
+}
+
+export {
+  filterPurchases,
+  getActivePurchases,
+  getCancelledPurchasesWithEndDate,
+  getMostRecentPurchase,
+  getPrimaryPurchase,
+  isPaidPurchase,
+  buildRequestHeaders,
+  enCopy,
+  mergeCopy,
+  CopyContext,
+  CopyProvider,
+  SolvaPayContext,
+  SolvaPayProvider,
+  setRef,
+  composeRefs,
+  Slot,
+  Slottable,
+  composeEventHandlers,
+  useSolvaPay,
+  useCheckout,
+  usePurchase,
+  useCustomer,
+  useCopy,
+  useLocale,
+  usePlans,
+  usePlan,
+  useProduct,
+  useActivation,
+  PaymentFormContext,
+  usePaymentForm,
+  PaymentFormProvider,
+  formatPrice,
+  interpolate,
+  CheckoutSummaryRoot2 as CheckoutSummaryRoot,
+  CheckoutSummaryProduct2 as CheckoutSummaryProduct,
+  CheckoutSummaryPlan2 as CheckoutSummaryPlan,
+  CheckoutSummaryPrice2 as CheckoutSummaryPrice,
+  CheckoutSummaryTrial2 as CheckoutSummaryTrial,
+  CheckoutSummaryTaxNote2 as CheckoutSummaryTaxNote,
+  CheckoutSummary,
+  useCheckoutSummary,
+  CheckoutSummary2,
+  useMerchant,
+  deriveVariant,
+  MandateText,
+  Spinner,
+  confirmPayment,
+  resolveCta,
+  PaymentFormRoot2 as PaymentFormRoot,
+  PaymentFormSummary,
+  PaymentFormCustomerFields2 as PaymentFormCustomerFields,
+  PaymentFormPaymentElement,
+  PaymentFormCardElement,
+  PaymentFormMandateText,
+  PaymentFormTermsCheckbox2 as PaymentFormTermsCheckbox,
+  PaymentFormSubmitButton2 as PaymentFormSubmitButton,
+  PaymentFormLoading2 as PaymentFormLoading,
+  PaymentFormError2 as PaymentFormError,
+  PaymentForm,
+  useTopupAmountSelector,
+  useBalance,
+  AmountPickerRoot2 as AmountPickerRoot,
+  AmountPickerOption2 as AmountPickerOption,
+  AmountPickerCustom2 as AmountPickerCustom,
+  AmountPickerConfirm2 as AmountPickerConfirm,
+  AmountPicker,
+  useAmountPicker,
+  useAmountPickerCopy,
+  useTopup,
+  TopupFormRoot2 as TopupFormRoot,
+  TopupFormPaymentElement,
+  TopupFormSubmitButton2 as TopupFormSubmitButton,
+  TopupFormLoading2 as TopupFormLoading,
+  TopupFormError2 as TopupFormError,
+  TopupForm,
+  useTopupForm,
+  TopupForm2,
+  ProductBadge2 as ProductBadge,
+  PlanBadge,
+  PurchaseGateRoot2 as PurchaseGateRoot,
+  PurchaseGateAllowed2 as PurchaseGateAllowed,
+  PurchaseGateBlocked2 as PurchaseGateBlocked,
+  PurchaseGateLoading2 as PurchaseGateLoading,
+  PurchaseGateError2 as PurchaseGateError,
+  PurchaseGate,
+  usePurchaseGate,
+  BalanceBadge,
+  PlanSelectorRoot2 as PlanSelectorRoot,
+  PlanSelectorHeading2 as PlanSelectorHeading,
+  PlanSelectorGrid2 as PlanSelectorGrid,
+  PlanSelectorCard2 as PlanSelectorCard,
+  PlanSelectorCardName2 as PlanSelectorCardName,
+  PlanSelectorCardPrice2 as PlanSelectorCardPrice,
+  PlanSelectorCardInterval2 as PlanSelectorCardInterval,
+  PlanSelectorCardBadge2 as PlanSelectorCardBadge,
+  PlanSelectorLoading2 as PlanSelectorLoading,
+  PlanSelectorError2 as PlanSelectorError,
+  PlanSelector,
+  usePlanSelector,
+  ActivationFlowRoot2 as ActivationFlowRoot,
+  ActivationFlowSummary2 as ActivationFlowSummary,
+  ActivationFlowActivateButton2 as ActivationFlowActivateButton,
+  ActivationFlowAmountPicker,
+  ActivationFlowContinueButton2 as ActivationFlowContinueButton,
+  ActivationFlowRetrying2 as ActivationFlowRetrying,
+  ActivationFlowActivated2 as ActivationFlowActivated,
+  ActivationFlowLoading2 as ActivationFlowLoading,
+  ActivationFlowError2 as ActivationFlowError,
+  ActivationFlow,
+  useActivationFlow,
+  usePurchaseActions,
+  CancelPlanButton,
+  usePurchaseStatus,
+  CancelledPlanNoticeRoot2 as CancelledPlanNoticeRoot,
+  CancelledPlanNoticeHeading2 as CancelledPlanNoticeHeading,
+  CancelledPlanNoticeExpires2 as CancelledPlanNoticeExpires,
+  CancelledPlanNoticeDaysRemaining2 as CancelledPlanNoticeDaysRemaining,
+  CancelledPlanNoticeAccessUntil2 as CancelledPlanNoticeAccessUntil,
+  CancelledPlanNoticeCancelledOn2 as CancelledPlanNoticeCancelledOn,
+  CancelledPlanNoticeReason2 as CancelledPlanNoticeReason,
+  CancelledPlanNoticeReactivateButton2 as CancelledPlanNoticeReactivateButton,
+  CancelledPlanNotice,
+  useCancelledPlanNotice,
+  CreditGateRoot2 as CreditGateRoot,
+  CreditGateHeading2 as CreditGateHeading,
+  CreditGateSubheading2 as CreditGateSubheading,
+  CreditGateTopup,
+  CreditGateLoading2 as CreditGateLoading,
+  CreditGateError2 as CreditGateError,
+  CreditGate,
+  useCreditGate
+};