@solvapay/react 1.3.0 → 1.4.0-preview-ecd61384a4e849717e13d47ab2daa086cdcd91c5

package/dist/chunk-GFWMLRR3.js

@@ -0,0 +1,3224 @@
+import {
+  AmountPicker,
+  MandateText,
+  MissingProductRefError,
+  MissingProviderError,
+  PaymentForm,
+  PlanSelector,
+  Slot,
+  SolvaPayContext,
+  Spinner,
+  TopupForm,
+  buildDefaultCheckoutPlanFilter,
+  composeEventHandlers,
+  createHttpTransport,
+  createTransportCacheKey,
+  formatContinueLabel,
+  formatPrice,
+  getMinorUnitsPerMajor,
+  interpolate,
+  isPaygPlan,
+  planSortByPaygFirstThenAsc,
+  shortCycle,
+  useActivation,
+  useAmountPicker,
+  useAmountPickerCopy,
+  useBalance,
+  useCheckoutFlow,
+  useCopy,
+  useLocale,
+  usePlan,
+  usePlanSelection,
+  usePlans,
+  useProduct,
+  usePurchase,
+  useSolvaPay,
+  useTopupAmountSelector,
+  withPaymentElementDefaults
+} from "./chunk-6RR4J74H.js";
+
+// src/TopupForm.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var TopupForm2 = (props) => {
+  const { className, buttonClassName, submitButtonText, ...rootProps } = props;
+  const rootClass = ["solvapay-topup-form", className].filter(Boolean).join(" ");
+  const buttonClass = ["solvapay-topup-form-submit", buttonClassName].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs(TopupForm.Root, { ...rootProps, className: rootClass, children: [
+    /* @__PURE__ */ jsx(TopupForm.PaymentElement, {}),
+    /* @__PURE__ */ jsx(TopupForm.Error, { className: "solvapay-topup-form-error" }),
+    /* @__PURE__ */ jsx(TopupForm.Loading, { className: "solvapay-topup-form-loading" }),
+    /* @__PURE__ */ jsx(TopupForm.SubmitButton, { className: buttonClass, children: submitButtonText })
+  ] });
+};
+
+// src/primitives/ProductBadge.tsx
+import { forwardRef, useContext, useEffect, useState } from "react";
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+var ProductBadgeImpl = forwardRef(function ProductBadge({ asChild, children, ...rest }, forwardedRef) {
+  const solva = useContext(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("ProductBadge");
+  const { purchases, loading, hasPaidPurchase, activePurchase } = usePurchase();
+  const copy = useCopy();
+  const [hasLoadedOnce, setHasLoadedOnce] = useState(false);
+  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__ */ jsx2(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx2(Fragment, { children: planToDisplay }) })
+    );
+  }
+  void purchases;
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    /* @__PURE__ */ jsx2("div", { ref: forwardedRef, ...commonProps, children: children ?? planToDisplay })
+  );
+});
+var ProductBadge2 = ProductBadgeImpl;
+var PlanBadge = ProductBadgeImpl;
+
+// src/primitives/PurchaseGate.tsx
+import {
+  createContext,
+  forwardRef as forwardRef2,
+  useContext as useContext2,
+  useMemo
+} from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var PurchaseGateContext = createContext(null);
+function useGateCtx(part) {
+  const ctx = useContext2(PurchaseGateContext);
+  if (!ctx) {
+    throw new Error(`PurchaseGate.${part} must be rendered inside <PurchaseGate.Root>.`);
+  }
+  return ctx;
+}
+var Root = forwardRef2(function PurchaseGateRoot({ requirePlan, requireProduct, asChild, children, ...rest }, forwardedRef) {
+  const solva = useContext2(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 = useMemo(
+    () => ({ state, loading, hasAccess, error }),
+    [state, loading, hasAccess, error]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx3(PurchaseGateContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx3(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-purchase-gate": "",
+      "data-state": state,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Allowed = forwardRef2(function PurchaseGateAllowed({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Allowed");
+  if (ctx.state !== "allowed") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx3(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-allowed": "", ...rest, children });
+});
+var Blocked = forwardRef2(function PurchaseGateBlocked({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Blocked");
+  if (ctx.state !== "blocked") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx3(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-blocked": "", ...rest, children });
+});
+var Loading = forwardRef2(function PurchaseGateLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Loading");
+  if (ctx.state !== "loading") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx3(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-loading": "", ...rest, children });
+});
+var ErrorSlot = forwardRef2(function PurchaseGateError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx("Error");
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx3(Comp, { ref: forwardedRef, "data-solvapay-purchase-gate-error": "", role: "alert", ...rest, children: children ?? ctx.error.message });
+});
+var PurchaseGateRoot2 = Root;
+var PurchaseGateAllowed2 = Allowed;
+var PurchaseGateBlocked2 = Blocked;
+var PurchaseGateLoading2 = Loading;
+var PurchaseGateError2 = ErrorSlot;
+var PurchaseGate = {
+  Root,
+  Allowed,
+  Blocked,
+  Loading,
+  Error: ErrorSlot
+};
+function usePurchaseGate() {
+  return useGateCtx("usePurchaseGate");
+}
+
+// src/primitives/ActivationFlow.tsx
+import {
+  createContext as createContext2,
+  forwardRef as forwardRef3,
+  useCallback,
+  useContext as useContext3,
+  useEffect as useEffect2,
+  useMemo as useMemo2,
+  useRef,
+  useState as useState2
+} from "react";
+import { Fragment as Fragment2, jsx as jsx4 } from "react/jsx-runtime";
+var ActivationFlowContext = createContext2(null);
+function useFlowCtx(part) {
+  const ctx = useContext3(ActivationFlowContext);
+  if (!ctx) {
+    throw new Error(`ActivationFlow.${part} must be rendered inside <ActivationFlow.Root>.`);
+  }
+  return ctx;
+}
+var Root2 = forwardRef3(function ActivationFlowRoot({
+  productRef,
+  planRef: planRefProp,
+  onSuccess,
+  onError,
+  retryDelayMs = 1500,
+  retryBackoffMs = 2e3,
+  asChild,
+  children,
+  ...rest
+}, forwardedRef) {
+  const solva = useContext3(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] = useState2("summary");
+  const calledSuccessRef = useRef(false);
+  const retryTimeoutRef = useRef(null);
+  useEffect2(() => {
+    if (state === "activated" && !calledSuccessRef.current) {
+      calledSuccessRef.current = true;
+      setStep("activated");
+      if (result) {
+        const activationResult = { kind: "activated", result };
+        onSuccess?.(activationResult);
+      }
+    }
+  }, [state, result, onSuccess]);
+  useEffect2(() => {
+    if (state === "topup_required" && (step === "summary" || step === "activating")) {
+      setStep("selectAmount");
+    }
+  }, [state, step]);
+  useEffect2(() => {
+    if ((state === "error" || state === "payment_required") && error) {
+      setStep("error");
+      if (state === "error") onError?.(new Error(error));
+    }
+  }, [state, error, onError]);
+  const handleActivate = useCallback(async () => {
+    if (!resolvedPlanRef) return;
+    setStep("activating");
+    await activate({ productRef, planRef: resolvedPlanRef });
+  }, [activate, productRef, resolvedPlanRef]);
+  const goToTopupPayment = useCallback(() => {
+    if (amountSelector.validate()) setStep("topupPayment");
+  }, [amountSelector]);
+  const backToSelectAmount = useCallback(() => {
+    setStep("selectAmount");
+  }, []);
+  const retryActivation = useCallback(async () => {
+    if (!resolvedPlanRef) return;
+    setStep("retrying");
+    const amountMinor2 = Math.round(
+      (amountSelector.resolvedAmount || 0) * getMinorUnitsPerMajor(currency)
+    );
+    const rate = displayExchangeRate ?? 1;
+    if (creditsPerMinorUnit) {
+      adjustBalance(Math.floor(amountMinor2 / rate * creditsPerMinorUnit));
+    }
+    await new Promise((r) => setTimeout(r, retryDelayMs));
+    await activate({ productRef, planRef: resolvedPlanRef });
+  }, [
+    resolvedPlanRef,
+    amountSelector.resolvedAmount,
+    currency,
+    displayExchangeRate,
+    creditsPerMinorUnit,
+    adjustBalance,
+    retryDelayMs,
+    activate,
+    productRef
+  ]);
+  const handleTopupSuccess = useCallback(async () => {
+    await retryActivation();
+  }, [retryActivation]);
+  useEffect2(() => {
+    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 = useCallback(() => {
+    reset();
+    calledSuccessRef.current = false;
+    setStep("summary");
+  }, [reset]);
+  const amountMinor = Math.round(
+    (amountSelector.resolvedAmount || 0) * getMinorUnitsPerMajor(currency)
+  );
+  const ctx = useMemo2(
+    () => ({
+      step,
+      plan,
+      productRef,
+      planRef: resolvedPlanRef ?? "",
+      amountSelector,
+      amountMinor,
+      // Deprecated alias — same value as amountMinor so legacy consumers
+      // keep working after the zero-decimal fix (previously this was
+      // `resolvedAmount * 100`, which over-billed JPY/KRW by 100x).
+      amountCents: amountMinor,
+      currency,
+      activate: handleActivate,
+      reset: resetFlow,
+      goToTopupPayment,
+      backToSelectAmount,
+      onTopupSuccess: handleTopupSuccess,
+      error,
+      onError
+    }),
+    [
+      step,
+      plan,
+      productRef,
+      resolvedPlanRef,
+      amountSelector,
+      amountMinor,
+      currency,
+      handleActivate,
+      resetFlow,
+      goToTopupPayment,
+      backToSelectAmount,
+      handleTopupSuccess,
+      error,
+      onError
+    ]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx4(ActivationFlowContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx4(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-activation-flow": "",
+      "data-state": step,
+      ...rest,
+      children
+    }
+  ) });
+});
+function matchStep(step, allowed) {
+  return allowed.includes(step);
+}
+var Summary = forwardRef3(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__ */ jsx4(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-summary": "", ...rest, children });
+});
+var ActivateButton = forwardRef3(
+  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__ */ jsx4(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx4(Fragment2, { children: label }) })
+      );
+    }
+    return /* @__PURE__ */ jsx4("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? label });
+  }
+);
+var AmountPickerMount = ({ children }) => {
+  const ctx = useFlowCtx("AmountPicker");
+  if (ctx.step !== "selectAmount") return null;
+  return /* @__PURE__ */ jsx4("div", { "data-solvapay-activation-flow-amount-picker": "", children: /* @__PURE__ */ jsx4(AmountPicker.Root, { currency: ctx.currency, selector: ctx.amountSelector, children }) });
+};
+var ContinueButton = forwardRef3(
+  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__ */ jsx4(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx4(Fragment2, { children: copy.activationFlow.continueToPayment }) })
+      );
+    }
+    return /* @__PURE__ */ jsx4("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? copy.activationFlow.continueToPayment });
+  }
+);
+var Retrying = forwardRef3(function ActivationFlowRetrying({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Retrying");
+  if (ctx.step !== "retrying") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx4(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-retrying": "", ...rest, children });
+});
+var Activated = forwardRef3(function ActivationFlowActivated({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Activated");
+  if (ctx.step !== "activated") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx4(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-activated": "", ...rest, children });
+});
+var Loading2 = forwardRef3(function ActivationFlowLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Loading");
+  if (ctx.plan) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx4(Comp, { ref: forwardedRef, "data-solvapay-activation-flow-loading": "", ...rest, children });
+});
+var ErrorSlot2 = forwardRef3(function ActivationFlowError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useFlowCtx("Error");
+  if (ctx.step !== "error") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx4(
+    Comp,
+    {
+      ref: forwardedRef,
+      role: "alert",
+      "data-solvapay-activation-flow-error": "",
+      ...rest,
+      children: children ?? ctx.error
+    }
+  );
+});
+var ActivationFlowRoot2 = Root2;
+var ActivationFlowSummary2 = Summary;
+var ActivationFlowActivateButton2 = ActivateButton;
+var ActivationFlowAmountPicker = AmountPickerMount;
+var ActivationFlowContinueButton2 = ContinueButton;
+var ActivationFlowRetrying2 = Retrying;
+var ActivationFlowActivated2 = Activated;
+var ActivationFlowLoading2 = Loading2;
+var ActivationFlowError2 = ErrorSlot2;
+var ActivationFlow = {
+  Root: Root2,
+  Summary,
+  ActivateButton,
+  AmountPicker: AmountPickerMount,
+  ContinueButton,
+  Retrying,
+  Activated,
+  Loading: Loading2,
+  Error: ErrorSlot2
+};
+function useActivationFlow() {
+  return useFlowCtx("useActivationFlow");
+}
+
+// src/primitives/CreditGate.tsx
+import {
+  createContext as createContext3,
+  forwardRef as forwardRef4,
+  useContext as useContext4,
+  useMemo as useMemo3
+} from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var CreditGateContext = createContext3(null);
+function useGateCtx2(part) {
+  const ctx = useContext4(CreditGateContext);
+  if (!ctx) {
+    throw new Error(`CreditGate.${part} must be rendered inside <CreditGate.Root>.`);
+  }
+  return ctx;
+}
+var Root3 = forwardRef4(function CreditGateRoot({
+  minCredits = 1,
+  productRef,
+  topupAmount = 1e3,
+  topupCurrency = "usd",
+  asChild,
+  children,
+  ...rest
+}, forwardedRef) {
+  const solva = useContext4(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 = useMemo3(
+    () => ({
+      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__ */ jsx5(CreditGateContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx5(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-credit-gate": "",
+      "data-state": state,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Heading = forwardRef4(function CreditGateHeading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx2("Heading");
+  const copy = useCopy();
+  if (ctx.state !== "blocked") return null;
+  const Comp = asChild ? Slot : "h3";
+  return /* @__PURE__ */ jsx5(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-heading": "", ...rest, children: children ?? copy.creditGate.lowBalanceHeading });
+});
+var Subheading = forwardRef4(function CreditGateSubheading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx2("Subheading");
+  const copy = useCopy();
+  if (ctx.state !== "blocked") return null;
+  const text = interpolate(copy.creditGate.lowBalanceSubheading, {
+    product: ctx.productName ?? "this product"
+  });
+  const Comp = asChild ? Slot : "p";
+  return /* @__PURE__ */ jsx5(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-subheading": "", ...rest, children: children ?? text });
+});
+var Topup = ({ amount, currency }) => {
+  const ctx = useGateCtx2("Topup");
+  if (ctx.state !== "blocked") return null;
+  return /* @__PURE__ */ jsx5(
+    TopupForm2,
+    {
+      amount: amount ?? ctx.topupAmount,
+      currency: currency ?? ctx.topupCurrency
+    }
+  );
+};
+var Loading3 = forwardRef4(function CreditGateLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useGateCtx2("Loading");
+  if (ctx.state !== "loading") return null;
+  const Comp = asChild ? Slot : "div";
+  return (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    /* @__PURE__ */ jsx5(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-loading": "", ...rest, children })
+  );
+});
+var ErrorSlot3 = forwardRef4(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__ */ jsx5(Comp, { ref: forwardedRef, "data-solvapay-credit-gate-error": "", role: "alert", ...rest, children })
+  );
+});
+var CreditGateRoot2 = Root3;
+var CreditGateHeading2 = Heading;
+var CreditGateSubheading2 = Subheading;
+var CreditGateTopup = Topup;
+var CreditGateLoading2 = Loading3;
+var CreditGateError2 = ErrorSlot3;
+var CreditGate = {
+  Root: Root3,
+  Heading,
+  Subheading,
+  Topup,
+  Loading: Loading3,
+  Error: ErrorSlot3
+};
+function useCreditGate() {
+  return useGateCtx2("useCreditGate");
+}
+
+// src/hooks/useAutoRecharge.ts
+import { useCallback as useCallback2, useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
+
+// src/hooks/autoRechargeCache.ts
+var autoRechargeCache = /* @__PURE__ */ new Map();
+var CACHE_DURATION = 5 * 60 * 1e3;
+function autoRechargeCacheKeyFor(config) {
+  return createTransportCacheKey(config, config?.api?.autoRecharge || "/api/auto-recharge");
+}
+
+// src/hooks/useAutoRecharge.ts
+function mergeAutoRechargeConfig(config, display) {
+  return display ? { ...config, display } : config;
+}
+async function fetchAutoRecharge(config) {
+  const transport = config?.transport ?? createHttpTransport(config);
+  if (!transport.getAutoRecharge) return null;
+  const response = await transport.getAutoRecharge();
+  if (!response.config) return null;
+  return mergeAutoRechargeConfig(response.config, response.display);
+}
+function useAutoRecharge() {
+  const { _config } = useSolvaPay();
+  const key = autoRechargeCacheKeyFor(_config);
+  const [config, setConfig] = useState3(
+    () => autoRechargeCache.get(key)?.config ?? null
+  );
+  const [loading, setLoading] = useState3(() => {
+    const cached = autoRechargeCache.get(key);
+    return !cached || !cached.config && !cached.promise;
+  });
+  const [saving, setSaving] = useState3(false);
+  const [disabling, setDisabling] = useState3(false);
+  const [error, setError] = useState3(null);
+  const requestSeq = useRef2(0);
+  const load = useCallback2(
+    async (force = false) => {
+      const seq = requestSeq.current;
+      const cached = autoRechargeCache.get(key);
+      const now = Date.now();
+      if (!force && cached?.config && now - cached.timestamp < CACHE_DURATION) {
+        if (seq !== requestSeq.current) return;
+        setConfig(cached.config);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+      if (!force && cached?.promise) {
+        setLoading(true);
+        try {
+          const value = await cached.promise;
+          if (seq !== requestSeq.current) return;
+          setConfig(value);
+          setError(null);
+        } catch (caught) {
+          if (seq !== requestSeq.current) return;
+          setError(caught instanceof Error ? caught : new Error(String(caught)));
+        } finally {
+          if (seq === requestSeq.current) {
+            setLoading(false);
+          }
+        }
+        return;
+      }
+      setLoading(true);
+      setError(null);
+      const promise = fetchAutoRecharge(_config);
+      autoRechargeCache.set(key, {
+        config: cached?.config ?? null,
+        promise,
+        timestamp: now
+      });
+      try {
+        const value = await promise;
+        if (seq !== requestSeq.current) return;
+        autoRechargeCache.set(key, { config: value, promise: null, timestamp: Date.now() });
+        setConfig(value);
+      } catch (caught) {
+        if (seq !== requestSeq.current) return;
+        const err = caught instanceof Error ? caught : new Error(String(caught));
+        autoRechargeCache.set(key, { config: null, promise: null, timestamp: Date.now() });
+        setError(err);
+      } finally {
+        if (seq === requestSeq.current) {
+          setLoading(false);
+        }
+      }
+    },
+    [_config, key]
+  );
+  useEffect3(() => {
+    void load();
+  }, [load]);
+  const refresh = useCallback2(
+    async (force = true) => {
+      await load(force);
+    },
+    [load]
+  );
+  const save = useCallback2(
+    async (input) => {
+      const transport = _config?.transport ?? createHttpTransport(_config);
+      if (!transport.saveAutoRecharge) {
+        throw new Error("saveAutoRecharge is not available on this transport");
+      }
+      setSaving(true);
+      setError(null);
+      const seq = ++requestSeq.current;
+      try {
+        const result = await transport.saveAutoRecharge(input);
+        if (seq !== requestSeq.current) return result;
+        const nextConfig = mergeAutoRechargeConfig(result.config, result.display);
+        autoRechargeCache.set(key, {
+          config: nextConfig,
+          promise: null,
+          timestamp: Date.now()
+        });
+        setConfig(nextConfig);
+        return result;
+      } catch (caught) {
+        const err = caught instanceof Error ? caught : new Error(String(caught));
+        setError(err);
+        throw err;
+      } finally {
+        setSaving(false);
+      }
+    },
+    [_config, key]
+  );
+  const disable = useCallback2(async () => {
+    const transport = _config?.transport ?? createHttpTransport(_config);
+    if (!transport.disableAutoRecharge) {
+      throw new Error("disableAutoRecharge is not available on this transport");
+    }
+    setDisabling(true);
+    setError(null);
+    const seq = ++requestSeq.current;
+    try {
+      const result = await transport.disableAutoRecharge();
+      if (seq === requestSeq.current) {
+        setConfig((current) => {
+          const disabledConfig = current ? { ...current, enabled: false } : null;
+          autoRechargeCache.set(key, {
+            config: disabledConfig,
+            promise: null,
+            timestamp: Date.now()
+          });
+          return disabledConfig;
+        });
+        await refresh(true);
+        setConfig((current) => {
+          const disabledConfig = current ? { ...current, enabled: false } : null;
+          autoRechargeCache.set(key, {
+            config: disabledConfig,
+            promise: null,
+            timestamp: Date.now()
+          });
+          return disabledConfig;
+        });
+      }
+      return result;
+    } catch (caught) {
+      const err = caught instanceof Error ? caught : new Error(String(caught));
+      setError(err);
+      throw err;
+    } finally {
+      setDisabling(false);
+    }
+  }, [_config, key, refresh]);
+  return { config, loading, saving, disabling, error, refresh, save, disable };
+}
+
+// src/utils/credit-estimation.ts
+import { creditsToDisplayMinorUnits } from "@solvapay/core";
+function estimateCredits(resolvedAmountMajor, currency, creditsPerMinorUnit, displayExchangeRate) {
+  if (resolvedAmountMajor == null || resolvedAmountMajor <= 0) return null;
+  if (creditsPerMinorUnit == null || creditsPerMinorUnit <= 0) return null;
+  const rate = displayExchangeRate ?? 1;
+  const resolvedAmountMinor = Math.round(resolvedAmountMajor * getMinorUnitsPerMajor(currency));
+  return Math.round(resolvedAmountMinor / rate * creditsPerMinorUnit);
+}
+function estimateCurrencyMajorFromCredits(credits, currency, creditsPerMinorUnit, displayExchangeRate) {
+  if (credits == null || credits <= 0) return null;
+  if (creditsPerMinorUnit == null || creditsPerMinorUnit <= 0) return null;
+  const rate = displayExchangeRate ?? 1;
+  const displayMinor = creditsToDisplayMinorUnits({
+    credits,
+    creditsPerMinorUnit,
+    displayExchangeRate: rate,
+    displayCurrency: currency
+  });
+  if (displayMinor === null) return null;
+  return displayMinor / getMinorUnitsPerMajor(currency);
+}
+
+// src/helpers/stripe-minimums.ts
+var STRIPE_MINIMUM_MINOR = {
+  USD: 50,
+  EUR: 50,
+  GBP: 30,
+  SEK: 300,
+  NOK: 300,
+  DKK: 250,
+  CHF: 50,
+  CAD: 50,
+  AUD: 50,
+  JPY: 50,
+  KRW: 500
+};
+var DEFAULT_MINIMUM_MINOR = 50;
+function getStripeMinimumMinor(currency) {
+  return STRIPE_MINIMUM_MINOR[currency.toUpperCase()] ?? DEFAULT_MINIMUM_MINOR;
+}
+
+// src/helpers/auto-recharge-form.ts
+var DEFAULT_VALIDATION_MESSAGES = {
+  invalidThreshold: "Enter a valid balance threshold.",
+  thresholdTooLow: "Balance threshold must be greater than zero.",
+  minTopupAmount: "Top-up amount must be at least {amount}.",
+  topupBelowThreshold: "Top-up amount must be at least your balance threshold ({amount})."
+};
+function amountAnchors(thresholdValue, topupValue, unit = "currency") {
+  return {
+    thresholdBaseValue: thresholdValue,
+    thresholdBaseUnit: unit,
+    topupBaseValue: topupValue,
+    topupBaseUnit: unit
+  };
+}
+function createDefaultAutoRechargeForm(currency, defaultTopupMajor, defaultThresholdMajor) {
+  const topup = defaultTopupMajor != null && defaultTopupMajor > 0 ? String(defaultTopupMajor) : "10";
+  const threshold = defaultThresholdMajor != null && defaultThresholdMajor >= 0 ? String(defaultThresholdMajor) : "5";
+  return {
+    enabled: false,
+    thresholdAmountMajor: threshold,
+    thresholdUnit: "currency",
+    topupAmountMajor: topup,
+    topupUnit: "currency",
+    ...amountAnchors(threshold, topup, "currency")
+  };
+}
+function parsePositiveNumber(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  const parsed = Number(trimmed);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return parsed;
+}
+function parseNonNegativeNumber(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  const parsed = Number(trimmed);
+  if (!Number.isFinite(parsed) || parsed < 0) return null;
+  return parsed;
+}
+function validateAutoRechargeForm(form, currency, conversion, messages = DEFAULT_VALIDATION_MESSAGES) {
+  if (!form.enabled) {
+    return {
+      ok: true,
+      payload: {
+        enabled: false,
+        triggerType: "balance",
+        currency: currency.toUpperCase()
+      }
+    };
+  }
+  const payload = {
+    enabled: true,
+    triggerType: "balance",
+    currency: currency.toUpperCase()
+  };
+  const minorPerMajor = getMinorUnitsPerMajor(currency);
+  const minMinor = getStripeMinimumMinor(currency);
+  const thresholdRaw = parseNonNegativeNumber(form.thresholdAmountMajor);
+  if (thresholdRaw == null) {
+    return { ok: false, error: messages.invalidThreshold };
+  }
+  if (form.thresholdUnit === "credits") {
+    const major = estimateCurrencyMajorFromCredits(
+      thresholdRaw,
+      currency,
+      conversion?.creditsPerMinorUnit,
+      conversion?.displayExchangeRate
+    );
+    if (major == null) {
+      return { ok: false, error: messages.invalidThreshold };
+    }
+    payload.thresholdAmountMajor = major;
+  } else {
+    payload.thresholdAmountMajor = thresholdRaw;
+  }
+  if (payload.thresholdAmountMajor == null || payload.thresholdAmountMajor <= 0) {
+    return { ok: false, error: messages.thresholdTooLow };
+  }
+  const amountRaw = parsePositiveNumber(form.topupAmountMajor);
+  if (amountRaw == null) {
+    return {
+      ok: false,
+      error: interpolate(messages.minTopupAmount, {
+        amount: formatPrice(minMinor, currency, { free: "" })
+      })
+    };
+  }
+  const amountMajor = form.topupUnit === "credits" ? estimateCurrencyMajorFromCredits(
+    amountRaw,
+    currency,
+    conversion?.creditsPerMinorUnit,
+    conversion?.displayExchangeRate
+  ) : amountRaw;
+  if (amountMajor == null || Math.round(amountMajor * minorPerMajor) < minMinor) {
+    return {
+      ok: false,
+      error: interpolate(messages.minTopupAmount, {
+        amount: formatPrice(minMinor, currency, { free: "" })
+      })
+    };
+  }
+  payload.topupAmountMajor = amountMajor;
+  if (amountMajor < payload.thresholdAmountMajor) {
+    return {
+      ok: false,
+      error: interpolate(messages.topupBelowThreshold, {
+        amount: formatPrice(
+          Math.round(payload.thresholdAmountMajor * minorPerMajor),
+          currency,
+          { free: "" }
+        )
+      })
+    };
+  }
+  return { ok: true, payload };
+}
+function triggerAmountMajorFromConfig(config) {
+  const topupCurrency = config.topup.currency.toUpperCase();
+  const minorPerMajor = getMinorUnitsPerMajor(topupCurrency);
+  const { thresholdAmountMinor } = config.trigger;
+  if (!Number.isFinite(thresholdAmountMinor) || thresholdAmountMinor < 0) {
+    return null;
+  }
+  return thresholdAmountMinor / minorPerMajor;
+}
+function configToAutoRechargeInput(config, options) {
+  if (!config.enabled) return null;
+  const display = options?.display ?? config.display;
+  const currency = (display?.currency ?? config.topup.currency ?? options?.currency ?? "USD").toUpperCase();
+  if (display?.thresholdAmountMajor != null && display.topupAmountMajor != null) {
+    return {
+      enabled: true,
+      triggerType: "balance",
+      thresholdAmountMajor: display.thresholdAmountMajor,
+      topupAmountMajor: display.topupAmountMajor,
+      currency
+    };
+  }
+  const thresholdMajor = triggerAmountMajorFromConfig(config);
+  const topupAmountMajor = config.topup.amountMinor / getMinorUnitsPerMajor(currency);
+  if (thresholdMajor == null || !Number.isFinite(topupAmountMajor) || topupAmountMajor <= 0) {
+    return null;
+  }
+  return {
+    enabled: true,
+    triggerType: "balance",
+    thresholdAmountMajor: Math.max(0, thresholdMajor),
+    topupAmountMajor,
+    currency
+  };
+}
+function configToForm(config, currency) {
+  const base = createDefaultAutoRechargeForm(currency);
+  const display = config.display;
+  if (display?.thresholdAmountMajor != null && display.topupAmountMajor != null) {
+    const thresholdStr2 = String(Math.max(0, display.thresholdAmountMajor));
+    const topupStr2 = String(display.topupAmountMajor);
+    return {
+      ...base,
+      enabled: config.enabled,
+      thresholdAmountMajor: thresholdStr2,
+      topupAmountMajor: topupStr2,
+      ...amountAnchors(thresholdStr2, topupStr2, "currency")
+    };
+  }
+  const thresholdMajor = triggerAmountMajorFromConfig(config);
+  const thresholdStr = thresholdMajor != null ? String(Math.max(0, thresholdMajor)) : "0";
+  const topupStr = String(config.topup.amountMinor / getMinorUnitsPerMajor(currency));
+  return {
+    ...base,
+    enabled: config.enabled,
+    thresholdAmountMajor: thresholdStr,
+    topupAmountMajor: topupStr,
+    ...amountAnchors(thresholdStr, topupStr, "currency")
+  };
+}
+function formatAmountWithUnit(value, unit, currency) {
+  const num = Number(value);
+  if (!value || !Number.isFinite(num)) return "\u2014";
+  if (unit === "credits") {
+    return `${new Intl.NumberFormat().format(num)} credits`;
+  }
+  return formatPrice(Math.round(num * getMinorUnitsPerMajor(currency)), currency, { free: "" });
+}
+function buildSummaryLine(form, currency) {
+  if (!form.enabled) return null;
+  const thresholdDisplay = formatAmountWithUnit(
+    form.thresholdAmountMajor,
+    form.thresholdUnit,
+    currency
+  );
+  const fixedDisplay = formatAmountWithUnit(form.topupAmountMajor, form.topupUnit, currency);
+  return `When my balance falls below ${thresholdDisplay}, add ${fixedDisplay}.`;
+}
+function convertAmountForUnitFlip(value, fromUnit, toUnit, currency, creditsPerMinorUnit, displayExchangeRate) {
+  if (fromUnit === toUnit) return value;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return value;
+  if (fromUnit === "currency" && toUnit === "credits") {
+    const credits = estimateCredits(parsed, currency, creditsPerMinorUnit, displayExchangeRate);
+    return credits != null ? String(credits) : value;
+  }
+  const major = estimateCurrencyMajorFromCredits(
+    parsed,
+    currency,
+    creditsPerMinorUnit,
+    displayExchangeRate
+  );
+  return major != null ? String(major) : value;
+}
+function flipUnitValue(anchor, targetUnit, currency, creditsPerMinorUnit, displayExchangeRate) {
+  if (targetUnit === anchor.unit) {
+    return { value: anchor.value, unit: anchor.unit };
+  }
+  const converted = convertAmountForUnitFlip(
+    anchor.value,
+    anchor.unit,
+    targetUnit,
+    currency,
+    creditsPerMinorUnit,
+    displayExchangeRate
+  );
+  return { value: converted, unit: targetUnit };
+}
+
+// src/primitives/AutoRecharge.tsx
+import {
+  createContext as createContext4,
+  forwardRef as forwardRef5,
+  useCallback as useCallback3,
+  useContext as useContext5,
+  useEffect as useEffect4,
+  useId,
+  useMemo as useMemo4,
+  useRef as useRef3,
+  useState as useState4
+} from "react";
+import { createPortal } from "react-dom";
+import {
+  Elements,
+  PaymentElement as StripePaymentElement,
+  useElements,
+  useStripe
+} from "@stripe/react-stripe-js";
+import { loadStripe } from "@stripe/stripe-js";
+
+// src/primitives/autoRechargeActivation.ts
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function waitForAutoRechargeActivation({
+  refresh,
+  getStatus,
+  attempts = 5,
+  delayMs = 800,
+  sleep = defaultSleep
+}) {
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    await refresh(true);
+    if (getStatus() === "active") return true;
+    if (attempt < attempts - 1) await sleep(delayMs);
+  }
+  return getStatus() === "active";
+}
+
+// src/primitives/setupIntentReturn.ts
+var SETUP_INTENT_PARAMS = ["setup_intent", "setup_intent_client_secret", "redirect_status"];
+function readSetupIntentClientSecret(search) {
+  return new URLSearchParams(search).get("setup_intent_client_secret");
+}
+function stripSetupIntentParams() {
+  if (typeof window === "undefined") return;
+  const url = new URL(window.location.href);
+  let changed = false;
+  for (const param of SETUP_INTENT_PARAMS) {
+    if (url.searchParams.has(param)) {
+      url.searchParams.delete(param);
+      changed = true;
+    }
+  }
+  if (!changed) return;
+  const query = url.searchParams.toString();
+  window.history.replaceState({}, "", `${url.pathname}${query ? `?${query}` : ""}${url.hash}`);
+}
+
+// src/primitives/AutoRecharge.tsx
+import { Fragment as Fragment3, jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+var AutoRechargeContext = createContext4(null);
+function useAutoRechargeCtx(part) {
+  const ctx = useContext5(AutoRechargeContext);
+  if (!ctx) {
+    throw new Error(`AutoRecharge.${part} must be rendered inside <AutoRecharge.Root>.`);
+  }
+  return ctx;
+}
+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.toUpperCase();
+  } catch {
+    return currency.toUpperCase();
+  }
+}
+var stripePromiseCache = /* @__PURE__ */ new Map();
+function getStripeCacheKey(publishableKey, accountId) {
+  return accountId ? `${publishableKey}:${accountId}` : publishableKey;
+}
+var Root4 = forwardRef5(function AutoRechargeRoot({
+  currency = "USD",
+  defaultThresholdAmountMajor,
+  defaultTopupAmountMajor,
+  open: openProp,
+  defaultOpen = false,
+  onOpenChange,
+  onSetupRequired,
+  onSaved,
+  onDisabled,
+  deferCardSetup = false,
+  onPendingConfig,
+  asChild,
+  children,
+  className,
+  ...rest
+}, forwardedRef) {
+  const solva = useContext5(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("AutoRecharge");
+  const autoRecharge = useAutoRecharge();
+  const { creditsPerMinorUnit, displayExchangeRate } = useBalance();
+  const copy = useCopy();
+  const titleId = useId();
+  const triggerRef = useRef3(null);
+  const defaultTopup = defaultTopupAmountMajor ?? defaultThresholdAmountMajor ?? void 0;
+  const [uncontrolledOpen, setUncontrolledOpen] = useState4(defaultOpen);
+  const isControlled = openProp !== void 0;
+  const open = isControlled ? openProp : uncontrolledOpen;
+  const setOpen = useCallback3(
+    (next) => {
+      if (!isControlled) {
+        setUncontrolledOpen(next);
+      }
+      onOpenChange?.(next);
+    },
+    [isControlled, onOpenChange]
+  );
+  const registerTriggerRef = useCallback3((node) => {
+    triggerRef.current = node;
+  }, []);
+  const focusTrigger = useCallback3(() => {
+    triggerRef.current?.focus();
+  }, []);
+  const [form, setForm] = useState4(
+    () => autoRecharge.config ? configToForm(autoRecharge.config, currency) : createDefaultAutoRechargeForm(currency, defaultTopup)
+  );
+  const [validationError, setValidationError] = useState4(null);
+  const [statusMessage, setStatusMessage] = useState4(null);
+  const [setup, setSetup] = useState4(null);
+  const latestConfigRef = useRef3(autoRecharge.config);
+  useEffect4(() => {
+    latestConfigRef.current = autoRecharge.config;
+  }, [autoRecharge.config]);
+  useEffect4(() => {
+    if (autoRecharge.config) {
+      setForm(configToForm(autoRecharge.config, currency));
+    }
+  }, [autoRecharge.config, currency]);
+  const canToggleUnits = creditsPerMinorUnit != null && creditsPerMinorUnit > 0;
+  const rate = displayExchangeRate ?? 1;
+  const isApproximate = rate !== 1;
+  const emitValidation = useCallback3(
+    (next) => {
+      const result = validateAutoRechargeForm(
+        next,
+        currency,
+        { creditsPerMinorUnit, displayExchangeRate },
+        copy.autoRecharge
+      );
+      if (!result.ok) {
+        setValidationError(result.error);
+        return null;
+      }
+      setValidationError(null);
+      return result.payload;
+    },
+    [currency, creditsPerMinorUnit, displayExchangeRate, copy.autoRecharge]
+  );
+  const updateForm = useCallback3(
+    (patch) => {
+      setForm((prev) => {
+        const next = { ...prev, ...patch };
+        emitValidation(next);
+        return next;
+      });
+    },
+    [emitValidation]
+  );
+  const resetForm = useCallback3(() => {
+    if (autoRecharge.config) {
+      setForm(configToForm(autoRecharge.config, currency));
+    } else {
+      setForm(createDefaultAutoRechargeForm(currency, defaultTopup));
+    }
+    setValidationError(null);
+  }, [autoRecharge.config, currency, defaultTopup]);
+  const flipUnit = useCallback3(
+    (valueKey, unitKey, baseValueKey, baseUnitKey, currentUnit) => {
+      const nextUnit = currentUnit === "currency" ? "credits" : "currency";
+      setForm((prev) => {
+        const anchor = { value: prev[baseValueKey], unit: prev[baseUnitKey] };
+        const flipped = flipUnitValue(
+          anchor,
+          nextUnit,
+          currency,
+          creditsPerMinorUnit,
+          displayExchangeRate
+        );
+        const next = {
+          ...prev,
+          [unitKey]: flipped.unit,
+          [valueKey]: flipped.value
+        };
+        emitValidation(next);
+        return next;
+      });
+    },
+    [currency, creditsPerMinorUnit, displayExchangeRate, emitValidation]
+  );
+  const fixedTopupHint = useMemo4(() => {
+    const parsed = Number(form.topupAmountMajor);
+    if (!Number.isFinite(parsed) || parsed <= 0) return null;
+    if (form.topupUnit === "currency") {
+      const credits = estimateCredits(parsed, currency, creditsPerMinorUnit, displayExchangeRate);
+      if (credits == null) return null;
+      return { credits, approximate: isApproximate };
+    }
+    const major = estimateCurrencyMajorFromCredits(
+      parsed,
+      currency,
+      creditsPerMinorUnit,
+      displayExchangeRate
+    );
+    if (major == null) return null;
+    return { major, approximate: isApproximate };
+  }, [
+    form.topupAmountMajor,
+    form.topupUnit,
+    currency,
+    creditsPerMinorUnit,
+    displayExchangeRate,
+    isApproximate
+  ]);
+  const summaryLine = useMemo4(() => buildSummaryLine(form, currency), [form, currency]);
+  const savedSummaryLine = useMemo4(() => {
+    if (!autoRecharge.config?.enabled) return null;
+    return buildSummaryLine(
+      configToForm(autoRecharge.config, currency),
+      currency
+    );
+  }, [autoRecharge.config, currency]);
+  const save = useCallback3(async () => {
+    const payload = emitValidation(form);
+    if (!payload) return;
+    const saveInput = deferCardSetup ? { ...payload, deferSetupIntent: true } : payload;
+    const result = await autoRecharge.save(saveInput);
+    if (result.setupClientSecret) {
+      setSetup(result);
+      setStatusMessage(copy.autoRecharge.setupRequiredMessage);
+      await onSetupRequired?.(result);
+      return;
+    }
+    setSetup(null);
+    if (deferCardSetup) {
+      await onPendingConfig?.(payload);
+    }
+    setStatusMessage(
+      payload.enabled ? copy.autoRecharge.savedMessage : copy.autoRecharge.disabledMessage
+    );
+    setOpen(false);
+    await onSaved?.(result);
+  }, [
+    autoRecharge,
+    copy.autoRecharge,
+    deferCardSetup,
+    emitValidation,
+    form,
+    onPendingConfig,
+    onSaved,
+    onSetupRequired,
+    setOpen
+  ]);
+  const disable = useCallback3(async () => {
+    await autoRecharge.disable();
+    setStatusMessage(copy.autoRecharge.disabledMessage);
+    setSetup(null);
+    await onDisabled?.();
+  }, [autoRecharge, copy.autoRecharge, onDisabled]);
+  const completeSetup = useCallback3(async () => {
+    const activated = await waitForAutoRechargeActivation({
+      refresh: autoRecharge.refresh,
+      getStatus: () => latestConfigRef.current?.status
+    });
+    setSetup(null);
+    if (!form.enabled) return;
+    if (activated) {
+      setStatusMessage(copy.autoRecharge.savedMessage);
+      setOpen(false);
+    } else {
+      setStatusMessage(copy.autoRecharge.setupAwaitingConfirmation);
+    }
+  }, [autoRecharge, copy.autoRecharge, form.enabled, setOpen]);
+  const dataState = setup ? "setup" : autoRecharge.error ? "error" : autoRecharge.loading ? "loading" : autoRecharge.saving ? "saving" : autoRecharge.disabling ? "disabling" : "idle";
+  const ctx = useMemo4(
+    () => ({
+      form,
+      updateForm,
+      resetForm,
+      validationError,
+      currency,
+      config: autoRecharge.config,
+      loading: autoRecharge.loading,
+      saving: autoRecharge.saving,
+      disabling: autoRecharge.disabling,
+      error: autoRecharge.error,
+      statusMessage,
+      setup,
+      dataState,
+      creditsPerMinorUnit,
+      displayExchangeRate,
+      canToggleUnits,
+      isApproximate,
+      summaryLine,
+      savedSummaryLine,
+      deferCardSetup,
+      fixedTopupHint: fixedTopupHint && "credits" in fixedTopupHint ? String(fixedTopupHint.credits) : fixedTopupHint && "major" in fixedTopupHint ? formatPrice(
+        Math.round(fixedTopupHint.major * getMinorUnitsPerMajor(currency)),
+        currency,
+        { free: "" }
+      ) : null,
+      open,
+      setOpen,
+      titleId,
+      registerTriggerRef,
+      focusTrigger,
+      save,
+      disable,
+      completeSetup,
+      flipUnit
+    }),
+    [
+      form,
+      updateForm,
+      resetForm,
+      validationError,
+      currency,
+      autoRecharge.config,
+      autoRecharge.loading,
+      autoRecharge.saving,
+      autoRecharge.disabling,
+      autoRecharge.error,
+      statusMessage,
+      setup,
+      dataState,
+      creditsPerMinorUnit,
+      displayExchangeRate,
+      canToggleUnits,
+      isApproximate,
+      summaryLine,
+      savedSummaryLine,
+      deferCardSetup,
+      fixedTopupHint,
+      open,
+      setOpen,
+      titleId,
+      registerTriggerRef,
+      focusTrigger,
+      save,
+      disable,
+      completeSetup,
+      flipUnit
+    ]
+  );
+  const Comp = asChild ? Slot : "section";
+  return /* @__PURE__ */ jsx6(AutoRechargeContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx6(
+    Comp,
+    {
+      ref: forwardedRef,
+      className,
+      "aria-label": "Automatic credit top-up",
+      "data-solvapay-auto-recharge": "",
+      "data-state": dataState,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Loading4 = forwardRef5(
+  function AutoRechargeLoading({ className, children, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("Loading");
+    if (!ctx.loading) return null;
+    return /* @__PURE__ */ jsx6("p", { ref: forwardedRef, className, "data-solvapay-auto-recharge-loading": "", ...rest, children: children ?? /* @__PURE__ */ jsxs2(Fragment3, { children: [
+      /* @__PURE__ */ jsx6(Spinner, { size: "sm" }),
+      " Loading auto-recharge settings\u2026"
+    ] }) });
+  }
+);
+var Card = forwardRef5(function AutoRechargeCard({ className, children, ...rest }, forwardedRef) {
+  return /* @__PURE__ */ jsx6(
+    "section",
+    {
+      ref: forwardedRef,
+      className,
+      "data-solvapay-auto-recharge-card": "",
+      ...rest,
+      children
+    }
+  );
+});
+var CardHeading = forwardRef5(
+  function AutoRechargeCardHeading({ className, children, ...rest }, forwardedRef) {
+    const copy = useCopy();
+    return /* @__PURE__ */ jsx6(
+      "h3",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-auto-recharge-card-heading": "",
+        ...rest,
+        children: children ?? copy.autoRecharge.heading
+      }
+    );
+  }
+);
+var CardSummary = forwardRef5(
+  function AutoRechargeCardSummary({ className, children, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("CardSummary");
+    const copy = useCopy();
+    const text = ctx.savedSummaryLine ?? copy.autoRecharge.notConfiguredHint;
+    return /* @__PURE__ */ jsx6(
+      "p",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-auto-recharge-card-summary": "",
+        ...rest,
+        children: children ?? text
+      }
+    );
+  }
+);
+var Trigger = forwardRef5(function AutoRechargeTrigger({ asChild, onClick, children, className, ...rest }, forwardedRef) {
+  const ctx = useAutoRechargeCtx("Trigger");
+  const copy = useCopy();
+  const hasExistingConfig = Boolean(ctx.config?.enabled);
+  const label = hasExistingConfig ? copy.autoRecharge.modifyTriggerLabel : copy.autoRecharge.setupTriggerLabel;
+  const setRefs = (node) => {
+    ctx.registerTriggerRef(node);
+    if (typeof forwardedRef === "function") {
+      forwardedRef(node);
+    } else if (forwardedRef) {
+      forwardedRef.current = node;
+    }
+  };
+  const commonProps = {
+    "data-solvapay-auto-recharge-trigger": "",
+    type: "button",
+    "aria-haspopup": "dialog",
+    "aria-expanded": ctx.open,
+    disabled: ctx.loading,
+    onClick: composeEventHandlers(onClick, (event) => {
+      event.preventDefault();
+      ctx.resetForm();
+      ctx.setOpen(true);
+    }),
+    className,
+    ...rest
+  };
+  if (asChild) {
+    return /* @__PURE__ */ jsx6(Slot, { ref: setRefs, ...commonProps, children: children ?? label });
+  }
+  return /* @__PURE__ */ jsx6("button", { ref: setRefs, ...commonProps, children: children ?? label });
+});
+var Overlay = forwardRef5(
+  function AutoRechargeOverlay({ onClick, className, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("Overlay");
+    return /* @__PURE__ */ jsx6(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-auto-recharge-overlay": "",
+        "aria-hidden": "true",
+        onClick: composeEventHandlers(onClick, () => {
+          ctx.resetForm();
+          ctx.setOpen(false);
+          ctx.focusTrigger();
+        }),
+        ...rest
+      }
+    );
+  }
+);
+var Content = forwardRef5(function AutoRechargeContent({ className, children, ...rest }, forwardedRef) {
+  const ctx = useAutoRechargeCtx("Content");
+  const panelRef = useRef3(null);
+  useEffect4(() => {
+    if (!ctx.open) return;
+    const handleKeyDown = (event) => {
+      if (event.key === "Escape") {
+        ctx.resetForm();
+        ctx.setOpen(false);
+        ctx.focusTrigger();
+      }
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    const focusTarget = panelRef.current?.querySelector(
+      'button:not([disabled]), input:not([disabled]), [href], [tabindex]:not([tabindex="-1"])'
+    );
+    focusTarget?.focus();
+    return () => {
+      document.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [ctx.open, ctx.resetForm, ctx.setOpen, ctx.focusTrigger]);
+  if (!ctx.open || typeof document === "undefined") return null;
+  return createPortal(
+    /* @__PURE__ */ jsxs2("div", { "data-solvapay-auto-recharge-portal": "", children: [
+      /* @__PURE__ */ jsx6(Overlay, {}),
+      /* @__PURE__ */ jsx6(
+        "div",
+        {
+          ref: (node) => {
+            panelRef.current = node;
+            if (typeof forwardedRef === "function") {
+              forwardedRef(node);
+            } else if (forwardedRef) {
+              forwardedRef.current = node;
+            }
+          },
+          role: "dialog",
+          "aria-modal": "true",
+          "aria-labelledby": ctx.titleId,
+          className,
+          "data-solvapay-auto-recharge-content": "",
+          ...rest,
+          children
+        }
+      )
+    ] }),
+    document.body
+  );
+});
+var Title = forwardRef5(
+  function AutoRechargeTitle({ className, children, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("Title");
+    const copy = useCopy();
+    return /* @__PURE__ */ jsx6(
+      "h2",
+      {
+        ref: forwardedRef,
+        id: ctx.titleId,
+        className,
+        "data-solvapay-auto-recharge-title": "",
+        ...rest,
+        children: children ?? copy.autoRecharge.settingsHeading
+      }
+    );
+  }
+);
+var EnableQuestion = forwardRef5(
+  function AutoRechargeEnableQuestion({ className, children, ...rest }, forwardedRef) {
+    const copy = useCopy();
+    return /* @__PURE__ */ jsx6("p", { ref: forwardedRef, className, "data-solvapay-auto-recharge-question": "", ...rest, children: children ?? copy.autoRecharge.enableQuestion });
+  }
+);
+var EnableSentence = forwardRef5(
+  function AutoRechargeEnableSentence({ className, children, ...rest }, forwardedRef) {
+    const copy = useCopy();
+    return /* @__PURE__ */ jsx6(
+      "label",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-auto-recharge-enable-sentence": "",
+        ...rest,
+        children: children ?? copy.autoRecharge.enableSentence
+      }
+    );
+  }
+);
+var EnableRow = forwardRef5(
+  function AutoRechargeEnableRow({ className, children, ...rest }, forwardedRef) {
+    const enableId = useId();
+    return /* @__PURE__ */ jsx6(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-auto-recharge-enable-row": "",
+        ...rest,
+        children: children ?? /* @__PURE__ */ jsxs2(Fragment3, { children: [
+          /* @__PURE__ */ jsx6(EnableSwitch, { appearance: "checkbox", id: enableId }),
+          /* @__PURE__ */ jsx6(EnableSentence, { htmlFor: enableId })
+        ] })
+      }
+    );
+  }
+);
+var CancelButton = forwardRef5(
+  function AutoRechargeCancelButton({ asChild, onClick, children, className, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("CancelButton");
+    const copy = useCopy();
+    const commonProps = {
+      "data-solvapay-auto-recharge-cancel": "",
+      type: "button",
+      onClick: composeEventHandlers(onClick, (event) => {
+        event.preventDefault();
+        ctx.resetForm();
+        ctx.setOpen(false);
+        ctx.focusTrigger();
+      }),
+      className,
+      ...rest
+    };
+    if (asChild) {
+      return /* @__PURE__ */ jsx6(
+        Slot,
+        {
+          ref: forwardedRef,
+          ...commonProps,
+          children: children ?? copy.autoRecharge.cancelButton
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx6("button", { ref: forwardedRef, ...commonProps, children: children ?? copy.autoRecharge.cancelButton });
+  }
+);
+var Header = forwardRef5(
+  function AutoRechargeHeader({ className, ...rest }, forwardedRef) {
+    const copy = useCopy();
+    const headingId = useId();
+    return /* @__PURE__ */ jsxs2(
+      "header",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-auto-recharge-header": "",
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsxs2("section", { "data-solvapay-auto-recharge-heading-group": "", children: [
+            /* @__PURE__ */ jsx6("h3", { id: headingId, "data-solvapay-auto-recharge-heading": "", children: copy.autoRecharge.heading }),
+            /* @__PURE__ */ jsx6(Description, {})
+          ] }),
+          /* @__PURE__ */ jsx6(EnableSwitch, { "aria-labelledby": headingId })
+        ]
+      }
+    );
+  }
+);
+var Description = forwardRef5(
+  function AutoRechargeDescription({ className, children, ...rest }, forwardedRef) {
+    const copy = useCopy();
+    return /* @__PURE__ */ jsx6(
+      "p",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-auto-recharge-description": "",
+        ...rest,
+        children: children ?? copy.autoRecharge.description
+      }
+    );
+  }
+);
+var EnableSwitch = forwardRef5(
+  function AutoRechargeEnableSwitch({ asChild, appearance = "switch", onChange, className, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("EnableSwitch");
+    const copy = useCopy();
+    const commonProps = {
+      "data-solvapay-auto-recharge-enable": "",
+      "data-appearance": appearance,
+      type: "checkbox",
+      ...appearance === "switch" ? { role: "switch", "aria-checked": ctx.form.enabled } : {},
+      checked: ctx.form.enabled,
+      "aria-label": copy.autoRecharge.enableLabel,
+      disabled: ctx.loading || ctx.saving || ctx.disabling || !!ctx.setup,
+      onChange: composeEventHandlers(onChange, (event) => {
+        ctx.updateForm({ enabled: event.currentTarget.checked });
+      }),
+      className,
+      ...rest
+    };
+    if (asChild) {
+      return /* @__PURE__ */ jsx6(
+        Slot,
+        {
+          ref: forwardedRef,
+          ...commonProps
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx6("input", { ref: forwardedRef, ...commonProps });
+  }
+);
+var Fields = forwardRef5(
+  function AutoRechargeFields({ className, children, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("Fields");
+    const copy = useCopy();
+    if (!ctx.form.enabled) return null;
+    return /* @__PURE__ */ jsxs2(
+      "fieldset",
+      {
+        ref: forwardedRef,
+        className,
+        disabled: ctx.saving || ctx.disabling,
+        "data-solvapay-auto-recharge-fields": "",
+        "data-solvapay-auto-recharge-body": "",
+        "data-state": "open",
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsx6("legend", { className: "sr-only", children: copy.autoRecharge.heading }),
+          children ?? /* @__PURE__ */ jsxs2(Fragment3, { children: [
+            /* @__PURE__ */ jsx6(Summary2, {}),
+            /* @__PURE__ */ jsx6(ThresholdField, {}),
+            /* @__PURE__ */ jsx6(TopupField, {}),
+            /* @__PURE__ */ jsx6(ValidationError, {})
+          ] })
+        ]
+      }
+    );
+  }
+);
+var Setup = forwardRef5(
+  function AutoRechargeSetup({ className, children, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("Setup");
+    if (!ctx.setup?.setupClientSecret) return null;
+    return /* @__PURE__ */ jsx6(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-auto-recharge-setup-panel": "",
+        ...rest,
+        children: children ?? /* @__PURE__ */ jsx6(CardSetup, { setup: ctx.setup, onComplete: ctx.completeSetup })
+      }
+    );
+  }
+);
+var Body = forwardRef5(
+  function AutoRechargeBody({ className, children, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("Body");
+    if (ctx.setup?.setupClientSecret) {
+      return /* @__PURE__ */ jsx6(Setup, { className });
+    }
+    if (!ctx.form.enabled) return null;
+    return /* @__PURE__ */ jsx6(Fields, { ref: forwardedRef, className, ...rest, children: children ?? /* @__PURE__ */ jsxs2(Fragment3, { children: [
+      /* @__PURE__ */ jsx6(Summary2, {}),
+      /* @__PURE__ */ jsx6(ThresholdField, {}),
+      /* @__PURE__ */ jsx6(TopupField, {}),
+      /* @__PURE__ */ jsx6(ValidationError, {}),
+      /* @__PURE__ */ jsx6(Actions, {})
+    ] }) });
+  }
+);
+var Summary2 = forwardRef5(
+  function AutoRechargeSummary({ className, children, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("Summary");
+    if (!ctx.summaryLine) return null;
+    return /* @__PURE__ */ jsx6("p", { ref: forwardedRef, className, "data-solvapay-auto-recharge-summary": "", ...rest, children: children ?? ctx.summaryLine });
+  }
+);
+var AmountField = forwardRef5(function AutoRechargeAmountField({ field, showLabel = true, asChild, onChange, className, ...rest }, forwardedRef) {
+  const ctx = useAutoRechargeCtx("AmountField");
+  const copy = useCopy();
+  const fieldConfig = {
+    threshold: {
+      label: copy.autoRecharge.thresholdLabel,
+      ariaLabel: copy.autoRecharge.thresholdAriaLabel,
+      unitToggleLabel: "balance threshold",
+      value: ctx.form.thresholdAmountMajor,
+      unit: ctx.form.thresholdUnit,
+      unitKey: "thresholdUnit",
+      valueKey: "thresholdAmountMajor",
+      baseValueKey: "thresholdBaseValue",
+      baseUnitKey: "thresholdBaseUnit",
+      mode: ctx.form.thresholdUnit === "currency" ? "currency" : "number",
+      onValue: (value) => ctx.updateForm({
+        thresholdAmountMajor: value,
+        thresholdBaseValue: value,
+        thresholdBaseUnit: ctx.form.thresholdUnit
+      })
+    },
+    fixed: {
+      label: copy.autoRecharge.fixedAmountLabel,
+      ariaLabel: copy.autoRecharge.fixedAmountAriaLabel,
+      unitToggleLabel: "fixed top-up amount",
+      value: ctx.form.topupAmountMajor,
+      unit: ctx.form.topupUnit,
+      unitKey: "topupUnit",
+      valueKey: "topupAmountMajor",
+      baseValueKey: "topupBaseValue",
+      baseUnitKey: "topupBaseUnit",
+      mode: ctx.form.topupUnit === "currency" ? "currency" : "number",
+      onValue: (value) => ctx.updateForm({
+        topupAmountMajor: value,
+        topupBaseValue: value,
+        topupBaseUnit: ctx.form.topupUnit
+      })
+    }
+  }[field];
+  const inputId = useId();
+  const prefix = fieldConfig.mode === "currency" ? getCurrencySymbol(ctx.currency) : void 0;
+  const handleChange = (event) => {
+    const raw = event.target.value;
+    const next = fieldConfig.mode === "currency" ? raw.replace(/[^0-9.]/g, "") : raw.replace(/[^0-9]/g, "");
+    fieldConfig.onValue(next);
+  };
+  const inputProps = {
+    id: inputId,
+    "data-solvapay-auto-recharge-amount": "",
+    "data-field": field,
+    type: "text",
+    inputMode: fieldConfig.mode === "currency" ? "decimal" : "numeric",
+    placeholder: fieldConfig.mode === "currency" ? "0.00" : "0",
+    value: fieldConfig.value,
+    "aria-label": fieldConfig.ariaLabel,
+    onChange: composeEventHandlers(onChange, handleChange),
+    className,
+    ...rest
+  };
+  const slotRef = forwardedRef;
+  return /* @__PURE__ */ jsxs2("p", { "data-solvapay-auto-recharge-field": "", "data-field": field, children: [
+    showLabel ? /* @__PURE__ */ jsx6("label", { htmlFor: inputId, children: fieldConfig.label }) : null,
+    /* @__PURE__ */ jsxs2("span", { "data-solvapay-auto-recharge-amount-row": "", children: [
+      prefix ? /* @__PURE__ */ jsx6("span", { "data-solvapay-auto-recharge-currency-prefix": "", "aria-hidden": "true", children: prefix }) : null,
+      asChild ? /* @__PURE__ */ jsx6(Slot, { ref: slotRef, ...inputProps }) : /* @__PURE__ */ jsx6("input", { ref: forwardedRef, ...inputProps }),
+      ctx.canToggleUnits ? /* @__PURE__ */ jsx6(
+        UnitToggle,
+        {
+          unit: fieldConfig.unit,
+          fieldLabel: fieldConfig.unitToggleLabel,
+          onToggle: () => ctx.flipUnit(
+            fieldConfig.valueKey,
+            fieldConfig.unitKey,
+            fieldConfig.baseValueKey,
+            fieldConfig.baseUnitKey,
+            fieldConfig.unit
+          )
+        }
+      ) : null
+    ] })
+  ] });
+});
+var ThresholdField = forwardRef5(
+  function AutoRechargeThresholdField({ className, ...rest }, ref) {
+    return /* @__PURE__ */ jsx6("section", { ref, className, ...rest, children: /* @__PURE__ */ jsx6(AmountField, { field: "threshold" }) });
+  }
+);
+var TopupField = forwardRef5(
+  function AutoRechargeTopupField({ className, ...rest }, ref) {
+    return /* @__PURE__ */ jsxs2(
+      "section",
+      {
+        ref,
+        className,
+        "data-solvapay-auto-recharge-topup-field": "",
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsx6(AmountField, { field: "fixed" }),
+          /* @__PURE__ */ jsx6(Hint, {})
+        ]
+      }
+    );
+  }
+);
+var UnitToggle = forwardRef5(function AutoRechargeUnitToggle({ unit, fieldLabel, onToggle, className, ...rest }, forwardedRef) {
+  const ctx = useAutoRechargeCtx("UnitToggle");
+  const targetUnitLabel = unit === "currency" ? "credits" : "currency";
+  return /* @__PURE__ */ jsx6(
+    "button",
+    {
+      ref: forwardedRef,
+      type: "button",
+      className,
+      "data-solvapay-auto-recharge-unit-toggle": "",
+      "aria-label": `Switch ${fieldLabel} to ${targetUnitLabel}`,
+      onClick: onToggle,
+      ...rest,
+      children: unit === "currency" ? ctx.currency.toUpperCase() : "credits"
+    }
+  );
+});
+var Hint = forwardRef5(
+  function AutoRechargeHint({ className, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("Hint");
+    const copy = useCopy();
+    const hint = ctx.fixedTopupHint;
+    if (!hint) return null;
+    const isCreditsHint = ctx.form.topupUnit === "currency";
+    const text = isCreditsHint ? interpolate(
+      ctx.isApproximate ? copy.autoRecharge.creditsPerRechargeApprox : copy.autoRecharge.creditsPerRecharge,
+      { credits: new Intl.NumberFormat().format(Number(hint)) }
+    ) : interpolate(
+      ctx.isApproximate ? copy.autoRecharge.currencyPerRechargeApprox : copy.autoRecharge.currencyPerRecharge,
+      { amount: hint }
+    );
+    return /* @__PURE__ */ jsx6("p", { ref: forwardedRef, className, "data-solvapay-auto-recharge-hint": "", ...rest, children: text });
+  }
+);
+var ValidationError = forwardRef5(function AutoRechargeValidationError({ className, ...rest }, forwardedRef) {
+  const ctx = useAutoRechargeCtx("ValidationError");
+  if (!ctx.validationError) return null;
+  return /* @__PURE__ */ jsx6(
+    "p",
+    {
+      ref: forwardedRef,
+      role: "alert",
+      "aria-live": "polite",
+      className,
+      "data-solvapay-auto-recharge-validation-error": "",
+      ...rest,
+      children: ctx.validationError
+    }
+  );
+});
+var Actions = forwardRef5(
+  function AutoRechargeActions({ className, children, ...rest }, forwardedRef) {
+    return /* @__PURE__ */ jsx6(
+      "menu",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-auto-recharge-actions": "",
+        ...rest,
+        children: children ?? /* @__PURE__ */ jsxs2(Fragment3, { children: [
+          /* @__PURE__ */ jsx6("li", { children: /* @__PURE__ */ jsx6(CancelButton, {}) }),
+          /* @__PURE__ */ jsx6("li", { children: /* @__PURE__ */ jsx6(SaveButton, {}) })
+        ] })
+      }
+    );
+  }
+);
+var SaveButton = forwardRef5(function AutoRechargeSaveButton({ asChild, onClick, children, className, ...rest }, forwardedRef) {
+  const ctx = useAutoRechargeCtx("SaveButton");
+  const copy = useCopy();
+  const dataState = ctx.saving ? "processing" : ctx.validationError ? "disabled" : "idle";
+  const commonProps = {
+    "data-solvapay-auto-recharge-save": "",
+    "data-state": dataState,
+    type: "button",
+    disabled: ctx.saving || ctx.disabling || !!ctx.validationError,
+    "aria-busy": ctx.saving,
+    onClick: composeEventHandlers(onClick, (event) => {
+      event.preventDefault();
+      void ctx.save();
+    }),
+    className,
+    ...rest
+  };
+  const content = ctx.saving ? /* @__PURE__ */ jsxs2(Fragment3, { children: [
+    /* @__PURE__ */ jsx6(Spinner, { size: "sm" }),
+    " ",
+    copy.cta.processing
+  ] }) : children ?? copy.autoRecharge.saveButton;
+  if (asChild) {
+    return /* @__PURE__ */ jsx6(
+      Slot,
+      {
+        ref: forwardedRef,
+        ...commonProps,
+        children: content
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx6("button", { ref: forwardedRef, ...commonProps, children: content });
+});
+var DisableButton = forwardRef5(
+  function AutoRechargeDisableButton({ asChild, onClick, children, className, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("DisableButton");
+    const copy = useCopy();
+    if (!ctx.config) return null;
+    const commonProps = {
+      "data-solvapay-auto-recharge-disable": "",
+      type: "button",
+      disabled: ctx.saving || ctx.disabling,
+      "aria-busy": ctx.disabling,
+      onClick: composeEventHandlers(onClick, (event) => {
+        event.preventDefault();
+        void ctx.disable();
+      }),
+      className,
+      ...rest
+    };
+    if (asChild) {
+      return /* @__PURE__ */ jsx6(
+        Slot,
+        {
+          ref: forwardedRef,
+          ...commonProps,
+          children: children ?? copy.autoRecharge.disableButton
+        }
+      );
+    }
+    return /* @__PURE__ */ jsx6("button", { ref: forwardedRef, ...commonProps, children: children ?? copy.autoRecharge.disableButton });
+  }
+);
+var ErrorSlot4 = forwardRef5(
+  function AutoRechargeError({ className, children, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("Error");
+    if (!ctx.error) return null;
+    return /* @__PURE__ */ jsx6(
+      "p",
+      {
+        ref: forwardedRef,
+        role: "alert",
+        "aria-live": "polite",
+        className,
+        "data-solvapay-auto-recharge-error": "",
+        ...rest,
+        children: children ?? ctx.error.message
+      }
+    );
+  }
+);
+var StatusMessage = forwardRef5(
+  function AutoRechargeStatusMessage({ className, children, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("StatusMessage");
+    if (!ctx.statusMessage) return null;
+    return /* @__PURE__ */ jsx6(
+      "p",
+      {
+        ref: forwardedRef,
+        "aria-live": "polite",
+        className,
+        "data-solvapay-auto-recharge-status-message": "",
+        ...rest,
+        children: children ?? ctx.statusMessage
+      }
+    );
+  }
+);
+var Status = forwardRef5(
+  function AutoRechargeStatus({ className, ...rest }, forwardedRef) {
+    const ctx = useAutoRechargeCtx("Status");
+    const copy = useCopy();
+    const status = ctx.config?.status;
+    if (!status || status === "active" || status === "disabled" || status === "pending_setup") {
+      return null;
+    }
+    const label = status === "failed" ? copy.autoRecharge.statusFailed : null;
+    if (!label) return null;
+    return /* @__PURE__ */ jsx6(
+      "span",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-auto-recharge-status": "",
+        "data-status": status,
+        ...rest,
+        children: label
+      }
+    );
+  }
+);
+function CardSetupInner({ onComplete }) {
+  const copy = useCopy();
+  const stripe = useStripe();
+  const elements = useElements();
+  const [processing, setProcessing] = useState4(false);
+  const [error, setError] = useState4(null);
+  useEffect4(() => {
+    if (!stripe) return;
+    const clientSecret = readSetupIntentClientSecret(window.location.search);
+    if (!clientSecret) return;
+    let cancelled = false;
+    void (async () => {
+      setProcessing(true);
+      const { setupIntent, error: retrieveError } = await stripe.retrieveSetupIntent(clientSecret);
+      if (cancelled) return;
+      stripSetupIntentParams();
+      if (retrieveError || !setupIntent) {
+        setError(copy.autoRecharge.setupAuthFailed);
+        setProcessing(false);
+        return;
+      }
+      if (setupIntent.status === "succeeded" || setupIntent.status === "processing") {
+        await onComplete();
+      } else {
+        setError(copy.autoRecharge.setupAuthFailed);
+      }
+      if (!cancelled) setProcessing(false);
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [stripe, onComplete, copy.autoRecharge]);
+  const handleSubmit = async (event) => {
+    event.preventDefault();
+    if (!stripe || !elements) {
+      setError("Stripe is still loading. Please wait.");
+      return;
+    }
+    setProcessing(true);
+    setError(null);
+    const { error: submitError } = await elements.submit();
+    if (submitError) {
+      setError(submitError.message ?? "Card authorization failed");
+      setProcessing(false);
+      return;
+    }
+    const { error: confirmError } = await stripe.confirmSetup({
+      elements,
+      confirmParams: {
+        return_url: typeof window !== "undefined" ? window.location.href : "/"
+      },
+      redirect: "if_required"
+    });
+    if (confirmError) {
+      setError(confirmError.message ?? "Card authorization failed");
+      setProcessing(false);
+      return;
+    }
+    await onComplete();
+    setProcessing(false);
+  };
+  return /* @__PURE__ */ jsxs2("form", { onSubmit: handleSubmit, "data-solvapay-auto-recharge-setup": "", children: [
+    /* @__PURE__ */ jsx6("h4", { children: copy.autoRecharge.setupHeading }),
+    /* @__PURE__ */ jsx6("p", { children: copy.autoRecharge.setupDescription }),
+    /* @__PURE__ */ jsx6(StripePaymentElement, { options: withPaymentElementDefaults() }),
+    error ? /* @__PURE__ */ jsx6("p", { role: "alert", "aria-live": "polite", "data-solvapay-auto-recharge-setup-error": "", children: error }) : null,
+    /* @__PURE__ */ jsx6(
+      "button",
+      {
+        type: "submit",
+        disabled: processing || !stripe,
+        "data-solvapay-auto-recharge-setup-submit": "",
+        children: processing ? copy.autoRecharge.setupProcessing : copy.autoRecharge.setupSubmit
+      }
+    )
+  ] });
+}
+function CardSetup({ setup, onComplete }) {
+  const stripePromise = useMemo4(() => {
+    if (!setup.publishableKey || !setup.setupClientSecret) return null;
+    const options = {
+      ...setup.stripeAccountId ? { stripeAccount: setup.stripeAccountId } : {},
+      developerTools: { assistant: { enabled: false } }
+    };
+    const cacheKey = getStripeCacheKey(setup.publishableKey, setup.stripeAccountId);
+    const cached = stripePromiseCache.get(cacheKey);
+    if (cached) return cached;
+    const promise = loadStripe(setup.publishableKey, options);
+    stripePromiseCache.set(cacheKey, promise);
+    return promise;
+  }, [setup.publishableKey, setup.setupClientSecret, setup.stripeAccountId]);
+  if (!stripePromise || !setup.setupClientSecret) {
+    return /* @__PURE__ */ jsxs2("p", { "data-solvapay-auto-recharge-setup-loading": "", children: [
+      /* @__PURE__ */ jsx6(Spinner, { size: "sm" }),
+      " Loading card form\u2026"
+    ] });
+  }
+  return /* @__PURE__ */ jsx6(
+    Elements,
+    {
+      stripe: stripePromise,
+      options: { clientSecret: setup.setupClientSecret },
+      children: /* @__PURE__ */ jsx6(CardSetupInner, { onComplete })
+    },
+    setup.setupClientSecret
+  );
+}
+var AutoRechargeRoot2 = Root4;
+var AutoRechargeLoading2 = Loading4;
+var AutoRechargeCard2 = Card;
+var AutoRechargeCardHeading2 = CardHeading;
+var AutoRechargeCardSummary2 = CardSummary;
+var AutoRechargeTrigger2 = Trigger;
+var AutoRechargeOverlay2 = Overlay;
+var AutoRechargeContent2 = Content;
+var AutoRechargeTitle2 = Title;
+var AutoRechargeEnableQuestion2 = EnableQuestion;
+var AutoRechargeEnableSentence2 = EnableSentence;
+var AutoRechargeEnableRow2 = EnableRow;
+var AutoRechargeCancelButton2 = CancelButton;
+var AutoRechargeHeader2 = Header;
+var AutoRechargeDescription2 = Description;
+var AutoRechargeEnableSwitch2 = EnableSwitch;
+var AutoRechargeFields2 = Fields;
+var AutoRechargeSetup2 = Setup;
+var AutoRechargeBody2 = Body;
+var AutoRechargeSummary2 = Summary2;
+var AutoRechargeThresholdField2 = ThresholdField;
+var AutoRechargeTopupField2 = TopupField;
+var AutoRechargeAmountField2 = AmountField;
+var AutoRechargeUnitToggle2 = UnitToggle;
+var AutoRechargeHint2 = Hint;
+var AutoRechargeValidationError2 = ValidationError;
+var AutoRechargeActions2 = Actions;
+var AutoRechargeSaveButton2 = SaveButton;
+var AutoRechargeDisableButton2 = DisableButton;
+var AutoRechargeError2 = ErrorSlot4;
+var AutoRechargeStatusMessage2 = StatusMessage;
+var AutoRechargeStatus2 = Status;
+var AutoRechargeCardSetup = CardSetup;
+var AutoRecharge = {
+  Root: Root4,
+  Loading: Loading4,
+  Card,
+  CardHeading,
+  CardSummary,
+  Trigger,
+  Overlay,
+  Content,
+  Title,
+  EnableQuestion,
+  EnableSentence,
+  EnableRow,
+  CancelButton,
+  Header,
+  Description,
+  EnableSwitch,
+  Fields,
+  Setup,
+  Body,
+  Summary: Summary2,
+  ThresholdField,
+  TopupField,
+  AmountField,
+  UnitToggle,
+  Hint,
+  ValidationError,
+  Actions,
+  SaveButton,
+  DisableButton,
+  Error: ErrorSlot4,
+  StatusMessage,
+  Status,
+  CardSetup
+};
+function useAutoRechargeForm() {
+  return useAutoRechargeCtx("useAutoRechargeForm");
+}
+
+// src/hooks/usePaywallResolver.ts
+import { useCallback as useCallback4, useMemo as useMemo5 } from "react";
+function balanceCoversNextUnit(balance, credits) {
+  if (!balance) return false;
+  if (typeof balance.remainingUnits === "number" && balance.remainingUnits > 0) {
+    return true;
+  }
+  if (credits != null && balance.creditsPerUnit && credits >= balance.creditsPerUnit) {
+    return true;
+  }
+  return false;
+}
+function usePaywallResolver(content) {
+  const { activePurchase, hasPaidPurchase, refetch: refetchPurchase } = usePurchase();
+  const { credits, refetch: refetchBalance } = useBalance();
+  const resolved = useMemo5(() => {
+    if (!content) return false;
+    const productMatches = !content.product || activePurchase?.productRef === content.product || activePurchase?.productName === content.product;
+    if (content.kind === "payment_required") {
+      if (hasPaidPurchase && productMatches) return true;
+      return balanceCoversNextUnit(content.balance, credits);
+    }
+    if (balanceCoversNextUnit(content.balance, credits)) return true;
+    return Boolean(productMatches && activePurchase?.status === "active");
+  }, [content, hasPaidPurchase, activePurchase, credits]);
+  const refetch = useCallback4(async () => {
+    await Promise.all([
+      refetchPurchase().catch(() => void 0),
+      refetchBalance().catch(() => void 0)
+    ]);
+  }, [refetchPurchase, refetchBalance]);
+  return { resolved, refetch };
+}
+
+// src/primitives/PaywallNotice.tsx
+import {
+  createContext as createContext6,
+  forwardRef as forwardRef7,
+  useCallback as useCallback5,
+  useContext as useContext7,
+  useEffect as useEffect5,
+  useMemo as useMemo7,
+  useRef as useRef4
+} from "react";
+
+// src/primitives/checkout/index.tsx
+import { createContext as createContext5, forwardRef as forwardRef6, useContext as useContext6, useMemo as useMemo6 } from "react";
+import { Fragment as Fragment4, jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+var CheckoutContext = createContext5(null);
+function useCheckoutContext(part) {
+  const ctx = useContext6(CheckoutContext);
+  if (!ctx) {
+    throw new Error(`CheckoutSteps.${part} must be rendered inside <CheckoutSteps.Root>.`);
+  }
+  return ctx;
+}
+function useCheckoutSteps() {
+  return useCheckoutContext("useCheckoutSteps");
+}
+var Root5 = forwardRef6(function CheckoutStepsRoot(props, forwardedRef) {
+  const {
+    productRef,
+    returnUrl: _returnUrl,
+    flow: externalFlow,
+    initialStep,
+    initialPlanRef,
+    initialAmountMinor,
+    autoSelectFirstPaid = false,
+    topupCurrency,
+    filter,
+    sortBy = planSortByPaygFirstThenAsc,
+    popularPlanRef,
+    currentPlanRef,
+    onPlanSelect,
+    onAmountSelect,
+    onPurchaseSuccess,
+    onError,
+    className,
+    children
+  } = props;
+  if (externalFlow) {
+    return /* @__PURE__ */ jsx7("div", { ref: forwardedRef, "data-solvapay-checkout": "", className, children: /* @__PURE__ */ jsx7(CheckoutContext.Provider, { value: externalFlow, children }) });
+  }
+  return /* @__PURE__ */ jsx7(
+    RootWithPlanSelector,
+    {
+      productRef,
+      filter,
+      sortBy,
+      popularPlanRef,
+      currentPlanRef,
+      autoSelectFirstPaid,
+      initialPlanRef,
+      forwardedRef,
+      className,
+      initialStep,
+      initialAmountMinor,
+      topupCurrency,
+      onPlanSelect,
+      onAmountSelect,
+      onPurchaseSuccess,
+      onError,
+      children
+    }
+  );
+});
+function RootWithPlanSelector({
+  productRef,
+  filter,
+  sortBy,
+  popularPlanRef,
+  currentPlanRef,
+  autoSelectFirstPaid,
+  initialPlanRef,
+  forwardedRef,
+  className,
+  initialStep,
+  initialAmountMinor,
+  topupCurrency,
+  onPlanSelect,
+  onAmountSelect,
+  onPurchaseSuccess,
+  onError,
+  children
+}) {
+  const { plans } = usePlans({ productRef });
+  const resolvedFilter = useMemo6(
+    () => filter ?? buildDefaultCheckoutPlanFilter(plans),
+    [filter, plans]
+  );
+  return /* @__PURE__ */ jsx7(
+    PlanSelector.Root,
+    {
+      productRef,
+      filter: resolvedFilter,
+      sortBy,
+      popularPlanRef,
+      currentPlanRef,
+      autoSelectFirstPaid,
+      initialPlanRef,
+      children: /* @__PURE__ */ jsx7(
+        FlowProvider,
+        {
+          productRef,
+          forwardedRef,
+          className,
+          initialStep,
+          initialAmountMinor,
+          topupCurrency,
+          onPlanSelect,
+          onAmountSelect,
+          onPurchaseSuccess,
+          onError,
+          children
+        }
+      )
+    }
+  );
+}
+function FlowProvider({
+  productRef,
+  initialStep,
+  initialAmountMinor,
+  topupCurrency,
+  onPlanSelect,
+  onAmountSelect,
+  onPurchaseSuccess,
+  onError,
+  className,
+  forwardedRef,
+  children
+}) {
+  const flow = useCheckoutFlow({
+    productRef,
+    initialStep,
+    initialAmountMinor,
+    topupCurrency,
+    onPlanSelect,
+    onAmountSelect,
+    onPurchaseSuccess,
+    onError
+  });
+  return /* @__PURE__ */ jsx7("div", { ref: forwardedRef, "data-solvapay-checkout": "", "data-step": flow.step, className, children: /* @__PURE__ */ jsx7(CheckoutContext.Provider, { value: flow, children }) });
+}
+function IfStep({ step, children }) {
+  const flow = useCheckoutContext("IfStep");
+  const matches = Array.isArray(step) ? step.includes(flow.step) : flow.step === step;
+  if (!matches) return null;
+  return /* @__PURE__ */ jsx7(Fragment4, { children });
+}
+var StepHeading = forwardRef6(function CheckoutStepsStepHeading({ asChild, children, className, ...rest }, forwardedRef) {
+  const flow = useCheckoutContext("StepHeading");
+  const copy = useCopy();
+  const paywallCtx = usePaywallNoticeOptional();
+  if (flow.step === "success") return null;
+  const defaultText = resolveStepHeading(flow.step, copy, paywallCtx?.content ?? null);
+  const Comp = asChild ? Slot : "h3";
+  return /* @__PURE__ */ jsx7(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-checkout-step-heading": "",
+      "data-step": flow.step,
+      className: className ?? "solvapay-checkout-step-heading",
+      ...rest,
+      children: children ?? defaultText
+    }
+  );
+});
+var StepMessage = forwardRef6(function CheckoutStepsStepMessage({ asChild, children, className, ...rest }, forwardedRef) {
+  const flow = useCheckoutContext("StepMessage");
+  const copy = useCopy();
+  const paywallCtx = usePaywallNoticeOptional();
+  if (flow.step === "success") return null;
+  const defaultText = resolveStepMessage(flow, copy, paywallCtx?.content ?? null);
+  if (!defaultText && children == null) return null;
+  const Comp = asChild ? Slot : "p";
+  return /* @__PURE__ */ jsx7(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-checkout-step-message": "",
+      "data-step": flow.step,
+      className: className ?? "solvapay-checkout-step-message",
+      ...rest,
+      children: children ?? defaultText
+    }
+  );
+});
+function resolveStepHeading(step, copy, content) {
+  if (step === "amount") return copy.checkout.stepHeading.amount;
+  if (step === "payment") return copy.checkout.stepHeading.payment;
+  if (step === "plan") {
+    if (content) {
+      if (content.kind === "payment_required") return copy.paywall.paymentRequiredHeading;
+      if (content.kind === "activation_required") {
+        return isTopupGate(content) ? copy.paywall.topupRequiredHeading : copy.paywall.activationRequiredHeading;
+      }
+    }
+    return copy.checkout.stepHeading.plan;
+  }
+  return "";
+}
+function resolveStepMessage(flow, copy, content) {
+  if (flow.step === "plan") {
+    if (content) return resolvePaywallMessage(content, copy.paywall);
+    return copy.checkout.stepMessage.plan;
+  }
+  if (flow.step === "amount") return copy.checkout.stepMessage.amount;
+  if (flow.step === "payment") {
+    if (flow.branch === "payg") return copy.checkout.stepMessage.paymentPayg;
+    const plan = flow.selectedPlan;
+    if (flow.branch === "recurring" && plan) {
+      const planName = plan.name ?? "your";
+      if (plan.billingCycle) {
+        return interpolate(copy.checkout.stepMessage.paymentRecurring, { planName });
+      }
+      return copy.checkout.stepMessage.paymentOneTime;
+    }
+    return copy.checkout.stepMessage.paymentOneTime;
+  }
+  return "";
+}
+function PlanGrid({ className, children }) {
+  return /* @__PURE__ */ jsx7(PlanSelector.Grid, { className: className ?? "solvapay-checkout-plan-grid", children: children ?? /* @__PURE__ */ jsxs3(PlanSelector.Card, { className: "solvapay-checkout-plan-card", children: [
+    /* @__PURE__ */ jsx7(PlanSelector.CardBadge, { className: "solvapay-checkout-plan-card-badge" }),
+    /* @__PURE__ */ jsx7(PlanSelector.CardName, { className: "solvapay-checkout-plan-card-name" }),
+    /* @__PURE__ */ jsx7(PlanSelector.CardPrice, { className: "solvapay-checkout-plan-card-price" }),
+    /* @__PURE__ */ jsx7(PlanSelector.CardInterval, { className: "solvapay-checkout-plan-card-interval" })
+  ] }) });
+}
+var PlanContinueButton = forwardRef6(
+  function PlanContinueButton2({ className, children, onClick, disabled, ...rest }, ref) {
+    const flow = useCheckoutContext("PlanContinueButton");
+    const locale = useLocale();
+    const selectedPlanShape = flow.selectedPlan;
+    const isDisabled = disabled || !flow.selectedPlanRef || flow.status === "activating";
+    const label = children ?? formatContinueLabel(selectedPlanShape, locale);
+    return /* @__PURE__ */ jsx7(
+      "button",
+      {
+        ref,
+        type: "button",
+        className: className ?? "solvapay-checkout-continue-button",
+        disabled: isDisabled,
+        "aria-disabled": isDisabled || void 0,
+        "data-solvapay-checkout-continue": "",
+        onClick: (e) => {
+          onClick?.(e);
+          if (e.defaultPrevented) return;
+          void flow.advance();
+        },
+        ...rest,
+        children: label
+      }
+    );
+  }
+);
+function AmountPicker2({ className, children }) {
+  const flow = useCheckoutContext("AmountPicker");
+  if (!flow.topupCurrencyReady || flow.topupCurrency == null) {
+    return /* @__PURE__ */ jsx7(
+      "div",
+      {
+        className: className ?? "solvapay-amount-picker",
+        "data-state": "loading",
+        "aria-busy": "true",
+        children: /* @__PURE__ */ jsx7("div", { className: "solvapay-amount-picker-pills", children: [0, 1, 2, 3].map((i) => /* @__PURE__ */ jsx7(
+          "span",
+          {
+            className: "solvapay-amount-picker-pill",
+            "data-state": "disabled",
+            "aria-hidden": "true"
+          },
+          i
+        )) })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx7(
+    AmountPicker.Root,
+    {
+      currency: flow.topupCurrency,
+      emit: "minor",
+      className: className ?? "solvapay-amount-picker",
+      onChange: (value) => {
+        if (typeof value === "number") {
+          flow.selectAmount(value);
+        }
+      },
+      children: children ?? /* @__PURE__ */ jsx7(DefaultAmountTree, {})
+    }
+  );
+}
+function DefaultAmountTree() {
+  const ctx = useAmountPicker();
+  const { selectAmountLabel, customAmountLabel, creditEstimate } = useAmountPickerCopy();
+  return /* @__PURE__ */ jsxs3(Fragment4, { children: [
+    /* @__PURE__ */ jsx7("p", { className: "solvapay-amount-picker-label", children: selectAmountLabel }),
+    /* @__PURE__ */ jsx7("div", { className: "solvapay-amount-picker-pills", children: ctx.quickAmounts.map((amount) => /* @__PURE__ */ jsx7(
+      AmountPicker.Option,
+      {
+        amount,
+        className: "solvapay-amount-picker-pill"
+      },
+      amount
+    )) }),
+    /* @__PURE__ */ jsxs3("div", { className: "solvapay-amount-picker-custom-wrapper", children: [
+      /* @__PURE__ */ jsx7("p", { className: "solvapay-amount-picker-custom-label", children: customAmountLabel }),
+      /* @__PURE__ */ jsxs3("div", { className: "solvapay-amount-picker-custom-row", children: [
+        /* @__PURE__ */ jsx7("span", { className: "solvapay-amount-picker-currency-symbol", children: ctx.currencySymbol }),
+        /* @__PURE__ */ jsx7(
+          AmountPicker.Custom,
+          {
+            className: "solvapay-amount-picker-custom-input",
+            placeholder: "0.00"
+          }
+        )
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx7(
+      "p",
+      {
+        className: "solvapay-amount-picker-credit-estimate",
+        "aria-hidden": ctx.estimatedCredits == null || void 0,
+        children: ctx.estimatedCredits != null ? creditEstimate(ctx.estimatedCredits) : "\xA0"
+      }
+    )
+  ] });
+}
+var AmountContinueButton = forwardRef6(
+  function AmountContinueButton2({ className, children, onClick, disabled, ...rest }, ref) {
+    const flow = useCheckoutContext("AmountContinueButton");
+    const locale = useLocale();
+    const currency = flow.topupCurrency;
+    const amountMinor = flow.selectedAmountMinor;
+    const ready = flow.topupCurrencyReady && currency != null;
+    const isDisabled = disabled || !ready || amountMinor == null;
+    const label = children ?? (ready && currency != null && amountMinor != null ? `Continue \u2014 ${formatPrice(amountMinor, currency, { locale })}` : "Continue");
+    return /* @__PURE__ */ jsx7(
+      "button",
+      {
+        ref,
+        type: "button",
+        className: className ?? "solvapay-checkout-continue-button",
+        disabled: isDisabled,
+        "aria-disabled": isDisabled || void 0,
+        "data-solvapay-checkout-continue": "",
+        onClick: (e) => {
+          onClick?.(e);
+          if (e.defaultPrevented) return;
+          void flow.advance();
+        },
+        ...rest,
+        children: label
+      }
+    );
+  }
+);
+function Payment({ className }) {
+  const flow = useCheckoutContext("Payment");
+  if (flow.branch === "payg") {
+    return /* @__PURE__ */ jsx7(PaygPayment, { className });
+  }
+  if (flow.branch === "recurring") {
+    return /* @__PURE__ */ jsx7(RecurringPayment, { className });
+  }
+  return null;
+}
+function PaygPayment({ className }) {
+  const flow = useCheckoutContext("Payment");
+  const locale = useLocale();
+  const { creditsPerMinorUnit, displayExchangeRate } = useBalance();
+  const returnUrl = useReturnUrl();
+  const selectedPlanShape = flow.selectedPlan;
+  const amountMinor = flow.selectedAmountMinor;
+  const currency = flow.topupCurrency;
+  if (!selectedPlanShape || amountMinor == null || currency == null) return null;
+  const creditsAdded = creditsPerMinorUnit != null && creditsPerMinorUnit > 0 ? Math.floor(amountMinor / (displayExchangeRate ?? 1) * creditsPerMinorUnit) : null;
+  return /* @__PURE__ */ jsxs3("div", { className: className ?? "solvapay-checkout-payment", "data-branch": "payg", children: [
+    /* @__PURE__ */ jsx7("div", { className: "solvapay-checkout-order-summary", "data-variant": "payg", children: /* @__PURE__ */ jsxs3("div", { className: "solvapay-checkout-order-summary-row", children: [
+      /* @__PURE__ */ jsx7("span", { children: creditsAdded != null ? `${creditsAdded.toLocaleString(locale)} credits` : formatPrice(amountMinor, currency, { locale }) }),
+      creditsAdded != null ? /* @__PURE__ */ jsx7("span", { children: formatPrice(amountMinor, currency, { locale }) }) : null
+    ] }) }),
+    /* @__PURE__ */ jsxs3(
+      TopupForm.Root,
+      {
+        amount: amountMinor,
+        currency,
+        returnUrl,
+        className: "solvapay-checkout-topup-form",
+        onSuccess: (intent, extras) => flow.notifyPaymentSuccess(intent, extras),
+        children: [
+          /* @__PURE__ */ jsx7(TopupForm.Loading, {}),
+          /* @__PURE__ */ jsx7(TopupForm.PaymentElement, {}),
+          /* @__PURE__ */ jsx7(TopupForm.Error, { className: "solvapay-checkout-error" }),
+          /* @__PURE__ */ jsx7(MandateText, { mode: "topup", amountMinor, currency }),
+          /* @__PURE__ */ jsxs3(TopupForm.SubmitButton, { className: "solvapay-checkout-pay-button", children: [
+            "Pay ",
+            formatPrice(amountMinor, currency, { locale })
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+function RecurringPayment({ className }) {
+  const flow = useCheckoutContext("Payment");
+  const locale = useLocale();
+  const returnUrl = useReturnUrl();
+  const productRef = useProductRef();
+  const selectedPlanShape = flow.selectedPlan;
+  if (!selectedPlanShape || !flow.selectedPlanRef) return null;
+  const currency = (selectedPlanShape.currency ?? "USD").toUpperCase();
+  const amountMinor = selectedPlanShape.price ?? 0;
+  const cycle = selectedPlanShape.billingCycle;
+  const planName = selectedPlanShape.name ?? "Plan";
+  const isRecurring = !!cycle;
+  const formattedAmount = formatPrice(amountMinor, currency, { locale });
+  const priceLine = isRecurring ? `${formattedAmount}/${shortCycle(cycle)}` : formattedAmount;
+  return /* @__PURE__ */ jsxs3("div", { className: className ?? "solvapay-checkout-payment", "data-branch": "recurring", children: [
+    /* @__PURE__ */ jsx7("div", { className: "solvapay-checkout-order-summary", "data-variant": "recurring", children: /* @__PURE__ */ jsxs3("div", { className: "solvapay-checkout-order-summary-row", children: [
+      /* @__PURE__ */ jsx7("span", { children: planName }),
+      /* @__PURE__ */ jsx7("span", { children: priceLine })
+    ] }) }),
+    /* @__PURE__ */ jsxs3(
+      PaymentForm.Root,
+      {
+        planRef: flow.selectedPlanRef,
+        productRef,
+        returnUrl,
+        requireTermsAcceptance: false,
+        onSuccess: (intent) => flow.notifyPaymentSuccess(intent),
+        children: [
+          /* @__PURE__ */ jsx7(PaymentForm.Loading, {}),
+          /* @__PURE__ */ jsx7(PaymentForm.PaymentElement, {}),
+          /* @__PURE__ */ jsx7(PaymentForm.Error, { className: "solvapay-checkout-error" }),
+          /* @__PURE__ */ jsx7(PaymentForm.MandateText, {}),
+          /* @__PURE__ */ jsx7(PaymentForm.SubmitButton, { className: "solvapay-checkout-pay-button", children: isRecurring ? `Subscribe \u2014 ${priceLine}` : `Pay ${formattedAmount}` })
+        ]
+      }
+    )
+  ] });
+}
+var CheckoutEnvContext = createContext5(null);
+function useReturnUrl() {
+  return useContext6(CheckoutEnvContext)?.returnUrl ?? "";
+}
+function useProductRef() {
+  return useContext6(CheckoutEnvContext)?.productRef ?? "";
+}
+var BackLink = forwardRef6(function CheckoutStepsBackLink({ label, glyph = "\u2190", className, onClick, ...rest }, ref) {
+  const flow = useCheckoutContext("BackLink");
+  if (!flow.canGoBack) return null;
+  const resolvedLabel = label ?? (flow.step === "payment" && flow.branch === "payg" ? "Change amount" : flow.step === "payment" && flow.branch === "recurring" ? "Change plan" : "Back");
+  return /* @__PURE__ */ jsxs3(
+    "button",
+    {
+      ref,
+      type: "button",
+      className: ["solvapay-checkout-back-link", className].filter(Boolean).join(" "),
+      "data-solvapay-checkout-back": "",
+      onClick: (e) => {
+        onClick?.(e);
+        if (e.defaultPrevented) return;
+        flow.back();
+      },
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsx7("span", { className: "solvapay-checkout-back-link-glyph", "aria-hidden": "true", children: glyph }),
+        /* @__PURE__ */ jsx7("span", { className: "solvapay-checkout-back-link-label", children: resolvedLabel })
+      ]
+    }
+  );
+});
+function Success({ className, children }) {
+  const flow = useCheckoutContext("Success");
+  const locale = useLocale();
+  if (flow.step !== "success" || !flow.successMeta) return null;
+  if (children) {
+    return /* @__PURE__ */ jsx7("div", { className: className ?? "solvapay-checkout-success", children });
+  }
+  const meta = flow.successMeta;
+  if (meta.branch === "payg") {
+    return /* @__PURE__ */ jsxs3("div", { className: className ?? "solvapay-checkout-success", "data-branch": "payg", children: [
+      /* @__PURE__ */ jsx7("div", { className: "solvapay-checkout-success-check", "aria-hidden": "true", children: "\u2713" }),
+      /* @__PURE__ */ jsx7("h2", { className: "solvapay-checkout-success-heading", children: "Credits added" }),
+      /* @__PURE__ */ jsx7("p", { className: "solvapay-checkout-success-subheading", children: "Pay as you go plan is active." }),
+      /* @__PURE__ */ jsxs3("dl", { className: "solvapay-checkout-receipt", "data-variant": "payg", children: [
+        /* @__PURE__ */ jsxs3("div", { className: "solvapay-checkout-receipt-row", children: [
+          /* @__PURE__ */ jsx7("dt", { children: "Amount" }),
+          /* @__PURE__ */ jsx7("dd", { children: formatPrice(meta.amountMinor, meta.currency, { locale }) })
+        ] }),
+        /* @__PURE__ */ jsxs3("div", { className: "solvapay-checkout-receipt-row", children: [
+          /* @__PURE__ */ jsx7("dt", { children: "Credits" }),
+          /* @__PURE__ */ jsxs3("dd", { children: [
+            "+",
+            meta.creditsAdded.toLocaleString(locale)
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs3("div", { className: "solvapay-checkout-receipt-row", children: [
+          /* @__PURE__ */ jsx7("dt", { children: "Plan" }),
+          /* @__PURE__ */ jsx7("dd", { children: meta.plan.name ?? "Pay as you go" })
+        ] }),
+        /* @__PURE__ */ jsxs3("div", { className: "solvapay-checkout-receipt-row", children: [
+          /* @__PURE__ */ jsx7("dt", { children: "Rate" }),
+          /* @__PURE__ */ jsx7("dd", { children: meta.rateLabel })
+        ] })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3("div", { className: className ?? "solvapay-checkout-success", "data-branch": "recurring", children: [
+    /* @__PURE__ */ jsx7("div", { className: "solvapay-checkout-success-check", "aria-hidden": "true", children: "\u2713" }),
+    /* @__PURE__ */ jsxs3("h2", { className: "solvapay-checkout-success-heading", children: [
+      meta.plan.name ?? "Plan",
+      " active"
+    ] }),
+    /* @__PURE__ */ jsx7("p", { className: "solvapay-checkout-success-subheading", children: "Subscription is live and credits are ready." }),
+    /* @__PURE__ */ jsxs3("dl", { className: "solvapay-checkout-receipt", "data-variant": "recurring", children: [
+      /* @__PURE__ */ jsxs3("div", { className: "solvapay-checkout-receipt-row", children: [
+        /* @__PURE__ */ jsx7("dt", { children: "Plan" }),
+        /* @__PURE__ */ jsx7("dd", { children: meta.plan.name ?? "Plan" })
+      ] }),
+      meta.creditsIncluded > 0 ? /* @__PURE__ */ jsxs3("div", { className: "solvapay-checkout-receipt-row", children: [
+        /* @__PURE__ */ jsx7("dt", { children: "Credits" }),
+        /* @__PURE__ */ jsxs3("dd", { children: [
+          "+",
+          meta.creditsIncluded.toLocaleString(locale)
+        ] })
+      ] }) : null,
+      /* @__PURE__ */ jsxs3("div", { className: "solvapay-checkout-receipt-row", children: [
+        /* @__PURE__ */ jsx7("dt", { children: "Charged today" }),
+        /* @__PURE__ */ jsx7("dd", { children: formatPrice(meta.chargedTodayMinor, meta.currency, { locale }) })
+      ] }),
+      meta.nextRenewalLabel ? /* @__PURE__ */ jsxs3("div", { className: "solvapay-checkout-receipt-row", children: [
+        /* @__PURE__ */ jsx7("dt", { children: "Next renewal" }),
+        /* @__PURE__ */ jsx7("dd", { children: meta.nextRenewalLabel })
+      ] }) : null
+    ] })
+  ] });
+}
+var RootWithEnv = forwardRef6(
+  function CheckoutStepsRootWithEnv(props, forwardedRef) {
+    const env = useMemo6(
+      () => ({ returnUrl: props.returnUrl, productRef: props.productRef }),
+      [props.returnUrl, props.productRef]
+    );
+    return /* @__PURE__ */ jsx7(CheckoutEnvContext.Provider, { value: env, children: /* @__PURE__ */ jsx7(Root5, { ...props, ref: forwardedRef }) });
+  }
+);
+var CheckoutSteps = {
+  Root: RootWithEnv,
+  IfStep,
+  StepHeading,
+  StepMessage,
+  PlanGrid,
+  PlanContinueButton,
+  AmountPicker: AmountPicker2,
+  AmountContinueButton,
+  Payment,
+  BackLink,
+  Success
+};
+var CheckoutStepsRoot2 = RootWithEnv;
+var CheckoutStepsIfStep = IfStep;
+var CheckoutStepsStepHeading2 = StepHeading;
+var CheckoutStepsStepMessage2 = StepMessage;
+var CheckoutStepsPlanGrid = PlanGrid;
+var CheckoutStepsPlanContinueButton = PlanContinueButton;
+var CheckoutStepsAmountPicker = AmountPicker2;
+var CheckoutStepsAmountContinueButton = AmountContinueButton;
+var CheckoutStepsPayment = Payment;
+var CheckoutStepsBackLink2 = BackLink;
+var CheckoutStepsSuccess = Success;
+
+// src/primitives/PaywallNotice.tsx
+import { Fragment as Fragment5, jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+var PaywallNoticeContext = createContext6(null);
+function usePaywallNoticeCtx(part) {
+  const ctx = useContext7(PaywallNoticeContext);
+  if (!ctx) {
+    throw new Error(`PaywallNotice.${part} must be rendered inside <PaywallNotice.Root>.`);
+  }
+  return ctx;
+}
+var Root6 = forwardRef7(function PaywallNoticeRoot({ content, onResolved, classNames, asChild, children, ...rest }, forwardedRef) {
+  const { resolved, refetch } = usePaywallResolver(content);
+  const classNamesResolved = useMemo7(() => classNames ?? {}, [classNames]);
+  const onResolvedRef = useRef4(onResolved);
+  useEffect5(() => {
+    onResolvedRef.current = onResolved;
+  }, [onResolved]);
+  const hasResolvedRef = useRef4(false);
+  const signalResolved = useCallback5(() => {
+    if (hasResolvedRef.current) return;
+    hasResolvedRef.current = true;
+    onResolvedRef.current?.();
+  }, []);
+  useEffect5(() => {
+    if (resolved) signalResolved();
+  }, [resolved, signalResolved]);
+  const ctx = useMemo7(
+    () => ({
+      content,
+      resolved,
+      refetch,
+      onResolved: signalResolved,
+      classNames: classNamesResolved
+    }),
+    [content, resolved, refetch, signalResolved, classNamesResolved]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx8(PaywallNoticeContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx8(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-paywall-notice": "",
+      "data-kind": content.kind,
+      "data-state": resolved ? "resolved" : "pending",
+      className: classNamesResolved.root,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Heading2 = forwardRef7(function PaywallNoticeHeading({ asChild, children, className, ...rest }, forwardedRef) {
+  const ctx = usePaywallNoticeCtx("Heading");
+  const copy = useCopy();
+  const defaultText = ctx.resolved ? copy.paywall.resolvedHeading : ctx.content.kind === "payment_required" ? copy.paywall.paymentRequiredHeading : isTopupGate(ctx.content) ? copy.paywall.topupRequiredHeading : copy.paywall.activationRequiredHeading;
+  const Comp = asChild ? Slot : "h2";
+  return /* @__PURE__ */ jsx8(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-paywall-heading": "",
+      className: className ?? ctx.classNames.heading,
+      ...rest,
+      children: children ?? defaultText
+    }
+  );
+});
+var Message = forwardRef7(function PaywallNoticeMessage({ asChild, children, className, ...rest }, forwardedRef) {
+  const ctx = usePaywallNoticeCtx("Message");
+  const copy = useCopy();
+  const Comp = asChild ? Slot : "p";
+  const defaultText = resolvePaywallMessage(ctx.content, copy.paywall);
+  return /* @__PURE__ */ jsx8(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-paywall-message": "",
+      className: className ?? ctx.classNames.message,
+      ...rest,
+      children: children ?? defaultText
+    }
+  );
+});
+function isTopupGate(content) {
+  if (content.kind !== "activation_required") return false;
+  const plans = content.plans;
+  if (!plans || plans.length === 0) return false;
+  return plans.every((p) => isPaygPlan(p));
+}
+function resolvePaywallMessage(content, paywallCopy) {
+  const productName = content.kind === "payment_required" || content.kind === "activation_required" ? content.productDetails?.name : void 0;
+  const forProduct = productName ? interpolate(paywallCopy.paymentRequiredProductSuffix, { product: productName }) : "";
+  if (content.kind === "payment_required") {
+    const balance = content.balance;
+    if (!balance) {
+      return interpolate(paywallCopy.paymentRequiredMessageNoBalance, { forProduct });
+    }
+    const remaining = balance.remainingUnits ?? 0;
+    if (remaining <= 0) {
+      return interpolate(paywallCopy.paymentRequiredMessage, { forProduct });
+    }
+    return interpolate(paywallCopy.paymentRequiredMessageRemaining, {
+      remaining: String(remaining),
+      pluralSuffix: remaining === 1 ? "" : "s",
+      forProduct
+    });
+  }
+  if (content.kind === "activation_required") {
+    if (isTopupGate(content)) {
+      return interpolate(paywallCopy.topupRequiredMessage, { forProduct });
+    }
+    return interpolate(paywallCopy.activationRequiredMessage, { forProduct });
+  }
+  return content.message ?? "";
+}
+var ProductContext = forwardRef7(function PaywallNoticeProductContext({ asChild, children, className, ...rest }, forwardedRef) {
+  const ctx = usePaywallNoticeCtx("ProductContext");
+  const copy = useCopy();
+  const product = ctx.content.kind === "activation_required" ? ctx.content.productDetails : void 0;
+  if (!product?.name) return null;
+  const label = interpolate(copy.paywall.productContext, { product: product.name });
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx8(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-paywall-product-context": "",
+      className: className ?? ctx.classNames.productContext,
+      ...rest,
+      children: children ?? label
+    }
+  );
+});
+var Balance = forwardRef7(function PaywallNoticeBalance({ asChild, children, className, ...rest }, forwardedRef) {
+  const ctx = usePaywallNoticeCtx("Balance");
+  const copy = useCopy();
+  const balance = ctx.content.balance;
+  if (ctx.content.kind !== "activation_required" || !balance) return null;
+  const label = interpolate(copy.paywall.balanceLine, {
+    available: String(balance.remainingUnits ?? 0),
+    required: String(balance.creditsPerUnit ?? 1)
+  });
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx8(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-paywall-balance": "",
+      className: className ?? ctx.classNames.balance,
+      ...rest,
+      children: children ?? label
+    }
+  );
+});
+function Plans({ className, children }) {
+  const ctx = usePaywallNoticeCtx("Plans");
+  if (ctx.content.kind !== "activation_required") return null;
+  if (!ctx.content.product) return null;
+  const defaultClass = className ?? ctx.classNames.plans ?? "solvapay-paywall-plans";
+  return /* @__PURE__ */ jsx8("div", { "data-solvapay-paywall-plans": "", className: defaultClass, children: /* @__PURE__ */ jsx8(PlanSelector.Root, { productRef: ctx.content.product, filter: hidesFreePlan, children: children ?? /* @__PURE__ */ jsxs4(Fragment5, { children: [
+    /* @__PURE__ */ jsx8(PlanSelector.Grid, { children: /* @__PURE__ */ jsxs4(PlanSelector.Card, { children: [
+      /* @__PURE__ */ jsx8(PlanSelector.CardBadge, {}),
+      /* @__PURE__ */ jsx8(PlanSelector.CardName, {}),
+      /* @__PURE__ */ jsx8(PlanSelector.CardPrice, {}),
+      /* @__PURE__ */ jsx8(PlanSelector.CardInterval, {})
+    ] }) }),
+    /* @__PURE__ */ jsx8(PlanSelector.Loading, {}),
+    /* @__PURE__ */ jsx8(PlanSelector.Error, {})
+  ] }) }) });
+}
+function hidesFreePlan(plan) {
+  return plan.requiresPayment !== false;
+}
+var HostedCheckoutLink = forwardRef7(function PaywallNoticeHostedCheckoutLink({ asChild, children, className, ...rest }, forwardedRef) {
+  const ctx = usePaywallNoticeCtx("HostedCheckoutLink");
+  const copy = useCopy();
+  const href = ctx.content.checkoutUrl;
+  if (!href) return null;
+  const Comp = asChild ? Slot : "a";
+  return /* @__PURE__ */ jsx8(
+    Comp,
+    {
+      ref: forwardedRef,
+      href,
+      target: "_blank",
+      rel: "noopener noreferrer",
+      "data-solvapay-paywall-hosted-link": "",
+      className: className ?? ctx.classNames.hostedLink,
+      ...rest,
+      children: children ?? copy.paywall.hostedCheckoutButton
+    }
+  );
+});
+function EmbeddedCheckout({ returnUrl, topupCurrency, className }) {
+  const ctx = usePaywallNoticeCtx("EmbeddedCheckout");
+  const productRef = ctx.content.product;
+  const { plans } = usePlans({ productRef: productRef ?? void 0 });
+  const filter = useMemo7(() => buildDefaultCheckoutPlanFilter(plans), [plans]);
+  if (!productRef) return null;
+  const resolvedClassName = className ?? ctx.classNames.embeddedCheckout ?? "solvapay-paywall-embedded-checkout";
+  const headingClassName = ctx.classNames.heading ?? "solvapay-paywall-step-heading";
+  const messageClassName = ctx.classNames.message ?? "solvapay-paywall-step-message";
+  return /* @__PURE__ */ jsxs4(
+    CheckoutSteps.Root,
+    {
+      productRef,
+      returnUrl,
+      filter,
+      topupCurrency,
+      onPurchaseSuccess: () => {
+        void ctx.refetch();
+        ctx.onResolved?.();
+      },
+      className: resolvedClassName,
+      children: [
+        /* @__PURE__ */ jsx8(CheckoutSteps.StepHeading, { className: headingClassName }),
+        /* @__PURE__ */ jsx8(CheckoutSteps.StepMessage, { className: messageClassName }),
+        /* @__PURE__ */ jsxs4(CheckoutSteps.IfStep, { step: "plan", children: [
+          /* @__PURE__ */ jsx8(CheckoutSteps.PlanGrid, {}),
+          /* @__PURE__ */ jsx8(PlanSelector.Loading, {}),
+          /* @__PURE__ */ jsx8(PlanSelector.Error, {}),
+          /* @__PURE__ */ jsx8(CheckoutSteps.PlanContinueButton, {})
+        ] }),
+        /* @__PURE__ */ jsxs4(CheckoutSteps.IfStep, { step: "amount", children: [
+          /* @__PURE__ */ jsx8(CheckoutSteps.BackLink, {}),
+          /* @__PURE__ */ jsx8(CheckoutSteps.AmountPicker, {}),
+          /* @__PURE__ */ jsx8(CheckoutSteps.AmountContinueButton, {})
+        ] }),
+        /* @__PURE__ */ jsxs4(CheckoutSteps.IfStep, { step: "payment", children: [
+          /* @__PURE__ */ jsx8(CheckoutSteps.BackLink, {}),
+          /* @__PURE__ */ jsx8(CheckoutSteps.Payment, {})
+        ] }),
+        /* @__PURE__ */ jsx8(CheckoutSteps.IfStep, { step: "success", children: /* @__PURE__ */ jsx8(CheckoutSteps.Success, {}) })
+      ]
+    }
+  );
+}
+var Retry = forwardRef7(function PaywallNoticeRetry({ asChild, children, className, onClick, ...rest }, forwardedRef) {
+  const ctx = usePaywallNoticeCtx("Retry");
+  const copy = useCopy();
+  const Comp = asChild ? Slot : "button";
+  return /* @__PURE__ */ jsx8(
+    Comp,
+    {
+      ref: forwardedRef,
+      type: "button",
+      disabled: !ctx.resolved,
+      "data-solvapay-paywall-retry": "",
+      "data-state": ctx.resolved ? "ready" : "waiting",
+      className: className ?? ctx.classNames.retryButton,
+      onClick: (e) => {
+        onClick?.(e);
+        if (!e.defaultPrevented && ctx.resolved) ctx.onResolved?.();
+      },
+      ...rest,
+      children: children ?? copy.paywall.retryButton
+    }
+  );
+});
+var PaywallNotice = Object.assign(Root6, {
+  Root: Root6,
+  Heading: Heading2,
+  Message,
+  ProductContext,
+  Plans,
+  Balance,
+  HostedCheckoutLink,
+  EmbeddedCheckout,
+  Retry
+});
+function usePaywallNotice() {
+  return usePaywallNoticeCtx("usePaywallNotice");
+}
+function usePaywallNoticeOptional() {
+  return useContext7(PaywallNoticeContext);
+}
+
+export {
+  TopupForm2 as TopupForm,
+  ProductBadge2 as ProductBadge,
+  PlanBadge,
+  PurchaseGateRoot2 as PurchaseGateRoot,
+  PurchaseGateAllowed2 as PurchaseGateAllowed,
+  PurchaseGateBlocked2 as PurchaseGateBlocked,
+  PurchaseGateLoading2 as PurchaseGateLoading,
+  PurchaseGateError2 as PurchaseGateError,
+  PurchaseGate,
+  usePurchaseGate,
+  ActivationFlowRoot2 as ActivationFlowRoot,
+  ActivationFlowSummary2 as ActivationFlowSummary,
+  ActivationFlowActivateButton2 as ActivationFlowActivateButton,
+  ActivationFlowAmountPicker,
+  ActivationFlowContinueButton2 as ActivationFlowContinueButton,
+  ActivationFlowRetrying2 as ActivationFlowRetrying,
+  ActivationFlowActivated2 as ActivationFlowActivated,
+  ActivationFlowLoading2 as ActivationFlowLoading,
+  ActivationFlowError2 as ActivationFlowError,
+  ActivationFlow,
+  useActivationFlow,
+  CreditGateRoot2 as CreditGateRoot,
+  CreditGateHeading2 as CreditGateHeading,
+  CreditGateSubheading2 as CreditGateSubheading,
+  CreditGateTopup,
+  CreditGateLoading2 as CreditGateLoading,
+  CreditGateError2 as CreditGateError,
+  CreditGate,
+  useCreditGate,
+  useAutoRecharge,
+  configToAutoRechargeInput,
+  AutoRechargeRoot2 as AutoRechargeRoot,
+  AutoRechargeLoading2 as AutoRechargeLoading,
+  AutoRechargeCard2 as AutoRechargeCard,
+  AutoRechargeCardHeading2 as AutoRechargeCardHeading,
+  AutoRechargeCardSummary2 as AutoRechargeCardSummary,
+  AutoRechargeTrigger2 as AutoRechargeTrigger,
+  AutoRechargeOverlay2 as AutoRechargeOverlay,
+  AutoRechargeContent2 as AutoRechargeContent,
+  AutoRechargeTitle2 as AutoRechargeTitle,
+  AutoRechargeEnableQuestion2 as AutoRechargeEnableQuestion,
+  AutoRechargeEnableSentence2 as AutoRechargeEnableSentence,
+  AutoRechargeEnableRow2 as AutoRechargeEnableRow,
+  AutoRechargeCancelButton2 as AutoRechargeCancelButton,
+  AutoRechargeHeader2 as AutoRechargeHeader,
+  AutoRechargeDescription2 as AutoRechargeDescription,
+  AutoRechargeEnableSwitch2 as AutoRechargeEnableSwitch,
+  AutoRechargeFields2 as AutoRechargeFields,
+  AutoRechargeSetup2 as AutoRechargeSetup,
+  AutoRechargeBody2 as AutoRechargeBody,
+  AutoRechargeSummary2 as AutoRechargeSummary,
+  AutoRechargeThresholdField2 as AutoRechargeThresholdField,
+  AutoRechargeTopupField2 as AutoRechargeTopupField,
+  AutoRechargeAmountField2 as AutoRechargeAmountField,
+  AutoRechargeUnitToggle2 as AutoRechargeUnitToggle,
+  AutoRechargeHint2 as AutoRechargeHint,
+  AutoRechargeValidationError2 as AutoRechargeValidationError,
+  AutoRechargeActions2 as AutoRechargeActions,
+  AutoRechargeSaveButton2 as AutoRechargeSaveButton,
+  AutoRechargeDisableButton2 as AutoRechargeDisableButton,
+  AutoRechargeError2 as AutoRechargeError,
+  AutoRechargeStatusMessage2 as AutoRechargeStatusMessage,
+  AutoRechargeStatus2 as AutoRechargeStatus,
+  AutoRechargeCardSetup,
+  AutoRecharge,
+  useAutoRechargeForm,
+  usePaywallResolver,
+  Root6 as Root,
+  Heading2 as Heading,
+  Message,
+  ProductContext,
+  Balance,
+  Plans,
+  HostedCheckoutLink,
+  EmbeddedCheckout,
+  Retry,
+  PaywallNotice,
+  usePaywallNotice,
+  useCheckoutSteps,
+  CheckoutSteps,
+  CheckoutStepsRoot2 as CheckoutStepsRoot,
+  CheckoutStepsIfStep,
+  CheckoutStepsStepHeading2 as CheckoutStepsStepHeading,
+  CheckoutStepsStepMessage2 as CheckoutStepsStepMessage,
+  CheckoutStepsPlanGrid,
+  CheckoutStepsPlanContinueButton,
+  CheckoutStepsAmountPicker,
+  CheckoutStepsAmountContinueButton,
+  CheckoutStepsPayment,
+  CheckoutStepsBackLink2 as CheckoutStepsBackLink,
+  CheckoutStepsSuccess
+};