@vibe2founder/tests2dialects 0.1.0

package/docs/api-narrativo.md

@@ -0,0 +1,181 @@
+# 📖 Dialeto Narrativo - API Completa
+
+> **Filosofia:** BDD (Behavior Driven Development) e Storytelling.
+>
+> **Vibe:** Fluida, Humana, Descritiva.
+>
+> **Ideal para:** Designers, Product Managers, times ágeis, testes de fluxos de usuário (User Journeys).
+
+## Estrutura
+
+| Função               | Descrição                           | Equivalente Jest |
+| -------------------- | ----------------------------------- | ---------------- |
+| `intend(name, fn)`   | Define a intenção do bloco          | `describe`       |
+| `story(name, fn)`    | Alias para agrupamento de histórias | `describe`       |
+| `detail(name, fn)`   | Detalha um comportamento específico | `test` / `it`    |
+| `scenario(name, fn)` | Um cenário de uso                   | `test` / `it`    |
+
+## Asserções
+
+| Função                    | Descrição                      | Equivalente Jest                         |
+| ------------------------- | ------------------------------ | ---------------------------------------- |
+| `to(val).be(expected)`    | "Para o valor ser..."          | `expect(val).toBe(expected)`             |
+| `to(val).have(prop)`      | Verifica posse de propriedade  | `expect(val).toHaveProperty(prop)`       |
+| `to(val).wasCalled()`     | Verifica se o ator foi chamado | `expect(val).toHaveBeenCalled()`         |
+| `to(val).received(args)`  | Verifica o que foi recebido    | `expect(val).toHaveBeenCalledWith(args)` |
+| `to(val).called(n).times` | Contagem de chamadas           | `expect(val).toHaveBeenCalledTimes(n)`   |
+
+## Mocks (Dublês/Atores)
+
+| Função                       | Descrição                        | Equivalente Jest          |
+| ---------------------------- | -------------------------------- | ------------------------- |
+| `dummy()`                    | Um dublê (ator) no lugar do real | `jest.fn()`               |
+| `standIn()`                  | Alias para dummy                 | `jest.fn()`               |
+| `watch(obj, method)`         | Observa um ator existente        | `jest.spyOn(obj, method)` |
+| `shadow(obj, method)`        | Segue (shadows) um método        | `jest.spyOn(obj, method)` |
+| `actor.respondsWith(val)`    | Define a resposta do ator        | `mockReturnValue(val)`    |
+| `actor.eventuallyGives(val)` | Resposta futura (promessa)       | `mockResolvedValue(val)`  |
+| `actor.actsLike(fn)`         | Define como o ator deve agir     | `mockImplementation(fn)`  |
+
+## Lifecycle
+
+| Função           | Descrição                     | Equivalente Jest |
+| ---------------- | ----------------------------- | ---------------- |
+| `background(fn)` | Contexto de fundo da história | `beforeAll(fn)`  |
+| `before(fn)`     | Antes de cada cena            | `beforeEach(fn)` |
+| `cleanup(fn)`    | Limpeza após a história       | `afterAll(fn)`   |
+
+## Exemplo Completo
+
+```javascript
+import {
+  intend,
+  story,
+  scenario,
+  detail,
+  to,
+  standIn,
+  dummy,
+  watch,
+  background,
+  before,
+  cleanup,
+} from "@vibe2founder/tests2dialects";
+
+intend("Fluxo de Autenticação do Usuário", () => {
+  const authService = standIn();
+  const database = standIn();
+  const emailSender = dummy();
+
+  background(() => {
+    // Configura o cenário de fundo para toda a história
+    authService.respondsWith({ token: "abc-123", expiresIn: 3600 });
+    database.respondsWith(true);
+    emailSender.respondsWith({ sent: true });
+  });
+
+  before(() => {
+    // Reset de estado antes de cada cena
+  });
+
+  scenario("Login com credenciais válidas deve retornar token", () => {
+    const response = authService.login("usuario", "senha_secreta");
+
+    to(response).have("token");
+    to(response.token).be("abc-123");
+    to(response).have("expiresIn");
+  });
+
+  scenario("Login deve registrar tentativa no banco de dados", () => {
+    authService.login("usuario", "senha_secreta");
+    database.logAttempt("usuario", "success");
+
+    to(database).wasCalled();
+    to(database).received("logAttempt", "usuario", "success");
+  });
+
+  scenario("Login bem-sucedido envia email de boas-vindas", () => {
+    authService.login("novo_usuario", "senha123");
+    emailSender.send("novo_usuario@email.com", "Bem-vindo!");
+
+    to(emailSender).wasCalled();
+  });
+
+  cleanup(() => {
+    console.log("Histórias de autenticação concluídas.");
+  });
+});
+
+story("Jornada de Compra do Usuário", () => {
+  const cart = standIn();
+  const user = standIn();
+  const paymentGateway = standIn();
+
+  background(() => {
+    cart.respondsWith({ items: [], total: 0 });
+    user.respondsWith({ name: "João", loggedIn: true });
+    paymentGateway.respondsWith({ status: "approved" });
+  });
+
+  scenario("Usuário adiciona primeiro produto ao carrinho", () => {
+    cart.add({ name: "Camiseta", price: 49.9, quantity: 1 });
+    cart.respondsWith({
+      items: [{ name: "Camiseta", price: 49.9, quantity: 1 }],
+      total: 49.9,
+    });
+
+    to(cart).wasCalled();
+    to(cart.items).have("length");
+  });
+
+  scenario("Usuário aplica cupom de desconto", () => {
+    const coupon = standIn();
+    coupon.respondsWith({ valid: true, discount: 15 });
+
+    cart.applyCoupon("DESCONTO15");
+    cart.respondsWith({ total: 42.42 }); // 49.9 - 15%
+
+    to(coupon).wasCalled();
+    to(cart.total).be(42.42);
+  });
+
+  detail("Carrinho vazio mostra mensagem amigável", () => {
+    cart.respondsWith({
+      items: [],
+      total: 0,
+      message: "Seu carrinho está vazio",
+    });
+
+    to(cart.message).be("Seu carrinho está vazio");
+  });
+
+  scenario("Usuário não logado tenta finalizar compra", () => {
+    user.respondsWith({ loggedIn: false });
+    const checkout = standIn();
+    checkout.respondsWith({ error: "LOGIN_REQUIRED", status: 401 });
+
+    to(checkout.status).be(401);
+    to(checkout.error).be("LOGIN_REQUIRED");
+  });
+
+  scenario("Pagamento aprovado finaliza a compra", () => {
+    cart.checkout();
+
+    to(paymentGateway.status).be("approved");
+    to(cart).wasCalled();
+  });
+});
+```
+
+## Quando Usar
+
+- ✅ Fluxos de usuário (User Journeys)
+- ✅ Testes E2E legíveis
+- ✅ Documentação viva para PMs
+- ✅ Regras de negócio de alto nível
+- ✅ Testes de aceitação
+
+## Quando NÃO Usar
+
+- ❌ Algoritmos matemáticos puros → Use o [Dialeto Matemático](./api-matematico.md)
+- ❌ Integrações técnicas com contratos rígidos → Use o [Dialeto Imperativo](./api-imperativo.md)

