# Comece aqui: do zero ao jogo publicado no catálogo

Este é o roteiro completo para pôr um jogo no plicflix, do cadastro até ele
**aparecer no catálogo para todos os assinantes**. Foi escrito para ser seguido
**ao pé da letra**, por uma pessoa ou por uma IA. Cada passo diz **quem faz**,
**o que fazer**, **onde** e **como saber que deu certo**.

> **Para IAs — leia antes de começar**
>
> 1. **O seu trabalho só termina quando o jogo está publicado** (ou, no
>    mínimo, enviado para revisão). Um jogo em `rascunho` **não aparece para
>    ninguém** além dos testadores. Integrar o código e parar aí é deixar o
>    trabalho pela metade. Confira a situação a qualquer momento com
>    `GET https://api.plicflix.com/v1/parceiro/jogos` (seção 4).
> 2. **Alguns passos só uma pessoa pode fazer** (marcados com 👤: criar contas,
>    aceitar termos, pagar, confirmar um e-mail, jogar no app). Quando chegar
>    num deles, **pare e peça à pessoa**, usando as mensagens prontas da
>    seção 8. Não pule o passo nem finja que foi feito.
> 3. Tudo o que é marcado com 🤖 você faz sozinha, com a chave `pk_` do
>    estúdio, pela API (`https://api.plicflix.com`) e pelo código do jogo.
> 4. O índice de todas as páginas, em texto puro: `https://developers.plicflix.com/llms.txt`
>    (tudo junto: `/llms-full.txt`; cada página em Markdown: some `.md`, ex.
>    `/docs/COMECE.md`). A API para máquinas: `https://developers.plicflix.com/openapi.json`.

## 1. O que é o plicflix (em 30 segundos)

- Um app de assinatura de jogos (web, Android, iOS). O jogador paga a
  assinatura e joga os jogos parceiros. **Todos veem o catálogo; para jogar é
  preciso assinar.**
- **O plicflix nunca hospeda o seu jogo.** O app abre o **seu** endereço
  (iframe na web, WebView no celular), com a tela de carregamento do plicflix
  na frente e a bolha do plicflix (avisos, amigos, sair) por cima.
- **Você recebe** 60% do líquido de cada assinante, dividido entre os jogos
  que ele jogou, pelo tempo ativo ([REGRAS](REGRAS)).

## 2. Os dois formatos de entrada

O jogador pode chegar ao seu jogo por duas portas. As duas entregam **o mesmo
jogador** (o mesmo `id` `pf_…`, fixo por pessoa e por jogo), então uma conta do
seu jogo serve às duas.

| | **A. Dentro do app** (obrigatório) | **B. Fora do app** (recomendado) |
|---|---|---|
| quando | o jogador toca em **Jogar** no plicflix | o jogador abriu o **seu** site ou app direto |
| o que você faz | carrega o SDK e troca um token no seu servidor | põe o botão **"Entrar com Plicflix"** (OAuth 2.0 + PKCE) |
| como o jogador chega | `…/?ref=plicflix#plicflix=pft_…` → `POST /v1/ingresso/trocar` | `plicflix.com/oauth/authorize` → `POST /v1/oauth/token` |
| guia | este roteiro (fase 3) e [SDK](SDK) | fase 4, [OAUTH](OAUTH) e [BOTAO](BOTAO) |

**O formato A é o que coloca o jogo no catálogo.** O B é um extra: faça depois
do A, sem atrasar a publicação.

## 3. Os endereços

| o quê | endereço |
|---|---|
| este portal (cadastro, painel, documentação) | `https://developers.plicflix.com` |
| o app (onde jogadores e testadores jogam) | `https://plicflix.com` |
| a API (o **seu servidor** chama) | `https://api.plicflix.com` |
| o SDK do navegador | `https://sdk.plicflix.com/plicflix.js` (ou uma cópia no seu site) |
| a origem que vai no seu `frame-ancestors` | `https://plicflix.com` |
| suporte | `suporte@plicflix.com` |

Não existe um "ambiente de testes" separado: você testa no plicflix de verdade,
como **testador** do seu próprio jogo ainda não publicado (fase 6). Só você e
quem você indicar enxergam o jogo até a equipe publicar.

## 4. Como o seu projeto fala com o plicflix

### 4.1 As variáveis de ambiente (no servidor do jogo)

