@waffo/pancake-nextjs 0.1.9 → 0.2.0

package/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to `@waffo/pancake-nextjs` will be documented in this file.
 
 Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), versioning follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.0] - 2026-07-14
+
+### Changed
+
+- **Public API renamed from "buyer" to "customer"** — the merchant's end consumer is called a customer across the SDK (matching the session-token JWT role). New primary names:
+  - Hooks: `useBuyer` → `useCustomer` · `useBuyerOrders` → `useCustomerOrders` · `useBuyerPayments` → `useCustomerPayments` · `useBuyerRefundTickets` → `useCustomerRefundTickets`
+  - Server action factories (`@waffo/pancake-nextjs/server`): `createBuyerTokenAction` → `createCustomerTokenAction` · `createBuyerSessionAction` → `createCustomerSessionAction`
+  - Types: `BuyerConfig` → `CustomerConfig` · `BuyerActionState` → `CustomerActionState` · `UseBuyerReturn` → `UseCustomerReturn` · `BuyerOnetimeOrder` → `CustomerOnetimeOrder` · `BuyerSubscriptionOrder` → `CustomerSubscriptionOrder` · `BuyerPayment` → `CustomerPayment` · `BuyerRefundTicket` → `CustomerRefundTicket` · `BuyerTokenAction` → `CustomerTokenAction` · `BuyerSessionAction` → `CustomerSessionAction` · `BuyerSessionActionType` → `CustomerSessionActionType`
+  - `<WaffoPancakeProvider>`: the config prop is now `customer` (the `buyer` prop is still accepted; `customer` wins when both are set)
+- **Wire contract unchanged** — request/payload field names stay as-is: `buyerIdentity` (checkout params, `issueSessionToken` params), `buyerEmail` (webhook event data, GraphQL fields), HTTP paths, and header names. No server-side changes required.
+
+### Deprecated
+
+- All previous "buyer" names remain exported as working aliases of the new "customer" names (marked `@deprecated`) and will be removed in the next release: `useBuyer`, `useBuyerOrders`, `useBuyerPayments`, `useBuyerRefundTickets`, `createBuyerTokenAction`, `createBuyerSessionAction`, the `Buyer*` types listed above, and the `buyer` prop on `<WaffoPancakeProvider>`.
+
 ## [0.1.9] - 2026-06-05
 
 ### Changed

package/README.md