package/docs/guia-rapido.md

@@ -0,0 +1,189 @@
+🚀 Seu Guia de Início Rápido para o tests2dialects
+
+Introdução: Cansado de "Descrever" Quando Você Quer "Provar"?
+
+O tests2dialects nasce de uma frustração comum no mundo dos testes: usar o mesmo vocabulário para problemas fundamentalmente diferentes. Afinal, a linguagem importa. Ela molda o pensamento. A ferramenta padrão (describe, it, should) é excelente para descrever comportamentos, mas e quando você está provando um teorema matemático ou verificando a conformidade com um contrato de API?
+
+Este framework oferece diferentes "dialetos" porque entende que testar um algoritmo de criptografia é uma tarefa fundamentalmente diferente de testar um fluxo de login de usuário. Ele oferece o vocabulário certo para cada trabalho.
+
+One Runner to Rule Them All.
+
+Esta abordagem é construída sobre uma filosofia fundamental que garante que a adoção da ferramenta seja suave e incremental, sem descartar seu trabalho existente.
+
+A "Filosofia Aditiva": Seu Conhecimento Está Seguro
+
+Uma das maiores barreiras para adotar uma nova ferramenta é o medo de ter que "jogar tudo fora e começar de novo". O tests2dialects foi projetado com o princípio oposto em mente.
+
+O Que É a Filosofia Aditiva?
+
+A Filosofia Aditiva significa que o tests2dialects funciona como um superset (superconjunto) do Jest. Ele não nega o passado; ele o expande. Se você tem milhares de testes escritos com a sintaxe padrão do Jest (describe, it), não precisa reescrever uma única linha. O framework entende nativamente o seu código legado.
+
+Essa filosofia se manifesta em três benefícios principais:
+
+- Seu código legado continua funcionando: Testes antigos que usam describe e it rodam nativamente no executor do tests2dialects. Seu conhecimento e seu código continuam 100% válidos.
+- Você não precisa aprender tudo: A ideia não é que cada desenvolvedor se torne fluente em todos os dialetos. A proposta é a Especialização por Contexto: um cientista de dados pode usar apenas o dialeto Matemático, enquanto um engenheiro de backend foca no Imperativo. O framework é poliglota; você não precisa ser.
+- Um único executor de testes: Unifique seu ciclo de vida de desenvolvimento e implantação. Um único comando npm test executa tanto os testes legados quanto os modernos, otimizando seu pipeline de CI/CD e consolidando todos os resultados em um único relatório autoritativo.
+
+Agora que você entende a filosofia, vamos colocar a mão na massa e ver como é fácil começar.
+
+Mão na Massa: Seu Primeiro Teste em 5 Minutos
+
+Vamos rodar um teste real para ver o framework em ação antes de mergulharmos nos detalhes de cada dialeto.
+
+Quick Start: Escrevendo um Teste Imperativo
+
+Siga estes três passos simples para escrever e executar seu primeiro teste.
+
+1. Instale o pacote: Abra seu terminal e execute o seguinte comando para adicionar o tests2dialects ao seu projeto.
+2. Crie o arquivo api.spec.ts: Crie um novo arquivo de teste e cole o código abaixo. Este exemplo usa o dialeto Imperativo para garantir o comportamento de uma API.
+3. Execute o teste: Volte ao seu terminal e rode o executor do tests2dialects.
+
+Pronto! Você acabou de rodar seu primeiro teste com o dialeto Imperativo. Agora, vamos explorar os diferentes dialetos para que você possa escolher o ideal para seus próprios projetos.
+
+Escolhendo Seu Dialeto: Qual é o Ideal para Você?
+
+Lembre-se: você não precisa aprender os três dialetos. A ideia é escolher aquele que melhor se encaixa no problema que você está resolvendo e ignorar o resto. Este fluxograma pode ajudar na sua decisão:
+
+┌─────────────────────────────────────────┐
+│ O que você está testando? │
+└───────────────────┬─────────────────────┘
+│
+┌───────────────────────────────┼───────────────────────────────┐
+│ │ │
+▼ ▼ ▼
+┌──────────────────────┐ ┌──────────────────────┐ ┌──────────────────────┐
+│ Algoritmos puros, │ │ Fluxos de usuário, │ │ APIs, contratos, │
+│ cálculos, regras │ │ regras de negócio │ │ integrações, │
+│ matemáticas? │ │ legíveis por PMs? │ │ conformidade? │
+└──────────┬───────────┘ └──────────┬───────────┘ └──────────┬───────────┘
+│ │ │
+▼ ▼ ▼
+┌──────────────────────┐ ┌──────────────────────┐ ┌──────────────────────┐
+│ 📐 MATEMÁTICO │ │ 📖 NARRATIVO │ │ 🛡️ IMPERATIVO │
+│ axiom, proof, implies│ │ intend, scenario, to │ │ ensure, check, that │
+└──────────────────────┘ └──────────────────────┘ └──────────────────────┘
+
+As seções a seguir são projetadas para ser o seu guia. Para cada dialeto, vamos diagnosticar um ponto de dor específico comum no desenvolvimento de software, apresentar a solução linguística oferecida pelo tests2dialects e fornecer um tutorial prático. Preste muita atenção à seção "A Dor" — se ela ressoar com você, você provavelmente encontrou o seu dialeto.
+
+O Dialeto Matemático (📐 MathDialect)
+
+A Dor: Quando "should" soa informal demais
+
+Imagine que você está testando uma função de criptografia pura ou um cálculo financeiro complexo. A sintaxe padrão de teste te força a escrever algo assim:
+
+describe("SHA-256", () => {
+it("should produce a valid hash", () => { ... });
+});
+
+Isso soa fraco e inadequado. Você não está "descrevendo um comportamento que deveria acontecer"; você está provando uma verdade matemática universal. A linguagem da ferramenta não reflete o rigor do seu código.
+
+A Solução: Escrevendo Provas Axiomáticas
+
+Com o dialeto Matemático, você escreve provas axiomáticas, usando um vocabulário que espelha a lógica formal. A linguagem agora reflete o que você está realmente fazendo: provar. Este não é apenas um teste; é uma prova axiomática formal, refletindo a vibe científica e imutável do código que valida.
+
+import { axiom, proof, implies } from "@vibe2founder/tests2dialects";
+
+axiom("Teoria de Hash SHA-256", () => {
+proof("Hash de string vazia converge para constante conhecida", () => {
+const sha256 = (str: string) => "e3b0c44..."; // Função de exemplo
+implies(sha256("")).is("e3b0c44...");
+});
+});
+
+Ideal para: Cientistas de dados, engenheiros de algoritmos, bibliotecas de utilitários, cálculos financeiros.
+
+Seu Primeiro Teste Matemático
+
+1. Crie o arquivo calculo.spec.ts: Crie um novo arquivo de teste para abrigar suas provas matemáticas.
+2. Escreva sua prova: Cole o código abaixo. Ele prova duas verdades sobre uma função de juros compostos.
+3. Execute e veja a mágica: Rode o executor novamente. Ele encontrará e executará todos os seus arquivos de teste, incluindo o novo.
+
+Este dialeto é perfeito para garantir a correção de algoritmos. A seguir, veremos um dialeto focado em comunicação e regras de negócio.
+
+O Dialeto Narrativo (📖 NarrativeDialect)
+
+A Dor: Quando seu PM não consegue ler seus testes
+
+As regras de negócio cruciais do seu sistema estão validadas, mas estão escondidas dentro de testes técnicos que só os desenvolvedores entendem.
+
+it("should return 403", () => { ... });
+
+Para um Gerente de Produto (PM) ou Designer, isso é indecifrável. Cria-se uma barreira entre o time de produto e a engenharia, onde a confiança substitui a validação explícita.
+
+A Solução: Testes como Documentação Viva
+
+O dialeto Narrativo transforma o teste em uma história legível por humanos. Ele serve como um contrato vivo entre produto e engenharia. Agora, seu PM pode ler o teste e entender exatamente qual regra de negócio está sendo validada. Este código lê como uma história, cumprindo a vibe fluida, humana e descritiva do Behavior-Driven Development.
+
+import { scenario, to } from "@vibe2founder/tests2dialects";
+
+scenario("Usuário sem permissão tenta acessar o painel de Admin", () => {
+const response = { status: 403 }; // Resposta de exemplo
+to(response.status).be(403);
+});
+
+Ideal para: Designers, Product Managers, times ágeis, testes de fluxos de usuário (User Journeys).
+
+Seu Primeiro Teste Narrativo
+
+1. Crie o arquivo auth.spec.ts: Crie um novo arquivo para descrever os fluxos de usuário do seu sistema.
+2. Escreva seu cenário: Cole o código abaixo, que descreve um cenário de login bem-sucedido.
+3. Execute e valide a história: Rode o executor de testes para garantir que seu cenário está funcionando como esperado.
+
+Enquanto o Narrativo foca em clareza e comunicação, o próximo dialeto foca em rigor e conformidade técnica.
+
+O Dialeto Imperativo (🛡️ ImperativeDialect)
+
+A Dor: Quando "should" soa frágil demais
+
+Você está testando a integração com um gateway de pagamento ou validando a conformidade com uma especificação de API com implicações legais. Num contexto de conformidade, should não é apenas uma sugestão; é um passivo. Representa uma falha semântica em impor um contrato não negociável.
+
+describe("Payment Gateway", () => {
+it("should return 200", () => { ... });
+});
+
+Você precisa de uma linguagem que imponha respeito e autoridade, garantindo que um contrato técnico está sendo cumprido.
+
+A Solução: Garantindo Contratos com Autoridade
+
+O dialeto Imperativo usa palavras de comando: Ensure, Verify, That. Essa linguagem muda completamente o peso do teste, tratando-o como um conjunto de verificações de conformidade. O vocabulário impositivo reforça a vibe técnica e rigorosa do Design by Contract, não deixando espaço para ambiguidades.
+
+import { ensure, verify, that } from "@vibe2founder/tests2dialects";
+
+ensure("Conformidade com Contrato PCI-DSS v4", () => {
+verify("Dados sensíveis nunca trafegam em texto plano", () => {
+const payload = "encrypted:a1b2c3d4"; // Payload de exemplo
+that(payload).matches(/^encrypted:/);
+});
+});
+
+Ideal para: Engenheiros de backend, DevOps, validação de APIs, drivers de banco de dados, conformidade (compliance).
+
+Seu Primeiro Teste Imperativo
+
+1. Revisite o arquivo api.spec.ts: Você já escreveu seu primeiro teste imperativo na seção "Quick Start"! Vamos apenas revisá-lo para entender melhor suas partes.
+2. Entenda as partes: Aqui está o código novamente, com explicações sobre o papel de cada palavra-chave.
+3. Execute e garanta a conformidade: Rode o executor mais uma vez para ver todos os seus testes de todos os dialetos passando juntos.
+
+Conclusão: Adotando o tests2dialects Gradualmente
+
+A mensagem mais importante é que você não precisa parar tudo e reescrever seus testes existentes. Graças à Filosofia Aditiva, o tests2dialects coexiste perfeitamente com o Jest.
+
+O código abaixo, com um teste legado e um teste novo no mesmo arquivo, é 100% válido e será executado pelo mesmo comando. Observe que este arquivo é 100% válido e executável pelo tests2dialects.
+
+// ✅ Legado: Ninguém precisa mexer nisso
+describe("Módulo de Login (Legacy)", () => {
+it("deve validar senha", () => {
+expect(validar("123")).toBe(true);
+});
+});
+
+// ✅ Novo: Feature nova com dialeto novo
+import { axiom, implies } from 'tests2dialects-tester';
+
+axiom("Nova Criptografia SHA-256", () => {
+implies(hash("123")).matches(/^[a-f0-9]{64}$/);
+});
+
+O tests2dialects não veio para substituir o que já funciona. Ele veio para dar o vocabulário certo para cada tarefa, tornando seus testes mais expressivos, precisos e valiosos. É uma ferramenta de adição, não de substituição, projetada para evoluir com você e sua equipe.
+
+Próximos Passos: Para uma referência completa de todos os comandos e suas equivalências com o Jest, consulte a Tabela Rosetta (Comparativo Geral) na documentação principal do projeto. Ela é uma ferramenta fantástica para traduzir mentalmente os conceitos que você já conhece.

