@fantastic.dev/better-stripe 0.14.0 → 0.15.0

package/src/client/billing/intents.test.ts

@@ -0,0 +1,216 @@
+import { expect, it, vi } from "vitest";
+import { BetterStripe } from "../index.js";
+import { getStripeClient, type Component, type RunCtx } from "../helpers.js";
+
+function fixture() {
+  const ref = { [Symbol.for("toReferencePath")]: "account" };
+  const component = {
+    core: { queries: { getAccountByStripeId: ref } },
+  } as unknown as Component;
+  const key = `sk_test_intents_${crypto.randomUUID()}`;
+  const client = new BetterStripe(component, { STRIPE_SECRET_KEY: key });
+  const sdk = getStripeClient(key);
+  const ctx = {
+    runQuery: vi
+      .fn()
+      .mockResolvedValue({ userId: "buyer", stripeAccountId: "acct_buyer" }),
+  } as unknown as RunCtx;
+  const price = vi.spyOn(sdk.prices, "retrieve").mockResolvedValue({
+    id: "price_one",
+    active: true,
+    type: "one_time",
+    unit_amount: 1200,
+    currency: "usd",
+    product: { id: "prod_one", active: true },
+  } as never);
+  const payment = vi.spyOn(sdk.paymentIntents, "create").mockResolvedValue({
+    id: "pi_one",
+    client_secret: "secret",
+    amount: 1200,
+  } as never);
+  const setup = vi.spyOn(sdk.setupIntents, "create").mockResolvedValue({
+    id: "seti_one",
+    client_secret: "setup_secret",
+  } as never);
+  const opts = {
+    userId: "buyer",
+    customerAccount: "acct_buyer",
+    idempotencyKey: "order:one",
+  };
+  return { client, ctx, price, payment, setup, opts };
+}
+it("creates a card-only intent with provider price economics and protected ownership metadata", async () => {
+  const { client, ctx, payment, opts } = fixture();
+  const args = {
+    ...opts,
+    stripePriceId: "price_one",
+    metadata: { userId: "forged", bsSplit: "forged", planId: "plan_one" },
+  };
+  expect(await client.createPaymentIntent(ctx, args)).toEqual({
+    paymentIntentId: "pi_one",
+    clientSecret: "secret",
+  });
+  await client.createPaymentIntent(ctx, args);
+  expect(payment).toHaveBeenNthCalledWith(
+    2,
+    {
+      amount: 1200,
+      currency: "usd",
+      customer_account: "acct_buyer",
+      receipt_email: undefined,
+      allowed_payment_method_types: ["card"],
+      metadata: {
+        userId: "buyer",
+        planId: "plan_one",
+        stripePriceId: "price_one",
+        stripeProductId: "prod_one",
+      },
+    },
+    { idempotencyKey: "order:one" },
+  );
+});
+it.each([
+  { active: false },
+  { type: "recurring" },
+  { unit_amount: null },
+  { unit_amount: 0 },
+  { product: { id: "prod_one", active: false } },
+])("rejects unsupported price economics %j", async (override) => {
+  const { client, ctx, price, payment, opts } = fixture();
+  price.mockResolvedValue({
+    active: true,
+    type: "one_time",
+    unit_amount: 1200,
+    currency: "usd",
+    product: { id: "prod_one", active: true },
+    ...override,
+  } as never);
+  await expect(
+    client.createPaymentIntent(ctx, { ...opts, stripePriceId: "price_one" }),
+  ).rejects.toThrow();
+  expect(payment).not.toHaveBeenCalled();
+});
+it("rejects another customer's account before provider writes", async () => {
+  const { client, ctx, payment, setup, opts } = fixture();
+  await expect(
+    client.createPaymentIntent(ctx, {
+      ...opts,
+      userId: "attacker",
+      stripePriceId: "price_one",
+    }),
+  ).rejects.toThrow(/belong/);
+  await expect(
+    client.createSetupIntent(ctx, {
+      ...opts,
+      userId: "attacker",
+      usage: "off_session",
+      consent: true,
+    }),
+  ).rejects.toThrow(/belong/);
+  expect(payment).not.toHaveBeenCalled();
+  expect(setup).not.toHaveBeenCalled();
+});
+it("provisions consented card setup, preserves retry key after transport failure, and returns minimal secrets", async () => {
+  const { client, ctx, setup, opts } = fixture();
+  const args = {
+    ...opts,
+    usage: "off_session" as const,
+    consent: true as const,
+  };
+  setup.mockRejectedValueOnce(new Error("connection lost"));
+  await expect(client.createSetupIntent(ctx, args)).rejects.toThrow(
+    "connection lost",
+  );
+  expect(await client.createSetupIntent(ctx, args)).toEqual({
+    setupIntentId: "seti_one",
+    clientSecret: "setup_secret",
+  });
+  expect(setup).toHaveBeenNthCalledWith(
+    2,
+    {
+      customer_account: "acct_buyer",
+      usage: "off_session",
+      allowed_payment_method_types: ["card"],
+      metadata: { userId: "buyer" },
+    },
+    { idempotencyKey: "order:one" },
+  );
+});
+it.each([undefined, "", "\n", "x".repeat(256)])(
+  "requires a valid explicit retry key %j",
+  async (key) => {
+    const { client, ctx, setup, payment, opts } = fixture();
+    const args = { ...opts, idempotencyKey: key as string };
+    await expect(
+      client.createSetupIntent(ctx, {
+        ...args,
+        usage: "on_session",
+        consent: true,
+      }),
+    ).rejects.toThrow();
+    await expect(
+      client.createPaymentIntent(ctx, { ...args, stripePriceId: "price_one" }),
+    ).rejects.toThrow();
+    expect(setup).not.toHaveBeenCalled();
+    expect(payment).not.toHaveBeenCalled();
+  },
+);
+it("requires setup consent and a supported usage", async () => {
+  const { client, ctx, setup, opts } = fixture();
+  await expect(
+    client.createSetupIntent(ctx, {
+      ...opts,
+      usage: "off_session",
+      consent: false as unknown as true,
+    }),
+  ).rejects.toThrow(/consent/);
+  await expect(
+    client.createSetupIntent(ctx, {
+      ...opts,
+      usage: "invalid" as "on_session",
+      consent: true,
+    }),
+  ).rejects.toThrow(/usage/);
+  expect(setup).not.toHaveBeenCalled();
+});
+it("rejects missing client secrets", async () => {
+  const { client, ctx, setup, payment, opts } = fixture();
+  setup.mockResolvedValue({ id: "seti_one", client_secret: null } as never);
+  payment.mockResolvedValue({ id: "pi_one", client_secret: null } as never);
+  await expect(
+    client.createSetupIntent(ctx, {
+      ...opts,
+      usage: "on_session",
+      consent: true,
+    }),
+  ).rejects.toThrow(/secret/);
+  await expect(
+    client.createPaymentIntent(ctx, { ...opts, stripePriceId: "price_one" }),
+  ).rejects.toThrow(/secret/);
+});
+it("preserves host-authorized guest purchases without inventing a customer account", async () => {
+  const { client, ctx, payment } = fixture();
+  await client.createPaymentIntent(ctx, {
+    userId: "",
+    stripePriceId: "price_one",
+    idempotencyKey: "guest:one",
+  });
+  expect(payment).toHaveBeenCalledWith(
+    expect.objectContaining({
+      customer_account: undefined,
+      metadata: expect.objectContaining({ userId: "" }),
+    }),
+    { idempotencyKey: "guest:one" },
+  );
+});
+it("preserves automatic-method checkout when the host selects it", async () => {
+  const { client, ctx, payment, opts } = fixture();
+  await client.createPaymentIntent(ctx, {
+    ...opts,
+    stripePriceId: "price_one",
+    paymentMethods: "automatic",
+  });
+  const request = payment.mock.calls[0][0];
+  expect(request.automatic_payment_methods).toEqual({ enabled: true });
+  expect(request.allowed_payment_method_types).toBeUndefined();
+});

