# Fluxo, variáveis e nós de estrutura

Esta página descreve como os fluxos são estruturados, como referência para desenvolvedores e agentes de IA que escrevem fluxos. Use o [esquema de estrutura](/pt/browser-rpa/local-api#contrato-local-leg%C3%ADvel-por-m%C3%A1quina) junto com esta página; o [endpoint de validação](/pt/browser-rpa/api/validate-workflow) é responsável pela semântica. Para começar, consulte a [Referência da Local API](/pt/browser-rpa/local-api) e o [Início rápido](/pt/browser-rpa/quickstart).

## 1. Documento e ordem

```json
{
  "editorVersion": 2,
  "editorParametersVersion": 1,
  "variables": {
    "type": "object",
    "properties": {}
  },
  "nodes": [
    {
      "id": "start",
      "type": "start"
    },
    {
      "id": "end",
      "type": "end",
      "data": {
        "inputsValues": {
          "status": {
            "type": "constant",
            "content": "success"
          },
          "message": {
            "type": "constant",
            "content": "Done"
          }
        }
      }
    }
  ]
}
```

As gravações aceitam apenas editorVersion=2 e editorParametersVersion=1. Os dados com a versão de parâmetros 2 ainda podem ser lidos na forma original, mas os chamadores externos não os reescrevem silenciosamente. Edite esses dados somente depois que eles forem migrados explicitamente no cliente desktop. A ordem do array é a ordem de execução, e blocks expressa o aninhamento. Não há arestas, conexões nem estados de ativação.

O array raiz tem start primeiro e end por último, com exatamente um de cada. Todo nó tem um id exclusivo. Recomendamos que um ID comece com uma letra ASCII, continue com letras, dígitos ou sublinhados e tenha no máximo 64 caracteres. Os IDs não podem usar os nomes reservados do editor `system`, `initVars` ou `custom`. Os IDs de grupos e de ramificações também contam para a exclusividade. Uma ação comum usa type=`browser_<action>`, data.browserAction deve corresponder a ele, e as entradas dela ficam em data.browserUi.inputs.

A área de dados compartilhada contém title/description, meta (dados de exibição em JSON) e data.inputs/outputs (descrições do editor; as saídas dos nós de ação são geradas pelo servidor, consulte [Campos preenchidos pelo servidor](#campos-preenchidos-pelo-servidor)). Os valores em browserUi.test e os resultados simulados de inicialização não são resultados reais; por isso, não os use para tomar decisões sobre uma execução. Para o contrato consolidado de cada tipo de nó, consulte os [contratos de nó estáticos](/pt/browser-rpa/nodes). Ele abrange a estrutura de entrada, os valores padrão, as condições, as variantes de saída e as políticas de campo.

## 2. Variáveis iniciais: seis tipos de campo

variables=`{type:'object',properties:{fieldName:Variable},required?:string[]}`. Os nomes de parâmetros podem conter caracteres chineses. Um nome não pode ficar vazio depois de remover os espaços das extremidades, não pode conter `.`, `[`, `]`, `${` nem `}` e não pode ser igual a custom/system/parameters nem a qualquer ID de nó deste fluxo. Os nomes `__proto__`, `constructor` e `prototype` são proibidos. Toda entrada em required deve existir em properties, e entradas duplicadas são rejeitadas.

Uma Variable pública pode usar estas propriedades: type, description, default e extra. A propriedade extra contém a configuração do editor declarada abaixo. Uma gravação pública rejeita campos desconhecidos que afetam a execução, e a configuração de exibição aceita apenas campos publicados. Um campo é obrigatório quando `extra.required=true` ou quando a lista required de nível superior o contém. Recomendamos usar apenas o required de nível superior. Se os dois entrarem em conflito, a gravação retorna 422, em vez de deixar que agentes de IA dependam de uma precedência implícita.

| Tipo de negócio | Declaração | Configuração extra e valores padrão | Valor de execução comum |
|  --- | --- | --- | --- |
| String | type=string | extra.private=false, localPath=false; charValid={enabled:false,value:…}; multiline={value:1,autoHeight:true} | kind=json, value é uma string |
| Número | type=number; inteiros também podem usar type=integer | decimalPlaces: padrão 2 para number e fixo em 0 para integer (igual ao editor); numberRange={enabled:false,min:null,max:null}; numberSuffix={enabled:false,value:''} | kind=json, value é um número finito; o intervalo e a precisão devem corresponder à declaração |
| Booleano | type=boolean | Sem extra de negócio | kind=json, value é um booleano |
| Array | type=array | multiline={value:1,autoHeight:true} | kind=json, value é um array JSON; não passe uma string JSON no lugar dele |
| Objeto | type=object | multiline={value:1,autoHeight:true} | kind=json, value é um objeto JSON |
| Arquivo | type=object para um único arquivo, type=array para vários arquivos; extra.type=file | multipleFiles={enabled:false,unlimited:false,maxCount:9} (para vários arquivos, omitir maxCount permite até 9 arquivos, e somente unlimited=true remove o limite de quantidade); formatType é um array de extensões de arquivo; sizeLimit={unit:'KB' ou 'MB',value:número positivo} e, quando omitido, cada arquivo pode ter no máximo 10MB (igual ao editor) | kind=json, value é uma string com caminho local absoluto (um único arquivo) ou um array de strings (vários arquivos). O servidor faz referência direta ao arquivo nesse caminho, da mesma forma que uma execução no cliente, sem copiá-lo. O caminho deve existir e atender aos limites de extensão, quantidade e tamanho. A url que o nó recebe é esse caminho. Os parâmetros de arquivo não podem declarar um valor padrão |


A configuração multiline.value é um inteiro de 1 a 200. Para quantidade de caracteres, precisão e limites de arquivo, o contrato em vigor é a referência oficial; não use dados simulados da interface. Os campos extra.name/index/placeholder são campos de exibição e não alteram o nome usado para referenciar o parâmetro. O fieldId é a chave em properties.

Um valor padrão comum tem duas representações existentes no editor. Variable.default é o recomendado, e extra.defaultValue={enabled:true,value:…} é aceito por compatibilidade. Definir extra.defaultValue.enabled=false significa explicitamente que não há valor padrão. Quando enabled=true, o value dele se aplica. Se default também for informado e os dois forem diferentes, uma gravação pública retorna RPA_DEFAULT_CONFLICT em vez de escolher um deles silenciosamente. Um valor padrão de array ou de objeto é um valor JSON. Uma execução não pode começar quando falta um valor obrigatório e não há valor padrão. Omitir um valor opcional é diferente de passar um null explícito ou um array vazio, e null precisa passar na validação do campo de destino.

```json
{
  "type": "object",
  "properties": {
    "targetUrl": {
      "type": "string",
      "description": "Target URL",
      "default": "https://example.com"
    },
    "count": {
      "type": "integer",
      "default": 2,
      "extra": {
        "decimalPlaces": 0,
        "numberRange": {
          "enabled": true,
          "min": 1,
          "max": 10
        }
      }
    },
    "enabled": {
      "type": "boolean",
      "default": true
    },
    "items": {
      "type": "array",
      "default": []
    },
    "settings": {
      "type": "object",
      "default": {}
    },
    "attachment": {
      "type": "object",
      "extra": {
        "type": "file",
        "multipleFiles": {
          "enabled": false
        },
        "formatType": [
          "txt"
        ],
        "sizeLimit": {
          "unit": "KB",
          "value": 100
        }
      }
    }
  },
  "required": [
    "targetUrl"
  ]
}
```

Fluxos com parâmetros de arquivo, ou com parâmetros string que têm localPath=true, podem ser executados externamente, assim como em uma execução no cliente. Passe um caminho local no momento da execução.

## 3. Valores padrão privados

Uma variável privada deve ter type=string e extra.private=true. A Local API não oculta valores privados. Você pode enviar um valor padrão em texto simples, GET retorna o valor padrão em texto simples, e um fluxo com parâmetros privados pode ser executado externamente (no momento da execução, você pode passar o texto simples diretamente; consulte [ParameterValues](/pt/browser-rpa/api/data-types#parametervalues)).

Grave um valor padrão em texto simples:

```json
{
  "type": "string",
  "default": "p@ssw0rd",
  "extra": {
    "private": true,
    "defaultValue": {
      "enabled": true,
      "value": "p@ssw0rd"
    }
  }
}
```

Isso corresponde à forma como o editor de Modelos Personalizados do cliente salva: o texto simples é gravado como está no conteúdo do modelo na nuvem, e GET o retorna na forma de texto simples mostrada acima. Quando o editor do cliente salva um valor padrão como referência ao armazenamento seguro local, a leitura nesta máquina descriptografa o valor e o retorna.

| Caso de gravação ou leitura | Regra |
|  --- | --- |
| POST/PUT/node-edits envia default ou defaultValue.value em texto simples | Gravado como está no modelo na nuvem; o salvamento é bem-sucedido |
| GET dos detalhes do modelo | Os valores padrão privados são retornados em texto simples como `default` e `defaultValue:{enabled:true,value}`; `redactedPaths` é sempre `[]` |
| Respostas dos endpoints de gravação (criação, atualização, cópia, edições de nós) | Igual a GET; os valores padrão privados são retornados em texto simples |
| Recibos de idempotência (repetição com a mesma chave, o resultado de `GET /requests/{key}`) | Os recibos não armazenam o conteúdo do modelo. Na repetição, o servidor lê novamente o modelo na nuvem e retorna o conteúdo atual dele, assim como GET |
| PUT/validação inline que traz o modelo original como base, o nome de campo original, string e private=true, e envia de volta `publicState:"retained"` | Mantém o valor padrão existente deste campo neste modelo (para compatibilidade com chamadores mais antigos); se não houver valor padrão correspondente, retorna 422 RPA_PRIVATE_DEFAULT_INVALID |
| retained enviado para um novo modelo, ou para outro modelo ou campo | 422 RPA_PRIVATE_DEFAULT_INVALID; o valor não é obtido de outro modelo. Para um novo modelo, envie o texto simples |
| defaultValue omitido, ou enabled=false | Remove o valor padrão existente; o campo pode continuar privado; retorna o aviso RPA_PRIVATE_DEFAULT_CLEARED |
| node-edits sem o campo variables | Mantém as variáveis existentes no servidor e os valores padrão privados |
| node-edits com o campo variables completo | Tratado da mesma forma que PUT |
| Cópia | A cópia mantém os valores padrão privados do modelo de origem, sem aviso |
| O valor padrão privado é uma referência ao armazenamento seguro local que não pode mais ser lida (por exemplo, foi salvo em outro dispositivo ou o armazenamento seguro local foi redefinido) | GET retorna `{enabled:false}` com o aviso RPA_PRIVATE_DEFAULT_UNAVAILABLE; envie novamente o texto simples para restaurá-lo |


Uma chamada somente de validação é somente leitura. Ela não grava o modelo na nuvem nem cria ou altera valores no armazenamento seguro. Os parâmetros privados devem ser strings, e `publicState` só pode ser usado em campos string privados.

NodeContract atribui a cada campo sensitivity=public|secret|credential|localPath|inlineFile|sourceCode, que apenas descreve a natureza do campo. `authoringPolicy` é sempre `allowed`. Campos como código-fonte de scripts (javaScript/injectJavaScript.content), caminhos locais (o path de cada ação de arquivo, a pasta de capturas de tela), arquivos inline, Cookie/LocalStorage e chaves 2FA aceitam diretamente um literal ou uma referência. GET os retorna como estão, e as execuções não são restringidas. Os chamadores devem armazenar e ocultar esse conteúdo por conta própria; consulte [Limites de dados e de execução](/pt/browser-rpa/api/common#limites-de-dados-e-de-execu%C3%A7%C3%A3o).

## 4. Os seis nós de estrutura

| type | data | blocks | Semântica de execução |
|  --- | --- | --- | --- |
| start | title/description; customVariables; taskSettings (configurações da tarefa do modelo, veja abaixo); os inputsValues descritivos de inicialização podem ser mantidos, mas não fornecem parâmetros reais de execução | Omitido ou [] | Primeiro na raiz; declara as variáveis personalizadas deste fluxo |
| end | inputsValues.status/message; recomenda-se um success ou failed fixo para status; message pode ser um WorkflowValue; null se torna uma string vazia, objetos passam por JSON.stringify e outros valores passam por String, de modo que o valor final é uma string | Omitido ou [] | Encerra o fluxo atual; status=failed faz com que ele falhe, caso contrário ele é bem-sucedido; as gravações públicas rejeitam outros literais determinísticos; o resultado bruto público é a string de message |
| group | title/name/description/collapsed | Array de nós obrigatório, pode ficar vazio; **não pode conter outro grupo** (grupos não podem ser aninhados, igual ao editor; caso contrário, é retornado RPA_INVALID_NODE) | Organiza a ordem e não produz um resultado de execução que possa ser referenciado por si só; é achatado em tempo de execução, mas o fluxo salvo mantém o grupo |
| case | title/description opcionais (recomendamos descrever o significado da ramificação; se omitido, é preenchido o título padrão `分支`); conditionGroups:[{content:Condition[]}], **apenas um grupo é permitido** | Array de nós obrigatório | Somente diretamente sob ifElse; as condições dentro do grupo são combinadas com AND; para expressar "ou", adicione mais ramificações; é seguido o primeiro case que corresponder, na ordem dos cases |
| caseDefault | title/description opcionais (recomendamos descrever o significado da ramificação; se omitido, é preenchido o título padrão `默认分支`) | Array de nós obrigatório | É executado somente quando ifElse não corresponde a nenhum case; no máximo um, e deve ser o último |
| exceptionBlock | title/description opcionais | Array de nós obrigatório, pode ficar vazio | Usado apenas como os blocks diretos de um nó configurado como "Executar ramificação de tratamento de exceções"; exatamente dois, a ramificação de sucesso primeiro e a ramificação de falha depois; consulte [Ramificações de tratamento de exceções](#ramifica%C3%A7%C3%B5es-de-tratamento-de-exce%C3%A7%C3%B5es) |


O objeto start.data.taskSettings contém as configurações no nível do modelo que o editor salva a partir de "Configurações da tarefa". GET as retorna como estão, e você pode gravá-las de volta sem alterações ou modificá-las. Para os campos e valores, consulte `$defs.start` em workflow.schema.json. As configurações só têm efeito em execuções reais (uma execução do fluxo completo no editor, uma execução iniciada pela Local API ou uma tarefa agendada). Elas não têm efeito na depuração de uma única etapa ou de um grupo, e o taskSettings de um modelo filho chamado também não tem efeito. Pontos principais:

- delayMinutes: a execução primeiro permanece na fila sem ocupar o ambiente e só inicia o navegador em `startAfter` (um campo do resumo da execução; para tarefas agendadas, o horário agendado é a referência). A execução pode ser cancelada enquanto está na fila.
- timeoutSeconds: a contagem do tempo começa quando o atraso termina e o navegador é iniciado. Quando o tempo limite se esgota, o navegador do ambiente principal é fechado e a execução falha com o código de erro RPA_TASK_TIMEOUT. Os nós que estão em execução no momento em que o tempo limite se esgota (incluindo os nós de loop, de condição e de fluxo filho que os contêm) também são registrados como failed com RPA_TASK_TIMEOUT. Eles não são repetidos e não passam pelo tratamento de exceções. O tempo limite da tarefa e os tempos limite dos nós se aplicam de forma independente.
- completionTabs / completionBrowser: após o sucesso ou a falha, essas configurações atuam sobre o ambiente principal (o ambiente usado quando a execução começou). Nada é feito quando o usuário interrompe a execução. Os ambientes abertos pelo nó "Iniciar navegador" não são afetados.
- headless, launchArguments, disableAutofill, allowSavePasswords e clearCacheOnClose se aplicam apenas aos navegadores que esta execução inicia (incluindo os iniciados pelo nó "Iniciar navegador"). Eles não têm efeito sobre ambientes que já estavam abertos antes da execução. Um navegador headless exige o kernel do navegador na versão 130 ou posterior (caso contrário, RPA_HEADLESS_CORE_UNSUPPORTED) e é sempre fechado quando a tarefa termina, inclusive quando o usuário a interrompe.


As gravações públicas de case aceitam apenas conditionGroups, com exatamente um grupo de condições (igual ao editor; mais de um grupo retorna RPA_WORKFLOW_SCHEMA_INVALID com reason=limit). Quando o inputsValues.condition legado é lido, a camada da API o projeta em um conditionGroups de um único elemento. Se os dois estiverem presentes, trata-se de um erro estrutural dentro do fluxo: salvar ou atualizar retorna 422, e uma chamada somente de validação retorna 200 com valid=false e um problema. Nenhuma das formas pode ser ignorada silenciosamente. Cada grupo deve ser não vazio, e toda condição exige um operando esquerdo. Os operadores são eq/ne/gt/lt/gte/lte/contains/notContains/exists/notExists, e somente exists/notExists podem omitir right. Os operadores gt/gte/lt/lte comparam números ou strings numéricas. Quando qualquer um dos lados é null (por exemplo, uma referência a um nó que foi ignorado depois de falhar), a condição não é atendida. Outros valores que não podem ser convertidos em números retornam VALUE_CONVERSION_FAILED. Escreva um operando como uma constante `{"type":"constant","content":…}` ou como uma referência `{"type":"ref","content":["nodeId","data","field"]}`. O content de uma referência **deve ser um array de segmentos de caminho** (igual ao editor). Se você o escrever como a string `"nodeId.data.field"`, o editor o tratará como não preenchido, e a gravação retornará RPA_NODE_INPUT_INVALID (reason=required). Não é possível transformar um grupo de condições inteiro em um ref.

O workflow.outputs da raiz é o mapeamento real das saídas do fluxo, ao contrário das descrições do editor em data.outputs de um nó. Quando ele não é declarado explicitamente, o runtime deriva `{result:"${<endId>.data.result}"}` do nó end no final da raiz. Um workflow.outputs explícito substitui esse padrão, e é por isso que call_child.data.outputs.result no exemplo de fluxo filho vem desse mapeamento. Toda referência na declaração também passa pelas verificações de escopo, de tipo e de política de execução.

Os nós de estrutura não contam como ações executáveis; por isso, ao ler os recursos (capabilities), não trate start ou group como ausentes em tempo de execução. O nó breakLoop é uma ação de controle. Ele só pode ser colocado no corpo de um loop do fluxo atual, e os blocks dele devem ser omitidos ou ficar vazios. Um break em um fluxo filho não pode sair do loop do chamador.

Ao criar um loop, sempre escreva `"accumulatorMode": "none"` (escreva outro valor quando precisar acumular resultados), o que corresponde aos loops criados no editor do cliente. Quando omitido, é tratado como `none`, o que corresponde ao que o editor mostra. A saída do loop `index` é a iteração atual e **começa em 1** (a primeira iteração é 1). No modo times, `item` é igual a `index`. No modo list/elements, `item` é o elemento ou valor atual e, para uma lista de objetos, `item` é `{key,value}`. Para campos que selecionam o N-ésimo elemento pela posição (como o serial de getElement, que também começa em 1), referencie `${loopId.data.index}` diretamente e não some 1. Depois que o loop termina, `index` é o número da última iteração, ou 0 se o loop foi executado zero vezes. No modo while, escreva loopConditions apenas como um array de regras, `[{"field":"index","operator":"lt","value":3}]` (igual ao editor; um grupo de condições `{content:[…]}` não é aceito). Quando maxIterations é atingido, o loop termina normalmente e exitReason é max_iterations.

## 5. Variáveis personalizadas e referências

Cada item em start.data.customVariables é `{id,name,type,initialValue}`. O type dele é string/number/boolean/array/object, e initialValue deve corresponder ao tipo. O id deve ser exclusivo e poder ser expresso na sintaxe de caminho. Referencie a variável com `${custom.<id>}`, e não pelo nome. As variáveis personalizadas são inicializadas de forma independente em cada execução completa e em cada chamada de fluxo filho. A API pública não expõe a depuração; por isso, os valores não são herdados entre execuções.

Só existe uma forma de gravar variáveis personalizadas (igual ao editor): declare-as em start.data.customVariables e altere-as com `browser_updateCustomVariable`. O variableId deve ser estático e já declarado, e a operação deve ser aplicável ao tipo da variável. Não é possível gravar dinamicamente parâmetros arbitrários nem variáveis de sistema. O editor não tem um nó setCustomVariable; por isso, gravar um deles retorna RPA_WORKFLOW_SCHEMA_INVALID. Um nó setCustomVariable remanescente em um modelo existente falha antes da execução (RPA_ACTION_UNSUPPORTED, com o ID e o caminho do nó).

```json
[
  {"id": "start", "type": "start", "data": {"customVariables": [{"id": "demoCounter", "name": "Counter", "type": "number", "initialValue": 0}]}},
  {"id": "set_counter", "type": "browser_updateCustomVariable", "data": {"browserAction": "updateCustomVariable",
    "browserUi": {"inputs": {"variableId": "demoCounter", "operation": "assign", "value": "2"}}}},
  {"id": "end", "type": "end", "data": {"inputsValues": {"status": {"type": "constant", "content": "success"},
    "message": {"type": "ref", "content": ["custom", "demoCounter"]}}}}
]
```

`${parameterName}` lê um parâmetro inicial, `${nodeId.data.field}` lê os dados de execução de um nó, `${custom.id}` lê uma variável personalizada, e `${system.browser.id}` e caminhos semelhantes leem o contexto do sistema. Uma referência de valor inteiro mantém o tipo original, e uma referência dentro de uma string concatenada é convertida em texto. WorkflowNumber aceita um número ou uma expressão aritmética restrita, e não um objeto ref. `${…}` só pode conter um caminho de referência, e não aritmética: `${loop.data.index + 1}` retorna RPA_REFERENCE_EXPRESSION_UNSUPPORTED. Em um campo numérico, escreva `"${loop.data.index}+1"` (a referência é escrita sozinha, e a aritmética fica fora de `${}`). Os campos de texto comuns não avaliam aritmética. As referências em browserUi.inputs/bindings de um nó de ação são escritas **apenas como texto `${path}`** (igual ao editor), e não como objetos wrapper como `{type:'ref'}`. Os campos de elemento e de frame também aceitam apenas texto de referência, como `${previousNode.data.element}`; não escreva objetos ElementRef/FrameRef manualmente. Gravar um objeto wrapper retorna RPA_WORKFLOW_SCHEMA_INVALID ou RPA_NODE_INPUT_INVALID (reason=format). O objeto ref `{type:'ref',content:[pathSegments]}` é usado apenas nos inputsValues do nó end e nos operandos das ramificações de condição.

Um WorkflowValue (os inputsValues do nó end, os operandos de condição e o key/value dos parâmetros de script) é um valor JSON simples ou um wrapper constant/ref/expression. Quando a validação semântica pública encontra a chave reservada type=ref/constant/expression, ela deve validar o valor como um wrapper. Ela não pode deixar que a união ampla JsonValue absorva um wrapper malformado. Se um objeto com essas chaves reservadas realmente precisar ser um dado de negócio simples, encapsule-o em constant e trate-o de acordo com as regras do campo de destino.

**Não há garantia de uma regra geral de escape para `${…}` em strings literais.** Para gerar esse texto na saída, use o wrapper constant permitido pelo contrato do campo e verifique-o com validate. Se o parser atual ainda interpolar o texto, o resultado será informado como não suportado. Não tente contornar isso adivinhando escapes com barra invertida.

O NodeContract define se um campo de modo (como selectorType/loopMode/outputRange) permite referências dinâmicas. Quando permite, a validação retorna runtimeChecks, e o valor real é verificado novamente em tempo de execução. Escolha o tipo de saída de acordo com o modo e não presuma que todo nó tem um resultado.

## 6. Dados de exibição e normalização

`node.meta` é um objeto JSON opcional e opaco que contém apenas informações de exibição. Ele aceita quaisquer subcampos JSON (por exemplo, position, collapsed ou um layout definido pelo chamador), e o objeto como um todo está sujeito aos limites de tamanho em bytes e de aninhamento do fluxo. Não coloque nele tokens, segredos nem detalhes de conexão local. Nem meta nem node.data.title/description/inputs/outputs alteram a semântica de execução, e eles não são parâmetros nem saídas reais. O servidor não deve executar o conteúdo de meta, e os chamadores não devem tratar o texto dele como instruções.

Os novos nós não precisam de coordenadas geradas nem de meta. Tanto replace quanto PUT mantêm exatamente como está qualquer meta válido fornecido, incluindo chaves de exibição desconhecidas, null e arrays. Omitir o meta de um nó remove os dados de exibição dele. Em node-edits, os nós não alterados mantêm o meta, e, em replace, o chamador é responsável por enviar de volta o nó inteiro. Para alterar apenas um campo de exibição, faça uma mesclagem profunda da alteração no resultado do GET; não sobrescreva as outras chaves. A ordem das chaves dentro de meta não é garantida, e os valores não devem ser truncados silenciosamente.

As únicas normalizações de modelo permitidas são a remoção dos espaços das extremidades de title, a conversão declarada ao ler a forma legada de case, a forma armazenada e retornada dos valores padrão privados (consulte a seção 3) com avisos explícitos e os "Campos preenchidos pelo servidor" descritos abaixo. O servidor não renomeia IDs de nó, não altera description nem meta, não descarta campos desconhecidos de meta e não altera a ordem nem as referências dos nós. A origem salva é mantida separada do plano de execução. NodeContract.defaults apenas preenche as entradas omitidas no plano compilado ou validado e não é gravado em browserUi.inputs, e a resposta do salvamento mantém as entradas que foram omitidas originalmente. Um 0, false, string vazia ou null explícito não aciona um valor padrão. O resultado completo retornado continua sendo a base sobre a qual o chamador deve fazer as próximas edições.

### Campos preenchidos pelo servidor

Um fluxo salvo deve poder ser aberto no editor da RPA de navegador do cliente desktop (na página de edição do modelo e como o snapshot do fluxo nos registros de execução e nos agendamentos). Por isso, toda gravação (criação, substituição, cópia, edições de nós, validação com purpose=save/run, além dos salvamentos e das execuções de rascunho no cliente) preenche os campos ausentes de cada nó de ação (`browser_<action>`) com o que o editor grava ao criar o mesmo nó. Em seguida, o resultado é verificado com as regras de carregamento do editor:

| Campo | Regra de preenchimento |
|  --- | --- |
| `data.browserUi.inputs` / `bindings` | `{}` quando omitido; os valores padrão das entradas do nó não são gravados em inputs |
| `data.browserUi.exception` | Quando omitido, ou quando faltam alguns campos, cada campo ausente recebe o valor padrão do editor (consulte [Política de exceção do nó](#pol%C3%ADtica-de-exce%C3%A7%C3%A3o-do-n%C3%B3-workflowexception)); os campos escritos explicitamente são mantidos como estão |
| `data.title` | Quando omitido, é preenchido o nome do nó no editor, com a redação original em chinês. Isso é apenas um fallback. Escreva um nome que descreva a finalidade do nó. Quando o nome é omitido, vazio ou igual ao nome padrão, o servidor retorna o aviso `RPA_NODE_TITLE_GENERIC` (veja abaixo) |
| `data.inputs` / `data.inputsValues` | Quando omitidos, `{"type":"object","properties":{}}` e `{}`, respectivamente; os inputsValues de um nó de ação devem ser um objeto vazio |
| `data.outputs` | Sempre gerado pelo servidor a partir do tipo de nó e de browserUi.inputs. Descreve as variáveis que os nós posteriores podem referenciar. Os chamadores não precisam preenchê-lo; se o fizerem, o resultado gerado tem precedência |
| `data` dos nós start / end | As chaves ausentes são preenchidas a partir dos nós start e end que o editor cria para um novo modelo: start recebe `title` `初始化`; end recebe `title` `结束`, `inputs`/`inputsValues` (status=success e uma message vazia, o que dá o mesmo resultado de execução que omiti-los) e `outputs`. As chaves escritas explicitamente (incluindo um title personalizado e status=failed) são mantidas como estão |
| `data.title` de case / caseDefault | Quando omitido, são preenchidos os nomes padrão de ramificação do editor: `分支` para case e `默认分支` para caseDefault. Um nome escrito explicitamente (inclusive uma string vazia) é mantido como está |


Como resultado, os nós de ação e os nós start/end lidos de volta com GET sempre contêm a estrutura completa acima, e a forma compacta no envio (apenas browserAction e browserUi.inputs) continua válida. Um fluxo que o editor ainda não consegue abrir depois do preenchimento dos campos (por exemplo, o tipo de nó não corresponde a browserAction ou uma ramificação de condição não está sob um nó de condição) retorna 422, e issues.path aponta para o nó afetado. O conteúdo completo que o próprio editor do cliente salva nunca é reescrito.

**Lembrete de nome**: o editor do cliente mostra apenas os nomes dos nós e das ramificações de um modelo. Por isso, criação, substituição, edições de nós e `POST /validations` retornam um aviso `RPA_NODE_TITLE_GENERIC` para cada nó de ação e cada case/caseDefault cujo nome esteja omitido, vazio ou igual ao nome padrão do editor. Cada aviso tem um path que aponta para o `data/title` do nó e inclui `nodeId`. O aviso não impede o salvamento nem a execução. Os nós start/end, group e exceptionBlock não são verificados, e a cópia de um modelo não retorna esse aviso. Renomeie esses nós para descrever a finalidade deles (por exemplo, "Aguardar os resultados da pesquisa aparecerem" ou "Localizar o vídeo de destino").

## 7. Mapeamento exato do resultado final

No caminho de sucesso, `end.data.inputsValues.message` é avaliado → null se torna `""`, objetos e arrays passam por JSON.stringify e outros valores passam por String → os dados de execução do nó end, `end.data.result` (string). Quando workflow.outputs não é fornecido explicitamente, o compilador deriva `{ "result": "${<endId>.data.result}" }`; assim, `data.result.outputs.result` na resposta do GET da execução é exatamente essa string. Se workflow.outputs for definido explicitamente, o resultado seguirá esse mapeamento, e não haverá um campo result implícito. Com status=failed, o fluxo termina como falha e não alega produzir um resultado bem-sucedido.

Por exemplo, se o valor de getUrl(type=search,key=item) for `"42"` e end.message referenciar esse valor, o outputs.result final será `"42"`. Quando a chave não existe, getUrl.value="" e o outputs.result final é `""`. Isso não significa que o nó falhou. Se end.message referenciar o objeto data inteiro de getUrl, o resultado será a string JSON desse objeto. Não confunda o resultado no nível do nó com o resultado no nível da execução.

## 8. URLs e os limites das evidências de validação

Um parâmetro inicial de URL só precisa ser declarado como string; URL não é um tipo de variável separado. Na validação de salvamento, um literal fixo em gotoUrl.url deve ser uma URL HTTP(S) absoluta. Para uma referência que ainda não tem valor de execução, a validação verifica a declaração e o escopo dela e a lista em runtimeChecks. A validação não pode afirmar que a URL é válida ou acessível. A pré-verificação de execução verifica novamente o formato da URL com os parâmetros reais. A conectividade do site, os redirecionamentos e as mudanças na página ainda só podem ser confirmados durante a execução. Um array runtimeChecks vazio não é prova de que uma execução será bem-sucedida. Quando valid=false, corrija os problemas e valide novamente.

## 9. Formas de referência, base e alterações de exibição

A forma literal é um valor JSON simples para o campo de destino. A forma template é uma string que contém `${…}` (uma referência de valor inteiro mantém o tipo, e a concatenação converte em texto). A forma numericExpression é uma expressão aritmética limitada, com as quatro operações básicas e referências numéricas, conforme aceita por WorkflowNumber; ela não é JavaScript. A forma reference é `{type:"ref",content:[pathSegments]}` e aparece apenas nos inputsValues do nó end e nos operandos de condição (ela não é usada no browserUi de um nó de ação). O esquema descreve o que é estruturalmente possível, e referenceRules restringe as formas que o campo permite publicamente. Os dois precisam ser atendidos. O campo gotoUrl.url aceita literal/template.

Com getUrl.type=href, value e url são ambos o endereço atual completo no momento da leitura, incluindo query/hash. Se uma navegação anterior foi redirecionada, esse é o endereço da página atual após o redirecionamento. Com origin, value é o esquema, o host e a porta. Com search, value é o primeiro valor da chave de consulta informada, ou uma string vazia se a chave não existir, e url continua sendo o endereço completo.

Um source inline sem base é um candidato independente para um novo modelo. O servidor não consegue deduzir de qual modelo existente ele veio; por isso, não verifica nenhuma versão salva e não permite retained. Ao modificar um modelo, você deve enviar base para que a verificação de versão possa proteger esta pré-verificação. O salvamento ainda exige If-Match. Se o chamador não puder acessar a base ou o modelo, o servidor retornará primeiro 403/404, e não RPA_TEMPLATE_VERSION_CONFLICT, e não revelará a versão.

Quando um usuário do cliente salva um layout de exibição ou edita um formulário, esse usuário também conta como outro autor de gravações. Isso deve incrementar a versão do modelo e invalidar os ETags antigos. Apenas abrir um modelo não é uma operação de gravação garantida pela API; por isso, não conclua a partir disso que a versão não mudou. Sempre leia novamente o modelo atual antes de continuar editando.

## 10. Escolha dos nós de espera

"Aguardar após acessar" pode usar gotoUrl.postWaitMs ou um waitTime separado, e as duas esperas se somam. Se o usuário também quiser editar o nó de espera separadamente, recomendamos um postWaitMs=0 explícito mais um waitTime separado, o que evita contar a espera duas vezes. Essa é a escolha padrão de composição, e não uma restrição do protocolo. Em waitTime, fixed.timeout aceita milissegundos fracionários finitos, mas a precisão de agendamento da execução não é garantida. As duas extremidades de randomInterval também aceitam frações (para as regras de valor, consulte o contrato de browser_waitTime). O meta da resposta (Metadata) é informação de rastreamento HTTP, enquanto node.meta é informação de exibição no canvas. Um não pode ser usado para preencher o outro.

Ao alterar um ID de nó, você deve corrigir todas as referências ao mesmo tempo. Substitua o modelo inteiro com PUT ou, em um único lote de node-edits, remova o nó antigo, insira o novo nó e substitua todos os nós que fazem referência a ele. A própria operação replace não pode alterar node.id. Em qualquer uma das abordagens, valide primeiro o candidato completo, mantenha os dados do usuário e use o If-Match atual e uma nova chave de intenção de gravação.

## Política de exceção do nó (WorkflowException)

A configuração fica em `node.data.browserUi.exception`, no mesmo nível de inputs e bindings. Ela não é escrita dentro de inputs. Para a estrutura dos campos, os intervalos de valores e os valores padrão, consulte o [esquema de WorkflowException](/pt/browser-rpa/local-api#contrato-local-leg%C3%ADvel-por-m%C3%A1quina).

Quando o objeto exception inteiro ou qualquer um dos campos dele é omitido, o servidor preenche cada campo ausente antes de salvar, usando o valor padrão que o editor do cliente define para um novo nó (consulte [Campos preenchidos pelo servidor](#campos-preenchidos-pelo-servidor)). Você vê os valores completos ao ler o modelo de volta. Os campos escritos explicitamente são mantidos como estão. Os valores preenchidos são iguais aos do mesmo nó criado no editor e aos mostrados no painel de configurações de exceção do editor. A execução usa os valores preenchidos.

| Campo | Preenchido quando omitido | Valores e semântica |
|  --- | --- | --- |
| policy | `"interrupt"` | interrupt: a execução para depois que o nó falha. skip: mantém o registro do nó com falha e continua. handle: processa a falha com handler e, depois, continua ou para. Um tempo limite de nó é tratado por policy como qualquer outra falha. Se a operação original ainda não tiver terminado dentro de mais um período de tempo limite depois que o tempo limite se esgotar, o executor primeiro se desconecta e reassume o controle do mesmo ambiente (mantendo a aba atual original) e, depois, aplica policy. Se a retomada do controle falhar (o contexto de execução foi isolado) ou se a execução for cancelada, skip/handle não pode forçar a execução a continuar. |
| handler | Não é preenchido; o executor o trata como `"screenshot"` | Só tem efeito quando policy=handle e as [ramificações de tratamento de exceções](#ramifica%C3%A7%C3%B5es-de-tratamento-de-exce%C3%A7%C3%B5es) não são usadas. screenshot: continua após uma captura de tela bem-sucedida ou para se a captura de tela falhar. stop: interrompe o restante do fluxo. remark: registra uma observação do ambiente. |
| screenshot | `true` | Tenta fazer uma captura de tela quando o nó falha definitivamente. Definir false desativa as capturas de tela comuns em caso de falha, mas policy=handle com handler=screenshot ainda exige uma captura de tela. Pode não ser possível fazer a captura de tela quando a página está fechada, a execução foi cancelada ou o contexto de execução foi isolado. Uma captura de tela com falha não substitui o erro original do nó. Os nós de arquivo local useExcel (Ler Excel), exportExcel (Gravar Excel), importText (Importar texto) e saveData (Salvar texto) nunca fazem capturas de tela, porque as falhas deles não estão relacionadas a uma página do navegador. Para esses nós, handler=screenshot apenas registra o erro e continua. |
| timeout | `30000` para nós de ação; `0` (sem limite) para nós de controle | Milissegundos, um **inteiro** no intervalo de 0 a 2147483647 (igual ao editor; um valor fracionário retorna RPA_WORKFLOW_SCHEMA_INVALID). `0` significa sem limite de tempo. É o tempo limite de uma única execução do nó e também é limitado pelo tempo restante da execução inteira. Não é o tempo limite de espera HTTP da Local API. O nó injectJavaScript também é limitado pela entrada executionTimeoutMs dele. |
| retry | `false` | Ativa as novas tentativas quando uma ação atômica falha. |
| retryTimes | `1` | Tem efeito quando retry=true. Um inteiro no intervalo de 1 a 10 que define o número de tentativas adicionais; a ação é executada no máximo 1+retryTimes vezes. |
| retryInterval | `2` | Intervalo entre as novas tentativas, em segundos, de 0 a 2147483. Essa unidade é diferente da de timeout, que usa milissegundos. |


**Quando timeout é omitido, os nós de ação (incluindo nós de navegação como gotoUrl) recebem 30 segundos, e os nós de controle (loop, ifElse, breakLoop, applySubProcess, updateCustomVariable) recebem `0`, o que significa sem limite de tempo.** Um nó de controle sem limite de tempo é limitado apenas pelo tempo restante da execução inteira, pelo maxIterations do loop e pelo cancelamento. Cada ação filha dentro dele continua sendo executada com o próprio tempo limite (30 segundos por padrão); por isso, uma única ação em uma página lenta precisa de um tempo limite explicitamente maior. Um tempo limite definido explicitamente em um nó de controle abrange a chamada inteira e todos os nós filhos dela, e o nó falha com TIMEOUT quando esse tempo se esgota.

O editor do cliente também grava 0 (sem limite) para novos nós de controle e 30000 para novos nós de ação. Qualquer nó que não precise de limite de tempo pode definir 0 explicitamente. Um valor de 2147483647 salvo por versões anteriores continua válido e também significa sem limite de tempo; ele não é reescrito na leitura. Quando agentes de IA montam fluxos, eles devem definir exception explicitamente com base na necessidade do negócio, em vez de depender dos valores padrão.

As novas tentativas se aplicam a ações atômicas. Os nós de controle não usam essas configurações para repetir o subgrafo inteiro. Um tempo limite de nó também gera novas tentativas de acordo com a configuração (isso pode repetir uma ação que já surtiu efeito). Se a operação original ainda não tiver terminado dentro de mais um período de tempo limite depois que o tempo limite se esgotar, a nova tentativa só acontece depois que o controle do ambiente for reassumido. Não há nova tentativa automática após um cancelamento ou uma falha na retomada do controle. Nem skip nem um handle bem-sucedido mudam um nó com falha para success; por isso, você ainda precisa verificar hasNodeErrors.

Por exemplo, o trecho a seguir mostra um loop que é executado por no máximo 10 minutos e que ignora um elemento com falha e continua, e um nó em uma página lenta que lê um valor e faz duas novas tentativas quando falha:

```json
[
  {
    "id": "each_item",
    "type": "browser_loop",
    "data": {
      "browserAction": "loop",
      "browserUi": {
        "inputs": {
          "loopMode": "times",
          "times": 20,
          "accumulatorMode": "none"
        },
        "exception": {
          "policy": "interrupt",
          "timeout": 600000,
          "screenshot": true
        }
      }
    },
    "blocks": [
      {
        "id": "read_title",
        "type": "browser_getElement",
        "data": {
          "browserAction": "getElement",
          "browserUi": {
            "inputs": {
              "selectorType": "selector",
              "selectorRadio": "CSS",
              "selector": "h1",
              "type": "innerText"
            },
            "exception": {
              "policy": "skip",
              "timeout": 15000,
              "retry": true,
              "retryTimes": 2,
              "retryInterval": 1,
              "screenshot": true
            }
          }
        }
      }
    ]
  }
]
```

Depois que uma captura de tela é publicada com sucesso, `data.items` de `GET /runs/{id}/artifacts` contém os metadados desse artefato, e os `artifacts` do registro de execução do nó que gerou a captura de tela fazem referência ao mesmo id. A API não fornece uma URL de download nem o conteúdo do arquivo. `path` é o caminho da captura de tela na máquina local.

### Ramificações de tratamento de exceções

Um nó de ação (incluindo ações de controle como applySubProcess, updateCustomVariable e breakLoop, mas não ifElse nem loop, que têm os próprios blocks) pode entregar a falha às duas ramificações do canvas, sucesso e falha. Isso funciona da mesma forma que "Executar ramificação de tratamento de exceções" no editor do cliente. Para configurar:

- Defina `data.exception` como `{"mode":"branchHandle"}` (no mesmo nível de `data.browserUi`, e não dentro de browserUi.exception).
- Defina `data.browserUi.exception.policy` como `"handle"`.
- Faça com que `blocks` contenha exatamente dois nós `exceptionBlock`: o primeiro é a ramificação de sucesso, e o segundo é a ramificação de falha. Somente a ordem no array determina a função de cada um. Os títulos e os IDs podem ter qualquer valor, e uma ramificação pode não conter nenhum nó.


Semântica de execução:

| Resultado final do nó pai | Comportamento |
|  --- | --- |
| Sucesso (incluindo sucesso após novas tentativas) | Executa apenas a ramificação de sucesso e, depois, continua com os nós posteriores ao pai |
| Falha (novas tentativas esgotadas) | Executa apenas a ramificação de falha e, depois, continua. O registro do nó pai permanece failed e mantém o erro original e a captura de tela da falha, com `nextAction=continue`; a execução tem hasNodeErrors=true |
| Cancelado, ou a operação original ainda não tinha terminado após o tempo limite e a retomada do controle do ambiente falhou (o contexto de execução foi isolado) | Não entra na ramificação de falha; a execução termina, assim como nas outras políticas |


- No modo de ramificação, `handler` não tem efeito (sem captura de tela substituta, sem observação, sem parada). A realização de uma captura de tela da falha depende apenas de `screenshot`.
- O `data` do nó pai é resolvido como null pela regra de "nós que continuam após a falha". Dentro da ramificação de falha, você pode referenciar `${parentId.error.code}` e `${parentId.status}`.
- As duas ramificações são alternativas entre si. Um nó de uma ramificação não pode referenciar um nó da outra ramificação (RPA_REFERENCE_NOT_VISIBLE), e o próprio `exceptionBlock` não pode ser referenciado. Quando um nó posterior às ramificações referencia um nó dentro de uma ramificação, a referência precisa de uma verificação em tempo de execução.
- Quando um nó dentro de uma ramificação falha, ele é tratado pelo próprio exception e não entra novamente na ramificação de falha do pai. Uma nova tentativa do nó pai não executa as ramificações de novo.
- Uma estrutura incompatível retorna RPA_STRUCTURE_INVALID: mode=branchHandle, mas blocks não tem exatamente dois nós exceptionBlock; policy não é handle; a configuração está em ifElse/loop; ou um exceptionBlock não está sob um nó desse tipo.
- `data.exception.mode` definido como `skipStep` / `stopTask` é apenas um marcador do editor. A execução segue policy, e o nó não pode ter filhos exceptionBlock.


```json
{
  "id": "open_shop",
  "type": "browser_newPage",
  "data": {
    "browserAction": "newPage",
    "browserUi": {
      "inputs": {"openMode": "url", "url": "https://example.com"},
      "exception": {"policy": "handle", "retry": true, "retryTimes": 2, "retryInterval": 2, "screenshot": true}
    },
    "exception": {"mode": "branchHandle"}
  },
  "blocks": [
    {"id": "open_ok", "type": "exceptionBlock", "data": {"title": "Success"}, "blocks": []},
    {"id": "open_failed", "type": "exceptionBlock", "data": {"title": "Failure"}, "blocks": [
      {"id": "wait_retry", "type": "browser_waitTime", "data": {"browserAction": "waitTime", "browserUi": {"inputs": {"timeoutType": "fixed", "timeout": 1000}}}}
    ]}
  ]
}
```

### Nós de controle, estados finais e etapas de validação

Os nós de controle do catálogo público são browser_ifElse, browser_loop, browser_breakLoop, browser_applySubProcess e browser_updateCustomVariable (a disponibilidade de cada nó ainda depende do catálogo da instância). Esses nós aceitam um objeto exception. O campo timeout limita a chamada de controle inteira e as chamadas filhas dela, e é 0 (sem limite) quando omitido. Os campos policy/handler/screenshot tratam as falhas da chamada de controle, incluindo os erros que se propagam até a chamada. Os sinais de controle normais de break, end e stop não são tratados como falhas passíveis de nova tentativa. Os campos retry/retryTimes/retryInterval ainda precisam passar na validação de campos, mas os nós de controle ignoram as novas tentativas em tempo de execução e não executam novamente o subgrafo inteiro. As ações atômicas nos nós filhos são executadas de acordo com o próprio exception.

Um nó com handler=remark pode ser salvo e também pode ser executado externamente pela Local API, assim como em uma execução no cliente.

Nós que continuam após a falha: quando um nó foi executado, falhou definitivamente e continuou de acordo com o exception dele (policy=skip ou continuação após handle), as referências posteriores a campos sob o `data` dele são resolvidas como `null`. Uma referência de valor inteiro (como `{type:'ref',content:['read','data','value']}` ou a string inteira `"${read.data.value}"`) recebe `null`, e uma referência concatenada em uma string de template (como `"Title: ${read.data.value}"`) recebe uma string vazia. As referências a caminhos fora de data, como `${id.status}` e `${id.error}`, não mudam. Uma referência a um nó que não existe, a um nó que ainda não foi executado ou a um campo que não existe em um nó bem-sucedido continua falhando em tempo de execução com MISSING_VARIABLE. As regras das verificações estáticas de referências antes do salvamento e da execução não mudam. Por isso, os nós seguintes podem referenciar diretamente um nó de coleta de dados que pode ser ignorado, sem um nó extra de variável para "limpar/registrar". Em uma condição, uma comparação gt/gte/lt/lte com null não é atendida. Para distinguir "nada foi lido" de "0 foi lido", verifique exists primeiro.

A tabela abaixo descreve apenas o resultado padrão depois que um único nó executado falha. Ela pressupõe que o resultado não seja substituído por cancelamento, isolamento do contexto de execução, uma falha posterior, uma avaliação de saída com falha ou uma instrução end explícita:

| Política | Próxima ação | run.status | hasNodeErrors |
|  --- | --- | --- | --- |
| interrupt | Interromper a execução | failed | true |
| skip | Continuar com os próximos nós | success (quando todos os nós posteriores são executados normalmente) | true |
| handle + screenshot, a captura de tela é bem-sucedida | Continuar com os próximos nós | success (quando todos os nós posteriores são executados normalmente) | true |
| handle + screenshot, a captura de tela falha | Interromper a execução | failed | true |
| handle + stop | Não executar mais nenhum nó | stopped | true |


Trata-se da semântica de execução, e não de regras para deduzir resultados em vez de consultá-los. Um cancelamento pode resultar em cancelled. Um tempo limite de nó resulta em failed (TIMEOUT) e é tratado por retry/screenshot/policy. Quando a tarefa excede o tempo limite, ou o navegador do ambiente principal é fechado durante a execução, o nó em execução termina como failed, assim como a execução (RPA_TASK_TIMEOUT / ENVIRONMENT_CLOSED), e retry/policy não se aplicam. Quando não é possível confirmar uma parada, a execução termina como failed com error.code OUTCOME_UNKNOWN. No fim, sempre leia os valores reais de run.status, hasNodeErrors e isolation.

O JSON Schema de WorkflowException restringe apenas o formato dos campos; as regras de inteiros e de intervalos são aplicadas pela validação semântica. Mesmo depois que a verificação do esquema local passa, você ainda precisa chamar validations. Uma única chamada de uma ação atômica tenta no máximo uma captura de tela da falha depois que as novas tentativas se esgotam. Várias chamadas em um loop, ou falhas separadas de nós pais e filhos, podem gerar várias capturas de tela.

Exemplo completo de como anexar uma política de exceção a um nó (o seletor `[` provoca deliberadamente uma falha em tempo de execução para que você possa observar o tratamento da falha):

```json
{
  "id": "capture_failure",
  "type": "browser_getElement",
  "data": {
    "browserAction": "getElement",
    "browserUi": {
      "inputs": {
        "selector": "[",
        "selectorType": "selector",
        "outputRange": "single",
        "type": "innerText"
      },
      "exception": {
        "policy": "interrupt",
        "screenshot": true,
        "retry": false
      }
    }
  }
}
```

Para saber onde os campos de artefatos aparecem nos registros de nós e como consultá-los página por página, consulte [Listar execuções de nós](/pt/browser-rpa/api/list-run-nodes). Para o formato da coleção de artefatos, consulte [Listar artefatos da execução](/pt/browser-rpa/api/list-run-artifacts).