@12-apps/payments-frontend 3.41.0 → 3.43.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@12-apps/payments-frontend",
-  "version": "3.41.0",
+  "version": "3.43.0",
   "type": "module",
   "sideEffects": false,
   "description": "Browser half of the vendor-agnostic payments platform: plug-and-play MUI components for the per-provider settings page (credential form from each provider's schema, masked hints, verify/enable) and the checkout page (PIX QR + polling, card tokenization, hosted-checkout redirect), plus the headless hooks and fetch clients they build on. Talks only to the host's payments HTTP surface — never to a provider directly. Microfrontend-ready: no app coupling, host injects theme and auth.",
@@ -23,7 +23,7 @@
     "storybook:build": "storybook build"
   },
   "dependencies": {
-    "@12-apps/payments-backend": "^4.31.0",
+    "@12-apps/payments-backend": "^4.33.0",
     "react-qr-code": "^2.2.0"
   },
   "peerDependencies": {

package/src/activation/use-redirect-activation.ts

@@ -143,9 +143,10 @@ interface ActivationCallbacks {
  * provider's page and gives up at `pollTimeoutMs` (ten minutes by default).
  *
  * Where it is recorded: the origin host's realtime doc ("Allowed exceptions")
- * and the decision record that superseded its 0071 with it. If activation
- * ever becomes webhook-only, this relaxes to the channel exactly as the
- * checkout's waits did (FUT-649) and the exception goes away.
+ * and a decision record that amends ADR 0071 with it. This bounded third-party
+ * wait is an amendment to that ADR, not a supersession: 0071 still stands for
+ * every other wait. If activation ever becomes webhook-only, this relaxes to
+ * the channel exactly as the checkout's waits did and the exception goes away.
  *
  * The give-up is a `failed` state carrying the host's own sentence, because the
  * wording is load-bearing: the charge is STILL valid, and an owner who has

package/src/card/pagbank-test-cards.ts

@@ -0,0 +1,50 @@
+/**
+ * PagBank's OFFICIAL sandbox test cards (developer.pagbank.com.br, "Cartões de
+ * teste") — the only cards the homologação evidence may use (FUT-3696).
+ *
+ * Public test data, published by PagBank for exactly this: they authorize
+ * nothing outside the sandbox. They are never sent to our server — the browser
+ * encrypts them and only the encrypted blob leaves it.
+ */
+interface PagBankTestCard {
+  scenario: "approved" | "declined";
+  brand: string;
+  number: string;
+  holder: string;
+  expMonth: string;
+  expYear: string;
+  securityCode: string;
+}
+
+/**
+ * December of NEXT year. PagBank's page prints 12/2026 as the example expiry,
+ * and the sandbox accepts any future date; a literal would turn every run
+ * after that month into a "card expired" evidence for a reason nobody chose.
+ */
+const TEST_EXPIRY_YEAR = String(new Date().getFullYear() + 1);
+
+export const PAGBANK_TEST_CARDS: readonly PagBankTestCard[] = [
+  {
+    scenario: "approved",
+    brand: "VISA",
+    number: "4539620659922097",
+    holder: "Jose da Silva",
+    expMonth: "12",
+    expYear: TEST_EXPIRY_YEAR,
+    securityCode: "123",
+  },
+  {
+    scenario: "declined",
+    brand: "VISA",
+    number: "4929291898380766",
+    holder: "Jose da Silva",
+    expMonth: "12",
+    expYear: TEST_EXPIRY_YEAR,
+    securityCode: "123",
+  },
+];
+
+/** `4539 62** **** 2097` — the first six and last four, as a receipt prints them. */
+export function maskTestCard(number: string): string {
+  return `${number.slice(0, 4)} ${number.slice(4, 6)}** **** ${number.slice(-4)}`;
+}

package/src/card/tokenize.ts

@@ -335,3 +335,29 @@ function mintToken(prefix: string): string {
   tokenCounter += 1;
   return `${prefix}_${Date.now().toString(36)}${tokenCounter.toString(36)}`;
 }
+
+/** Why {@link encryptPagBankCard} produced no blob. */
+type PagBankEncryptFailure = "SDK_UNAVAILABLE" | "NOT_PROCESSED";
+
+/**
+ * Encrypt a card with PagBank's own browser SDK — the same script and the same
+ * `PagSeguro.encryptCard` call the checkout's {@link tokenizeCard} makes, minus
+ * the buyer-form validation and copy. For the homologação evidence (FUT-3696),
+ * which encrypts PagBank's official TEST cards and must prove the flow the
+ * checkout really uses: the PAN never leaves the browser, only the blob does.
+ */
+export async function encryptPagBankCard(params: {
+  publicKey: string;
+  holder: string;
+  number: string;
+  expMonth: string;
+  expYear: string;
+  securityCode: string;
+}): Promise<{ encrypted: string } | { failure: PagBankEncryptFailure }> {
+  if (!(await ensurePagBankSdk()) || !window.PagSeguro?.encryptCard) {
+    return { failure: "SDK_UNAVAILABLE" };
+  }
+  const result = window.PagSeguro.encryptCard(params);
+  if (result.hasErrors || !result.encryptedCard) return { failure: "NOT_PROCESSED" };
+  return { encrypted: result.encryptedCard };
+}

package/src/components/checkout/poll-live.ts

@@ -23,7 +23,13 @@
  * - A wait given {@link LiveCadence.liveIntervalMs} keeps that floor. The hook
  *   gives it one only on a hosted-checkout return carrying the settlement pair
  *   (`carriesSettlementPair`), where the buyer's own read is what confirms the
- *   payment and no server sweep can stand in for it.
+ *   payment and no server sweep can stand in for it. That floor is a timed
+ *   read on a live channel — a bounded wait on a THIRD PARTY, the provider the
+ *   buyer just paid — and it is recorded as one: the origin host's realtime
+ *   doc lists it under "Allowed exceptions", beside the redirect activation's
+ *   verify (`../../activation/use-redirect-activation.ts`), with the decision
+ *   that admits the class. If the provider's webhook ever settles every
+ *   return, the floor goes and the return waits on the channel like the rest.
  *
  * Split out of `poll-loop.ts` so the loop stays one question: WHEN to ask. This
  * file answers only how being live changes that answer.

package/src/components/platform/ConnectApplicationPanel.tsx

@@ -3,11 +3,17 @@
 import { Box, Button, Stack, Typography } from '@mui/material';
 import type { ReactNode } from 'react';
 
-import type { ConnectApplicationReport, PaymentEnvironment } from '@12-apps/payments-backend';
+import type {
+  ConnectApplicationReport,
+  ConnectApplicationStatus,
+  PastedConnectCredentials,
+  PaymentEnvironment,
+} from '@12-apps/payments-backend';
 
-import { CARD_SX, ConnectEnvironmentCard } from './ConnectEnvironmentCard';
+import { CARD_SX, ConnectEnvironmentCard, TAP_SX } from './ConnectEnvironmentCard';
 import type { PlatformHomologacaoCopy } from './copy';
 import { PlatformCopyProvider, usePlatformCopy } from './copy-context';
+import { PastedCredentialsCard } from './PastedCredentialsCard';
 
 /**
  * The platform's PagBank Connect application, per environment (FUT-479,
@@ -41,9 +47,17 @@ export interface ConnectApplicationPanelProps {
   /**
    * Which host-side variables feed one environment's application — the host's
    * own configuration surface, rendered as a collapsible per-environment help
-   * when provided.
+   * when provided. ORDER MATTERS: the first three name the client id, the
+   * client secret and the account token, in that order — the credential
+   * preview and the paste fields are labelled by position.
    */
   configVarsFor?: (environment: PaymentEnvironment) => string[];
+  /**
+   * Consult with PASTED credentials — the host's mounted call to the backend's
+   * `consultPastedConnectApplication`, resolving to the status it answered.
+   * Omitted, the paste block is not rendered.
+   */
+  onConsultPasted?: (pasted: PastedConnectCredentials) => Promise<ConnectApplicationStatus>;
   /** Every word this panel and its environment cards render. REQUIRED. */
   copy: PlatformHomologacaoCopy;
 }
@@ -57,12 +71,12 @@ export function ConnectApplicationPanel(props: ConnectApplicationPanelProps): Re
 }
 
 function ConnectApplicationBody(props: ConnectApplicationPanelProps): ReactNode {
-  const { report, onRefresh, configVarsFor } = props;
+  const { report, onRefresh, configVarsFor, onConsultPasted } = props;
   const copy = usePlatformCopy().connect;
   return (
     <Stack spacing={2} data-testid="connect-application-panel">
       <Stack spacing={0.5} data-testid="connect-expected-redirect" sx={CARD_SX}>
-        <Typography variant="caption" color="text.secondary" fontWeight={600}>
+        <Typography variant="caption" fontWeight={600}>
           {copy.expectedRedirectHeading}
         </Typography>
         <Box
@@ -79,6 +93,9 @@ function ConnectApplicationBody(props: ConnectApplicationPanelProps): ReactNode
           configVars={configVarsFor?.(status.environment)}
         />
       ))}