package/src/client/billing/intents.ts

@@ -0,0 +1,120 @@
+import type Stripe from "stripe";
+import type { Component, RunCtx } from "../helpers.js";
+import { stripReservedMetadata } from "../helpers.js";
+import { idempotencyOptions } from "../core/idempotency.js";
+import { componentRef } from "../webhooks/helpers.js";
+
+/** Host must derive userId from authentication and authorize the purchase. */
+export type IntentScope = {
+  userId: string;
+  customerAccount?: string;
+  /** Persist the logical request and its immutable inputs before calling. */
+  idempotencyKey: string;
+  /** Server-selected attribution only. Never forward arbitrary browser metadata. */
+  metadata?: Record<string, string>;
+};
+export type CreatePaymentIntentOptions = IntentScope & {
+  stripePriceId: string;
+  receiptEmail?: string;
+  /** Card-only by default; automatic preserves host-selected local payment methods. */
+  paymentMethods?: "card" | "automatic";
+};
+export type CreateSetupIntentOptions = IntentScope & {
+  customerAccount: string;
+  usage: "on_session" | "off_session";
+  /** Host records consent for the selected usage before provisioning. */
+  consent: true;
+};
+async function authorize(component: Component, ctx: RunCtx, opts: IntentScope) {
+  if (typeof opts.idempotencyKey !== "string")
+    throw new Error("An explicit idempotency key is required.");
+  const request = idempotencyOptions(opts.idempotencyKey)!;
+  if (opts.customerAccount === undefined) return request;
+  if (!opts.userId || !/^acct_[a-zA-Z0-9]+$/.test(opts.customerAccount))
+    throw new Error(
+      "An authenticated user and V2 customer account are required.",
+    );
+  const account = await ctx.runQuery(
+    componentRef(component, "core/queries/getAccountByStripeId"),
+    { stripeAccountId: opts.customerAccount },
+  );
+  if (!account || account.userId !== opts.userId)
+    throw new Error(
+      "Customer account does not belong to the authenticated user.",
+    );
+  return request;
+}
+export async function createPaymentIntent(
+  stripe: Stripe,
+  component: Component,
+  ctx: RunCtx,
+  opts: CreatePaymentIntentOptions,
+) {
+  const request = await authorize(component, ctx, opts);
+  const price = await stripe.prices.retrieve(opts.stripePriceId, {
+    expand: ["product"],
+  });
+  const product = price.product;
+  if (
+    !price.active ||
+    price.type !== "one_time" ||
+    !Number.isSafeInteger(price.unit_amount) ||
+    price.unit_amount! <= 0 ||
+    typeof product === "string" ||
+    product.deleted ||
+    !product.active
+  )
+    throw new Error(
+      "Payment Intents require an active product and a positive fixed one-time price.",
+    );
+  const intent = await stripe.paymentIntents.create(
+    {
+      amount: price.unit_amount!,
+      currency: price.currency,
+      customer_account: opts.customerAccount,
+      receipt_email: opts.receiptEmail,
+      ...(opts.paymentMethods === "automatic"
+        ? { automatic_payment_methods: { enabled: true } }
+        : { allowed_payment_method_types: ["card" as const] }),
+      metadata: {
+        ...stripReservedMetadata(opts.metadata),
+        userId: opts.userId,
+        stripePriceId: price.id,
+        stripeProductId: product.id,
+      },
+    },
+    request,
+  );
+  if (!intent.client_secret)
+    throw new Error("Stripe did not return a payment secret.");
+  return { paymentIntentId: intent.id, clientSecret: intent.client_secret };
+}
+export async function createSetupIntent(
+  stripe: Stripe,
+  component: Component,
+  ctx: RunCtx,
+  opts: CreateSetupIntentOptions,
+) {
+  if (!opts.customerAccount)
+    throw new Error("A customer account is required for setup.");
+  const request = await authorize(component, ctx, opts);
+  if (opts.consent !== true)
+    throw new Error("Explicit saved-card consent is required.");
+  if (opts.usage !== "on_session" && opts.usage !== "off_session")
+    throw new Error("Unsupported SetupIntent usage.");
+  const intent = await stripe.setupIntents.create(
+    {
+      customer_account: opts.customerAccount,
+      usage: opts.usage,
+      allowed_payment_method_types: ["card"],
+      metadata: {
+        ...stripReservedMetadata(opts.metadata),
+        userId: opts.userId,
+      },
+    },
+    request,
+  );
+  if (!intent.client_secret)
+    throw new Error("Stripe did not return a setup secret.");
+  return { setupIntentId: intent.id, clientSecret: intent.client_secret };
+}