| variável | valor | para quê |
|---|---|---|
| `PLICFLIX_CHAVE` | `pk_…` (fase 1, passo 3) | autentica o **seu servidor** na API. **Secreta:** nunca no navegador, no app nem no git |
| `PLICFLIX_API` | `https://api.plicflix.com` | a API (já é o padrão dos ajudantes) |
| `PLICFLIX_SLUG` | o identificador do jogo, ex. `ilha-das-luzes` | conferir que o token é **deste** jogo |
| `PLICFLIX_ORIGENS` | `https://plicflix.com` | o que vai no `frame-ancestors` |

### 4.2 Quem chama o quê

| quem | chama | autenticação |
|---|---|---|
| **o navegador** (a página do jogo) | o SDK (`window.Plicflix`) e a **sua** rota `/api/plicflix/entrar` | nenhuma chave (o token vem no endereço) |
| **o seu servidor** | `https://api.plicflix.com/v1/ingresso/trocar` e as rotas `/v1/parceiro/*` | `Authorization: Bearer <PLICFLIX_CHAVE>` |
| **a sua IA / os seus scripts** | as rotas `/v1/parceiro/*` (vitrine, mídia, conferência, revisão, repasse) | `Authorization: Bearer <PLICFLIX_CHAVE>` |

Ajudantes prontos para a troca do token (só a biblioteca padrão; leem
`PLICFLIX_CHAVE` e `PLICFLIX_API` do ambiente): [`plicflix.mjs`](/sdk/plicflix.mjs?baixar=1)
(Node 18+) e [`plicflix.go`](/sdk/plicflix.go?baixar=1) (Go). Outra linguagem:
é um POST comum (fase 3, passo 6).

### 4.3 O primeiro teste da chave (faça assim que tiver a chave)

```bash
curl -s https://api.plicflix.com/v1/parceiro/jogos -H "Authorization: Bearer $PLICFLIX_CHAVE"
# → {"parceiro":"Seu Estúdio","jogos":[{"slug":"ilha-das-luzes","situacao":"rascunho","status":"online",…}]}
```

- `401` = chave errada ou estúdio ainda não liberado (fatura em aberto).
- `situacao`: `rascunho` → `em_revisao` → `publicado` (ou `recusado`, com
  `motivo_recusa`). **Só `publicado` aparece no catálogo.**

### 4.4 As rotas que você vai usar, por fase

| fase | rota | o quê |
|---|---|---|
| 3 | `POST /v1/ingresso/trocar` `{token}` | a troca do token (no seu servidor) |
| 4 | `PUT /v1/parceiro/jogos/{slug}/oauth` `{redirect_uris}` | os endereços de volta do botão "Entrar com Plicflix" |
| 5 | `PUT /v1/parceiro/jogos/{slug}` | os textos da vitrine (parcial: só o que você enviar muda) |
| 5 | `POST /v1/parceiro/jogos/{slug}/midia/{campo}` | banner, pôster, logo, capturas, trailer |
| 7 | `GET /v1/parceiro/jogos/{slug}/conferencia?verificar=1` | **o que falta** para enviar (com a verificação automática) |
| 7 | `POST /v1/parceiro/jogos/{slug}/revisao` | **enviar para revisão** |
| 8 | `GET /v1/parceiro/jogos` | conferir se ficou `publicado` |

Detalhes e formatos: [API](API) e [`/openapi.json`](/openapi.json).

## 5. Quem faz cada passo

| fase | passo | quem |
|---|---|---|
| 1 | criar a conta do estúdio, aceitar os termos | 👤 pessoa |
| 1 | pagar a taxa de entrada | 👤 pessoa |
| 1 | gerar a chave e entregar ao servidor/IA | 👤 pessoa |
| 2 | cadastrar o jogo (nome, slug, endereço, rota de status) | 👤 pessoa no portal (ou 🤖, se a pessoa der o login do portal) |
| 3 | integrar o SDK, a troca do token e os cabeçalhos (formato A) | 🤖 |
| 4 | o botão "Entrar com Plicflix" (formato B, recomendado) | 🤖 |
| 5 | a vitrine: textos e imagens | 🤖 (pela API) |
| 6 | criar uma conta de jogador, confirmar o e-mail e virar testador | 👤 pessoa |
| 6 | jogar uma vez dentro do app (ou dar à IA a conta testadora) | 👤 pessoa, ou 🤖 com a conta testadora |
| 7 | endereço público, conferir e **enviar para revisão** | 🤖 |
| 8 | revisar e **publicar** | equipe plicflix |
| 8 | conferir que está no catálogo e avisar a pessoa | 🤖 |