package/docs/whitepaper.md

@@ -0,0 +1,21 @@
+# Whitepaper
+
+## Introduction
+This whitepaper outlines the key features and benefits of the vibe2founder One Proof for All.
+
+## Background
+In the evolving landscape of blockchain technology, the need for a scalable and secure proof mechanism has never been more critical. This document discusses the architecture, protocol design, and operational specifics of the vibe2founder system.
+
+## System Overview
+### Core Components
+- **Distributed Ledger:** A decentralized database ensuring transparency and security.
+- **Consensus Mechanism:** Fast and energy-efficient protocol that validates transactions.
+- **Application Layer:** Interfaces that facilitate interaction with end-users and applications.
+
+## Benefits
+- **Scalability:** Designed to handle high volumes of transactions without compromising performance.
+- **Security:** Robust security mechanisms that safeguard against common vulnerabilities.
+- **User-friendly:** Simple interfaces for better user engagement.
+
+## Conclusion
+The vibe2founder One Proof for All offers innovative solutions to the current challenges in the blockchain ecosystem and sets a benchmark for future developments. For more information, refer to our detailed documentation and user guides.

package/examples/imperative.spec.ts

@@ -0,0 +1,58 @@
+import { ImperativeDialect } from "../src/index.js";
+
+const { ensure, check, that, stub, initAll } = ImperativeDialect;
+
+ensure("Sistema de Segurança e Compliance", () => {
+  // Stubs de Infraestrutura
+  const firewall = stub();
+  const logger = stub();
+
+  initAll(() => {
+    // Configuração Hardened
+    firewall.forceReturn({ allowed: true, threatLevel: 0 });
+  });
+
+  check("Deve bloquear conexões de IPs na blacklist", () => {
+    const maliciousIp = "192.168.1.666";
+
+    // Reconfigurando stub para este caso
+    firewall.executes((ip: string) => {
+      return ip === maliciousIp ? { allowed: false } : { allowed: true };
+    });
+
+    const access = firewall(maliciousIp);
+
+    that(access.allowed).is(false);
+    that(firewall).triggered();
+    that(firewall).calledWith(maliciousIp);
+  });
+
+  check("Deve registrar auditoria para cada acesso", () => {
+    logger("Acesso admin iniciado");
+
+    that(logger).triggeredCount(1);
+    that(logger).calledWith("Acesso admin iniciado");
+  });
+});
+
+ensure("Validação Estrutural da API V2", () => {
+  const apiResponse = {
+    status: 200,
+    data: {
+      id: "uuid-1234",
+      role: "admin",
+      meta: { version: 2 },
+    },
+  };
+
+  check("Payload deve conter metadados corretos", () => {
+    that(apiResponse.status).is(200);
+    that(apiResponse.data.role).is("admin");
+    that(apiResponse.data.meta.version).is(2);
+  });
+
+  check("Campos obrigatórios devem existir", () => {
+    that(apiResponse.data).isOk();
+    that(apiResponse.data.id).matches(/^uuid-/);
+  });
+});