package/src/client/billing/intentsTransport.test.ts

@@ -0,0 +1,94 @@
+import type Stripe from "stripe";
+import { componentsGeneric } from "convex/server";
+import { expect, it, vi } from "vitest";
+import { BetterStripe } from "../index.js";
+import { getStripeClient, type Component, type RunCtx } from "../helpers.js";
+it.each([undefined, "2026-09-30.preview"] as const)(
+  "sends customer-bound intents using configured Stripe version %s",
+  async (version) => {
+    const key = `sk_test_intent_transport_${crypto.randomUUID()}`;
+    const client = new BetterStripe(
+      componentsGeneric().betterStripe as unknown as Component,
+      { STRIPE_SECRET_KEY: key, stripeApiVersion: version },
+    );
+    const sdk = getStripeClient(key, version);
+    const calls: {
+      path: string;
+      version: string;
+      key?: string;
+      body: string;
+    }[] = [];
+    (
+      sdk as unknown as { _setApiField: (name: string, value: unknown) => void }
+    )._setApiField("httpClient", {
+      getClientName: () => "intent-contract-test",
+      makeRequest: async (
+        ...[, , path, , headers, body]: Parameters<
+          ReturnType<typeof Stripe.createNodeHttpClient>["makeRequest"]
+        >
+      ) => {
+        calls.push({
+          path,
+          version: String(headers["Stripe-Version"]),
+          key: headers["Idempotency-Key"] as string | undefined,
+          body,
+        });
+        const data = path.startsWith("/v1/prices/")
+          ? {
+              id: "price_one",
+              active: true,
+              type: "one_time",
+              unit_amount: 100,
+              currency: "usd",
+              product: { id: "prod_one", active: true },
+            }
+          : {
+              id: path.includes("setup_intents") ? "seti_one" : "pi_one",
+              client_secret: "secret",
+            };
+        return {
+          getStatusCode: () => 200,
+          getHeaders: () => ({}),
+          getRawResponse: () => ({}),
+          toJSON: async () => data,
+          toStream: () => {
+            throw new Error("Unexpected stream");
+          },
+        };
+      },
+    });
+    const ctx = {
+      runQuery: vi.fn().mockResolvedValue({ userId: "buyer" }),
+    } as unknown as RunCtx;
+    const scope = {
+      userId: "buyer",
+      customerAccount: "acct_buyer",
+      idempotencyKey: "save-one",
+    };
+    await client.createSetupIntent(ctx, {
+      ...scope,
+      usage: "off_session",
+      consent: true,
+    });
+    await client.createPaymentIntent(ctx, {
+      ...scope,
+      idempotencyKey: "pay-one",
+      stripePriceId: "price_one",
+    });
+    expect(calls.map((c) => c.version)).toEqual(
+      Array(3).fill(version ?? "2026-09-30.endive"),
+    );
+    const writes = calls.filter((c) => c.key);
+    expect(writes.map((c) => c.key)).toEqual(["save-one", "pay-one"]);
+    for (const call of writes) {
+      const params = new URLSearchParams(call.body);
+      expect(params.get("customer_account")).toBe("acct_buyer");
+      expect(params.get("allowed_payment_method_types[0]")).toBe("card");
+      expect(params.has("customer")).toBe(false);
+    }
+    expect(new URLSearchParams(writes[0].body).get("usage")).toBe(
+      "off_session",
+    );
+    expect(new URLSearchParams(writes[1].body).get("amount")).toBe("100");
+  },
+);

