@reactionary/ucp 0.10.35 → 0.10.37

package/index.js

@@ -1,2 +1,13 @@
 export * from "./lib/reactionary-ucp-server.js";
 export * from "./lib/reactionary-ucp-identity.js";
+export * from "./lib/reactionary-ucp-localization.js";
+import { toPublicSigningJwk } from "./lib/reactionary-ucp-signing.js";
+import {
+  DEFAULT_UCP_PAYMENT_AUTHORIZATION_WAIT,
+  DEFAULT_UCP_PLACEHOLDER_EMAIL
+} from "./lib/reactionary-ucp-checkout-session.js";
+export {
+  DEFAULT_UCP_PAYMENT_AUTHORIZATION_WAIT,
+  DEFAULT_UCP_PLACEHOLDER_EMAIL,
+  toPublicSigningJwk
+};

package/lib/reactionary-ucp-checkout-session.js

@@ -0,0 +1,603 @@
+import * as z from "zod";
+import {
+  createUCPError,
+  createUcpCheckoutSuccessMetadata,
+  createUcpErrorMessage,
+  createUcpWarning,
+  getMoneyCurrency,
+  getMoneyValue,
+  getSelectedPaymentInstrument,
+  toOrderPermalinkUrl,
+  toReactionaryAddress,
+  toUcpCartLineItem,
+  toUcpCostTotals
+} from "./reactionary-ucp-mapping.js";
+import { applyDiscountCodes, getRequestedDiscountCodes, toUcpDiscounts } from "./reactionary-ucp-discounts.js";
+import {
+  UCPBuyerConsentSchema
+} from "./reactionary-ucp-session-store.js";
+const DEFAULT_UCP_PLACEHOLDER_EMAIL = "pending@checkout.invalid";
+const DEFAULT_UCP_PAYMENT_AUTHORIZATION_WAIT = {
+  timeoutMs: 1e4,
+  intervalMs: 1e3
+};
+async function pollUntil(read, done, wait) {
+  const deadline = Date.now() + wait.timeoutMs;
+  let value = await read();
+  while (!done(value) && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, Math.min(wait.intervalMs, Math.max(deadline - Date.now(), 0))));
+    value = await read();
+  }
+  return value;
+}
+const PostalAddressRequestSchema = z.looseObject({
+  id: z.string().optional(),
+  first_name: z.string().optional(),
+  last_name: z.string().optional(),
+  street_address: z.string().optional(),
+  extended_address: z.string().optional(),
+  address_locality: z.string().optional(),
+  address_region: z.string().optional(),
+  address_country: z.string().optional(),
+  postal_code: z.string().optional(),
+  phone_number: z.string().optional()
+});
+const FulfillmentRequestSchema = z.looseObject({
+  methods: z.array(z.looseObject({
+    selected_destination_id: z.string().nullish(),
+    destinations: z.array(PostalAddressRequestSchema).optional(),
+    groups: z.array(z.looseObject({
+      selected_option_id: z.string().nullish()
+    })).optional()
+  })).optional()
+});
+async function createCheckoutSession(context, body) {
+  if (!context.client.checkout || !context.client.cart) {
+    return createUCPError("not_available", "Checkout capability is not available.");
+  }
+  let cart;
+  if (body.cart_id) {
+    cart = await getCart(context, body.cart_id);
+  } else if (body.line_items?.length) {
+    cart = await context.createCart(body.line_items);
+  }
+  if (!cart) {
+    return createUCPError("invalid_request", "A checkout session requires cart_id or line_items.");
+  }
+  if (!("identifier" in cart)) {
+    return cart;
+  }
+  const discountMessages = await applyRequestedDiscountCodes(context, cart, body);
+  const state = {
+    id: `checkout_${crypto.randomUUID()}`,
+    cartId: cart.identifier.key,
+    status: "open"
+  };
+  mergeRequestIntoState(state, body);
+  await context.store.putCheckoutSession(state);
+  await context.store.bindResource(state.id, context.sessionId);
+  return (await buildOpenView(context, state, discountMessages)).response;
+}
+async function getCheckoutSession(context, checkoutSessionId) {
+  const state = await context.store.getCheckoutSession(checkoutSessionId);
+  if (!state) {
+    return checkoutSessionNotFound(checkoutSessionId);
+  }
+  return state.finalCheckoutId ? buildFinalView(context, state) : (await buildOpenView(context, state)).response;
+}
+async function updateCheckoutSession(context, checkoutSessionId, body) {
+  const state = await context.store.getCheckoutSession(checkoutSessionId);
+  if (!state) {
+    return checkoutSessionNotFound(checkoutSessionId);
+  }
+  if (state.finalCheckoutId || state.status === "canceled") {
+    return createUCPError("checkout_not_modifiable", "The checkout session can no longer be modified.");
+  }
+  if (body.line_items?.length) {
+    const failure = await context.reconcileCart(state.cartId, body.line_items);
+    if (failure) {
+      return failure;
+    }
+  }
+  const cart = await getCart(context, state.cartId);
+  const discountMessages = "identifier" in cart ? await applyRequestedDiscountCodes(context, cart, body) : [];
+  mergeRequestIntoState(state, body);
+  await context.store.putCheckoutSession(state);
+  return (await buildOpenView(context, state, discountMessages)).response;
+}
+async function applyRequestedDiscountCodes(context, cart, body) {
+  const codes = getRequestedDiscountCodes(body);
+  return codes ? (await applyDiscountCodes(context.client, cart, codes)).messages : [];
+}
+async function cancelCheckoutSession(context, checkoutSessionId) {
+  const state = await context.store.getCheckoutSession(checkoutSessionId);
+  if (!state) {
+    return checkoutSessionNotFound(checkoutSessionId);
+  }
+  if (state.finalCheckoutId) {
+    return createUCPError("checkout_not_modifiable", "A completed checkout session cannot be canceled.");
+  }
+  state.status = "canceled";
+  await context.store.putCheckoutSession(state);
+  return (await buildOpenView(context, state)).response;
+}
+async function completeCheckoutSession(context, checkoutSessionId, body) {
+  const state = await context.store.getCheckoutSession(checkoutSessionId);
+  if (!state) {
+    return checkoutSessionNotFound(checkoutSessionId);
+  }
+  if (state.status === "canceled" || state.status === "completed") {
+    return createUCPError("checkout_not_modifiable", `A ${state.status} checkout session cannot be completed.`);
+  }
+  const messages = [];
+  if (!state.finalCheckoutId) {
+    mergeRequestIntoState(state, body);
+    const { response, ready } = await buildOpenView(context, state);
+    if (!ready) {
+      return response;
+    }
+    const payment = resolvePayment(context, state, getSelectedPaymentInstrument(body)?.credential);
+    if ("failure" in payment) {
+      return addMessages(response, [payment.failure], "incomplete");
+    }
+    const placement = await placeFinalCheckout(context, state, payment);
+    if (placement.failure) {
+      return addMessages(response, [placement.failure], "incomplete");
+    }
+    messages.push(...placement.messages);
+  }
+  return finalizeIfReady(context, state, messages);
+}
+function resolvePayment(context, state, credential) {
+  const handlerId = state.instrument?.handler_id ?? "";
+  const testHandler = context.testPaymentHandlers?.find((handler) => handler.id === handlerId);
+  const resolved = testHandler ? { handlerId: testHandler.delegateHandlerId, credential: testHandler.resolveCredential(credential) } : { handlerId, credential };
+  if (testHandler && resolved.credential === void 0) {
+    return { failure: createUcpErrorMessage("payment_failed", "The payment credential was declined.", "$.payment.instruments") };
+  }
+  if (!context.acceptRawCardCredentials && isRawCardCredential(resolved.credential)) {
+    return {
+      failure: createUcpErrorMessage(
+        "payment_failed",
+        "Raw card credentials are not accepted; submit a delegated token from the payment handler instead.",
+        "$.payment.instruments"
+      )
+    };
+  }
+  return resolved;
+}
+function isRawCardCredential(credential) {
+  if (typeof credential !== "object" || credential === null) {
+    return false;
+  }
+  const type = Reflect.get(credential, "type");
+  return type === "pan" || type === "card" || ["number", "cvc", "card_number"].some((field) => Reflect.get(credential, field) !== void 0);
+}
+function isAcceptedPaymentHandler(context, handlerId) {
+  const advertised = Object.values(context.paymentHandlers).flat();
+  return advertised.length === 0 || advertised.some((handler) => handler.id === handlerId) || Boolean(context.testPaymentHandlers?.some((handler) => handler.id === handlerId));
+}
+function mergeRequestIntoState(state, body) {
+  if (body.buyer) {
+    const consent = UCPBuyerConsentSchema.safeParse(Reflect.get(body.buyer, "consent"));
+    state.buyer = {
+      ...state.buyer,
+      ...body.buyer.first_name ? { first_name: body.buyer.first_name } : {},
+      ...body.buyer.last_name ? { last_name: body.buyer.last_name } : {},
+      ...body.buyer.email ? { email: body.buyer.email } : {},
+      ...body.buyer.phone_number ? { phone_number: body.buyer.phone_number } : {},
+      ...consent.success ? { consent: consent.data } : {}
+    };
+  }
+  const instrument = getSelectedPaymentInstrument(body);
+  if (instrument?.billing_address) {
+    state.billingAddress = instrument.billing_address;
+  }
+  if (instrument) {
+    state.instrument = {
+      id: instrument.id,
+      handler_id: instrument.handler_id,
+      type: instrument.type
+    };
+  }
+  const fulfillment = FulfillmentRequestSchema.safeParse(body["fulfillment"]);
+  const method = fulfillment.success ? fulfillment.data.methods?.[0] : void 0;
+  if (method) {
+    const destinations = method.destinations ?? [];
+    const destination = destinations.find((candidate) => candidate.id === method.selected_destination_id) ?? (destinations.length === 1 ? destinations[0] : void 0);
+    if (destination) {
+      state.destination = destination;
+    }
+    const selectedOptionId = method.groups?.[0]?.selected_option_id;
+    if (selectedOptionId) {
+      state.selectedOptionId = selectedOptionId;
+    } else if (selectedOptionId === null) {
+      delete state.selectedOptionId;
+    }
+  }
+}
+async function resolveBuyerEmail(context, state) {
+  const email = state.buyer?.email ?? await context.getIdentityEmail();
+  if (!email && context.anonymousOrderEmail) {
+    console.warn(
+      `UCP: checkout session ${state.id} has no buyer email; using the configured anonymousOrderEmail \u2014 an order placed this way cannot send the buyer a receipt.`
+    );
+    return context.anonymousOrderEmail;
+  }
+  return email;
+}
+async function priceWithTransientCheckout(context, cart, state) {
+  const address = state.destination ?? state.billingAddress;
+  const checkoutCapability = context.client.checkout;
+  if (!address || !checkoutCapability) {
+    return { options: [] };
+  }
+  const initiated = await checkoutCapability.initiateCheckoutForCart({
+    cart,
+    billingAddress: toReactionaryAddress(state.billingAddress ?? address),
+    notificationEmail: await resolveBuyerEmail(context, state) ?? context.placeholderEmail,
+    ...state.buyer?.phone_number ? { notificationPhone: state.buyer.phone_number } : {}
+  });
+  if (!initiated.success) {
+    return {
+      options: [],
+      failure: createUcpErrorMessage("checkout_pricing_failed", "Unable to price the checkout for the given address.")
+    };
+  }
+  let checkout = initiated.value;
+  try {
+    checkout = await applyFulfillment(context, checkout, state);
+    const options = await getShippingOptions(context, checkout);
+    return { checkout, options };
+  } finally {
+    await discardTransientCheckout(context, cart, checkout);
+  }
+}
+async function applyFulfillment(context, checkout, state) {
+  const checkoutCapability = context.client.checkout;
+  let current = checkout;
+  if (state.destination && checkoutCapability?.setShippingAddress) {
+    const result = await checkoutCapability.setShippingAddress({
+      checkout: current.identifier,
+      shippingAddress: toReactionaryAddress(state.destination)
+    });
+    if (result.success) {
+      current = result.value;
+    }
+  }
+  if (state.selectedOptionId && checkoutCapability?.setShippingInstruction) {
+    const result = await checkoutCapability.setShippingInstruction({
+      checkout: current.identifier,
+      shippingInstruction: {
+        shippingMethod: { key: state.selectedOptionId },
+        instructions: "",
+        pickupPoint: "",
+        consentForUnattendedDelivery: false
+      }
+    });
+    if (result.success) {
+      current = result.value;
+    }
+  }
+  return current;
+}
+async function getShippingOptions(context, checkout) {
+  const checkoutCapability = context.client.checkout;
+  if (!checkoutCapability?.getAvailableShippingMethods) {
+    return [];
+  }
+  const result = await checkoutCapability.getAvailableShippingMethods({ checkout: checkout.identifier });
+  return result.success ? result.value : [];
+}
+async function discardTransientCheckout(context, cart, checkout) {
+  if (checkout.identifier.key === cart.identifier.key || !context.client.cart) {
+    return;
+  }
+  await context.client.cart.deleteCart({ cart: checkout.identifier });
+}
+async function buildOpenView(context, state, warnings = []) {
+  const cart = await getCart(context, state.cartId);
+  if (!("identifier" in cart)) {
+    return { response: cart, ready: false };
+  }
+  const pricing = state.status === "canceled" ? { options: [] } : await priceWithTransientCheckout(context, cart, state);
+  const price = pricing.checkout?.price ?? cart.price;
+  const messages = [
+    ...await getStockMessages(context, cart),
+    ...getMissingInputMessages(context, state, pricing, await resolveBuyerEmail(context, state))
+  ];
+  const ready = state.status === "open" && messages.length === 0;
+  messages.push(...warnings);
+  state.lastTotal = getMoneyValue(price.grandTotal);
+  const selectedOptionTitle = state.selectedOptionId ? getOptionTitles(pricing.options).get(state.selectedOptionId) : void 0;
+  if (selectedOptionTitle) {
+    state.selectedOptionTitle = selectedOptionTitle;
+  }
+  await context.store.putCheckoutSession(state);
+  const response = {
+    id: state.id,
+    status: state.status === "canceled" ? "canceled" : ready ? "ready_for_complete" : "incomplete",
+    line_items: cart.items.map(toUcpCartLineItem),
+    currency: getMoneyCurrency(price.grandTotal),
+    totals: toUcpCostTotals(price, pricing.checkout?.items ?? cart.items),
+    links: [],
+    ...state.buyer ? { buyer: state.buyer } : {},
+    ...toUcpPayment(state),
+    ...toUcpFulfillment(context, cart, state, pricing.options),
+    ...context.client.cart?.applyCouponCode ? toUcpDiscounts(cart) : {},
+    ...messages.length > 0 ? { messages } : {},
+    ucp: createUcpCheckoutSuccessMetadata(context.paymentHandlers)
+  };
+  return { response, ready };
+}
+async function getStockMessages(context, cart) {
+  const inventoryCapability = context.client.inventory;
+  const fulfillmentCenterKeys = context.inventory?.fulfillmentCenterKeys ?? [];
+  if (!inventoryCapability || fulfillmentCenterKeys.length === 0) {
+    return [];
+  }
+  const messages = await Promise.all(cart.items.map(async (item, index) => {
+    const results = await Promise.all(fulfillmentCenterKeys.map((key) => inventoryCapability.getBySKU({
+      variant: item.variant,
+      fulfilmentCenter: { key }
+    })));
+    const inventories = results.flatMap((result) => result.success ? [result.value] : []);
+    if (inventories.length === 0 || inventories.some((inventory) => inventory.status === "onBackOrder" || inventory.status === "preOrder")) {
+      return void 0;
+    }
+    const available = inventories.reduce(
+      (total, inventory) => total + (inventory.status === "inStock" ? Math.max(inventory.quantity, 0) : 0),
+      0
+    );
+    if (item.quantity <= available) {
+      return void 0;
+    }
+    const sku = item.variant.sku;
+    return createUcpErrorMessage(
+      "out_of_stock",
+      available > 0 ? `Only ${available} of ${sku} are in stock.` : `${sku} is out of stock.`,
+      `$.line_items[${index}]`
+    );
+  }));
+  return messages.filter((message) => message !== void 0);
+}
+function getMissingInputMessages(context, state, pricing, email) {
+  const messages = pricing.failure ? [pricing.failure] : [];
+  if (!email) {
+    messages.push(createUcpErrorMessage("missing", "A buyer email is required to complete the checkout.", "$.buyer.email"));
+  }
+  if (context.client.checkout?.setShippingAddress) {
+    if (!state.destination) {
+      messages.push(createUcpErrorMessage("missing", "A shipping destination is required.", "$.fulfillment.methods[0].destinations"));
+    }
+  } else if (!state.destination && !state.billingAddress) {
+    messages.push(createUcpErrorMessage("missing", "A shipping destination or billing address is required.", "$.fulfillment.methods[0].destinations"));
+  }
+  if (pricing.options.length > 0 && !pricing.options.some((option) => option.identifier.key === state.selectedOptionId)) {
+    messages.push(createUcpErrorMessage("missing", "A fulfillment option must be selected.", "$.fulfillment.methods[0].groups[0].selected_option_id"));
+  }
+  if (!state.instrument) {
+    messages.push(createUcpErrorMessage("missing", "A payment instrument must be selected.", "$.payment.instruments"));
+  } else if (!isAcceptedPaymentHandler(context, state.instrument.handler_id)) {
+    messages.push(createUcpErrorMessage(
+      "payment_failed",
+      `Payment handler '${state.instrument.handler_id}' is not supported by this business.`,
+      "$.payment.instruments"
+    ));
+  }
+  return messages;
+}
+function toUcpPayment(state) {
+  const candidate = {
+    instruments: state.instrument ? [{
+      id: state.instrument.id,
+      handler_id: state.instrument.handler_id,
+      type: state.instrument.type,
+      selected: true,
+      ...state.billingAddress ? { billing_address: state.billingAddress } : {}
+    }] : []
+  };
+  return isUcpPayment(candidate) ? { payment: candidate } : {};
+}
+function isUcpPayment(value) {
+  const instruments = typeof value === "object" && value !== null ? Reflect.get(value, "instruments") : void 0;
+  return Array.isArray(instruments) && instruments.every(
+    (instrument) => typeof instrument === "object" && instrument !== null && typeof Reflect.get(instrument, "id") === "string" && typeof Reflect.get(instrument, "handler_id") === "string"
+  );
+}
+function toUcpFulfillment(context, cart, state, options) {
+  const destination = state.destination;
+  if (!context.client.checkout?.getAvailableShippingMethods) {
+    return {};
+  }
+  const lineItemIds = cart.items.map((item) => item.identifier.key);
+  const destinationId = destination?.id ?? "destination_1";
+  const titles = getOptionTitles(options);
+  const selectedOptionId = options.some((option) => option.identifier.key === state.selectedOptionId) ? state.selectedOptionId : void 0;
+  return {
+    fulfillment: {
+      methods: [
+        {
+          id: "shipping",
+          type: "shipping",
+          line_item_ids: lineItemIds,
+          destinations: destination ? [{ ...destination, id: destinationId }] : [],
+          ...destination ? { selected_destination_id: destinationId } : {},
+          groups: [
+            {
+              id: "group_1",
+              line_item_ids: lineItemIds,
+              options: options.map((option) => ({
+                id: option.identifier.key,
+                title: titles.get(option.identifier.key) ?? option.identifier.key,
+                totals: [{ type: "total", amount: getMoneyValue(option.price) }]
+              })),
+              ...selectedOptionId ? { selected_option_id: selectedOptionId } : {}
+            }
+          ]
+        }
+      ]
+    }
+  };
+}
+function getOptionTitles(options) {
+  const titles = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const option of options) {
+    let title = option.name || option.identifier.key;
+    if (used.has(title)) {
+      title = `${title} (${option.identifier.key})`;
+    }
+    used.add(title);
+    titles.set(option.identifier.key, title);
+  }
+  return titles;
+}
+async function placeFinalCheckout(context, state, payment) {
+  const checkoutCapability = context.client.checkout;
+  const address = state.destination ?? state.billingAddress;
+  const email = await resolveBuyerEmail(context, state);
+  const instrument = state.instrument;
+  const cart = await getCart(context, state.cartId);
+  if (!checkoutCapability || !address || !email || !instrument || !("identifier" in cart)) {
+    return {
+      failure: createUcpErrorMessage("checkout_complete_failed", "The checkout session is missing data required to complete it."),
+      messages: []
+    };
+  }
+  const initiated = await checkoutCapability.initiateCheckoutForCart({
+    cart,
+    billingAddress: toReactionaryAddress(state.billingAddress ?? address),
+    notificationEmail: email,
+    ...state.buyer?.phone_number ? { notificationPhone: state.buyer.phone_number } : {}
+  });
+  if (!initiated.success) {
+    return {
+      failure: createUcpErrorMessage("checkout_complete_failed", "The checkout could not be created."),
+      messages: []
+    };
+  }
+  const checkout = await applyFulfillment(context, initiated.value, state);
+  const paid = await checkoutCapability.addPaymentInstruction({
+    checkout: checkout.identifier,
+    paymentInstruction: {
+      amount: checkout.price.grandTotal,
+      paymentMethod: {
+        method: instrument.type,
+        name: instrument.id,
+        paymentProcessor: payment.handlerId
+      },
+      protocolData: [
+        { key: "ucp_payment_instrument_id", value: instrument.id },
+        { key: "ucp_payment_handler_id", value: payment.handlerId },
+        { key: "ucp_payment_instrument_type", value: instrument.type },
+        // Passed verbatim: the credential's shape is defined by the payment
+        // handler, and the backend's payment integration interprets it.
+        ...payment.credential ? [{ key: "ucp_payment_credential", value: JSON.stringify(payment.credential) }] : []
+      ]
+    }
+  });
+  if (!paid.success) {
+    return {
+      failure: createUcpErrorMessage("payment_failed", "The payment instruction could not be added.", "$.payment.instruments"),
+      messages: []
+    };
+  }
+  const messages = [];
+  const finalTotal = getMoneyValue(paid.value.price.grandTotal);
+  if (state.lastTotal !== void 0 && state.lastTotal !== finalTotal) {
+    messages.push(createUcpWarning("price_changed", "The total changed since the checkout session was last shown.", "$.totals"));
+  }
+  state.finalCheckoutId = paid.value.identifier.key;
+  state.status = "complete_in_progress";
+  await context.store.putCheckoutSession(state);
+  return { messages };
+}
+async function finalizeIfReady(context, state, messages) {
+  const checkoutCapability = context.client.checkout;
+  if (state.status !== "completed" && checkoutCapability && state.finalCheckoutId) {
+    const finalCheckoutId = state.finalCheckoutId;
+    const current = await pollUntil(
+      () => checkoutCapability.getById({ identifier: { key: finalCheckoutId } }),
+      (result) => !result.success || Boolean(result.value.resultingOrder || result.value.readyForFinalization),
+      context.paymentAuthorizationWait
+    );
+    if (current.success && current.value.resultingOrder) {
+      state.status = "completed";
+      state.orderId = current.value.resultingOrder.key;
+    } else if (current.success && current.value.readyForFinalization) {
+      const finalized = await checkoutCapability.finalizeCheckout({ checkout: current.value.identifier });
+      if (finalized.success) {
+        state.status = "completed";
+        state.orderId = finalized.value.resultingOrder?.key;
+      } else {
+        messages.push(createUcpErrorMessage("checkout_complete_failed", "Checkout completion failed."));
+      }
+    }
+    await context.store.putCheckoutSession(state);
+    await recordOrder(context, state);
+  }
+  return buildFinalView(context, state, messages);
+}
+async function recordOrder(context, state) {
+  if (state.status !== "completed" || !state.orderId || await context.store.getOrder(state.orderId)) {
+    return;
+  }
+  await context.store.putOrder({
+    id: state.orderId,
+    checkoutSessionId: state.id,
+    sessionId: context.sessionId,
+    ...context.agentProfile ? { agentProfile: context.agentProfile } : {},
+    ...state.destination ? { destination: state.destination } : {},
+    ...state.selectedOptionTitle ? { fulfillmentTitle: state.selectedOptionTitle } : {},
+    events: [],
+    adjustments: []
+  });
+  context.onOrderPlaced?.(state.orderId);
+}
+async function buildFinalView(context, state, messages = []) {
+  const result = state.finalCheckoutId ? await context.client.checkout?.getById({ identifier: { key: state.finalCheckoutId } }) : void 0;
+  if (!result?.success) {
+    return createUCPError("not_found", `Checkout was not found for session: ${state.id}`);
+  }
+  const checkout = result.value;
+  const orderId = state.orderId ?? checkout.resultingOrder?.key;
+  return {
+    id: state.id,
+    status: state.status === "completed" ? "completed" : "complete_in_progress",
+    line_items: checkout.items.map(toUcpCartLineItem),
+    currency: getMoneyCurrency(checkout.price.grandTotal),
+    totals: toUcpCostTotals(checkout.price, checkout.items),
+    links: [],
+    ...state.buyer ? { buyer: state.buyer } : {},
+    ...orderId ? { order: { id: orderId, permalink_url: toOrderPermalinkUrl(context.merchantUrl, orderId) } } : {},
+    ...messages.length > 0 ? { messages } : {},
+    ucp: createUcpCheckoutSuccessMetadata(context.paymentHandlers)
+  };
+}
+async function getCart(context, cartId) {
+  const result = await context.client.cart?.getById({ cart: { key: cartId } });
+  return result?.success ? result.value : createUCPError("not_found", `Cart was not found: ${cartId}`);
+}
+function addMessages(response, messages, status) {
+  if (!("id" in response)) {
+    return response;
+  }
+  return {
+    ...response,
+    status,
+    messages: [...response.messages ?? [], ...messages]
+  };
+}
+function checkoutSessionNotFound(checkoutSessionId) {
+  return createUCPError("not_found", `Checkout session was not found: ${checkoutSessionId}`);
+}
+export {
+  DEFAULT_UCP_PAYMENT_AUTHORIZATION_WAIT,
+  DEFAULT_UCP_PLACEHOLDER_EMAIL,
+  cancelCheckoutSession,
+  completeCheckoutSession,
+  createCheckoutSession,
+  getCheckoutSession,
+  updateCheckoutSession
+};