@vtex/faststore 0.0.10 → 0.0.11

package/dist/matter/place-order/place-order.js

@@ -1,21 +1,81 @@
 "use client";
 import { defineComponent } from "../../core/dist/define-component.js";
+import { defineContentType } from "../../core/dist/define-content-type.js";
 import "../../core/dist/index.js";
 import { resolveSiteRelativeHref } from "../../utils/safe-href.js";
+import { resolveStorefrontHref } from "../../sdk/navigation/resolve-storefront-href.js";
+import { useStorefrontContext } from "../../sdk/context/storefront-context.js";
+import { useMessageFormatter } from "../../sdk/i18n/use-message-formatter.js";
+import { useRouteMap } from "../../sdk/navigation/route-map-provider.js";
 import { useStorefrontNavigation } from "../../sdk/navigation/use-storefront-navigation.js";
 import { useActionsOverride } from "../../sdk/actions/actions-override-context.js";
+import { formatErrorCode } from "../../sdk/i18n/format-error-code.js";
 import { useDataOverride } from "../../sdk/data/data-override-context.js";
 import { Button } from "../../particles/button/button.js";
 import { usePayment } from "../payment/payment.js";
 import { refusalTargetOf, usePaymentSubmitGate } from "../payment/use-payment-submit-gate.js";
+import { buildChallengeReturnQuery } from "../../sdk/payment/challenge-return.js";
+import { useSettledOrderRead } from "../../sdk/payment/resumed-purchase.js";
 import { usePlaceOrder } from "../../sdk/payment/use-place-order.js";
