@solvapay/react 1.0.7 → 1.0.8-preview.10

package/dist/primitives/index.cjs

@@ -0,0 +1,4254 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/primitives/index.ts
+var primitives_exports = {};
+__export(primitives_exports, {
+  ActivationFlow: () => ActivationFlow,
+  ActivationFlowActivateButton: () => ActivationFlowActivateButton2,
+  ActivationFlowActivated: () => ActivationFlowActivated2,
+  ActivationFlowAmountPicker: () => ActivationFlowAmountPicker,
+  ActivationFlowContinueButton: () => ActivationFlowContinueButton2,
+  ActivationFlowError: () => ActivationFlowError2,
+  ActivationFlowLoading: () => ActivationFlowLoading2,
+  ActivationFlowRetrying: () => ActivationFlowRetrying2,
+  ActivationFlowRoot: () => ActivationFlowRoot2,
+  ActivationFlowSummary: () => ActivationFlowSummary2,
+  AmountPicker: () => AmountPicker,
+  AmountPickerConfirm: () => AmountPickerConfirm2,
+  AmountPickerCustom: () => AmountPickerCustom2,
+  AmountPickerOption: () => AmountPickerOption2,
+  AmountPickerRoot: () => AmountPickerRoot2,
+  BalanceBadge: () => BalanceBadge,
+  CancelPlanButton: () => CancelPlanButton,
+  CancelledPlanNotice: () => CancelledPlanNotice,
+  CancelledPlanNoticeAccessUntil: () => CancelledPlanNoticeAccessUntil2,
+  CancelledPlanNoticeCancelledOn: () => CancelledPlanNoticeCancelledOn2,
+  CancelledPlanNoticeDaysRemaining: () => CancelledPlanNoticeDaysRemaining2,
+  CancelledPlanNoticeExpires: () => CancelledPlanNoticeExpires2,
+  CancelledPlanNoticeHeading: () => CancelledPlanNoticeHeading2,
+  CancelledPlanNoticeReactivateButton: () => CancelledPlanNoticeReactivateButton2,
+  CancelledPlanNoticeReason: () => CancelledPlanNoticeReason2,
+  CancelledPlanNoticeRoot: () => CancelledPlanNoticeRoot2,
+  CheckoutSummary: () => CheckoutSummary,
+  CheckoutSummaryPlan: () => CheckoutSummaryPlan2,
+  CheckoutSummaryPrice: () => CheckoutSummaryPrice2,
+  CheckoutSummaryProduct: () => CheckoutSummaryProduct2,
+  CheckoutSummaryRoot: () => CheckoutSummaryRoot2,
+  CheckoutSummaryTaxNote: () => CheckoutSummaryTaxNote2,
+  CheckoutSummaryTrial: () => CheckoutSummaryTrial2,
+  CreditGate: () => CreditGate,
+  CreditGateError: () => CreditGateError2,
+  CreditGateHeading: () => CreditGateHeading2,
+  CreditGateLoading: () => CreditGateLoading2,
+  CreditGateRoot: () => CreditGateRoot2,
+  CreditGateSubheading: () => CreditGateSubheading2,
+  CreditGateTopup: () => CreditGateTopup,
+  MandateText: () => MandateText,
+  PaymentForm: () => PaymentForm,
+  PaymentFormCardElement: () => PaymentFormCardElement,
+  PaymentFormCustomerFields: () => PaymentFormCustomerFields2,
+  PaymentFormError: () => PaymentFormError2,
+  PaymentFormLoading: () => PaymentFormLoading2,
+  PaymentFormMandateText: () => PaymentFormMandateText,
+  PaymentFormPaymentElement: () => PaymentFormPaymentElement,
+  PaymentFormRoot: () => PaymentFormRoot2,
+  PaymentFormSubmitButton: () => PaymentFormSubmitButton2,
+  PaymentFormSummary: () => PaymentFormSummary,
+  PaymentFormTermsCheckbox: () => PaymentFormTermsCheckbox2,
+  PlanBadge: () => PlanBadge,
+  PlanSelector: () => PlanSelector,
+  PlanSelectorCard: () => PlanSelectorCard2,
+  PlanSelectorCardBadge: () => PlanSelectorCardBadge2,
+  PlanSelectorCardInterval: () => PlanSelectorCardInterval2,
+  PlanSelectorCardName: () => PlanSelectorCardName2,
+  PlanSelectorCardPrice: () => PlanSelectorCardPrice2,
+  PlanSelectorError: () => PlanSelectorError2,
+  PlanSelectorGrid: () => PlanSelectorGrid2,
+  PlanSelectorHeading: () => PlanSelectorHeading2,
+  PlanSelectorLoading: () => PlanSelectorLoading2,
+  PlanSelectorRoot: () => PlanSelectorRoot2,
+  ProductBadge: () => ProductBadge2,
+  PurchaseGate: () => PurchaseGate,
+  PurchaseGateAllowed: () => PurchaseGateAllowed2,
+  PurchaseGateBlocked: () => PurchaseGateBlocked2,
+  PurchaseGateError: () => PurchaseGateError2,
+  PurchaseGateLoading: () => PurchaseGateLoading2,
+  PurchaseGateRoot: () => PurchaseGateRoot2,
+  Slot: () => Slot,
+  Slottable: () => Slottable,
+  TopupForm: () => TopupForm,
+  TopupFormError: () => TopupFormError2,
+  TopupFormLoading: () => TopupFormLoading2,
+  TopupFormPaymentElement: () => TopupFormPaymentElement,
+  TopupFormRoot: () => TopupFormRoot2,
+  TopupFormSubmitButton: () => TopupFormSubmitButton2,
+  composeEventHandlers: () => composeEventHandlers,
+  composeRefs: () => composeRefs,
+  setRef: () => setRef,
+  useActivationFlow: () => useActivationFlow,
+  useAmountPicker: () => useAmountPicker,
+  useAmountPickerCopy: () => useAmountPickerCopy,
+  useCancelledPlanNotice: () => useCancelledPlanNotice,
+  useCheckoutSummary: () => useCheckoutSummary,
+  useCreditGate: () => useCreditGate,
+  usePlanSelector: () => usePlanSelector,
+  usePurchaseGate: () => usePurchaseGate,
+  useTopupForm: () => useTopupForm
+});
+module.exports = __toCommonJS(primitives_exports);
+
+// src/primitives/slot.tsx
+var import_react = __toESM(require("react"), 1);
+
+// 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
+var import_jsx_runtime = require("react/jsx-runtime");
+var Slot = import_react.default.forwardRef((props, forwardedRef) => {
+  const { children, ...slotProps } = props;
+  const childrenArray = import_react.default.Children.toArray(children);
+  const slottable = childrenArray.find(isSlottable);
+  if (slottable) {
+    const newElement = slottable.props.children;
+    const newChildren = childrenArray.map((child) => {
+      if (child === slottable) {
+        if (import_react.default.Children.count(newElement) > 1) return import_react.default.Children.only(null);
+        return import_react.default.isValidElement(newElement) ? newElement.props.children : null;
+      }
+      return child;
+    });
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SlotClone, { ...slotProps, ref: forwardedRef, children: import_react.default.isValidElement(newElement) ? import_react.default.cloneElement(newElement, void 0, newChildren) : null });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SlotClone, { ...slotProps, ref: forwardedRef, children });
+});
+Slot.displayName = "Slot";
+var SlotClone = import_react.default.forwardRef(
+  (props, forwardedRef) => {
+    const { children, ...slotProps } = props;
+    if (import_react.default.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 import_react.default.cloneElement(children, cloneProps);
+    }
+    return import_react.default.Children.count(children) > 1 ? import_react.default.Children.only(null) : null;
+  }
+);
+SlotClone.displayName = "SlotClone";
+var Slottable = ({ children }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children });
+};
+function isSlottable(child) {
+  return import_react.default.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/primitives/CheckoutSummary.tsx
+var import_react9 = require("react");
+
+// src/hooks/usePlan.ts
+var import_react6 = require("react");
+
+// src/hooks/useSolvaPay.ts
+var import_react4 = require("react");
+
+// src/SolvaPayProvider.tsx
+var import_react3 = require("react");
+
+// src/adapters/auth.ts
+var defaultAuthAdapter = {
+  async getToken() {
+    if (typeof window === "undefined") return null;
+    const token = localStorage.getItem("auth_token");
+    return token || null;
+  },
+  async getUserId() {
+    const token = await this.getToken();
+    if (!token) return null;
+    try {
+      const parts = token.split(".");
+      if (parts.length === 3) {
+        const payload = JSON.parse(atob(parts[1]));
+        return payload.sub || payload.user_id || null;
+      }
+    } catch {
+    }
+    return null;
+  }
+};
+
+// src/utils/headers.ts
+var CUSTOMER_REF_KEY = "solvapay_customerRef";
+var CUSTOMER_REF_EXPIRY = "solvapay_customerRef_expiry";
+var CUSTOMER_REF_USER_ID_KEY = "solvapay_customerRef_userId";
+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 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/i18n/context.tsx
+var import_react2 = require("react");
+
+// 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/context.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var CopyContext = (0, import_react2.createContext)({
+  locale: void 0,
+  copy: enCopy
+});
+function useCopyContext() {
+  return (0, import_react2.useContext)(CopyContext);
+}
+
+// src/SolvaPayProvider.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var SolvaPayContext = (0, import_react3.createContext)(null);
+
+// src/hooks/useSolvaPay.ts
+function useSolvaPay() {
+  const context = (0, import_react4.useContext)(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/usePlans.ts
+var import_react5 = require("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 = (0, import_react5.useRef)(fetcher);
+  const filterRef = (0, import_react5.useRef)(filter);
+  const sortByRef = (0, import_react5.useRef)(sortBy);
+  const autoSelectFirstPaidRef = (0, import_react5.useRef)(autoSelectFirstPaid);
+  const initialPlanRefRef = (0, import_react5.useRef)(initialPlanRef);
+  const selectionReadyRef = (0, import_react5.useRef)(selectionReady);
+  const hasAppliedInitialRef = (0, import_react5.useRef)(false);
+  const userHasSelectedRef = (0, import_react5.useRef)(false);
+  const [selectedPlanIndex, setSelectedPlanIndexState] = (0, import_react5.useState)(() => {
+    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] = (0, import_react5.useState)(() => {
+    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] = (0, import_react5.useState)(() => plans.length === 0);
+  const [error, setError] = (0, import_react5.useState)(null);
+  (0, import_react5.useEffect)(() => {
+    fetcherRef.current = fetcher;
+  }, [fetcher]);
+  (0, import_react5.useEffect)(() => {
+    filterRef.current = filter;
+  }, [filter]);
+  (0, import_react5.useEffect)(() => {
+    sortByRef.current = sortBy;
+  }, [sortBy]);
+  (0, import_react5.useEffect)(() => {
+    autoSelectFirstPaidRef.current = autoSelectFirstPaid;
+  }, [autoSelectFirstPaid]);
+  (0, import_react5.useEffect)(() => {
+    initialPlanRefRef.current = initialPlanRef;
+  }, [initialPlanRef]);
+  (0, import_react5.useEffect)(() => {
+    selectionReadyRef.current = selectionReady;
+  }, [selectionReady]);
+  const setSelectedPlanIndex = (0, import_react5.useCallback)((index) => {
+    userHasSelectedRef.current = true;
+    setSelectedPlanIndexState(index);
+  }, []);
+  const applyInitialSelection = (0, import_react5.useCallback)((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 = (0, import_react5.useCallback)(
+    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]
+  );
+  (0, import_react5.useEffect)(() => {
+    fetchPlans();
+  }, [fetchPlans]);
+  (0, import_react5.useEffect)(() => {
+    if (hasAppliedInitialRef.current || userHasSelectedRef.current) return;
+    if (!selectionReady || plans.length === 0) return;
+    applyInitialSelection(plans);
+  }, [selectionReady, plans, applyInitialSelection]);
+  const selectedPlan = (0, import_react5.useMemo)(() => plans[selectedPlanIndex] || null, [plans, selectedPlanIndex]);
+  const selectPlan = (0, import_react5.useCallback)(
+    (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
+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 = (0, import_react6.useCallback)(
+    (plans) => {
+      if (!planRef) return null;
+      return plans.find((p) => p.reference === planRef) || null;
+    },
+    [planRef]
+  );
+  const [plan, setPlan] = (0, import_react6.useState)(() => {
+    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] = (0, import_react6.useState)(() => !!(planRef && !plan));
+  const [error, setError] = (0, import_react6.useState)(null);
+  const load = (0, import_react6.useCallback)(
+    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]
+  );
+  (0, import_react6.useEffect)(() => {
+    load();
+  }, [load]);
+  return {
+    plan,
+    loading,
+    error,
+    refetch: () => load(true)
+  };
+}
+
+// src/hooks/useProduct.ts
+var import_react7 = require("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] = (0, import_react7.useState)(
+    () => productRef ? productCache.get(cacheKey)?.product ?? null : null
+  );
+  const [loading, setLoading] = (0, import_react7.useState)(() => {
+    if (!productRef) return false;
+    const cached = productCache.get(cacheKey);
+    return !cached || !cached.product && !cached.promise;
+  });
+  const [error, setError] = (0, import_react7.useState)(null);
+  const load = (0, import_react7.useCallback)(
+    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]
+  );
+  (0, import_react7.useEffect)(() => {
+    load();
+  }, [load]);
+  return {
+    product,
+    loading,
+    error,
+    refetch: () => load(true)
+  };
+}
+
+// src/hooks/useCopy.ts
+function useCopy() {
+  return useCopyContext().copy;
+}
+function useLocale() {
+  return useCopyContext().locale;
+}
+
+// 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/components/PlanSelectionContext.tsx
+var import_react8 = require("react");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var PlanSelectionContext = (0, import_react8.createContext)(null);
+var PlanSelectionProvider = ({
+  value,
+  children
+}) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(PlanSelectionContext.Provider, { value, children });
+function usePlanSelection() {
+  return (0, import_react8.useContext)(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
+var import_jsx_runtime5 = require("react/jsx-runtime");
+var CheckoutSummaryContext = (0, import_react9.createContext)(null);
+function useCheckoutSummaryContext(part) {
+  const ctx = (0, import_react9.useContext)(CheckoutSummaryContext);
+  if (!ctx) {
+    throw new Error(
+      `CheckoutSummary.${part} must be rendered inside <CheckoutSummary.Root>.`
+    );
+  }
+  return ctx;
+}
+var Root = (0, import_react9.forwardRef)(function CheckoutSummaryRoot({ planRef, productRef, asChild, children, ...rest }, forwardedRef) {
+  const solva = (0, import_react9.useContext)(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 = (0, import_react9.useMemo)(() => {
+    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 = (0, import_react9.useMemo)(() => {
+    const trialDays = plan?.trialDays;
+    if (!trialDays || trialDays <= 0) return null;
+    return interpolate(copy.interval.trial, { trialDays });
+  }, [plan?.trialDays, copy.interval.trial]);
+  const ctx = (0, import_react9.useMemo)(
+    () => ({ plan, product, priceFormatted, trialBanner, loading }),
+    [plan, product, priceFormatted, trialBanner, loading]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary": "", ...rest, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(CheckoutSummaryContext.Provider, { value: ctx, children }) });
+});
+var ProductSlot = (0, import_react9.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__ */ (0, import_jsx_runtime5.jsx)(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-product": "", ...rest, children: children ?? name });
+});
+var PlanSlot = (0, import_react9.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__ */ (0, import_jsx_runtime5.jsx)(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-plan": "", ...rest, children: children ?? name });
+});
+var PriceSlot = (0, import_react9.forwardRef)(function CheckoutSummaryPrice({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useCheckoutSummaryContext("Price");
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-price": "", ...rest, children: children ?? ctx.priceFormatted });
+});
+var TrialSlot = (0, import_react9.forwardRef)(function CheckoutSummaryTrial({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useCheckoutSummaryContext("Trial");
+  if (!ctx.trialBanner) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-trial": "", ...rest, children: children ?? ctx.trialBanner });
+});
+var TaxNoteSlot = (0, import_react9.forwardRef)(function CheckoutSummaryTaxNote({ asChild, children, ...rest }, forwardedRef) {
+  useCheckoutSummaryContext("TaxNote");
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(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/primitives/PlanSelector.tsx
+var import_react10 = require("react");
+
+// src/hooks/usePurchase.ts
+function usePurchase() {
+  const { purchase, refetchPurchase } = useSolvaPay();
+  return {
+    ...purchase,
+    refetch: refetchPurchase
+  };
+}
+
+// src/primitives/PlanSelector.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+var PlanSelectorContext = (0, import_react10.createContext)(null);
+function usePlanSelectorContext(part) {
+  const ctx = (0, import_react10.useContext)(PlanSelectorContext);
+  if (!ctx) {
+    throw new Error(`PlanSelector.${part} must be rendered inside <PlanSelector.Root>.`);
+  }
+  return ctx;
+}
+var CardContext = (0, import_react10.createContext)(null);
+function useCardContext(part) {
+  const ctx = (0, import_react10.useContext)(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 Root2 = (0, import_react10.forwardRef)(function PlanSelectorRoot(props, forwardedRef) {
+  const {
+    productRef,
+    fetcher,
+    filter,
+    sortBy,
+    autoSelectFirstPaid = true,
+    initialPlanRef,
+    currentPlanRef,
+    popularPlanRef,
+    onSelect,
+    children,
+    ...rest
+  } = props;
+  const solva = (0, import_react10.useContext)(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("PlanSelector");
+  if (!productRef) throw new MissingProductRefError("PlanSelector");
+  const { _config } = solva;
+  const { purchases } = usePurchase();
+  const effectiveFetcher = (0, import_react10.useMemo)(
+    () => fetcher ?? ((ref) => defaultListPlans(ref, _config)),
+    [fetcher, _config]
+  );
+  const { plans, selectedPlan, selectPlan, loading, error } = usePlans({
+    productRef,
+    fetcher: effectiveFetcher,
+    filter,
+    sortBy,
+    autoSelectFirstPaid,
+    initialPlanRef
+  });
+  const autoCurrentPlanRef = (0, import_react10.useMemo)(() => {
+    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 = (0, import_react10.useCallback)(
+    (ref) => resolvedCurrentPlanRef === ref,
+    [resolvedCurrentPlanRef]
+  );
+  const isFree = (0, import_react10.useCallback)(
+    (ref) => plans.find((p) => p.reference === ref)?.requiresPayment === false,
+    [plans]
+  );
+  const isPopular = (0, import_react10.useCallback)(
+    (ref) => popularPlanRef === ref,
+    [popularPlanRef]
+  );
+  const select = (0, import_react10.useCallback)(
+    (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 = (0, import_react10.useMemo)(
+    () => ({
+      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__ */ (0, import_jsx_runtime6.jsx)(
+    PlanSelectionProvider,
+    {
+      value: {
+        productRef,
+        selectedPlanRef,
+        setSelectedPlanRef: (ref) => {
+          if (ref) select(ref);
+        },
+        plans,
+        loading,
+        error
+      },
+      children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", { ref: forwardedRef, "data-solvapay-plan-selector": "", ...rest, children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(PlanSelectorContext.Provider, { value: ctx, children }) })
+    }
+  );
+});
+var Heading = (0, import_react10.forwardRef)(function PlanSelectorHeading({ asChild, children, ...rest }, forwardedRef) {
+  usePlanSelectorContext("Heading");
+  const copy = useCopy();
+  const Comp = asChild ? Slot : "h3";
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-heading": "", ...rest, children: children ?? copy.planSelector.heading });
+});
+var Grid = (0, import_react10.forwardRef)(function PlanSelectorGrid({ children, ...rest }, forwardedRef) {
+  const ctx = usePlanSelectorContext("Grid");
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("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__ */ (0, import_jsx_runtime6.jsx)(CardContext.Provider, { value: cardCtx, children }, plan.reference);
+  }) });
+});
+var Card = (0, import_react10.forwardRef)(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__ */ (0, import_jsx_runtime6.jsx)(Slot, { ref: forwardedRef, ...commonProps, children })
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+    "button",
+    {
+      ref: forwardedRef,
+      type: "button",
+      disabled: card.disabled,
+      ...commonProps,
+      children
+    }
+  );
+});
+var CardName = (0, import_react10.forwardRef)(function PlanSelectorCardName({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardName");
+  if (!card.plan.name) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-name": "", ...rest, children: children ?? card.plan.name });
+});
+var CardPrice = (0, import_react10.forwardRef)(function PlanSelectorCardPrice({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardPrice");
+  const locale = useLocale();
+  const copy = useCopy();
+  const formatted = (0, import_react10.useMemo)(() => {
+    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__ */ (0, import_jsx_runtime6.jsx)(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-price": "", ...rest, children: children ?? formatted });
+});
+var CardInterval = (0, import_react10.forwardRef)(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__ */ (0, import_jsx_runtime6.jsx)(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-interval": "", ...rest, children: children ?? text });
+});
+var CardBadge = (0, import_react10.forwardRef)(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__ */ (0, import_jsx_runtime6.jsx)(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-plan-selector-card-badge": "",
+      "data-variant": variant,
+      ...rest,
+      children: children ?? label
+    }
+  );
+});
+var Loading = (0, import_react10.forwardRef)(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__ */ (0, import_jsx_runtime6.jsx)(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-loading": "", ...rest, children });
+});
+var ErrorSlot = (0, import_react10.forwardRef)(function PlanSelectorError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = usePlanSelectorContext("Error");
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-error": "", role: "alert", ...rest, children: children ?? ctx.error.message });
+});
+var PlanSelectorRoot2 = Root2;
+var PlanSelectorHeading2 = Heading;
+var PlanSelectorGrid2 = Grid;
+var PlanSelectorCard2 = Card;
+var PlanSelectorCardName2 = CardName;
+var PlanSelectorCardPrice2 = CardPrice;
+var PlanSelectorCardInterval2 = CardInterval;
+var PlanSelectorCardBadge2 = CardBadge;
+var PlanSelectorLoading2 = Loading;
+var PlanSelectorError2 = ErrorSlot;
+var PlanSelector = {
+  Root: Root2,
+  Heading,
+  Grid,
+  Card,
+  CardName,
+  CardPrice,
+  CardInterval,
+  CardBadge,
+  Loading,
+  Error: ErrorSlot
+};
+function usePlanSelector() {
+  return usePlanSelectorContext("usePlanSelector");
+}
+
+// src/primitives/PaymentForm.tsx
+var import_react16 = require("react");
+var import_react_stripe_js = require("@stripe/react-stripe-js");
+
+// src/hooks/useCheckout.ts
+var import_react11 = require("react");
+var import_stripe_js = require("@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] = (0, import_react11.useState)(false);
+  const [error, setError] = (0, import_react11.useState)(null);
+  const [stripePromise, setStripePromise] = (0, import_react11.useState)(null);
+  const [clientSecret, setClientSecret] = (0, import_react11.useState)(null);
+  const [resolvedPlanRef, setResolvedPlanRef] = (0, import_react11.useState)(planRef || null);
+  const isStartingRef = (0, import_react11.useRef)(false);
+  const startCheckout = (0, import_react11.useCallback)(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 = (0, import_stripe_js.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 = (0, import_react11.useCallback)(() => {
+    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/useCustomer.ts
+function useCustomer() {
+  const { purchase, customerRef } = useSolvaPay();
+  return {
+    customerRef: purchase.customerRef || customerRef,
+    email: purchase.email,
+    name: purchase.name,
+    loading: purchase.loading
+  };
+}
+
+// src/hooks/useActivation.ts
+var import_react12 = require("react");
+function useActivation() {
+  const { activatePlan } = useSolvaPay();
+  const copy = useCopy();
+  const [state, setState] = (0, import_react12.useState)("idle");
+  const [error, setError] = (0, import_react12.useState)(null);
+  const [result, setResult] = (0, import_react12.useState)(null);
+  const activate = (0, import_react12.useCallback)(
+    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 = (0, import_react12.useCallback)(() => {
+    setState("idle");
+    setError(null);
+    setResult(null);
+  }, []);
+  return { activate, state, error, result, reset };
+}
+
+// src/components/PaymentFormContext.tsx
+var import_react13 = require("react");
+var import_jsx_runtime7 = require("react/jsx-runtime");
+var PaymentFormContext = (0, import_react13.createContext)(null);
+function usePaymentForm() {
+  const ctx = (0, import_react13.useContext)(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__ */ (0, import_jsx_runtime7.jsx)(PaymentFormContext.Provider, { value, children });
+
+// src/components/CheckoutSummary.tsx
+var import_jsx_runtime8 = require("react/jsx-runtime");
+var CheckoutSummary2 = ({
+  planRef,
+  productRef,
+  showTrial = true,
+  showTaxNote = false,
+  className
+}) => {
+  const rootClass = ["solvapay-checkout-summary", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(CheckoutSummary.Root, { planRef, productRef, className: rootClass, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(CheckoutSummary.Product, { className: "solvapay-checkout-summary-product" }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)("div", { className: "solvapay-checkout-summary-row", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(CheckoutSummary.Plan, { className: "solvapay-checkout-summary-plan" }),
+      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(CheckoutSummary.Price, { className: "solvapay-checkout-summary-price" })
+    ] }),
+    showTrial && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(CheckoutSummary.Trial, { className: "solvapay-checkout-summary-trial" }),
+    showTaxNote && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(CheckoutSummary.TaxNote, { className: "solvapay-checkout-summary-tax-note" })
+  ] });
+};
+
+// src/primitives/MandateText.tsx
+var import_react15 = require("react");
+
+// src/hooks/useMerchant.ts
+var import_react14 = require("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] = (0, import_react14.useState)(
+    () => merchantCache.get(key)?.merchant ?? null
+  );
+  const [loading, setLoading] = (0, import_react14.useState)(() => {
+    const cached = merchantCache.get(key);
+    return !cached || !cached.merchant && !cached.promise;
+  });
+  const [error, setError] = (0, import_react14.useState)(null);
+  const load = (0, import_react14.useCallback)(
+    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]
+  );
+  (0, import_react14.useEffect)(() => {
+    load();
+  }, [load]);
+  return {
+    merchant,
+    loading,
+    error,
+    refetch: () => load(true)
+  };
+}
+
+// src/utils/checkoutVariant.ts
+function deriveVariant(plan, mode) {
+  if (mode === "topup") return "topup";
+  if (!plan?.type) return "oneTime";
+  if (plan.type === "usage-based") {
+    return plan.billingModel === "post-paid" ? "usageMetered" : "topup";
+  }
+  if (plan.requiresPayment === false) return "freeTier";
+  switch (plan.type) {
+    case "recurring":
+      return "recurring";
+    case "one-time":
+    default:
+      return "oneTime";
+  }
+}
+
+// src/primitives/MandateText.tsx
+var import_jsx_runtime9 = require("react/jsx-runtime");
+var MandateText = (0, import_react15.forwardRef)(
+  function MandateText2({
+    planRef,
+    productRef,
+    variant,
+    mode,
+    amountMinor,
+    currency,
+    asChild,
+    children,
+    ...rest
+  }, forwardedRef) {
+    const solva = (0, import_react15.useContext)(SolvaPayContext);
+    if (!solva) throw new MissingProviderError("MandateText");
+    const locale = useLocale();
+    const copy = useCopy();
+    const planSelection = usePlanSelection();
+    const resolvedPlanRef = planRef ?? planSelection?.selectedPlanRef ?? void 0;
+    const resolvedProductRef = productRef ?? planSelection?.productRef;
+    const { plan } = usePlan({ planRef: resolvedPlanRef, productRef: resolvedProductRef });
+    const { product } = useProduct(resolvedProductRef);
+    const { merchant } = useMerchant();
+    const resolvedVariant = variant || deriveVariant(plan, mode);
+    const effectiveAmount = amountMinor ?? plan?.price ?? 0;
+    const effectiveCurrency = currency ?? plan?.currency ?? merchant?.defaultCurrency ?? "usd";
+    const amountFormatted = formatPrice(effectiveAmount, effectiveCurrency, {
+      locale,
+      free: copy.interval.free
+    });
+    const ctx = (0, import_react15.useMemo)(
+      () => ({
+        merchant: {
+          legalName: merchant?.legalName ?? merchant?.displayName ?? "",
+          displayName: merchant?.displayName,
+          supportEmail: merchant?.supportEmail,
+          termsUrl: merchant?.termsUrl,
+          privacyUrl: merchant?.privacyUrl
+        },
+        plan: plan ? {
+          name: plan.name,
+          interval: plan.interval,
+          intervalCount: 1,
+          trialDays: plan.trialDays,
+          measures: plan.measures,
+          billingCycle: plan.billingCycle
+        } : void 0,
+        product: product ? { name: product.name } : void 0,
+        amountFormatted,
+        trialDays: plan?.trialDays
+      }),
+      [merchant, plan, product, amountFormatted]
+    );
+    const template = copy.mandate[resolvedVariant];
+    const text = typeof template === "function" ? template(ctx) : template;
+    if (!text) return null;
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(
+      Comp,
+      {
+        ref: forwardedRef,
+        "data-solvapay-mandate-text": "",
+        "data-variant": resolvedVariant,
+        ...rest,
+        children: children ?? text
+      }
+    );
+  }
+);
+
+// src/components/Spinner.tsx
+var import_jsx_runtime10 = require("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__ */ (0, import_jsx_runtime10.jsxs)(
+    "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__ */ (0, import_jsx_runtime10.jsx)("circle", { className: "opacity-25", cx: "12", cy: "12", r: "10", stroke: "currentColor", strokeWidth: "4" }),
+        /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+          "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/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/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
+var import_jsx_runtime11 = require("react/jsx-runtime");
+function toSubmitVariant(variant) {
+  switch (variant) {
+    case "freeTier":
+      return "free";
+    case "topup":
+      return "topup";
+    case "usageMetered":
+      return "activate";
+    default:
+      return "paid";
+  }
+}
+var Root3 = (0, import_react16.forwardRef)(function PaymentFormRoot(props, forwardedRef) {
+  const {
+    planRef,
+    productRef,
+    onSuccess,
+    onResult,
+    onFreePlan,
+    onError,
+    returnUrl,
+    submitButtonText,
+    className,
+    buttonClassName,
+    prefillCustomer,
+    requireTermsAcceptance = false,
+    children
+  } = props;
+  const solva = (0, import_react16.useContext)(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 = (0, import_react16.useRef)(false);
+  const hasPlanOrProduct = !!(effectivePlanRef || effectiveProductRef);
+  (0, import_react16.useEffect)(() => {
+    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 = (0, import_react16.useMemo)(() => {
+    if (!clientSecret) return void 0;
+    return { clientSecret, locale };
+  }, [clientSecret, locale]);
+  const shouldRenderElements = !!(stripePromise && clientSecret);
+  if (!hasPlanOrProduct) {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "error",
+        children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { "data-solvapay-payment-form-error": "", children: copy.errors.configMissingPlanOrProduct })
+      }
+    );
+  }
+  if (checkoutError) {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "error",
+        children: /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { "data-solvapay-payment-form-error": "", children: [
+          copy.errors.paymentInitFailed,
+          " ",
+          checkoutError.message || copy.errors.unknownError
+        ] })
+      }
+    );
+  }
+  if (isFreePlan && resolvedPlan) {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "ready",
+        "data-variant": "free",
+        children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+          FreeInner,
+          {
+            planRef: effectivePlanRef,
+            productRef: effectiveProductRef,
+            plan: resolvedPlan,
+            resolvedPlanRef,
+            requireTermsAcceptance,
+            submitButtonText,
+            buttonClassName,
+            onFreePlan,
+            onResult,
+            onError,
+            children
+          }
+        )
+      }
+    );
+  }
+  if (shouldRenderElements && elementsOptions) {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "ready",
+        "data-variant": "paid",
+        children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_react_stripe_js.Elements, { stripe: stripePromise, options: elementsOptions, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+          PaidInner,
+          {
+            planRef: effectivePlanRef,
+            productRef: effectiveProductRef,
+            prefillCustomer,
+            resolvedPlanRef,
+            plan: resolvedPlan ?? null,
+            clientSecret,
+            returnUrl: finalReturnUrl,
+            submitButtonText,
+            buttonClassName,
+            requireTermsAcceptance,
+            onSuccess,
+            onResult,
+            onError,
+            children
+          }
+        ) }, clientSecret)
+      }
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    "div",
+    {
+      ref: forwardedRef,
+      className,
+      "data-solvapay-payment-form": "",
+      "data-state": "loading",
+      children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { "data-solvapay-payment-form-loading": "", children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Spinner, { size: "md" }) })
+    }
+  );
+});
+var PaidInner = ({
+  planRef,
+  productRef,
+  prefillCustomer,
+  resolvedPlanRef,
+  plan,
+  clientSecret,
+  returnUrl,
+  submitButtonText,
+  buttonClassName,
+  requireTermsAcceptance,
+  onSuccess,
+  onResult,
+  onError,
+  children
+}) => {
+  const stripe = (0, import_react_stripe_js.useStripe)();
+  const elements = (0, import_react_stripe_js.useElements)();
+  const copy = useCopy();
+  const customer = useCustomer();
+  const { processPayment } = useSolvaPay();
+  const { refetch } = usePurchase();
+  const [elementKind, setElementKind] = (0, import_react16.useState)(
+    children ? null : "payment-element"
+  );
+  const [paymentInputComplete, setPaymentInputComplete] = (0, import_react16.useState)(false);
+  const [termsAccepted, setTermsAccepted] = (0, import_react16.useState)(false);
+  const [isProcessing, setIsProcessing] = (0, import_react16.useState)(false);
+  const [error, setError] = (0, import_react16.useState)(null);
+  const isReady = !!(stripe && elements);
+  const canSubmit = isReady && !!clientSecret && !!elementKind && paymentInputComplete && (!requireTermsAcceptance || termsAccepted) && !isProcessing;
+  const submit = (0, import_react16.useCallback)(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 = (0, import_react16.useMemo)(
+    () => ({
+      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__ */ (0, import_jsx_runtime11.jsx)(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] = (0, import_react16.useState)(false);
+  const [localError, setLocalError] = (0, import_react16.useState)(null);
+  const resultFiredRef = (0, import_react16.useRef)(false);
+  (0, import_react16.useEffect)(() => {
+    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 = (0, import_react16.useCallback)(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 = (0, import_react16.useMemo)(
+    () => ({
+      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__ */ (0, import_jsx_runtime11.jsx)(PaymentFormProvider, { value: contextValue, children });
+};
+var Summary = (props) => {
+  const ctx = usePaymentForm();
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    CheckoutSummary2,
+    {
+      ...props,
+      planRef: ctx.planRef || ctx.resolvedPlanRef || void 0,
+      productRef: ctx.productRef
+    }
+  );
+};
+var MandateTextPrimitive = (props) => {
+  const ctx = usePaymentForm();
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    MandateText,
+    {
+      ...props,
+      planRef: ctx.planRef || ctx.resolvedPlanRef || void 0,
+      productRef: ctx.productRef
+    }
+  );
+};
+var CustomerFields = (0, import_react16.forwardRef)(
+  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__ */ (0, import_jsx_runtime11.jsx)(Comp, { ref, "data-solvapay-payment-form-customer-fields": "", ...rest, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
+      email && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { "data-solvapay-payment-form-customer-email": "", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("span", { children: [
+          copy.customer.emailLabel,
+          ": "
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", { children: email })
+      ] }),
+      name && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("div", { "data-solvapay-payment-form-customer-name": "", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)("span", { children: [
+          copy.customer.nameLabel,
+          ": "
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", { children: name })
+      ] })
+    ] }) });
+  }
+);
+var PaymentElementSlot = ({ options }) => {
+  const { setElementKind, setPaymentInputComplete, isReady, stripe, elements } = usePaymentForm();
+  const locale = useLocale();
+  (0, import_react16.useEffect)(() => {
+    if (stripe && elements) setElementKind("payment-element");
+  }, [setElementKind, stripe, elements]);
+  if (!stripe || !elements) return null;
+  if (!isReady) {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { "data-solvapay-payment-form-loading": "", children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Spinner, { size: "sm" }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { "data-solvapay-payment-form-payment-element": "", children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    import_react_stripe_js.PaymentElement,
+    {
+      options,
+      onChange: (e) => setPaymentInputComplete(e.complete)
+    },
+    locale || "default"
+  ) });
+};
+var CardElementSlot = ({ options }) => {
+  const { setElementKind, setPaymentInputComplete, isReady, stripe, elements } = usePaymentForm();
+  (0, import_react16.useEffect)(() => {
+    if (stripe && elements) setElementKind("card-element");
+  }, [setElementKind, stripe, elements]);
+  if (!stripe || !elements) return null;
+  if (!isReady) {
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { "data-solvapay-payment-form-loading": "", children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Spinner, { size: "sm" }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("div", { "data-solvapay-payment-form-card-element": "", children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    import_react_stripe_js.CardElement,
+    {
+      options,
+      onChange: (e) => setPaymentInputComplete(e.complete)
+    }
+  ) });
+};
+var TermsCheckbox = (0, import_react16.forwardRef)(
+  function PaymentFormTermsCheckbox({ asChild, label, children, ...rest }, ref) {
+    const { termsAccepted, setTermsAccepted } = usePaymentForm();
+    const copy = useCopy();
+    const id = "solvapay-terms-checkbox";
+    if (asChild) {
+      return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Slot, { ref, "data-solvapay-payment-form-terms": "", ...rest, children });
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(
+      "label",
+      {
+        ref,
+        htmlFor: id,
+        "data-solvapay-payment-form-terms": "",
+        ...rest,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+            "input",
+            {
+              id,
+              type: "checkbox",
+              checked: termsAccepted,
+              onChange: (e) => setTermsAccepted(e.target.checked)
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("span", { children: label ?? copy.terms.checkboxLabel })
+        ]
+      }
+    );
+  }
+);
+var SubmitButton = (0, import_react16.forwardRef)(
+  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__ */ (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Spinner, { size: "sm" }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("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__ */ (0, import_jsx_runtime11.jsx)(Slot, { ref, ...buttonProps, children: content })
+      );
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)("button", { ref, type: "submit", ...buttonProps, children: content });
+  }
+);
+var Loading2 = (0, import_react16.forwardRef)(function PaymentFormLoading({ asChild, children, ...rest }, ref) {
+  const ctx = usePaymentForm();
+  if (ctx.isReady && ctx.clientSecret) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Comp, { ref, "data-solvapay-payment-form-loading": "", ...rest, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(Spinner, { size: "sm" }) });
+});
+var ErrorSlot2 = (0, import_react16.forwardRef)(function PaymentFormError({ asChild, children, ...rest }, ref) {
+  const ctx = usePaymentForm();
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+    Comp,
+    {
+      ref,
+      role: "alert",
+      "aria-live": "assertive",
+      "aria-atomic": "true",
+      "data-solvapay-payment-form-error": "",
+      ...rest,
+      children: children ?? ctx.error
+    }
+  );
+});
+var PaymentFormRoot2 = Root3;
+var PaymentFormSummary = Summary;
+var PaymentFormCustomerFields2 = CustomerFields;
+var PaymentFormPaymentElement = PaymentElementSlot;
+var PaymentFormCardElement = CardElementSlot;
+var PaymentFormMandateText = MandateTextPrimitive;
+var PaymentFormTermsCheckbox2 = TermsCheckbox;
+var PaymentFormSubmitButton2 = SubmitButton;
+var PaymentFormLoading2 = Loading2;
+var PaymentFormError2 = ErrorSlot2;
+var PaymentForm = {
+  Root: Root3,
+  Summary,
+  CustomerFields,
+  PaymentElement: PaymentElementSlot,
+  CardElement: CardElementSlot,
+  MandateText: MandateTextPrimitive,
+  TermsCheckbox,
+  SubmitButton,
+  Loading: Loading2,
+  Error: ErrorSlot2
+};
+
+// src/primitives/ActivationFlow.tsx
+var import_react20 = require("react");
+
+// src/primitives/AmountPicker.tsx
+var import_react19 = require("react");
+
+// src/hooks/useTopupAmountSelector.ts
+var import_react17 = require("react");
+function getQuickAmounts(currency) {
+  switch (currency.toUpperCase()) {
+    case "SEK":
+    case "NOK":
+    case "DKK":
+      return [100, 500, 1e3, 5e3];
+    case "JPY":
+      return [1e3, 5e3, 1e4, 5e4];
+    case "KRW":
+      return [1e4, 5e4, 1e5, 5e5];
+    case "ISK":
+    case "HUF":
+      return [1e3, 5e3, 1e4, 5e4];
+    default:
+      return [10, 50, 100, 500];
+  }
+}
+function getCurrencySymbol(currency) {
+  try {
+    const parts = new Intl.NumberFormat("en", { style: "currency", currency }).formatToParts(0);
+    const sym = parts.find((p) => p.type === "currency");
+    return sym?.value || currency;
+  } catch {
+    return currency;
+  }
+}
+var DEFAULT_MIN = 1;
+var DEFAULT_MAX = 1e5;
+function useTopupAmountSelector(options) {
+  const { currency, minAmount = DEFAULT_MIN, maxAmount = DEFAULT_MAX } = options;
+  const copy = useCopy();
+  const [selectedAmount, setSelectedAmount] = (0, import_react17.useState)(null);
+  const [customAmount, setCustomAmountRaw] = (0, import_react17.useState)("");
+  const [error, setError] = (0, import_react17.useState)(null);
+  const quickAmounts = (0, import_react17.useMemo)(() => getQuickAmounts(currency), [currency]);
+  const currencySymbol = (0, import_react17.useMemo)(() => getCurrencySymbol(currency), [currency]);
+  const resolvedAmount = (0, import_react17.useMemo)(() => {
+    if (customAmount) {
+      const parsed = parseFloat(customAmount);
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+    }
+    return selectedAmount;
+  }, [selectedAmount, customAmount]);
+  const selectQuickAmount = (0, import_react17.useCallback)(
+    (amount) => {
+      setSelectedAmount(amount);
+      setCustomAmountRaw("");
+      setError(null);
+    },
+    []
+  );
+  const setCustomAmount = (0, import_react17.useCallback)(
+    (value) => {
+      const sanitized = value.replace(/[^0-9.]/g, "");
+      const dotIndex = sanitized.indexOf(".");
+      const cleaned = dotIndex === -1 ? sanitized : sanitized.slice(0, dotIndex + 1) + sanitized.slice(dotIndex + 1).replace(/\./g, "");
+      setCustomAmountRaw(cleaned);
+      setSelectedAmount(null);
+      setError(null);
+    },
+    []
+  );
+  const validate = (0, import_react17.useCallback)(() => {
+    if (resolvedAmount == null) {
+      setError(copy.topup.selectOrEnterAmount);
+      return false;
+    }
+    if (resolvedAmount < minAmount) {
+      setError(
+        interpolate(copy.topup.minAmount, {
+          amount: `${currencySymbol}${minAmount}`
+        })
+      );
+      return false;
+    }
+    if (resolvedAmount > maxAmount) {
+      setError(
+        interpolate(copy.topup.maxAmount, {
+          amount: `${currencySymbol}${maxAmount.toLocaleString()}`
+        })
+      );
+      return false;
+    }
+    setError(null);
+    return true;
+  }, [resolvedAmount, minAmount, maxAmount, currencySymbol, copy]);
+  const reset = (0, import_react17.useCallback)(() => {
+    setSelectedAmount(null);
+    setCustomAmountRaw("");
+    setError(null);
+  }, []);
+  return {
+    quickAmounts,
+    selectedAmount,
+    customAmount,
+    resolvedAmount,
+    selectQuickAmount,
+    setCustomAmount,
+    error,
+    validate,
+    reset,
+    currencySymbol
+  };
+}
+
+// src/hooks/useBalance.ts
+var import_react18 = require("react");
+function useBalance() {
+  const { balance } = useSolvaPay();
+  (0, import_react18.useEffect)(() => {
+    balance.refetch();
+  }, [balance.refetch]);
+  return balance;
+}
+
+// src/primitives/AmountPicker.tsx
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var AmountPickerContext = (0, import_react19.createContext)(null);
+function usePickerCtx(part) {
+  const ctx = (0, import_react19.useContext)(AmountPickerContext);
+  if (!ctx) {
+    throw new Error(`AmountPicker.${part} must be rendered inside <AmountPicker.Root>.`);
+  }
+  return ctx;
+}
+var Root4 = (0, import_react19.forwardRef)(function AmountPickerRoot({ currency, minAmount, maxAmount, onChange, asChild, children, ...rest }, forwardedRef) {
+  const solva = (0, import_react19.useContext)(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("AmountPicker");
+  const selector = useTopupAmountSelector({ currency, minAmount, maxAmount });
+  const { creditsPerMinorUnit, displayExchangeRate } = useBalance();
+  (0, import_react19.useEffect)(() => {
+    onChange?.(selector.resolvedAmount);
+  }, [selector.resolvedAmount, onChange]);
+  const resolvedAmountMinor = selector.resolvedAmount != null && selector.resolvedAmount > 0 ? Math.round(selector.resolvedAmount * 100) : null;
+  const rate = displayExchangeRate ?? 1;
+  const estimatedCredits = creditsPerMinorUnit != null && creditsPerMinorUnit > 0 && resolvedAmountMinor != null ? Math.floor(resolvedAmountMinor / rate * creditsPerMinorUnit) : null;
+  const isApproximate = rate !== 1;
+  const ctx = (0, import_react19.useMemo)(
+    () => ({
+      ...selector,
+      currency,
+      creditsPerMinorUnit,
+      displayExchangeRate,
+      estimatedCredits,
+      isApproximate
+    }),
+    [selector, currency, creditsPerMinorUnit, displayExchangeRate, estimatedCredits, isApproximate]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(AmountPickerContext.Provider, { value: ctx, children: /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Comp, { ref: forwardedRef, "data-solvapay-amount-picker": "", ...rest, children }) });
+});
+var Option = (0, import_react19.forwardRef)(function AmountPickerOption({ asChild, amount, onClick, children, ...rest }, forwardedRef) {
+  const ctx = usePickerCtx("Option");
+  const isActive = ctx.selectedAmount === amount && !ctx.customAmount;
+  const state = rest.disabled ? "disabled" : isActive ? "selected" : "idle";
+  const commonProps = {
+    "data-solvapay-amount-picker-option": "",
+    "data-state": state,
+    "data-amount": String(amount),
+    "aria-pressed": isActive,
+    onClick: composeEventHandlers(onClick, () => {
+      ctx.selectQuickAmount(amount);
+    }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_jsx_runtime12.Fragment, { children: [
+        ctx.currencySymbol,
+        amount.toLocaleString()
+      ] }) })
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_jsx_runtime12.Fragment, { children: [
+    ctx.currencySymbol,
+    amount.toLocaleString()
+  ] }) });
+});
+var Custom = (0, import_react19.forwardRef)(function AmountPickerCustom({ asChild, onChange, onFocus, ...rest }, forwardedRef) {
+  const ctx = usePickerCtx("Custom");
+  const state = ctx.customAmount ? "active" : "dormant";
+  const commonProps = {
+    "data-solvapay-amount-picker-custom": "",
+    "data-state": state,
+    type: "text",
+    inputMode: "decimal",
+    placeholder: "0.00",
+    value: ctx.customAmount,
+    onChange: composeEventHandlers(onChange, (e) => {
+      ctx.setCustomAmount(e.target.value);
+    }),
+    onFocus: composeEventHandlers(onFocus, () => {
+      if (ctx.selectedAmount != null) ctx.selectQuickAmount(0);
+    }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Slot, { ref: forwardedRef, ...commonProps })
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("input", { ref: forwardedRef, ...commonProps });
+});
+var Confirm = (0, import_react19.forwardRef)(function AmountPickerConfirm({ asChild, onClick, onConfirm, disabled, children, ...rest }, forwardedRef) {
+  const ctx = usePickerCtx("Confirm");
+  const isDisabled = disabled || !ctx.resolvedAmount;
+  const handleConfirm = (0, import_react19.useCallback)(() => {
+    if (ctx.validate() && ctx.resolvedAmount != null) {
+      onConfirm?.(ctx.resolvedAmount);
+    }
+  }, [ctx, onConfirm]);
+  const commonProps = {
+    "data-solvapay-amount-picker-confirm": "",
+    "data-state": isDisabled ? "disabled" : "idle",
+    disabled: isDisabled,
+    "aria-disabled": isDisabled || void 0,
+    onClick: composeEventHandlers(onClick, handleConfirm),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(Slot, { ref: forwardedRef, ...commonProps, children })
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)("button", { ref: forwardedRef, type: "button", ...commonProps, children });
+});
+var AmountPickerRoot2 = Root4;
+var AmountPickerOption2 = Option;
+var AmountPickerCustom2 = Custom;
+var AmountPickerConfirm2 = Confirm;
+var AmountPicker = {
+  Root: Root4,
+  Option,
+  Custom,
+  Confirm
+};
+function useAmountPicker() {
+  return usePickerCtx("useAmountPicker");
+}
+function useAmountPickerCopy() {
+  const copy = useCopy();
+  const ctx = usePickerCtx("useAmountPickerCopy");
+  return {
+    selectAmountLabel: copy.amountPicker.selectAmountLabel,
+    customAmountLabel: copy.amountPicker.customAmountLabel,
+    creditEstimate: (credits) => interpolate(
+      ctx.isApproximate ? copy.amountPicker.creditEstimateApprox : copy.amountPicker.creditEstimateExact,
+      { credits: new Intl.NumberFormat().format(credits) }
+    )
+  };
+}
+
+// src/primitives/ActivationFlow.tsx
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var ActivationFlowContext = (0, import_react20.createContext)(null);
+function useFlowCtx(part) {
+  const ctx = (0, import_react20.useContext)(ActivationFlowContext);
+  if (!ctx) {
+    throw new Error(`ActivationFlow.${part} must be rendered inside <ActivationFlow.Root>.`);
+  }
+  return ctx;
+}
+var Root5 = (0, import_react20.forwardRef)(function ActivationFlowRoot({
+  productRef,
+  planRef: planRefProp,
+  onSuccess,
+  onError,
+  retryDelayMs = 1500,
+  retryBackoffMs = 2e3,
+  asChild,
+  children,
+  ...rest
+}, forwardedRef) {
+  const solva = (0, import_react20.useContext)(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("ActivationFlow");
+  if (!productRef) throw new MissingProductRefError("ActivationFlow");
+  const planSelection = usePlanSelection();
+  const resolvedPlanRef = planRefProp ?? planSelection?.selectedPlanRef ?? void 0;
+  const { plan } = usePlan({ planRef: resolvedPlanRef, productRef });
+  const { activate, state, error, result, reset } = useActivation();
+  const currency = plan?.currency ?? "USD";
+  const amountSelector = useTopupAmountSelector({ currency });
+  const { adjustBalance, creditsPerMinorUnit, displayExchangeRate } = useBalance();
+  const [step, setStep] = (0, import_react20.useState)("summary");
+  const calledSuccessRef = (0, import_react20.useRef)(false);
+  const retryTimeoutRef = (0, import_react20.useRef)(null);
+  (0, import_react20.useEffect)(() => {
+    if (state === "activated" && !calledSuccessRef.current) {
+      calledSuccessRef.current = true;
+      setStep("activated");
+      if (result) {
+        const activationResult = { kind: "activated", result };
+        onSuccess?.(activationResult);
+      }
+    }
+  }, [state, result, onSuccess]);
+  (0, import_react20.useEffect)(() => {
+    if (state === "topup_required" && (step === "summary" || step === "activating")) {
+      setStep("selectAmount");
+    }
+  }, [state, step]);
+  (0, import_react20.useEffect)(() => {
+    if ((state === "error" || state === "payment_required") && error) {
+      setStep("error");
+      if (state === "error") onError?.(new Error(error));
+    }
+  }, [state, error, onError]);
+  const handleActivate = (0, import_react20.useCallback)(async () => {
+    if (!resolvedPlanRef) return;
+    setStep("activating");
+    await activate({ productRef, planRef: resolvedPlanRef });
+  }, [activate, productRef, resolvedPlanRef]);
+  const goToTopupPayment = (0, import_react20.useCallback)(() => {
+    if (amountSelector.validate()) setStep("topupPayment");
+  }, [amountSelector]);
+  const backToSelectAmount = (0, import_react20.useCallback)(() => {
+    setStep("selectAmount");
+  }, []);
+  const retryActivation = (0, import_react20.useCallback)(async () => {
+    if (!resolvedPlanRef) return;
+    setStep("retrying");
+    const amountMinor = Math.round((amountSelector.resolvedAmount || 0) * 100);
+    const rate = displayExchangeRate ?? 1;
+    if (creditsPerMinorUnit) {
+      adjustBalance(Math.floor(amountMinor / rate * creditsPerMinorUnit));
+    }
+    await new Promise((r) => setTimeout(r, retryDelayMs));
+    await activate({ productRef, planRef: resolvedPlanRef });
+  }, [
+    resolvedPlanRef,
+    amountSelector.resolvedAmount,
+    displayExchangeRate,
+    creditsPerMinorUnit,
+    adjustBalance,
+    retryDelayMs,
+    activate,
+    productRef
+  ]);
+  const handleTopupSuccess = (0, import_react20.useCallback)(async () => {
+    await retryActivation();
+  }, [retryActivation]);
+  (0, import_react20.useEffect)(() => {
+    if (step !== "retrying") return;
+    if (state !== "topup_required") return;
+    if (!resolvedPlanRef) return;
+    retryTimeoutRef.current = setTimeout(async () => {
+      await activate({ productRef, planRef: resolvedPlanRef });
+    }, retryBackoffMs);
+    return () => {
+      if (retryTimeoutRef.current) clearTimeout(retryTimeoutRef.current);
+    };
+  }, [step, state, resolvedPlanRef, retryBackoffMs, activate, productRef]);
+  const resetFlow = (0, import_react20.useCallback)(() => {
+    reset();
+    calledSuccessRef.current = false;
+    setStep("summary");
+  }, [reset]);
+  const amountCents = Math.round((amountSelector.resolvedAmount || 0) * 100);
+  const ctx = (0, import_react20.useMemo)(
+    () => ({
+      step,
+      plan,
+      productRef,
+      planRef: resolvedPlanRef ?? "",
+      amountSelector,
+      amountCents,
+      currency,
+      activate: handleActivate,
+      reset: resetFlow,
+      goToTopupPayment,
+      backToSelectAmount,
+      onTopupSuccess: handleTopupSuccess,
+      error,
+      onError
+    }),
+    [
+      step,
+      plan,
+      productRef,
+      resolvedPlanRef,
+      amountSelector,
+      amountCents,
+      currency,
+      handleActivate,
+      resetFlow,
+      goToTopupPayment,
+      backToSelectAmount,
+      handleTopupSuccess,
+      error,
+      onError
+    ]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(ActivationFlowContext.Provider, { value: ctx, children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-activation-flow": "",
+      "data-state": step,
+      ...rest,
+      children
+    }
+  ) });
+});
+function matchStep(step, allowed) {
+  return allowed.includes(step);
+}
+var Summary2 = (0, import_react20.forwardRef)(function ActivationFlowSummary({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Summary");
+  if (!matchStep(ctx.step, ["summary", "activating"])) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-summary": "", ...rest, children });
+});
+var ActivateButton = (0, import_react20.forwardRef)(
+  function ActivationFlowActivateButton({ asChild, onClick, children, ...rest }, forwardedRef) {
+    const ctx = useFlowCtx("ActivateButton");
+    const copy = useCopy();
+    if (!matchStep(ctx.step, ["summary", "activating"])) return null;
+    const isActivating = ctx.step === "activating";
+    const disabled = isActivating;
+    const commonProps = {
+      "data-solvapay-activation-flow-activate": "",
+      "data-state": isActivating ? "activating" : "idle",
+      "aria-busy": isActivating,
+      disabled,
+      onClick: composeEventHandlers(onClick, () => {
+        void ctx.activate();
+      }),
+      ...rest
+    };
+    const label = isActivating ? copy.activationFlow.activatingLabel : copy.activationFlow.activateButton;
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_jsx_runtime13.Fragment, { children: label }) })
+      );
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? label });
+  }
+);
+var AmountPickerMount = ({ children }) => {
+  const ctx = useFlowCtx("AmountPicker");
+  if (ctx.step !== "selectAmount") return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("div", { "data-solvapay-activation-flow-amount-picker": "", children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(AmountPicker.Root, { currency: ctx.currency, children }) });
+};
+var ContinueButton = (0, import_react20.forwardRef)(
+  function ActivationFlowContinueButton({ asChild, onClick, children, ...rest }, forwardedRef) {
+    const ctx = useFlowCtx("ContinueButton");
+    const copy = useCopy();
+    if (ctx.step !== "selectAmount") return null;
+    const disabled = !ctx.amountSelector.resolvedAmount;
+    const commonProps = {
+      "data-solvapay-activation-flow-continue": "",
+      "data-state": disabled ? "disabled" : "idle",
+      disabled,
+      "aria-disabled": disabled || void 0,
+      onClick: composeEventHandlers(onClick, () => {
+        ctx.goToTopupPayment();
+      }),
+      ...rest
+    };
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_jsx_runtime13.Fragment, { children: copy.activationFlow.continueToPayment }) })
+      );
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? copy.activationFlow.continueToPayment });
+  }
+);
+var Retrying = (0, import_react20.forwardRef)(function ActivationFlowRetrying({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Retrying");
+  if (ctx.step !== "retrying") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-retrying": "", ...rest, children });
+});
+var Activated = (0, import_react20.forwardRef)(function ActivationFlowActivated({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Activated");
+  if (ctx.step !== "activated") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-activated": "", ...rest, children });
+});
+var Loading3 = (0, import_react20.forwardRef)(function ActivationFlowLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Loading");
+  if (ctx.plan) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-loading": "", ...rest, children });
+});
+var ErrorSlot3 = (0, import_react20.forwardRef)(function ActivationFlowError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Error");
+  if (ctx.step !== "error") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+    Comp,
+    {
+      ref: forwardedRef,
+      role: "alert",
+      "data-solvapay-activation-flow-error": "",
+      ...rest,
+      children: children ?? ctx.error
+    }
+  );
+});
+var ActivationFlowRoot2 = Root5;
+var ActivationFlowSummary2 = Summary2;
+var ActivationFlowActivateButton2 = ActivateButton;
+var ActivationFlowAmountPicker = AmountPickerMount;
+var ActivationFlowContinueButton2 = ContinueButton;
+var ActivationFlowRetrying2 = Retrying;
+var ActivationFlowActivated2 = Activated;
+var ActivationFlowLoading2 = Loading3;
+var ActivationFlowError2 = ErrorSlot3;
+var ActivationFlow = {
+  Root: Root5,
+  Summary: Summary2,
+  ActivateButton,
+  AmountPicker: AmountPickerMount,
+  ContinueButton,
+  Retrying,
+  Activated,
+  Loading: Loading3,
+  Error: ErrorSlot3
+};
+function useActivationFlow() {
+  return useFlowCtx("useActivationFlow");
+}
+
+// src/primitives/BalanceBadge.tsx
+var import_react21 = require("react");
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var BalanceBadge = (0, import_react21.forwardRef)(function BalanceBadge2({ asChild, numberOnly, lowThreshold = 10, children, ...rest }, forwardedRef) {
+  const solva = (0, import_react21.useContext)(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("BalanceBadge");
+  const { credits, displayCurrency, creditsPerMinorUnit, displayExchangeRate, loading } = useBalance();
+  const copy = useCopy();
+  const locale = useLocale();
+  const state = loading ? "loading" : credits == null || credits === 0 ? "zero" : credits <= lowThreshold ? "low" : "ok";
+  const commonProps = {
+    "data-solvapay-balance-badge": "",
+    "data-state": state,
+    "data-credits": credits == null ? void 0 : String(credits),
+    "aria-busy": loading,
+    ...rest
+  };
+  if (state === "loading") {
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_jsx_runtime14.Fragment, {}) })
+      );
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("span", { ref: forwardedRef, ...commonProps });
+  }
+  if (credits == null) return null;
+  const formattedCredits = new Intl.NumberFormat(locale).format(credits);
+  let currencyEquivalent = "";
+  if (!numberOnly && displayCurrency && creditsPerMinorUnit) {
+    const usdCents = credits / creditsPerMinorUnit;
+    const displayMajorUnits = usdCents * (displayExchangeRate ?? 1) / 100;
+    const formatted = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: displayCurrency,
+      minimumFractionDigits: 2
+    }).format(displayMajorUnits);
+    currencyEquivalent = interpolate(copy.balance.currencyEquivalent, { amount: formatted });
+  }
+  const content = children ?? /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [
+    formattedCredits,
+    !numberOnly && copy.balance.credits,
+    !numberOnly && currencyEquivalent
+  ] });
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(Slot, { ref: forwardedRef, ...commonProps, children: content })
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("span", { ref: forwardedRef, ...commonProps, children: content });
+});
+
+// src/primitives/CancelPlanButton.tsx
+var import_react23 = require("react");
+
+// src/hooks/usePurchaseActions.ts
+var import_react22 = require("react");
+function usePurchaseActions() {
+  const ctx = useSolvaPay();
+  const [isCancelling, setIsCancelling] = (0, import_react22.useState)(false);
+  const [isReactivating, setIsReactivating] = (0, import_react22.useState)(false);
+  const [isActivating, setIsActivating] = (0, import_react22.useState)(false);
+  const cancelRenewal = (0, import_react22.useCallback)(
+    async (params) => {
+      setIsCancelling(true);
+      try {
+        return await ctx.cancelRenewal(params);
+      } finally {
+        setIsCancelling(false);
+      }
+    },
+    [ctx.cancelRenewal]
+  );
+  const reactivateRenewal = (0, import_react22.useCallback)(
+    async (params) => {
+      setIsReactivating(true);
+      try {
+        return await ctx.reactivateRenewal(params);
+      } finally {
+        setIsReactivating(false);
+      }
+    },
+    [ctx.reactivateRenewal]
+  );
+  const activatePlan = (0, import_react22.useCallback)(
+    async (params) => {
+      setIsActivating(true);
+      try {
+        return await ctx.activatePlan(params);
+      } finally {
+        setIsActivating(false);
+      }
+    },
+    [ctx.activatePlan]
+  );
+  return {
+    cancelRenewal,
+    reactivateRenewal,
+    activatePlan,
+    isCancelling,
+    isReactivating,
+    isActivating
+  };
+}
+
+// src/primitives/CancelPlanButton.tsx
+var import_jsx_runtime15 = require("react/jsx-runtime");
+function resolveConfirmText(confirm, purchase, defaults) {
+  if (confirm === false) return null;
+  if (typeof confirm === "string") return confirm;
+  const planType = purchase?.planSnapshot?.planType;
+  if (planType === "usage-based") return defaults.usageBased;
+  return defaults.recurring;
+}
+var CancelPlanButton = (0, import_react23.forwardRef)(
+  function CancelPlanButton2({
+    asChild,
+    purchaseRef,
+    reason,
+    confirm = true,
+    onCancelled,
+    onError,
+    onClick,
+    children,
+    ...rest
+  }, forwardedRef) {
+    const solva = (0, import_react23.useContext)(SolvaPayContext);
+    if (!solva) throw new MissingProviderError("CancelPlanButton");
+    const copy = useCopy();
+    const { activePurchase } = usePurchase();
+    const { cancelRenewal, isCancelling } = usePurchaseActions();
+    const effectivePurchase = purchaseRef ? activePurchase && activePurchase.reference === purchaseRef ? activePurchase : { reference: purchaseRef } : activePurchase;
+    const effectiveRef = purchaseRef ?? effectivePurchase?.reference;
+    const cancel = (0, import_react23.useCallback)(async () => {
+      if (!effectiveRef) return;
+      const confirmText = resolveConfirmText(confirm, effectivePurchase, {
+        recurring: copy.cancelPlan.confirmRecurring,
+        usageBased: copy.cancelPlan.confirmUsageBased
+      });
+      if (confirmText && typeof window !== "undefined" && !window.confirm(confirmText)) {
+        return;
+      }
+      try {
+        await cancelRenewal({ purchaseRef: effectiveRef, reason });
+        onCancelled?.();
+      } catch (err) {
+        onError?.(err instanceof Error ? err : new Error(String(err)));
+      }
+    }, [effectiveRef, effectivePurchase, confirm, copy, cancelRenewal, reason, onCancelled, onError]);
+    const disabled = isCancelling || !effectiveRef;
+    const state = isCancelling ? "cancelling" : "idle";
+    const commonProps = {
+      "data-solvapay-cancel-plan": "",
+      "data-state": state,
+      "aria-busy": isCancelling,
+      "aria-disabled": disabled || void 0,
+      disabled,
+      onClick: composeEventHandlers(onClick, () => {
+        void cancel();
+      }),
+      ...rest
+    };
+    const label = isCancelling ? copy.cancelPlan.buttonLoading : copy.cancelPlan.button;
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_jsx_runtime15.Fragment, { children: label }) })
+      );
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? label });
+  }
+);
+
+// src/primitives/CancelledPlanNotice.tsx
+var import_react25 = require("react");
+
+// src/hooks/usePurchaseStatus.ts
+var import_react24 = require("react");
+function usePurchaseStatus() {
+  const { purchases } = usePurchase();
+  const locale = useLocale();
+  const isPaidPurchase = (0, import_react24.useCallback)((p) => {
+    return (p.amount ?? 0) > 0;
+  }, []);
+  const purchaseData = (0, import_react24.useMemo)(() => {
+    const cancelledPaidPurchases = purchases.filter((p) => {
+      return p.status === "active" && p.cancelledAt && isPaidPurchase(p);
+    });
+    const cancelledPurchase = cancelledPaidPurchases.sort(
+      (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
+    )[0] || null;
+    const shouldShowCancelledNotice = !!cancelledPurchase;
+    return {
+      cancelledPurchase,
+      shouldShowCancelledNotice
+    };
+  }, [purchases, isPaidPurchase]);
+  const formatDate = (0, import_react24.useCallback)(
+    (dateString) => {
+      if (!dateString) return null;
+      return new Date(dateString).toLocaleDateString(locale || "en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+    },
+    [locale]
+  );
+  const getDaysUntilExpiration = (0, import_react24.useCallback)((endDate) => {
+    if (!endDate) return null;
+    const now = /* @__PURE__ */ new Date();
+    const expiration = new Date(endDate);
+    const diffTime = expiration.getTime() - now.getTime();
+    const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+    return diffDays > 0 ? diffDays : 0;
+  }, []);
+  return {
+    cancelledPurchase: purchaseData.cancelledPurchase,
+    shouldShowCancelledNotice: purchaseData.shouldShowCancelledNotice,
+    formatDate,
+    getDaysUntilExpiration
+  };
+}
+
+// src/primitives/CancelledPlanNotice.tsx
+var import_jsx_runtime16 = require("react/jsx-runtime");
+var CancelledPlanNoticeContext = (0, import_react25.createContext)(null);
+function useNoticeCtx(part) {
+  const ctx = (0, import_react25.useContext)(CancelledPlanNoticeContext);
+  if (!ctx) {
+    throw new Error(
+      `CancelledPlanNotice.${part} must be rendered inside <CancelledPlanNotice.Root>.`
+    );
+  }
+  return ctx;
+}
+var Root6 = (0, import_react25.forwardRef)(function CancelledPlanNoticeRoot({ onReactivated, onError, asChild, children, ...rest }, forwardedRef) {
+  const solva = (0, import_react25.useContext)(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("CancelledPlanNotice");
+  const {
+    cancelledPurchase,
+    shouldShowCancelledNotice,
+    formatDate,
+    getDaysUntilExpiration
+  } = usePurchaseStatus();
+  const { reactivateRenewal, isReactivating } = usePurchaseActions();
+  const reactivate = (0, import_react25.useCallback)(async () => {
+    if (!cancelledPurchase) return;
+    try {
+      await reactivateRenewal({ purchaseRef: cancelledPurchase.reference });
+      onReactivated?.();
+    } catch (err) {
+      onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [cancelledPurchase, reactivateRenewal, onReactivated, onError]);
+  const daysRemaining = (0, import_react25.useMemo)(
+    () => cancelledPurchase ? getDaysUntilExpiration(cancelledPurchase.endDate) : null,
+    [cancelledPurchase, getDaysUntilExpiration]
+  );
+  const ctx = (0, import_react25.useMemo)(() => {
+    if (!cancelledPurchase) return null;
+    const state = daysRemaining != null && daysRemaining > 0 ? "active" : "expired";
+    return {
+      purchase: cancelledPurchase,
+      state,
+      daysRemaining,
+      hasReason: !!cancelledPurchase.cancellationReason,
+      formatDate,
+      reactivate,
+      isReactivating
+    };
+  }, [cancelledPurchase, daysRemaining, formatDate, reactivate, isReactivating]);
+  if (!shouldShowCancelledNotice || !ctx) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(CancelledPlanNoticeContext.Provider, { value: ctx, children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-cancelled-notice": "",
+      "data-state": ctx.state,
+      "data-has-reason": ctx.hasReason ? "" : void 0,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Heading2 = (0, import_react25.forwardRef)(function CancelledPlanNoticeHeading({ asChild, children, ...rest }, forwardedRef) {
+  useNoticeCtx("Heading");
+  const copy = useCopy();
+  const Comp = asChild ? Slot : "p";
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-heading": "", ...rest, children: children ?? copy.cancelledNotice.heading });
+});
+var Expires = (0, import_react25.forwardRef)(function CancelledPlanNoticeExpires({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useNoticeCtx("Expires");
+  const copy = useCopy();
+  const date = ctx.formatDate(ctx.purchase.endDate);
+  if (!ctx.purchase.endDate) {
+    const Comp2 = asChild ? Slot : "p";
+    return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Comp2, { ref: forwardedRef, "data-solvapay-cancelled-notice-expires": "", ...rest, children: children ?? copy.cancelledNotice.accessEnded });
+  }
+  const Comp = asChild ? Slot : "p";
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-expires": "", ...rest, children: children ?? interpolate(copy.cancelledNotice.expiresLabel, { date: date ?? "" }) });
+});
+var DaysRemaining = (0, import_react25.forwardRef)(
+  function CancelledPlanNoticeDaysRemaining({ asChild, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("DaysRemaining");
+    const copy = useCopy();
+    if (ctx.daysRemaining == null || ctx.daysRemaining <= 0) return null;
+    const template = ctx.daysRemaining === 1 ? copy.cancelledNotice.dayRemaining : copy.cancelledNotice.daysRemaining;
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-days-remaining": "", ...rest, children: children ?? interpolate(template, { days: ctx.daysRemaining }) });
+  }
+);
+var AccessUntil = (0, import_react25.forwardRef)(
+  function CancelledPlanNoticeAccessUntil({ asChild, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("AccessUntil");
+    const copy = useCopy();
+    if (!ctx.purchase.endDate) return null;
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-access-until": "", ...rest, children: children ?? interpolate(copy.cancelledNotice.accessUntil, {
+      product: ctx.purchase.productName
+    }) });
+  }
+);
+var CancelledOn = (0, import_react25.forwardRef)(
+  function CancelledPlanNoticeCancelledOn({ asChild, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("CancelledOn");
+    const copy = useCopy();
+    if (!ctx.purchase.cancelledAt) return null;
+    const date = ctx.formatDate(ctx.purchase.cancelledAt);
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-cancelled-on": "", ...rest, children: children ?? interpolate(copy.cancelledNotice.cancelledOn, { date: date ?? "" }) });
+  }
+);
+var Reason = (0, import_react25.forwardRef)(function CancelledPlanNoticeReason({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useNoticeCtx("Reason");
+  if (!ctx.hasReason) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-reason": "", ...rest, children: children ?? ctx.purchase.cancellationReason });
+});
+var ReactivateButton = (0, import_react25.forwardRef)(
+  function CancelledPlanNoticeReactivateButton({ asChild, onClick, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("ReactivateButton");
+    const copy = useCopy();
+    const disabled = ctx.isReactivating;
+    const commonProps = {
+      "data-solvapay-cancelled-notice-reactivate": "",
+      "data-state": ctx.isReactivating ? "reactivating" : "idle",
+      "aria-busy": ctx.isReactivating,
+      "aria-disabled": disabled || void 0,
+      disabled,
+      onClick: composeEventHandlers(onClick, () => {
+        void ctx.reactivate();
+      }),
+      ...rest
+    };
+    const label = ctx.isReactivating ? copy.cancelledNotice.reactivateButtonLoading : copy.cancelledNotice.reactivateButton;
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_jsx_runtime16.Fragment, { children: label }) })
+      );
+    }
+    return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? label });
+  }
+);
+var CancelledPlanNoticeRoot2 = Root6;
+var CancelledPlanNoticeHeading2 = Heading2;
+var CancelledPlanNoticeExpires2 = Expires;
+var CancelledPlanNoticeDaysRemaining2 = DaysRemaining;
+var CancelledPlanNoticeAccessUntil2 = AccessUntil;
+var CancelledPlanNoticeCancelledOn2 = CancelledOn;
+var CancelledPlanNoticeReason2 = Reason;
+var CancelledPlanNoticeReactivateButton2 = ReactivateButton;
+var CancelledPlanNotice = {
+  Root: Root6,
+  Heading: Heading2,
+  Expires,
+  DaysRemaining,
+  AccessUntil,
+  CancelledOn,
+  Reason,
+  ReactivateButton
+};
+function useCancelledPlanNotice() {
+  return useNoticeCtx("useCancelledPlanNotice");
+}
+
+// src/primitives/CreditGate.tsx
+var import_react28 = require("react");
+
+// src/primitives/TopupForm.tsx
+var import_react27 = require("react");
+var import_react_stripe_js2 = require("@stripe/react-stripe-js");
+
+// src/hooks/useTopup.ts
+var import_react26 = require("react");
+var import_stripe_js2 = require("@stripe/stripe-js");
+var stripePromiseCache2 = /* @__PURE__ */ new Map();
+function getStripeCacheKey2(publishableKey, accountId) {
+  return accountId ? `${publishableKey}:${accountId}` : publishableKey;
+}
+function useTopup(options) {
+  const { amount, currency } = options;
+  const { createTopupPayment, customerRef, updateCustomerRef } = useSolvaPay();
+  const [loading, setLoading] = (0, import_react26.useState)(false);
+  const [error, setError] = (0, import_react26.useState)(null);
+  const [stripePromise, setStripePromise] = (0, import_react26.useState)(null);
+  const [clientSecret, setClientSecret] = (0, import_react26.useState)(null);
+  const isStartingRef = (0, import_react26.useRef)(false);
+  const startTopup = (0, import_react26.useCallback)(async () => {
+    if (isStartingRef.current || loading) {
+      return;
+    }
+    if (!amount || amount <= 0) {
+      setError(new Error("useTopup: amount must be a positive number"));
+      return;
+    }
+    isStartingRef.current = true;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await createTopupPayment({ amount, currency });
+      if (!result || typeof result !== "object") {
+        throw new Error("Invalid topup payment intent response from server");
+      }
+      if (!result.clientSecret || typeof result.clientSecret !== "string") {
+        throw new Error("Invalid client secret in topup payment intent response");
+      }
+      if (!result.publishableKey || typeof result.publishableKey !== "string") {
+        throw new Error("Invalid publishable key in topup payment intent response");
+      }
+      if (result.customerRef && result.customerRef !== customerRef && updateCustomerRef) {
+        updateCustomerRef(result.customerRef);
+      }
+      const stripeOptions = result.accountId ? { stripeAccount: result.accountId } : {};
+      const cacheKey = getStripeCacheKey2(result.publishableKey, result.accountId);
+      let stripe = stripePromiseCache2.get(cacheKey);
+      if (!stripe) {
+        stripe = (0, import_stripe_js2.loadStripe)(result.publishableKey, stripeOptions);
+        stripePromiseCache2.set(cacheKey, stripe);
+      }
+      setStripePromise(stripe);
+      setClientSecret(result.clientSecret);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to start topup");
+      setError(error2);
+    } finally {
+      setLoading(false);
+      isStartingRef.current = false;
+    }
+  }, [amount, currency, createTopupPayment, customerRef, updateCustomerRef, loading]);
+  const reset = (0, import_react26.useCallback)(() => {
+    isStartingRef.current = false;
+    setLoading(false);
+    setError(null);
+    setStripePromise(null);
+    setClientSecret(null);
+  }, []);
+  return {
+    loading,
+    error,
+    stripePromise,
+    clientSecret,
+    startTopup,
+    reset
+  };
+}
+
+// src/primitives/TopupForm.tsx
+var import_jsx_runtime17 = require("react/jsx-runtime");
+var TopupFormContext = (0, import_react27.createContext)(null);
+function useTopupCtx(part) {
+  const ctx = (0, import_react27.useContext)(TopupFormContext);
+  if (!ctx) {
+    throw new Error(`TopupForm.${part} must be rendered inside <TopupForm.Root>.`);
+  }
+  return ctx;
+}
+var Root7 = (0, import_react27.forwardRef)(function TopupFormRoot(props, forwardedRef) {
+  const {
+    amount,
+    currency,
+    onSuccess,
+    onError,
+    returnUrl,
+    submitButtonText: _submitButtonText,
+    buttonClassName: _buttonClassName,
+    className,
+    asChild,
+    children,
+    ...rest
+  } = props;
+  const solva = (0, import_react27.useContext)(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("TopupForm");
+  const copy = useCopy();
+  const locale = useLocale();
+  const { loading, error: topupError, clientSecret, startTopup, stripePromise } = useTopup({
+    amount,
+    currency
+  });
+  const hasInitializedRef = (0, import_react27.useRef)(false);
+  const hasAmount = amount > 0;
+  (0, import_react27.useEffect)(() => {
+    if (!hasInitializedRef.current && hasAmount && !loading && !topupError && !clientSecret) {
+      hasInitializedRef.current = true;
+      startTopup().catch(() => {
+        hasInitializedRef.current = false;
+      });
+    }
+    if (hasAmount && clientSecret) hasInitializedRef.current = true;
+  }, [hasAmount, loading, topupError, clientSecret, startTopup]);
+  const finalReturnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
+  const elementsOptions = (0, import_react27.useMemo)(() => {
+    if (!clientSecret) return void 0;
+    return { clientSecret, locale };
+  }, [clientSecret, locale]);
+  const Comp = asChild ? Slot : "div";
+  const outerError = !hasAmount ? copy.errors.configMissingAmount : topupError ? `${copy.errors.topupInitFailed} ${topupError.message || copy.errors.unknownError}` : null;
+  const dataState = outerError ? "error" : clientSecret && stripePromise ? "ready" : "loading";
+  const canMountElements = !!(stripePromise && clientSecret && elementsOptions);
+  const innerCommon = {
+    amount,
+    currency,
+    clientSecret,
+    returnUrl: finalReturnUrl,
+    outerError,
+    state: dataState,
+    onSuccess,
+    onError
+  };
+  const shell = /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+    Comp,
+    {
+      ref: forwardedRef,
+      className,
+      "data-solvapay-topup-form": "",
+      "data-state": dataState,
+      ...rest,
+      children
+    }
+  );
+  if (canMountElements) {
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_react_stripe_js2.Elements, { stripe: stripePromise, options: elementsOptions, children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Inner, { ...innerCommon, children: shell }) }, clientSecret);
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(OfflineInner, { ...innerCommon, children: shell });
+});
+var Inner = ({
+  amount,
+  currency,
+  clientSecret,
+  returnUrl,
+  outerError,
+  state,
+  onSuccess,
+  onError,
+  children
+}) => {
+  const stripe = (0, import_react_stripe_js2.useStripe)();
+  const elements = (0, import_react_stripe_js2.useElements)();
+  const copy = useCopy();
+  const [paymentInputComplete, setPaymentInputComplete] = (0, import_react27.useState)(false);
+  const [isProcessing, setIsProcessing] = (0, import_react27.useState)(false);
+  const [error, setError] = (0, import_react27.useState)(null);
+  const isReady = !!(stripe && elements);
+  const canSubmit = isReady && paymentInputComplete && !isProcessing && !!clientSecret;
+  const submit = (0, import_react27.useCallback)(async () => {
+    if (!stripe || !elements || !clientSecret) {
+      const msg = copy.errors.stripeUnavailable;
+      setError(msg);
+      onError?.(new Error(msg));
+      return;
+    }
+    setError(null);
+    setIsProcessing(true);
+    const { error: confirmError, paymentIntent } = await stripe.confirmPayment({
+      elements,
+      clientSecret,
+      confirmParams: { return_url: returnUrl },
+      redirect: "if_required"
+    });
+    if (confirmError) {
+      const msg = confirmError.message || copy.errors.paymentUnexpected;
+      setError(msg);
+      setIsProcessing(false);
+      onError?.(new Error(msg));
+      return;
+    }
+    setIsProcessing(false);
+    if (paymentIntent) {
+      await onSuccess?.(paymentIntent);
+    }
+  }, [stripe, elements, clientSecret, returnUrl, copy, onSuccess, onError]);
+  const effectiveError = error ?? outerError;
+  const ctx = (0, import_react27.useMemo)(
+    () => ({
+      amount,
+      currency,
+      state,
+      clientSecret,
+      stripe: stripe ?? null,
+      elements: elements ?? null,
+      isReady,
+      isProcessing,
+      paymentInputComplete,
+      canSubmit,
+      error: effectiveError,
+      returnUrl,
+      setPaymentInputComplete,
+      submit
+    }),
+    [
+      amount,
+      currency,
+      state,
+      clientSecret,
+      stripe,
+      elements,
+      isReady,
+      isProcessing,
+      paymentInputComplete,
+      canSubmit,
+      effectiveError,
+      returnUrl,
+      submit
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(TopupFormContext.Provider, { value: ctx, children });
+};
+var OfflineInner = ({
+  amount,
+  currency,
+  clientSecret,
+  returnUrl,
+  outerError,
+  state,
+  children
+}) => {
+  const noopSubmit = (0, import_react27.useCallback)(async () => {
+  }, []);
+  const noopSet = (0, import_react27.useCallback)(() => {
+  }, []);
+  const ctx = (0, import_react27.useMemo)(
+    () => ({
+      amount,
+      currency,
+      state,
+      clientSecret,
+      stripe: null,
+      elements: null,
+      isReady: false,
+      isProcessing: false,
+      paymentInputComplete: false,
+      canSubmit: false,
+      error: outerError,
+      returnUrl,
+      setPaymentInputComplete: noopSet,
+      submit: noopSubmit
+    }),
+    [amount, currency, state, clientSecret, outerError, returnUrl, noopSet, noopSubmit]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(TopupFormContext.Provider, { value: ctx, children });
+};
+var PaymentElementSlot2 = ({ options }) => {
+  const { setPaymentInputComplete, isReady, stripe, elements } = useTopupCtx("PaymentElement");
+  const locale = useLocale();
+  if (!stripe || !elements) return null;
+  if (!isReady) {
+    return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { "data-solvapay-topup-form-loading": "", children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Spinner, { size: "sm" }) });
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("div", { "data-solvapay-topup-form-payment-element": "", children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+    import_react_stripe_js2.PaymentElement,
+    {
+      options,
+      onChange: (e) => setPaymentInputComplete(e.complete)
+    },
+    locale || "default"
+  ) });
+};
+var SubmitButton2 = (0, import_react27.forwardRef)(function TopupFormSubmitButton({ asChild, onClick, children, ...rest }, forwardedRef) {
+  const ctx = useTopupCtx("SubmitButton");
+  const copy = useCopy();
+  const dataState = ctx.isProcessing ? "processing" : !ctx.canSubmit ? "disabled" : "idle";
+  const content = ctx.isProcessing ? /* @__PURE__ */ (0, import_jsx_runtime17.jsxs)(import_jsx_runtime17.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Spinner, { size: "sm" }),
+    /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("span", { children: copy.cta.processing })
+  ] }) : children ? children : copy.cta.topUp;
+  const commonProps = {
+    "data-solvapay-topup-form-submit": "",
+    "data-state": dataState,
+    "aria-busy": ctx.isProcessing,
+    "aria-disabled": !ctx.canSubmit,
+    disabled: !ctx.canSubmit,
+    onClick: composeEventHandlers(onClick, (e) => {
+      e.preventDefault();
+      void ctx.submit();
+    }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Slot, { ref: forwardedRef, ...commonProps, children: content })
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("button", { ref: forwardedRef, type: "submit", ...commonProps, children: content });
+});
+var Loading4 = (0, import_react27.forwardRef)(function TopupFormLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useTopupCtx("Loading");
+  if (ctx.state !== "loading") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Comp, { ref: forwardedRef, "data-solvapay-topup-form-loading": "", ...rest, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Spinner, { size: "sm" }) });
+});
+var ErrorSlot4 = (0, import_react27.forwardRef)(function TopupFormError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useTopupCtx("Error");
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(
+    Comp,
+    {
+      ref: forwardedRef,
+      role: "alert",
+      "aria-live": "assertive",
+      "aria-atomic": "true",
+      "data-solvapay-topup-form-error": "",
+      ...rest,
+      children: children ?? ctx.error
+    }
+  );
+});
+var TopupFormRoot2 = Root7;
+var TopupFormPaymentElement = PaymentElementSlot2;
+var TopupFormSubmitButton2 = SubmitButton2;
+var TopupFormLoading2 = Loading4;
+var TopupFormError2 = ErrorSlot4;
+var TopupForm = {
+  Root: Root7,
+  AmountPicker: AmountPicker.Root,
+  PaymentElement: PaymentElementSlot2,
+  SubmitButton: SubmitButton2,
+  Loading: Loading4,
+  Error: ErrorSlot4
+};
+function useTopupForm() {
+  return useTopupCtx("useTopupForm");
+}
+
+// src/TopupForm.tsx
+var import_jsx_runtime18 = require("react/jsx-runtime");
+var TopupForm2 = (props) => {
+  const { className, buttonClassName, submitButtonText, ...rootProps } = props;
+  const rootClass = ["solvapay-topup-form", className].filter(Boolean).join(" ");
+  const buttonClass = ["solvapay-topup-form-submit", buttonClassName].filter(Boolean).join(" ");
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsxs)(TopupForm.Root, { ...rootProps, className: rootClass, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(TopupForm.PaymentElement, {}),
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(TopupForm.Error, { className: "solvapay-topup-form-error" }),
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(TopupForm.Loading, { className: "solvapay-topup-form-loading" }),
+    /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(TopupForm.SubmitButton, { className: buttonClass, children: submitButtonText })
+  ] });
+};
+
+// src/primitives/CreditGate.tsx
+var import_jsx_runtime19 = require("react/jsx-runtime");
+var CreditGateContext = (0, import_react28.createContext)(null);
+function useGateCtx(part) {
+  const ctx = (0, import_react28.useContext)(CreditGateContext);
+  if (!ctx) {
+    throw new Error(`CreditGate.${part} must be rendered inside <CreditGate.Root>.`);
+  }
+  return ctx;
+}
+var Root8 = (0, import_react28.forwardRef)(function CreditGateRoot({
+  minCredits = 1,
+  productRef,
+  topupAmount = 1e3,
+  topupCurrency = "usd",
+  asChild,
+  children,
+  ...rest
+}, forwardedRef) {
+  const solva = (0, import_react28.useContext)(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("CreditGate");
+  const { credits, loading } = useBalance();
+  const { product } = useProduct(productRef);
+  const hasCredits = credits != null && credits >= minCredits;
+  const state = loading && credits == null ? "loading" : hasCredits ? "allowed" : "blocked";
+  const ctx = (0, import_react28.useMemo)(
+    () => ({
+      state,
+      loading,
+      hasCredits,
+      balance: credits,
+      productName: product?.name ?? null,
+      topupAmount,
+      topupCurrency
+    }),
+    [state, loading, hasCredits, credits, product?.name, topupAmount, topupCurrency]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(CreditGateContext.Provider, { value: ctx, children: /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-credit-gate": "",
+      "data-state": state,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Heading3 = (0, import_react28.forwardRef)(function CreditGateHeading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Heading");
+  const copy = useCopy();
+  if (ctx.state !== "blocked") return null;
+  const Comp = asChild ? Slot : "h3";
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-heading": "", ...rest, children: children ?? copy.creditGate.lowBalanceHeading });
+});
+var Subheading = (0, import_react28.forwardRef)(function CreditGateSubheading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Subheading");
+  const copy = useCopy();
+  if (ctx.state !== "blocked") return null;
+  const text = interpolate(copy.creditGate.lowBalanceSubheading, {
+    product: ctx.productName ?? "this product"
+  });
+  const Comp = asChild ? Slot : "p";
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-subheading": "", ...rest, children: children ?? text });
+});
+var Topup = ({ amount, currency }) => {
+  const ctx = useGateCtx("Topup");
+  if (ctx.state !== "blocked") return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(
+    TopupForm2,
+    {
+      amount: amount ?? ctx.topupAmount,
+      currency: currency ?? ctx.topupCurrency
+    }
+  );
+};
+var Loading5 = (0, import_react28.forwardRef)(function CreditGateLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Loading");
+  if (ctx.state !== "loading") return null;
+  const Comp = asChild ? Slot : "div";
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-loading": "", ...rest, children })
+  );
+});
+var ErrorSlot5 = (0, import_react28.forwardRef)(function CreditGateError({ asChild, children, ...rest }, forwardedRef) {
+  if (!children) return null;
+  const Comp = asChild ? Slot : "div";
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    /* @__PURE__ */ (0, import_jsx_runtime19.jsx)(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-error": "", role: "alert", ...rest, children })
+  );
+});
+var CreditGateRoot2 = Root8;
+var CreditGateHeading2 = Heading3;
+var CreditGateSubheading2 = Subheading;
+var CreditGateTopup = Topup;
+var CreditGateLoading2 = Loading5;
+var CreditGateError2 = ErrorSlot5;
+var CreditGate = {
+  Root: Root8,
+  Heading: Heading3,
+  Subheading,
+  Topup,
+  Loading: Loading5,
+  Error: ErrorSlot5
+};
+function useCreditGate() {
+  return useGateCtx("useCreditGate");
+}
+
+// src/primitives/PurchaseGate.tsx
+var import_react29 = require("react");
+var import_jsx_runtime20 = require("react/jsx-runtime");
+var PurchaseGateContext = (0, import_react29.createContext)(null);
+function useGateCtx2(part) {
+  const ctx = (0, import_react29.useContext)(PurchaseGateContext);
+  if (!ctx) {
+    throw new Error(`PurchaseGate.${part} must be rendered inside <PurchaseGate.Root>.`);
+  }
+  return ctx;
+}
+var Root9 = (0, import_react29.forwardRef)(function PurchaseGateRoot({ requirePlan, requireProduct, asChild, children, ...rest }, forwardedRef) {
+  const solva = (0, import_react29.useContext)(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("PurchaseGate");
+  const { purchases, loading, hasProduct, error } = usePurchase();
+  const productToCheck = requireProduct || requirePlan;
+  const hasAccess = productToCheck ? hasProduct(productToCheck) : purchases.some((p) => p.status === "active");
+  const state = loading ? "loading" : hasAccess ? "allowed" : "blocked";
+  const ctx = (0, import_react29.useMemo)(
+    () => ({ state, loading, hasAccess, error }),
+    [state, loading, hasAccess, error]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(PurchaseGateContext.Provider, { value: ctx, children: /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-purchase-gate": "",
+      "data-state": state,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Allowed = (0, import_react29.forwardRef)(function PurchaseGateAllowed({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx2("Allowed");
+  if (ctx.state !== "allowed") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-allowed": "", ...rest, children });
+});
+var Blocked = (0, import_react29.forwardRef)(function PurchaseGateBlocked({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx2("Blocked");
+  if (ctx.state !== "blocked") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-blocked": "", ...rest, children });
+});
+var Loading6 = (0, import_react29.forwardRef)(function PurchaseGateLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx2("Loading");
+  if (ctx.state !== "loading") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-loading": "", ...rest, children });
+});
+var ErrorSlot6 = (0, import_react29.forwardRef)(function PurchaseGateError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx2("Error");
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ (0, import_jsx_runtime20.jsx)(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-error": "", role: "alert", ...rest, children: children ?? ctx.error.message });
+});
+var PurchaseGateRoot2 = Root9;
+var PurchaseGateAllowed2 = Allowed;
+var PurchaseGateBlocked2 = Blocked;
+var PurchaseGateLoading2 = Loading6;
+var PurchaseGateError2 = ErrorSlot6;
+var PurchaseGate = {
+  Root: Root9,
+  Allowed,
+  Blocked,
+  Loading: Loading6,
+  Error: ErrorSlot6
+};
+function usePurchaseGate() {
+  return useGateCtx2("usePurchaseGate");
+}
+
+// src/primitives/ProductBadge.tsx
+var import_react30 = require("react");
+var import_jsx_runtime21 = require("react/jsx-runtime");
+var ProductBadgeImpl = (0, import_react30.forwardRef)(function ProductBadge({ asChild, children, ...rest }, forwardedRef) {
+  const solva = (0, import_react30.useContext)(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("ProductBadge");
+  const { purchases, loading, hasPaidPurchase, activePurchase } = usePurchase();
+  const copy = useCopy();
+  const [hasLoadedOnce, setHasLoadedOnce] = (0, import_react30.useState)(false);
+  (0, import_react30.useEffect)(() => {
+    if (!loading) setHasLoadedOnce(true);
+  }, [loading]);
+  const planToDisplay = activePurchase?.productName ?? null;
+  const shouldShow = planToDisplay !== null && (!loading || hasLoadedOnce);
+  if (!shouldShow) return null;
+  const commonProps = {
+    "data-solvapay-product-badge": "",
+    "data-loading": loading ? "" : void 0,
+    "data-has-purchase": activePurchase ? "" : void 0,
+    "data-has-paid-purchase": hasPaidPurchase ? "" : void 0,
+    role: "status",
+    "aria-live": "polite",
+    "aria-busy": loading,
+    "aria-label": interpolate(copy.product.currentProductLabel, { name: planToDisplay }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ (0, import_jsx_runtime21.jsx)(import_jsx_runtime21.Fragment, { children: planToDisplay }) })
+    );
+  }
+  void purchases;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    /* @__PURE__ */ (0, import_jsx_runtime21.jsx)("div", { ref: forwardedRef, ...commonProps, children: children ?? planToDisplay })
+  );
+});
+var ProductBadge2 = ProductBadgeImpl;
+var PlanBadge = ProductBadgeImpl;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActivationFlow,
+  ActivationFlowActivateButton,
+  ActivationFlowActivated,
+  ActivationFlowAmountPicker,
+  ActivationFlowContinueButton,
+  ActivationFlowError,
+  ActivationFlowLoading,
+  ActivationFlowRetrying,
+  ActivationFlowRoot,
+  ActivationFlowSummary,
+  AmountPicker,
+  AmountPickerConfirm,
+  AmountPickerCustom,
+  AmountPickerOption,
+  AmountPickerRoot,
+  BalanceBadge,
+  CancelPlanButton,
+  CancelledPlanNotice,
+  CancelledPlanNoticeAccessUntil,
+  CancelledPlanNoticeCancelledOn,
+  CancelledPlanNoticeDaysRemaining,
+  CancelledPlanNoticeExpires,
+  CancelledPlanNoticeHeading,
+  CancelledPlanNoticeReactivateButton,
+  CancelledPlanNoticeReason,
+  CancelledPlanNoticeRoot,
+  CheckoutSummary,
+  CheckoutSummaryPlan,
+  CheckoutSummaryPrice,
+  CheckoutSummaryProduct,
+  CheckoutSummaryRoot,
+  CheckoutSummaryTaxNote,
+  CheckoutSummaryTrial,
+  CreditGate,
+  CreditGateError,
+  CreditGateHeading,
+  CreditGateLoading,
+  CreditGateRoot,
+  CreditGateSubheading,
+  CreditGateTopup,
+  MandateText,
+  PaymentForm,
+  PaymentFormCardElement,
+  PaymentFormCustomerFields,
+  PaymentFormError,
+  PaymentFormLoading,
+  PaymentFormMandateText,
+  PaymentFormPaymentElement,
+  PaymentFormRoot,
+  PaymentFormSubmitButton,
+  PaymentFormSummary,
+  PaymentFormTermsCheckbox,
+  PlanBadge,
+  PlanSelector,
+  PlanSelectorCard,
+  PlanSelectorCardBadge,
+  PlanSelectorCardInterval,
+  PlanSelectorCardName,
+  PlanSelectorCardPrice,
+  PlanSelectorError,
+  PlanSelectorGrid,
+  PlanSelectorHeading,
+  PlanSelectorLoading,
+  PlanSelectorRoot,
+  ProductBadge,
+  PurchaseGate,
+  PurchaseGateAllowed,
+  PurchaseGateBlocked,
+  PurchaseGateError,
+  PurchaseGateLoading,
+  PurchaseGateRoot,
+  Slot,
+  Slottable,
+  TopupForm,
+  TopupFormError,
+  TopupFormLoading,
+  TopupFormPaymentElement,
+  TopupFormRoot,
+  TopupFormSubmitButton,
+  composeEventHandlers,
+  composeRefs,
+  setRef,
+  useActivationFlow,
+  useAmountPicker,
+  useAmountPickerCopy,
+  useCancelledPlanNotice,
+  useCheckoutSummary,
+  useCreditGate,
+  usePlanSelector,
+  usePurchaseGate,
+  useTopupForm
+});