@12-apps/payments-frontend 3.22.0 → 3.23.1

package/src/flows/pipeline/context.ts

@@ -0,0 +1,140 @@
+/**
+ * THE CONTEXT EVERY PLUGIN READS, built once from the host's own hooks
+ * (FUT-1240).
+ *
+ * One builder, used by BOTH the engine and `flows.useAdmission()`, so the
+ * headless admission the cart drawer asks and the checkout the shopper reaches
+ * cannot disagree about the same shopper. That was the whole harm behind
+ * "three exemption sets": every surface answered "may this store take money"
+ * from its own reading of its own facts.
+ *
+ * Every field is server-owned or parked. Nothing here is React state the
+ * engine happens to hold — the engine layers its own on top with
+ * {@link withCheckoutState}, and only there.
+ */
+import type { CheckoutOrder } from "../../components/checkout/types";
+
+import { useResolvedConfig, type FlowsRuntime } from "../runtime";
+
+import type { CheckoutContext, CheckoutPipelineConfig } from "./types";
+
+/** No host `useIntent` ⇒ no one-click, no resume request, no preset method. */
+const NO_INTENT: CheckoutContext["intent"] = Object.freeze({
+  oneClick: false,
+  resuming: false,
+  presetMethod: null,
+});
+
+/** No host `useOpenPayable` ⇒ the server is never asked; the park still answers. */
+const NO_OPEN_PAYABLE: { order: CheckoutOrder | null; pending: boolean } = Object.freeze({
+  order: null,
+  pending: false,
+});
+
+/**
+ * The two reads only a HOST can answer: what the address bar asked for, and
+ * what the server says is already in flight.
+ *
+ * Its own function so the defaulting stays in one place — and so the base
+ * builder below reads as a list of facts rather than as a chain of `??`.
+ */
+function usePipelineReads(pipeline: CheckoutPipelineConfig): {
+  intent: CheckoutContext["intent"];
+  openPayable: { order: CheckoutOrder | null; pending: boolean };
+} {
+  const intent = pipeline.useIntent?.() ?? NO_INTENT;
+  const openPayable = pipeline.useOpenPayable?.() ?? NO_OPEN_PAYABLE;
+  return { intent, openPayable };
+}
+
+/** The base context plus the two reads a caller may need on their own. */
+interface CheckoutBase {
+  ctx: CheckoutContext;
+  openPayable: { order: CheckoutOrder | null; pending: boolean };
+  /** The buyer's saved details are still being fetched. */
+  buyerPending: boolean;
+}
+
+/**
+ * The host's facts, as a context.
+ *
+ * `method`, `order`, `outcome` and `slices` are at their resting values here:
+ * an admission decision is about the SHOPPER and the STORE, never about how
+ * far into a payment somebody is. The engine supplies the rest.
+ */
+export function useCheckoutBase(
+  runtime: FlowsRuntime,
+  pipeline: CheckoutPipelineConfig,
+): CheckoutBase {
+  const cart = runtime.config.useCart();
+  const defaults = runtime.config.useBuyerDefaults?.() ?? {};
+  const settlement = runtime.config.useSettlement?.() ?? null;
+  const { config, pending } = useResolvedConfig(runtime);
+  const tenantSlug = runtime.useTenantSlug();
+  const { intent, openPayable } = usePipelineReads(pipeline);
+  return {
+    ctx: {
+      ...(tenantSlug === undefined ? {} : { tenantSlug }),
+      config,
+      configPending: pending,
+      cart,
+      settlement,
+      ...buyerFacts(defaults),
+      ...AT_REST,
+      order: openPayable.order,
+      intent,
+    },
+    openPayable,
+    buyerPending: defaults.pending ?? false,
+  };
+}
+
+/** Nothing has been chosen, raised or answered yet. */
+const AT_REST = Object.freeze({
+  method: null,
+  outcome: null,
+  slices: Object.freeze({}),
+} as const);
+
+/** The buyer half, with the two absences that mean "the host wired none". */
+function buyerFacts(defaults: {
+  buyer?: CheckoutContext["buyer"];
+  taxIdOnFile?: boolean;
+}): Pick<CheckoutContext, "buyer" | "taxIdOnFile"> {
+  return {
+    buyer: defaults.buyer ?? {},
+    taxIdOnFile: defaults.taxIdOnFile ?? false,
+  };
+}
+
+/** What the ENGINE knows and the base does not. */
+interface CheckoutEngineState {
+  buyer: CheckoutContext["buyer"];
+  method: string | null;
+  order: CheckoutOrder | null;
+  outcome: CheckoutContext["outcome"];
+  slices: Readonly<Record<string, unknown>>;
+}
+
+/**
+ * The base context with the engine's own state laid over it.
+ *
+ * The BUYER is overlaid rather than merged: the shopper may have typed a CPF
+ * for this purchase over the one on file, and the whole of `checkout-skip-dados`
+ * turns on that replacement being visible to every later step.
+ */
+export function withCheckoutState(
+  base: CheckoutContext,
+  state: CheckoutEngineState,
+): CheckoutContext {
+  return {
+    ...base,
+    buyer: state.buyer,
+    method: state.method,
+    // The just-raised order wins over whatever the server or the park offered:
+    // it is the one this visit is actually paying.
+    order: state.order ?? base.order,
+    outcome: state.outcome,
+    slices: state.slices,
+  };
+}