## 6. O roteiro

### Fase 1 — A conta e a chave 👤

**1. Criar a conta de desenvolvedor.** Em `https://developers.plicflix.com/cadastro`:
o nome, o e-mail, uma senha (10 ou mais caracteres) e o estúdio (nome, CPF ou
CNPJ — com ou sem pontuação —, país, site); aceite os [termos](TERMOS).
*Deu certo quando:* você cai no painel e chega um e-mail de boas-vindas com o
link de confirmar o endereço e a fatura da taxa de entrada.

**2. Pagar a taxa de entrada.** A fatura aparece no topo do painel. Enquanto o
pagamento on-line não está ligado, responda ao e-mail da fatura (ou escreva
para `suporte@plicflix.com`) com o número dela: mandamos o Pix ou o boleto.
*Deu certo quando:* chega o e-mail "Payment received" e o painel libera
**Gerar chave** e **Novo jogo**. Enquanto isso, a IA já pode adiantar a fase 3
(o código não depende da chave para ser escrito).

**3. Gerar a chave.** Painel → **Gerar chave** → uma chave `pk_…`, que
**aparece uma vez**. Ponha no servidor do jogo como `PLICFLIX_CHAVE` (e entregue
à IA da mesma forma, por variável de ambiente — nunca colada no código).
*Deu certo quando:* o teste da seção 4.3 responde 200. Perdeu a chave? Gere
outra; a antiga para de funcionar na hora.

### Fase 2 — Cadastrar o jogo 👤

**4.** Painel → **Novo jogo** (`/jogos/novo`):

| campo | exemplo | regra |
|---|---|---|
| nome | `Ilha das Luzes` | até 60 letras |
| identificador (slug) | `ilha-das-luzes` | minúsculas, números e `-`; **não muda depois**; vira o `PLICFLIX_SLUG` |
| endereço | `https://ilha.exemplo.com/` | a página que o app abre; https (para testar, pode ser `http://localhost:4100/`) |
| rota de status | `https://ilha.exemplo.com/saude` | responde 200 rápido; a vigia consulta a cada minuto |

*Deu certo quando:* `GET /v1/parceiro/jogos` (seção 4.3) lista o jogo com
`"situacao":"rascunho"`. O endereço pode mudar depois (aba **Integração →
Endereço do jogo**) enquanto estiver em rascunho ou recusado.

### Fase 3 — Formato A: dentro do app 🤖

**5. O SDK no navegador.** Baixe [`plicflix.js`](/sdk/plicflix.js?baixar=1) para
o seu site (sem mudar nada) e carregue **antes** do jogo, **por uma tag
`<script src>` no HTML da página** — não importe nem empacote o SDK dentro do
bundle do seu jogo (Vite, webpack…). O verificador do plicflix procura essa tag
na página, e o arquivo separado é o que permite atualizar o SDK sem recompilar
o jogo:

```html
<script src="/plicflix.js"></script>
<script type="module" src="/jogo.js"></script>
```

```js
// jogo.js
if (Plicflix.dentro()) {
  Plicflix.progresso(10, "Entrando…");                       // a tela do plicflix acompanha
  try {
    await Plicflix.entrar("/api/plicflix/entrar");           // passo 6: o SEU servidor troca o token
  } catch {
    // recarregou a página depois de entrar? use a sessão que já existe (o cookie)
  }
  Plicflix.aoSair(async () => { await salvarProgresso(); }); // o "Sair" da bolha espera (até 5 s)
  Plicflix.aoIrPara(async (destino) => levarAte(destino));   // opcional: "ir até o amigo"
}
// … carregue o jogo …
Plicflix.pronto();                                           // tira a tela de carregamento
Plicflix.onde({ texto: "Praia do Norte", area: "ilha/praia", ponto: { x: 10, y: 4 } }); // a cada troca de lugar
```

