@solvapay/react 1.0.9-preview.1 → 1.0.9

package/dist/chunk-37R5NZGF.js

@@ -0,0 +1,4824 @@
+import {
+  defaultAuthAdapter
+} from "./chunk-OUSEQRCT.js";
+
+// src/utils/purchases.ts
+function filterPurchases(purchases) {
+  return purchases.filter((purchase) => purchase.status === "active");
+}
+function getActivePurchases(purchases) {
+  return purchases.filter((purchase) => purchase.status === "active");
+}
+function getCancelledPurchasesWithEndDate(purchases) {
+  const now = /* @__PURE__ */ new Date();
+  return purchases.filter((purchase) => {
+    return purchase.status === "active" && purchase.cancelledAt && purchase.endDate && new Date(purchase.endDate) > now;
+  });
+}
+function getMostRecentPurchase(purchases) {
+  if (purchases.length === 0) return null;
+  return purchases.reduce((latest, current) => {
+    return new Date(current.startDate) > new Date(latest.startDate) ? current : latest;
+  });
+}
+function getPrimaryPurchase(purchases) {
+  const filtered = filterPurchases(purchases);
+  if (filtered.length > 0) {
+    return getMostRecentPurchase(filtered);
+  }
+  return null;
+}
+function isPaidPurchase(purchase) {
+  return (purchase.amount ?? 0) > 0;
+}
+function isPlanPurchase(purchase) {
+  return !!purchase.planSnapshot && purchase.metadata?.purpose !== "credit_topup";
+}
+function isTopupPurchase(purchase) {
+  return !isPlanPurchase(purchase);
+}
+
+// src/utils/headers.ts
+var CUSTOMER_REF_KEY = "solvapay_customerRef";
+var CUSTOMER_REF_EXPIRY = "solvapay_customerRef_expiry";
+var CUSTOMER_REF_USER_ID_KEY = "solvapay_customerRef_userId";
+function getAuthAdapter(config) {
+  if (config?.auth?.adapter) {
+    return config.auth.adapter;
+  }
+  return defaultAuthAdapter;
+}
+function getCachedCustomerRef(userId) {
+  if (typeof window === "undefined") return null;
+  const cached = localStorage.getItem(CUSTOMER_REF_KEY);
+  const expiry = localStorage.getItem(CUSTOMER_REF_EXPIRY);
+  const cachedUserId = localStorage.getItem(CUSTOMER_REF_USER_ID_KEY);
+  if (!cached || !expiry) return null;
+  if (Date.now() > parseInt(expiry)) {
+    localStorage.removeItem(CUSTOMER_REF_KEY);
+    localStorage.removeItem(CUSTOMER_REF_EXPIRY);
+    localStorage.removeItem(CUSTOMER_REF_USER_ID_KEY);
+    return null;
+  }
+  if (userId !== void 0 && userId !== null) {
+    if (cachedUserId !== userId) {
+      clearCachedCustomerRef();
+      return null;
+    }
+  }
+  return cached;
+}
+var CACHE_DURATION = 24 * 60 * 60 * 1e3;
+function setCachedCustomerRef(customerRef, userId) {
+  if (typeof window === "undefined") return;
+  if (userId === void 0 || userId === null) {
+    return;
+  }
+  localStorage.setItem(CUSTOMER_REF_KEY, customerRef);
+  localStorage.setItem(CUSTOMER_REF_EXPIRY, String(Date.now() + CACHE_DURATION));
+  localStorage.setItem(CUSTOMER_REF_USER_ID_KEY, userId);
+}
+function clearCachedCustomerRef() {
+  if (typeof window === "undefined") return;
+  localStorage.removeItem(CUSTOMER_REF_KEY);
+  localStorage.removeItem(CUSTOMER_REF_EXPIRY);
+  localStorage.removeItem(CUSTOMER_REF_USER_ID_KEY);
+}
+async function buildRequestHeaders(config) {
+  const adapter = getAuthAdapter(config);
+  const token = await adapter.getToken();
+  const userId = await adapter.getUserId();
+  const cachedRef = getCachedCustomerRef(userId);
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (token) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (cachedRef) {
+    headers["x-solvapay-customer-ref"] = cachedRef;
+  }
+  if (config?.headers) {
+    const custom = typeof config.headers === "function" ? await config.headers() : config.headers;
+    Object.assign(headers, custom);
+  }
+  return { headers, userId };
+}
+
+// src/transport/http.ts
+async function request(config, url, opts) {
+  const { headers } = await buildRequestHeaders(config);
+  const fetchFn = config?.fetch || fetch;
+  const init = { method: opts.method, headers };
+  if (opts.body !== void 0) {
+    init.body = JSON.stringify(opts.body);
+  }
+  const res = await fetchFn(url, init);
+  if (!res.ok) {
+    let serverMessage;
+    try {
+      const data = await res.clone().json();
+      serverMessage = data?.error;
+    } catch {
+    }
+    const error = new Error(serverMessage || `${opts.errorPrefix}: ${res.statusText || res.status}`);
+    config?.onError?.(error, opts.onErrorContext);
+    throw error;
+  }
+  return await res.json();
+}
+var DEFAULT_ROUTES = {
+  checkPurchase: "/api/check-purchase",
+  createPayment: "/api/create-payment-intent",
+  processPayment: "/api/process-payment",
+  createTopupPayment: "/api/create-topup-payment-intent",
+  customerBalance: "/api/customer-balance",
+  cancelRenewal: "/api/cancel-renewal",
+  reactivateRenewal: "/api/reactivate-renewal",
+  activatePlan: "/api/activate-plan",
+  createCheckoutSession: "/api/create-checkout-session",
+  createCustomerSession: "/api/create-customer-session",
+  getMerchant: "/api/merchant",
+  getProduct: "/api/get-product",
+  listPlans: "/api/list-plans",
+  getPaymentMethod: "/api/payment-method",
+  getUsage: "/api/usage"
+};
+function routeFor(config, key) {
+  const configured = config?.api?.[key];
+  return configured || DEFAULT_ROUTES[key];
+}
+function createHttpTransport(config) {
+  return {
+    checkPurchase: () => request(config, routeFor(config, "checkPurchase"), {
+      method: "GET",
+      onErrorContext: "checkPurchase",
+      errorPrefix: "Failed to check purchase"
+    }),
+    createPayment: (params) => {
+      const body = {};
+      if (params.planRef) body.planRef = params.planRef;
+      if (params.productRef) body.productRef = params.productRef;
+      if (params.customer && (params.customer.name || params.customer.email)) {
+        body.customer = params.customer;
+      }
+      return request(config, routeFor(config, "createPayment"), {
+        method: "POST",
+        body,
+        onErrorContext: "createPayment",
+        errorPrefix: "Failed to create payment"
+      });
+    },
+    processPayment: (params) => request(config, routeFor(config, "processPayment"), {
+      method: "POST",
+      body: params,
+      onErrorContext: "processPayment",
+      errorPrefix: "Failed to process payment"
+    }),
+    createTopupPayment: (params) => request(config, routeFor(config, "createTopupPayment"), {
+      method: "POST",
+      body: { amount: params.amount, currency: params.currency },
+      onErrorContext: "createTopupPayment",
+      errorPrefix: "Failed to create topup payment"
+    }),
+    getBalance: () => request(config, routeFor(config, "customerBalance"), {
+      method: "GET",
+      onErrorContext: "getBalance",
+      errorPrefix: "Failed to fetch balance"
+    }),
+    cancelRenewal: (params) => request(config, routeFor(config, "cancelRenewal"), {
+      method: "POST",
+      body: params,
+      onErrorContext: "cancelRenewal",
+      errorPrefix: "Failed to cancel renewal"
+    }),
+    reactivateRenewal: (params) => request(config, routeFor(config, "reactivateRenewal"), {
+      method: "POST",
+      body: params,
+      onErrorContext: "reactivateRenewal",
+      errorPrefix: "Failed to reactivate renewal"
+    }),
+    activatePlan: (params) => request(config, routeFor(config, "activatePlan"), {
+      method: "POST",
+      body: params,
+      onErrorContext: "activatePlan",
+      errorPrefix: "Failed to activate plan"
+    }),
+    createCheckoutSession: (params) => {
+      const body = {};
+      if (params?.planRef) body.planRef = params.planRef;
+      if (params?.productRef) body.productRef = params.productRef;
+      if (params?.returnUrl) body.returnUrl = params.returnUrl;
+      return request(
+        config,
+        routeFor(config, "createCheckoutSession"),
+        {
+          method: "POST",
+          body,
+          onErrorContext: "createCheckoutSession",
+          errorPrefix: "Failed to create checkout session"
+        }
+      );
+    },
+    createCustomerSession: () => request(
+      config,
+      routeFor(config, "createCustomerSession"),
+      {
+        method: "POST",
+        body: {},
+        onErrorContext: "createCustomerSession",
+        errorPrefix: "Failed to create customer session"
+      }
+    ),
+    getMerchant: () => request(config, routeFor(config, "getMerchant"), {
+      method: "GET",
+      onErrorContext: "getMerchant",
+      errorPrefix: "Failed to fetch merchant"
+    }),
+    getProduct: (productRef) => {
+      const base = routeFor(config, "getProduct");
+      const url = `${base}?productRef=${encodeURIComponent(productRef)}`;
+      return request(config, url, {
+        method: "GET",
+        onErrorContext: "getProduct",
+        errorPrefix: "Failed to fetch product"
+      });
+    },
+    listPlans: (productRef) => {
+      const base = routeFor(config, "listPlans");
+      const url = `${base}?productRef=${encodeURIComponent(productRef)}`;
+      return request(config, url, {
+        method: "GET",
+        onErrorContext: "listPlans",
+        errorPrefix: "Failed to list plans"
+      });
+    },
+    getPaymentMethod: () => request(config, routeFor(config, "getPaymentMethod"), {
+      method: "GET",
+      onErrorContext: "getPaymentMethod",
+      errorPrefix: "Failed to load payment method"
+    }),
+    getUsage: () => request(config, routeFor(config, "getUsage"), {
+      method: "GET",
+      onErrorContext: "getUsage",
+      errorPrefix: "Failed to load usage"
+    })
+  };
+}
+
+// src/i18n/en.ts
+function intervalPhrase(ctx) {
+  const interval = ctx.plan?.interval;
+  const count = ctx.plan?.intervalCount ?? 1;
+  if (!interval) return "";
+  return count > 1 ? `${count} ${interval}s` : interval;
+}
+function trialPhrase(ctx) {
+  const trialDays = ctx.plan?.trialDays ?? ctx.trialDays;
+  return trialDays ? ` after your ${trialDays}-day free trial` : "";
+}
+function termsSentence(ctx) {
+  const { termsUrl, privacyUrl } = ctx.merchant;
+  if (termsUrl && privacyUrl) {
+    return ` See ${termsUrl} and ${privacyUrl}.`;
+  }
+  if (termsUrl) return ` See ${termsUrl}.`;
+  if (privacyUrl) return ` See ${privacyUrl}.`;
+  return "";
+}
+var enCopy = {
+  mandate: {
+    recurring: (ctx) => {
+      const period = intervalPhrase(ctx);
+      const trial = trialPhrase(ctx);
+      const every = period ? ` every ${period}` : "";
+      return `By subscribing, you authorize ${ctx.merchant.legalName} to charge ${ctx.amountFormatted}${every}${trial} until you cancel. You can cancel any time. Payments are processed by SolvaPay.${termsSentence(ctx)}`;
+    },
+    oneTime: (ctx) => {
+      const product = ctx.product?.name ? ` for ${ctx.product.name}` : "";
+      return `By confirming, you authorize ${ctx.merchant.legalName} to charge ${ctx.amountFormatted}${product}. Payments are processed by SolvaPay.${termsSentence(ctx)}`;
+    },
+    topup: (ctx) => {
+      const product = ctx.product?.name ? ` to add credits to your ${ctx.product.name} balance` : " to add credits to your balance";
+      return `By confirming, you authorize ${ctx.merchant.legalName} to charge ${ctx.amountFormatted}${product}. Credits are non-refundable once used. Payments are processed by SolvaPay.${termsSentence(ctx)}`;
+    },
+    usageMetered: (ctx) => {
+      const measures = ctx.plan?.measures ?? "unit";
+      const cycle = ctx.plan?.billingCycle ?? "monthly";
+      const product = ctx.product?.name ?? "the service";
+      return `By confirming, you authorize ${ctx.merchant.legalName} to charge your payment method for metered usage of ${product} at ${ctx.amountFormatted} per ${measures}, billed ${cycle}. You can cancel any time. Payments are processed by SolvaPay.${termsSentence(ctx)}`;
+    },
+    freeTier: (ctx) => {
+      const product = ctx.product?.name ?? "this plan";
+      const planPhrase = ctx.plan?.name ? ` on ${ctx.plan.name}` : "";
+      return `By confirming, you activate ${product}${planPhrase}. Payments are processed by SolvaPay.${termsSentence(ctx)}`;
+    }
+  },
+  cta: {
+    payNow: "Pay Now",
+    topUp: "Top Up",
+    subscribe: "Subscribe",
+    trialStart: "Start {trialDays}-day free trial",
+    payAmount: "Pay {amount}",
+    addAmount: "Add {amount}",
+    startUsing: "Start using {product}",
+    processing: "Processing..."
+  },
+  interval: {
+    day: "day",
+    week: "week",
+    month: "month",
+    year: "year",
+    every: "every {n} {unit}",
+    free: "Free",
+    trial: "{trialDays}-day free trial"
+  },
+  terms: {
+    checkboxLabel: "I agree to the terms and privacy policy"
+  },
+  customer: {
+    chargingTo: "Charging to {email}",
+    emailLabel: "Email",
+    nameLabel: "Name"
+  },
+  balance: {
+    credits: " credits",
+    currencyEquivalent: " (~{amount})"
+  },
+  product: {
+    currentProductLabel: "Current product: {name}"
+  },
+  topup: {
+    selectOrEnterAmount: "Please select or enter an amount",
+    minAmount: "Minimum amount is {amount}",
+    maxAmount: "Maximum amount is {amount}"
+  },
+  activation: {
+    paymentRequired: "This plan requires payment. Please select a different plan.",
+    invalidConfiguration: "Invalid plan configuration.",
+    unexpectedResponse: "Unexpected response from server.",
+    failed: "Activation failed"
+  },
+  planSelector: {
+    heading: "Choose your pricing",
+    currentBadge: "Current",
+    popularBadge: "Popular",
+    freeBadge: "Free",
+    perIntervalShort: "/{interval}",
+    continueButton: "Continue",
+    backButton: "\u2190 Back to plans",
+    trialBadge: "{trialDays}-day free trial"
+  },
+  amountPicker: {
+    selectAmountLabel: "Select an amount",
+    customAmountLabel: "Or enter a custom amount",
+    creditEstimateExact: "= {credits} credits",
+    creditEstimateApprox: "~ {credits} credits"
+  },
+  activationFlow: {
+    heading: "Confirm your plan",
+    activateButton: "Activate",
+    activatingLabel: "Activating...",
+    topupHeading: "Add credits",
+    topupSubheading: "Top up your credits to activate this plan.",
+    continueToPayment: "Continue to payment",
+    changeAmountButton: "Change amount",
+    retryingHeading: "Activating your plan...",
+    retryingSubheading: "Payment received. Setting up your plan.",
+    activatedHeading: "Plan selected",
+    activatedSubheading: "Your plan is now active.",
+    tryAgainButton: "Try Again",
+    backButton: "\u2190 Back to plan selection"
+  },
+  cancelPlan: {
+    button: "Cancel plan",
+    buttonLoading: "Cancelling...",
+    confirmRecurring: "Are you sure you want to cancel your subscription?",
+    confirmUsageBased: "Are you sure you want to deactivate your plan? This will take effect immediately."
+  },
+  cancelledNotice: {
+    heading: "Your purchase has been cancelled",
+    expiresLabel: "Purchase Expires: {date}",
+    daysRemaining: "{days} days remaining",
+    dayRemaining: "1 day remaining",
+    accessUntil: "You'll continue to have access to {product} features until this date",
+    accessEnded: "Your purchase access has ended",
+    cancelledOn: "Cancelled on {date}",
+    reactivateButton: "Undo Cancellation",
+    reactivateButtonLoading: "Reactivating..."
+  },
+  creditGate: {
+    lowBalanceHeading: "You're out of credits",
+    lowBalanceSubheading: "Top up to continue using {product}",
+    topUpCta: "Top up now"
+  },
+  currentPlan: {
+    heading: "Your plan",
+    nextBilling: "Next billing: {date}",
+    expiresOn: "Expires {date}",
+    validIndefinitely: "Valid indefinitely",
+    paymentMethod: "{brand} \u2022\u2022\u2022\u2022 {last4}",
+    paymentMethodExpires: "expires {month}/{year}",
+    noPaymentMethod: "No payment method on file",
+    updatePaymentButton: "Update card",
+    cycleUnit: {
+      weekly: "week",
+      monthly: "month",
+      quarterly: "3 months",
+      yearly: "year"
+    }
+  },
+  customerPortal: {
+    launchButton: "Manage billing",
+    loadingLabel: "Loading portal\u2026"
+  },
+  errors: {
+    paymentInitFailed: "Payment initialization failed",
+    topupInitFailed: "Top-up initialization failed",
+    configMissingPlanOrProduct: "PaymentForm: either planRef or productRef is required",
+    configMissingAmount: "TopupForm: amount must be a positive number",
+    unknownError: "Unknown error",
+    stripeUnavailable: "Stripe is not available. Please refresh the page.",
+    paymentIntentUnavailable: "Payment intent not available. Please refresh the page.",
+    cardElementMissing: "Card element not found",
+    paymentUnexpected: "An unexpected error occurred.",
+    paymentProcessingFailed: "Payment processing failed. Please try again or contact support.",
+    paymentRequires3ds: "Payment requires additional authentication. Please complete the verification.",
+    paymentProcessingTimeout: "Payment processing timed out \u2014 webhooks may not be configured",
+    paymentConfirmationDelayed: "Payment succeeded but confirmation is taking longer than usual. Refresh in a moment to see your purchase.",
+    paymentStatusPrefix: "Payment status: {status}",
+    paywallInvalidContent: "Paywall content is missing or malformed.",
+    usageLoadFailed: "Failed to load usage"
+  },
+  paywall: {
+    header: "Unlock access",
+    paymentRequiredHeading: "Upgrade to continue",
+    activationRequiredHeading: "Add credits to continue",
+    resolvedHeading: "You can continue",
+    productContext: "For {product}",
+    balanceLine: "You have {available} credits, need {required}.",
+    paymentRequiredMessage: "You've used all your included calls{forProduct}. Choose a plan below to keep going.",
+    paymentRequiredMessageRemaining: "Only {remaining} call{pluralSuffix} left{forProduct}. Choose a plan below to keep going.",
+    paymentRequiredProductSuffix: " for {product}",
+    retryButton: "Continue",
+    hostedCheckoutButton: "Open checkout",
+    hostedCheckoutLoading: "Loading checkout\u2026"
+  },
+  usage: {
+    header: "Usage",
+    percentUsedLabel: "{percent}% used",
+    usedLabel: "{used} / {total} {unit}",
+    remainingLabel: "{remaining} {unit} remaining",
+    unlimitedLabel: "Unlimited",
+    resetsInLabel: "Resets in {days} days",
+    resetsOnLabel: "Resets {date}",
+    loadingLabel: "Loading usage\u2026",
+    emptyLabel: "No usage-based plan is active.",
+    approachingLimit: "You're approaching your usage limit.",
+    atLimit: "You've reached your usage limit.",
+    topUpCta: "Add credits",
+    upgradeCta: "Upgrade plan",
+    refreshCta: "Refresh"
+  }
+};
+
+// src/i18n/merge.ts
+function mergeCopy(defaults, overrides) {
+  if (!overrides) return defaults;
+  const merged = { ...defaults };
+  for (const sectionKey of Object.keys(overrides)) {
+    const defaultSection = defaults[sectionKey];
+    const overrideSection = overrides[sectionKey];
+    if (!overrideSection) continue;
+    const combined = { ...defaultSection, ...overrideSection };
+    merged[sectionKey] = combined;
+  }
+  return merged;
+}
+
+// src/i18n/context.tsx
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var CopyContext = createContext({
+  locale: void 0,
+  copy: enCopy
+});
+var CopyProvider = ({
+  locale,
+  copy: overrides,
+  children
+}) => {
+  const value = useMemo(
+    () => ({
+      locale,
+      copy: mergeCopy(enCopy, overrides)
+    }),
+    [locale, overrides]
+  );
+  return /* @__PURE__ */ jsx(CopyContext.Provider, { value, children });
+};
+function useCopyContext() {
+  return useContext(CopyContext);
+}
+
+// src/SolvaPayProvider.tsx
+import { createContext as createContext2, useState, useEffect, useCallback, useMemo as useMemo2, useRef } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var SolvaPayContext = createContext2(null);
+function resolveTransport(config) {
+  return config?.transport ?? createHttpTransport(config);
+}
+var SolvaPayProvider = ({ config, children }) => {
+  const initial = config?.initial;
+  const [purchaseData, setPurchaseData] = useState(() => {
+    if (!initial) return { purchases: [] };
+    return {
+      // The server-side `PurchaseCheckResult.purchases` shape has looser
+      // optional fields than `PurchaseInfo`, but the runtime data is
+      // identical — the same rows flow through `transport.checkPurchase()`
+      // today. Cast once here to unify the two entry points, and run
+      // the same `filterPurchases` the HTTP path applies in
+      // `fetchPurchase` so the bootstrap-hydrated data never contains
+      // cancelled / expired / suspended rows the active-only derivations
+      // (`activePurchase`, `hasPaidPurchase`, …) wouldn't expect.
+      purchases: filterPurchases(
+        initial.purchase?.purchases ?? []
+      ),
+      customerRef: initial.customerRef ?? initial.purchase?.customerRef,
+      email: initial.purchase?.email,
+      name: initial.purchase?.name
+    };
+  });
+  const [loading, setLoading] = useState(false);
+  const [isRefetching, setIsRefetching] = useState(false);
+  const [purchaseError, setPurchaseError] = useState(null);
+  const [internalCustomerRef, setInternalCustomerRef] = useState(
+    initial?.customerRef ?? void 0
+  );
+  const [userId, setUserId] = useState(null);
+  const [isAuthenticated, setIsAuthenticated] = useState(!!initial?.customerRef);
+  const [creditsValue, setCreditsValue] = useState(
+    initial?.balance?.credits ?? null
+  );
+  const [displayCurrencyValue, setDisplayCurrencyValue] = useState(
+    initial?.balance?.displayCurrency ?? null
+  );
+  const [creditsPerMinorUnitValue, setCreditsPerMinorUnitValue] = useState(
+    initial?.balance?.creditsPerMinorUnit ?? null
+  );
+  const [displayExchangeRateValue, setDisplayExchangeRateValue] = useState(
+    initial?.balance?.displayExchangeRate ?? null
+  );
+  const [balanceLoading, setBalanceLoading] = useState(false);
+  const balanceInFlightRef = useRef(false);
+  const balanceLoadedRef = useRef(!!initial?.balance);
+  const optimisticUntilRef = useRef(0);
+  const optimisticTimerRef = useRef(null);
+  const fetchBalanceRef = useRef(null);
+  const inFlightRef = useRef(null);
+  const loadedCacheKeysRef = useRef(
+    new Set(initial?.customerRef ? [initial.customerRef] : [])
+  );
+  const configRef = useRef(config);
+  const transportRef = useRef(resolveTransport(config));
+  useEffect(() => {
+    configRef.current = config;
+    transportRef.current = resolveTransport(config);
+  }, [config]);
+  const fetchBalanceImpl = useCallback(async () => {
+    if (optimisticUntilRef.current > Date.now()) return;
+    if (!isAuthenticated && !internalCustomerRef) {
+      setCreditsValue(null);
+      setDisplayCurrencyValue(null);
+      setCreditsPerMinorUnitValue(null);
+      setDisplayExchangeRateValue(null);
+      setBalanceLoading(false);
+      balanceLoadedRef.current = false;
+      return;
+    }
+    if (balanceInFlightRef.current) return;
+    balanceInFlightRef.current = true;
+    if (!balanceLoadedRef.current) {
+      setBalanceLoading(true);
+    }
+    try {
+      if (!transportRef.current.getBalance) {
+        setBalanceLoading(false);
+        balanceInFlightRef.current = false;
+        return;
+      }
+      const data = await transportRef.current.getBalance();
+      setCreditsValue(data.credits ?? null);
+      setDisplayCurrencyValue(data.displayCurrency ?? null);
+      setCreditsPerMinorUnitValue(data.creditsPerMinorUnit ?? null);
+      setDisplayExchangeRateValue(data.displayExchangeRate ?? null);
+      balanceLoadedRef.current = true;
+    } catch (error) {
+      console.error("[SolvaPayProvider] Failed to fetch balance:", error);
+    } finally {
+      setBalanceLoading(false);
+      balanceInFlightRef.current = false;
+    }
+  }, [isAuthenticated, internalCustomerRef]);
+  useEffect(() => {
+    fetchBalanceRef.current = fetchBalanceImpl;
+  }, [fetchBalanceImpl]);
+  useEffect(() => {
+    return () => {
+      if (optimisticTimerRef.current) clearTimeout(optimisticTimerRef.current);
+    };
+  }, []);
+  const OPTIMISTIC_GRACE_MS = 8e3;
+  const adjustBalanceImpl = useCallback((credits) => {
+    setCreditsValue((prev) => (prev ?? 0) + credits);
+    optimisticUntilRef.current = Date.now() + OPTIMISTIC_GRACE_MS;
+    if (optimisticTimerRef.current) clearTimeout(optimisticTimerRef.current);
+    optimisticTimerRef.current = setTimeout(() => {
+      optimisticUntilRef.current = 0;
+      fetchBalanceRef.current?.();
+    }, OPTIMISTIC_GRACE_MS);
+  }, []);
+  const createPayment = useCallback(
+    (params) => transportRef.current.createPayment(params),
+    []
+  );
+  const processPayment = useCallback(
+    (params) => transportRef.current.processPayment(params),
+    []
+  );
+  const createTopupPayment = useCallback(
+    (params) => transportRef.current.createTopupPayment(params),
+    []
+  );
+  useEffect(() => {
+    if (configRef.current?.initial) {
+      setIsAuthenticated(configRef.current.initial.customerRef !== null);
+      return;
+    }
+    const detectAuth = async () => {
+      const currentConfig = configRef.current;
+      const adapter2 = getAuthAdapter(currentConfig);
+      const token = await adapter2.getToken();
+      const detectedUserId = await adapter2.getUserId();
+      const prevUserId = userId;
+      setIsAuthenticated(!!token);
+      setUserId(detectedUserId);
+      if (prevUserId !== null && detectedUserId !== prevUserId) {
+        clearCachedCustomerRef();
+        setInternalCustomerRef(void 0);
+        loadedCacheKeysRef.current.clear();
+        return;
+      }
+      const cachedRef = getCachedCustomerRef(detectedUserId);
+      if (cachedRef && token) {
+        setInternalCustomerRef(cachedRef);
+      } else if (!token) {
+        clearCachedCustomerRef();
+        setInternalCustomerRef(void 0);
+        loadedCacheKeysRef.current.clear();
+      } else if (token && !cachedRef) {
+        setInternalCustomerRef(void 0);
+      }
+    };
+    detectAuth();
+    const adapter = getAuthAdapter(configRef.current);
+    if (typeof adapter.subscribe === "function") {
+      const unsubscribe = adapter.subscribe(() => {
+        detectAuth();
+      });
+      return unsubscribe;
+    }
+    const interval = setInterval(detectAuth, 3e4);
+    return () => clearInterval(interval);
+  }, [userId]);
+  const fetchPurchase = useCallback(
+    async (force = false) => {
+      if (!isAuthenticated && !internalCustomerRef) {
+        setPurchaseData({ purchases: [] });
+        setPurchaseError(null);
+        setLoading(false);
+        setIsRefetching(false);
+        inFlightRef.current = null;
+        return;
+      }
+      const cacheKey = internalCustomerRef || userId || "anonymous";
+      if (inFlightRef.current === cacheKey && !force) {
+        return;
+      }
+      inFlightRef.current = cacheKey;
+      const hasLoadedOnce = loadedCacheKeysRef.current.has(cacheKey);
+      if (hasLoadedOnce) {
+        setIsRefetching(true);
+      } else {
+        setLoading(true);
+      }
+      try {
+        if (!transportRef.current.checkPurchase) {
+          setLoading(false);
+          setIsRefetching(false);
+          loadedCacheKeysRef.current.add(cacheKey);
+          inFlightRef.current = null;
+          return;
+        }
+        const data = await transportRef.current.checkPurchase();
+        if (data.customerRef) {
+          setInternalCustomerRef(data.customerRef);
+          loadedCacheKeysRef.current.add(data.customerRef);
+          const currentAdapter = getAuthAdapter(configRef.current);
+          const currentUserId = await currentAdapter.getUserId();
+          setCachedCustomerRef(data.customerRef, currentUserId);
+        }
+        if (inFlightRef.current === cacheKey) {
+          const filteredData = {
+            ...data,
+            purchases: filterPurchases(data.purchases || [])
+          };
+          setPurchaseData(filteredData);
+          setPurchaseError(null);
+        }
+      } catch (err) {
+        console.error("[SolvaPayProvider] Failed to fetch purchase:", err);
+        if (inFlightRef.current === cacheKey) {
+          setPurchaseError(err instanceof Error ? err : new Error(String(err)));
+        }
+      } finally {
+        if (inFlightRef.current === cacheKey) {
+          loadedCacheKeysRef.current.add(cacheKey);
+          setLoading(false);
+          setIsRefetching(false);
+          inFlightRef.current = null;
+        }
+      }
+    },
+    [isAuthenticated, internalCustomerRef, userId]
+  );
+  const fetchPurchaseRef = useRef(fetchPurchase);
+  useEffect(() => {
+    fetchPurchaseRef.current = fetchPurchase;
+  }, [fetchPurchase]);
+  const applyInitialRef = useRef(null);
+  const refetchPurchase = useCallback(async () => {
+    inFlightRef.current = null;
+    const refresh = configRef.current?.refreshInitial;
+    const hasCheckPurchase = !!transportRef.current.checkPurchase;
+    if (refresh && !hasCheckPurchase) {
+      setIsRefetching(true);
+      try {
+        const next = await refresh();
+        if (next) applyInitialRef.current?.(next);
+      } catch (err) {
+        console.error("[SolvaPayProvider] refetchPurchase (MCP) failed:", err);
+      } finally {
+        setIsRefetching(false);
+      }
+      return;
+    }
+    await fetchPurchaseRef.current(true);
+  }, []);
+  const applyInitial = useCallback((next) => {
+    setPurchaseData({
+      // Mirror the HTTP path: strip non-active rows before any
+      // derivation (`activePurchase` etc.) reads the array.
+      purchases: filterPurchases(
+        next.purchase?.purchases ?? []
+      ),
+      customerRef: next.customerRef ?? next.purchase?.customerRef,
+      email: next.purchase?.email,
+      name: next.purchase?.name
+    });
+    if (next.customerRef) {
+      setInternalCustomerRef(next.customerRef);
+      loadedCacheKeysRef.current.add(next.customerRef);
+    } else {
+      setInternalCustomerRef(void 0);
+      loadedCacheKeysRef.current.clear();
+    }
+    setIsAuthenticated(next.customerRef !== null);
+    setCreditsValue(next.balance?.credits ?? null);
+    setDisplayCurrencyValue(next.balance?.displayCurrency ?? null);
+    setCreditsPerMinorUnitValue(next.balance?.creditsPerMinorUnit ?? null);
+    setDisplayExchangeRateValue(next.balance?.displayExchangeRate ?? null);
+    balanceLoadedRef.current = !!next.balance;
+  }, []);
+  useEffect(() => {
+    applyInitialRef.current = applyInitial;
+  }, [applyInitial]);
+  const refreshBootstrap = useCallback(async () => {
+    const refresh = configRef.current?.refreshInitial;
+    if (refresh) {
+      try {
+        const next = await refresh();
+        if (next) applyInitial(next);
+      } catch (err) {
+        console.error("[SolvaPayProvider] refreshBootstrap failed:", err);
+      }
+      return;
+    }
+    await Promise.all([refetchPurchase(), fetchBalanceRef.current?.() ?? Promise.resolve()]);
+  }, [refetchPurchase, applyInitial]);
+  const cancelRenewal = useCallback(
+    async (params) => {
+      const result = await transportRef.current.cancelRenewal(params);
+      await refetchPurchase();
+      return result;
+    },
+    [refetchPurchase]
+  );
+  const reactivateRenewal = useCallback(
+    async (params) => {
+      const result = await transportRef.current.reactivateRenewal(params);
+      await refetchPurchase();
+      return result;
+    },
+    [refetchPurchase]
+  );
+  const activatePlan = useCallback(
+    async (params) => {
+      const result = await transportRef.current.activatePlan(params);
+      if (result.status === "activated" || result.status === "already_active") {
+        await refetchPurchase();
+      }
+      return result;
+    },
+    [refetchPurchase]
+  );
+  const hydratedFromInitialRef = useRef(!!initial);
+  useEffect(() => {
+    inFlightRef.current = null;
+    if (hydratedFromInitialRef.current) {
+      hydratedFromInitialRef.current = false;
+      return;
+    }
+    if (isAuthenticated || internalCustomerRef) {
+      fetchPurchase();
+    } else {
+      setPurchaseData({ purchases: [] });
+      setPurchaseError(null);
+      setLoading(false);
+      setIsRefetching(false);
+    }
+  }, [isAuthenticated, internalCustomerRef, userId]);
+  const updateCustomerRef = useCallback(
+    (newCustomerRef) => {
+      setInternalCustomerRef(newCustomerRef);
+      setCachedCustomerRef(newCustomerRef, userId);
+      fetchPurchase(true);
+    },
+    [fetchPurchase, userId]
+  );
+  const purchase = useMemo2(() => {
+    const planPurchases = purchaseData.purchases.filter(isPlanPurchase);
+    const balanceTransactions = purchaseData.purchases.filter((p) => !isPlanPurchase(p));
+    const activePurchase = getPrimaryPurchase(planPurchases);
+    const activePaidPurchases = planPurchases.filter(
+      (p) => p.status === "active" && isPaidPurchase(p)
+    );
+    const activePaidPurchase = activePaidPurchases.sort(
+      (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
+    )[0] || null;
+    return {
+      loading,
+      isRefetching,
+      error: purchaseError,
+      customerRef: purchaseData.customerRef || internalCustomerRef,
+      email: purchaseData.email,
+      name: purchaseData.name,
+      purchases: purchaseData.purchases,
+      hasProduct: (productName) => {
+        return planPurchases.some(
+          (p) => p.productName.toLowerCase() === productName.toLowerCase() && p.status === "active"
+        );
+      },
+      activePurchase,
+      hasPaidPurchase: activePaidPurchases.length > 0,
+      activePaidPurchase,
+      balanceTransactions
+    };
+  }, [loading, isRefetching, purchaseError, purchaseData, internalCustomerRef]);
+  const balance = useMemo2(
+    () => ({
+      loading: balanceLoading,
+      credits: creditsValue,
+      displayCurrency: displayCurrencyValue,
+      creditsPerMinorUnit: creditsPerMinorUnitValue,
+      displayExchangeRate: displayExchangeRateValue,
+      refetch: fetchBalanceImpl,
+      adjustBalance: adjustBalanceImpl
+    }),
+    [
+      balanceLoading,
+      creditsValue,
+      displayCurrencyValue,
+      creditsPerMinorUnitValue,
+      displayExchangeRateValue,
+      fetchBalanceImpl,
+      adjustBalanceImpl
+    ]
+  );
+  const contextValue = useMemo2(
+    () => ({
+      purchase,
+      refetchPurchase,
+      createPayment,
+      processPayment,
+      createTopupPayment,
+      cancelRenewal,
+      reactivateRenewal,
+      activatePlan,
+      customerRef: purchaseData.customerRef || internalCustomerRef,
+      updateCustomerRef,
+      balance,
+      refreshBootstrap,
+      _config: configRef.current
+    }),
+    [
+      purchase,
+      refetchPurchase,
+      createPayment,
+      processPayment,
+      createTopupPayment,
+      cancelRenewal,
+      reactivateRenewal,
+      activatePlan,
+      purchaseData.customerRef,
+      internalCustomerRef,
+      updateCustomerRef,
+      balance,
+      refreshBootstrap
+    ]
+  );
+  return /* @__PURE__ */ jsx2(SolvaPayContext.Provider, { value: contextValue, children: /* @__PURE__ */ jsx2(CopyProvider, { locale: config?.locale, copy: config?.copy, children }) });
+};
+
+// src/primitives/composeRefs.ts
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref !== null && ref !== void 0) {
+    ;
+    ref.current = value;
+  }
+}
+function composeRefs(...refs) {
+  return (node) => {
+    for (const ref of refs) {
+      setRef(ref, node);
+    }
+  };
+}
+
+// src/primitives/slot.tsx
+import React3 from "react";
+import { Fragment, jsx as jsx3 } from "react/jsx-runtime";
+var Slot = React3.forwardRef((props, forwardedRef) => {
+  const { children, ...slotProps } = props;
+  const childrenArray = React3.Children.toArray(children);
+  const slottable = childrenArray.find(isSlottable);
+  if (slottable) {
+    const newElement = slottable.props.children;
+    const newChildren = childrenArray.map((child) => {
+      if (child === slottable) {
+        if (React3.Children.count(newElement) > 1) return React3.Children.only(null);
+        return React3.isValidElement(newElement) ? newElement.props.children : null;
+      }
+      return child;
+    });
+    return /* @__PURE__ */ jsx3(SlotClone, { ...slotProps, ref: forwardedRef, children: React3.isValidElement(newElement) ? React3.cloneElement(newElement, void 0, newChildren) : null });
+  }
+  return /* @__PURE__ */ jsx3(SlotClone, { ...slotProps, ref: forwardedRef, children });
+});
+Slot.displayName = "Slot";
+var SlotClone = React3.forwardRef(
+  (props, forwardedRef) => {
+    const { children, ...slotProps } = props;
+    if (React3.isValidElement(children)) {
+      const childProps = children.props ?? {};
+      const childRef = getElementRef(children);
+      const props2 = mergeProps(slotProps, childProps);
+      const cloneProps = { ...props2 };
+      if (forwardedRef) {
+        cloneProps.ref = childRef ? composeRefs(forwardedRef, childRef) : forwardedRef;
+      } else {
+        cloneProps.ref = childRef;
+      }
+      return React3.cloneElement(children, cloneProps);
+    }
+    return React3.Children.count(children) > 1 ? React3.Children.only(null) : null;
+  }
+);
+SlotClone.displayName = "SlotClone";
+var Slottable = ({ children }) => {
+  return /* @__PURE__ */ jsx3(Fragment, { children });
+};
+function isSlottable(child) {
+  return React3.isValidElement(child) && child.type === Slottable;
+}
+function mergeProps(slotProps, childProps) {
+  const overrideProps = { ...childProps };
+  for (const propName in slotProps) {
+    const slotPropValue = slotProps[propName];
+    const childPropValue = childProps[propName];
+    const isHandler = /^on[A-Z]/.test(propName);
+    if (isHandler) {
+      if (slotPropValue && childPropValue) {
+        overrideProps[propName] = (...args) => {
+          ;
+          childPropValue(...args);
+          const first = args[0];
+          if (!first?.defaultPrevented) {
+            ;
+            slotPropValue(...args);
+          }
+        };
+      } else if (slotPropValue) {
+        overrideProps[propName] = slotPropValue;
+      }
+    } else if (propName === "style") {
+      overrideProps[propName] = {
+        ...slotPropValue,
+        ...childPropValue
+      };
+    } else if (propName === "className") {
+      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+    } else if (propName === "ref") {
+    } else if (childPropValue === void 0) {
+      overrideProps[propName] = slotPropValue;
+    }
+  }
+  return overrideProps;
+}
+function getElementRef(element) {
+  const el = element;
+  return el.props?.ref ?? el.ref ?? null;
+}
+
+// src/primitives/composeEventHandlers.ts
+function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {
+  return function handleEvent(event) {
+    originalEventHandler?.(event);
+    if (checkForDefaultPrevented === false || !event.defaultPrevented) {
+      ourEventHandler?.(event);
+    }
+  };
+}
+
+// src/hooks/useSolvaPay.ts
+import { useContext as useContext2 } from "react";
+function useSolvaPay() {
+  const context = useContext2(SolvaPayContext);
+  if (!context) {
+    throw new Error(
+      "useSolvaPay must be used within a SolvaPayProvider. Wrap your component tree with <SolvaPayProvider> to use this hook."
+    );
+  }
+  return context;
+}
+
+// src/hooks/useCheckout.ts
+import { useState as useState2, useCallback as useCallback2, useRef as useRef2 } from "react";
+import { loadStripe } from "@stripe/stripe-js";
+var stripePromiseCache = /* @__PURE__ */ new Map();
+function getStripeCacheKey(publishableKey, accountId) {
+  return accountId ? `${publishableKey}:${accountId}` : publishableKey;
+}
+async function resolvePlanRef(productRef, config) {
+  const listPlansRoute = config?.api?.listPlans || "/api/list-plans";
+  const url = `${listPlansRoute}?productRef=${encodeURIComponent(productRef)}`;
+  const fetchFn = config?.fetch || fetch;
+  const { headers } = await buildRequestHeaders(config);
+  const res = await fetchFn(url, { method: "GET", headers });
+  if (!res.ok) {
+    throw new Error(`Failed to fetch plans for product "${productRef}": ${res.statusText}`);
+  }
+  const data = await res.json();
+  const allPlans = data.plans ?? [];
+  const activePlans = allPlans.filter((p) => p.isActive !== false && p.status !== "inactive");
+  if (activePlans.length === 0) {
+    throw new Error(
+      `No active plans found for product "${productRef}". Configure at least one plan in the SolvaPay Console.`
+    );
+  }
+  if (activePlans.length === 1) {
+    return activePlans[0].reference;
+  }
+  const defaultPlan = activePlans.find((p) => p.default === true);
+  if (defaultPlan) {
+    return defaultPlan.reference;
+  }
+  throw new Error(
+    `Product "${productRef}" has ${activePlans.length} active plans but none is marked as default. Either pass planRef explicitly, use <PricingSelector> for user selection, or mark one plan as default in the SolvaPay Console.`
+  );
+}
+function useCheckout(options) {
+  const { planRef, productRef, customer } = options;
+  const { createPayment, customerRef, updateCustomerRef, _config } = useSolvaPay();
+  const [loading, setLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [stripePromise, setStripePromise] = useState2(null);
+  const [clientSecret, setClientSecret] = useState2(null);
+  const [resolvedPlanRef, setResolvedPlanRef] = useState2(planRef || null);
+  const isStartingRef = useRef2(false);
+  const startCheckout = useCallback2(async () => {
+    if (isStartingRef.current || loading) {
+      return;
+    }
+    if (!planRef && !productRef) {
+      setError(
+        new Error(
+          "useCheckout: either planRef or productRef is required. Pass planRef directly, or pass productRef to auto-resolve the plan."
+        )
+      );
+      return;
+    }
+    isStartingRef.current = true;
+    setLoading(true);
+    setError(null);
+    try {
+      let effectivePlanRef = planRef;
+      if (!effectivePlanRef && productRef) {
+        effectivePlanRef = await resolvePlanRef(productRef, _config);
+        setResolvedPlanRef(effectivePlanRef);
+      }
+      if (!effectivePlanRef) {
+        throw new Error("Could not determine plan reference for checkout");
+      }
+      const result = await createPayment({
+        planRef: effectivePlanRef,
+        productRef,
+        customer
+      });
+      if (!result || typeof result !== "object") {
+        throw new Error("Invalid payment intent response from server");
+      }
+      if (!result.clientSecret || typeof result.clientSecret !== "string") {
+        throw new Error("Invalid client secret in payment intent response");
+      }
+      if (!result.publishableKey || typeof result.publishableKey !== "string") {
+        throw new Error("Invalid publishable key in payment intent response");
+      }
+      if (result.customerRef && result.customerRef !== customerRef && updateCustomerRef) {
+        updateCustomerRef(result.customerRef);
+      }
+      const stripeOptions = result.accountId ? { stripeAccount: result.accountId } : {};
+      const cacheKey = getStripeCacheKey(result.publishableKey, result.accountId);
+      let stripe = stripePromiseCache.get(cacheKey);
+      if (!stripe) {
+        stripe = loadStripe(result.publishableKey, stripeOptions);
+        stripePromiseCache.set(cacheKey, stripe);
+      }
+      setStripePromise(stripe);
+      setClientSecret(result.clientSecret);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to start checkout");
+      setError(error2);
+    } finally {
+      setLoading(false);
+      isStartingRef.current = false;
+    }
+  }, [planRef, productRef, customer, createPayment, updateCustomerRef, loading, _config]);
+  const reset = useCallback2(() => {
+    isStartingRef.current = false;
+    setLoading(false);
+    setError(null);
+    setStripePromise(null);
+    setClientSecret(null);
+    setResolvedPlanRef(planRef || null);
+  }, [planRef]);
+  return {
+    loading,
+    error,
+    stripePromise,
+    clientSecret,
+    resolvedPlanRef,
+    startCheckout,
+    reset
+  };
+}
+
+// src/hooks/usePurchase.ts
+function usePurchase() {
+  const { purchase, refetchPurchase } = useSolvaPay();
+  return {
+    ...purchase,
+    refetch: refetchPurchase
+  };
+}
+
+// src/hooks/useCustomer.ts
+function useCustomer() {
+  const { purchase, customerRef } = useSolvaPay();
+  return {
+    customerRef: purchase.customerRef || customerRef,
+    email: purchase.email,
+    name: purchase.name,
+    loading: purchase.loading
+  };
+}
+
+// src/hooks/useCopy.ts
+function useCopy() {
+  return useCopyContext().copy;
+}
+function useLocale() {
+  return useCopyContext().locale;
+}
+
+// src/hooks/usePlans.ts
+import { useState as useState3, useEffect as useEffect2, useCallback as useCallback3, useMemo as useMemo3, useRef as useRef3 } from "react";
+var plansCache = /* @__PURE__ */ new Map();
+var CACHE_DURATION2 = 5 * 60 * 1e3;
+function processPlans(raw, filter, sortBy) {
+  let result = sortBy ? [...raw].sort(sortBy) : raw;
+  if (filter) result = result.filter(filter);
+  return result;
+}
+function computeInitialIndex(plans, initialPlanRef, autoSelectFirstPaid) {
+  if (plans.length === 0) return 0;
+  if (initialPlanRef) {
+    const idx = plans.findIndex((p) => p.reference === initialPlanRef);
+    if (idx >= 0) return idx;
+  }
+  if (autoSelectFirstPaid) {
+    const idx = plans.findIndex((p) => p.requiresPayment !== false);
+    return idx >= 0 ? idx : 0;
+  }
+  return 0;
+}
+function usePlans(options) {
+  const {
+    fetcher,
+    productRef,
+    filter,
+    sortBy,
+    autoSelectFirstPaid = false,
+    initialPlanRef,
+    selectionReady = true
+  } = options;
+  const fetcherRef = useRef3(fetcher);
+  const filterRef = useRef3(filter);
+  const sortByRef = useRef3(sortBy);
+  const autoSelectFirstPaidRef = useRef3(autoSelectFirstPaid);
+  const initialPlanRefRef = useRef3(initialPlanRef);
+  const selectionReadyRef = useRef3(selectionReady);
+  const hasAppliedInitialRef = useRef3(false);
+  const userHasSelectedRef = useRef3(false);
+  const [selectedPlanIndex, setSelectedPlanIndexState] = useState3(() => {
+    if (!selectionReady || !productRef) return 0;
+    const cached = plansCache.get(productRef);
+    if (!cached || Date.now() - cached.timestamp >= CACHE_DURATION2 || cached.plans.length === 0) {
+      return 0;
+    }
+    const processed = processPlans(cached.plans, filter, sortBy);
+    if (processed.length === 0) return 0;
+    const idx = computeInitialIndex(processed, initialPlanRef, autoSelectFirstPaid);
+    hasAppliedInitialRef.current = true;
+    return idx;
+  });
+  const [plans, setPlans] = useState3(() => {
+    if (!productRef) return [];
+    const cached = plansCache.get(productRef);
+    if (!cached || Date.now() - cached.timestamp >= CACHE_DURATION2 || cached.plans.length === 0) {
+      return [];
+    }
+    return processPlans(cached.plans, filter, sortBy);
+  });
+  const [loading, setLoading] = useState3(() => plans.length === 0);
+  const [error, setError] = useState3(null);
+  useEffect2(() => {
+    fetcherRef.current = fetcher;
+  }, [fetcher]);
+  useEffect2(() => {
+    filterRef.current = filter;
+  }, [filter]);
+  useEffect2(() => {
+    sortByRef.current = sortBy;
+  }, [sortBy]);
+  useEffect2(() => {
+    autoSelectFirstPaidRef.current = autoSelectFirstPaid;
+  }, [autoSelectFirstPaid]);
+  useEffect2(() => {
+    initialPlanRefRef.current = initialPlanRef;
+  }, [initialPlanRef]);
+  useEffect2(() => {
+    selectionReadyRef.current = selectionReady;
+  }, [selectionReady]);
+  const setSelectedPlanIndex = useCallback3((index) => {
+    userHasSelectedRef.current = true;
+    setSelectedPlanIndexState(index);
+  }, []);
+  const applyInitialSelection = useCallback3((processedPlans) => {
+    if (hasAppliedInitialRef.current || userHasSelectedRef.current) return;
+    if (!selectionReadyRef.current || processedPlans.length === 0) return;
+    hasAppliedInitialRef.current = true;
+    const idx = computeInitialIndex(
+      processedPlans,
+      initialPlanRefRef.current,
+      autoSelectFirstPaidRef.current
+    );
+    setSelectedPlanIndexState(idx);
+  }, []);
+  const fetchPlans = useCallback3(
+    async (force = false) => {
+      if (!productRef) {
+        setError(new Error("Product reference not configured"));
+        setLoading(false);
+        return;
+      }
+      const cached = plansCache.get(productRef);
+      const now = Date.now();
+      if (!force && cached && now - cached.timestamp < CACHE_DURATION2) {
+        const processedPlans = processPlans(
+          cached.plans,
+          filterRef.current,
+          sortByRef.current
+        );
+        setPlans(processedPlans);
+        setLoading(false);
+        setError(null);
+        applyInitialSelection(processedPlans);
+        return;
+      }
+      if (cached?.promise) {
+        try {
+          setLoading(true);
+          const fetchedPlans = await cached.promise;
+          const processedPlans = processPlans(
+            fetchedPlans,
+            filterRef.current,
+            sortByRef.current
+          );
+          setPlans(processedPlans);
+          setError(null);
+          applyInitialSelection(processedPlans);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error("Failed to load plans"));
+        } finally {
+          setLoading(false);
+        }
+        return;
+      }
+      try {
+        setLoading(true);
+        setError(null);
+        const fetchPromise = fetcherRef.current(productRef);
+        plansCache.set(productRef, { plans: [], timestamp: now, promise: fetchPromise });
+        const fetchedPlans = await fetchPromise;
+        plansCache.set(productRef, { plans: fetchedPlans, timestamp: now, promise: null });
+        const processedPlans = processPlans(
+          fetchedPlans,
+          filterRef.current,
+          sortByRef.current
+        );
+        setPlans(processedPlans);
+        applyInitialSelection(processedPlans);
+      } catch (err) {
+        plansCache.delete(productRef);
+        setError(err instanceof Error ? err : new Error("Failed to load plans"));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [productRef, applyInitialSelection]
+  );
+  useEffect2(() => {
+    fetchPlans();
+  }, [fetchPlans]);
+  useEffect2(() => {
+    if (hasAppliedInitialRef.current || userHasSelectedRef.current) return;
+    if (!selectionReady || plans.length === 0) return;
+    applyInitialSelection(plans);
+  }, [selectionReady, plans, applyInitialSelection]);
+  const selectedPlan = useMemo3(() => plans[selectedPlanIndex] || null, [plans, selectedPlanIndex]);
+  const selectPlan = useCallback3(
+    (planRef) => {
+      const index = plans.findIndex((p) => p.reference === planRef);
+      if (index >= 0) {
+        setSelectedPlanIndex(index);
+      }
+    },
+    [plans, setSelectedPlanIndex]
+  );
+  return {
+    plans,
+    loading,
+    error,
+    selectedPlanIndex,
+    selectedPlan,
+    setSelectedPlanIndex,
+    selectPlan,
+    refetch: () => fetchPlans(true),
+    isSelectionReady: hasAppliedInitialRef.current
+  };
+}
+
+// src/hooks/usePlan.ts
+import { useCallback as useCallback4, useEffect as useEffect3, useState as useState4 } from "react";
+async function listPlans(productRef, config) {
+  const base = config?.api?.listPlans || "/api/list-plans";
+  const url = `${base}?productRef=${encodeURIComponent(productRef)}`;
+  const fetchFn = config?.fetch || fetch;
+  const { headers } = await buildRequestHeaders(config);
+  const res = await fetchFn(url, { method: "GET", headers });
+  if (!res.ok) {
+    const error = new Error(`Failed to fetch plans: ${res.statusText || res.status}`);
+    config?.onError?.(error, "listPlans");
+    throw error;
+  }
+  const data = await res.json();
+  return data.plans ?? [];
+}
+function usePlan(options) {
+  const { planRef, productRef } = options;
+  const { _config } = useSolvaPay();
+  const findPlan = useCallback4(
+    (plans) => {
+      if (!planRef) return null;
+      return plans.find((p) => p.reference === planRef) || null;
+    },
+    [planRef]
+  );
+  const [plan, setPlan] = useState4(() => {
+    if (!planRef || !productRef) return null;
+    const cached = plansCache.get(productRef);
+    if (!cached || Date.now() - cached.timestamp >= CACHE_DURATION2) return null;
+    return findPlan(cached.plans);
+  });
+  const [loading, setLoading] = useState4(() => !!(planRef && !plan));
+  const [error, setError] = useState4(null);
+  const load = useCallback4(
+    async (force = false) => {
+      if (!planRef) {
+        setPlan(null);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+      if (!productRef) {
+        setLoading(false);
+        setError(
+          new Error("usePlan: productRef is required to resolve a plan reference")
+        );
+        return;
+      }
+      const cached = plansCache.get(productRef);
+      const now = Date.now();
+      if (!force && cached?.plans.length && now - cached.timestamp < CACHE_DURATION2) {
+        const p = findPlan(cached.plans);
+        setPlan(p);
+        setLoading(false);
+        setError(
+          p ? null : new Error(
+            `Plan "${planRef}" not found in product "${productRef}"`
+          )
+        );
+        return;
+      }
+      if (!force && cached?.promise) {
+        try {
+          setLoading(true);
+          const plans = await cached.promise;
+          const p = findPlan(plans);
+          setPlan(p);
+          setError(
+            p ? null : new Error(
+              `Plan "${planRef}" not found in product "${productRef}"`
+            )
+          );
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error("Failed to load plan"));
+        } finally {
+          setLoading(false);
+        }
+        return;
+      }
+      try {
+        setLoading(true);
+        setError(null);
+        const promise = listPlans(productRef, _config);
+        plansCache.set(productRef, { plans: [], timestamp: now, promise });
+        const plans = await promise;
+        plansCache.set(productRef, { plans, timestamp: now, promise: null });
+        const p = findPlan(plans);
+        setPlan(p);
+        if (!p) {
+          setError(new Error(`Plan "${planRef}" not found in product "${productRef}"`));
+        }
+      } catch (err) {
+        plansCache.delete(productRef);
+        setError(err instanceof Error ? err : new Error("Failed to load plan"));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [planRef, productRef, _config, findPlan]
+  );
+  useEffect3(() => {
+    load();
+  }, [load]);
+  return {
+    plan,
+    loading,
+    error,
+    refetch: () => load(true)
+  };
+}
+
+// src/hooks/useProduct.ts
+import { useCallback as useCallback5, useEffect as useEffect4, useState as useState5 } from "react";
+
+// src/transport/cache-key.ts
+var transportIds = /* @__PURE__ */ new WeakMap();
+var nextTransportId = 0;
+function transportIdFor(transport) {
+  let id = transportIds.get(transport);
+  if (id === void 0) {
+    id = ++nextTransportId;
+    transportIds.set(transport, id);
+  }
+  return id;
+}
+function createTransportCacheKey(config, fallbackRoute, suffix) {
+  const transport = config?.transport;
+  if (transport) {
+    const id = transportIdFor(transport);
+    return suffix ? `transport:${id}:${suffix}` : `transport:${id}`;
+  }
+  return fallbackRoute;
+}
+
+// src/hooks/useProduct.ts
+var productCache = /* @__PURE__ */ new Map();
+var CACHE_DURATION3 = 5 * 60 * 1e3;
+function cacheKeyFor(config, productRef) {
+  return createTransportCacheKey(config, productRef, productRef);
+}
+async function fetchProduct(productRef, config) {
+  const transport = config?.transport ?? createHttpTransport(config);
+  if (!transport.getProduct) return null;
+  return transport.getProduct(productRef);
+}
+function useProduct(productRef) {
+  const { _config } = useSolvaPay();
+  const cacheKey = productRef ? cacheKeyFor(_config, productRef) : "";
+  const [product, setProduct] = useState5(
+    () => productRef ? productCache.get(cacheKey)?.product ?? null : null
+  );
+  const [loading, setLoading] = useState5(() => {
+    if (!productRef) return false;
+    const cached = productCache.get(cacheKey);
+    return !cached || !cached.product && !cached.promise;
+  });
+  const [error, setError] = useState5(null);
+  const load = useCallback5(
+    async (force = false) => {
+      if (!productRef) {
+        setProduct(null);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+      const key = cacheKeyFor(_config, productRef);
+      const cached = productCache.get(key);
+      const now = Date.now();
+      if (!force && cached?.product && now - cached.timestamp < CACHE_DURATION3) {
+        setProduct(cached.product);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+      if (!force && cached?.promise) {
+        try {
+          setLoading(true);
+          const p = await cached.promise;
+          setProduct(p);
+          setError(null);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error("Failed to load product"));
+        } finally {
+          setLoading(false);
+        }
+        return;
+      }
+      try {
+        setLoading(true);
+        setError(null);
+        const promise = fetchProduct(productRef, _config);
+        productCache.set(key, {
+          product: cached?.product ?? null,
+          promise,
+          timestamp: now
+        });
+        const p = await promise;
+        if (p === null) {
+          productCache.set(key, {
+            product: cached?.product ?? null,
+            promise: null,
+            timestamp: cached?.timestamp ?? now
+          });
+          setProduct(cached?.product ?? null);
+          setLoading(false);
+          return;
+        }
+        productCache.set(key, { product: p, promise: null, timestamp: now });
+        setProduct(p);
+      } catch (err) {
+        productCache.delete(key);
+        setError(err instanceof Error ? err : new Error("Failed to load product"));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [productRef, _config]
+  );
+  useEffect4(() => {
+    load();
+  }, [load]);
+  return {
+    product,
+    loading,
+    error,
+    refetch: () => load(true)
+  };
+}
+
+// src/hooks/useActivation.ts
+import { useState as useState6, useCallback as useCallback6 } from "react";
+function useActivation() {
+  const { activatePlan } = useSolvaPay();
+  const copy = useCopy();
+  const [state, setState] = useState6("idle");
+  const [error, setError] = useState6(null);
+  const [result, setResult] = useState6(null);
+  const activate = useCallback6(
+    async (params) => {
+      setState("activating");
+      setError(null);
+      setResult(null);
+      try {
+        const data = await activatePlan(params);
+        setResult(data);
+        switch (data.status) {
+          case "activated":
+          case "already_active":
+            setState("activated");
+            break;
+          case "topup_required":
+            setState("topup_required");
+            break;
+          case "payment_required":
+            setError(copy.activation.paymentRequired);
+            setState("payment_required");
+            break;
+          case "invalid":
+            setError(data.message || copy.activation.invalidConfiguration);
+            setState("error");
+            break;
+          default:
+            setError(copy.activation.unexpectedResponse);
+            setState("error");
+        }
+      } catch (err) {
+        setError(err instanceof Error ? err.message : copy.activation.failed);
+        setState("error");
+      }
+    },
+    [activatePlan, copy]
+  );
+  const reset = useCallback6(() => {
+    setState("idle");
+    setError(null);
+    setResult(null);
+  }, []);
+  return { activate, state, error, result, reset };
+}
+
+// src/components/PaymentFormContext.tsx
+import { createContext as createContext3, useContext as useContext3 } from "react";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var PaymentFormContext = createContext3(null);
+function usePaymentForm() {
+  const ctx = useContext3(PaymentFormContext);
+  if (!ctx) {
+    throw new Error(
+      "PaymentForm subcomponents must be used inside a <PaymentForm>. Wrap the slots with <PaymentForm planRef=... productRef=...>."
+    );
+  }
+  return ctx;
+}
+var PaymentFormProvider = ({ value, children }) => /* @__PURE__ */ jsx4(PaymentFormContext.Provider, { value, children });
+
+// src/utils/format.ts
+var ZERO_DECIMAL_CURRENCIES = /* @__PURE__ */ new Set([
+  "bif",
+  "clp",
+  "djf",
+  "gnf",
+  "jpy",
+  "kmf",
+  "krw",
+  "mga",
+  "pyg",
+  "rwf",
+  "ugx",
+  "vnd",
+  "vuv",
+  "xaf",
+  "xof",
+  "xpf"
+]);
+function getFractionDigits(currency) {
+  return ZERO_DECIMAL_CURRENCIES.has(currency.toLowerCase()) ? 0 : 2;
+}
+function getMinorUnitsPerMajor(currency) {
+  return getFractionDigits(currency) === 0 ? 1 : 100;
+}
+function toMajorUnits(amountMinor, currency) {
+  const fractionDigits = getFractionDigits(currency);
+  return fractionDigits === 0 ? amountMinor : amountMinor / 100;
+}
+function formatPrice(amountMinor, currency, opts = {}) {
+  const { locale, interval, intervalCount = 1, free = "Free" } = opts;
+  if (amountMinor === 0 && free !== "") {
+    return free;
+  }
+  const naturalFractionDigits = getFractionDigits(currency);
+  const minorPerMajor = getMinorUnitsPerMajor(currency);
+  const isWhole = amountMinor % minorPerMajor === 0;
+  const fractionDigits = isWhole ? 0 : naturalFractionDigits;
+  const major = toMajorUnits(amountMinor, currency);
+  const formatter = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currency.toUpperCase(),
+    minimumFractionDigits: fractionDigits,
+    maximumFractionDigits: fractionDigits
+  });
+  const formatted = formatter.format(major);
+  if (!interval) return formatted;
+  const suffix = intervalCount > 1 ? `${intervalCount} ${interval}s` : interval;
+  return `${formatted} / ${suffix}`;
+}
+
+// src/i18n/interpolate.ts
+function interpolate(template, vars) {
+  return template.replace(/\{(\w+)\}/g, (match, key) => {
+    const value = vars[key];
+    if (value === void 0 || value === null) return match;
+    return String(value);
+  });
+}
+
+// src/primitives/CheckoutSummary.tsx
+import { createContext as createContext5, forwardRef, useContext as useContext5, useMemo as useMemo4 } from "react";
+
+// src/components/PlanSelectionContext.tsx
+import { createContext as createContext4, useContext as useContext4 } from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var PlanSelectionContext = createContext4(null);
+var PlanSelectionProvider = ({
+  value,
+  children
+}) => /* @__PURE__ */ jsx5(PlanSelectionContext.Provider, { value, children });
+function usePlanSelection() {
+  return useContext4(PlanSelectionContext);
+}
+
+// src/utils/errors.ts
+var DOCS_BASE_URL = "https://solvapay.com/docs";
+var SolvaPayError = class extends Error {
+  code;
+  docsUrl;
+  constructor(code, message, docsUrl) {
+    super(message);
+    this.name = "SolvaPayError";
+    this.code = code;
+    this.docsUrl = docsUrl;
+  }
+};
+var MissingProviderError = class extends SolvaPayError {
+  constructor(primitiveName) {
+    const docsUrl = `${DOCS_BASE_URL}/troubleshooting/missing-provider`;
+    super(
+      "MISSING_PROVIDER",
+      `${primitiveName} must be rendered inside <SolvaPayProvider>. Wrap your app (or the section using ${primitiveName}) with <SolvaPayProvider config={{ ... }}>. See ${docsUrl}`,
+      docsUrl
+    );
+    this.name = "MissingProviderError";
+  }
+};
+var MissingProductRefError = class extends SolvaPayError {
+  constructor(primitiveName) {
+    const docsUrl = `${DOCS_BASE_URL}/primitives/product-ref`;
+    super(
+      "MISSING_PRODUCT_REF",
+      `${primitiveName} requires a productRef. Pass the \`productRef\` prop (or set NEXT_PUBLIC_SOLVAPAY_PRODUCT_REF). See ${docsUrl}`,
+      docsUrl
+    );
+    this.name = "MissingProductRefError";
+  }
+};
+
+// src/primitives/CheckoutSummary.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var CheckoutSummaryContext = createContext5(null);
+function useCheckoutSummaryContext(part) {
+  const ctx = useContext5(CheckoutSummaryContext);
+  if (!ctx) {
+    throw new Error(
+      `CheckoutSummary.${part} must be rendered inside <CheckoutSummary.Root>.`
+    );
+  }
+  return ctx;
+}
+var Root = forwardRef(function CheckoutSummaryRoot({ planRef, productRef, asChild, children, ...rest }, forwardedRef) {
+  const solva = useContext5(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("CheckoutSummary");
+  const locale = useLocale();
+  const copy = useCopy();
+  const planSelection = usePlanSelection();
+  const resolvedPlanRef = planRef ?? planSelection?.selectedPlanRef ?? void 0;
+  const resolvedProductRef = productRef ?? planSelection?.productRef;
+  const { plan, loading: planLoading } = usePlan({
+    planRef: resolvedPlanRef,
+    productRef: resolvedProductRef
+  });
+  const { product, loading: productLoading } = useProduct(resolvedProductRef);
+  const loading = planLoading || productLoading;
+  const priceFormatted = useMemo4(() => {
+    const price = plan?.price ?? 0;
+    const currency = plan?.currency ?? "usd";
+    return formatPrice(price, currency, {
+      locale,
+      interval: plan?.interval,
+      intervalCount: 1,
+      free: copy.interval.free
+    });
+  }, [plan, locale, copy.interval.free]);
+  const trialBanner = useMemo4(() => {
+    const trialDays = plan?.trialDays;
+    if (!trialDays || trialDays <= 0) return null;
+    return interpolate(copy.interval.trial, { trialDays });
+  }, [plan?.trialDays, copy.interval.trial]);
+  const ctx = useMemo4(
+    () => ({ plan, product, priceFormatted, trialBanner, loading }),
+    [plan, product, priceFormatted, trialBanner, loading]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary": "", ...rest, children: /* @__PURE__ */ jsx6(CheckoutSummaryContext.Provider, { value: ctx, children }) });
+});
+var ProductSlot = forwardRef(function CheckoutSummaryProduct({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useCheckoutSummaryContext("Product");
+  const name = ctx.product?.name;
+  if (!name) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-product": "", ...rest, children: children ?? name });
+});
+var PlanSlot = forwardRef(function CheckoutSummaryPlan({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useCheckoutSummaryContext("Plan");
+  const name = ctx.plan?.name;
+  if (!name) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-plan": "", ...rest, children: children ?? name });
+});
+var PriceSlot = forwardRef(function CheckoutSummaryPrice({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useCheckoutSummaryContext("Price");
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-price": "", ...rest, children: children ?? ctx.priceFormatted });
+});
+var TrialSlot = forwardRef(function CheckoutSummaryTrial({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useCheckoutSummaryContext("Trial");
+  if (!ctx.trialBanner) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-trial": "", ...rest, children: children ?? ctx.trialBanner });
+});
+var TaxNoteSlot = forwardRef(function CheckoutSummaryTaxNote({ asChild, children, ...rest }, forwardedRef) {
+  useCheckoutSummaryContext("TaxNote");
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx6(Comp, { ref: forwardedRef, "data-solvapay-checkout-summary-tax-note": "", ...rest, children: children ?? "Taxes calculated at checkout" });
+});
+var CheckoutSummaryRoot2 = Root;
+var CheckoutSummaryProduct2 = ProductSlot;
+var CheckoutSummaryPlan2 = PlanSlot;
+var CheckoutSummaryPrice2 = PriceSlot;
+var CheckoutSummaryTrial2 = TrialSlot;
+var CheckoutSummaryTaxNote2 = TaxNoteSlot;
+var CheckoutSummary = {
+  Root,
+  Product: ProductSlot,
+  Plan: PlanSlot,
+  Price: PriceSlot,
+  Trial: TrialSlot,
+  TaxNote: TaxNoteSlot
+};
+function useCheckoutSummary() {
+  return useCheckoutSummaryContext("useCheckoutSummary");
+}
+
+// src/components/CheckoutSummary.tsx
+import { jsx as jsx7, jsxs } from "react/jsx-runtime";
+var CheckoutSummary2 = ({
+  planRef,
+  productRef,
+  showTrial = true,
+  showTaxNote = false,
+  className
+}) => {
+  const rootClass = ["solvapay-checkout-summary", className].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs(CheckoutSummary.Root, { planRef, productRef, className: rootClass, children: [
+    /* @__PURE__ */ jsx7(CheckoutSummary.Product, { className: "solvapay-checkout-summary-product" }),
+    /* @__PURE__ */ jsxs("div", { className: "solvapay-checkout-summary-row", children: [
+      /* @__PURE__ */ jsx7(CheckoutSummary.Plan, { className: "solvapay-checkout-summary-plan" }),
+      /* @__PURE__ */ jsx7(CheckoutSummary.Price, { className: "solvapay-checkout-summary-price" })
+    ] }),
+    showTrial && /* @__PURE__ */ jsx7(CheckoutSummary.Trial, { className: "solvapay-checkout-summary-trial" }),
+    showTaxNote && /* @__PURE__ */ jsx7(CheckoutSummary.TaxNote, { className: "solvapay-checkout-summary-tax-note" })
+  ] });
+};
+
+// src/hooks/useMerchant.ts
+import { useCallback as useCallback7, useEffect as useEffect5, useState as useState7 } from "react";
+var merchantCache = /* @__PURE__ */ new Map();
+var CACHE_DURATION4 = 5 * 60 * 1e3;
+function cacheKeyFor2(config) {
+  return createTransportCacheKey(config, config?.api?.getMerchant || "/api/merchant");
+}
+async function fetchMerchant(config) {
+  const transport = config?.transport ?? createHttpTransport(config);
+  if (!transport.getMerchant) return null;
+  return transport.getMerchant();
+}
+function useMerchant() {
+  const { _config } = useSolvaPay();
+  const key = cacheKeyFor2(_config);
+  const [merchant, setMerchant] = useState7(
+    () => merchantCache.get(key)?.merchant ?? null
+  );
+  const [loading, setLoading] = useState7(() => {
+    const cached = merchantCache.get(key);
+    return !cached || !cached.merchant && !cached.promise;
+  });
+  const [error, setError] = useState7(null);
+  const load = useCallback7(
+    async (force = false) => {
+      const cached = merchantCache.get(key);
+      const now = Date.now();
+      if (!force && cached?.merchant && now - cached.timestamp < CACHE_DURATION4) {
+        setMerchant(cached.merchant);
+        setLoading(false);
+        setError(null);
+        return;
+      }
+      if (!force && cached?.promise) {
+        try {
+          setLoading(true);
+          const m = await cached.promise;
+          setMerchant(m);
+          setError(null);
+        } catch (err) {
+          setError(err instanceof Error ? err : new Error("Failed to load merchant"));
+        } finally {
+          setLoading(false);
+        }
+        return;
+      }
+      try {
+        setLoading(true);
+        setError(null);
+        const promise = fetchMerchant(_config);
+        merchantCache.set(key, {
+          merchant: cached?.merchant ?? null,
+          promise,
+          timestamp: now
+        });
+        const m = await promise;
+        if (m === null) {
+          merchantCache.set(key, {
+            merchant: cached?.merchant ?? null,
+            promise: null,
+            timestamp: cached?.timestamp ?? now
+          });
+          setMerchant(cached?.merchant ?? null);
+          setLoading(false);
+          return;
+        }
+        merchantCache.set(key, { merchant: m, promise: null, timestamp: now });
+        setMerchant(m);
+      } catch (err) {
+        merchantCache.delete(key);
+        setError(err instanceof Error ? err : new Error("Failed to load merchant"));
+      } finally {
+        setLoading(false);
+      }
+    },
+    [_config, key]
+  );
+  useEffect5(() => {
+    load();
+  }, [load]);
+  return {
+    merchant,
+    loading,
+    error,
+    refetch: () => load(true)
+  };
+}
+
+// src/utils/checkoutVariant.ts
+function deriveVariant(plan, mode) {
+  if (mode === "topup") return "topup";
+  if (!plan?.type) return "oneTime";
+  if (plan.type === "usage-based") {
+    return plan.billingModel === "post-paid" ? "usageMetered" : "topup";
+  }
+  if (plan.requiresPayment === false) return "freeTier";
+  switch (plan.type) {
+    case "recurring":
+      return "recurring";
+    case "one-time":
+    default:
+      return "oneTime";
+  }
+}
+
+// src/primitives/MandateText.tsx
+import { forwardRef as forwardRef2, useContext as useContext6, useMemo as useMemo5 } from "react";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var MandateText = forwardRef2(
+  function MandateText2({
+    planRef,
+    productRef,
+    variant,
+    mode,
+    amountMinor,
+    currency,
+    asChild,
+    children,
+    ...rest
+  }, forwardedRef) {
+    const solva = useContext6(SolvaPayContext);
+    if (!solva) throw new MissingProviderError("MandateText");
+    const locale = useLocale();
+    const copy = useCopy();
+    const planSelection = usePlanSelection();
+    const resolvedPlanRef = planRef ?? planSelection?.selectedPlanRef ?? void 0;
+    const resolvedProductRef = productRef ?? planSelection?.productRef;
+    const { plan } = usePlan({ planRef: resolvedPlanRef, productRef: resolvedProductRef });
+    const { product } = useProduct(resolvedProductRef);
+    const { merchant } = useMerchant();
+    const resolvedVariant = variant || deriveVariant(plan, mode);
+    const effectiveAmount = amountMinor ?? plan?.price ?? 0;
+    const effectiveCurrency = currency ?? plan?.currency ?? merchant?.defaultCurrency ?? "usd";
+    const amountFormatted = formatPrice(effectiveAmount, effectiveCurrency, {
+      locale,
+      free: copy.interval.free
+    });
+    const ctx = useMemo5(
+      () => ({
+        merchant: {
+          legalName: merchant?.legalName ?? merchant?.displayName ?? "",
+          displayName: merchant?.displayName,
+          supportEmail: merchant?.supportEmail,
+          termsUrl: merchant?.termsUrl,
+          privacyUrl: merchant?.privacyUrl
+        },
+        plan: plan ? {
+          name: plan.name,
+          interval: plan.interval,
+          intervalCount: 1,
+          trialDays: plan.trialDays,
+          measures: plan.measures,
+          billingCycle: plan.billingCycle
+        } : void 0,
+        product: product ? { name: product.name } : void 0,
+        amountFormatted,
+        trialDays: plan?.trialDays
+      }),
+      [merchant, plan, product, amountFormatted]
+    );
+    const template = copy.mandate[resolvedVariant];
+    const text = typeof template === "function" ? template(ctx) : template;
+    if (!text) return null;
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ jsx8(
+      Comp,
+      {
+        ref: forwardedRef,
+        "data-solvapay-mandate-text": "",
+        "data-variant": resolvedVariant,
+        ...rest,
+        children: children ?? text
+      }
+    );
+  }
+);
+
+// src/components/Spinner.tsx
+import { jsx as jsx9, jsxs as jsxs2 } from "react/jsx-runtime";
+var SIZE_PX = { sm: 16, md: 20, lg: 24 };
+var Spinner = ({ className, size = "md" }) => {
+  const px = SIZE_PX[size];
+  return /* @__PURE__ */ jsxs2(
+    "svg",
+    {
+      "data-solvapay-spinner": "",
+      className,
+      width: px,
+      height: px,
+      viewBox: "0 0 24 24",
+      fill: "none",
+      "aria-hidden": "true",
+      children: [
+        /* @__PURE__ */ jsx9(
+          "circle",
+          {
+            cx: "12",
+            cy: "12",
+            r: "10",
+            stroke: "currentColor",
+            strokeWidth: "4",
+            strokeOpacity: "0.25"
+          }
+        ),
+        /* @__PURE__ */ jsx9(
+          "path",
+          {
+            fill: "currentColor",
+            fillOpacity: "0.75",
+            d: "M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/utils/confirmPayment.ts
+async function confirmPayment(input) {
+  const { stripe, elements, clientSecret, mode, returnUrl, billingDetails, copy } = input;
+  try {
+    if (mode === "payment-element") {
+      const paymentElement = elements.getElement("payment");
+      if (!paymentElement) {
+        return { status: "error", message: copy.errors.cardElementMissing };
+      }
+      const { error: submitError } = await elements.submit();
+      if (submitError) {
+        return {
+          status: "error",
+          message: submitError.message || copy.errors.paymentUnexpected
+        };
+      }
+      const { error: error2, paymentIntent: paymentIntent2 } = await stripe.confirmPayment({
+        elements,
+        clientSecret,
+        confirmParams: {
+          return_url: returnUrl,
+          payment_method_data: billingDetails ? { billing_details: billingDetails } : void 0
+        },
+        redirect: "if_required"
+      });
+      if (error2) {
+        return { status: "error", message: error2.message || copy.errors.paymentUnexpected };
+      }
+      return mapIntent(paymentIntent2, copy);
+    }
+    const cardElement = elements.getElement("card");
+    if (!cardElement) {
+      return { status: "error", message: copy.errors.cardElementMissing };
+    }
+    const { error, paymentIntent } = await stripe.confirmCardPayment(clientSecret, {
+      payment_method: {
+        card: cardElement,
+        billing_details: billingDetails
+      }
+    });
+    if (error) {
+      return { status: "error", message: error.message || copy.errors.paymentUnexpected };
+    }
+    return mapIntent(paymentIntent, copy);
+  } catch (err) {
+    return {
+      status: "error",
+      message: err instanceof Error ? err.message : copy.errors.paymentUnexpected
+    };
+  }
+}
+function mapIntent(paymentIntent, copy) {
+  if (!paymentIntent) {
+    return { status: "error", message: copy.errors.paymentUnexpected };
+  }
+  if (paymentIntent.status === "succeeded") {
+    return { status: "succeeded", paymentIntent };
+  }
+  if (paymentIntent.status === "requires_action") {
+    return { status: "requires_action", message: copy.errors.paymentRequires3ds };
+  }
+  return {
+    status: "other",
+    message: interpolate(copy.errors.paymentStatusPrefix, {
+      status: paymentIntent.status || "processing"
+    }),
+    paymentIntent
+  };
+}
+
+// src/utils/checkoutCta.ts
+function resolveCta(input) {
+  if (input.override) return input.override;
+  const { variant, plan, product, amountFormatted, copy } = input;
+  if (variant === "recurring") {
+    if (plan?.trialDays && plan.trialDays > 0) {
+      return interpolate(copy.cta.trialStart, { trialDays: plan.trialDays });
+    }
+    return copy.cta.subscribe;
+  }
+  if (variant === "oneTime") {
+    return interpolate(copy.cta.payAmount, { amount: amountFormatted });
+  }
+  if (variant === "topup") {
+    return interpolate(copy.cta.addAmount, { amount: amountFormatted });
+  }
+  if (variant === "usageMetered" || variant === "freeTier") {
+    const productName = product?.name ?? (typeof plan?.metadata?.productName === "string" ? plan.metadata.productName : plan?.name ?? "service");
+    return interpolate(copy.cta.startUsing, { product: productName });
+  }
+  return copy.cta.payNow;
+}
+
+// src/primitives/PaymentForm.tsx
+import {
+  forwardRef as forwardRef3,
+  useCallback as useCallback8,
+  useContext as useContext7,
+  useEffect as useEffect6,
+  useMemo as useMemo6,
+  useRef as useRef4,
+  useState as useState8
+} from "react";
+import {
+  Elements,
+  useStripe,
+  useElements,
+  PaymentElement as StripePaymentElement,
+  CardElement as StripeCardElement
+} from "@stripe/react-stripe-js";
+
+// src/utils/processPaymentResult.ts
+async function reconcilePayment(input) {
+  const { paymentIntentId, productRef, planRef, processPayment, refetchPurchase, copy } = input;
+  if (!processPayment || !productRef) {
+    try {
+      await refetchPurchase();
+      return { status: "success" };
+    } catch (err) {
+      return {
+        status: "error",
+        error: err instanceof Error ? err : new Error(String(err))
+      };
+    }
+  }
+  try {
+    const result = await processPayment({ paymentIntentId, productRef, planRef });
+    const isTimeout = result?.status === "timeout";
+    if (isTimeout) {
+      for (let attempt = 1; attempt <= 5; attempt++) {
+        await new Promise((resolve) => setTimeout(resolve, attempt * 1e3));
+        await refetchPurchase();
+      }
+      return {
+        status: "timeout",
+        error: new Error(copy.errors.paymentProcessingTimeout)
+      };
+    }
+    await refetchPurchase();
+    return { status: "success" };
+  } catch (err) {
+    return {
+      status: "error",
+      error: err instanceof Error ? err : new Error(String(err))
+    };
+  }
+}
+
+// src/primitives/PaymentForm.tsx
+import { Fragment as Fragment2, jsx as jsx10, jsxs as jsxs3 } from "react/jsx-runtime";
+function toSubmitVariant(variant) {
+  switch (variant) {
+    case "freeTier":
+      return "free";
+    case "topup":
+      return "topup";
+    case "usageMetered":
+      return "activate";
+    default:
+      return "paid";
+  }
+}
+var Root2 = forwardRef3(function PaymentFormRoot(props, forwardedRef) {
+  const {
+    planRef,
+    productRef,
+    onSuccess,
+    onResult,
+    onFreePlan,
+    onError,
+    returnUrl,
+    submitButtonText,
+    className,
+    buttonClassName,
+    prefillCustomer,
+    requireTermsAcceptance = false,
+    children
+  } = props;
+  const solva = useContext7(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("PaymentForm");
+  const copy = useCopy();
+  const locale = useLocale();
+  const planSelection = usePlanSelection();
+  const effectivePlanRef = planRef ?? planSelection?.selectedPlanRef ?? void 0;
+  const effectiveProductRef = productRef ?? planSelection?.productRef;
+  const { plan: resolvedPlan } = usePlan({
+    planRef: effectivePlanRef,
+    productRef: effectiveProductRef
+  });
+  const isFreePlan = resolvedPlan?.requiresPayment === false;
+  const {
+    loading: checkoutLoading,
+    error: checkoutError,
+    clientSecret,
+    startCheckout,
+    stripePromise,
+    resolvedPlanRef
+  } = useCheckout({
+    planRef: effectivePlanRef,
+    productRef: effectiveProductRef,
+    customer: prefillCustomer
+  });
+  const hasInitializedRef = useRef4(false);
+  const hasPlanOrProduct = !!(effectivePlanRef || effectiveProductRef);
+  useEffect6(() => {
+    if (isFreePlan) return;
+    if (!hasInitializedRef.current && hasPlanOrProduct && !checkoutLoading && !checkoutError && !clientSecret) {
+      hasInitializedRef.current = true;
+      startCheckout().catch(() => {
+        hasInitializedRef.current = false;
+      });
+    }
+    if (hasPlanOrProduct && clientSecret) {
+      hasInitializedRef.current = true;
+    }
+  }, [
+    hasPlanOrProduct,
+    checkoutLoading,
+    checkoutError,
+    clientSecret,
+    startCheckout,
+    isFreePlan
+  ]);
+  const finalReturnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
+  const elementsOptions = useMemo6(() => {
+    if (!clientSecret) return void 0;
+    return { clientSecret, locale };
+  }, [clientSecret, locale]);
+  const shouldRenderElements = !!(stripePromise && clientSecret);
+  if (!hasPlanOrProduct) {
+    return /* @__PURE__ */ jsx10(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "error",
+        children: /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-error": "", children: copy.errors.configMissingPlanOrProduct })
+      }
+    );
+  }
+  if (checkoutError) {
+    return /* @__PURE__ */ jsx10(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "error",
+        children: /* @__PURE__ */ jsxs3("div", { "data-solvapay-payment-form-error": "", children: [
+          copy.errors.paymentInitFailed,
+          " ",
+          checkoutError.message || copy.errors.unknownError
+        ] })
+      }
+    );
+  }
+  if (isFreePlan && resolvedPlan) {
+    return /* @__PURE__ */ jsx10(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "ready",
+        "data-variant": "free",
+        children: /* @__PURE__ */ jsx10(
+          FreeInner,
+          {
+            planRef: effectivePlanRef,
+            productRef: effectiveProductRef,
+            plan: resolvedPlan,
+            resolvedPlanRef,
+            requireTermsAcceptance,
+            submitButtonText,
+            buttonClassName,
+            onFreePlan,
+            onResult,
+            onError,
+            children
+          }
+        )
+      }
+    );
+  }
+  if (shouldRenderElements && elementsOptions) {
+    return /* @__PURE__ */ jsx10(
+      "div",
+      {
+        ref: forwardedRef,
+        className,
+        "data-solvapay-payment-form": "",
+        "data-state": "ready",
+        "data-variant": "paid",
+        children: /* @__PURE__ */ jsx10(Elements, { stripe: stripePromise, options: elementsOptions, children: /* @__PURE__ */ jsx10(
+          PaidInner,
+          {
+            planRef: effectivePlanRef,
+            productRef: effectiveProductRef,
+            prefillCustomer,
+            resolvedPlanRef,
+            plan: resolvedPlan ?? null,
+            clientSecret,
+            returnUrl: finalReturnUrl,
+            submitButtonText,
+            buttonClassName,
+            requireTermsAcceptance,
+            onSuccess,
+            onResult,
+            onError,
+            children
+          }
+        ) }, clientSecret)
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx10(
+    "div",
+    {
+      ref: forwardedRef,
+      className,
+      "data-solvapay-payment-form": "",
+      "data-state": "loading",
+      children: /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-loading": "", children: /* @__PURE__ */ jsx10(Spinner, { size: "md" }) })
+    }
+  );
+});
+var PaidInner = ({
+  planRef,
+  productRef,
+  prefillCustomer,
+  resolvedPlanRef,
+  plan,
+  clientSecret,
+  returnUrl,
+  submitButtonText,
+  buttonClassName,
+  requireTermsAcceptance,
+  onSuccess,
+  onResult,
+  onError,
+  children
+}) => {
+  const stripe = useStripe();
+  const elements = useElements();
+  const copy = useCopy();
+  const customer = useCustomer();
+  const { processPayment } = useSolvaPay();
+  const { refetch, hasPaidPurchase } = usePurchase();
+  const hasPaidPurchaseRef = useRef4(hasPaidPurchase);
+  useEffect6(() => {
+    hasPaidPurchaseRef.current = hasPaidPurchase;
+  }, [hasPaidPurchase]);
+  const [elementKind, setElementKind] = useState8(
+    children ? null : "payment-element"
+  );
+  const [paymentInputComplete, setPaymentInputComplete] = useState8(false);
+  const [termsAccepted, setTermsAccepted] = useState8(false);
+  const [isProcessing, setIsProcessing] = useState8(false);
+  const [error, setError] = useState8(null);
+  const isReady = !!(stripe && elements);
+  const canSubmit = isReady && !!clientSecret && !!elementKind && paymentInputComplete && (!requireTermsAcceptance || termsAccepted) && !isProcessing;
+  const submit = useCallback8(async () => {
+    if (!stripe || !elements || !clientSecret || !elementKind) {
+      const msg2 = !stripe || !elements ? copy.errors.stripeUnavailable : copy.errors.paymentIntentUnavailable;
+      setError(msg2);
+      onError?.(new Error(msg2));
+      return;
+    }
+    setError(null);
+    setIsProcessing(true);
+    const result = await confirmPayment({
+      stripe,
+      elements,
+      clientSecret,
+      mode: elementKind,
+      returnUrl,
+      billingDetails: {
+        name: customer.name ?? prefillCustomer?.name,
+        email: customer.email ?? prefillCustomer?.email
+      },
+      copy
+    });
+    if (result.status === "error") {
+      setError(result.message);
+      setIsProcessing(false);
+      onError?.(new Error(result.message));
+      return;
+    }
+    if (result.status === "requires_action" || result.status === "other") {
+      setError(result.message);
+      setIsProcessing(false);
+      return;
+    }
+    const paymentIntent = result.paymentIntent;
+    const reconcileResult = await reconcilePayment({
+      paymentIntentId: paymentIntent.id,
+      productRef,
+      planRef: planRef || resolvedPlanRef || void 0,
+      processPayment,
+      refetchPurchase: refetch,
+      copy
+    });
+    if (reconcileResult.status === "success") {
+      const pi = paymentIntent;
+      onSuccess?.(pi);
+      const paid = { kind: "paid", paymentIntent: pi };
+      onResult?.(paid);
+      const CONFIRMATION_TIMEOUT_MS = 1e4;
+      const startedAt = Date.now();
+      let attempt = 0;
+      while (!hasPaidPurchaseRef.current && Date.now() - startedAt < CONFIRMATION_TIMEOUT_MS) {
+        attempt += 1;
+        await new Promise((r) => setTimeout(r, Math.min(500 * attempt, 1500)));
+        if (hasPaidPurchaseRef.current) break;
+        try {
+          await refetch();
+        } catch {
+        }
+      }
+      if (!hasPaidPurchaseRef.current) {
+        const confirmationMsg = copy.errors.paymentConfirmationDelayed;
+        setError(confirmationMsg);
+        setIsProcessing(false);
+        onError?.(new Error(confirmationMsg));
+        return;
+      }
+      setIsProcessing(false);
+      return;
+    }
+    setIsProcessing(false);
+    const msg = reconcileResult.status === "timeout" ? reconcileResult.error.message : copy.errors.paymentProcessingFailed;
+    setError(msg);
+    onError?.(reconcileResult.error);
+  }, [
+    stripe,
+    elements,
+    clientSecret,
+    elementKind,
+    returnUrl,
+    customer,
+    prefillCustomer,
+    copy,
+    processPayment,
+    productRef,
+    planRef,
+    resolvedPlanRef,
+    refetch,
+    onSuccess,
+    onResult,
+    onError
+  ]);
+  const contextValue = useMemo6(
+    () => ({
+      planRef,
+      productRef,
+      prefillCustomer,
+      resolvedPlanRef,
+      plan,
+      clientSecret,
+      stripe: stripe ?? null,
+      elements: elements ?? null,
+      isProcessing,
+      isReady,
+      paymentInputComplete,
+      termsAccepted,
+      requireTermsAcceptance,
+      canSubmit,
+      error,
+      elementKind,
+      returnUrl,
+      submitButtonText,
+      buttonClassName,
+      setElementKind,
+      setPaymentInputComplete,
+      setTermsAccepted,
+      submit
+    }),
+    [
+      planRef,
+      productRef,
+      prefillCustomer,
+      resolvedPlanRef,
+      plan,
+      clientSecret,
+      stripe,
+      elements,
+      isProcessing,
+      isReady,
+      paymentInputComplete,
+      termsAccepted,
+      requireTermsAcceptance,
+      canSubmit,
+      error,
+      elementKind,
+      returnUrl,
+      submitButtonText,
+      buttonClassName,
+      submit
+    ]
+  );
+  return /* @__PURE__ */ jsx10(PaymentFormProvider, { value: contextValue, children });
+};
+var FreeInner = ({
+  planRef,
+  productRef,
+  plan,
+  resolvedPlanRef,
+  requireTermsAcceptance,
+  submitButtonText,
+  buttonClassName,
+  onFreePlan,
+  onResult,
+  onError,
+  children
+}) => {
+  const copy = useCopy();
+  const { refetch } = usePurchase();
+  const { activate, state, error: activationError, result: activationResult } = useActivation();
+  const [termsAccepted, setTermsAccepted] = useState8(false);
+  const [localError, setLocalError] = useState8(null);
+  const resultFiredRef = useRef4(false);
+  useEffect6(() => {
+    if (state === "activated" && activationResult && !resultFiredRef.current) {
+      resultFiredRef.current = true;
+      const res = { kind: "activated", result: activationResult };
+      onResult?.(res);
+      refetch().catch(() => {
+      });
+    }
+  }, [state, activationResult, onResult, refetch]);
+  const isProcessing = state === "activating";
+  const canSubmit = !isProcessing && (!requireTermsAcceptance || termsAccepted) && !!productRef;
+  const submit = useCallback8(async () => {
+    if (!productRef) {
+      const msg = copy.errors.configMissingPlanOrProduct;
+      setLocalError(msg);
+      onError?.(new Error(msg));
+      return;
+    }
+    setLocalError(null);
+    try {
+      if (onFreePlan) {
+        await onFreePlan(plan);
+        onResult?.({
+          kind: "activated",
+          result: {
+            status: "activated",
+            productRef,
+            planRef: plan.reference
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          }
+        });
+        return;
+      }
+      await activate({ productRef, planRef: plan.reference });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : copy.activation.failed;
+      setLocalError(msg);
+      onError?.(err instanceof Error ? err : new Error(msg));
+    }
+  }, [productRef, plan, onFreePlan, activate, onResult, onError, copy]);
+  const error = localError ?? activationError;
+  const contextValue = useMemo6(
+    () => ({
+      planRef,
+      productRef,
+      prefillCustomer: void 0,
+      resolvedPlanRef,
+      plan,
+      clientSecret: null,
+      stripe: null,
+      elements: null,
+      isProcessing,
+      isReady: true,
+      paymentInputComplete: true,
+      termsAccepted,
+      requireTermsAcceptance,
+      canSubmit,
+      error,
+      elementKind: null,
+      returnUrl: "",
+      submitButtonText,
+      buttonClassName,
+      setElementKind: () => {
+      },
+      setPaymentInputComplete: () => {
+      },
+      setTermsAccepted,
+      submit
+    }),
+    [
+      planRef,
+      productRef,
+      resolvedPlanRef,
+      plan,
+      isProcessing,
+      termsAccepted,
+      requireTermsAcceptance,
+      canSubmit,
+      error,
+      submitButtonText,
+      buttonClassName,
+      submit
+    ]
+  );
+  return /* @__PURE__ */ jsx10(PaymentFormProvider, { value: contextValue, children });
+};
+var Summary = (props) => {
+  const ctx = usePaymentForm();
+  return /* @__PURE__ */ jsx10(
+    CheckoutSummary2,
+    {
+      ...props,
+      planRef: ctx.planRef || ctx.resolvedPlanRef || void 0,
+      productRef: ctx.productRef
+    }
+  );
+};
+var MandateTextPrimitive = (props) => {
+  const ctx = usePaymentForm();
+  return /* @__PURE__ */ jsx10(
+    MandateText,
+    {
+      ...props,
+      planRef: ctx.planRef || ctx.resolvedPlanRef || void 0,
+      productRef: ctx.productRef
+    }
+  );
+};
+var CustomerFields = forwardRef3(
+  function PaymentFormCustomerFields({ asChild, readOnly: _readOnly = true, children, ...rest }, ref) {
+    const copy = useCopy();
+    const customer = useCustomer();
+    const { prefillCustomer } = usePaymentForm();
+    const email = customer.email ?? prefillCustomer?.email;
+    const name = customer.name ?? prefillCustomer?.name;
+    if (!email && !name) return null;
+    const Comp = asChild ? Slot : "div";
+    return /* @__PURE__ */ jsx10(Comp, { ref, "data-solvapay-payment-form-customer-fields": "", ...rest, children: children ?? /* @__PURE__ */ jsxs3(Fragment2, { children: [
+      email && /* @__PURE__ */ jsxs3("div", { "data-solvapay-payment-form-customer-email": "", children: [
+        /* @__PURE__ */ jsxs3("span", { children: [
+          copy.customer.emailLabel,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx10("span", { children: email })
+      ] }),
+      name && /* @__PURE__ */ jsxs3("div", { "data-solvapay-payment-form-customer-name": "", children: [
+        /* @__PURE__ */ jsxs3("span", { children: [
+          copy.customer.nameLabel,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx10("span", { children: name })
+      ] })
+    ] }) });
+  }
+);
+var PaymentElementSlot = ({ options }) => {
+  const { setElementKind, setPaymentInputComplete, isReady, stripe, elements } = usePaymentForm();
+  const locale = useLocale();
+  useEffect6(() => {
+    if (stripe && elements) setElementKind("payment-element");
+  }, [setElementKind, stripe, elements]);
+  if (!stripe || !elements) return null;
+  if (!isReady) {
+    return /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-loading": "", children: /* @__PURE__ */ jsx10(Spinner, { size: "sm" }) });
+  }
+  return /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-payment-element": "", children: /* @__PURE__ */ jsx10(
+    StripePaymentElement,
+    {
+      options,
+      onChange: (e) => setPaymentInputComplete(e.complete)
+    },
+    locale || "default"
+  ) });
+};
+var CardElementSlot = ({ options }) => {
+  const { setElementKind, setPaymentInputComplete, isReady, stripe, elements } = usePaymentForm();
+  useEffect6(() => {
+    if (stripe && elements) setElementKind("card-element");
+  }, [setElementKind, stripe, elements]);
+  if (!stripe || !elements) return null;
+  if (!isReady) {
+    return /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-loading": "", children: /* @__PURE__ */ jsx10(Spinner, { size: "sm" }) });
+  }
+  return /* @__PURE__ */ jsx10("div", { "data-solvapay-payment-form-card-element": "", children: /* @__PURE__ */ jsx10(
+    StripeCardElement,
+    {
+      options,
+      onChange: (e) => setPaymentInputComplete(e.complete)
+    }
+  ) });
+};
+var TermsCheckbox = forwardRef3(
+  function PaymentFormTermsCheckbox({ asChild, label, children, ...rest }, ref) {
+    const { termsAccepted, setTermsAccepted } = usePaymentForm();
+    const copy = useCopy();
+    const id = "solvapay-terms-checkbox";
+    if (asChild) {
+      return /* @__PURE__ */ jsx10(Slot, { ref, "data-solvapay-payment-form-terms": "", ...rest, children });
+    }
+    return /* @__PURE__ */ jsxs3(
+      "label",
+      {
+        ref,
+        htmlFor: id,
+        "data-solvapay-payment-form-terms": "",
+        ...rest,
+        children: [
+          /* @__PURE__ */ jsx10(
+            "input",
+            {
+              id,
+              type: "checkbox",
+              checked: termsAccepted,
+              onChange: (e) => setTermsAccepted(e.target.checked)
+            }
+          ),
+          /* @__PURE__ */ jsx10("span", { children: label ?? copy.terms.checkboxLabel })
+        ]
+      }
+    );
+  }
+);
+var SubmitButton = forwardRef3(
+  function PaymentFormSubmitButton({ asChild, onClick, children, ...rest }, ref) {
+    const ctx = usePaymentForm();
+    const copy = useCopy();
+    const locale = useLocale();
+    const { plan } = usePlan({
+      planRef: ctx.planRef || ctx.resolvedPlanRef || void 0,
+      productRef: ctx.productRef
+    });
+    const { product } = useProduct(ctx.productRef);
+    const variant = deriveVariant(plan ?? ctx.plan ?? void 0);
+    const dataVariant = toSubmitVariant(variant);
+    const dataState = ctx.isProcessing ? "processing" : !ctx.canSubmit ? "disabled" : "idle";
+    const amountFormatted = formatPrice(
+      plan?.price ?? ctx.plan?.price ?? 0,
+      plan?.currency ?? ctx.plan?.currency ?? "usd",
+      { locale, free: copy.interval.free }
+    );
+    const label = resolveCta({
+      variant,
+      plan: plan ?? ctx.plan,
+      product,
+      amountFormatted,
+      copy,
+      override: typeof children === "string" ? children : ctx.submitButtonText
+    });
+    const content = ctx.isProcessing ? /* @__PURE__ */ jsxs3(Fragment2, { children: [
+      /* @__PURE__ */ jsx10(Spinner, { size: "sm" }),
+      /* @__PURE__ */ jsx10("span", { children: copy.cta.processing })
+    ] }) : children && typeof children !== "string" ? children : label;
+    const buttonProps = {
+      "data-solvapay-payment-form-submit": "",
+      "data-state": dataState,
+      "data-variant": dataVariant,
+      "aria-busy": ctx.isProcessing,
+      "aria-disabled": !ctx.canSubmit,
+      "aria-label": label,
+      disabled: !ctx.canSubmit,
+      className: rest.className ?? ctx.buttonClassName,
+      onClick: composeEventHandlers(onClick, (e) => {
+        e.preventDefault();
+        ctx.submit();
+      }),
+      ...rest
+    };
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ jsx10(Slot, { ref, ...buttonProps, children: content })
+      );
+    }
+    return /* @__PURE__ */ jsx10("button", { ref, type: "submit", ...buttonProps, children: content });
+  }
+);
+var Loading = forwardRef3(function PaymentFormLoading({ asChild, children, ...rest }, ref) {
+  const ctx = usePaymentForm();
+  if (ctx.isReady && ctx.clientSecret) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx10(Comp, { ref, "data-solvapay-payment-form-loading": "", ...rest, children: children ?? /* @__PURE__ */ jsx10(Spinner, { size: "sm" }) });
+});
+var ErrorSlot = forwardRef3(function PaymentFormError({ asChild, children, ...rest }, ref) {
+  const ctx = usePaymentForm();
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx10(
+    Comp,
+    {
+      ref,
+      role: "alert",
+      "aria-live": "assertive",
+      "aria-atomic": "true",
+      "data-solvapay-payment-form-error": "",
+      ...rest,
+      children: children ?? ctx.error
+    }
+  );
+});
+var PaymentFormRoot2 = Root2;
+var PaymentFormSummary = Summary;
+var PaymentFormCustomerFields2 = CustomerFields;
+var PaymentFormPaymentElement = PaymentElementSlot;
+var PaymentFormCardElement = CardElementSlot;
+var PaymentFormMandateText = MandateTextPrimitive;
+var PaymentFormTermsCheckbox2 = TermsCheckbox;
+var PaymentFormSubmitButton2 = SubmitButton;
+var PaymentFormLoading2 = Loading;
+var PaymentFormError2 = ErrorSlot;
+var PaymentForm = {
+  Root: Root2,
+  Summary,
+  CustomerFields,
+  PaymentElement: PaymentElementSlot,
+  CardElement: CardElementSlot,
+  MandateText: MandateTextPrimitive,
+  TermsCheckbox,
+  SubmitButton,
+  Loading,
+  Error: ErrorSlot
+};
+
+// src/hooks/useTopupAmountSelector.ts
+import { useState as useState9, useCallback as useCallback9, useMemo as useMemo7 } from "react";
+function getQuickAmounts(currency) {
+  switch (currency.toUpperCase()) {
+    case "SEK":
+    case "NOK":
+    case "DKK":
+      return [100, 500, 1e3, 5e3];
+    case "JPY":
+      return [1e3, 5e3, 1e4, 5e4];
+    case "KRW":
+      return [1e4, 5e4, 1e5, 5e5];
+    case "ISK":
+    case "HUF":
+      return [1e3, 5e3, 1e4, 5e4];
+    default:
+      return [10, 50, 100, 500];
+  }
+}
+function getCurrencySymbol(currency) {
+  try {
+    const parts = new Intl.NumberFormat("en", { style: "currency", currency }).formatToParts(0);
+    const sym = parts.find((p) => p.type === "currency");
+    return sym?.value || currency;
+  } catch {
+    return currency;
+  }
+}
+var DEFAULT_MIN = 1;
+var DEFAULT_MAX = 1e5;
+function useTopupAmountSelector(options) {
+  const { currency, minAmount = DEFAULT_MIN, maxAmount = DEFAULT_MAX } = options;
+  const copy = useCopy();
+  const [selectedAmount, setSelectedAmount] = useState9(null);
+  const [customAmount, setCustomAmountRaw] = useState9("");
+  const [error, setError] = useState9(null);
+  const quickAmounts = useMemo7(() => getQuickAmounts(currency), [currency]);
+  const currencySymbol = useMemo7(() => getCurrencySymbol(currency), [currency]);
+  const resolvedAmount = useMemo7(() => {
+    if (customAmount) {
+      const parsed = parseFloat(customAmount);
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+    }
+    return selectedAmount;
+  }, [selectedAmount, customAmount]);
+  const selectQuickAmount = useCallback9(
+    (amount) => {
+      setSelectedAmount(amount);
+      setCustomAmountRaw("");
+      setError(null);
+    },
+    []
+  );
+  const setCustomAmount = useCallback9(
+    (value) => {
+      const sanitized = value.replace(/[^0-9.]/g, "");
+      const dotIndex = sanitized.indexOf(".");
+      const cleaned = dotIndex === -1 ? sanitized : sanitized.slice(0, dotIndex + 1) + sanitized.slice(dotIndex + 1).replace(/\./g, "");
+      setCustomAmountRaw(cleaned);
+      setSelectedAmount(null);
+      setError(null);
+    },
+    []
+  );
+  const validate = useCallback9(() => {
+    if (resolvedAmount == null) {
+      setError(copy.topup.selectOrEnterAmount);
+      return false;
+    }
+    if (resolvedAmount < minAmount) {
+      setError(
+        interpolate(copy.topup.minAmount, {
+          amount: formatPrice(minAmount * getMinorUnitsPerMajor(currency), currency, {
+            free: ""
+          })
+        })
+      );
+      return false;
+    }
+    if (resolvedAmount > maxAmount) {
+      setError(
+        interpolate(copy.topup.maxAmount, {
+          amount: formatPrice(maxAmount * getMinorUnitsPerMajor(currency), currency, {
+            free: ""
+          })
+        })
+      );
+      return false;
+    }
+    setError(null);
+    return true;
+  }, [resolvedAmount, minAmount, maxAmount, currency, copy]);
+  const reset = useCallback9(() => {
+    setSelectedAmount(null);
+    setCustomAmountRaw("");
+    setError(null);
+  }, []);
+  return {
+    quickAmounts,
+    selectedAmount,
+    customAmount,
+    resolvedAmount,
+    selectQuickAmount,
+    setCustomAmount,
+    error,
+    validate,
+    reset,
+    currencySymbol
+  };
+}
+
+// src/hooks/useBalance.ts
+import { useEffect as useEffect7 } from "react";
+function useBalance() {
+  const { balance } = useSolvaPay();
+  useEffect7(() => {
+    balance.refetch();
+  }, [balance.refetch]);
+  return balance;
+}
+
+// src/primitives/AmountPicker.tsx
+import {
+  createContext as createContext6,
+  forwardRef as forwardRef4,
+  useCallback as useCallback10,
+  useContext as useContext8,
+  useEffect as useEffect8,
+  useMemo as useMemo8
+} from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var AmountPickerContext = createContext6(null);
+function usePickerCtx(part) {
+  const ctx = useContext8(AmountPickerContext);
+  if (!ctx) {
+    throw new Error(`AmountPicker.${part} must be rendered inside <AmountPicker.Root>.`);
+  }
+  return ctx;
+}
+var Root3 = forwardRef4(function AmountPickerRoot({
+  currency,
+  minAmount,
+  maxAmount,
+  emit = "major",
+  selector: externalSelector,
+  onChange,
+  asChild,
+  children,
+  ...rest
+}, forwardedRef) {
+  const solva = useContext8(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("AmountPicker");
+  const internalSelector = useTopupAmountSelector({ currency, minAmount, maxAmount });
+  const selector = externalSelector ?? internalSelector;
+  const { creditsPerMinorUnit, displayExchangeRate } = useBalance();
+  const minorPerMajor = getMinorUnitsPerMajor(currency);
+  const resolvedAmountMinor = selector.resolvedAmount != null && selector.resolvedAmount > 0 ? Math.round(selector.resolvedAmount * minorPerMajor) : null;
+  useEffect8(() => {
+    if (emit === "minor") {
+      onChange?.(resolvedAmountMinor);
+    } else {
+      onChange?.(selector.resolvedAmount);
+    }
+  }, [emit, selector.resolvedAmount, resolvedAmountMinor, onChange]);
+  const rate = displayExchangeRate ?? 1;
+  const estimatedCredits = creditsPerMinorUnit != null && creditsPerMinorUnit > 0 && resolvedAmountMinor != null ? Math.floor(resolvedAmountMinor / rate * creditsPerMinorUnit) : null;
+  const isApproximate = rate !== 1;
+  const ctx = useMemo8(
+    () => ({
+      ...selector,
+      currency,
+      emit,
+      creditsPerMinorUnit,
+      displayExchangeRate,
+      estimatedCredits,
+      isApproximate,
+      resolvedAmountMinor
+    }),
+    [
+      selector,
+      currency,
+      emit,
+      creditsPerMinorUnit,
+      displayExchangeRate,
+      estimatedCredits,
+      isApproximate,
+      resolvedAmountMinor
+    ]
+  );
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx11(AmountPickerContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx11(Comp, { ref: forwardedRef, "data-solvapay-amount-picker": "", ...rest, children }) });
+});
+var Option = forwardRef4(function AmountPickerOption({ asChild, amount, onClick, children, ...rest }, forwardedRef) {
+  const ctx = usePickerCtx("Option");
+  const isActive = ctx.selectedAmount === amount && !ctx.customAmount;
+  const state = rest.disabled ? "disabled" : isActive ? "selected" : "idle";
+  const commonProps = {
+    "data-solvapay-amount-picker-option": "",
+    "data-state": state,
+    "data-amount": String(amount),
+    "aria-pressed": isActive,
+    onClick: composeEventHandlers(onClick, () => {
+      ctx.selectQuickAmount(amount);
+    }),
+    ...rest
+  };
+  const defaultLabel = formatPrice(
+    amount * getMinorUnitsPerMajor(ctx.currency),
+    ctx.currency,
+    { free: "" }
+  );
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx11(Slot, { ref: forwardedRef, ...commonProps, children: children ?? defaultLabel })
+    );
+  }
+  return /* @__PURE__ */ jsx11("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? defaultLabel });
+});
+var Custom = forwardRef4(function AmountPickerCustom({ asChild, onChange, onFocus, ...rest }, forwardedRef) {
+  const ctx = usePickerCtx("Custom");
+  const state = ctx.customAmount ? "active" : "dormant";
+  const commonProps = {
+    "data-solvapay-amount-picker-custom": "",
+    "data-state": state,
+    type: "text",
+    inputMode: "decimal",
+    placeholder: "0.00",
+    value: ctx.customAmount,
+    onChange: composeEventHandlers(onChange, (e) => {
+      ctx.setCustomAmount(e.target.value);
+    }),
+    onFocus: composeEventHandlers(onFocus, () => {
+      if (ctx.selectedAmount != null) ctx.selectQuickAmount(0);
+    }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx11(Slot, { ref: forwardedRef, ...commonProps })
+    );
+  }
+  return /* @__PURE__ */ jsx11("input", { ref: forwardedRef, ...commonProps });
+});
+var Confirm = forwardRef4(function AmountPickerConfirm({ asChild, onClick, onConfirm, disabled, children, ...rest }, forwardedRef) {
+  const ctx = usePickerCtx("Confirm");
+  const isDisabled = disabled || !ctx.resolvedAmount;
+  const handleConfirm = useCallback10(() => {
+    if (!ctx.validate()) return;
+    if (ctx.emit === "minor") {
+      if (ctx.resolvedAmountMinor != null) onConfirm?.(ctx.resolvedAmountMinor);
+      return;
+    }
+    if (ctx.resolvedAmount != null) onConfirm?.(ctx.resolvedAmount);
+  }, [ctx, onConfirm]);
+  const commonProps = {
+    "data-solvapay-amount-picker-confirm": "",
+    "data-state": isDisabled ? "disabled" : "idle",
+    disabled: isDisabled,
+    "aria-disabled": isDisabled || void 0,
+    onClick: composeEventHandlers(onClick, handleConfirm),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx11(Slot, { ref: forwardedRef, ...commonProps, children })
+    );
+  }
+  return /* @__PURE__ */ jsx11("button", { ref: forwardedRef, type: "button", ...commonProps, children });
+});
+var AmountPickerRoot2 = Root3;
+var AmountPickerOption2 = Option;
+var AmountPickerCustom2 = Custom;
+var AmountPickerConfirm2 = Confirm;
+var AmountPicker = {
+  Root: Root3,
+  Option,
+  Custom,
+  Confirm
+};
+function useAmountPicker() {
+  return usePickerCtx("useAmountPicker");
+}
+function useAmountPickerCopy() {
+  const copy = useCopy();
+  const ctx = usePickerCtx("useAmountPickerCopy");
+  return {
+    selectAmountLabel: copy.amountPicker.selectAmountLabel,
+    customAmountLabel: copy.amountPicker.customAmountLabel,
+    creditEstimate: (credits) => interpolate(
+      ctx.isApproximate ? copy.amountPicker.creditEstimateApprox : copy.amountPicker.creditEstimateExact,
+      { credits: new Intl.NumberFormat().format(credits) }
+    )
+  };
+}
+
+// src/hooks/useTopup.ts
+import { useState as useState10, useCallback as useCallback11, useRef as useRef5 } from "react";
+import { loadStripe as loadStripe2 } from "@stripe/stripe-js";
+var stripePromiseCache2 = /* @__PURE__ */ new Map();
+function getStripeCacheKey2(publishableKey, accountId) {
+  return accountId ? `${publishableKey}:${accountId}` : publishableKey;
+}
+function useTopup(options) {
+  const { amount, currency } = options;
+  const { createTopupPayment, customerRef, updateCustomerRef } = useSolvaPay();
+  const [loading, setLoading] = useState10(false);
+  const [error, setError] = useState10(null);
+  const [stripePromise, setStripePromise] = useState10(null);
+  const [clientSecret, setClientSecret] = useState10(null);
+  const isStartingRef = useRef5(false);
+  const startTopup = useCallback11(async () => {
+    if (isStartingRef.current || loading) {
+      return;
+    }
+    if (!amount || amount <= 0) {
+      setError(new Error("useTopup: amount must be a positive number"));
+      return;
+    }
+    isStartingRef.current = true;
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await createTopupPayment({ amount, currency });
+      if (!result || typeof result !== "object") {
+        throw new Error("Invalid topup payment intent response from server");
+      }
+      if (!result.clientSecret || typeof result.clientSecret !== "string") {
+        throw new Error("Invalid client secret in topup payment intent response");
+      }
+      if (!result.publishableKey || typeof result.publishableKey !== "string") {
+        throw new Error("Invalid publishable key in topup payment intent response");
+      }
+      if (result.customerRef && result.customerRef !== customerRef && updateCustomerRef) {
+        updateCustomerRef(result.customerRef);
+      }
+      const stripeOptions = result.accountId ? { stripeAccount: result.accountId } : {};
+      const cacheKey = getStripeCacheKey2(result.publishableKey, result.accountId);
+      let stripe = stripePromiseCache2.get(cacheKey);
+      if (!stripe) {
+        stripe = loadStripe2(result.publishableKey, stripeOptions);
+        stripePromiseCache2.set(cacheKey, stripe);
+      }
+      setStripePromise(stripe);
+      setClientSecret(result.clientSecret);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to start topup");
+      setError(error2);
+    } finally {
+      setLoading(false);
+      isStartingRef.current = false;
+    }
+  }, [amount, currency, createTopupPayment, customerRef, updateCustomerRef, loading]);
+  const reset = useCallback11(() => {
+    isStartingRef.current = false;
+    setLoading(false);
+    setError(null);
+    setStripePromise(null);
+    setClientSecret(null);
+  }, []);
+  return {
+    loading,
+    error,
+    stripePromise,
+    clientSecret,
+    startTopup,
+    reset
+  };
+}
+
+// src/primitives/TopupForm.tsx
+import {
+  createContext as createContext7,
+  forwardRef as forwardRef5,
+  useCallback as useCallback12,
+  useContext as useContext9,
+  useEffect as useEffect9,
+  useMemo as useMemo9,
+  useRef as useRef6,
+  useState as useState11
+} from "react";
+import {
+  Elements as Elements2,
+  useStripe as useStripe2,
+  useElements as useElements2,
+  PaymentElement as StripePaymentElement2
+} from "@stripe/react-stripe-js";
+import { Fragment as Fragment3, jsx as jsx12, jsxs as jsxs4 } from "react/jsx-runtime";
+var TopupFormContext = createContext7(null);
+function useTopupCtx(part) {
+  const ctx = useContext9(TopupFormContext);
+  if (!ctx) {
+    throw new Error(`TopupForm.${part} must be rendered inside <TopupForm.Root>.`);
+  }
+  return ctx;
+}
+var Root4 = forwardRef5(function TopupFormRoot(props, forwardedRef) {
+  const {
+    amount,
+    currency,
+    onSuccess,
+    onError,
+    returnUrl,
+    submitButtonText: _submitButtonText,
+    buttonClassName: _buttonClassName,
+    className,
+    asChild,
+    children,
+    ...rest
+  } = props;
+  const solva = useContext9(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("TopupForm");
+  const copy = useCopy();
+  const locale = useLocale();
+  const { loading, error: topupError, clientSecret, startTopup, stripePromise } = useTopup({
+    amount,
+    currency
+  });
+  const hasInitializedRef = useRef6(false);
+  const hasAmount = amount > 0;
+  useEffect9(() => {
+    if (!hasInitializedRef.current && hasAmount && !loading && !topupError && !clientSecret) {
+      hasInitializedRef.current = true;
+      startTopup().catch(() => {
+        hasInitializedRef.current = false;
+      });
+    }
+    if (hasAmount && clientSecret) hasInitializedRef.current = true;
+  }, [hasAmount, loading, topupError, clientSecret, startTopup]);
+  const finalReturnUrl = returnUrl || (typeof window !== "undefined" ? window.location.href : "/");
+  const elementsOptions = useMemo9(() => {
+    if (!clientSecret) return void 0;
+    return { clientSecret, locale };
+  }, [clientSecret, locale]);
+  const Comp = asChild ? Slot : "div";
+  const outerError = !hasAmount ? copy.errors.configMissingAmount : topupError ? `${copy.errors.topupInitFailed} ${topupError.message || copy.errors.unknownError}` : null;
+  const dataState = outerError ? "error" : clientSecret && stripePromise ? "ready" : "loading";
+  const canMountElements = !!(stripePromise && clientSecret && elementsOptions);
+  const innerCommon = {
+    amount,
+    currency,
+    clientSecret,
+    returnUrl: finalReturnUrl,
+    outerError,
+    state: dataState,
+    onSuccess,
+    onError
+  };
+  const shell = /* @__PURE__ */ jsx12(
+    Comp,
+    {
+      ref: forwardedRef,
+      className,
+      "data-solvapay-topup-form": "",
+      "data-state": dataState,
+      ...rest,
+      children
+    }
+  );
+  if (canMountElements) {
+    return /* @__PURE__ */ jsx12(Elements2, { stripe: stripePromise, options: elementsOptions, children: /* @__PURE__ */ jsx12(Inner, { ...innerCommon, children: shell }) }, clientSecret);
+  }
+  return /* @__PURE__ */ jsx12(OfflineInner, { ...innerCommon, children: shell });
+});
+var Inner = ({
+  amount,
+  currency,
+  clientSecret,
+  returnUrl,
+  outerError,
+  state,
+  onSuccess,
+  onError,
+  children
+}) => {
+  const stripe = useStripe2();
+  const elements = useElements2();
+  const copy = useCopy();
+  const [paymentInputComplete, setPaymentInputComplete] = useState11(false);
+  const [isProcessing, setIsProcessing] = useState11(false);
+  const [error, setError] = useState11(null);
+  const isReady = !!(stripe && elements);
+  const canSubmit = isReady && paymentInputComplete && !isProcessing && !!clientSecret;
+  const submit = useCallback12(async () => {
+    if (!stripe || !elements || !clientSecret) {
+      const msg = copy.errors.stripeUnavailable;
+      setError(msg);
+      onError?.(new Error(msg));
+      return;
+    }
+    setError(null);
+    setIsProcessing(true);
+    const { error: submitError } = await elements.submit();
+    if (submitError) {
+      const msg = submitError.message || copy.errors.paymentUnexpected;
+      setError(msg);
+      setIsProcessing(false);
+      onError?.(new Error(msg));
+      return;
+    }
+    const { error: confirmError, paymentIntent } = await stripe.confirmPayment({
+      elements,
+      clientSecret,
+      confirmParams: { return_url: returnUrl },
+      redirect: "if_required"
+    });
+    if (confirmError) {
+      const msg = confirmError.message || copy.errors.paymentUnexpected;
+      setError(msg);
+      setIsProcessing(false);
+      onError?.(new Error(msg));
+      return;
+    }
+    setIsProcessing(false);
+    if (paymentIntent) {
+      await onSuccess?.(paymentIntent);
+    }
+  }, [stripe, elements, clientSecret, returnUrl, copy, onSuccess, onError]);
+  const effectiveError = error ?? outerError;
+  const ctx = useMemo9(
+    () => ({
+      amount,
+      currency,
+      state,
+      clientSecret,
+      stripe: stripe ?? null,
+      elements: elements ?? null,
+      isReady,
+      isProcessing,
+      paymentInputComplete,
+      canSubmit,
+      error: effectiveError,
+      returnUrl,
+      setPaymentInputComplete,
+      submit
+    }),
+    [
+      amount,
+      currency,
+      state,
+      clientSecret,
+      stripe,
+      elements,
+      isReady,
+      isProcessing,
+      paymentInputComplete,
+      canSubmit,
+      effectiveError,
+      returnUrl,
+      submit
+    ]
+  );
+  return /* @__PURE__ */ jsx12(TopupFormContext.Provider, { value: ctx, children });
+};
+var OfflineInner = ({
+  amount,
+  currency,
+  clientSecret,
+  returnUrl,
+  outerError,
+  state,
+  children
+}) => {
+  const noopSubmit = useCallback12(async () => {
+  }, []);
+  const noopSet = useCallback12(() => {
+  }, []);
+  const ctx = useMemo9(
+    () => ({
+      amount,
+      currency,
+      state,
+      clientSecret,
+      stripe: null,
+      elements: null,
+      isReady: false,
+      isProcessing: false,
+      paymentInputComplete: false,
+      canSubmit: false,
+      error: outerError,
+      returnUrl,
+      setPaymentInputComplete: noopSet,
+      submit: noopSubmit
+    }),
+    [amount, currency, state, clientSecret, outerError, returnUrl, noopSet, noopSubmit]
+  );
+  return /* @__PURE__ */ jsx12(TopupFormContext.Provider, { value: ctx, children });
+};
+var PaymentElementSlot2 = ({ options }) => {
+  const { setPaymentInputComplete, isReady, stripe, elements } = useTopupCtx("PaymentElement");
+  const locale = useLocale();
+  if (!stripe || !elements) return null;
+  if (!isReady) {
+    return /* @__PURE__ */ jsx12("div", { "data-solvapay-topup-form-loading": "", children: /* @__PURE__ */ jsx12(Spinner, { size: "sm" }) });
+  }
+  return /* @__PURE__ */ jsx12("div", { "data-solvapay-topup-form-payment-element": "", children: /* @__PURE__ */ jsx12(
+    StripePaymentElement2,
+    {
+      options,
+      onChange: (e) => setPaymentInputComplete(e.complete)
+    },
+    locale || "default"
+  ) });
+};
+var SubmitButton2 = forwardRef5(function TopupFormSubmitButton({ asChild, onClick, children, ...rest }, forwardedRef) {
+  const ctx = useTopupCtx("SubmitButton");
+  const copy = useCopy();
+  const dataState = ctx.isProcessing ? "processing" : !ctx.canSubmit ? "disabled" : "idle";
+  const content = ctx.isProcessing ? /* @__PURE__ */ jsxs4(Fragment3, { children: [
+    /* @__PURE__ */ jsx12(Spinner, { size: "sm" }),
+    /* @__PURE__ */ jsx12("span", { children: copy.cta.processing })
+  ] }) : children ? children : copy.cta.topUp;
+  const commonProps = {
+    "data-solvapay-topup-form-submit": "",
+    "data-state": dataState,
+    "aria-busy": ctx.isProcessing,
+    "aria-disabled": !ctx.canSubmit,
+    disabled: !ctx.canSubmit,
+    onClick: composeEventHandlers(onClick, (e) => {
+      e.preventDefault();
+      void ctx.submit();
+    }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx12(Slot, { ref: forwardedRef, ...commonProps, children: content })
+    );
+  }
+  return /* @__PURE__ */ jsx12("button", { ref: forwardedRef, type: "submit", ...commonProps, children: content });
+});
+var Loading2 = forwardRef5(function TopupFormLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useTopupCtx("Loading");
+  if (ctx.state !== "loading") return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx12(Comp, { ref: forwardedRef, "data-solvapay-topup-form-loading": "", ...rest, children: children ?? /* @__PURE__ */ jsx12(Spinner, { size: "sm" }) });
+});
+var ErrorSlot2 = forwardRef5(function TopupFormError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useTopupCtx("Error");
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx12(
+    Comp,
+    {
+      ref: forwardedRef,
+      role: "alert",
+      "aria-live": "assertive",
+      "aria-atomic": "true",
+      "data-solvapay-topup-form-error": "",
+      ...rest,
+      children: children ?? ctx.error
+    }
+  );
+});
+var TopupFormRoot2 = Root4;
+var TopupFormPaymentElement = PaymentElementSlot2;
+var TopupFormSubmitButton2 = SubmitButton2;
+var TopupFormLoading2 = Loading2;
+var TopupFormError2 = ErrorSlot2;
+var TopupForm = {
+  Root: Root4,
+  AmountPicker: AmountPicker.Root,
+  PaymentElement: PaymentElementSlot2,
+  SubmitButton: SubmitButton2,
+  Loading: Loading2,
+  Error: ErrorSlot2
+};
+function useTopupForm() {
+  return useTopupCtx("useTopupForm");
+}
+
+// src/primitives/BalanceBadge.tsx
+import { forwardRef as forwardRef6, useContext as useContext10 } from "react";
+import { Fragment as Fragment4, jsx as jsx13, jsxs as jsxs5 } from "react/jsx-runtime";
+var BalanceBadge = forwardRef6(function BalanceBadge2({ asChild, numberOnly, lowThreshold = 10, children, ...rest }, forwardedRef) {
+  const solva = useContext10(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("BalanceBadge");
+  const { credits, displayCurrency, creditsPerMinorUnit, displayExchangeRate, loading } = useBalance();
+  const copy = useCopy();
+  const locale = useLocale();
+  const state = loading ? "loading" : credits == null || credits === 0 ? "zero" : credits <= lowThreshold ? "low" : "ok";
+  const commonProps = {
+    "data-solvapay-balance-badge": "",
+    "data-state": state,
+    "data-credits": credits == null ? void 0 : String(credits),
+    "aria-busy": loading,
+    ...rest
+  };
+  if (state === "loading") {
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ jsx13(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx13(Fragment4, {}) })
+      );
+    }
+    return /* @__PURE__ */ jsx13("span", { ref: forwardedRef, ...commonProps });
+  }
+  if (credits == null) return null;
+  const formattedCredits = new Intl.NumberFormat(locale).format(credits);
+  let currencyEquivalent = "";
+  if (!numberOnly && displayCurrency && creditsPerMinorUnit) {
+    const usdCents = credits / creditsPerMinorUnit;
+    const displayMajorUnits = usdCents * (displayExchangeRate ?? 1) / 100;
+    const formatted = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: displayCurrency,
+      minimumFractionDigits: 2
+    }).format(displayMajorUnits);
+    currencyEquivalent = interpolate(copy.balance.currencyEquivalent, { amount: formatted });
+  }
+  const content = children ?? /* @__PURE__ */ jsxs5(Fragment4, { children: [
+    formattedCredits,
+    !numberOnly && copy.balance.credits,
+    !numberOnly && currencyEquivalent
+  ] });
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx13(Slot, { ref: forwardedRef, ...commonProps, children: content })
+    );
+  }
+  return /* @__PURE__ */ jsx13("span", { ref: forwardedRef, ...commonProps, children: content });
+});
+
+// src/primitives/PlanSelector.tsx
+import {
+  createContext as createContext8,
+  forwardRef as forwardRef7,
+  useCallback as useCallback13,
+  useContext as useContext11,
+  useMemo as useMemo10
+} from "react";
+
+// src/transport/list-plans.ts
+async function defaultListPlans(productRef, config) {
+  const transport = config?.transport;
+  if (transport) {
+    return transport.listPlans ? transport.listPlans(productRef) : plansCache.get(productRef)?.plans ?? [];
+  }
+  const base = config?.api?.listPlans || "/api/list-plans";
+  const url = `${base}?productRef=${encodeURIComponent(productRef)}`;
+  const fetchFn = config?.fetch || fetch;
+  const { headers } = await buildRequestHeaders(config);
+  const res = await fetchFn(url, { method: "GET", headers });
+  if (!res.ok) {
+    const error = new Error(`Failed to fetch plans: ${res.statusText || res.status}`);
+    config?.onError?.(error, "listPlans");
+    throw error;
+  }
+  const data = await res.json();
+  return data.plans ?? [];
+}
+
+// src/primitives/PlanSelector.tsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+var PlanSelectorContext = createContext8(null);
+function usePlanSelectorContext(part) {
+  const ctx = useContext11(PlanSelectorContext);
+  if (!ctx) {
+    throw new Error(`PlanSelector.${part} must be rendered inside <PlanSelector.Root>.`);
+  }
+  return ctx;
+}
+var CardContext = createContext8(null);
+function useCardContext(part) {
+  const ctx = useContext11(CardContext);
+  if (!ctx) {
+    throw new Error(`PlanSelector.${part} must be rendered inside <PlanSelector.Card>.`);
+  }
+  return ctx;
+}
+var Root5 = forwardRef7(function PlanSelectorRoot(props, forwardedRef) {
+  const {
+    productRef,
+    fetcher,
+    filter,
+    sortBy,
+    autoSelectFirstPaid = true,
+    initialPlanRef,
+    currentPlanRef,
+    popularPlanRef,
+    onSelect,
+    children,
+    ...rest
+  } = props;
+  const solva = useContext11(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("PlanSelector");
+  if (!productRef) throw new MissingProductRefError("PlanSelector");
+  const { _config } = solva;
+  const { purchases } = usePurchase();
+  const effectiveFetcher = useMemo10(
+    () => fetcher ?? ((ref) => defaultListPlans(ref, _config)),
+    [fetcher, _config]
+  );
+  const { plans, selectedPlan, selectPlan, setSelectedPlanIndex, loading, error } = usePlans({
+    productRef,
+    fetcher: effectiveFetcher,
+    filter,
+    sortBy,
+    autoSelectFirstPaid,
+    initialPlanRef
+  });
+  const autoCurrentPlanRef = useMemo10(() => {
+    const active = purchases.filter((p) => p.status === "active").sort((a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime())[0];
+    return active?.planSnapshot?.reference ?? null;
+  }, [purchases]);
+  const resolvedCurrentPlanRef = currentPlanRef === null ? null : currentPlanRef ?? autoCurrentPlanRef;
+  const isCurrent = useCallback13(
+    (ref) => resolvedCurrentPlanRef === ref,
+    [resolvedCurrentPlanRef]
+  );
+  const isFree = useCallback13(
+    (ref) => plans.find((p) => p.reference === ref)?.requiresPayment === false,
+    [plans]
+  );
+  const isPopular = useCallback13(
+    (ref) => popularPlanRef === ref,
+    [popularPlanRef]
+  );
+  const select = useCallback13(
+    (ref) => {
+      const plan = plans.find((p) => p.reference === ref);
+      if (!plan) return;
+      if (plan.requiresPayment === false) return;
+      selectPlan(ref);
+      onSelect?.(ref, plan);
+    },
+    [plans, selectPlan, onSelect]
+  );
+  const clearSelection = useCallback13(() => {
+    setSelectedPlanIndex(-1);
+  }, [setSelectedPlanIndex]);
+  const selectedPlanRef = selectedPlan?.reference ?? null;
+  const ctx = useMemo10(
+    () => ({
+      plans,
+      loading,
+      error,
+      selectedPlan: selectedPlan ?? null,
+      selectedPlanRef,
+      popularPlanRef,
+      currentPlanRef: resolvedCurrentPlanRef,
+      isCurrent,
+      isFree,
+      isPopular,
+      select,
+      clearSelection
+    }),
+    [
+      plans,
+      loading,
+      error,
+      selectedPlan,
+      selectedPlanRef,
+      popularPlanRef,
+      resolvedCurrentPlanRef,
+      isCurrent,
+      isFree,
+      isPopular,
+      select,
+      clearSelection
+    ]
+  );
+  return /* @__PURE__ */ jsx14(
+    PlanSelectionProvider,
+    {
+      value: {
+        productRef,
+        selectedPlanRef,
+        setSelectedPlanRef: (ref) => {
+          if (ref) select(ref);
+        },
+        plans,
+        loading,
+        error
+      },
+      children: /* @__PURE__ */ jsx14("div", { ref: forwardedRef, "data-solvapay-plan-selector": "", ...rest, children: /* @__PURE__ */ jsx14(PlanSelectorContext.Provider, { value: ctx, children }) })
+    }
+  );
+});
+var Heading = forwardRef7(function PlanSelectorHeading({ asChild, children, ...rest }, forwardedRef) {
+  usePlanSelectorContext("Heading");
+  const copy = useCopy();
+  const Comp = asChild ? Slot : "h3";
+  return /* @__PURE__ */ jsx14(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-heading": "", ...rest, children: children ?? copy.planSelector.heading });
+});
+var Grid = forwardRef7(function PlanSelectorGrid({ children, ...rest }, forwardedRef) {
+  const ctx = usePlanSelectorContext("Grid");
+  return /* @__PURE__ */ jsx14("div", { ref: forwardedRef, "data-solvapay-plan-selector-grid": "", ...rest, children: ctx.plans.map((plan) => {
+    const isCurrent = ctx.isCurrent(plan.reference);
+    const isFree = ctx.isFree(plan.reference);
+    const isPopular = ctx.isPopular(plan.reference);
+    const selected = ctx.selectedPlanRef === plan.reference;
+    const disabled = isCurrent || isFree;
+    const state = isCurrent ? "current" : isFree ? "disabled" : selected ? "selected" : "idle";
+    const cardCtx = {
+      plan,
+      state,
+      isCurrent,
+      isFree,
+      isPopular,
+      disabled,
+      select: () => ctx.select(plan.reference)
+    };
+    return /* @__PURE__ */ jsx14(CardContext.Provider, { value: cardCtx, children }, plan.reference);
+  }) });
+});
+var Card = forwardRef7(function PlanSelectorCard({ asChild, onClick, children, ...rest }, forwardedRef) {
+  const card = useCardContext("Card");
+  const dataTrial = !!(card.plan.trialDays && card.plan.trialDays > 0);
+  const commonProps = {
+    "data-solvapay-plan-selector-card": "",
+    "data-state": card.state,
+    "data-free": card.isFree ? "" : void 0,
+    "data-popular": card.isPopular ? "" : void 0,
+    "data-trial": dataTrial ? "" : void 0,
+    "aria-disabled": card.disabled || void 0,
+    onClick: composeEventHandlers(onClick, () => {
+      if (!card.disabled) card.select();
+    }),
+    ...rest
+  };
+  if (asChild) {
+    return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      /* @__PURE__ */ jsx14(Slot, { ref: forwardedRef, ...commonProps, children })
+    );
+  }
+  return /* @__PURE__ */ jsx14(
+    "button",
+    {
+      ref: forwardedRef,
+      type: "button",
+      disabled: card.disabled,
+      ...commonProps,
+      children
+    }
+  );
+});
+var CardName = forwardRef7(function PlanSelectorCardName({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardName");
+  const fallback = card.plan.requiresPayment === false ? "Free" : card.plan.type === "usage-based" ? "Pay as you go" : card.plan.type === "recurring" ? "Plan" : null;
+  const label = card.plan.name ?? fallback;
+  if (!label && children == null) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx14(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-name": "", ...rest, children: children ?? label });
+});
+var CardPrice = forwardRef7(function PlanSelectorCardPrice({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardPrice");
+  const locale = useLocale();
+  const copy = useCopy();
+  const formatted = useMemo10(() => {
+    if (card.isFree) return copy.planSelector.freeBadge;
+    if (card.plan.type === "usage-based") {
+      const creditsPerUnit = card.plan.creditsPerUnit ?? 1;
+      const perCallMinor = Math.max(1, Math.round(1 / creditsPerUnit));
+      const rate = formatPrice(perCallMinor, card.plan.currency ?? "usd", {
+        locale,
+        free: ""
+      });
+      return `${rate} / call`;
+    }
+    return formatPrice(card.plan.price ?? 0, card.plan.currency ?? "usd", {
+      locale,
+      free: copy.interval.free
+    });
+  }, [
+    card.isFree,
+    card.plan.type,
+    card.plan.price,
+    card.plan.currency,
+    card.plan.creditsPerUnit,
+    locale,
+    copy.planSelector.freeBadge,
+    copy.interval.free
+  ]);
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx14(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-price": "", ...rest, children: children ?? formatted });
+});
+var CardInterval = forwardRef7(function PlanSelectorCardInterval({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardInterval");
+  const copy = useCopy();
+  if (card.isFree || card.plan.type === "usage-based") return null;
+  const rawInterval = card.plan.interval ?? normalizeBillingCycle(card.plan.billingCycle);
+  if (!rawInterval) return null;
+  const text = interpolate(copy.planSelector.perIntervalShort, { interval: rawInterval });
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx14(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-card-interval": "", ...rest, children: children ?? text });
+});
+function normalizeBillingCycle(cycle) {
+  if (!cycle) return null;
+  const lc = cycle.toLowerCase();
+  if (lc === "monthly" || lc === "month") return "month";
+  if (lc === "yearly" || lc === "annually" || lc === "annual" || lc === "year") return "year";
+  if (lc === "weekly" || lc === "week") return "week";
+  if (lc === "daily" || lc === "day") return "day";
+  return cycle;
+}
+var CardBadge = forwardRef7(function PlanSelectorCardBadge({ asChild, children, ...rest }, forwardedRef) {
+  const card = useCardContext("CardBadge");
+  const copy = useCopy();
+  let variant = null;
+  let label = "";
+  if (card.isCurrent) {
+    variant = "current";
+    label = copy.planSelector.currentBadge;
+  } else if (card.isPopular && !card.isFree) {
+    variant = "popular";
+    label = copy.planSelector.popularBadge;
+  }
+  if (!variant) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx14(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-plan-selector-card-badge": "",
+      "data-variant": variant,
+      ...rest,
+      children: children ?? label
+    }
+  );
+});
+var Loading3 = forwardRef7(function PlanSelectorLoading({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = usePlanSelectorContext("Loading");
+  if (!ctx.loading || ctx.plans.length > 0) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx14(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-loading": "", ...rest, children });
+});
+var ErrorSlot3 = forwardRef7(function PlanSelectorError({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = usePlanSelectorContext("Error");
+  if (!ctx.error) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx14(Comp, { ref: forwardedRef, "data-solvapay-plan-selector-error": "", role: "alert", ...rest, children: children ?? ctx.error.message });
+});
+var PlanSelectorRoot2 = Root5;
+var PlanSelectorHeading2 = Heading;
+var PlanSelectorGrid2 = Grid;
+var PlanSelectorCard2 = Card;
+var PlanSelectorCardName2 = CardName;
+var PlanSelectorCardPrice2 = CardPrice;
+var PlanSelectorCardInterval2 = CardInterval;
+var PlanSelectorCardBadge2 = CardBadge;
+var PlanSelectorLoading2 = Loading3;
+var PlanSelectorError2 = ErrorSlot3;
+var PlanSelector = {
+  Root: Root5,
+  Heading,
+  Grid,
+  Card,
+  CardName,
+  CardPrice,
+  CardInterval,
+  CardBadge,
+  Loading: Loading3,
+  Error: ErrorSlot3
+};
+function usePlanSelector() {
+  return usePlanSelectorContext("usePlanSelector");
+}
+
+// src/hooks/usePurchaseActions.ts
+import { useState as useState12, useCallback as useCallback14 } from "react";
+function usePurchaseActions() {
+  const ctx = useSolvaPay();
+  const [isCancelling, setIsCancelling] = useState12(false);
+  const [isReactivating, setIsReactivating] = useState12(false);
+  const [isActivating, setIsActivating] = useState12(false);
+  const cancelRenewal = useCallback14(
+    async (params) => {
+      setIsCancelling(true);
+      try {
+        return await ctx.cancelRenewal(params);
+      } finally {
+        setIsCancelling(false);
+      }
+    },
+    [ctx.cancelRenewal]
+  );
+  const reactivateRenewal = useCallback14(
+    async (params) => {
+      setIsReactivating(true);
+      try {
+        return await ctx.reactivateRenewal(params);
+      } finally {
+        setIsReactivating(false);
+      }
+    },
+    [ctx.reactivateRenewal]
+  );
+  const activatePlan = useCallback14(
+    async (params) => {
+      setIsActivating(true);
+      try {
+        return await ctx.activatePlan(params);
+      } finally {
+        setIsActivating(false);
+      }
+    },
+    [ctx.activatePlan]
+  );
+  return {
+    cancelRenewal,
+    reactivateRenewal,
+    activatePlan,
+    isCancelling,
+    isReactivating,
+    isActivating
+  };
+}
+
+// src/primitives/CancelPlanButton.tsx
+import { forwardRef as forwardRef8, useCallback as useCallback15, useContext as useContext12 } from "react";
+import { Fragment as Fragment5, jsx as jsx15 } from "react/jsx-runtime";
+function resolveConfirmText(confirm, purchase, defaults) {
+  if (confirm === false) return null;
+  if (typeof confirm === "string") return confirm;
+  const planType = purchase?.planSnapshot?.planType;
+  if (planType === "usage-based") return defaults.usageBased;
+  return defaults.recurring;
+}
+var CancelPlanButton = forwardRef8(
+  function CancelPlanButton2({
+    asChild,
+    purchaseRef,
+    reason,
+    confirm = true,
+    onCancelled,
+    onError,
+    onClick,
+    children,
+    ...rest
+  }, forwardedRef) {
+    const solva = useContext12(SolvaPayContext);
+    if (!solva) throw new MissingProviderError("CancelPlanButton");
+    const copy = useCopy();
+    const { activePurchase } = usePurchase();
+    const { cancelRenewal, isCancelling } = usePurchaseActions();
+    const effectivePurchase = purchaseRef ? activePurchase && activePurchase.reference === purchaseRef ? activePurchase : { reference: purchaseRef } : activePurchase;
+    const effectiveRef = purchaseRef ?? effectivePurchase?.reference;
+    const cancel = useCallback15(async () => {
+      if (!effectiveRef) return;
+      const confirmText = resolveConfirmText(confirm, effectivePurchase, {
+        recurring: copy.cancelPlan.confirmRecurring,
+        usageBased: copy.cancelPlan.confirmUsageBased
+      });
+      if (confirmText && typeof window !== "undefined" && !window.confirm(confirmText)) {
+        return;
+      }
+      try {
+        await cancelRenewal({ purchaseRef: effectiveRef, reason });
+        onCancelled?.();
+      } catch (err) {
+        onError?.(err instanceof Error ? err : new Error(String(err)));
+      }
+    }, [effectiveRef, effectivePurchase, confirm, copy, cancelRenewal, reason, onCancelled, onError]);
+    const disabled = isCancelling || !effectiveRef;
+    const state = isCancelling ? "cancelling" : "idle";
+    const commonProps = {
+      "data-solvapay-cancel-plan": "",
+      "data-state": state,
+      "aria-busy": isCancelling,
+      "aria-disabled": disabled || void 0,
+      disabled,
+      onClick: composeEventHandlers(onClick, () => {
+        void cancel();
+      }),
+      ...rest
+    };
+    const label = isCancelling ? copy.cancelPlan.buttonLoading : copy.cancelPlan.button;
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ jsx15(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx15(Fragment5, { children: label }) })
+      );
+    }
+    return /* @__PURE__ */ jsx15("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? label });
+  }
+);
+
+// src/hooks/usePurchaseStatus.ts
+import { useMemo as useMemo11, useCallback as useCallback16 } from "react";
+function usePurchaseStatus() {
+  const { purchases } = usePurchase();
+  const locale = useLocale();
+  const isPaidPurchase2 = useCallback16((p) => {
+    return (p.amount ?? 0) > 0;
+  }, []);
+  const purchaseData = useMemo11(() => {
+    const cancelledPaidPurchases = purchases.filter((p) => {
+      return p.status === "active" && p.cancelledAt && isPaidPurchase2(p) && isPlanPurchase(p);
+    });
+    const cancelledPurchase = cancelledPaidPurchases.sort(
+      (a, b) => new Date(b.startDate).getTime() - new Date(a.startDate).getTime()
+    )[0] || null;
+    const shouldShowCancelledNotice = !!cancelledPurchase;
+    return {
+      cancelledPurchase,
+      shouldShowCancelledNotice
+    };
+  }, [purchases, isPaidPurchase2]);
+  const formatDate = useCallback16(
+    (dateString) => {
+      if (!dateString) return null;
+      return new Date(dateString).toLocaleDateString(locale || "en-US", {
+        year: "numeric",
+        month: "long",
+        day: "numeric"
+      });
+    },
+    [locale]
+  );
+  const getDaysUntilExpiration = useCallback16((endDate) => {
+    if (!endDate) return null;
+    const now = /* @__PURE__ */ new Date();
+    const expiration = new Date(endDate);
+    const diffTime = expiration.getTime() - now.getTime();
+    const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+    return diffDays > 0 ? diffDays : 0;
+  }, []);
+  return {
+    cancelledPurchase: purchaseData.cancelledPurchase,
+    shouldShowCancelledNotice: purchaseData.shouldShowCancelledNotice,
+    formatDate,
+    getDaysUntilExpiration
+  };
+}
+
+// src/primitives/CancelledPlanNotice.tsx
+import {
+  createContext as createContext9,
+  forwardRef as forwardRef9,
+  useCallback as useCallback17,
+  useContext as useContext13,
+  useMemo as useMemo12
+} from "react";
+import { Fragment as Fragment6, jsx as jsx16 } from "react/jsx-runtime";
+var CancelledPlanNoticeContext = createContext9(null);
+function useNoticeCtx(part) {
+  const ctx = useContext13(CancelledPlanNoticeContext);
+  if (!ctx) {
+    throw new Error(
+      `CancelledPlanNotice.${part} must be rendered inside <CancelledPlanNotice.Root>.`
+    );
+  }
+  return ctx;
+}
+var Root6 = forwardRef9(function CancelledPlanNoticeRoot({ onReactivated, onError, asChild, children, ...rest }, forwardedRef) {
+  const solva = useContext13(SolvaPayContext);
+  if (!solva) throw new MissingProviderError("CancelledPlanNotice");
+  const {
+    cancelledPurchase,
+    shouldShowCancelledNotice,
+    formatDate,
+    getDaysUntilExpiration
+  } = usePurchaseStatus();
+  const { reactivateRenewal, isReactivating } = usePurchaseActions();
+  const reactivate = useCallback17(async () => {
+    if (!cancelledPurchase) return;
+    try {
+      await reactivateRenewal({ purchaseRef: cancelledPurchase.reference });
+      onReactivated?.();
+    } catch (err) {
+      onError?.(err instanceof Error ? err : new Error(String(err)));
+    }
+  }, [cancelledPurchase, reactivateRenewal, onReactivated, onError]);
+  const daysRemaining = useMemo12(
+    () => cancelledPurchase ? getDaysUntilExpiration(cancelledPurchase.endDate) : null,
+    [cancelledPurchase, getDaysUntilExpiration]
+  );
+  const ctx = useMemo12(() => {
+    if (!cancelledPurchase) return null;
+    const state = daysRemaining != null && daysRemaining > 0 ? "active" : "expired";
+    return {
+      purchase: cancelledPurchase,
+      state,
+      daysRemaining,
+      hasReason: !!cancelledPurchase.cancellationReason,
+      formatDate,
+      reactivate,
+      isReactivating
+    };
+  }, [cancelledPurchase, daysRemaining, formatDate, reactivate, isReactivating]);
+  if (!shouldShowCancelledNotice || !ctx) return null;
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx16(CancelledPlanNoticeContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx16(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-cancelled-notice": "",
+      "data-state": ctx.state,
+      "data-has-reason": ctx.hasReason ? "" : void 0,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Heading2 = forwardRef9(function CancelledPlanNoticeHeading({ asChild, children, ...rest }, forwardedRef) {
+  useNoticeCtx("Heading");
+  const copy = useCopy();
+  const Comp = asChild ? Slot : "p";
+  return /* @__PURE__ */ jsx16(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-heading": "", ...rest, children: children ?? copy.cancelledNotice.heading });
+});
+var Expires = forwardRef9(function CancelledPlanNoticeExpires({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useNoticeCtx("Expires");
+  const copy = useCopy();
+  const date = ctx.formatDate(ctx.purchase.endDate);
+  if (!ctx.purchase.endDate) {
+    const Comp2 = asChild ? Slot : "p";
+    return /* @__PURE__ */ jsx16(Comp2, { ref: forwardedRef, "data-solvapay-cancelled-notice-expires": "", ...rest, children: children ?? copy.cancelledNotice.accessEnded });
+  }
+  const Comp = asChild ? Slot : "p";
+  return /* @__PURE__ */ jsx16(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-expires": "", ...rest, children: children ?? interpolate(copy.cancelledNotice.expiresLabel, { date: date ?? "" }) });
+});
+var DaysRemaining = forwardRef9(
+  function CancelledPlanNoticeDaysRemaining({ asChild, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("DaysRemaining");
+    const copy = useCopy();
+    if (ctx.daysRemaining == null || ctx.daysRemaining <= 0) return null;
+    const template = ctx.daysRemaining === 1 ? copy.cancelledNotice.dayRemaining : copy.cancelledNotice.daysRemaining;
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ jsx16(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-days-remaining": "", ...rest, children: children ?? interpolate(template, { days: ctx.daysRemaining }) });
+  }
+);
+var AccessUntil = forwardRef9(
+  function CancelledPlanNoticeAccessUntil({ asChild, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("AccessUntil");
+    const copy = useCopy();
+    if (!ctx.purchase.endDate) return null;
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ jsx16(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-access-until": "", ...rest, children: children ?? interpolate(copy.cancelledNotice.accessUntil, {
+      product: ctx.purchase.productName
+    }) });
+  }
+);
+var CancelledOn = forwardRef9(
+  function CancelledPlanNoticeCancelledOn({ asChild, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("CancelledOn");
+    const copy = useCopy();
+    if (!ctx.purchase.cancelledAt) return null;
+    const date = ctx.formatDate(ctx.purchase.cancelledAt);
+    const Comp = asChild ? Slot : "p";
+    return /* @__PURE__ */ jsx16(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-cancelled-on": "", ...rest, children: children ?? interpolate(copy.cancelledNotice.cancelledOn, { date: date ?? "" }) });
+  }
+);
+var Reason = forwardRef9(function CancelledPlanNoticeReason({ asChild, children, ...rest }, forwardedRef) {
+  const ctx = useNoticeCtx("Reason");
+  if (!ctx.hasReason) return null;
+  const Comp = asChild ? Slot : "span";
+  return /* @__PURE__ */ jsx16(Comp, { ref: forwardedRef, "data-solvapay-cancelled-notice-reason": "", ...rest, children: children ?? ctx.purchase.cancellationReason });
+});
+var ReactivateButton = forwardRef9(
+  function CancelledPlanNoticeReactivateButton({ asChild, onClick, children, ...rest }, forwardedRef) {
+    const ctx = useNoticeCtx("ReactivateButton");
+    const copy = useCopy();
+    const disabled = ctx.isReactivating;
+    const commonProps = {
+      "data-solvapay-cancelled-notice-reactivate": "",
+      "data-state": ctx.isReactivating ? "reactivating" : "idle",
+      "aria-busy": ctx.isReactivating,
+      "aria-disabled": disabled || void 0,
+      disabled,
+      onClick: composeEventHandlers(onClick, () => {
+        void ctx.reactivate();
+      }),
+      ...rest
+    };
+    const label = ctx.isReactivating ? copy.cancelledNotice.reactivateButtonLoading : copy.cancelledNotice.reactivateButton;
+    if (asChild) {
+      return (
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        /* @__PURE__ */ jsx16(Slot, { ref: forwardedRef, ...commonProps, children: children ?? /* @__PURE__ */ jsx16(Fragment6, { children: label }) })
+      );
+    }
+    return /* @__PURE__ */ jsx16("button", { ref: forwardedRef, type: "button", ...commonProps, children: children ?? label });
+  }
+);
+var CancelledPlanNoticeRoot2 = Root6;
+var CancelledPlanNoticeHeading2 = Heading2;
+var CancelledPlanNoticeExpires2 = Expires;
+var CancelledPlanNoticeDaysRemaining2 = DaysRemaining;
+var CancelledPlanNoticeAccessUntil2 = AccessUntil;
+var CancelledPlanNoticeCancelledOn2 = CancelledOn;
+var CancelledPlanNoticeReason2 = Reason;
+var CancelledPlanNoticeReactivateButton2 = ReactivateButton;
+var CancelledPlanNotice = {
+  Root: Root6,
+  Heading: Heading2,
+  Expires,
+  DaysRemaining,
+  AccessUntil,
+  CancelledOn,
+  Reason,
+  ReactivateButton
+};
+function useCancelledPlanNotice() {
+  return useNoticeCtx("useCancelledPlanNotice");
+}
+
+// src/hooks/useTransport.ts
+import { useMemo as useMemo13 } from "react";
+function useTransport() {
+  const { _config } = useSolvaPay();
+  return useMemo13(() => _config?.transport ?? createHttpTransport(_config), [_config]);
+}
+
+// src/hooks/useUsage.ts
+import { useCallback as useCallback18, useEffect as useEffect10, useMemo as useMemo14, useState as useState13 } from "react";
+function deriveUsage(purchase) {
+  if (!purchase) return null;
+  const snap = purchase.planSnapshot;
+  const usage = purchase.usage;
+  const meterRef = snap?.meterRef ?? null;
+  const total = typeof snap?.limit === "number" ? snap.limit : null;
+  if (meterRef === null && !usage) return null;
+  const used = typeof usage?.used === "number" ? usage.used : 0;
+  const remaining = total !== null ? Math.max(0, total - used) : null;
+  const percentUsed = total !== null && total > 0 ? Math.min(100, Math.round(used / total * 1e4) / 100) : null;
+  return {
+    meterRef,
+    total,
+    used,
+    remaining,
+    percentUsed,
+    ...usage?.periodStart ? { periodStart: usage.periodStart } : {},
+    ...usage?.periodEnd ? { periodEnd: usage.periodEnd } : {},
+    ...purchase.reference ? { purchaseRef: purchase.reference } : {}
+  };
+}
+function useUsage() {
+  const { activePurchase, refetch: refetchPurchase, loading: purchaseLoading } = usePurchase();
+  const transport = useTransport();
+  const [override, setOverride] = useState13(null);
+  const [error, setError] = useState13(null);
+  const [transportLoading, setTransportLoading] = useState13(false);
+  const derived = useMemo14(() => deriveUsage(activePurchase ?? null), [activePurchase]);
+  const activePurchaseRef = activePurchase?.reference ?? null;
+  useEffect10(() => {
+    setOverride(null);
+  }, [activePurchaseRef]);
+  const usage = override ?? derived;
+  const refetch = useCallback18(async () => {
+    setError(null);
+    if (typeof transport.getUsage === "function") {
+      setTransportLoading(true);
+      try {
+        const next = await transport.getUsage();
+        setOverride(next);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to load usage"));
+      } finally {
+        setTransportLoading(false);
+      }
+      return;
+    }
+    try {
+      await refetchPurchase();
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to refetch purchase"));
+    }
+  }, [transport, refetchPurchase]);
+  const percentUsed = usage?.percentUsed ?? null;
+  const isApproachingLimit = percentUsed !== null && percentUsed >= 80 && percentUsed < 100;
+  const isAtLimit = percentUsed !== null && percentUsed >= 100;
+  const isUnlimited = usage !== null && usage.total === null;
+  return {
+    usage,
+    loading: purchaseLoading || transportLoading,
+    error,
+    refetch,
+    percentUsed,
+    isApproachingLimit,
+    isAtLimit,
+    isUnlimited,
+    meterRef: usage?.meterRef ?? null
+  };
+}
+
+// src/primitives/UsageMeter.tsx
+import { createContext as createContext10, forwardRef as forwardRef10, useContext as useContext14, useMemo as useMemo15 } from "react";
+import { jsx as jsx17 } from "react/jsx-runtime";
+var UsageMeterContext = createContext10(null);
+function useUsageMeterCtx(part) {
+  const ctx = useContext14(UsageMeterContext);
+  if (!ctx) {
+    throw new Error(`UsageMeter.${part} must be rendered inside <UsageMeter.Root>.`);
+  }
+  return ctx;
+}
+var Root7 = forwardRef10(function UsageMeterRoot({
+  warningAt = 75,
+  criticalAt = 90,
+  classNames,
+  asChild,
+  usageOverride,
+  children,
+  className,
+  ...rest
+}, forwardedRef) {
+  const hookResult = useUsage();
+  const usage = usageOverride !== void 0 ? usageOverride : hookResult.usage;
+  const loading = hookResult.loading && !usage;
+  const percentUsed = usage?.percentUsed ?? null;
+  const state = loading ? "loading" : percentUsed === null ? "safe" : percentUsed >= criticalAt ? "critical" : percentUsed >= warningAt ? "warning" : "safe";
+  const ctx = useMemo15(
+    () => ({
+      usage,
+      loading,
+      error: hookResult.error,
+      percentUsed,
+      isApproachingLimit: hookResult.isApproachingLimit,
+      isAtLimit: hookResult.isAtLimit,
+      isUnlimited: hookResult.isUnlimited,
+      state,
+      warningAt,
+      criticalAt
+    }),
+    [
+      usage,
+      loading,
+      hookResult.error,
+      percentUsed,
+      hookResult.isApproachingLimit,
+      hookResult.isAtLimit,
+      hookResult.isUnlimited,
+      state,
+      warningAt,
+      criticalAt
+    ]
+  );
+  const rootClass = [classNames?.root ?? "solvapay-usage-meter", className].filter(Boolean).join(" ");
+  const Comp = asChild ? Slot : "div";
+  return /* @__PURE__ */ jsx17(UsageMeterContext.Provider, { value: ctx, children: /* @__PURE__ */ jsx17(
+    Comp,
+    {
+      ref: forwardedRef,
+      "data-solvapay-usage-meter": "",
+      "data-state": state,
+      className: rootClass,
+      ...rest,
+      children
+    }
+  ) });
+});
+var Bar = forwardRef10(function UsageMeterBar({ className, style, ...rest }, forwardedRef) {
+  const ctx = useUsageMeterCtx("Bar");
+  const width = ctx.percentUsed === null ? 0 : Math.max(0, Math.min(100, ctx.percentUsed));
+  return /* @__PURE__ */ jsx17(
+    "div",
+    {
+      ref: forwardedRef,
+      "data-solvapay-usage-meter-bar": "",
+      "data-state": ctx.state,
+      role: "progressbar",
+      "aria-valuenow": Math.round(width),
+      "aria-valuemin": 0,
+      "aria-valuemax": 100,
+      className: className ?? "solvapay-usage-meter-bar",
+      style: {
+        // Expose as a CSS custom property so default styles can drive
+        // `width: var(--solvapay-usage-meter-fill)` without inline styling.
+        ["--solvapay-usage-meter-fill"]: `${width}%`,
+        ...style
+      },
+      ...rest
+    }
+  );
+});
+var Label = forwardRef10(function UsageMeterLabel({ className, children, ...rest }, forwardedRef) {
+  const ctx = useUsageMeterCtx("Label");
+  const copy = useCopy();
+  if (!ctx.usage) return null;
+  if (ctx.isUnlimited) {
+    return /* @__PURE__ */ jsx17(
+      "span",
+      {
+        ref: forwardedRef,
+        "data-solvapay-usage-meter-label": "",
+        className: className ?? "solvapay-usage-meter-label",
+        ...rest,
+        children: children ?? copy.usage.unlimitedLabel
+      }
+    );
+  }
+  const unit = ctx.usage.meterRef ?? "units";
+  const label = ctx.usage.total !== null ? interpolate(copy.usage.usedLabel, {
+    used: String(ctx.usage.used),
+    total: String(ctx.usage.total),
+    unit
+  }) : interpolate(copy.usage.remainingLabel, {
+    remaining: String(ctx.usage.remaining ?? 0),
+    unit
+  });
+  return /* @__PURE__ */ jsx17(
+    "span",
+    {
+      ref: forwardedRef,
+      "data-solvapay-usage-meter-label": "",
+      className: className ?? "solvapay-usage-meter-label",
+      ...rest,
+      children: children ?? label
+    }
+  );
+});
+var Percentage = forwardRef10(function UsageMeterPercentage({ className, children, ...rest }, forwardedRef) {
+  const ctx = useUsageMeterCtx("Percentage");
+  const copy = useCopy();
+  if (ctx.percentUsed === null) return null;
+  return /* @__PURE__ */ jsx17(
+    "span",
+    {
+      ref: forwardedRef,
+      "data-solvapay-usage-meter-percentage": "",
+      className: className ?? "solvapay-usage-meter-percentage",
+      ...rest,
+      children: children ?? interpolate(copy.usage.percentUsedLabel, { percent: String(Math.round(ctx.percentUsed)) })
+    }
+  );
+});
+function formatResetsIn(copy, periodEnd, nowMs = typeof performance !== "undefined" ? performance.timeOrigin + performance.now() : 0) {
+  const end = new Date(periodEnd).getTime();
+  if (Number.isNaN(end)) return null;
+  const daysLeft = Math.max(0, Math.ceil((end - nowMs) / (24 * 60 * 60 * 1e3)));
+  return daysLeft > 0 ? interpolate(copy.usage.resetsInLabel, { days: String(daysLeft) }) : interpolate(copy.usage.resetsOnLabel, { date: new Date(periodEnd).toLocaleDateString() });
+}
+var ResetsIn = forwardRef10(function UsageMeterResetsIn({ className, children, ...rest }, forwardedRef) {
+  const ctx = useUsageMeterCtx("ResetsIn");
+  const copy = useCopy();
+  const periodEnd = ctx.usage?.periodEnd;
+  if (!periodEnd) return null;
+  const label = formatResetsIn(copy, periodEnd);
+  if (!label) return null;
+  return /* @__PURE__ */ jsx17(
+    "span",
+    {
+      ref: forwardedRef,
+      "data-solvapay-usage-meter-resets-in": "",
+      className: className ?? "solvapay-usage-meter-resets-in",
+      ...rest,
+      children: children ?? label
+    }
+  );
+});
+var Loading4 = forwardRef10(function UsageMeterLoading({ className, children, ...rest }, forwardedRef) {
+  const ctx = useUsageMeterCtx("Loading");
+  const copy = useCopy();
+  if (ctx.state !== "loading") return null;
+  return /* @__PURE__ */ jsx17(
+    "div",
+    {
+      ref: forwardedRef,
+      "data-solvapay-usage-meter-loading": "",
+      className: className ?? "solvapay-usage-meter-loading",
+      ...rest,
+      children: children ?? copy.usage.loadingLabel
+    }
+  );
+});
+var Empty = forwardRef10(function UsageMeterEmpty({ className, children, ...rest }, forwardedRef) {
+  const ctx = useUsageMeterCtx("Empty");
+  const copy = useCopy();
+  if (ctx.loading || ctx.usage !== null) return null;
+  return /* @__PURE__ */ jsx17(
+    "div",
+    {
+      ref: forwardedRef,
+      "data-solvapay-usage-meter-empty": "",
+      className: className ?? "solvapay-usage-meter-empty",
+      ...rest,
+      children: children ?? copy.usage.emptyLabel
+    }
+  );
+});
+var UsageMeter = Object.assign(Root7, {
+  Root: Root7,
+  Bar,
+  Label,
+  Percentage,
+  ResetsIn,
+  Loading: Loading4,
+  Empty
+});
+function useUsageMeter() {
+  return useUsageMeterCtx("useUsageMeter");
+}
+
+// src/hooks/usePaywallResolver.ts
+import { useCallback as useCallback19, useMemo as useMemo16 } from "react";
+function usePaywallResolver(content) {
+  const { activePurchase, hasPaidPurchase, refetch: refetchPurchase } = usePurchase();
+  const { credits, refetch: refetchBalance } = useBalance();
+  const resolved = useMemo16(() => {
+    if (!content) return false;
+    const productMatches = !content.product || activePurchase?.productRef === content.product || activePurchase?.productName === content.product;
+    if (content.kind === "payment_required") {
+      return Boolean(hasPaidPurchase && productMatches);
+    }
+    const balance = content.balance;
+    if (balance && typeof balance.remainingUnits === "number" && balance.remainingUnits > 0) {
+      return true;
+    }
+    if (balance && credits != null && balance.creditsPerUnit && credits >= balance.creditsPerUnit) {
+      return true;
+    }
+    return Boolean(productMatches && activePurchase?.status === "active");
+  }, [content, hasPaidPurchase, activePurchase, credits]);
+  const refetch = useCallback19(async () => {
+    await Promise.all([
+      refetchPurchase().catch(() => void 0),
+      refetchBalance().catch(() => void 0)
+    ]);
+  }, [refetchPurchase, refetchBalance]);
+  return { resolved, refetch };
+}
+
+export {
+  filterPurchases,
+  getActivePurchases,
+  getCancelledPurchasesWithEndDate,
+  getMostRecentPurchase,
+  getPrimaryPurchase,
+  isPaidPurchase,
+  isPlanPurchase,
+  isTopupPurchase,
+  DEFAULT_ROUTES,
+  createHttpTransport,
+  enCopy,
+  mergeCopy,
+  CopyContext,
+  CopyProvider,
+  SolvaPayContext,
+  SolvaPayProvider,
+  setRef,
+  composeRefs,
+  Slot,
+  Slottable,
+  composeEventHandlers,
+  MissingProviderError,
+  MissingProductRefError,
+  useSolvaPay,
+  useCheckout,
+  usePurchase,
+  useCustomer,
+  useCopy,
+  useLocale,
+  plansCache,
+  usePlans,
+  usePlan,
+  createTransportCacheKey,
+  productCache,
+  useProduct,
+  useActivation,
+  usePlanSelection,
+  PaymentFormContext,
+  usePaymentForm,
+  PaymentFormProvider,
+  getMinorUnitsPerMajor,
+  toMajorUnits,
+  formatPrice,
+  interpolate,
+  CheckoutSummaryRoot2 as CheckoutSummaryRoot,
+  CheckoutSummaryProduct2 as CheckoutSummaryProduct,
+  CheckoutSummaryPlan2 as CheckoutSummaryPlan,
+  CheckoutSummaryPrice2 as CheckoutSummaryPrice,
+  CheckoutSummaryTrial2 as CheckoutSummaryTrial,
+  CheckoutSummaryTaxNote2 as CheckoutSummaryTaxNote,
+  CheckoutSummary,
+  useCheckoutSummary,
+  CheckoutSummary2,
+  merchantCache,
+  useMerchant,
+  deriveVariant,
+  MandateText,
+  Spinner,
+  confirmPayment,
+  resolveCta,
+  PaymentFormRoot2 as PaymentFormRoot,
+  PaymentFormSummary,
+  PaymentFormCustomerFields2 as PaymentFormCustomerFields,
+  PaymentFormPaymentElement,
+  PaymentFormCardElement,
+  PaymentFormMandateText,
+  PaymentFormTermsCheckbox2 as PaymentFormTermsCheckbox,
+  PaymentFormSubmitButton2 as PaymentFormSubmitButton,
+  PaymentFormLoading2 as PaymentFormLoading,
+  PaymentFormError2 as PaymentFormError,
+  PaymentForm,
+  useTopupAmountSelector,
+  useBalance,
+  AmountPickerRoot2 as AmountPickerRoot,
+  AmountPickerOption2 as AmountPickerOption,
+  AmountPickerCustom2 as AmountPickerCustom,
+  AmountPickerConfirm2 as AmountPickerConfirm,
+  AmountPicker,
+  useAmountPicker,
+  useAmountPickerCopy,
+  useTopup,
+  TopupFormRoot2 as TopupFormRoot,
+  TopupFormPaymentElement,
+  TopupFormSubmitButton2 as TopupFormSubmitButton,
+  TopupFormLoading2 as TopupFormLoading,
+  TopupFormError2 as TopupFormError,
+  TopupForm,
+  useTopupForm,
+  BalanceBadge,
+  defaultListPlans,
+  PlanSelectorRoot2 as PlanSelectorRoot,
+  PlanSelectorHeading2 as PlanSelectorHeading,
+  PlanSelectorGrid2 as PlanSelectorGrid,
+  PlanSelectorCard2 as PlanSelectorCard,
+  PlanSelectorCardName2 as PlanSelectorCardName,
+  PlanSelectorCardPrice2 as PlanSelectorCardPrice,
+  PlanSelectorCardInterval2 as PlanSelectorCardInterval,
+  PlanSelectorCardBadge2 as PlanSelectorCardBadge,
+  PlanSelectorLoading2 as PlanSelectorLoading,
+  PlanSelectorError2 as PlanSelectorError,
+  PlanSelector,
+  usePlanSelector,
+  usePurchaseActions,
+  CancelPlanButton,
+  usePurchaseStatus,
+  CancelledPlanNoticeRoot2 as CancelledPlanNoticeRoot,
+  CancelledPlanNoticeHeading2 as CancelledPlanNoticeHeading,
+  CancelledPlanNoticeExpires2 as CancelledPlanNoticeExpires,
+  CancelledPlanNoticeDaysRemaining2 as CancelledPlanNoticeDaysRemaining,
+  CancelledPlanNoticeAccessUntil2 as CancelledPlanNoticeAccessUntil,
+  CancelledPlanNoticeCancelledOn2 as CancelledPlanNoticeCancelledOn,
+  CancelledPlanNoticeReason2 as CancelledPlanNoticeReason,
+  CancelledPlanNoticeReactivateButton2 as CancelledPlanNoticeReactivateButton,
+  CancelledPlanNotice,
+  useCancelledPlanNotice,
+  useTransport,
+  useUsage,
+  Root7 as Root,
+  Bar,
+  Label,
+  Percentage,
+  ResetsIn,
+  Loading4 as Loading,
+  Empty,
+  UsageMeter,
+  useUsageMeter,
+  usePaywallResolver
+};