> For the complete documentation index, see [llms.txt](https://docs.skail.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.skail.dev/aprender/garantias/glossario.md).

# Glossário

Fonte única do vocabulário da documentação. Uma frase por termo, com a grafia usada em todas as páginas.

| Termo                          | Definição                                                                                                                                                                                                        |
| ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| skail                          | O produto. Sempre em minúsculo e no masculino: "o skail".                                                                                                                                                        |
| SDK                            | O pacote `Skail.Platform.Runtime` que você adiciona ao projeto: atributos, `SkailTask`, primitivas, analyzer.                                                                                                    |
| Runtime                        | O motor que roda dentro da sua aplicação: descobre métodos, busca trabalho no skail, faz replay, grava passos, exporta telemetria.                                                                               |
| Nuvem do skail                 | A plataforma operada pelo skail: recebe a API HTTP, acompanha cada execução passo a passo, agenda as esperas, entrega os eventos e reentrega o trabalho quando algo falha. Você não instala nem opera nada dela. |
| Portal                         | app.skailhq.com: projetos, environments, workloads, Monitor, Time Travel Debug.                                                                                                                                  |
| Function                       | Método marcado com `[SkailFunction]`; o orquestrador determinístico, reexecutado por replay a cada retomada.                                                                                                     |
| Command                        | Método marcado com `[SkailCommand]`; executa uma operação de I/O (banco, HTTP, fila, e-mail) ou produz um valor que muda a cada execução (hora atual, id gerado), uma vez por resultado, memoizado no histórico. |
| SkailTask, SkailTask\<T>       | Tipo de retorno obrigatório de functions e commands; awaitable que permite ao runtime interceptar cada `await`.                                                                                                  |
| Primitivas                     | Métodos estáticos de `SkailTask`: `Delay`, `DelaySeconds`, `DelayMinutes`, `WhenAll`, `WhenAny`, `WaitForEvent`, `WaitForEvent<T>`.                                                                              |
| Execução                       | Uma instância de uma function em andamento ou concluída, identificada por um TaskId. Também chamada de task na base técnica.                                                                                     |
| TaskId                         | Identificador da execução. É o último segmento da URL do trigger; disponível no código por `SkailContext.Current.TaskId`.                                                                                        |
| Trigger                        | A chamada `POST /trigger/{workload}/{versao}/{funcao}/{id}` que inicia uma execução.                                                                                                                             |
| Fire                           | A chamada `POST /api/v1/fire/{eventName}/{instanceId}` que dispara um evento externo.                                                                                                                            |
| Evento externo                 | Um sinal, com ou sem payload, disparado de fora por fire e recebido por `WaitForEvent`.                                                                                                                          |
| eventName                      | Nome do evento; identifica o tipo. Constante compartilhada, em MAIÚSCULAS\_COM\_UNDERSCORE.                                                                                                                      |
| instanceId                     | Identificador da instância aguardada; um id de negócio estável, idêntico no `WaitForEvent` e no fire.                                                                                                            |
| Histórico da execução          | A sequência de passos de uma execução, com argumentos e resultados. O replay percorre esse histórico; o Monitor o desenha como linha do tempo.                                                                   |
| Passo                          | Uma entrada do histórico da execução: início da function, resultado de um command, delay, evento recebido, composição.                                                                                           |
| Checkpoint                     | Um `await` dentro de uma function; cada um vira um passo.                                                                                                                                                        |
| Replay                         | Reexecução da function a partir do histórico da execução para retomar uma execução; passos já registrados devolvem o gravado sem executar.                                                                       |
| Determinismo                   | Propriedade de uma function de percorrer a mesma sequência de `await`s dado o mesmo histórico; exige que I/O, relógio e aleatoriedade fiquem em commands.                                                        |
| Memoização                     | Gravação do resultado de um command no histórico da execução, para que ele não execute de novo naquela execução.                                                                                                 |
| Hibernar                       | Pausar uma execução em um `Delay` ou `WaitForEvent` sem manter nada em memória.                                                                                                                                  |
| Retomar                        | Voltar a executar uma execução hibernada ou interrompida, do último passo concluído, via replay.                                                                                                                 |
| retryCount                     | Parâmetro dos atributos: máximo de reentregas do passo. 5 em `[SkailCommand]`, 15 em `[SkailFunction]` por padrão.                                                                                               |
| Reentrega                      | Nova entrega de uma execução após falha; o passo que falhou executa de novo, os concluídos não.                                                                                                                  |
| Idempotência                   | Propriedade de um efeito externo de poder ser aplicado mais de uma vez sem duplicar; garantida pelo seu código com uma chave de negócio.                                                                         |
| Projeto                        | Agrupador de mais alto nível no portal: environments, workloads e acessos de uma iniciativa.                                                                                                                     |
| Environment                    | Estágio do ciclo de vida dentro de um projeto (dev, hml, prod); tem chave, namespace e URL base próprios.                                                                                                        |
| Namespace                      | Identidade do environment para a API: `tenant/environment`. `SKAIL_NAMESPACE` e header `Skail-namespace`.                                                                                                        |
| Chave                          | Credencial do environment. `SKAIL_KEY` e header `skail-key`. Segredo.                                                                                                                                            |
| Workload                       | A aplicação vista pelo skail: `nome:versao`. `SKAIL_WORKLOAD`; aparece no caminho do trigger.                                                                                                                    |
| Versão do workload             | A parte depois dos dois-pontos; faz parte do endereço de cada function, por isso versiona o fluxo.                                                                                                               |
| URI do método                  | Endereço de uma function ou command: `nome:versao/NomeDoMetodo`. Pode ser fixado com `skailMethodName`.                                                                                                          |
| skailMethodName                | Parâmetro de `[SkailFunction]` que define a URI explicitamente; usado para versionar uma function sem versionar o workload.                                                                                      |
| Monitor                        | Área do portal com cada execução, estado e linha do tempo; permite retomada manual.                                                                                                                              |
| Time Travel Debug              | Reprodução local, na IDE, de uma execução a partir de uma captura do histórico, com os dados originais.                                                                                                          |
| Analyzer                       | `Skail.Platform.Analyzer`, o analisador Roslyn que cobra as regras SKAIL001, SKAIL002 e SKAIL003 na compilação.                                                                                                  |
| SkailNonDeterministicException | Exceção lançada quando o replay diverge do histórico: código não determinístico ou fluxo alterado com execuções em andamento.                                                                                    |
| VisibleToSkailPlatform         | Atributo de assembly obrigatório para o runtime descobrir os métodos.                                                                                                                                            |
| UseSkail, AddSkail             | Extensões que registram o runtime no host (`builder.UseSkail()`) ou nos serviços (`services.AddSkail()`).                                                                                                        |
| URL base da API                | Endereço do environment para trigger e fire; nos exemplos, `https://SEU_SKAIL_BASE_URL`.                                                                                                                         |

## Próximos passos

[Modelo de programação](/aprender/fundamentos/modelo-de-programacao.md) para ver os termos em uso. [Projetos, environments, namespaces e workloads](/aprender/arquitetura/projetos-environments-namespaces-e-workloads.md) para a hierarquia.