-import { useEffect, useId, useLayoutEffect, useState } from "react";
+import { useCallback, useEffect, useId, useLayoutEffect, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
-const PlaceOrderDefinition = defineComponent({
-	name: "PlaceOrder",
-	importPath: "@vtex/faststore/components",
-	component: PlaceOrder,
-	fragment: `
+//#region src/matter/place-order/place-order.tsx
+/**
+* The `PlaceOrder` CTA matter (specs/place-order.md, T14 of the Credit Card epic;
+* docs/features/credit-card/rfc.md § D9). Drives T13's `usePlaceOrder` orchestration hook and renders
+* the three v1 states the RFC names: the idle CTA, a blocking loading state while the three-call
+* sequence runs, and an inline outcome (error or success) once it settles.
+*
+* **Composes as a sibling of the card entry (T7) and the saved cards list (T12) under the payment
+* root, never nested inside either.** That placement is what lets this one CTA serve both the
+* new-card and saved-card paths — nesting it inside a card form, as the legacy `CardForm` does,
+* would force a second CTA for the saved-card path. This is a documented authoring convention, not a
+* compiler guarantee: `requiresContext: 'payment'` (ADR-0009) only fails the build when *no* ancestor
+* at any depth declares `providesContext: 'payment'` — there is no `forbidsAncestor` token, so a
+* schema that nests this component inside `CardEntry`/`SavedCards` instead of beside them still
+* compiles and still resolves the context from the payment root further up. This component throws
+* at runtime only when rendered entirely outside a `PaymentSectionRoot`/`Controller` subtree — both
+* `usePayment()` (read directly below, for `draft.billingAddressDifferent`) and `usePlaceOrder` (via
+* the submission channel those roots provide) enforce that guard, with `usePayment()` throwing first
+* since its value feeds `usePlaceOrder`'s own argument — a real, load-bearing guard, but a weaker one
+* than "must be a sibling." See specs/place-order.md's open items for this gap.
+*
+* **This component never touches card data.** It declares its own thin fragment for the read-model
+* slice `usePlaceOrder` needs (`selectedMethodId`, `selectedInstallment`, `methods` — ADR-0011,
+* mirroring `PaymentSummaryData`/`PaymentSectionData`) and forwards it plus `$actions` straight into
+* the hook. The one fact it reads off `usePayment()`'s context directly is `draft.billingAddressDifferent`
+* (T11's widening of `PaymentDraft`), forwarded into `usePlaceOrder`'s own optional argument of the
+* same name so the gateway descriptor carries the shopper's choice (fix pass, PR #544 review F1) —
+* still not a card field, since `PaymentDraft` never carries one. `usePaymentSubmitGate()` (T24)
+* resolves the client-side document/billing refusal off that same context and is forwarded as
+* `usePlaceOrder`'s `submitGate` argument — an opaque `PaymentUserError | null`, never the facts
+* behind it. The hook already owns `placing`, `userErrors`, and `orderId` — including releasing
+* `placing` on every failure path — so this component only reflects that state, never re-implements it.
+*
+* `attempted` is the one bit of state this component adds, and it is not a duplicate of anything the
+* hook owns: `usePlaceOrder`'s `userErrors: []` is both the pre-attempt state and the settled-success
+* state (T13 does not disambiguate the two, by design — see `UsePlaceOrder`'s doc), so distinguishing
+* "never attempted" from "attempted and succeeded" is exactly this component's job. `succeeded` is
+* derived, not stored: `attempted && !placing && userErrors.length === 0`.
+*
+* **T29 widens both `succeeded` and the button label with the surviving `attempt` record read off
+* `usePayment()`** (specs/make-an-order-attempt-survive-a.md), never mirrored into local state:
+* `attempted`/`userErrors`/`orderId` all restart at their pre-attempt defaults on every mount, but the
+* attempt record does not, so a remount renders its truth rather than this instance's own fresh state.
+* `succeeded` is `true` whenever the record's own phase is `'settled'`, independent of `attempted`; the
+* button shows `resumeLabel` instead of `label` whenever the phase is `'sent'` or `'unresolved'` — the
+* card already left the browser (or its fate is unknown) and the next click finalizes it through
+* `usePlaceOrder`'s `resume()` rather than opening a new transaction.
+*
+* The button disables on `placing` (the required blocking state) and, deliberately, on `succeeded`
+* too — an already-placed order has nothing left to submit, and a second click risks exactly the
+* duplicate-transaction outcome T13's own concurrency guard (Decision 6) calls "the worst outcome
+* this task's surface has". `usePlaceOrder`'s in-flight ref is the inner guard; this is the outer one.
+* Fix pass, finding S-F1: it also disables on the *shared* `usePayment().placing`, since a second
+* composed `PlaceOrder` has no other way to learn a sibling instance already opened a transaction —
+* each `usePlaceOrder()` call owns its own, independent `inFlight` ref.
+*/
+const fragment = `
   fragment PlaceOrderData on Query {
     payment {
       __typename
@@ -37,7 +97,168 @@ const PlaceOrderDefinition = defineComponent({
       }
     }
   }
-`,
+`;
+const PlaceOrderContent = defineContentType({
+	id: "place-order",
+	title: "Place Order",
+	description: "The place-order button labels, the message while placing, the success message, and the message for each refusal it words.",
+	schema: {
+		type: "object",
+		additionalProperties: false,
+		properties: {
+			label: {
+				type: "string",
+				title: "Button label",
+				format: "icu-message",
+				messageSource: "Place order"
+			},
+			placingLabel: {
+				type: "string",
+				title: "Button label while placing",
+				format: "icu-message",
+				messageSource: "Placing order..."
+			},
+			placingMessage: {
+				type: "string",
+				title: "Message while placing",
+				format: "icu-message",
+				messageSource: "Processing your payment. Please keep this page open.",
+				messageOptional: true
+			},
+			resumeLabel: {
+				type: "string",
+				title: "Button label while a surviving attempt offers a resume",
+				format: "icu-message",
+				messageSource: "Complete your order"
+			},
+			successMessage: {
+				type: "string",
+				title: "Success message",
+				format: "icu-message",
+				messageSource: "Order placed successfully."
+			},
+			missingSubmissionMessage: {
+				type: "string",
+				title: "Missing payment submission message",
+				format: "icu-message",
+				messageSource: "Enter your payment details before placing the order."
+			},
+			missingMethodMessage: {
+				type: "string",
+				title: "Missing payment method message",
+				format: "icu-message",
+				messageSource: "Choose a payment method before placing the order."
+			},
+			invalidTransactionMessage: {
+				type: "string",
+				title: "Invalid transaction message",
+				format: "icu-message",
+				messageSource: "Unable to start the payment. Please try again."
+			},
+			networkErrorMessage: {
+				type: "string",
+				title: "Network error message",
+				format: "icu-message",
+				messageSource: "Unable to complete the request. Please try again."
+			},
+			missingDocumentMessage: {
+				type: "string",
+				title: "Missing document message",
+				format: "icu-message",
+				messageSource: "Enter your document before placing the order."
+			},
+			invalidDocumentMessage: {
+				type: "string",
+				title: "Invalid document message",
+				format: "icu-message",
+				messageSource: "Enter a valid document before placing the order."
+			},
+			unavailableMethodMessage: {
+				type: "string",
+				title: "Unavailable payment method message",
+				format: "icu-message",
+				messageSource: "Choose another payment method before placing the order."
+			},
+			unsavedBillingAddressMessage: {
+				type: "string",
+				title: "Unsaved billing address message",
+				format: "icu-message",
+				messageSource: "Save your billing address before placing the order."
+			},
+			missingProfileNameMessage: {
+				type: "string",
+				title: "Missing name message",
+				format: "icu-message",
+				messageSource: "Enter your first and last name before placing the order."
+			},
+			missingProfilePhoneMessage: {
+				type: "string",
+				title: "Missing phone message",
+				format: "icu-message",
+				messageSource: "Enter your phone number before placing the order."
+			},
+			invalidCardDataMessage: {
+				type: "string",
+				title: "Invalid card data message",
+				format: "icu-message",
+				messageSource: "Enter valid card details before placing the order."
+			},
+			unsupportedNetworkMessage: {
+				type: "string",
+				title: "Unsupported card network message",
+				format: "icu-message",
+				messageSource: "This card is not from a network the store accepts. Use another card or choose another payment method."
+			},
+			invalidSecurityCodeMessage: {
+				type: "string",
+				title: "Invalid security code message",
+				format: "icu-message",
+				messageSource: "Enter a valid security code before placing the order."
+			},
+			gatewayErrorMessage: {
+				type: "string",
+				title: "Gateway error message",
+				format: "icu-message",
+				messageSource: "Unable to complete the payment. Please try again."
+			},
+			inFlightMessage: {
+				type: "string",
+				title: "Order already in flight message",
+				format: "icu-message",
+				messageSource: "This order is already being placed. Please wait."
+			},
+			unconfirmedMessage: {
+				type: "string",
+				title: "Unconfirmed order message",
+				format: "icu-message",
+				messageSource: "We could not confirm your order yet. Your payment may still be processing, so please do not pay again."
+			},
+			declinedMessage: {
+				type: "string",
+				title: "Declined payment message",
+				format: "icu-message",
+				messageSource: "Check your payment information or choose another payment method."
+			},
+			lapsedTransactionMessage: {
+				type: "string",
+				title: "Lapsed payment window message",
+				format: "icu-message",
+				messageSource: "We could not confirm your order yet. Your payment may still be processing, so please do not pay again."
+			},
+			challengeUnavailableMessage: {
+				type: "string",
+				title: "Unavailable bank verification message",
+				format: "icu-message",
+				messageSource: "Your bank asked for an extra verification step that we could not open. Your payment may still be processing, so please do not pay again."
+			}
+		}
+	}
+});
+const PlaceOrderDefinition = defineComponent({
+	name: "PlaceOrder",
+	importPath: "@vtex/faststore/components",
+	component: PlaceOrder,
+	fragment,
 	fetchStrategy: "reactive",
 	actions: {
 		payment: ["startTransaction", "gatewayCallback"],
@@ -48,116 +269,27 @@ const PlaceOrderDefinition = defineComponent({
 		label: "Place Order",
 		category: "commerce"
 	},
+	content: PlaceOrderContent,
 	schema: {
-		label: {
-			type: "string",
-			default: "Place order",
-			label: "Button label"
-		},
-		placingLabel: {
-			type: "string",
-			default: "Placing order...",
-			label: "Button label while placing"
-		},
-		placingMessage: {
-			type: "string",
-			label: "Message shown while placing the order"
-		},
-		resumeLabel: {
-			type: "string",
-			default: "Complete your order",
-			label: "Button label while a surviving attempt offers a resume"
-		},
-		successMessage: {
-			type: "string",
-			default: "Order placed successfully.",
-			label: "Success message"
-		},
-		missingSubmissionMessage: {
-			type: "string",
-			default: "Enter your payment details before placing the order.",
-			label: "Missing payment submission message"
-		},
-		missingMethodMessage: {
-			type: "string",
-			default: "Choose a payment method before placing the order.",
-			label: "Missing payment method message"
-		},
-		invalidTransactionMessage: {
-			type: "string",
-			default: "Unable to start the payment. Please try again.",
-			label: "Invalid transaction message"
-		},
-		networkErrorMessage: {
-			type: "string",
-			default: "Unable to complete the request. Please try again.",
-			label: "Network error message"
-		},
-		missingDocumentMessage: {
-			type: "string",
-			default: "Enter your document before placing the order.",
-			label: "Missing document message"
-		},
-		invalidDocumentMessage: {
-			type: "string",
-			default: "Enter a valid document before placing the order.",
-			label: "Invalid document message"
-		},
-		unavailableMethodMessage: {
-			type: "string",
-			default: "Choose another payment method before placing the order.",
-			label: "Unavailable payment method message"
-		},
-		unsavedBillingAddressMessage: {
-			type: "string",
-			default: "Save your billing address before placing the order.",
-			label: "Unsaved billing address message"
-		},
-		invalidCardDataMessage: {
-			type: "string",
-			default: "Enter valid card details before placing the order.",
-			label: "Invalid card data message"
-		},
-		unsupportedNetworkMessage: {
-			type: "string",
-			default: "This card is not from a network the store accepts. Use another card or choose another payment method.",
-			label: "Unsupported card network message"
-		},
-		invalidSecurityCodeMessage: {
-			type: "string",
-			default: "Enter a valid security code before placing the order.",
-			label: "Invalid security code message"
-		},
-		gatewayErrorMessage: {
-			type: "string",
-			default: "Unable to complete the payment. Please try again.",
-			label: "Gateway error message"
-		},
-		inFlightMessage: {
-			type: "string",
-			default: "This order is already being placed. Please wait.",
-			label: "Order already in flight message"
-		},
-		unconfirmedMessage: {
-			type: "string",
-			default: "We could not confirm your order yet. Your payment may still be processing, so please do not pay again.",
-			label: "Unconfirmed order message"
-		},
 		successHref: {
 			type: "link",
 			default: { standard: "order-placed" },
-			fills: ["orderGroup"],
+			fills: ["orderId"],
 			label: "Confirmation Page"
+		},
+		challengeReturnHref: {
+			type: "link",
+			label: "Bank challenge return page"
 		}
 	},
-	guideline: "The place-order CTA: invokes usePlaceOrder's three-call sequence (start transaction, the registered submission's own direct-to-gateway leg, then the gateway callback) and blocks interaction while it runs. Compose it as a sibling — never a child — of every other payment-entry leaf under the same PaymentSectionRoot or PaymentSectionController, so the one CTA serves every entry path. Renders one inline outcome after settling: the first userError's message, or successMessage on a clean settle. While the order is being placed it renders nothing but the button, unless placingMessage is set: then a status message shows beside the button, and the rest of the payment form is blocked for as long as it shows. This component reaches no payment-sensitive input. Must be inside a payment root. See place-order.md."
+	guideline: "The place-order CTA: invokes usePlaceOrder's three-call sequence (start transaction, the registered submission's own direct-to-gateway leg, then the gateway callback) and blocks interaction while it runs. Compose it as a sibling — never a child — of every other payment-entry leaf under the same PaymentSectionRoot or PaymentSectionController, so the one CTA serves every entry path. Its button labels and messages are $content fields (label, placingLabel, placingMessage, resumeLabel, successMessage, and one message per refusal code it words). Renders one inline outcome after settling: the message for the first userError's code (networkErrorMessage for a code it does not word), or successMessage on a clean settle. While the order is being placed it renders nothing but the button, unless the placingMessage message is authored: then a status message shows beside the button, and the rest of the payment form is blocked for as long as it shows. When challengeReturnHref names a return page of the store and the bank asks for a challenge, the shopper is sent to the bank with the form blocked and no success or error shown; the return page finishes the order. This component reaches no payment-sensitive input. Must be inside a payment root. See place-order.md."
 });
 /** The default confirmation page. */
 const ORDER_PLACED_PAGE = { standard: "order-placed" };
 /**
 * Fail-closed warning for a string `successHref` that is not a path of this store. Nothing upstream
 * validates a string prop's shape, and an absolute or protocol-relative value would turn this CTA into
-* an open redirect that fires right after a real purchase, carrying the shopper's own order group to
+* an open redirect that fires right after a real purchase, carrying the shopper's own order id to
 * another origin. Dev-only, like every other authoring warning in this component.
 */
 function warnUnsafeSuccessHref(successHref, reason) {
@@ -167,38 +299,109 @@ function warnUnsafeSuccessHref(successHref, reason) {
 /**
 * Fail-closed warning for a string `successHref` that still carries a `{token}`, the template form this
 * prop took before page references. Nothing fills the token any more, so navigating would land the
-* shopper on a literal `%7BorderGroup%7D` 404 right after paying. Dev-only.
+* shopper on a literal `%7BorderId%7D` 404 right after paying. Dev-only.
 */
 function warnTemplateSuccessHref(successHref) {
 	if (process.env.NODE_ENV === "production") return;
 	console.warn(`[PlaceOrder] successHref "${successHref}" is a route template; refusing to navigate there. Reference the confirmation page instead: { standard: 'order-placed' }.`);
 }
 /**
-* Navigates once `orderId` transitions to a non-empty value — not on `succeeded` (Decision 4) — so a
-* null or empty order group and every failure path never navigate. `userErrors` is also consulted
+* Dev-only warning for a `challengeReturnHref` this CTA cannot build a return URL from. Nothing upstream
+* validates a link prop's shape at runtime, and a string would have to be turned into an absolute URL the
+* bank must come back to; so the prop is a page reference or nothing, and the shopper keeps the refusal
+* a challenge answer gets without a return page.
+*/
+function warnUnusableChallengeReturnHref(reason) {
+	if (process.env.NODE_ENV === "production") return;
+	console.warn(`[PlaceOrder] challengeReturnHref ${reason}; sending no return URL, so a bank challenge cannot be followed. Reference a page of this store instead: { page: 'checkout-challenge-return' }.`);
+}
+function isPageRef(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* The builder `usePlaceOrder` calls with an opened order's group: the absolute URL of the authored return
+* page, carrying the group and the literal flag, or `null` when the store authored none or it cannot be
+* built. Resolved through `resolveStorefrontHref`, which never logs, so an unusable prop warns exactly once
+* here, naming itself. Keyed on the serialized reference, not its identity: a reference authored in a
+* schema arrives as a new object on every server render.
+*/
+function useChallengeReturn(challengeReturnHref) {
+	const { bindingId, basePath } = useStorefrontContext();
+	const { routeMap } = useRouteMap();
+	const authoredKey = challengeReturnHref === void 0 ? null : JSON.stringify(challengeReturnHref);
+	return useCallback((orderGroup) => {
+		if (authoredKey === null) return null;
+		const authored = JSON.parse(authoredKey);
+		if (!isPageRef(authored)) {
+			warnUnusableChallengeReturnHref("is not a page reference");
+			return null;
+		}
+		const query = buildChallengeReturnQuery(orderGroup);
+		if (query === null) return null;
+		const resolved = resolveStorefrontHref({
+			bindingId,
+			basePath
+		}, routeMap, {
+			...authored,
+			query: {
+				...authored.query,
+				...query
+			}
+		});
+		if (resolved.href === null) {
+			warnUnusableChallengeReturnHref(`names a page this store does not serve (${resolved.reason})`);
+			return null;
+		}
+		return `${globalThis.location.origin}${resolved.href}`;
+	}, [
+		authoredKey,
+		bindingId,
+		basePath,
+		routeMap
+	]);
+}
+/**
+* Hands the document to the bank once `redirectUrl` is set. `useStorefrontNavigation().push` makes an
+* absolute URL a document load, which unloads this page: nothing here draws a success or an error, and the
+* hook keeps `placing` true so the form stays blocked until the browser leaves. A ref remembers the URL
+* already navigated to, so neither a re-render nor StrictMode's second effect pass navigates twice.
+*/
+function PlaceOrderNavigateOnRedirect({ redirectUrl }) {
+	const { push } = useStorefrontNavigation();
+	const navigatedTo = useRef(null);
+	useEffect(() => {
+		if (!redirectUrl || navigatedTo.current === redirectUrl) return;
+		navigatedTo.current = redirectUrl;
+		push(redirectUrl);
+	}, [redirectUrl, push]);
+	return null;
+}
+/**
+* Navigates once `orderNodeId` transitions to a non-empty value — not on `succeeded` (Decision 4) — so a
+* null or empty order Node id and every failure path never navigate. `userErrors` is also consulted
 * directly (INV-1): this component does not own `usePlaceOrder`, so it does not rely on that hook never
 * settling an order id beside an error.
 *
-* The call site passes `displayOrderId` (`orderId ?? the surviving attempt's own orderId`), not the
-* mount-local `orderId` this type is named for: a remounted CTA whose own `usePlaceOrder()` never ran
-* has an empty local `orderId` forever, and would otherwise leave the shopper on the payment page.
+* The call site passes `displayOrderNodeId` (`orderNodeId ?? the surviving attempt's own orderNodeId`),
+* not the mount-local `orderNodeId` this type is named for: a remounted CTA whose own `usePlaceOrder()`
+* never ran has an empty local `orderNodeId` forever, and would otherwise leave the shopper on the payment page.
 *
 * The effect keys on the serialized `successHref`, not on its identity: a reference authored in a
 * schema arrives as a new object on every server render, and keying on it would navigate again on a
 * `router.refresh()`.
 */
-function PlaceOrderNavigateOnSuccess({ successHref, orderId, userErrors }) {
+function PlaceOrderNavigateOnSuccess({ successHref, orderNodeId, userErrors }) {
 	const { replace } = useStorefrontNavigation();
 	const successKey = JSON.stringify(successHref);
 	useEffect(() => {
-		if (!orderId || userErrors.length > 0) return;
+		if (!orderNodeId || userErrors.length > 0) return;
 		const authored = JSON.parse(successKey);
 		if (typeof authored !== "string") {
 			replace({
 				...authored,
 				params: {
 					...authored.params,
-					orderGroup: orderId
+					orderId: orderNodeId
 				}
 			});
 			return;
@@ -214,7 +417,7 @@ function PlaceOrderNavigateOnSuccess({ successHref, orderId, userErrors }) {
 		}
 		replace(destination.href);
 	}, [
-		orderId,
+		orderNodeId,
 		successKey,
 		userErrors,
 		replace
@@ -222,75 +425,70 @@ function PlaceOrderNavigateOnSuccess({ successHref, orderId, userErrors }) {
 	return null;
 }
 /**
-* Builds the code -> copy map `resolveErrorMessage` reads (Decision 1, FR-4). The codes are literal
-* strings, never imported constants: importing them from card-entry.tsx / saved-cards.tsx /
-* use-place-order.ts / use-payment-submit-gate.ts / gateway.ts here would make this file a matter ->
-* matter dependency (R5) — `resolvePaymentSubmitGate` and `use-place-order.ts` stay untouched and this
-* component still imports nothing from either module beyond the hooks it already called. Exported for
-* direct unit testing, mirroring card-entry.tsx's convention for its own pure helpers:
-* place-order.test.tsx imports the five files' own real exported code constants and asserts this
-* function's returned key set equals their union.
+* The message field for each code in `PlaceOrderErrorCode`. The codes are literal strings, never imported
+* constants: importing them from card-entry.tsx / saved-cards.tsx / use-place-order.ts /
+* use-payment-submit-gate.ts / gateway.ts would make this file a matter -> matter dependency (R5).
+* `CARD_ENTRY_COLLAPSED` reads as an unavailable method; the two cart codes and `NETWORK_ERROR` share the
+* generic message; `ORDER_GROUP_MISMATCH`, like a lapsed cookie, means the card POST was accepted.
 */
-function buildAuthoredErrorMessages(messages) {
-	return {
-		MISSING_PAYMENT_SUBMISSION: messages.missingSubmissionMessage,
-		MISSING_PAYMENT_METHOD_SELECTION: messages.missingMethodMessage,
-		INVALID_TRANSACTION_DATA: messages.invalidTransactionMessage,
-		NETWORK_ERROR: messages.networkErrorMessage,
-		MISSING_CARDHOLDER_DOCUMENT: messages.missingDocumentMessage,
-		INVALID_CARDHOLDER_DOCUMENT: messages.invalidDocumentMessage,
-		UNSAVED_BILLING_ADDRESS: messages.unsavedBillingAddressMessage,
-		INVALID_CARD_DATA: messages.invalidCardDataMessage,
-		UNSUPPORTED_CARD_NETWORK: messages.unsupportedNetworkMessage,
-		INVALID_SECURITY_CODE: messages.invalidSecurityCodeMessage,
-		GATEWAY_ERROR: messages.gatewayErrorMessage,
-		PLACE_ORDER_IN_FLIGHT: messages.inFlightMessage,
-		PLACE_ORDER_UNCONFIRMED: messages.unconfirmedMessage,
-		UNAVAILABLE_PAYMENT_METHOD: messages.unavailableMethodMessage
-	};
-}
+const PLACE_ORDER_ERROR_FIELDS = {
+	MISSING_PAYMENT_SUBMISSION: "missingSubmissionMessage",
+	MISSING_PAYMENT_METHOD_SELECTION: "missingMethodMessage",
+	INVALID_TRANSACTION_DATA: "invalidTransactionMessage",
+	NETWORK_ERROR: "networkErrorMessage",
+	MISSING_CARDHOLDER_DOCUMENT: "missingDocumentMessage",
+	INVALID_CARDHOLDER_DOCUMENT: "invalidDocumentMessage",
+	UNSAVED_BILLING_ADDRESS: "unsavedBillingAddressMessage",
+	MISSING_PROFILE_NAME: "missingProfileNameMessage",
+	MISSING_PROFILE_PHONE: "missingProfilePhoneMessage",
+	INVALID_CARD_DATA: "invalidCardDataMessage",
+	UNSUPPORTED_CARD_NETWORK: "unsupportedNetworkMessage",
+	CARD_ENTRY_COLLAPSED: "unavailableMethodMessage",
+	INVALID_SECURITY_CODE: "invalidSecurityCodeMessage",
+	GATEWAY_ERROR: "gatewayErrorMessage",
+	PLACE_ORDER_IN_FLIGHT: "inFlightMessage",
+	PLACE_ORDER_UNCONFIRMED: "unconfirmedMessage",
+	UNAVAILABLE_PAYMENT_METHOD: "unavailableMethodMessage",
+	MISSING_CART_CONTEXT: "networkErrorMessage",
+	CART_NOT_FOUND: "networkErrorMessage",
+	PAYMENT_DECLINED: "declinedMessage",
+	MISSING_TRANSACTION_COOKIES: "lapsedTransactionMessage",
+	ORDER_GROUP_MISMATCH: "lapsedTransactionMessage",
+	REDIRECT_REQUIRED: "challengeUnavailableMessage"
+};
 /**
-* Resolves the alert's rendered message for one client-synthesized `PaymentUserError`: the authored
-* copy for its `code` when this component owns one, otherwise the error's own `message` unchanged
-* (US-2 AC2 — a server-returned code this component does not author must render verbatim).
-*
-* `||`, not `??` (fix pass, finding 7): a store author can write `""` for a code's authored message —
-* a valid, if unusual, `type: 'string'` prop value — and `??` only falls through on `null`/`undefined`,
-* so an authored empty string would render as an empty `role="alert"` on a genuine gateway refusal,
-* leaving the shopper with no feedback at all where the unauthored default always rendered
-* `error.message`. Falling through on any falsy authored value is the exception on this surface, not
-* the rule: eight sibling `??` resolutions elsewhere (`access-code-sign-in.tsx`, `region.tsx`) stay on
-* `??`; `billing-address.tsx`'s `fieldLabels` fallback (fix pass round 2, finding N1) is fixed the
-* same way, for the same reason.
+* The alert's message for one `PaymentUserError`: the message field for its `code`, or networkErrorMessage
+* for a code this CTA does not word. A missing message renders empty and the formatter logs it.
 */
-function resolveErrorMessage(error, authored) {
-	return authored[error.code] || error.message;
+function resolveErrorMessage(error, format) {
+	return formatErrorCode(PlaceOrderContent, PLACE_ORDER_ERROR_FIELDS, error, format, "networkErrorMessage");
 }
 /**
 * The CTA's feedback nodes: the authored placing message, the alert for a refusal, the status notice for
 * an order that could not be confirmed (T176), and the success line. Rendered as the CTA's own children,
 * so none of them adds a wrapper.
 */
-function PlaceOrderFeedback({ placing, placingMessage, firstError, unconfirmed, succeeded, successMessage, displayOrderId, authoredErrorMessages }) {
+function PlaceOrderFeedback({ placing, firstError, unconfirmed, succeeded, displayOrderId, format }) {
+	const placingMessage = placing ? format("placingMessage") : "";
 	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
-		placing && placingMessage?.trim() ? /* @__PURE__ */ jsx("output", {
+		placingMessage.trim() ? /* @__PURE__ */ jsx("output", {
 			"data-fs-place-order-placing": "",
 			children: placingMessage
 		}) : null,
 		firstError && !unconfirmed ? /* @__PURE__ */ jsx("div", {
 			role: "alert",
 			"data-fs-place-order-error": "",
-			children: resolveErrorMessage(firstError, authoredErrorMessages)
+			children: resolveErrorMessage(firstError, format)
 		}) : null,
 		firstError && unconfirmed && !succeeded ? /* @__PURE__ */ jsx("output", {
 			"data-fs-place-order-unconfirmed": "",
-			children: resolveErrorMessage(firstError, authoredErrorMessages)
+			children: resolveErrorMessage(firstError, format)
 		}) : null,
 		succeeded ? /* @__PURE__ */ jsxs("output", {
 			"data-fs-place-order-success": "",
 			children: [/* @__PURE__ */ jsx("span", {
 				"data-fs-place-order-success-message": "",
-				children: successMessage
+				children: format("successMessage")
 			}), displayOrderId ? /* @__PURE__ */ jsx("span", {
 				"data-fs-place-order-success-order-id": "",
 				children: displayOrderId
@@ -307,36 +505,25 @@ function refusalFocusTarget(refusals, reachedGateway) {
 	const [refusal] = refusals;
 	return reachedGateway === false && refusal ? refusalTargetOf(refusal) : null;
 }
-function PlaceOrder({ label = "Place order", placingLabel = "Placing order...", placingMessage, resumeLabel = "Complete your order", successMessage = "Order placed successfully.", missingSubmissionMessage = "Enter your payment details before placing the order.", missingMethodMessage = "Choose a payment method before placing the order.", invalidTransactionMessage = "Unable to start the payment. Please try again.", networkErrorMessage = "Unable to complete the request. Please try again.", missingDocumentMessage = "Enter your document before placing the order.", invalidDocumentMessage = "Enter a valid document before placing the order.", unavailableMethodMessage = "Choose another payment method before placing the order.", unsavedBillingAddressMessage = "Save your billing address before placing the order.", invalidCardDataMessage = "Enter valid card details before placing the order.", unsupportedNetworkMessage = "This card is not from a network the store accepts. Use another card or choose another payment method.", invalidSecurityCodeMessage = "Enter a valid security code before placing the order.", gatewayErrorMessage = "Unable to complete the payment. Please try again.", inFlightMessage = "This order is already being placed. Please wait.", unconfirmedMessage = "We could not confirm your order yet. Your payment may still be processing, so please do not pay again.", successHref = ORDER_PLACED_PAGE, $data: $dataProp, $actions: $actionsProp, className, ...props }) {
+function PlaceOrder({ successHref = ORDER_PLACED_PAGE, challengeReturnHref, $data: $dataProp, $actions: $actionsProp, $content, $locale, className, ...props }) {
 	const $data = useDataOverride($dataProp);
 	const $actions = useActionsOverride($actionsProp);
 	const instanceKey = useId();
 	const { draft, placing: sectionPlacing, setPlacing, attempt, setAttempt, focusRefusal } = usePayment();
 	const submitGate = usePaymentSubmitGate();
-	const { placeOrder, placing, userErrors, orderId } = usePlaceOrder({
+	const challengeReturn = useChallengeReturn(challengeReturnHref);
+	const readSettledOrder = useSettledOrderRead();
+	const { placeOrder, placing, userErrors, orderId, orderNodeId, redirectUrl } = usePlaceOrder({
 		$data,
 		$actions,
 		attempt,
 		setAttempt,
 		billingAddressDifferent: draft.billingAddressDifferent,
-		submitGate
-	});
-	const authoredErrorMessages = buildAuthoredErrorMessages({
-		missingSubmissionMessage,
-		missingMethodMessage,
-		invalidTransactionMessage,
-		networkErrorMessage,
-		missingDocumentMessage,
-		invalidDocumentMessage,
-		unsavedBillingAddressMessage,
-		invalidCardDataMessage,
-		unsupportedNetworkMessage,
-		invalidSecurityCodeMessage,
-		gatewayErrorMessage,
-		inFlightMessage,
-		unconfirmedMessage,
-		unavailableMethodMessage
+		submitGate,
+		challengeReturn,
+		readSettledOrder
 	});
+	const { format } = useMessageFormatter(PlaceOrderContent, $content);
 	const [attempted, setAttempted] = useState(false);
 	useLayoutEffect(() => {
 		setPlacing(instanceKey, placing);
@@ -351,9 +538,11 @@ function PlaceOrder({ label = "Place order", placingLabel = "Placing order...",
 	]);
 	const [firstError] = userErrors;
 	const settledAttemptOrderId = attempt?.phase === "settled" ? attempt.orderId : null;
+	const settledAttemptOrderNodeId = attempt?.phase === "settled" ? attempt.orderNodeId ?? null : null;
 	const succeeded = attempted && !placing && userErrors.length === 0 || attempt?.phase === "settled";
 	const resumable = attempt?.phase === "sent" || attempt?.phase === "unresolved";
 	const displayOrderId = orderId ?? settledAttemptOrderId;
+	const displayOrderNodeId = orderNodeId ?? settledAttemptOrderNodeId;
 	const unconfirmed = firstError?.code === "PLACE_ORDER_UNCONFIRMED";
 	const blockedByOtherInstance = sectionPlacing && !resumable;
 	function handleClick() {
@@ -364,6 +553,9 @@ function PlaceOrder({ label = "Place order", placingLabel = "Placing order...",
 			if (target) focusRefusal(target);
 		});
 	}
+	let buttonLabelField = "label";
+	if (placing) buttonLabelField = "placingLabel";
+	else if (resumable) buttonLabelField = "resumeLabel";
 	return /* @__PURE__ */ jsxs("div", {
 		...props,
 		className,
@@ -376,27 +568,26 @@ function PlaceOrder({ label = "Place order", placingLabel = "Placing order...",
 				"aria-busy": placing || void 0,
 				"data-fs-place-order-button": "",
 				...placing ? { "data-fs-place-order-button-pending": "" } : {},
-				children: placing ? placingLabel : resumable ? resumeLabel : label
+				children: format(buttonLabelField)
 			}),
 			/* @__PURE__ */ jsx(PlaceOrderFeedback, {
 				placing,
-				placingMessage,
 				firstError,
 				unconfirmed,
 				succeeded,
-				successMessage,
 				displayOrderId,
-				authoredErrorMessages
+				format
 			}),
 			/* @__PURE__ */ jsx(PlaceOrderNavigateOnSuccess, {
 				successHref,
-				orderId: displayOrderId,
+				orderNodeId: displayOrderNodeId,
 				userErrors
-			})
+			}),
+			/* @__PURE__ */ jsx(PlaceOrderNavigateOnRedirect, { redirectUrl })
 		]
 	});
 }
 //#endregion
-export { PlaceOrder, PlaceOrderDefinition, buildAuthoredErrorMessages, resolveErrorMessage };
+export { PLACE_ORDER_ERROR_FIELDS, PlaceOrder, PlaceOrderContent, PlaceOrderDefinition, resolveErrorMessage };
 
 //# sourceMappingURL=place-order.js.map