@startsimpli/billing 0.4.34 → 0.4.37

package/src/copy/billing-copy.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from "vitest";
+import {
+  defaultBillingCopy,
+  withBillingCopy,
+  resolveFeatureCopy,
+  featureText,
+} from "./index";
+import { trialLabel, planCtaLabel } from "../utils/plan";
+import { formatFeatureLabel } from "../utils/format";
+import { crochetPro, crochetFree } from "../components/__fixtures__/crochetProduct";
+
+describe("withBillingCopy", () => {
+  it("returns the defaults with no override", () => {
+    expect(withBillingCopy()).toEqual(defaultBillingCopy);
+    expect(withBillingCopy({})).toEqual(defaultBillingCopy);
+  });
+
+  it("keeps today's strings as the defaults", () => {
+    expect(defaultBillingCopy.changePlan).toBe("Change Plan");
+    expect(defaultBillingCopy.availablePlans).toBe("Available Plans");
+    expect(defaultBillingCopy.downgradeTo("Free")).toBe("Downgrade to Free");
+    expect(defaultBillingCopy.upgradeTo("Pro")).toBe("Upgrade to Pro");
+    expect(defaultBillingCopy.trialFree(7)).toBe("7-day free trial");
+  });
+
+  it("overrides single keys and merges the status labels per key", () => {
+    const c = withBillingCopy({ changePlan: "Pick a plan", status: { active: "On" } as never });
+    expect(c.changePlan).toBe("Pick a plan");
+    expect(c.availablePlans).toBe("Available Plans");
+    expect(c.status.active).toBe("On");
+    expect(c.status.past_due).toBe("Past due");
+  });
+});
+
+describe("resolveFeatureCopy", () => {
+  const f = { key: "ai_refine", name: "AI chat to refine any pattern", value: true };
+  it("is null without an entry", () => {
+    expect(resolveFeatureCopy(f, undefined)).toBeNull();
+    expect(resolveFeatureCopy(f, { other: "x" })).toBeNull();
+  });
+  it("accepts a string or {label, hint}", () => {
+    expect(resolveFeatureCopy(f, { ai_refine: "Chat to tweak" })).toEqual({ label: "Chat to tweak" });
+    expect(resolveFeatureCopy(f, { ai_refine: { label: "Chat", hint: "Ask for changes" } })).toEqual({ label: "Chat", hint: "Ask for changes" });
+  });
+  it("featureText falls back to the old label", () => {
+    expect(featureText(f, undefined)).toEqual({ label: formatFeatureLabel(f) });
+    expect(featureText(f, { ai_refine: "Chat" }).label).toBe("Chat");
+  });
+});
+
+describe("plan helpers take optional copy", () => {
+  it("trialLabel default unchanged, overridable", () => {
+    expect(trialLabel(crochetPro)).toBe("7-day free trial");
+    expect(trialLabel(crochetPro, withBillingCopy({ trialFree: (d) => `Try it for ${d} days` }))).toBe("Try it for 7 days");
+  });
+  it("trialLabel with a fee", () => {
+    const o = { ...crochetPro, trialFeeCents: 100 };
+    expect(trialLabel(o)).toBe("7-day trial · $1 today");
+    expect(trialLabel(o, withBillingCopy({ trialWithFee: (d, fee) => `${d} days, ${fee} now` }))).toBe("7 days, $1 now");
+  });
+  it("planCtaLabel default unchanged, overridable", () => {
+    expect(planCtaLabel(crochetFree, "downgrade")).toBe("Downgrade to Free");
+    expect(planCtaLabel(crochetPro, "upgrade", true)).toBe("Upgrade to Pro");
+    expect(planCtaLabel(crochetPro, "current")).toBe("Current plan");
+    const copy = withBillingCopy({ downgradeTo: (n) => `Move down to ${n}`, upgradeTo: (n) => `Move up to ${n}`, currentPlan: "Your pick" });
+    expect(planCtaLabel(crochetFree, "downgrade", false, copy)).toBe("Move down to Free");
+    expect(planCtaLabel(crochetPro, "upgrade", true, copy)).toBe("Move up to Pro");
+    expect(planCtaLabel(crochetPro, "current", false, copy)).toBe("Your pick");
+  });
+});

package/src/copy/billing-copy.ts

