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

package/dist/chunk-TP4JPKE2.js

@@ -0,0 +1,3126 @@
+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/components/MandateText.tsx
+import { useMemo as useMemo5 } from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var MandateText = ({
+  planRef,
+  productRef,
+  variant,
+  mode,
+  amountMinor,
+  currency,
+  className
+}) => {
+  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;
+  return /* @__PURE__ */ jsx8(
+    "p",
+    {
+      className,
+      "data-solvapay-mandate-text": "",
+      style: {
+        fontSize: 12,
+        lineHeight: 1.5,
+        color: "rgba(0,0,0,0.6)",
+        margin: 0
+      },
+      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 forwardRef2,
+  useCallback as useCallback8,
+  useContext as useContext6,
+  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 = forwardRef2(function PaymentFormRoot(props, forwardedRef) {
+  const {
+    planRef,
+    productRef,
+    onSuccess,
+    onResult,
+    onFreePlan,
+    onError,
+    returnUrl,
+    submitButtonText,
+    className,
+    buttonClassName,
+    prefillCustomer,
+    requireTermsAcceptance = false,
+    children
+  } = props;
+  const solva = useContext6(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 = forwardRef2(
+  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 = forwardRef2(
+  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 = forwardRef2(
+  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 = forwardRef2(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 = forwardRef2(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/primitives/PlanSelector.tsx
+import {
+  createContext as createContext6,
+  forwardRef as forwardRef3,
+  useCallback as useCallback9,
+  useContext as useContext7,
+  useMemo as useMemo7
+} from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var PlanSelectorContext = createContext6(null);
+function usePlanSelectorContext(part) {
+  const ctx = useContext7(PlanSelectorContext);
+  if (!ctx) {
+    throw new Error(`PlanSelector.${part} must be rendered inside <PlanSelector.Root>.`);
+  }
+  return ctx;
+}
+var CardContext = createContext6(null);
+function useCardContext(part) {
+  const ctx = useContext7(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 Root3 = forwardRef3(function PlanSelectorRoot(props, forwardedRef) {
+  const {
+    productRef,
+    fetcher,
+    filter,
+    sortBy,
+    autoSelectFirstPaid = true,
+    initialPlanRef,
+    currentPlanRef,
+    popularPlanRef,
+    onSelect,
+    children,
+    ...rest
+  } = props;
+  const solva = useContext7(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("PlanSelector");
+  if (!productRef) throw new MissingProductRefError("PlanSelector");
+  const { _config } = solva;
+  const { purchases } = usePurchase();
+  const effectiveFetcher = useMemo7(
+    () => fetcher ?? ((ref) => defaultListPlans(ref, _config)),
+    [fetcher, _config]
+  );
+  const { plans, selectedPlan, selectPlan, loading, error } = usePlans({
+    productRef,
+    fetcher: effectiveFetcher,
+    filter,
+    sortBy,
+    autoSelectFirstPaid,
+    initialPlanRef
+  });
+  const autoCurrentPlanRef = useMemo7(() => {
+    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 = useCallback9(
+    (ref) => resolvedCurrentPlanRef === ref,
+    [resolvedCurrentPlanRef]
+  );
+  const isFree = useCallback9(
+    (ref) => plans.find((p) => p.reference === ref)?.requiresPayment === false,
+    [plans]
+  );
+  const isPopular = useCallback9(
+    (ref) => popularPlanRef === ref,
+    [popularPlanRef]
+  );
+  const select = useCallback9(
+    (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 = useMemo7(
+    () => ({
+      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__ */ jsx11(
+    PlanSelectionProvider,
+    {
+      value: {
+        productRef,
+        selectedPlanRef,
+        setSelectedPlanRef: (ref) => {
+          if (ref) select(ref);
+        },
+        plans,
+        loading,
+        error
+      },
+      children: /* @__PURE__ */ jsx11("div", { ref: forwardedRef, "data-solvapay-plan-selector": "", ...rest, children: /* @__PURE__ */ jsx11(PlanSelectorContext.Provider, { value: ctx, children }) })
+    }
+  );
+});
+var Heading = forwardRef3(function PlanSelectorHeading({ asChild, children, ...rest }, forwardedRef) {
+  usePlanSelectorContext("Heading");
+  const copy = useCopy();
+  const Comp = asChild ? Slot : "h3";
+  return /* @__PURE__ */ jsx11(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-heading": "", ...rest, children: children ?? copy.planSelector.heading });
+});
+var Grid = forwardRef3(function PlanSelectorGrid({ children, ...rest }, forwardedRef) {
+  const ctx = usePlanSelectorContext("Grid");
+  return /* @__PURE__ */ jsx11("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__ */ jsx11(CardContext.Provider, { value: cardCtx, children }, plan.reference);
+  }) });
+});
+var Card = forwardRef3(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__ */ jsx11(Slot, { ref: forwardedRef, ...commonProps, children })
+    );
+  }
+  return /* @__PURE__ */ jsx11(
+    "button",
+    {
+      ref: forwardedRef,
+      type: "button",
+      disabled: card.disabled,
+      ...commonProps,
+      children
+    }
+  );
+});
+var CardName = forwardRef3(function PlanSelectorCardName({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardName");
+  if (!card.plan.name) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx11(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-name": "", ...rest, children: children ?? card.plan.name });
+});
+var CardPrice = forwardRef3(function PlanSelectorCardPrice({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardPrice");
+  const locale = useLocale();
+  const copy = useCopy();
+  const formatted = useMemo7(() => {
+    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__ */ jsx11(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-price": "", ...rest, children: children ?? formatted });
+});
+var CardInterval = forwardRef3(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__ */ jsx11(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-interval": "", ...rest, children: children ?? text });
+});
+var CardBadge = forwardRef3(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__ */ jsx11(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-plan-selector-card-badge": "",
+      "data-variant": variant,
+      ...rest,
+      children: children ?? label
+    }
+  );
+});
+var Loading2 = forwardRef3(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__ */ jsx11(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-loading": "", ...rest, children });
+});
+var ErrorSlot2 = forwardRef3(function PlanSelectorError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = usePlanSelectorContext("Error");
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx11(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-error": "", role: "alert", ...rest, children: children ?? ctx.error.message });
+});
+var PlanSelectorRoot2 = Root3;
+var PlanSelectorHeading2 = Heading;
+var PlanSelectorGrid2 = Grid;
+var PlanSelectorCard2 = Card;
+var PlanSelectorCardName2 = CardName;
+var PlanSelectorCardPrice2 = CardPrice;
+var PlanSelectorCardInterval2 = CardInterval;
+var PlanSelectorCardBadge2 = CardBadge;
+var PlanSelectorLoading2 = Loading2;
+var PlanSelectorError2 = ErrorSlot2;
+var PlanSelector = {
+  Root: Root3,
+  Heading,
+  Grid,
+  Card,
+  CardName,
+  CardPrice,
+  CardInterval,
+  CardBadge,
+  Loading: Loading2,
+  Error: ErrorSlot2
+};
+function usePlanSelector() {
+  return usePlanSelectorContext("usePlanSelector");
+}
+
+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,
+  usePlanSelection,
+  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,
+  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
+};