+      {onConsultPasted ? (
+        <PastedCredentialsCard onConsult={onConsultPasted} configVarsFor={configVarsFor} />
+      ) : null}
       {onRefresh ? (
         <Box>
           <Button
@@ -86,6 +103,7 @@ function ConnectApplicationBody(props: ConnectApplicationPanelProps): ReactNode
             size="small"
             onClick={() => onRefresh()}
             data-testid="connect-refresh"
+            sx={TAP_SX}
           >
             {copy.consultAgain}
           </Button>

package/src/components/platform/ConnectEnvironmentCard.tsx

@@ -1,9 +1,13 @@
 'use client';
 
 import { Alert, Box, Button, Stack, Typography } from '@mui/material';
-import { useState, type ReactNode } from 'react';
+import { Fragment, useState, type ReactNode } from 'react';
 
-import type { ConnectApplicationStatus, PaymentEnvironment } from '@12-apps/payments-backend';
+import type {
+  ConnectApplicationStatus,
+  ConnectCredentialPreview,
+  PaymentEnvironment,
+} from '@12-apps/payments-backend';
 import { usePlatformCopy } from './copy-context';
 
 /**
@@ -11,17 +15,15 @@ import { usePlatformCopy } from './copy-context';
  * Sandbox and production are SEPARATE applications with separate id/secret
  * pairs, so each card stands on its own: configured or not, what PagBank says
  * is registered, and whether the registered redirect URI matches the
- * deployment's callback.
+ * deployment's callback — plus the first characters of each value it was
+ * consulted with, so an operator can tell WHICH id, secret and token are in play.
  *
- * English, like the rest of this platform surface (FUT-760) — see
- * `ConnectApplicationPanel` for why.
+ * The same card renders the answer to a PASTED consult, so its test ids key on
+ * a `slot` — the environment for the host's two cards, `PASTED` for that one —
+ * rather than on the environment, which the pasted answer shares with one of
+ * them.
  */
 
-const ENV_LABEL: Record<PaymentEnvironment, string> = {
-  SANDBOX: 'Sandbox',
-  PRODUCTION: 'Production',
-};
-
 /** The bordered-card look every block of these screens shares. */
 export const CARD_SX = {
   border: 1,
@@ -30,13 +32,32 @@ export const CARD_SX = {
   p: 2,
 } as const;
 
+/** A small button that is still a 40px tap target on a phone. */
+export const TAP_SX = { minHeight: { xs: 40, sm: 'auto' } } as const;
+
+/**
+ * A label like `PAGBANK_OAUTH_CLIENT_SECRET` is one token, so a narrow card
+ * would break it anywhere ("…SECRE / T"). A `<wbr>` after each underscore lets
+ * it wrap at the word joints instead.
+ */
+function breakAfterUnderscores(label: string): ReactNode {
+  return label.split(/(?<=_)/).map((part, index) => (
+    // The parts are positional by construction; the label never reorders.
+    <Fragment key={index}>
+      {part}
+      <wbr />
+    </Fragment>
+  ));
+}
+
 function Field({ label, children }: { label: string; children: ReactNode }): ReactNode {
   return (
     <Box
-      sx={{ display: 'flex', flexDirection: 'column', gap: 0.25, minWidth: 180, wordBreak: 'break-all' }}
+      // Whole words stay whole; only an unbroken id or URL breaks mid-run.
+      sx={{ display: 'flex', flexDirection: 'column', gap: 0.25, minWidth: 180, overflowWrap: 'anywhere' }}
     >
-      <Typography variant="caption" color="text.secondary" fontWeight={600}>
-        {label}
+      <Typography variant="caption" fontWeight={600}>
+        {breakAfterUnderscores(label)}
       </Typography>
       <Typography component="span" variant="body2">
         {children}
@@ -46,32 +67,32 @@ function Field({ label, children }: { label: string; children: ReactNode }): Rea
 }
 
 /** The verdict the screen exists for: does the registered callback match ours? */
-function MismatchAlert({ status }: { status: ConnectApplicationStatus }): ReactNode {
+function MismatchAlert({ status, slot }: { status: ConnectApplicationStatus; slot: string }): ReactNode {
   const copy = usePlatformCopy().connect;
   if (status.application === null) return null;
   if (status.redirectUriMismatch === true) {
     return (
-      <Alert severity="error" data-testid={`connect-mismatch-${status.environment}`}>
+      <Alert severity="error" data-testid={`connect-mismatch-${slot}`}>
         {copy.redirectDiffers}
       </Alert>
     );
   }
   if (status.redirectUriMismatch === false) {
     return (
-      <Alert severity="success" data-testid={`connect-match-${status.environment}`}>
+      <Alert severity="success" data-testid={`connect-match-${slot}`}>
         {copy.redirectMatches}
       </Alert>
     );
   }
   return (
-    <Alert severity="warning" data-testid={`connect-unknown-${status.environment}`}>
+    <Alert severity="warning" data-testid={`connect-unknown-${slot}`}>
       {copy.redirectUnreported}
     </Alert>
   );
 }
 
 /** What PagBank reports as registered, plus whatever extra keys came back. */
-function ApplicationFields({ status }: { status: ConnectApplicationStatus }): ReactNode {
+function ApplicationFields({ status, slot }: { status: ConnectApplicationStatus; slot: string }): ReactNode {
   const copy = usePlatformCopy().connect;
   const app = status.application;
   if (app === null) return null;
@@ -88,8 +109,8 @@ function ApplicationFields({ status }: { status: ConnectApplicationStatus }): Re
         </Field>
       </Box>
       {extraKeys.length > 0 ? (
-        <Box data-testid={`connect-extra-${status.environment}`}>
-          <Typography variant="caption" color="text.secondary" fontWeight={600}>
+        <Box data-testid={`connect-extra-${slot}`}>
+          <Typography variant="caption" fontWeight={600}>
             {copy.extraKeys}
           </Typography>
           <Box component="pre" sx={{ m: 0, fontSize: 12, overflowX: 'auto' }}>
@@ -101,6 +122,69 @@ function ApplicationFields({ status }: { status: ConnectApplicationStatus }): Re
   );
 }
 
+const EMPTY_PREVIEW: ConnectCredentialPreview = {
+  clientId: null,
+  clientSecret: null,
+  accountToken: null,
+};
+
+/** One previewed value: unset, inherited from a fallback variable, or its own. */
+function PreviewValue({ value, inherited }: { value: string | null; inherited: boolean }): ReactNode {
+  const copy = usePlatformCopy().connect;
+  if (value === null) return copy.previewUnset;
+  const code = (
+    <Box component="code" sx={{ fontFamily: 'monospace', fontSize: 13 }}>
+      {`${value}…`}
+    </Box>
+  );
+  if (!inherited) return code;
+  return (
+    <>
+      {copy.previewInherited} {code}
+    </>
+  );
+}
+
+/**
+ * The first characters of each value the application was consulted with —
+ * never the value. Each is named by the host's own variable when it supplies
+ * them (`configVars`, in id / secret / token order), by the copy's names when not.
+ */
+function CredentialPreview({
+  status,
+  slot,
+  configVars,
+}: {
+  status: ConnectApplicationStatus;
+  slot: string;
+  configVars?: string[];
+}): ReactNode {
+  const copy = usePlatformCopy().connect;
+  // A payload from a backend older than the preview carries none — render it unset, never crash.
+  const preview = status.credentialPreview ?? EMPTY_PREVIEW;
+  const names = copy.credentialNames;
+  const fields = ['clientId', 'clientSecret', 'accountToken'] as const;
+  const rows = fields.map((field, index) => ({
+    name: configVars?.[index] ?? names[field],
+    value: preview[field],
+    inherited: preview.inherited?.includes(field) ?? false,
+  }));
+  return (
+    <Stack spacing={1} data-testid={`connect-preview-${slot}`}>
+      <Typography variant="caption" fontWeight={600}>
+        {copy.previewHeading}
+      </Typography>
+      <Box sx={{ display: 'flex', flexWrap: 'wrap', gap: 2.5 }}>
+        {rows.map(({ name, value, inherited }) => (
+          <Field key={name} label={name}>
+            <PreviewValue value={value} inherited={inherited} />
+          </Field>
+        ))}
+      </Box>
+    </Stack>
+  );
+}
+
 /**
  * The collapsible "what feeds this environment" help. The variable names are
  * the HOST's own configuration surface, so they arrive via `configVars`; with
@@ -123,6 +207,7 @@ function ConfigHelp({
         size="small"
         onClick={() => setOpen((value) => !value)}
         data-testid={`connect-config-toggle-${environment}`}
+        sx={TAP_SX}
       >
         {open ? copy.hideConfig : copy.showConfig}
       </Button>
@@ -149,18 +234,30 @@ function ConfigHelp({
 export function ConnectEnvironmentCard({
   status,
   configVars,
+  slot = status.environment,
+  showConfigHelp = true,
 }: {
   status: ConnectApplicationStatus;
   configVars?: string[];
+  /** What the test ids key on — see the module doc. */
+  slot?: string;
+  /** The variable help belongs to a host-configured environment, not a pasted answer. */
+  showConfigHelp?: boolean;
 }): ReactNode {
   const copy = usePlatformCopy().connect;
   return (
-    <Stack spacing={1.5} data-testid={`connect-env-${status.environment}`} sx={CARD_SX}>
-      <Box sx={{ display: 'flex', alignItems: 'baseline', gap: 1.5, wordBreak: 'break-all' }}>
-        <Typography variant="body2" fontWeight={600}>
-          {ENV_LABEL[status.environment]}
+    <Stack spacing={1.5} data-testid={`connect-env-${slot}`} sx={CARD_SX}>
+      {/* The label never yields to a long client_id: the id wraps beneath it. */}
+      <Box sx={{ display: 'flex', flexWrap: 'wrap', alignItems: 'baseline', columnGap: 1.5 }}>
+        <Typography variant="body2" fontWeight={600} sx={{ whiteSpace: 'nowrap' }}>
+          {copy.environmentLabels[status.environment]}
         </Typography>
-        <Typography component="span" variant="caption" color="text.secondary">
+        <Typography
+          component="span"
+          variant="caption"
+          color="text.secondary"
+          sx={{ wordBreak: 'break-all', minWidth: 0 }}
+        >
           {status.clientId !== null ? `client_id: ${status.clientId}` : ''}
         </Typography>
       </Box>
@@ -168,13 +265,14 @@ export function ConnectEnvironmentCard({
         <Typography variant="body2" color="text.secondary">{copy.noApplication}</Typography>
       ) : null}
       {status.error !== null ? (
-        <Alert severity="warning" data-testid={`connect-error-${status.environment}`}>
+        <Alert severity="warning" data-testid={`connect-error-${slot}`}>
           {status.error}
         </Alert>
       ) : null}
-      <MismatchAlert status={status} />
-      <ApplicationFields status={status} />
-      <ConfigHelp environment={status.environment} configVars={configVars} />
+      <MismatchAlert status={status} slot={slot} />
+      <ApplicationFields status={status} slot={slot} />
+      <CredentialPreview status={status} slot={slot} configVars={configVars} />
+      {showConfigHelp ? <ConfigHelp environment={status.environment} configVars={configVars} /> : null}
     </Stack>
   );
 }

package/src/components/platform/HomologacaoEvidenceCard.tsx

@@ -0,0 +1,277 @@
+'use client';
+
+import { Alert, Box, Button, LinearProgress, Stack, Typography } from '@mui/material';
+import { useState, type ReactNode } from 'react';
+
+import type {
+  BrowserCardResult,
+  EvidenceSummary,
+  PaymentEnvironment,
+} from '@12-apps/payments-backend';
+
+import { maskTestCard, PAGBANK_TEST_CARDS } from '../../card/pagbank-test-cards';
+import { encryptPagBankCard } from '../../card/tokenize';
+import { CARD_SX, TAP_SX } from './ConnectEnvironmentCard';
+import type { PlatformHomologacaoCopy } from './copy';
+import { PlatformCopyProvider, usePlatformCopy } from './copy-context';
+
+/**
+ * The homologação EVIDENCE card (FUT-3696): connect a sandbox test seller,
+ * then run the real scenarios and download the TXT PagBank's form takes.
+ *
+ * The one thing this card does itself is the part that has to happen in a
+ * browser: encrypting PagBank's official TEST cards with the seller's public
+ * key, through the same SDK call the checkout makes. Everything else is the
+ * host's — each callback is a call to its own mounted routes — and what the
+ * file says is decided by the server, from what was recorded. This card shows
+ * the counts it answered and never infers a result of its own.
+ */
+
+/** The test seller's connection, as the host reads it back. */
+export interface HomologacaoSellerView {
+  connected: boolean;
+  environment: PaymentEnvironment | null;
+  /** UNVERIFIED | VERIFIED | FAILED | RECONNECT_REQUIRED. */
+  status: string | null;
+  connectedAt: string | null;
+  accountId: string | null;
+  /** Why the latest authorization did not complete, as the evidence recorded it. */
+  lastConnectProblem?: string | null;
+}
+
+export interface HomologacaoEvidenceCardProps {
+  copy: PlatformHomologacaoCopy;
+  /** Null while the host is still reading it. */
+  seller: HomologacaoSellerView | null;
+  /** How the last return from PagBank ended, when the page was opened by one. */
+  connectOutcome?: 'connected' | 'failed' | null;
+  /** Start the authorization: the host mints the state and navigates away. */
+  onConnect: () => Promise<void>;
+  /** Phase 1 — the seller's public key, null when it could not be minted. */
+  onPrepare: () => Promise<{ runId: string; publicKey: string | null }>;
+  /** Phase 2 — raise the orders with the encrypted cards. */
+  onRun: (runId: string, cards: BrowserCardResult[]) => Promise<void>;
+  /** Build and deliver the file; resolves to the counts it holds. */
+  onDownload: () => Promise<EvidenceSummary>;
+}
+
+type Phase = 'idle' | 'preparing' | 'encrypting' | 'running' | 'downloading';
+type ActivePhase = Exclude<Phase, 'idle'>;
+
+/** Each official test card, encrypted — or the code saying why it is not. */
+async function encryptTestCards(publicKey: string | null): Promise<BrowserCardResult[]> {
+  const results: BrowserCardResult[] = [];
+  for (const card of PAGBANK_TEST_CARDS) {
+    const base = { scenario: card.scenario, brand: card.brand, masked: maskTestCard(card.number) };
+    if (!publicKey) {
+      results.push({ ...base, encrypted: null, failure: 'NO_PUBLIC_KEY' });
+      continue;
+    }
+    const encrypted = await encryptPagBankCard({
+      publicKey,
+      holder: card.holder,
+      number: card.number,
+      expMonth: card.expMonth,
+      expYear: card.expYear,
+      securityCode: card.securityCode,
+    });
+    results.push(
+      'encrypted' in encrypted
+        ? { ...base, encrypted: encrypted.encrypted }
+        : { ...base, encrypted: null, failure: encrypted.failure },
+    );
+  }
+  return results;
+}
+
+export function HomologacaoEvidenceCard(props: HomologacaoEvidenceCardProps): ReactNode {
+  return (
+    <PlatformCopyProvider copy={props.copy}>
+      <EvidenceBody {...props} />
+    </PlatformCopyProvider>
+  );
+}
+
+/** The seller's one-line state — null while the host is still reading it. */
+function sellerLine(copy: PlatformHomologacaoCopy['evidence'], seller: HomologacaoSellerView | null): string | null {
+  if (!seller) return null;
+  if (seller.status === 'RECONNECT_REQUIRED') return copy.sellerReconnect;
+  return seller.connected ? copy.sellerConnected(seller.connectedAt, seller.accountId) : copy.sellerNotConnected;
+}
+
+function SellerBlock({
+  seller,
+  onConnect,
+}: Pick<HomologacaoEvidenceCardProps, 'seller' | 'onConnect'>): ReactNode {
+  const copy = usePlatformCopy().evidence;
+  const [failed, setFailed] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const line = sellerLine(copy, seller);
+  const offerReconnect = Boolean(seller?.connected) && seller?.status !== 'RECONNECT_REQUIRED';
+  const connect = (): void => {
+    setBusy(true);
+    setFailed(false);
+    onConnect()
+      .catch(() => setFailed(true))
+      .finally(() => setBusy(false));
+  };
+  return (
+    <Stack spacing={1} data-testid="evidence-seller">
+      <Typography variant="body2" fontWeight={600}>
+        {copy.sellerHeading}
+      </Typography>
+      {line ? (
+        <Typography variant="body2" data-testid="evidence-seller-state">
+          {line}
+        </Typography>
+      ) : null}
+      <Typography variant="caption" component="p" color="text.secondary">
+        {copy.connectHint}
+      </Typography>
+      <Box>
+        <Button
+          // The next step until a seller is connected; secondary once one is.
+          variant={offerReconnect ? 'outlined' : 'contained'}
+          size="small"
+          disabled={!seller || busy}
+          onClick={connect}
+          data-testid="evidence-connect"
+          sx={TAP_SX}
+        >
+          {offerReconnect ? copy.reconnect : copy.connect}
+        </Button>
+      </Box>
+      {failed ? (
+        <Alert severity="error" data-testid="evidence-connect-failed">
+          {copy.connectFailed}
+        </Alert>
+      ) : null}
+    </Stack>
+  );
+}
+
+/** One run at a time: which phase it is in, what it answered, where it failed. */
+function useEvidenceRun({ onPrepare, onRun, onDownload }: Pick<HomologacaoEvidenceCardProps, 'onPrepare' | 'onRun' | 'onDownload'>) {
+  const [phase, setPhase] = useState<Phase>('idle');
+  const [summary, setSummary] = useState<EvidenceSummary | null>(null);
+  const [failed, setFailed] = useState<ActivePhase | null>(null);
+  const run = async (full: boolean): Promise<void> => {
+    setFailed(null);
+    setSummary(null);
+    // The phase that throws is the one the operator is told about.
+    let current: ActivePhase = full ? 'preparing' : 'downloading';
+    const enter = (next: ActivePhase): void => {
+      current = next;
+      setPhase(next);
+    };
+    try {
+      if (full) {
+        enter('preparing');
+        const prepared = await onPrepare();
+        enter('encrypting');
+        const cards = await encryptTestCards(prepared.publicKey);
+        enter('running');
+        await onRun(prepared.runId, cards);
+      }
+      enter('downloading');
+      setSummary(await onDownload());
+    } catch {
+      setFailed(current);
+    } finally {
+      setPhase('idle');
+    }
+  };
+  return { phase, busy: phase !== 'idle', summary, failed, run };
+}
+
+/** How the last return from PagBank ended — with the recorded reason when it failed. */
+function ConnectOutcome({ seller, connectOutcome }: Pick<HomologacaoEvidenceCardProps, 'seller' | 'connectOutcome'>): ReactNode {
+  const copy = usePlatformCopy().evidence;
+  // The URL only says PagBank came back; the seller's own row says whether it
+  // connected. A "connected" the row does not confirm is not announced.
+  const outcome = connectOutcome === 'connected' && !seller?.connected ? null : connectOutcome;
+  if (!outcome) return null;
+  return (
+    <Alert severity={outcome === 'connected' ? 'success' : 'warning'} data-testid="evidence-connect-outcome">
+      {outcome === 'connected' ? copy.returnedConnected : (seller?.lastConnectProblem ?? copy.returnedFailed)}
+    </Alert>
+  );
+}
+
+function EvidenceBody(props: HomologacaoEvidenceCardProps): ReactNode {
+  const { seller, onConnect } = props;
+  const copy = usePlatformCopy().evidence;
+  const { phase, busy, summary, failed, run } = useEvidenceRun(props);
+  return (
+    <Stack spacing={1.5} data-testid="homologacao-evidence-card" sx={CARD_SX}>
+      <Typography variant="body2" fontWeight={600}>
+        {copy.heading}
+      </Typography>
+      <Typography variant="caption" component="p">
+        {copy.lede}
+      </Typography>
+      <ConnectOutcome seller={seller} connectOutcome={props.connectOutcome} />
+      <SellerBlock seller={seller} onConnect={onConnect} />
+      <Stack direction={{ xs: 'column', sm: 'row' }} spacing={1} sx={{ alignItems: { sm: 'center' } }}>
+        <Button
+          variant={seller?.connected ? 'contained' : 'outlined'}
+          size="small"
+          disabled={busy}
+          onClick={() => void run(true)}
+          data-testid="evidence-generate"
+          sx={TAP_SX}
+        >
+          {copy.generate}
+        </Button>
+        <Button
+          variant="text"
+          size="small"
+          disabled={busy}
+          onClick={() => void run(false)}
+          data-testid="evidence-download-latest"
+          sx={TAP_SX}
+        >
+          {copy.downloadLatest}
+        </Button>
+      </Stack>
+      {busy ? (
+        <Stack spacing={0.5} role="status" aria-busy="true" data-testid="evidence-phase">
+          <Typography variant="body2">{copy.phases[phase as ActivePhase]}</Typography>
+          <LinearProgress />
+        </Stack>
+      ) : null}
+      <EvidenceResult summary={summary} failed={failed} />
+    </Stack>
+  );
+}
+
+/** The server's counts — never inferred here — or the failure line. */
+function EvidenceResult({
+  summary,
+  failed,
+}: {
+  summary: EvidenceSummary | null;
+  failed: ActivePhase | null;
+}): ReactNode {
+  const copy = usePlatformCopy().evidence;
+  if (failed) {
+    return (
+      <Alert severity="error" data-testid="evidence-generate-failed">
+        {copy.generateFailed(failed)}
+      </Alert>
+    );
+  }
+  if (!summary) return null;
+  return (
+    <Stack spacing={0.5} role="status" data-testid="evidence-summary">
+      <Typography variant="body2" fontWeight={600} data-testid="evidence-summary-counts">
+        {copy.summary(summary)}
+      </Typography>
+      {summary.failed + summary.pending > 0 ? (
+        <Typography variant="caption" component="p" data-testid="evidence-incomplete">
+          {copy.incomplete}
+        </Typography>
+      ) : null}
+    </Stack>
+  );
+}

package/src/components/platform/PastedCredentialsCard.tsx

@@ -0,0 +1,227 @@
+'use client';
+
+import { Alert, Box, Button, Stack, TextField, Typography } from '@mui/material';
+import { useRef, useState, type ReactNode } from 'react';
+
+import type {
+  ConnectApplicationStatus,
+  PastedConnectCredentials,
+  PaymentEnvironment,
+} from '@12-apps/payments-backend';
+
+import { CARD_SX, ConnectEnvironmentCard, TAP_SX } from './ConnectEnvironmentCard';
+import { usePlatformCopy } from './copy-context';
+
+/**
+ * Consult a Connect application with credentials PASTED here rather than the
+ * ones the host holds — the backend's `consultPastedConnectApplication`.
+ *
+ * The host's two cards answer "what is configured?"; this answers "is the
+ * application I am about to configure the right one, and is its redirect_uri
+ * ours?" before anyone edits a secret and redeploys to find out. The answer
+ * comes back in the same card the environments use, previews included, so the
+ * three blocks read the same way.
+ *
+ * Whatever `onConsult` sends is the host's to keep out of storage and logs —
+ * this card holds the values in component state and nowhere else.
+ */
+
+type PastedValues = Omit<PastedConnectCredentials, 'environment'>;
+
+const EMPTY: PastedValues = { clientId: '', clientSecret: '', accountToken: '' };
+
+/** The three paste fields; the secret two are masked as they are typed. */
+function CredentialInputs({
+  names,
+  values,
+  onChange,
+}: {
+  names: [string, string, string];
+  values: PastedValues;
+  onChange: (values: PastedValues) => void;
+}): ReactNode {
+  const fields: [keyof PastedValues, string, boolean][] = [
+    ['clientId', names[0], false],
+    ['clientSecret', names[1], true],
+    ['accountToken', names[2], true],
+  ];
+  return fields.map(([key, label, secret]) => (
+    <TextField
+      key={key}
+      size="small"
+      type={secret ? 'password' : 'text'}
+      label={label}
+      value={values[key]}
+      // "off", never "new-password": that value is the hint password managers use to
+      // offer saving what was typed, and these values are never to be stored.
+      autoComplete="off"
+      onChange={(event) => onChange({ ...values, [key]: event.target.value })}
+      // Shrunk for good: the names share a long prefix, so an empty field's
+      // placeholder-sized label is cut to the same "PAGBANK_OAUTH_CLIENT…" twice.
+      slotProps={{
+        inputLabel: { shrink: true },
+        htmlInput: {
+          'data-testid': `connect-pasted-${key}`,
+          // Password managers that ignore autocomplete honour these.
+          'data-1p-ignore': true,
+          'data-lpignore': 'true',
+        },
+      }}
+    />
+  ));
+}
+
+/** The input names: the host's own variables when it names them, the copy's when not. */
+function useCredentialNames(
+  environment: PaymentEnvironment,
+  configVarsFor?: (environment: PaymentEnvironment) => string[],
+): [string, string, string] {
+  const fallback = usePlatformCopy().connect.credentialNames;
+  const vars = configVarsFor?.(environment) ?? [];
+  return [
+    vars[0] ?? fallback.clientId,
+    vars[1] ?? fallback.clientSecret,
+    vars[2] ?? fallback.accountToken,
+  ];
+}
+
+/** One consult at a time: what it answered, whether it failed, whether it is running. */
+function usePastedConsult(
+  onConsult: (pasted: PastedConnectCredentials) => Promise<ConnectApplicationStatus>,
+): {
+  run: (pasted: PastedConnectCredentials) => void;
+  reset: () => void;
+  pending: boolean;
+  failed: boolean;
+  result: ConnectApplicationStatus | null;
+} {
+  const [pending, setPending] = useState(false);
+  const [failed, setFailed] = useState(false);
+  const [result, setResult] = useState<ConnectApplicationStatus | null>(null);
+  // Which call the screen still wants an answer to. `reset` and every new `run`
+  // move it on, so a consult that settles after the values changed is dropped
+  // instead of landing beside values it was not given.
+  const current = useRef(0);
+  const run = (pasted: PastedConnectCredentials): void => {
+    const id = ++current.current;
+    const live = (): boolean => id === current.current;
+    setPending(true);
+    setFailed(false);
+    onConsult(pasted)
+      .then((status) => live() && setResult(status))
+      .catch(() => live() && setFailed(true))
+      .finally(() => live() && setPending(false));
+  };
+  // An answer belongs to the values it was given: editing any of them retires it.
+  const reset = (): void => {
+    current.current += 1;
+    setPending(false);
+    setFailed(false);
+    setResult(null);
+  };
+  return { run, reset, pending, failed, result };
+}
+
+export function PastedCredentialsCard({
+  onConsult,
+  configVarsFor,
+}: {
+  onConsult: (pasted: PastedConnectCredentials) => Promise<ConnectApplicationStatus>;
+  configVarsFor?: (environment: PaymentEnvironment) => string[];
+}): ReactNode {
+  const copy = usePlatformCopy().connect;
+  const [environment, setEnvironment] = useState<PaymentEnvironment>('SANDBOX');
+  const [values, setValues] = useState<PastedValues>(EMPTY);
+  const names = useCredentialNames(environment, configVarsFor);
+  const consult = usePastedConsult(onConsult);
+  const complete = Object.values(values).every((value) => value.trim() !== '');
+  const trimmed = {
+    environment,
+    clientId: values.clientId.trim(),
+    clientSecret: values.clientSecret.trim(),
+    accountToken: values.accountToken.trim(),
+  };
+
+  return (
+    <Stack spacing={1.5} data-testid="connect-pasted" sx={CARD_SX}>
+      <Typography variant="body2" fontWeight={600}>
+        {copy.pasted.heading}
+      </Typography>
+      <Typography variant="caption" component="p">
+        {copy.pasted.lede}
+      </Typography>
+      <Stack spacing={1.5} sx={{ maxWidth: 560 }}>
+        <TextField
+          select
+          size="small"
+          label={copy.pasted.environment}
+          value={environment}
+          onChange={(event) => {
+            setEnvironment(event.target.value as PaymentEnvironment);
+            consult.reset();
+          }}
+          slotProps={{
+            select: { native: true },
+            htmlInput: { 'data-testid': 'connect-pasted-environment' },
+          }}
+        >
+          <option value="SANDBOX">{copy.environmentLabels.SANDBOX}</option>
+          <option value="PRODUCTION">{copy.environmentLabels.PRODUCTION}</option>
+        </TextField>
+        <CredentialInputs
+          names={names}
+          values={values}
+          onChange={(next) => {
+            setValues(next);
+            consult.reset();
+          }}
+        />
+        <Box>
+          <Button
+            variant="contained"
+            size="small"
+            disabled={!complete || consult.pending}
+            onClick={() => consult.run(trimmed)}
+            data-testid="connect-pasted-submit"
+            sx={TAP_SX}
+          >
+            {copy.pasted.submit}
+          </Button>
+        </Box>
+      </Stack>
+      <PastedAnswer consult={consult} configVarsFor={configVarsFor} />
+    </Stack>
+  );
+}
+
+/** The failure line, or the answer in the same card the environments use. */
+function PastedAnswer({
+  consult,
+  configVarsFor,
+}: {
+  consult: ReturnType<typeof usePastedConsult>;
+  configVarsFor?: (environment: PaymentEnvironment) => string[];
+}): ReactNode {
+  const copy = usePlatformCopy().connect;
+  if (consult.failed) {
+    return (
+      <Alert severity="error" data-testid="connect-pasted-failed">
+        {copy.pasted.failed}
+      </Alert>
+    );
+  }
+  if (!consult.result) return null;
+  return (
+    <Stack spacing={1}>
+      <Alert severity="info" data-testid="connect-pasted-secret-not-checked">
+        {copy.pasted.secretNotChecked}
+      </Alert>
+      <ConnectEnvironmentCard
+        status={consult.result}
+        slot="PASTED"
+        configVars={configVarsFor?.(consult.result.environment)}
+        showConfigHelp={false}
+      />
+    </Stack>
+  );
+}

package/src/components/platform/copy.ts

@@ -102,6 +102,56 @@ export interface ConnectApplicationCopy {
   hideConfig: string;
   /** The heading above whatever extra keys PagBank's response carried. */
   extraKeys: string;
+  /** Each card's heading — the environment, in the operator's words. */
+  environmentLabels: Readonly<Record<'SANDBOX' | 'PRODUCTION', string>>;
+  /**
+   * The preview of the values an application was consulted with: a heading,
+   * what an unset value reads as, and each value's name when the host names no
+   * configuration variables of its own (`configVarsFor`).
+   */
+  previewHeading: string;
+  previewUnset: string;
+  /** A value read from a fallback variable (production's token from the unsuffixed name). */
+  previewInherited: string;
+  credentialNames: { clientId: string; clientSecret: string; accountToken: string };
+  /** The block that consults with PASTED credentials — rendered only when the host wires it. */
+  pasted: {
+    heading: string;
+    /** Must say the values are not stored: the operator is pasting secrets. */
+    lede: string;
+    environment: string;
+    submit: string;
+    failed: string;
+    /**
+     * The consult authenticates with the account token and looks up the client
+     * id; the secret is never sent. The answer must not read as "all three are good".
+     */
+    secretNotChecked: string;
+  };
+}
+
+/** The homologação evidence card (FUT-3696) — the sandbox test seller and the TXT. */
+export interface HomologacaoEvidenceCardCopy {
+  heading: string;
+  lede: string;
+  sellerHeading: string;
+  /** `connectedAt` is ISO-8601; the pack formats it in its own locale. */
+  sellerConnected: (connectedAt: string | null, accountId: string | null) => string;
+  sellerNotConnected: string;
+  sellerReconnect: string;
+  connectHint: string;
+  connect: string;
+  reconnect: string;
+  connectFailed: string;
+  returnedConnected: string;
+  returnedFailed: string;
+  generate: string;
+  downloadLatest: string;
+  phases: { preparing: string; encrypting: string; running: string; downloading: string };
+  summary: (counts: { executed: number; failed: number; pending: number }) => string;
+  incomplete: string;
+  /** Which phase failed — and that the latest recorded file can still be downloaded. */
+  generateFailed: (phase: 'preparing' | 'encrypting' | 'running' | 'downloading') => string;
 }
 
 /** The whole platform surface, in one object a host passes at the mount. */
@@ -110,4 +160,5 @@ export interface PlatformHomologacaoCopy {
   guide: HomologacaoGuideCopy;
   anexo: HomologacaoAnexoCopy;
   connect: ConnectApplicationCopy;
+  evidence: HomologacaoEvidenceCardCopy;
 }

package/src/components/platform/en-US.ts

@@ -72,7 +72,7 @@ export const EN_US_PLATFORM_HOMOLOGACAO_COPY: PlatformHomologacaoCopy = {
     // operator compares the two strings character by character.
     redirectMatches: 'The registered redirect_uri matches the callback this deploy uses.',
     redirectDiffers:
-      'The redirect_uri registered with PagBank differs from the callback this deploy uses.',
+      'The redirect_uri registered with PagBank differs from the callback this deploy uses. The OAuth authorization flow fails silently until the registration is fixed at PagBank.',
     redirectUnreported:
       "PagBank's response carried no redirect_uri, so it could not be compared with the callback.",
     fields: {
@@ -85,9 +85,63 @@ export const EN_US_PLATFORM_HOMOLOGACAO_COPY: PlatformHomologacaoCopy = {
     fieldEmpty: '—',
     redirectNotReported: 'not reported',
     resolvedFrom:
-      "This environment's application is resolved strictly from these variables, with no fallback between environments:",
+      "This environment's application is resolved from these variables. The client_id and client_secret are strict, with no fallback between environments; the others, such as the token, fall back to the unsuffixed variable when this environment's own is unset:",
     showConfig: 'Show environment variables',
     hideConfig: 'Hide environment variables',
-    extraKeys: 'Other fields returned',
+    extraKeys: 'Other fields returned (undocumented schema)',
+    environmentLabels: { SANDBOX: 'Sandbox', PRODUCTION: 'Production' },
+    previewHeading: 'First 5 characters of each variable',
+    previewUnset: 'not set',
+    previewInherited: 'not set — uses the unsuffixed variable:',
+    // `client_id` / `client_secret` are PagBank's own parameter names.
+    credentialNames: { clientId: 'client_id', clientSecret: 'client_secret', accountToken: 'account token' },
+    pasted: {
+      heading: 'Test other credentials',
+      lede:
+        "Paste an application's credentials to look it up at PagBank before changing the environment variables. The values are used for this lookup only and are not saved.",
+      environment: 'Environment',
+      submit: 'Look up with these credentials',
+      failed: 'The pasted credentials could not be looked up.',
+      secretNotChecked:
+        'PagBank does not check the client_secret in this lookup — only the client_id and the token. A wrong client_secret only shows at the first store authorization.',
+    },
+  },
+  evidence: {
+    heading: 'Homologation evidence (sandbox)',
+    lede: "Runs the real scenarios in PagBank's sandbox and builds the TXT for the form. Nothing is charged.",
+    sellerHeading: 'Test seller',
+    sellerConnected: (connectedAt, accountId) =>
+      `Connected${connectedAt ? ` on ${new Date(connectedAt).toLocaleString('en-US')}` : ''}` +
+      (accountId ? ` · account ${accountId}` : ''),
+    sellerNotConnected:
+      'No test seller connected. Without one, the Connect, Pix and card scenarios stay pending in the file.',
+    sellerReconnect: "The test seller's connection must be authorized again.",
+    connectHint:
+      "You will sign in to PagBank's sandbox with a test seller account and approve the consent. Sandbox only.",
+    connect: 'Connect test seller',
+    reconnect: 'Reconnect test seller',
+    connectFailed: 'Could not start the test seller connection.',
+    returnedConnected: 'Test seller connected. The callback and the code exchange were recorded in the evidence.',
+    returnedFailed: 'The test seller connection did not complete. The reason was recorded in the evidence file.',
+    generate: 'Generate evidence file\u00a0(TXT)',
+    downloadLatest: 'Download again (no run)',
+    phases: {
+      preparing: 'Consulting the application, renewing the token and minting the public key…',
+      encrypting: 'Encrypting the test cards in the browser…',
+      running: 'Creating the Pix and card orders in the sandbox — this can take up to a minute…',
+      downloading: 'Building the file…',
+    },
+    summary: ({ executed, failed, pending }) => `✓ ${executed} executed · ✗ ${failed} failed · ⧗ ${pending} pending`,
+    incomplete:
+      'The file lists what is missing under Pendências. Do not submit it as complete. Notifications that arrive later show up when you download again.',
+    generateFailed: (phase) =>
+      `${
+        {
+          preparing: 'Consulting the application and preparing the test seller failed.',
+          encrypting: 'Encrypting the test cards in the browser failed.',
+          running: 'Creating the orders in the sandbox failed.',
+          downloading: 'Building the file failed.',
+        }[phase]
+      } Try again; "Download again" still returns what was recorded.`,
   },
 };

package/src/components/platform/pt-BR.ts

@@ -52,7 +52,7 @@ export const PT_BR_PLATFORM_HOMOLOGACAO_COPY: PlatformHomologacaoCopy = {
     noApplication: 'Nenhuma aplicação configurada neste ambiente.',
     redirectMatches: 'O redirect_uri registrado confere com o callback que este deploy usa.',
     redirectDiffers:
-      'O redirect_uri registrado no PagBank é diferente do callback que este deploy usa.',
+      'O redirect_uri registrado no PagBank é diferente do callback que este deploy usa. O fluxo de autorização OAuth falha silenciosamente até o cadastro ser corrigido no PagBank.',
     redirectUnreported:
       'A resposta do PagBank não trouxe redirect_uri, então não foi possível comparar com o callback.',
     fields: {
@@ -65,9 +65,67 @@ export const PT_BR_PLATFORM_HOMOLOGACAO_COPY: PlatformHomologacaoCopy = {
     fieldEmpty: '—',
     redirectNotReported: 'não informado',
     resolvedFrom:
-      'A aplicação deste ambiente é resolvida estritamente a partir destas variáveis, sem fallback entre ambientes:',
+      'A aplicação deste ambiente é resolvida a partir destas variáveis. O client_id e o client_secret são estritos, sem fallback entre ambientes; as demais, como o token, caem para a variável sem sufixo quando a deste ambiente não existe:',
     showConfig: 'Mostrar variáveis de ambiente',
     hideConfig: 'Ocultar variáveis de ambiente',
-    extraKeys: 'Outros campos retornados',
+    extraKeys: 'Outros campos retornados (schema não documentado)',
+    environmentLabels: { SANDBOX: 'Sandbox', PRODUCTION: 'Produção' },
+    previewHeading: 'Primeiros 5 caracteres de cada variável',
+    previewUnset: 'não definida',
+    previewInherited: 'não definida — usa o valor da variável sem sufixo:',
+    credentialNames: { clientId: 'client_id', clientSecret: 'client_secret', accountToken: 'token da conta' },
+    pasted: {
+      heading: 'Testar outras credenciais',
+      lede:
+        'Cole as credenciais de uma aplicação para consultá-la no PagBank antes de alterar as variáveis de ambiente. Os valores são usados só nesta consulta e não são salvos.',
+      environment: 'Ambiente',
+      submit: 'Consultar com estas credenciais',
+      failed: 'Não foi possível consultar com as credenciais coladas.',
+      secretNotChecked:
+        'O PagBank não verifica o client_secret nesta consulta — só o client_id e o token. Um client_secret errado só aparece na primeira autorização de loja.',
+    },
+  },
+  evidence: {
+    heading: 'Evidências para homologação (sandbox)',
+    lede: 'Executa os cenários reais no sandbox do PagBank e gera o TXT para o formulário. Nada é cobrado.',
+    sellerHeading: 'Lojista de teste',
+    sellerConnected: (connectedAt, accountId) =>
+      `Conectado${connectedAt ? ` em ${new Date(connectedAt).toLocaleString('pt-BR', { timeZone: 'America/Sao_Paulo' })}` : ''}` +
+      (accountId ? ` · conta ${accountId}` : ''),
+    sellerNotConnected:
+      'Nenhum lojista de teste conectado. Sem ele, os cenários de Connect, Pix e cartão ficam pendentes no arquivo.',
+    sellerReconnect: 'A conexão do lojista de teste precisa ser autorizada de novo.',
+    connectHint:
+      'Você fará login no sandbox do PagBank com uma conta de vendedor de teste e aprovará o consentimento. Somente sandbox.',
+    connect: 'Conectar lojista de teste',
+    reconnect: 'Reconectar lojista de teste',
+    connectFailed: 'Não foi possível iniciar a conexão do lojista de teste.',
+    returnedConnected:
+      'Lojista de teste conectado. O callback e a troca do código foram registrados nas evidências.',
+    returnedFailed:
+      'A conexão do lojista de teste não foi concluída. O motivo foi registrado no arquivo de evidências.',
+    generate: 'Gerar arquivo de evidências\u00a0(TXT)',
+    downloadLatest: 'Baixar de novo (sem executar)',
+    phases: {
+      preparing: 'Consultando a aplicação, renovando o token e gerando a chave pública…',
+      encrypting: 'Criptografando os cartões de teste no navegador…',
+      running: 'Criando os pedidos Pix e cartão no sandbox — pode levar até um minuto…',
+      downloading: 'Montando o arquivo…',
+    },
+    summary: ({ executed, failed, pending }) =>
+      `✓ ${executed} ${executed === 1 ? 'executado' : 'executados'} · ` +
+      `✗ ${failed} ${failed === 1 ? 'falhou' : 'falharam'} · ` +
+      `⧗ ${pending} ${pending === 1 ? 'pendente' : 'pendentes'}`,
+    incomplete:
+      'O arquivo lista o que falta na seção Pendências. Não o envie como completo. Notificações que chegarem depois aparecem ao baixar de novo.',
+    generateFailed: (phase) =>
+      `${
+        {
+          preparing: 'Falhou ao consultar a aplicação e preparar o lojista de teste.',
+          encrypting: 'Falhou ao criptografar os cartões de teste no navegador.',
+          running: 'Falhou ao criar os pedidos no sandbox.',
+          downloading: 'Falhou ao montar o arquivo.',
+        }[phase]
+      } Tente de novo; "Baixar de novo" ainda traz o que já foi registrado.`,
   },
 };

package/src/index.ts

@@ -337,6 +337,7 @@ export {
   type ConnectApplicationPanelProps,
 } from './components/platform/ConnectApplicationPanel';
 export { PlatformHomologacao, type PlatformHomologacaoProps } from './components/platform/PlatformHomologacao';
+export * from './components/platform/HomologacaoEvidenceCard';
 export {
   type HomologacaoSaveInput,
   type HomologacaoSaveState,