@@ -0,0 +1,188 @@
+/**
+ * Every overridable customer-facing string of the plan UI. The app owns its
+ * vocabulary (what a plan or a design is called); these defaults are the
+ * words the components always had. Plan NAMES and prices are not here: they
+ * come from the offers.
+ *
+ *   <SubscriptionManager copy={{ changePlan: "Pick a level" }} />
+ */
+import { defaultPlanChangeCopy, type PlanChangeCopy } from "./plan-change-copy";
+
+export interface BillingCopy extends PlanChangeCopy {
+  // Plan grid (SubscriptionManager) and buttons shared by every plan list.
+  changePlan: string;
+  availablePlans: string;
+  currentPlan: string;
+  upgradeTo: (offerName: string) => string;
+  downgradeTo: (offerName: string) => string;
+  /** Button on the current-plan card: "Upgrade to Pro →". */
+  upgradeToArrow: (offerName: string) => string;
+  switchToAnnual: string;
+  switchToMonthly: string;
+  startsOn: (date: string) => string;
+  openingCheckout: string;
+  onlyOwnerCanChange: string;
+  manageBilling: string;
+  loadingShort: string;
+
+  // Trial phrasing ("7-day free trial").
+  trialFree: (days: number) => string;
+  /** The trial costs a card-check fee, so it is not called free. */
+  trialWithFee: (days: number, fee: string) => string;
+
+  // Status badges, keyed by subscription status.
+  status: Record<string, string>;
+  endsOn: (date: string) => string;
+  /** Spoken form inside the status label: "ends Jun 27, 2026". */
+  endsOnAria: (date: string) => string;
+  statusAria: (label: string) => string;
+
+  // Current plan card.
+  freePrice: string;
+  pastDueMessage: string;
+  updateCard: string;
+  cancelledMessage: (planName: string, date: string) => string;
+  endOfPeriod: string;
+  reactivate: string;
+  checkoutExpired: (planName: string) => string;
+  setupIncomplete: (planName: string) => string;
+  startOver: string;
+  finishCheckout: string;
+  trialEndsToday: (date: string) => string;
+  trialEndsTomorrow: (date: string) => string;
+  trialEndsIn: (days: number, date: string) => string;
+  cancelTrial: string;
+  firstCharge: (price: string, date: string) => string;
+  nextBilling: (date: string) => string;
+  billingPeriod: (start: string, end: string) => string;
+
+  // SubscriptionManager states and banners.
+  freeByDefault: (planName: string) => string;
+  chooseToUpgrade: string;
+  noSubscription: string;
+  chooseToStart: string;
+  trialStarted: (planName: string) => string;
+  activated: string;
+  checkoutCancelled: string;
+  paymentPending: string;
+  activating: string;
+  scheduled: string;
+  scheduledUntil: (date: string) => string;
+  scheduledUntilPeriodEnd: string;
+
+  // Pricing pages, modal and section.
+  chooseAPlan: string;
+  mostPopular: string;
+  everythingIn: (tierName: string) => string;
+  yourPlanBilled: (interval: "monthly" | "yearly") => string;
+  unlistedYoureOn: (planName: string) => string;
+  unlistedExplain: (planName: string) => string;
+  pricingLoading: string;
+  pricingError: string;
+  pricingErrorTryAgain: string;
+  noPlans: string;
+  tryAgain: string;
+  checkingPlan: string;
+  planCheckFailed: string;
+  featureColumn: string;
+  included: string;
+  notIncluded: string;
+  unlimited: string;
+  monthly: string;
+  annual: string;
+  billingInterval: string;
+}
+
+export const defaultBillingCopy: BillingCopy = {
+  ...defaultPlanChangeCopy,
+  changePlan: "Change Plan",
+  availablePlans: "Available Plans",
+  currentPlan: "Current plan",
+  upgradeTo: (n) => `Upgrade to ${n}`,
+  downgradeTo: (n) => `Downgrade to ${n}`,
+  upgradeToArrow: (n) => `Upgrade to ${n} →`,
+  switchToAnnual: "Switch to annual",
+  switchToMonthly: "Switch to monthly",
+  startsOn: (d) => `Starts ${d}`,
+  openingCheckout: "Opening checkout…",
+  onlyOwnerCanChange: "Only the team owner can change the plan",
+  manageBilling: "Manage Billing",
+  loadingShort: "Loading...",
+
+  trialFree: (days) => `${days}-day free trial`,
+  trialWithFee: (days, fee) => `${days}-day trial · ${fee} today`,
+
+  status: {
+    active: "Active",
+    trialing: "Trialing",
+    past_due: "Past due",
+    cancelled: "Cancelled",
+    incomplete: "Incomplete",
+    incomplete_expired: "Expired",
+    unpaid: "Unpaid",
+  },
+  endsOn: (d) => `Ends ${d}`,
+  endsOnAria: (d) => `ends ${d}`,
+  statusAria: (label) => `Subscription status: ${label}`,
+
+  freePrice: "Free",
+  pastDueMessage: "Your last payment failed. Update your card to keep your subscription active.",
+  updateCard: "Update card",
+  cancelledMessage: (name, date) => `Your ${name} plan is cancelled. You'll keep access until ${date}.`,
+  endOfPeriod: "the end of your period",
+  reactivate: "Reactivate",
+  checkoutExpired: (name) => `Your ${name} checkout expired. Start over to activate the plan.`,
+  setupIncomplete: (name) => `Your ${name} plan setup is incomplete. Finish checkout to activate.`,
+  startOver: "Start over",
+  finishCheckout: "Finish checkout",
+  trialEndsToday: (d) => `Your trial ends today (${d}).`,
+  trialEndsTomorrow: (d) => `Your trial ends tomorrow (${d}).`,
+  trialEndsIn: (n, d) => `Your trial ends in ${n} days (${d}).`,
+  cancelTrial: "Cancel trial",
+  firstCharge: (price, d) => `First charge ${price} on ${d}`,
+  nextBilling: (d) => `Next billing date: ${d}`,
+  billingPeriod: (s, e) => `Billing period: ${s} to ${e}`,
+
+  freeByDefault: (name) => `You're on the ${name} plan`,
+  chooseToUpgrade: "Choose a plan below to upgrade.",
+  noSubscription: "No active subscription",
+  chooseToStart: "Choose a plan below to get started.",
+  trialStarted: (name) => `Your ${name} trial has started.`,
+  activated: "Subscription activated successfully!",
+  checkoutCancelled: "Checkout was cancelled. You can try again whenever you're ready.",
+  paymentPending: "We haven't received the payment confirmation yet. It can take a minute; refresh this page to check again. Please don't pay a second time.",
+  activating: "Activating your subscription...",
+  scheduled: "Your plan change is scheduled.",
+  scheduledUntil: (d) => `You keep your current plan until ${d}.`,
+  scheduledUntilPeriodEnd: "You keep your current plan until the end of this billing period.",
+
+  chooseAPlan: "Choose a plan",
+  mostPopular: "Most Popular",
+  everythingIn: (tier) => `Everything in ${tier}, plus:`,
+  yourPlanBilled: (i) => `Your plan · billed ${i}`,
+  unlistedYoureOn: (n) => `You're on ${n}.`,
+  unlistedExplain: (n) => `It isn't one of the plans below. If you choose another plan, ${n} ends and can't be chosen again.`,
+  pricingLoading: "Loading pricing...",
+  pricingError: "Unable to load pricing.",
+  pricingErrorTryAgain: "Unable to load pricing. Please try again.",
+  noPlans: "No pricing plans available at this time.",
+  tryAgain: "Try again",
+  checkingPlan: "Checking your plan…",
+  planCheckFailed: "We couldn't check your plan, so plan changes are paused.",
+  featureColumn: "Feature",
+  included: "Included",
+  notIncluded: "Not included",
+  unlimited: "Unlimited",
+  monthly: "Monthly",
+  annual: "Annual",
+  billingInterval: "Billing interval",
+};
+
+/** Per-key override. `status` is merged key by key so one badge can change. */
+export type BillingCopyInput = Partial<BillingCopy>;
+
+export const withBillingCopy = (copy?: BillingCopyInput): BillingCopy => ({
+  ...defaultBillingCopy,
+  ...copy,
+  status: { ...defaultBillingCopy.status, ...copy?.status },
+});