package/src/flows/pipeline/derive-step.ts

@@ -0,0 +1,234 @@
+/**
+ * WHICH STEP THE SHOPPER IS ON — derived, never remembered (FUT-1240).
+ *
+ * The flat controller holds `useState<Step>`, so a reload, a discarded tab or
+ * a return from a provider's own page all forget where the shopper was. Here
+ * the answer is a function of facts the SERVER owns (the cart, the buyer's
+ * `hasTaxId`, the open payable) plus the steps' own declared slices, so it is
+ * the same answer before and after the page goes away.
+ *
+ * ## It reproduces `useCheckoutNav` exactly, and that is the point
+ *
+ * `checkout-actions.ts`'s nav has three rules that look like details and are
+ * not, because the money path walks through them:
+ *
+ *  - back off the payment step lands on Dados — UNLESS the buyer has a CPF on
+ *    file and has never opened Dados, in which case that step is not part of
+ *    their flow and the only honest destination is the catalog;
+ *  - "alterar" (`editBuyer`) exists ONLY for a buyer whose Dados was skipped,
+ *    and opening it makes Dados part of their flow from then on;
+ *  - back off the CONFIRMATION is the catalog, always. The flat nav maps back
+ *    to Dados only from `payment`; every other step goes to the menu.
+ *
+ * The first two fall out of one general rule here: **back re-opens the PREVIOUS
+ * APPLYING step, and exits when there is none.** A skipped Dados does not
+ * apply, so it is not the previous applying step, so back exits — which is the
+ * second rule verbatim. `editBuyer` flips the Dados slice's `opened`, after
+ * which Dados applies and back returns to it — which is the first.
+ *
+ * The third does NOT, and stating it separately is the whole of {@link
+ * deriveNav}'s `terminal`. A paid Pix order leaves its pane APPLYING — an order
+ * exists, nothing handed over — and merely COMPLETE, so the previous applying
+ * step behind the confirmation is the payment surface for money that already
+ * moved. Re-opening it puts a live pay button in front of a shopper who has
+ * paid, which is the hazard `ADOPTING.md` records under one owner paying four
+ * times.
+ */
+import type {
+  AnyCheckoutStep,
+  AnySettlementMethod,
+  CheckoutContext,
+  CheckoutStepPhase,
+} from "./types";
+
+/** Phases in walk order. A step's `order` breaks ties inside one phase. */
+const PHASE_ORDER: readonly CheckoutStepPhase[] = [
+  "details",
+  "before-pay",
+  "pay",
+  "after-pay",
+];
+
+/** Facts, by step id — the engine runs every `useFacts()` once, in array order. */
+type StepFacts = Readonly<Record<string, unknown>>;
+
+/** What a walk over the registered steps produced. */
+interface DerivedStep {
+  /** The step to render, or `null` when nothing applies yet. */
+  step: AnyCheckoutStep | null;
+  /** Every step that applies to THIS shopper, in walk order. */
+  applying: readonly AnyCheckoutStep[];
+  /** `step`'s index in {@link applying}, or `-1`. */
+  index: number;
+}
+
+/**
+ * The registered steps in walk order.
+ *
+ * Sorted stably: two steps in the same phase with the same `order` keep the
+ * order their arrays were merged in, so a host appending a step never reshuffles
+ * the package's own.
+ */
+function orderedSteps(steps: readonly AnyCheckoutStep[]): AnyCheckoutStep[] {
+  return steps
+    .map((step, at) => ({ step, at }))
+    .sort((left, right) => {
+      const phase =
+        PHASE_ORDER.indexOf(left.step.phase) - PHASE_ORDER.indexOf(right.step.phase);
+      if (phase !== 0) return phase;
+      const order = (left.step.order ?? 0) - (right.step.order ?? 0);
+      return order !== 0 ? order : left.at - right.at;
+    })
+    .map((entry) => entry.step);
+}
+
+/**
+ * THE NO-CHARGE RULE, stated once.
+ *
+ * A settlement method whose `raisesCharge` is `false` mounts no payment
+ * surface after it is chosen: no Dados-for-the-charge, no method pane, no
+ * poll. Enforced here rather than in each lane, because "each lane" is exactly
+ * how a delivery checkout ended up rendering a PIX pane for a shopper paying
+ * the courier.
+ *
+ * Unknown method ⇒ the rule does not fire. An id nobody registered cannot be
+ * asserted to raise no charge, and refusing the pay phase on a guess would
+ * strand a shopper mid-payment.
+ */
+export function raisesCharge(
+  method: string | null,
+  methods: readonly AnySettlementMethod[],
+): boolean {
+  if (method === null) return true;
+  const descriptor = methods.find((entry) => entry.id === method);
+  return descriptor ? descriptor.raisesCharge : true;
+}
+
+/**
+ * A step's slice, with the step's own `initial` standing in when the context
+ * carries none.
+ *
+ * The engine seeds every slice at mount, so in a live checkout this fallback
+ * never fires. It exists because `complete()` is a step author's function and
+ * must never be handed `undefined` where its type says `S` — a walk that
+ * throws while deciding where the shopper is would take the whole checkout
+ * with it, and the cause would be an absent key.
+ */
+export function sliceFor(step: AnyCheckoutStep, ctx: CheckoutContext): unknown {
+  const value = ctx.slices[step.id];
+  if (value !== undefined) return value;
+  return step.slice ? step.slice.initial(ctx) : undefined;
+}
+
+/** What `deriveStep` is asked. */
+interface DeriveStepInput {
+  steps: readonly AnyCheckoutStep[];
+  ctx: CheckoutContext;
+  facts: StepFacts;
+  methods: readonly AnySettlementMethod[];
+  /** A step the shopper navigated BACK to; it wins while it still applies. */
+  reopened?: string | null;
+}
+
+/**
+ * THE PANE RULE, stated once — the other half of the no-charge one.
+ *
+ * A `pay`-phase step that some registered method named as its
+ * {@link AnySettlementMethod.pane} belongs to THAT method: it applies while
+ * that method is the chosen one and never otherwise. A `pay` step nobody named
+ * — the hand-off interstitial, which is about the ORDER rather than about the
+ * method — is untouched by this.
+ *
+ * Stated here rather than as a `ctx.method === "PIX"` inside each pane, because
+ * a descriptor field that decides nothing is config that lies: `pane` was
+ * declared, documented and read nowhere while the two panes hard-coded the very
+ * ids it names.
+ */
+function paneApplies(
+  step: AnyCheckoutStep,
+  ctx: CheckoutContext,
+  methods: readonly AnySettlementMethod[],
+): boolean {
+  if (!methods.some((entry) => entry.pane === step.id)) return true;
+  const chosen = methods.find((entry) => entry.id === ctx.method);
+  return chosen?.pane === step.id;
+}
+
+/** The steps that apply to this shopper, with the no-charge rule already applied. */
+export function applyingSteps(input: DeriveStepInput): AnyCheckoutStep[] {
+  const { ctx, facts, methods } = input;
+  const charges = raisesCharge(ctx.method, methods);
+  return orderedSteps(input.steps).filter((step) => {
+    if (step.phase === "pay") {
+      if (!charges) return false;
+      if (!paneApplies(step, ctx, methods)) return false;
+    }
+    return step.applies(ctx, facts[step.id]);
+  });
+}
+
+/**
+ * The current step: the first applying step whose `complete()` is false, plus
+ * the one explicit override — a step the shopper pressed back into.
+ *
+ * All complete ⇒ the LAST applying step, which is the terminal one. The
+ * package's own confirmation answers `complete: false` forever, so this is a
+ * safety net rather than a path: a walk whose every step is finished has
+ * nowhere else to put the shopper.
+ */
+export function deriveStep(input: DeriveStepInput): DerivedStep {
+  const applying = applyingSteps(input);
+  const reopened = input.reopened ?? null;
+  const back = reopened === null ? -1 : applying.findIndex((step) => step.id === reopened);
+  if (back !== -1) return { step: applying[back] ?? null, applying, index: back };
+  const at = applying.findIndex(
+    (step) => !step.complete(input.ctx, input.facts[step.id], sliceFor(step, input.ctx)),
+  );
+  if (at !== -1) return { step: applying[at] ?? null, applying, index: at };
+  const last = applying.length - 1;
+  return { step: applying[last] ?? null, applying, index: last };
+}
+
+/** The ports `deriveNav` drives — the engine's own writers, named. */
+interface NavPorts {
+  /** Mark a step as the one the shopper went back to. */
+  reopen(stepId: string): void;
+  /** Open the buyer-details step for a shopper whose CPF made it skippable. */
+  openDados(): void;
+  /** Leave checkout for the host's catalog. */
+  exitToCatalog(): void;
+}
+
+/**
+ * `back` and `editBuyer`, reproducing `useCheckoutNav` (FUT-465, FUT-1216
+ * risk 2).
+ *
+ * `editBuyer` is `undefined` unless Dados was SKIPPED — the payer block keys
+ * off its presence, so the decision lives here rather than being re-derived by
+ * every caller, exactly as it did in the flat controller.
+ *
+ * `terminal` is `ctx.outcome !== null`, and it is the flat nav's "from `status`
+ * you go to the menu" — see the third rule at the top of this file. It is asked
+ * of the OUTCOME rather than of the last step's identity so that a host's own
+ * confirmation, and a FAILED or EXPIRED one, answer the same way: once this
+ * checkout has an outcome there is nothing behind it a shopper should be sent
+ * back into.
+ */
+export function deriveNav(input: {
+  applying: readonly AnyCheckoutStep[];
+  index: number;
+  taxIdOnFile: boolean;
+  /** The walk has an outcome — `ctx.outcome !== null`. */
+  terminal: boolean;
+  ports: NavPorts;
+}): { back(): void; editBuyer: (() => void) | undefined } {
+  const { applying, index, ports } = input;
+  const previous = input.terminal || index <= 0 ? undefined : applying[index - 1];
+  return {
+    back() {
+      if (previous) ports.reopen(previous.id);
+      else ports.exitToCatalog();
+    },
+    editBuyer: input.taxIdOnFile ? ports.openDados : undefined,
+  };
+}