package/examples/math.spec.ts

@@ -0,0 +1,52 @@
+import { MathDialect } from "../src/index.js";
+
+const { axiom, proof, implies, arbitrary } = MathDialect;
+
+// --- Domain Logic: Financial Calculation ---
+const calculateInterests = (principal: number, rate: number, time: number) => {
+  return principal * Math.pow(1 + rate, time);
+};
+
+axiom("Teoria Financeira: Juros Compostos", () => {
+  proof("O capital deve crescer exponencialmente", () => {
+    const principal = 1000;
+    const rate = 0.05; // 5%
+    const time = 2; // anos
+
+    const result = calculateInterests(principal, rate, time);
+    // 1000 * (1.05)^2 = 1000 * 1.1025 = 1102.5
+
+    implies(result).is(1102.5);
+  });
+
+  proof("Taxa zero implica em imutabilidade do capital", () => {
+    const principal = 500;
+    const result = calculateInterests(principal, 0, 10);
+
+    implies(result).is(principal);
+  });
+});
+
+axiom("Álgebra Booleana: Leis de De Morgan", () => {
+  const A = true;
+  const B = false;
+
+  proof("A negação da disjunção é a conjunção das negações", () => {
+    const lhs = !(A || B);
+    const rhs = !A && !B;
+
+    implies(lhs).is(rhs);
+  });
+});
+
+axiom("Análise de Funções Recursivas", () => {
+  const factorial = arbitrary();
+
+  // Configurando comportamento axiomático
+  factorial.derive((n: number): number => (n <= 1 ? 1 : n * factorial(n - 1)));
+
+  proof("Fatorial de 5 converge para 120", () => {
+    const res = factorial(5);
+    implies(res).is(120);
+  });
+});