package/src/copy/feature-copy.ts

@@ -0,0 +1,24 @@
+import type { OfferFeature } from "../types";
+import { formatFeatureLabel } from "../utils/format";
+
+export type FeatureCopyEntry = string | { label: string; hint?: string };
+
+/** Override of a plan feature row, by feature key (`ai_refine`, `trial_note`, …). */
+export type FeatureCopy = Record<string, FeatureCopyEntry>;
+
+export interface FeatureText {
+  label: string;
+  hint?: string;
+}
+
+/** The override for this feature, or null when the app set none. */
+export function resolveFeatureCopy(feature: Pick<OfferFeature, "key">, featureCopy?: FeatureCopy): FeatureText | null {
+  const entry = featureCopy?.[feature.key];
+  if (entry === undefined || entry === null) return null;
+  return typeof entry === "string" ? { label: entry } : { label: entry.label, ...(entry.hint ? { hint: entry.hint } : {}) };
+}
+
+/** What a feature row says: the override, else the label the card always had. */
+export function featureText(feature: OfferFeature, featureCopy?: FeatureCopy): FeatureText {
+  return resolveFeatureCopy(feature, featureCopy) ?? { label: formatFeatureLabel(feature) };
+}

package/src/copy/index.ts

@@ -0,0 +1,6 @@
+export { defaultBillingCopy, withBillingCopy } from "./billing-copy";
+export type { BillingCopy, BillingCopyInput } from "./billing-copy";
+export { defaultPlanChangeCopy } from "./plan-change-copy";
+export type { PlanChangeCopy } from "./plan-change-copy";
+export { featureText, resolveFeatureCopy } from "./feature-copy";
+export type { FeatureCopy, FeatureCopyEntry, FeatureText } from "./feature-copy";