package/src/client/core/fees.ts

@@ -273,3 +273,11 @@ export function validateSplit(recipients: SplitRecipient[]): void {
     throw new Error(`split percents sum to ${percentSum}, which exceeds 100`);
   }
 }
+
+/** Deep-copy a platform fee config so stored/returned values can't be mutated. */
+export function clonePlatformFee(config: PlatformFeeConfig): PlatformFeeConfig {
+  return {
+    ...config,
+    tiers: config.tiers?.map((tier) => ({ ...tier })),
+  };
+}

package/src/client/index.ts

@@ -1,3 +1,7 @@
+import type { CreateCheckoutSessionOptions } from "./billing/checkoutOptions.js";
+export type { CreateCheckoutSessionOptions } from "./billing/checkoutOptions.js";
+import * as intentsImpl from "./billing/intents.js";
+export type * from "./billing/intents.js";
 import { CostRecoveryClient } from "./costRecovery.js";
 export * from "./charge-currency.js";
 export * from "./costRecovery.js";
@@ -88,7 +92,7 @@ import * as transfersImpl from "./connect/transfers.js";
 import * as accountLinksImpl from "./core/accountLinks.js";
 import * as accountsImpl from "./core/accounts.js";
 import * as configImpl from "./core/config.js";
-import { resolveFeeConfig, validatePlatformFee } from "./core/fees.js";
+import * as fees from "./core/fees.js";
 import { validateStatementDescriptorSuffix } from "./core/descriptors.js";
 export { computeFee, computeSplit } from "./core/fees.js";
 export type { FeeBreakdown, SplitResult, SplitTransfer } from "./core/fees.js";