package/examples/narrative.spec.ts

@@ -0,0 +1,61 @@
+import { NarrativeDialect } from "../src/index.js";
+
+const { intend, detail, to, standIn, background, before } = NarrativeDialect;
+
+intend("Jornada de Compra do Usuário", () => {
+  // Atores (Mocks)
+  const cart = standIn();
+  const paymentGateway = standIn();
+  const notificationService = standIn();
+
+  before(() => {
+    // Limpa estado para cada cena
+    cart.clear();
+    paymentGateway.clear();
+    notificationService.clear();
+  });
+
+  background(() => {
+    // Contexto: Carrinho tem itens e gateway está online
+    cart.getTotal.respondsWith(150.0); // Especifica o método
+    paymentGateway.process.respondsWith(true); // Especifica o método
+  });
+
+  detail("O cliente finaliza a compra com sucesso", () => {
+    // Ação: Usuário clica em 'Checkout'
+    const total = cart.getTotal();
+    const success = paymentGateway.process(total);
+
+    if (success) {
+      notificationService.sendEmail("Compra aprovada!");
+    }
+
+    // Expectativas narrativas
+    to(cart).wasCalled();
+    to(paymentGateway).uploaded(total); // Alias mental para 'received'
+    to(notificationService).received("Compra aprovada!");
+  });
+
+  detail("O sistema deve lidar com falha no pagamento", () => {
+    // Mudança de enredo: Gateway recusa
+    paymentGateway.process.respondsWith(false);
+
+    const success = paymentGateway.process(100);
+
+    to(success).be(false);
+    to(notificationService).not.wasCalled();
+  });
+});
+
+intend("Onboarding de Novos Membros", () => {
+  const database = standIn();
+
+  detail("Deve criar perfil padrão ao registrar", () => {
+    const newUser = { name: "Alice", email: "alice@wonder.land" };
+
+    // Simula o registro
+    database.save(newUser);
+
+    to(database).received(newUser);
+  });
+});