package/src/copy/plan-change-copy.ts

@@ -0,0 +1,66 @@
+/** The words of the plan-change confirmation dialog (PlanChangeConfirm). */
+export interface PlanChangeCopy {
+  confirmDowngradeTitle: (offerName: string) => string;
+  confirmDowngradeAction: (offerName: string) => string;
+  /** Leaving a plan that is not for sale. */
+  confirmEndAction: (currentName: string) => string;
+  confirmDowngradeAtDate: (currentName: string, date: string) => string;
+  confirmDowngradeAtPeriodEnd: (currentName: string) => string;
+  confirmDowngradeAfter: (offerName: string, currentName: string) => string;
+  confirmEndsNow: (currentName: string) => string;
+  confirmUnlistedGone: (currentName: string) => string;
+  confirmDowngradeGeneric: (currentName: string) => string;
+  confirmSwitchTitle: (offerName: string) => string;
+  confirmSwitchAction: (offerName: string) => string;
+  confirmSwitchAtDate: (currentName: string, offerName: string, date: string, recurring: string) => string;
+  confirmSwitchAtPeriodEnd: (currentName: string, offerName: string, recurring: string) => string;
+  confirmNothingToday: string;
+  confirmChangeTitle: (offerName: string) => string;
+  confirmChangeAction: (offerName: string) => string;
+  confirmChangeRules: (offerName: string, recurring: string) => string;
+  confirmNoTrial: string;
+  confirmUpgradeTitle: (offerName: string) => string;
+  confirmUpgradeAction: (offerName: string) => string;
+  confirmUpgradeAndPay: (amount: string) => string;
+  confirmChargedAmount: (amount: string, recurring: string) => string;
+  confirmChargedProrated: (recurring: string) => string;
+  confirmChangesNow: (currentName: string, offerName: string) => string;
+  /** Used when the viewer's current plan name is unknown. */
+  confirmYourCurrentPlan: string;
+  confirmKeepPlan: string;
+  confirmCancel: string;
+  confirmWorking: string;
+}
+
+const NO_TRIAL = "There's no free trial when you're already on a paid plan.";
+
+export const defaultPlanChangeCopy: PlanChangeCopy = {
+  confirmDowngradeTitle: (n) => `Downgrade to ${n}?`,
+  confirmDowngradeAction: (n) => `Downgrade to ${n}`,
+  confirmEndAction: (c) => `End ${c}`,
+  confirmDowngradeAtDate: (c, d) => `Your ${c} plan ends on ${d}. You keep everything in it until then, and you won't be charged again.`,
+  confirmDowngradeAtPeriodEnd: (c) => `Your ${c} plan ends at the end of this billing period. You keep everything in it until then, and you won't be charged again.`,
+  confirmDowngradeAfter: (n, c) => `After that you're on ${n}, and lose what ${c} includes.`,
+  confirmEndsNow: (c) => `Your ${c} plan ends now, and you lose what it includes.`,
+  confirmUnlistedGone: (c) => `${c} isn't a plan you can buy, so once it ends you can't get it back.`,
+  confirmDowngradeGeneric: (c) => `Your ${c} plan will end. If it is a paid plan you keep it until the end of the period you've paid for.`,
+  confirmSwitchTitle: (n) => `Switch to ${n}?`,
+  confirmSwitchAction: (n) => `Switch to ${n}`,
+  confirmSwitchAtDate: (c, n, d, r) => `You keep ${c} until ${d}. Then your plan changes to ${n} at ${r}.`,
+  confirmSwitchAtPeriodEnd: (c, n, r) => `You keep ${c} until the end of this billing period. Then your plan changes to ${n} at ${r}.`,
+  confirmNothingToday: "Nothing is charged today.",
+  confirmChangeTitle: (n) => `Change to ${n}?`,
+  confirmChangeAction: (n) => `Change to ${n}`,
+  confirmChangeRules: (n, r) => `${n} is ${r}. Moving to a more expensive plan is charged today for the rest of this billing period (prorated); moving to a cheaper one takes effect when this period ends.`,
+  confirmNoTrial: NO_TRIAL,
+  confirmUpgradeTitle: (n) => `Upgrade to ${n}?`,
+  confirmUpgradeAction: (n) => `Upgrade to ${n}`,
+  confirmUpgradeAndPay: (a) => `Upgrade and pay ${a}`,
+  confirmChargedAmount: (a, r) => `You'll be charged ${a} today for the rest of this billing period, then ${r}.`,
+  confirmChargedProrated: (r) => `You'll be charged today for the rest of this billing period (prorated), then ${r}.`,
+  confirmChangesNow: (c, n) => `Your plan changes from ${c} to ${n} now.`,
+  confirmYourCurrentPlan: "your current plan",
+  confirmKeepPlan: "Keep my plan",
+  confirmCancel: "Cancel",
+  confirmWorking: "Working…",
+};