@@ -5,7 +5,7 @@ Next.js SDK for the [Waffo Pancake](https://waffo.ai) Merchant of Record (MoR) p
 - Three checkout modes: link (instant redirect), anonymous (API), authenticated (API + token)
 - Popup blocker avoidance — synchronous `window.open` in click handler
 - Webhook route handler with automatic signature verification and event dispatch
-- Buyer self-service hooks with automatic token lifecycle management
+- Customer self-service hooks with automatic token lifecycle management
 - Server action architecture — private keys never leave the server
 
 ## Installation
@@ -16,7 +16,7 @@ npm install @waffo/pancake-nextjs
 
 ## Quick Start
 
-> Most merchants create stores and products in the [Dashboard](https://pancake.waffo.ai/dashboard). This SDK is primarily used for **embedding checkout, webhooks, and buyer self-service** into your Next.js app.
+> Most merchants create stores and products in the [Dashboard](https://pancake.waffo.ai/dashboard). This SDK is primarily used for **embedding checkout, webhooks, and customer self-service** into your Next.js app.
 
 The fastest integration — a link checkout button, no API keys needed:
 
@@ -29,15 +29,15 @@ import { CheckoutButton } from "@waffo/pancake-nextjs";
 </CheckoutButton>;
 ```
 
-For API-level control (dynamic pricing, buyer identity, trial overrides), set up server actions first:
+For API-level control (dynamic pricing, customer identity, trial overrides), set up server actions first:
 
 ```ts
 // app/lib/waffo.ts — define once, import everywhere
 "use server";
 import {
   createCheckoutAction,
-  createBuyerTokenAction,
-  createBuyerSessionAction,
+  createCustomerTokenAction,
+  createCustomerSessionAction,
   createMerchantQueryAction,
 } from "@waffo/pancake-nextjs/server";
 
@@ -48,8 +48,8 @@ const config = {
 };
 
 export const checkout = createCheckoutAction(config);
-export const issueBuyerToken = createBuyerTokenAction(config);
-export const buyerAction = createBuyerSessionAction(config);
+export const issueCustomerToken = createCustomerTokenAction(config);
+export const customerAction = createCustomerSessionAction(config);
 export const merchantQuery = createMerchantQueryAction(config);
 ```
 
@@ -59,13 +59,13 @@ Private keys are captured in server action closures — they never reach the bro
 
 Waffo supports three checkout modes based on how much control the merchant needs:
 
-| Mode              | `type`            | Needs Server Action? | Use Case                                                                                |
-| ----------------- | ----------------- | :------------------: | --------------------------------------------------------------------------------------- |
-| **Link**          | `"link"`          |          No          | Landing pages, email campaigns. Redirects to product page which auto-creates a session. |
-| **Anonymous**     | omit              |         Yes          | API-level control without buyer identity. Buyer fills in details on checkout page.      |
-| **Authenticated** | `"authenticated"` |         Yes          | Merchant provides buyer identity. Form pre-filled. Enables buyer self-service.          |
+| Mode              | `type`            | Needs Server Action? | Use Case                                                                                 |
+| ----------------- | ----------------- | :------------------: | ---------------------------------------------------------------------------------------- |
+| **Link**          | `"link"`          |          No          | Landing pages, email campaigns. Redirects to product page which auto-creates a session.  |
+| **Anonymous**     | omit              |         Yes          | API-level control without customer identity. Customer fills in details on checkout page. |
+| **Authenticated** | `"authenticated"` |         Yes          | Merchant provides customer identity. Form pre-filled. Enables customer self-service.     |
 
-> **We recommend authenticated checkout whenever possible.** It binds orders to a stable merchant-controlled identifier. In anonymous mode, the buyer self-reports their email — if they enter a different address, previous orders become unlinked and subscription trial periods can be exploited.
+> **We recommend authenticated checkout whenever possible.** It binds orders to a stable merchant-controlled identifier. In anonymous mode, the customer self-reports their email — if they enter a different address, previous orders become unlinked and subscription trial periods can be exploited.
 
 ### Link Checkout
 
@@ -85,7 +85,7 @@ import { CheckoutButton } from "@waffo/pancake-nextjs";
   storeSlug="my-store"
   productId="PROD_xxx"
   currency="USD"
-  email="buyer@example.com"
+  email="customer@example.com"
   successUrl="https://example.com/thank-you"
   country="US"
   test={false}
@@ -122,13 +122,13 @@ Pass an optional `orderMerchantExternalId` to attach your internal order referen
 
 ### Authenticated Checkout (Recommended)
 
-Creates a session **and** a token bound to the buyer you provide. `buyerIdentity` is for order attribution and trial tracking — it is not rendered on the checkout page. To pre-fill the email field on the checkout form, pass `buyerEmail` explicitly.
+Creates a session **and** a token bound to the customer you provide. `buyerIdentity` is for order attribution and trial tracking — it is not rendered on the checkout page. To pre-fill the email field on the checkout form, pass `buyerEmail` explicitly.
 
 ```tsx
 import { CheckoutButton } from "@waffo/pancake-nextjs";
 import { checkout } from "./lib/waffo";
 
-// Basic — buyer identity only (checkout page email field stays empty)
+// Basic — customer identity only (checkout page email field stays empty)
 <CheckoutButton type="authenticated" action={checkout} productId="PROD_xxx" currency="USD" buyerIdentity={user.id}>
   Upgrade to Pro
 </CheckoutButton>
@@ -191,12 +191,12 @@ const { checkout, isLoading, error } = useCheckout({
 
 Both `CheckoutButton` and `useCheckout` support two navigation modes via the `mode` prop:
 
-- `"redirect"` (default) — navigates the current page. Buyer returns via `successUrl`.
+- `"redirect"` (default) — navigates the current page. Customer returns via `successUrl`.
 - `"popup"` — opens a new tab. Link mode opens the URL directly; API modes show a loading page first, then redirect once the session is ready.
 
 ## Webhook Verification
 
-After a buyer completes payment, Waffo sends webhook events to your server. The `Webhook` factory creates a Next.js route handler that verifies signatures and dispatches events:
+After a customer completes payment, Waffo sends webhook events to your server. The `Webhook` factory creates a Next.js route handler that verifies signatures and dispatches events:
 
 ```ts
 // app/api/webhooks/waffo/route.ts
@@ -237,18 +237,20 @@ export const POST = Webhook({
 
 Returns `200` on success, `401` on invalid signature, `500` if a handler throws. Full event list: `onOrderCompleted`, `onSubscriptionActivated`, `onSubscriptionPaymentSucceeded`, `onSubscriptionCanceling`, `onSubscriptionUncanceled`, `onSubscriptionUpdated`, `onSubscriptionCanceled`, `onSubscriptionPastDue`, `onRefundSucceeded`, `onRefundFailed`.
 
-## Buyer Self-Service
+## Customer Self-Service
 
-Beyond checkout, you can let buyers manage their own orders and subscriptions. Wrap with `WaffoPancakeProvider` — it auto-issues tokens and refreshes them before expiry:
+Beyond checkout, you can let customers manage their own orders and subscriptions. Wrap with `WaffoPancakeProvider` — it auto-issues tokens and refreshes them before expiry:
 
 ```tsx
-import { WaffoPancakeProvider, useBuyer, useBuyerOrders, useBuyerPayments, useBuyerRefundTickets } from "@waffo/pancake-nextjs";
-import { issueBuyerToken, buyerAction } from "./lib/waffo";
+import { WaffoPancakeProvider, useCustomer, useCustomerOrders, useCustomerPayments, useCustomerRefundTickets } from "@waffo/pancake-nextjs";
+import { issueCustomerToken, customerAction } from "./lib/waffo";
 
 // Wrap once — provider manages token lifecycle
 export default function AccountLayout({ user }: { user: { email: string } }) {
   return (
-    <WaffoPancakeProvider buyer={{ identity: user.email, storeId: "STO_xxx", issueToken: issueBuyerToken, sessionAction: buyerAction }}>
+    <WaffoPancakeProvider
+      customer={{ identity: user.email, storeId: "STO_xxx", issueToken: issueCustomerToken, sessionAction: customerAction }}
+    >
       <AccountPage />
     </WaffoPancakeProvider>
   );
@@ -256,10 +258,10 @@ export default function AccountLayout({ user }: { user: { email: string } }) {
 
 // All hooks work without passing token or client
 function AccountPage() {
-  const { data: orders, isLoading, refetch } = useBuyerOrders();
-  const { data: payments } = useBuyerPayments();
-  const { data: tickets } = useBuyerRefundTickets();
-  const buyer = useBuyer();
+  const { data: orders, isLoading, refetch } = useCustomerOrders();
+  const { data: payments } = useCustomerPayments();
+  const { data: tickets } = useCustomerRefundTickets();
+  const customer = useCustomer();
 
   if (isLoading) return <p>Loading...</p>;
 
@@ -271,9 +273,9 @@ function AccountPage() {
           <p>
             {sub.product?.name} — {sub.status}
           </p>
-          {sub.status === "active" && <button onClick={() => buyer.cancelSubscription.execute({ orderId: sub.id })}>Cancel</button>}
+          {sub.status === "active" && <button onClick={() => customer.cancelSubscription.execute({ orderId: sub.id })}>Cancel</button>}
           {sub.status === "canceling" && (
-            <button onClick={() => buyer.reactivateSubscription.execute({ orderId: sub.id })}>Undo Cancellation</button>
+            <button onClick={() => customer.reactivateSubscription.execute({ orderId: sub.id })}>Undo Cancellation</button>
           )}
         </div>
       ))}
@@ -287,7 +289,7 @@ function AccountPage() {
 
       <button
         onClick={() =>
-          buyer.createRefundTicket.execute({
+          customer.createRefundTicket.execute({
             paymentId: "PAY_xxx",
             reason: "Product not as described",
             requestedAmount: { amount: "29.00", currency: "USD" },
@@ -302,14 +304,14 @@ function AccountPage() {
 }
 ```
 
-### Buyer Hooks
+### Customer Hooks
 
-| Hook                      | Returns                                                                                                                     |     Auto-fetches?      |
-| ------------------------- | --------------------------------------------------------------------------------------------------------------------------- | :--------------------: |
-| `useBuyer()`              | `cancelSubscription`, `cancelOnetimeOrder`, `reactivateSubscription`, `createRefundTicket`, `resubmitRefundTicket`, `query` | No — call `.execute()` |
-| `useBuyerOrders()`        | `{ onetimeOrders, subscriptionOrders }` with product, payments, billing cycle                                               |          Yes           |
-| `useBuyerPayments()`      | Payment records — amount, status, failure reason                                                                            |          Yes           |
-| `useBuyerRefundTickets()` | Refund tickets — status, reason, amount                                                                                     |          Yes           |
+| Hook                         | Returns                                                                                                                     |     Auto-fetches?      |
+| ---------------------------- | --------------------------------------------------------------------------------------------------------------------------- | :--------------------: |
+| `useCustomer()`              | `cancelSubscription`, `cancelOnetimeOrder`, `reactivateSubscription`, `createRefundTicket`, `resubmitRefundTicket`, `query` | No — call `.execute()` |
+| `useCustomerOrders()`        | `{ onetimeOrders, subscriptionOrders }` with product, payments, billing cycle                                               |          Yes           |
+| `useCustomerPayments()`      | Payment records — amount, status, failure reason                                                                            |          Yes           |
+| `useCustomerRefundTickets()` | Refund tickets — status, reason, amount                                                                                     |          Yes           |
 
 Action hooks return `{ execute, isLoading, error, data }`. Data hooks return `{ data, isLoading, error, refetch }`.
 
@@ -317,10 +319,10 @@ Action hooks return `{ execute, isLoading, error, data }`. Data hooks return `{
 
 Attach your own internal references to a checkout or a refund ticket so cross-system reconciliation does not require Waffo IDs. Two flat keys, both optional (max 128 chars):
 
-| Field                            | Attach via                       | Inherited by                                  |
-| -------------------------------- | -------------------------------- | --------------------------------------------- |
-| `orderMerchantExternalId`        | `CheckoutButton` / `useCheckout` | `Order`, `Payment` (incl. renewals), `Refund` |
-| `refundTicketMerchantExternalId` | `useBuyer().createRefundTicket`  | `RefundTicket`, `Refund`                      |
+| Field                            | Attach via                         | Inherited by                                  |
+| -------------------------------- | ---------------------------------- | --------------------------------------------- |
+| `orderMerchantExternalId`        | `CheckoutButton` / `useCheckout`   | `Order`, `Payment` (incl. renewals), `Refund` |
+| `refundTicketMerchantExternalId` | `useCustomer().createRefundTicket` | `RefundTicket`, `Refund`                      |
 
 The same field name appears at every layer: prop / hook param, webhook payload (`event.data.orderMerchantExternalId` / `event.data.refundTicketMerchantExternalId`), and GraphQL types. A `refund.*` webhook event carries **both** keys (order key inherited from the originating order).
 
@@ -333,8 +335,8 @@ The same field name appears at every layer: prop / hook param, webhook payload (
 
 // 2. Attach at refund-ticket creation — value is bound to the ticket and the
 //    refund record once the PSP confirms.
-const buyer = useBuyer();
-await buyer.createRefundTicket.execute({
+const customer = useCustomer();
+await customer.createRefundTicket.execute({
   paymentId: "PAY_xxx",
   reason: "Product not as described",
   requestedAmount: { amount: "29.00", currency: "USD" },
@@ -351,8 +353,8 @@ export const POST = Webhook({
   },
 });
 
-// 4. Query by reference via the buyer's GraphQL surface — same field name on every type.
-const result = await buyer.query({
+// 4. Query by reference via the customer's GraphQL surface — same field name on every type.
+const result = await customer.query({
   query: `query ($ref: String!) {
     onetimeOrders(filter: { orderMerchantExternalId: { eq: $ref } }) {
       id status orderMerchantExternalId
@@ -386,12 +388,12 @@ All merchant hooks return `{ data, isLoading, error, refetch }`.
 
 ## Server Actions
 
-| Factory                             | Returns               | Description                                           |
-| ----------------------------------- | --------------------- | ----------------------------------------------------- |
-| `createCheckoutAction(config)`      | `CheckoutAction`      | Checkout session creation (anonymous + authenticated) |
-| `createBuyerTokenAction(config)`    | `BuyerTokenAction`    | Buyer session token issuance                          |
-| `createBuyerSessionAction(config)`  | `BuyerSessionAction`  | Buyer self-service operations                         |
-| `createMerchantQueryAction(config)` | `MerchantQueryAction` | Merchant GraphQL queries                              |
+| Factory                               | Returns                 | Description                                           |
+| ------------------------------------- | ----------------------- | ----------------------------------------------------- |
+| `createCheckoutAction(config)`        | `CheckoutAction`        | Checkout session creation (anonymous + authenticated) |
+| `createCustomerTokenAction(config)`   | `CustomerTokenAction`   | Customer session token issuance                       |
+| `createCustomerSessionAction(config)` | `CustomerSessionAction` | Customer self-service operations                      |
+| `createMerchantQueryAction(config)`   | `MerchantQueryAction`   | Merchant GraphQL queries                              |
 
 Import from `@waffo/pancake-nextjs/server`. Config requires `merchantId` and `privateKey`.
 
@@ -407,7 +409,7 @@ Import from `@waffo/pancake-nextjs/server`. Config requires `merchantId` and `pr
 
 ### Types
 
-Key types: `PriceInfo`, `BillingDetail`, `WebhookEvent`, `CheckoutAction`, `BuyerTokenAction`, `BuyerSessionAction`, `MerchantQueryAction`, `BuyerConfig`, `CheckoutButtonProps`, `CheckoutMode`, `UseCheckoutReturn`, `UseBuyerReturn`, `BuyerActionState<T>`, `QueryState<T>`, `SalesOverview`, `SubscriptionOverview`, `WebhookConfig`.
+Key types: `PriceInfo`, `BillingDetail`, `WebhookEvent`, `CheckoutAction`, `CustomerTokenAction`, `CustomerSessionAction`, `MerchantQueryAction`, `CustomerConfig`, `CheckoutButtonProps`, `CheckoutMode`, `UseCheckoutReturn`, `UseCustomerReturn`, `CustomerActionState<T>`, `QueryState<T>`, `SalesOverview`, `SubscriptionOverview`, `WebhookConfig`.
 
 ## Development
 
@@ -429,8 +431,8 @@ src/
 ├── provider.tsx           # <WaffoPancakeProvider> — token lifecycle
 ├── checkout-button.tsx    # <CheckoutButton> component
 ├── use-checkout.ts        # useCheckout() — link + anonymous + authenticated
-├── use-buyer.ts           # useBuyer() — buyer actions
-├── use-buyer-data.ts      # useBuyerOrders / useBuyerPayments / useBuyerRefundTickets
+├── use-customer.ts        # useCustomer() — customer actions
+├── use-customer-data.ts   # useCustomerOrders / useCustomerPayments / useCustomerRefundTickets
 ├── use-merchant-data.ts   # useMerchantOrders / useMerchantSales / useMerchantSubscriptions
 ├── use-query.ts           # Shared useQuery helper
 ├── webhook.ts             # Webhook() route handler factory

package/dist/index.cjs

@@ -32,6 +32,10 @@ __export(src_exports, {
   useBuyerPayments: () => useBuyerPayments,
   useBuyerRefundTickets: () => useBuyerRefundTickets,
   useCheckout: () => useCheckout,
+  useCustomer: () => useCustomer,
+  useCustomerOrders: () => useCustomerOrders,
+  useCustomerPayments: () => useCustomerPayments,
+  useCustomerRefundTickets: () => useCustomerRefundTickets,
   useMerchantOrders: () => useMerchantOrders,
   useMerchantSales: () => useMerchantSales,
   useMerchantSubscriptions: () => useMerchantSubscriptions
@@ -43,23 +47,25 @@ var import_react = require("react");
 var import_jsx_runtime = require("react/jsx-runtime");
 var PancakeContext = (0, import_react.createContext)(null);
 var REFRESH_BUFFER_MS = 3e4;
-function WaffoPancakeProvider({ buyer, children }) {
+function WaffoPancakeProvider({ customer, buyer, children }) {
+  const config = customer ?? buyer;
+  if (!config) throw new Error("WaffoPancakeProvider: the `customer` prop is required");
   const tokenRef = (0, import_react.useRef)(null);
   const refreshPromiseRef = (0, import_react.useRef)(null);
-  const [isBuyerReady, setIsBuyerReady] = (0, import_react.useState)(false);
+  const [isCustomerReady, setIsCustomerReady] = (0, import_react.useState)(false);
   const refreshToken = (0, import_react.useCallback)(async () => {
-    const result = await buyer.issueToken({
-      buyerIdentity: buyer.identity,
-      storeId: buyer.storeId,
-      productId: buyer.productId
+    const result = await config.issueToken({
+      buyerIdentity: config.identity,
+      storeId: config.storeId,
+      productId: config.productId
     });
     tokenRef.current = {
       token: result.token,
       expiresAt: new Date(result.expiresAt).getTime()
     };
     return result.token;
-  }, [buyer]);
-  const getBuyerToken = (0, import_react.useCallback)(async () => {
+  }, [config]);
+  const getCustomerToken = (0, import_react.useCallback)(async () => {
     const current = tokenRef.current;
     if (current && Date.now() < current.expiresAt - REFRESH_BUFFER_MS) {
       return current.token;
@@ -72,16 +78,16 @@ function WaffoPancakeProvider({ buyer, children }) {
     return refreshPromiseRef.current;
   }, [refreshToken]);
   (0, import_react.useEffect)(() => {
-    refreshToken().then(() => setIsBuyerReady(true)).catch(() => setIsBuyerReady(true));
+    refreshToken().then(() => setIsCustomerReady(true)).catch(() => setIsCustomerReady(true));
   }, [refreshToken]);
   const value = (0, import_react.useMemo)(
     () => ({
-      getBuyerToken,
-      buyerSessionAction: buyer.sessionAction,
-      hasBuyer: true,
-      isBuyerReady
+      getCustomerToken,
+      customerSessionAction: config.sessionAction,
+      hasCustomer: true,
+      isCustomerReady
     }),
-    [getBuyerToken, buyer.sessionAction, isBuyerReady]
+    [getCustomerToken, config.sessionAction, isCustomerReady]
   );
   return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(PancakeContext.Provider, { value, children });
 }
@@ -165,9 +171,9 @@ function CheckoutButton(props) {
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("button", { type: "button", onClick: checkout, disabled: disabled || isLoading, className, style, children: isLoading ? loadingChildren ?? children : children });
 }
 
-// src/use-buyer.ts
+// src/use-customer.ts
 var import_react3 = require("react");
-function useBuyerAction(actionFn) {
+function useCustomerAction(actionFn) {
   const [isLoading, setIsLoading] = (0, import_react3.useState)(false);
   const [error, setError] = (0, import_react3.useState)(null);
   const [data, setData] = (0, import_react3.useState)(null);
@@ -189,34 +195,34 @@ function useBuyerAction(actionFn) {
   );
   return { execute, isLoading, error, data };
 }
-function useBuyer() {
+function useCustomer() {
   const ctx = (0, import_react3.useContext)(PancakeContext);
-  if (!ctx) throw new Error("useBuyer: must be used within <WaffoPancakeProvider>");
-  const { getBuyerToken, buyerSessionAction } = ctx;
+  if (!ctx) throw new Error("useCustomer: must be used within <WaffoPancakeProvider>");
+  const { getCustomerToken, customerSessionAction } = ctx;
   const callAction = (0, import_react3.useCallback)(
     async (actionType, params) => {
-      const token = await getBuyerToken();
-      return buyerSessionAction(token, actionType, params);
+      const token = await getCustomerToken();
+      return customerSessionAction(token, actionType, params);
     },
-    [getBuyerToken, buyerSessionAction]
+    [getCustomerToken, customerSessionAction]
   );
-  const cancelSubscription = useBuyerAction(
+  const cancelSubscription = useCustomerAction(
     (0, import_react3.useCallback)((params) => callAction("cancelSubscription", params), [callAction])
   );
-  const cancelOnetimeOrder = useBuyerAction(
+  const cancelOnetimeOrder = useCustomerAction(
     (0, import_react3.useCallback)((params) => callAction("cancelOnetimeOrder", params), [callAction])
   );
-  const reactivateSubscription = useBuyerAction(
+  const reactivateSubscription = useCustomerAction(
     (0, import_react3.useCallback)((params) => callAction("reactivateSubscription", params), [callAction])
   );
-  const createRefundTicket = useBuyerAction(
+  const createRefundTicket = useCustomerAction(
     (0, import_react3.useCallback)((params) => callAction("createRefundTicket", params), [callAction])
   );
   const createRefundTicketMapped = (0, import_react3.useMemo)(
     () => ({ ...createRefundTicket, data: createRefundTicket.data?.ticket ?? null }),
     [createRefundTicket]
   );
-  const resubmitRefundTicket = useBuyerAction(
+  const resubmitRefundTicket = useCustomerAction(
     (0, import_react3.useCallback)((params) => callAction("resubmitRefundTicket", params), [callAction])
   );
   const resubmitRefundTicketMapped = (0, import_react3.useMemo)(
@@ -225,10 +231,10 @@ function useBuyer() {
   );
   const query = (0, import_react3.useCallback)(
     async (params) => {
-      const token = await getBuyerToken();
-      return buyerSessionAction(token, "query", params);
+      const token = await getCustomerToken();
+      return customerSessionAction(token, "query", params);
     },
-    [getBuyerToken, buyerSessionAction]
+    [getCustomerToken, customerSessionAction]
   );
   return {
     cancelSubscription,
@@ -239,8 +245,9 @@ function useBuyer() {
     query
   };
 }
+var useBuyer = useCustomer;
 
-// src/use-buyer-data.ts
+// src/use-customer-data.ts
 var import_react5 = require("react");
 
 // src/use-query.ts
@@ -261,8 +268,8 @@ function useQuery(queryFn, ready) {
   return { data, isLoading, error, refetch: fetch };
 }
 
-// src/use-buyer-data.ts
-var BUYER_ORDERS_QUERY = `query {
+// src/use-customer-data.ts
+var CUSTOMER_ORDERS_QUERY = `query {
   onetimeOrders(limit: 50) {
     id status currency buyerEmail createdAt
     product { id name }
@@ -274,12 +281,12 @@ var BUYER_ORDERS_QUERY = `query {
     payments { id status snapshotDisplayAmount snapshotDisplayCurrency createdAt }
   }
 }`;
-var BUYER_PAYMENTS_QUERY = `query {
+var CUSTOMER_PAYMENTS_QUERY = `query {
   payments(limit: 50) {
     id orderId status snapshotDisplayAmount snapshotDisplayCurrency failureReason createdAt
   }
 }`;
-var BUYER_REFUND_TICKETS_QUERY = `query {
+var CUSTOMER_REFUND_TICKETS_QUERY = `query {
   refundTickets(limit: 50) {
     id status versionNumber
     versionData {
@@ -289,28 +296,31 @@ var BUYER_REFUND_TICKETS_QUERY = `query {
     createdAt
   }
 }`;
-function useBuyerQuery(query) {
+function useCustomerQuery(query) {
   const ctx = (0, import_react5.useContext)(PancakeContext);
-  if (!ctx) throw new Error("Buyer data hook: must be used within <WaffoPancakeProvider>");
-  const { getBuyerToken, buyerSessionAction, isBuyerReady } = ctx;
+  if (!ctx) throw new Error("Customer data hook: must be used within <WaffoPancakeProvider>");
+  const { getCustomerToken, customerSessionAction, isCustomerReady } = ctx;
   const queryFn = (0, import_react5.useCallback)(async () => {
-    const token = await getBuyerToken();
-    const result = await buyerSessionAction(token, "query", { query });
+    const token = await getCustomerToken();
+    const result = await customerSessionAction(token, "query", { query });
     return result.data;
-  }, [getBuyerToken, buyerSessionAction, query]);
-  return useQuery(queryFn, isBuyerReady);
+  }, [getCustomerToken, customerSessionAction, query]);
+  return useQuery(queryFn, isCustomerReady);
 }
-function useBuyerOrders() {
-  return useBuyerQuery(BUYER_ORDERS_QUERY);
+function useCustomerOrders() {
+  return useCustomerQuery(CUSTOMER_ORDERS_QUERY);
 }
-function useBuyerPayments() {
-  const result = useBuyerQuery(BUYER_PAYMENTS_QUERY);
+function useCustomerPayments() {
+  const result = useCustomerQuery(CUSTOMER_PAYMENTS_QUERY);
   return { ...result, data: result.data?.payments ?? null };
 }
-function useBuyerRefundTickets() {
-  const result = useBuyerQuery(BUYER_REFUND_TICKETS_QUERY);
+function useCustomerRefundTickets() {
+  const result = useCustomerQuery(CUSTOMER_REFUND_TICKETS_QUERY);
   return { ...result, data: result.data?.refundTickets ?? null };
 }
+var useBuyerOrders = useCustomerOrders;
+var useBuyerPayments = useCustomerPayments;
+var useBuyerRefundTickets = useCustomerRefundTickets;
 
 // src/use-merchant-data.ts
 var import_react6 = require("react");
@@ -464,6 +474,10 @@ var import_pancake_ts2 = require("@waffo/pancake-ts");
   useBuyerPayments,
   useBuyerRefundTickets,
   useCheckout,
+  useCustomer,
+  useCustomerOrders,
+  useCustomerPayments,
+  useCustomerRefundTickets,
   useMerchantOrders,
   useMerchantSales,
   useMerchantSubscriptions