package/src/flows/pipeline/engine-actions.ts

@@ -0,0 +1,257 @@
+/**
+ * WHAT THE ENGINE DOES WHEN A STEP ASKS (FUT-1240).
+ *
+ * One writer per fact, and every one of them here: choosing a method, raising
+ * the payable, passing the buyer-details gate, reporting a terminal status,
+ * navigating back and leaving. A step calls these; nothing else writes.
+ *
+ * The payable is raised in ONE place, for every settlement method. What
+ * differs for a method that raises no charge is not the call — it is that the
+ * engine parks nothing and treats the placement itself as the settlement, so
+ * the walk goes straight to the confirmation with no pane in between.
+ */
+import { useCallback, useMemo } from "react";
+
+import { buyerFieldsFor } from "../../components/checkout/buyer-fields";
+import { buyerGateError } from "../../components/checkout/buyer-gate";
+import { parkedBasket } from "../../components/checkout/basket";
+import type { CheckoutDecline } from "../../components/checkout/decline";
+import { forgetHostedOrder, rememberHostedOrder } from "../../components/checkout/hosted-return";
+import { handOffMethod, offeredMethods } from "../../components/checkout/method-capability";
+import type {
+  BuyerInfo,
+  CheckoutOrder,
+  CreateOrderRequest,
+  OrderStatus,
+  PaymentMethod,
+} from "../../components/checkout/types";
+import { useCatalogExit } from "../catalog-exit";
+import type { FlowsRuntime } from "../runtime";
+
+import { applyingSteps, raisesCharge, sliceFor } from "./derive-step";
+import type { EngineStore } from "./engine-state";
+import { isPackageMethod } from "./methods";
+import {
+  BUYER_FIELD_CODE,
+  DADOS_STEP_ID,
+  METHOD_STEP_ID,
+  dadosSliceOf,
+} from "./steps";
+import type {
+  AnyCheckoutGate,
+  AnyCheckoutStep,
+  AnySettlementMethod,
+  CheckoutContext,
+} from "./types";
+
+/** Everything one factory's engine closes over. Built once, never per render. */
+export interface PipelineWiring {
+  steps: readonly AnyCheckoutStep[];
+  gates: readonly AnyCheckoutGate[];
+  methods: readonly AnySettlementMethod[];
+}
+
+/**
+ * The `method` the WIRE carries for a settlement this package cannot name.
+ *
+ * `method` is what the CHAIN can be asked to charge, so a host's registered id
+ * is never one of its values: the chain's own hand-off method is what the
+ * server will honour, exactly as it is for a store whose buyer was never asked.
+ *
+ * WHICH settlement the buyer actually chose rides {@link settlementOnWire}
+ * beside it. It has to: `method` alone makes a courier, a waiter and a Pix
+ * charge the same request, and `raisesCharge: false` is the capability this
+ * step exists for.
+ */
+function wireMethod(id: string, ctx: CheckoutContext): PaymentMethod {
+  return isPackageMethod(id) ? id : handOffMethod(offeredMethods(ctx.config));
+}
+
+/**
+ * The chosen id, for a settlement the two package methods do not cover.
+ *
+ * ABSENT for `PIX` and `CARD` — a host reading only `method` reads exactly the
+ * request it read before this field existed, which is the whole of the wire
+ * staying additive. A step that wants to say something else still can: its
+ * `contribute` returns `Partial<CreateOrderRequest>`, and the contributions are
+ * folded over this base.
+ */
+function settlementOnWire(id: string): Pick<CreateOrderRequest, "settlementMethod"> {
+  return isPackageMethod(id) ? {} : { settlementMethod: id };
+}
+
+/** The create request: the method, the buyer, and whatever each step contributes. */
+function createRequest(input: {
+  ctx: CheckoutContext;
+  applying: readonly AnyCheckoutStep[];
+  stepFacts: Readonly<Record<string, unknown>>;
+  saveProfile: boolean;
+  methodId: string;
+}): CreateOrderRequest {
+  const base: CreateOrderRequest = {
+    method: wireMethod(input.methodId, input.ctx),
+    buyer: input.ctx.buyer,
+    saveProfile: input.saveProfile,
+    ...settlementOnWire(input.methodId),
+  };
+  return input.applying.reduce<CreateOrderRequest>(
+    (request, step) => ({
+      ...request,
+      ...step.contribute?.(input.ctx, input.stepFacts[step.id], sliceFor(step, input.ctx)),
+    }),
+    base,
+  );
+}
+
+/** What the writers need from the render they were built in. */
+interface EngineWritersInput {
+  runtime: FlowsRuntime;
+  wiring: PipelineWiring;
+  store: EngineStore;
+  ctx: CheckoutContext;
+  stepFacts: Readonly<Record<string, unknown>>;
+}
+
+/** The engine's writers. */
+interface EngineWriters {
+  choose(methodId: string): void;
+  place(): void;
+  continueFromDados(): void;
+  setBuyer(buyer: BuyerInfo): void;
+  setSaveProfile(save: boolean): void;
+  resolve(status: OrderStatus, decline?: CheckoutDecline | null): void;
+  adoptOrder(order: CheckoutOrder): void;
+  exitToCatalog(): void;
+  reopen(stepId: string): void;
+  openDados(): void;
+  retry(): void;
+}
+
+/** Raise the payable, park it when it can be resumed, and record what came back. */
+function usePlaceOrder(input: EngineWritersInput): (methodId?: string) => Promise<void> {
+  const { runtime, store, ctx, wiring, stepFacts } = input;
+  const saveProfile = store.state.saveProfile;
+  return useCallback(
+    async (methodId?: string) => {
+      const chosen = methodId ?? ctx.method;
+      if (chosen === null) return;
+      store.patch({ placing: true, error: null, decline: null });
+      // The walk is re-derived FOR THE CHOSEN METHOD, not read off the render
+      // that offered the picker: a step whose `applies` asks which settlement
+      // this is would otherwise be absent from the request that settles it.
+      // ONE context, used for both halves. Deriving the walk against the chosen
+      // method and then building the request against the un-overridden `ctx` let
+      // a step's `contribute` read `ctx.method === null` on the immediate-place
+      // path, which is the path a method with no Review takes — so the field
+      // ADOPTING.md says a step may set "when the settlement has a finer name
+      // than the tile does" was written from a context that did not know it.
+      const applyingCtx = { ...ctx, method: chosen };
+      const applying = applyingSteps({
+        steps: wiring.steps,
+        ctx: applyingCtx,
+        facts: stepFacts,
+        methods: wiring.methods,
+      });
+      const request = createRequest({
+        ctx: applyingCtx,
+        applying,
+        stepFacts,
+        saveProfile,
+        methodId: chosen,
+      });
+      const result = await runtime.config.ports.createPayable(request);
+      if (!result.ok) {
+        store.patch({ placing: false, error: result.error });
+        return;
+      }
+      const charges = raisesCharge(chosen, wiring.methods);
+      // PARKED ON EVERY RAISE (FUT-1140), with the STORE and the BASKET — a
+      // low-memory phone discards this tab while the shopper is in their bank
+      // app. A settlement that raises no charge has nothing to come back to.
+      if (charges) {
+        rememberHostedOrder(result.data, {
+          ...(ctx.tenantSlug === undefined ? {} : { tenantSlug: ctx.tenantSlug }),
+          basket: parkedBasket(ctx.cart.identity),
+          handoff: false,
+        });
+      }
+      store.patch({
+        placing: false,
+        order: result.data,
+        // Placing IS the settlement for a no-charge method, so its own status
+        // is already the outcome — there is no pane and no poll to wait for.
+        outcome: charges ? null : result.data.status,
+      });
+    },
+    [runtime, store, ctx, wiring, stepFacts, saveProfile],
+  );
+}
+
+/** "Continuar" on the buyer-details step: gate on the chain's demands, then persist. */
+function useContinueFromDados(input: EngineWritersInput): () => void {
+  const { runtime, store, ctx } = input;
+  const copy = runtime.config.copy.views.screens.screens.validation;
+  const fields = useMemo(() => buyerFieldsFor(ctx.config?.chain, null), [ctx.config]);
+  return useCallback(() => {
+    const complaint = buyerGateError(copy, ctx.buyer, fields, ctx.taxIdOnFile);
+    if (complaint) {
+      store.patch({
+        error: { code: BUYER_FIELD_CODE, message: complaint.message, field: complaint.field },
+      });
+      return;
+    }
+    // The write happens HERE and not when a payment is raised: everything after
+    // this step can fail, and the details must survive all of it (FUT-465).
+    if (store.state.saveProfile) {
+      runtime.config.ports.saveBuyerContact?.({
+        ...(ctx.buyer.name === undefined ? {} : { name: ctx.buyer.name }),
+        ...(ctx.buyer.phone === undefined ? {} : { phone: ctx.buyer.phone }),
+        ...(ctx.buyer.taxId === undefined ? {} : { taxId: ctx.buyer.taxId }),
+      });
+    }
+    store.setSlice(DADOS_STEP_ID, { ...dadosSliceOf(ctx), done: true });
+    store.patch({ reopened: null, error: null });
+  }, [copy, ctx, fields, runtime, store]);
+}
+
+/** Every writer, bound to this render's context. */
+export function useEngineWriters(input: EngineWritersInput): EngineWriters {
+  const { runtime, store, ctx, wiring } = input;
+  const placeOrder = usePlaceOrder(input);
+  const continueFromDados = useContinueFromDados(input);
+  const exitToCatalog = useCatalogExit(runtime);
+  const choose = useCallback(
+    (methodId: string) => {
+      // A different method means the order raised for the previous one is
+      // gone — and the parked entry with it, scoped to THIS store so another
+      // store's checkout in the same tab keeps its own.
+      store.setSlice(METHOD_STEP_ID, { chosen: methodId });
+      store.patch({ order: null, error: null, decline: null, reopened: null });
+      forgetHostedOrder(ctx.tenantSlug);
+      const descriptor = wiring.methods.find((entry) => entry.id === methodId);
+      if (!descriptor?.Review) void placeOrder(methodId);
+    },
+    [store, ctx.tenantSlug, wiring.methods, placeOrder],
+  );
+  return useMemo(
+    () => ({
+      choose,
+      continueFromDados,
+      exitToCatalog,
+      place: () => void placeOrder(),
+      setBuyer: (buyer: BuyerInfo) =>
+        store.patch({ buyer, buyerTouched: true, error: null }),
+      setSaveProfile: (saveProfile: boolean) => store.patch({ saveProfile }),
+      resolve: (status: OrderStatus, decline?: CheckoutDecline | null) =>
+        store.patch({ outcome: status, decline: decline ?? null, reopened: null, error: null }),
+      adoptOrder: (order: CheckoutOrder) => store.patch({ order, error: null }),
+      reopen: (stepId: string) => store.patch({ reopened: stepId }),
+      openDados: () => {
+        store.setSlice(DADOS_STEP_ID, { opened: true, done: false });
+        store.patch({ reopened: null, error: null });
+      },
+      retry: () => store.patch({ error: null, decline: null, reopened: null }),
+    }),
+    [choose, continueFromDados, exitToCatalog, placeOrder, store],
+  );
+}