package/src/credits/CreditHistoryList.tsx

@@ -9,8 +9,9 @@ const when = (iso: string) => {
 /** Purchases and use, in the order given (newest first from the server). */
 export function CreditHistoryList({ history, copy }: { history: PatternCreditHistoryEntry[]; copy: CreditsCopy }) {
   if (history.length === 0) return <p className="text-sm text-muted-foreground">{copy.historyEmpty}</p>;
+  // The server's own line ("Added 5 patterns") wins; otherwise the entry type's words.
   const label = (e: PatternCreditHistoryEntry) =>
-    e.entryType === "grant" && e.reason ? e.reason : copy.entry[e.entryType] ?? e.entryType;
+    e.label ? e.label : e.entryType === "grant" && e.reason ? e.reason : copy.entry[e.entryType] ?? e.entryType;
   return (
     <ul aria-label={copy.historyTitle} className="divide-y divide-border rounded-lg border border-border bg-card">
       {history.map((e) => (

package/src/credits/credits.label.test.tsx

@@ -0,0 +1,26 @@
+import React from "react";
+import { render, screen } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+import { CreditHistoryList } from "./CreditHistoryList";
+import { defaultCreditsCopy } from "./copy";
+
+const entry = (over = {}) => ({ id: "h1", entryType: "grant", quantity: 5, externalRef: "", reason: "", createdAt: "2026-11-01T00:00:00Z", ...over }) as never;
+
+describe("CreditHistoryList label", () => {
+  it("renders the server label when given", () => {
+    render(<CreditHistoryList copy={defaultCreditsCopy} history={[entry({ label: "Added 5 patterns" }), entry({ id: "h2", entryType: "commit", quantity: -1, label: "Used 1 pattern" })]} />);
+    expect(screen.getByText("Added 5 patterns")).toBeTruthy();
+    expect(screen.getByText("Used 1 pattern")).toBeTruthy();
+    expect(screen.queryByText("Bought")).toBeNull();
+  });
+  it("falls back to the old rendering without a label", () => {
+    render(<CreditHistoryList copy={defaultCreditsCopy} history={[entry(), entry({ id: "h2", entryType: "grant", reason: "Welcome gift" }), entry({ id: "h3", entryType: "commit", quantity: -1 })]} />);
+    expect(screen.getByText("Bought")).toBeTruthy();
+    expect(screen.getByText("Welcome gift")).toBeTruthy();
+    expect(screen.getByText("Used")).toBeTruthy();
+  });
+  it("ignores an empty label", () => {
+    render(<CreditHistoryList copy={defaultCreditsCopy} history={[entry({ label: "" })]} />);
+    expect(screen.getByText("Bought")).toBeTruthy();
+  });
+});

package/src/index.ts

@@ -43,6 +43,10 @@ export type {
   UsageMap,
 } from "./types";
 
+// Copy / label overrides
+export { defaultBillingCopy, withBillingCopy, defaultPlanChangeCopy, featureText, resolveFeatureCopy } from "./copy";
+export type { BillingCopy, BillingCopyInput, PlanChangeCopy, FeatureCopy, FeatureCopyEntry, FeatureText } from "./copy";
+
 // Components
 export { PricingPage, PricingSection, PricingDetailPage, UpgradeModal, ManageSubscription, SubscriptionManager, PlanGate, CurrentPlanCard, LimitNudge, PlanChangeConfirm, planChangeCopy, UsageMeters } from "./components";
 export type {

package/src/utils/plan.ts

@@ -8,6 +8,7 @@
  */
 
 import type { OfferFeature, ProductOffer, SubscriptionInfo } from "../types";
+import { defaultBillingCopy, type BillingCopy } from "../copy/billing-copy";
 
 const PAID_STATUSES: ReadonlyArray<SubscriptionInfo["status"]> = ["active", "trialing"];
 
@@ -311,10 +312,13 @@ export function trialApplies(card: ProductOffer, direction: PlanDirection, payin
  * "7-day free trial", or "7-day trial · $1 today" when starting it charges a
  * card-check fee (then it is not free, so it must not say so).
  */
-export function trialLabel(offer: Pick<ProductOffer, "trialDays" | "trialFeeCents" | "currency">): string {
+export function trialLabel(
+  offer: Pick<ProductOffer, "trialDays" | "trialFeeCents" | "currency">,
+  copy: Pick<BillingCopy, "trialFree" | "trialWithFee"> = defaultBillingCopy,
+): string {
   const days = offer.trialDays ?? 0;
   const cents = offer.trialFeeCents ?? 0;
-  if (cents <= 0) return `${days}-day free trial`;
+  if (cents <= 0) return copy.trialFree(days);
   const amount = cents / 100;
   let fee: string;
   try {
@@ -326,7 +330,7 @@ export function trialLabel(offer: Pick<ProductOffer, "trialDays" | "trialFeeCent
   } catch {
     fee = `$${amount}`;
   }
-  return `${days}-day trial · ${fee} today`;
+  return copy.trialWithFee(days, fee);
 }
 
 /**
@@ -334,12 +338,17 @@ export function trialLabel(offer: Pick<ProductOffer, "trialDays" | "trialFeeCent
  * new buyer; someone already paying is upgraded in place, so they get
  * "Upgrade to X" (startsim-21f, crochet_patterns-anw61).
  */
-export function planCtaLabel(card: ProductOffer, direction: PlanDirection, paying = false): string {
-  if (direction === "current") return "Current plan";
-  if (direction === "switch") return card.intervalUnit === "year" ? "Switch to annual" : "Switch to monthly";
-  if (direction === "downgrade") return `Downgrade to ${card.name}`;
-  if (paying) return `Upgrade to ${card.name}`;
-  return card.ctaText || `Upgrade to ${card.name}`;
+export function planCtaLabel(
+  card: ProductOffer,
+  direction: PlanDirection,
+  paying = false,
+  copy: Pick<BillingCopy, "currentPlan" | "switchToAnnual" | "switchToMonthly" | "downgradeTo" | "upgradeTo"> = defaultBillingCopy,
+): string {
+  if (direction === "current") return copy.currentPlan;
+  if (direction === "switch") return card.intervalUnit === "year" ? copy.switchToAnnual : copy.switchToMonthly;
+  if (direction === "downgrade") return copy.downgradeTo(card.name);
+  if (paying) return copy.upgradeTo(card.name);
+  return card.ctaText || copy.upgradeTo(card.name);
 }
 
 /**