> 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/referencia/garantias/garantias-de-execucao.md).

# Garantias de execução

O que o skail promete sobre uma execução, o que não promete, e o que fica a cargo do seu código. Em uma tabela, para o arquiteto que precisa decidir.

## O que o skail garante

| Garantia                   | O que significa                                                                                                       | Mecanismo                                                                                    |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| Retomada                   | Uma execução interrompida (queda, restart, deploy, fim de espera) continua do último `await` concluído, sem recomeçar | Histórico por execução e replay da function                                                  |
| Memoização de commands     | Um command que gravou o resultado não executa de novo naquela execução, em nenhuma retomada                           | Passo com argumentos e resultado no histórico; o replay devolve o gravado                    |
| Retry de commands          | Um command que lança exceção é reexecutado até `retryCount` vezes antes de a exceção chegar à function                | Reentrega da execução; `retryCount` do command (5 por padrão)                                |
| Retry de functions         | Uma function que lança exceção é reentregue até o seu `retryCount` (15 por padrão), sem repetir commands concluídos   | Reentrega; memoização                                                                        |
| Espera durável por tempo   | Um delay sobrevive a qualquer interrupção da aplicação e a execução retoma no prazo                                   | Agendamento no skail; hibernação                                                             |
| Entrega de evento          | Um fire com o mesmo nome e instance id de uma espera retoma a execução dessa espera, mesmo que chegue antes dela      | Casamento de nome e id no skail; um fire que chega antes é entregue quando a espera aparecer |
| Um dono por execução       | Duas instâncias da sua aplicação não processam a mesma execução ao mesmo tempo                                        | Garantido pelo skail na entrega                                                              |
| Isolamento por environment | Execuções, histórico e eventos de um environment não são visíveis de outro                                            | Namespace `tenant/environment` e chave por environment                                       |
| Rastreabilidade            | Cada passo de cada execução fica visível, em ordem, com tempos e tentativas                                           | Histórico da execução e telemetria no Monitor                                                |

## O que o skail não garante

| Não garantido                                           | Por quê                                                                                                                                                                                     | O que fazer                                                                                                                                                                                             |
| ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Operação externa exatamente uma vez                     | Se um command falha entre executar a operação externa e gravar o resultado, a próxima tentativa executa a operação de novo. A janela é pequena e inevitável em qualquer sistema distribuído | Chave de idempotência (id de negócio) em toda chamada externa. Ver [Como escrever commands idempotentes](/construa/como-fazer/escrever-commands-idempotentes.md)                                        |
| Distinção entre erro transitório e definitivo           | O runtime não classifica exceções; toda exceção gera nova tentativa enquanto houver `retryCount`                                                                                            | Falha de negócio como resultado; se vier como exceção, `retryCount: 0` no command e tratamento na function. Ver [Como tratar erros e compensar](/construa/como-fazer/tratar-erros-e-desfazer-passos.md) |
| Compatibilidade automática entre versões de código      | Uma execução em andamento referencia a sequência de `await`s da versão em que começou                                                                                                       | Versionar a function ou o workload antes de mudar o fluxo. Ver [Versionamento](/construa/conceitos/versoes-com-execucoes-em-andamento.md)                                                               |
| Ordem de conclusão ao esperar todos em paralelo         | As ramificações terminam em ordem não determinada                                                                                                                                           | Ler resultados pela posição                                                                                                                                                                             |
| Latência de retomada                                    | A retomada depende de haver uma instância da sua aplicação rodando com esse workload                                                                                                        | Manter réplicas suficientes e observar o estado Na fila no Monitor                                                                                                                                      |
| Entrega de evento sem espera correspondente para sempre | Um fire que chega antes da espera pelo evento é entregue quando a espera aparecer, mas não conte com isso por tempo indeterminado                                                           | Dispare o evento depois do trigger da execução que vai esperar por ele                                                                                                                                  |
| Estado compartilhado entre execuções                    | Cada execução tem o próprio histórico; não há memória compartilhada nem lock distribuído exposto                                                                                            | Estado compartilhado no seu banco, via commands                                                                                                                                                         |

## O que fica com o seu código

* Determinismo da function (sem I/O, relógio ou aleatoriedade fora de commands).
* Idempotência da operação externa.
* Prazo em toda espera.
* Versionamento ao mudar fluxos com execuções em andamento.
* Retry no chamador do trigger e do fire, que ficam fora da durabilidade.
* Tamanho e conteúdo dos argumentos (o que trafega para o skail).

## Próximos passos

[Falhas, retries e idempotência](/construa/conceitos/retries-e-idempotencia.md) detalha as duas primeiras linhas. [Limites e cotas](/referencia/limites-e-cotas.md) para os números. [Segurança](/referencia/garantias/seguranca.md) para isolamento e dados.