Referência completa: [SDK](SDK#11-referência-do-sdk). Unity, Godot, jogos sem
servidor: [MOTORES](MOTORES).

**6. A troca do token no servidor.** Uma rota sua (ex. `POST /api/plicflix/entrar`)
recebe `{ token, contexto }` do `Plicflix.entrar` e faz:

```
POST https://api.plicflix.com/v1/ingresso/trocar
Authorization: Bearer <PLICFLIX_CHAVE>
Content-Type: application/json

{"token":"pft_…"}
```

Resposta 200:

```json
{"jogador":{"id":"pf_4olrydypdwdxj3adjnzjvgss","nome":"Ana"},"jogo":"ilha-das-luzes",
 "partida":"pt_…","assinante":true,"contexto":{"ref":"plicflix","idioma":"pt-BR","plataforma":"web"}}
```

Depois:
1. confira `jogo == PLICFLIX_SLUG` (senão, 401);
2. ache ou crie a conta pelo `jogador.id` e atualize o `nome`;
3. abra a sessão com o cookie, escrito à mão:
   `Set-Cookie: sessao=…; Path=/; HttpOnly; Secure; SameSite=None; Partitioned`;
4. responda 200.

`401` da API = token inválido, vencido (5 min) ou já usado: peça para abrir de
novo pelo plicflix.

**7. Deixar o plicflix abrir o jogo.** Na página do jogo:

```
Content-Security-Policy: frame-ancestors 'self' https://plicflix.com
```

E **nenhum** `X-Frame-Options`. Mais a rota de status respondendo 200.

**Atalho:** o [exemplo de referência](/sdk/exemplo-node.zip) (Node, sem
dependências) já faz os passos 5, 6 e 7; também em [Go](/sdk/exemplo-go.zip).

*Deu certo quando (sem o app):*
- `curl -sI https://SEU-JOGO/ | grep -i frame-ancestors` mostra `https://plicflix.com`;
- `curl -s https://SEU-JOGO/plicflix.js | head -2` mostra o SDK;
- `curl -s -X POST https://SEU-JOGO/api/plicflix/entrar -H 'Content-Type: application/json' -d '{"token":"pft_x"}'`
  responde um erro de token (e **não** 404) — a rota existe e conversa com a API.

### Fase 4 — Formato B: fora do app (recomendado) 🤖

O botão **"Entrar com Plicflix"** no seu site ou app nativo. Faça depois da
fase 3; ele não trava a publicação.

1. Cadastre os endereços de volta:
   `PUT /v1/parceiro/jogos/{slug}/oauth` com `{"redirect_uris":["https://SEU-JOGO/api/plicflix/volta"]}`.
2. Duas rotas no seu servidor (ir para `plicflix.com/oauth/authorize` com PKCE;
   voltar e trocar o código em `POST /v1/oauth/token`) — o exemplo completo
   está em [OAUTH](OAUTH), seção 4.3.
3. O botão: uma tag só, `<plicflix-entrar>` ([BOTAO](BOTAO)).

*Deu certo quando:* clicar no botão leva ao plicflix, a pessoa autoriza e volta
logada no seu jogo com o **mesmo** `pf_…` da entrada pelo app.

### Fase 5 — A vitrine 🤖

Textos e imagens que o jogador vê antes de jogar ([VITRINE](VITRINE)):
- **textos:** `PUT /v1/parceiro/jogos/{slug}` com frase de chamada (20+
  letras), descrição curta (40+), "Sobre o jogo" (300+), gêneros, tags,
  classificação indicativa (obrigatória), plataformas e cor;
- **imagens:** `POST /v1/parceiro/jogos/{slug}/midia/{campo}` (banner, pôster,
  logo transparente, 3 a 12 capturas; trailer opcional) — cada arquivo é
  conferido na hora e a resposta diz o que está fora do padrão.

*Deu certo quando:* em `GET …/conferencia` (fase 7) todos os itens do grupo
**Vitrine** estão `"ok": true`.

### Fase 6 — Testar como testador 👤 (+ 🤖)

A lista de conferência só fica verde em **Entrada pelo SDK** e **Tela de
carregamento** quando uma partida de verdade acontece. Para isso:

1. 👤 Uma pessoa cria uma conta de jogador em `https://plicflix.com` e
   confirma o e-mail com o código.
2. 👤 No portal: o jogo → aba **Testadores** → adiciona o e-mail dessa conta.
3. 👤 Com essa conta, em `https://plicflix.com`, fileira **"Em teste (só você
   vê)"** → **Jogar**. Testador não precisa de assinatura. O jogo pode estar em
   `http://localhost` nessa hora.
   - **Ou** 🤖: a pessoa dá à IA o e-mail e a senha da conta testadora, e a IA
     faz a partida pela API ([API](API#testar-pela-api)): `POST /v1/entrar` →
     `POST /v1/jogos/{slug}/jogar` → abre a URL devolvida num navegador
     automatizado (ou manda o token para a sua rota) → `POST /v1/partidas/{id}/carregou`.

*Deu certo quando:* o jogo abre dentro do app sem pedir login, a tela de
carregamento some sozinha, a bolha aparece por cima, **Sair do jogo** fecha em
menos de 5 s com o progresso salvo — e `GET …/conferencia` mostra
`"Entrada pelo SDK"` e `"Tela de carregamento"` com `"ok": true`.

### Fase 7 — Conferir e enviar para revisão 🤖

1. O jogo precisa estar num **endereço público com https** (não `localhost`).
   Se não estiver, peça à pessoa para trocar no portal (aba **Integração →
   Endereço do jogo**) e espere a vigia ver o servidor no ar (até 2 minutos).
2. Veja o que falta:

   ```bash
   curl -s "https://api.plicflix.com/v1/parceiro/jogos/$PLICFLIX_SLUG/conferencia?verificar=1" \
     -H "Authorization: Bearer $PLICFLIX_CHAVE"
   # → {"situacao":"rascunho","pode_enviar":false,"faltando":["Integração: Entrada pelo SDK (…)"],"itens":[…]}
   ```

   Resolva cada item de `faltando` (a fase de cada um está acima) e repita até
   `"pode_enviar": true`.
3. Envie:

   ```bash
   curl -s -X POST "https://api.plicflix.com/v1/parceiro/jogos/$PLICFLIX_SLUG/revisao" \
     -H "Authorization: Bearer $PLICFLIX_CHAVE"
   # → {"ok":true,"situacao":"em_revisao"}     (409 + "faltando" se ainda falta algo)
   ```

*Deu certo quando:* `GET /v1/parceiro/jogos` mostra `"situacao":"em_revisao"`
e chega o e-mail "… is in review". (Pelo portal: aba **Integração → Conferir
agora** e **Enviar para revisão** fazem o mesmo.)

### Fase 8 — Revisão, publicação e conferência final

1. A equipe plicflix abre o jogo, joga e confere — em geral em até 3 dias
   úteis. A resposta chega por e-mail: **publicado** ou **recusado com o
   motivo** (`motivo_recusa` em `GET /v1/parceiro/jogos`). Recusado: corrija o
   motivo e volte à fase 7.
2. 🤖 Confira que está no catálogo:

   ```bash
   curl -s https://api.plicflix.com/v1/parceiro/jogos -H "Authorization: Bearer $PLICFLIX_CHAVE"   # "situacao":"publicado"
   curl -s https://plicflix.com/v1/inicio | grep -o '"slug":"'$PLICFLIX_SLUG'"' | head -1      # aparece na tela inicial
   ```

3. 🤖 Avise a pessoa (mensagem pronta na seção 8).

**Depois de publicado:** mantenha a rota de status respondendo (fora do ar, o
app não deixa abrir); responda aos casos de reclamação em até 48 horas úteis
([REGRAS](REGRAS#reclamações)); acompanhe o repasse em `GET /v1/parceiro/repasses`.
Atualizar a vitrine não precisa de nova revisão.

## 7. A lista final (copie e marque)

**Para publicar (obrigatório)**
- [ ] `GET /v1/parceiro/jogos` responde 200 com a chave (seção 4.3).
- [ ] `plicflix.js` carregado por `<script src>` no HTML, antes do jogo (não no bundle); `Plicflix.entrar(...)` quando `Plicflix.dentro()`.
- [ ] A rota do servidor troca o token com `PLICFLIX_CHAVE` e confere `jogo == PLICFLIX_SLUG`.
- [ ] A conta ligada a `jogador.id` (único), sem senha utilizável, nome atualizado a cada entrada.
- [ ] `frame-ancestors 'self' https://plicflix.com` e nenhum `X-Frame-Options`.
- [ ] Cookie da sessão com `SameSite=None; Secure; Partitioned`.
- [ ] `Plicflix.pronto()` e `Plicflix.aoSair` (salvando em até 5 s).
- [ ] Rota de status respondendo 200 num endereço público com https.
- [ ] Vitrine completa com a qualidade mínima.
- [ ] Uma partida de testador feita (fase 6).
- [ ] `GET …/conferencia` com `"pode_enviar": true` → `POST …/revisao` → `"em_revisao"`.
- [ ] Depois da equipe: `"situacao":"publicado"` e o jogo em `https://plicflix.com/v1/inicio`.

**Recomendado**
- [ ] O botão "Entrar com Plicflix" (formato B).
- [ ] `Plicflix.progresso` durante o carregamento e `Plicflix.erro` se não der para abrir.
- [ ] `Plicflix.onde({ texto, area, ponto })` a cada troca de lugar.
- [ ] `Plicflix.aoIrPara` levando até o amigo pelo `jogador_id`, decidido no servidor.

## 8. Mensagens prontas (para a IA pedir à pessoa)

Use estas mensagens quando chegar num passo 👤. Troque o que está entre `<>`.

**Fase 1 — a conta, o pagamento e a chave**
> Para pôr o jogo no plicflix, preciso de três coisas que só você pode fazer:
> 1. criar a conta do estúdio em https://developers.plicflix.com/cadastro;
> 2. pagar a taxa de entrada (responda ao e-mail da fatura pedindo o Pix ou o boleto);
> 3. no painel, clicar em **Gerar chave** e colocar a chave `pk_…` no servidor do
>    jogo como `PLICFLIX_CHAVE` (não me mande a chave pelo chat).
> Enquanto isso, eu adianto a integração do código.

**Fase 2 — cadastrar o jogo**
> No painel do developers, clique em **Novo jogo** e preencha: nome `<nome>`,
> identificador `<slug>`, endereço `<https://…/>`, rota de status `<https://…/saude>`.
> Me avise quando estiver feito.

**Fase 6 — o testador**
> Falta uma partida de teste dentro do app para a lista de conferência ficar verde:
> 1. crie uma conta em https://plicflix.com e confirme o e-mail com o código;
> 2. no developers: o jogo `<slug>` → aba **Testadores** → adicione esse e-mail;
> 3. em https://plicflix.com, fileira **"Em teste (só você vê)"** → **Jogar**, e
>    jogue um minuto; depois toque em **Sair do jogo** na bolha.
> Me diga se entrou sem pedir login e se a tela de carregamento sumiu sozinha.

**Fase 7 — o endereço público** (só se o jogo estiver em `localhost`)
> O jogo precisa de um endereço público com https para ir à revisão. No developers:
> o jogo → aba **Integração → Endereço do jogo** → `<https://…/>` e a rota de
> status `<https://…/saude>`.

**Fase 8 — o resultado**
> O `<nome>` foi enviado para revisão em `<data>` (situação `em_revisao`). A equipe
> do plicflix responde por e-mail, em geral em até 3 dias úteis. Quando sair
> `publicado`, ele aparece no catálogo de https://plicflix.com para todos.

## 9. Erros comuns

| sintoma | causa | conserto |
|---|---|---|
| **o jogo não aparece no catálogo** | a situação ainda é `rascunho` ou `em_revisao` | fases 7 e 8: só `publicado` aparece para todos |
| o jogo não aparece nem para mim | a conta não é testadora, ou o e-mail dela não foi confirmado | fase 6 |
| tela branca dentro do app; o console fala em `frame-ancestors` | o `frame-ancestors` não tem `https://plicflix.com`, ou há `X-Frame-Options` | passo 7 |
| `GET /v1/parceiro/jogos` dá 401 | chave errada, ou fatura em aberto | fase 1 |
| `Plicflix.entrar` dá 401 | token vencido (5 min), já trocado, de outro estúdio, ou chave errada | abra de novo pelo app; confira `PLICFLIX_CHAVE` |
| entra, mas ao recarregar pede login | o cookie sem `SameSite=None; Secure; Partitioned` | passo 6.3 |
| a tela de carregamento fica 12 s e some sozinha | o jogo não chama `Plicflix.pronto()` | chame quando o jogador puder jogar |
| "Sair do jogo" demora 5 s | o `aoSair` não terminou | salve mais rápido |
| `await` dá erro de sintaxe | o script não é módulo | `<script type="module">` |
| "A página carrega o SDK" vermelho, mas o jogo usa o SDK | o SDK foi importado/empacotado no bundle | carregue com `<script src="/plicflix.js">` no HTML (passo 5) |
| `POST …/revisao` dá 409 | ainda faltam itens | `GET …/conferencia` diz quais |
| "Endereço público" vermelho | o endereço ainda é `localhost` | fase 7, item 1 |

## 10. Ajuda

`suporte@plicflix.com`. Diga o identificador do jogo e o que você já tentou.