@@ -204,14 +208,6 @@ export type {
 
 export type BetterStripeComponent = ComponentApi;
 
-/** Deep-copy a platform fee config so stored/returned values can't be mutated. */
-function clonePlatformFee(config: PlatformFeeConfig): PlatformFeeConfig {
-  return {
-    ...config,
-    tiers: config.tiers?.map((tier) => ({ ...tier })),
-  };
-}
-
 // BETTER STRIPE CLIENT
 
 export class BetterStripe {
@@ -230,10 +226,10 @@ export class BetterStripe {
     this._triggers = options?.triggers;
     this._hooks = options?.hooks;
     if (options?.platformFee !== undefined) {
-      validatePlatformFee(options.platformFee);
+      fees.validatePlatformFee(options.platformFee);
       // Store a defensive copy so later mutation of the caller's object can't
       // silently bypass validation or change runtime behavior.
-      this._platformFee = clonePlatformFee(options.platformFee);
+      this._platformFee = fees.clonePlatformFee(options.platformFee);
     }
     if (options?.statementDescriptorSuffix !== undefined) {
       this._statementDescriptorSuffix = validateStatementDescriptorSuffix(
@@ -252,7 +248,7 @@ export class BetterStripe {
 
   /** The configured default platform fee (the platform's take), if any. */
   get platformFee(): PlatformFeeConfig | undefined {
-    return this._platformFee && clonePlatformFee(this._platformFee);
+    return this._platformFee && fees.clonePlatformFee(this._platformFee);
   }
 
   /**
@@ -260,8 +256,8 @@ export class BetterStripe {
    * default. The fee math itself is applied at charge time (M2).
    */
   resolveFee(override?: FeeOverride): PlatformFeeConfig | undefined {
-    const resolved = resolveFeeConfig(this._platformFee, override);
-    return resolved && clonePlatformFee(resolved);
+    const resolved = fees.resolveFeeConfig(this._platformFee, override);
+    return resolved && fees.clonePlatformFee(resolved);
   }
 
   get apiKey(): string {
@@ -657,34 +653,35 @@ export class BetterStripe {
     return pricesImpl.listStripePrices(this.stripe(), ctx, opts);
   }
 
-  // CHECKOUT METHODS
+  /** Card-only one-time checkout. Host authorizes price and authenticated customer. */
+  async createPaymentIntent(
+    ctx: RunCtx,
+    opts: intentsImpl.CreatePaymentIntentOptions,
+  ) {
+    return intentsImpl.createPaymentIntent(
+      this.stripe(),
+      this.component,
+      ctx,
+      opts,
+    );
+  }
 
-  async createCheckoutSession(
+  /** Provision consented card setup; confirmation and authentication happen in Stripe.js. */
+  async createSetupIntent(
     ctx: RunCtx,
-    opts: {
-      idempotencyKey?: string;
-      userId: string;
-      orgId?: string;
-      stripePriceId: string;
-      mode: "payment" | "subscription" | "setup";
-      uiMode?: "embedded" | "redirect" | "custom" | "form";
-      quantity?: number;
-      returnUrl: string;
-      trialDays?: number;
-      accountId?: string;
-      customerEmail?: string;
-      /** Seller/recipient connected account to route funds to (destination charge). */
-      destinationAccountId?: string;
-      /** Multiple recipients (store + affiliate[s]); >1 routes via separate charges & transfers. */
-      split?: SplitRecipient[];
-      /** Per-call platform fee override; falls back to the configured default. */
-      fee?: FeeOverride;
-      /** Charge total (minor units) for one-time payment fee computation. */
-      amount?: number;
-      metadata?: Record<string, string>;
-      sessionOverrides?: Record<string, unknown>;
-    },
+    opts: intentsImpl.CreateSetupIntentOptions,
   ) {
+    return intentsImpl.createSetupIntent(
+      this.stripe(),
+      this.component,
+      ctx,
+      opts,
+    );
+  }
+
+  // CHECKOUT METHODS
+
+  async createCheckoutSession(ctx: RunCtx, opts: CreateCheckoutSessionOptions) {
     const { fee, ...rest } = opts;
     return checkoutImpl.createCheckoutSession(
       this.stripe(),

package/src/react/hooks/useConfirmPayment.test.tsx

@@ -0,0 +1,47 @@
+// @vitest-environment jsdom
+import { renderHook } from "@testing-library/react";
+import { expect, it, vi } from "vitest";
+const f = vi.hoisted(() => ({ confirmSetup: vi.fn(), submit: vi.fn() }));
+vi.mock("@stripe/react-stripe-js", () => ({
+  useStripe: () => ({ confirmSetup: f.confirmSetup }),
+  useElements: () => ({ submit: f.submit }),
+}));
+import { useConfirmPayment } from "./useConfirmPayment.js";
+it("submits Elements and confirms explicit redisplay permission only on succeeded setup", async () => {
+  f.submit.mockResolvedValue({});
+  f.confirmSetup.mockResolvedValue({ setupIntent: { status: "succeeded" } });
+  const { result } = renderHook(useConfirmPayment);
+  expect(
+    await result.current.confirmSetup("https://app.test", "always"),
+  ).toEqual({ success: true });
+  expect(f.submit).toHaveBeenCalled();
+  expect(f.confirmSetup).toHaveBeenCalledWith({
+    elements: expect.anything(),
+    confirmParams: {
+      return_url: "https://app.test",
+      payment_method_data: { allow_redisplay: "always" },
+    },
+    redirect: "if_required",
+  });
+});
+it("does not turn processing or incomplete authentication into saved-card success", async () => {
+  f.submit.mockResolvedValue({});
+  f.confirmSetup.mockResolvedValue({
+    setupIntent: { status: "requires_action" },
+  });
+  const { result } = renderHook(useConfirmPayment);
+  expect(await result.current.confirmSetup()).toEqual({
+    success: false,
+    error: "Card setup is not complete.",
+  });
+});
+it("reports validation errors before confirmation", async () => {
+  f.confirmSetup.mockClear();
+  f.submit.mockResolvedValue({ error: { message: "Invalid card" } });
+  const { result } = renderHook(useConfirmPayment);
+  expect(await result.current.confirmSetup()).toEqual({
+    success: false,
+    error: "Invalid card",
+  });
+  expect(f.confirmSetup).not.toHaveBeenCalled();
+});

package/src/react/hooks/useConfirmPayment.ts

@@ -77,15 +77,27 @@ export function useConfirmPayment() {
    * @param returnUrl - URL to redirect to after 3D Secure. Defaults to current page.
    */
   const confirmSetup = useCallback(
-    async (returnUrl?: string): Promise<StripeConfirmResult> => {
+    async (
+      returnUrl?: string,
+      allowRedisplay?: "always" | "limited" | "unspecified",
+    ): Promise<StripeConfirmResult> => {
       if (!stripe || !elements) {
         return { success: false, error: "Stripe not initialized" };
       }
 
-      const { error } = await stripe.confirmSetup({
+      const validation = await elements.submit();
+      if (validation.error)
+        return {
+          success: false,
+          error: validation.error.message ?? "Check your card details.",
+        };
+      const { error, setupIntent } = await stripe.confirmSetup({
         elements,
         confirmParams: {
           return_url: returnUrl ?? window.location.href,
+          ...(allowRedisplay
+            ? { payment_method_data: { allow_redisplay: allowRedisplay } }
+            : {}),
         },
         redirect: "if_required",
       });
@@ -96,6 +108,8 @@ export function useConfirmPayment() {
           error: error.message ?? "Failed to confirm setup",
         };
       }
+      if (setupIntent?.status !== "succeeded")
+        return { success: false, error: "Card setup is not complete." };
       return { success: true };
     },
     [stripe, elements],

package/src/react/index.ts

@@ -290,3 +290,6 @@ export {
   formatChargeAmount,
   type ChargeCurrencyMetadata,
 } from "../client/charge-currency.js";
+
+export { SaveCard } from "./workflows/SaveCard.js";
+export type { SaveCardProps, SaveCardFormState } from "./workflows/SaveCard.js";