# Flujo de trabajo, variables y nodos de estructura

Esta página describe la estructura de los flujos de trabajo, como referencia para los desarrolladores y agentes de IA que los escriben. Usa el [esquema de la estructura](/es/browser-rpa/local-api#contrato-local-legible-por-m%C3%A1quina) junto con esta página; el [endpoint de validación](/es/browser-rpa/api/validate-workflow) se encarga de la semántica. Para empezar, consulta la [Referencia de la Local API](/es/browser-rpa/local-api) y el [Inicio rápido](/es/browser-rpa/quickstart).

## 1. Documento y orden

```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"
          }
        }
      }
    }
  ]
}
```

Las escrituras solo aceptan editorVersion=2 y editorParametersVersion=1. Los datos con la versión 2 de parámetros se pueden seguir leyendo en su forma original, pero los llamadores externos no los reescriben de forma silenciosa. Edita esos datos solo después de migrarlos explícitamente en el cliente de escritorio. El orden del array es el orden de ejecución, y blocks expresa el anidamiento. No hay aristas, conexiones ni estados de activación.

El array raíz tiene start al principio y end al final, exactamente uno de cada uno. Cada nodo tiene un id único. Te recomendamos que un ID empiece por una letra ASCII, continúe con letras, dígitos o guiones bajos, y tenga como máximo 64 caracteres. Los ID no pueden usar los nombres reservados del editor `system`, `initVars` ni `custom`. Los ID de los grupos y de las ramas también cuentan para la unicidad. Una acción normal usa type=`browser_<action>`, data.browserAction debe coincidir con él, y sus entradas van en data.browserUi.inputs.

El área de datos compartida contiene title/description, meta (datos de visualización JSON) y data.inputs/outputs (descripciones del editor; las salidas de los nodos de acción las genera el servidor, consulta [Campos que completa el servidor](#campos-que-completa-el-servidor)). Los valores de browserUi.test y los resultados de inicialización simulados no son resultados reales, así que no los uses para tomar decisiones sobre una ejecución. Para ver el contrato consolidado de cada tipo de nodo, consulta los [contratos de nodo estáticos](/es/browser-rpa/nodes). Abarca la estructura de las entradas, los valores predeterminados, las condiciones, las variantes de salida y las políticas de campo.

## 2. Variables iniciales: seis tipos de campo

variables=`{type:'object',properties:{fieldName:Variable},required?:string[]}`. Los nombres de los parámetros pueden contener caracteres chinos. Un nombre no puede quedar vacío después de quitar los espacios iniciales y finales, no puede contener `.`, `[`, `]`, `${` ni `}`, y no puede ser igual a custom/system/parameters ni a ningún ID de nodo de este flujo de trabajo. Los nombres `__proto__`, `constructor` y `prototype` están prohibidos. Cada entrada de required debe existir en properties, y se rechazan las entradas duplicadas.

Una Variable pública puede usar estas propiedades: type, description, default y extra. La propiedad extra contiene la configuración del editor que se declara a continuación. Una escritura pública rechaza los campos desconocidos que afectan a la ejecución, y la configuración de visualización solo admite los campos publicados. Un campo es obligatorio cuando `extra.required=true` o cuando la lista required de nivel superior lo contiene. Te recomendamos usar solo el required de nivel superior. Si los dos entran en conflicto, la escritura devuelve 422 en lugar de dejar que los agentes de IA dependan de una prioridad implícita.

| Tipo de negocio | Declaración | Configuración de extra y valores predeterminados | Valor de ejecución normal |
|  --- | --- | --- | --- |
| Cadena | type=string | extra.private=false, localPath=false; charValid={enabled:false,value:…}; multiline={value:1,autoHeight:true} | kind=json, value es una cadena |
| Número | type=number; los enteros también pueden usar type=integer | decimalPlaces: es 2 de forma predeterminada para number y está fijado en 0 para integer (igual que en el editor); numberRange={enabled:false,min:null,max:null}; numberSuffix={enabled:false,value:''} | kind=json, value es un número finito; el rango y la precisión deben coincidir con la declaración |
| Booleano | type=boolean | Sin extra de negocio | kind=json, value es un booleano |
| Array | type=array | multiline={value:1,autoHeight:true} | kind=json, value es un array JSON; no pases en su lugar una cadena JSON |
| Objeto | type=object | multiline={value:1,autoHeight:true} | kind=json, value es un objeto JSON |
| Archivo | type=object para un solo archivo, type=array para varios archivos; extra.type=file | multipleFiles={enabled:false,unlimited:false,maxCount:9} (con varios archivos, omitir maxCount permite hasta 9 archivos, y solo unlimited=true elimina el límite de cantidad); formatType es un array de extensiones de archivo; sizeLimit={unit:'KB' o 'MB',value:número positivo}, y cuando se omite, cada archivo puede tener como máximo 10MB (igual que en el editor) | kind=json, value es una cadena con una ruta local absoluta (un solo archivo) o un array de cadenas (varios archivos). El servidor hace referencia directamente al archivo de esa ruta, igual que una ejecución en el cliente, sin copiarlo. La ruta debe existir y cumplir los límites de extensión, cantidad y tamaño. La url que recibe el nodo es esta ruta. Los parámetros de archivo no pueden declarar un valor predeterminado |


El ajuste multiline.value es un entero de 1 a 200. Para el número de caracteres, la precisión y los límites de archivos, prevalece el contrato en vivo; no uses datos simulados de la interfaz. Los campos extra.name/index/placeholder son campos de visualización y no cambian el nombre que se usa para hacer referencia al parámetro. El fieldId es la clave en properties.

Un valor predeterminado normal tiene dos representaciones existentes en el editor. Se recomienda Variable.default, y extra.defaultValue={enabled:true,value:…} se admite por compatibilidad. Definir extra.defaultValue.enabled=false significa explícitamente que no hay valor predeterminado. Cuando enabled=true, se aplica su valor. Si también se indica default y los dos difieren, una escritura pública devuelve RPA_DEFAULT_CONFLICT en lugar de elegir uno de forma silenciosa. Un valor predeterminado de array u objeto es un valor JSON. Una ejecución no puede iniciarse cuando falta un valor obligatorio y no hay valor predeterminado. Omitir un valor opcional es distinto de pasar un null explícito o un array vacío, y null debe superar la validación del 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"
  ]
}
```

Los flujos de trabajo con parámetros de archivo, o con parámetros de cadena que tienen localPath=true, se pueden ejecutar externamente, igual que en una ejecución en el cliente. Pasa una ruta local en tiempo de ejecución.

## 3. Valores predeterminados privados

Una variable privada debe tener type=string y extra.private=true. La Local API no oculta los valores privados. Puedes enviar un valor predeterminado en texto plano, GET devuelve el valor predeterminado en texto plano y un flujo de trabajo con parámetros privados se puede ejecutar externamente (en tiempo de ejecución puedes pasar el texto plano directamente; consulta [ParameterValues](/es/browser-rpa/api/data-types#parametervalues)).

Escribe un valor predeterminado en texto plano:

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

Esto coincide con la forma en que guarda el editor de Plantillas personalizadas del cliente: el texto plano se escribe tal cual en el contenido de la plantilla en la nube, y GET lo devuelve en la forma de texto plano que se muestra arriba. Cuando el editor del cliente guarda un valor predeterminado como referencia al almacenamiento seguro local, al leerlo en esta computadora se descifra el valor y se devuelve.

| Caso de escritura o lectura | Regla |
|  --- | --- |
| POST/PUT/node-edits envía un default o un defaultValue.value en texto plano | Se escribe tal cual en la plantilla en la nube; el guardado se completa correctamente |
| GET de los detalles de la plantilla | Los valores predeterminados privados se devuelven en texto plano como `default` y `defaultValue:{enabled:true,value}`; `redactedPaths` siempre es `[]` |
| Respuestas de los endpoints de escritura (creación, actualización, copia, ediciones de nodos) | Igual que GET; los valores predeterminados privados se devuelven en texto plano |
| Recibos de idempotencia (reproducción con la misma clave, el resultado de `GET /requests/{key}`) | Los recibos no almacenan el contenido de la plantilla. En una reproducción, el servidor vuelve a leer la plantilla en la nube y devuelve su contenido actual, igual que GET |
| PUT/validación inline que lleva la plantilla original como base, el nombre de campo original, string y private=true, y vuelve a enviar `publicState:"retained"` | Conserva el valor predeterminado existente de este campo en esta plantilla (por compatibilidad con llamadores antiguos); si no hay ningún valor predeterminado coincidente, devuelve 422 RPA_PRIVATE_DEFAULT_INVALID |
| retained enviado para una plantilla nueva, o para otra plantilla u otro campo | 422 RPA_PRIVATE_DEFAULT_INVALID; el valor no se toma de otra plantilla. Para una plantilla nueva, envía el texto plano |
| defaultValue omitido, o enabled=false | Borra el valor predeterminado existente; el campo puede seguir siendo privado; devuelve la advertencia RPA_PRIVATE_DEFAULT_CLEARED |
| node-edits sin variables | Conserva las variables y los valores predeterminados privados existentes en el servidor |
| node-edits con variables completas | Se trata igual que PUT |
| Copia | La copia conserva los valores predeterminados privados de la plantilla de origen, sin ninguna advertencia |
| El valor predeterminado privado es una referencia al almacenamiento seguro local que ya no se puede leer (por ejemplo, se guardó en otro dispositivo o se restableció el almacenamiento seguro local) | GET devuelve `{enabled:false}` con la advertencia RPA_PRIVATE_DEFAULT_UNAVAILABLE; vuelve a enviar el texto plano para restablecerlo |


Una llamada que solo valida es de solo lectura. No escribe la plantilla en la nube ni crea o cambia valores en el almacenamiento seguro. Los parámetros privados deben ser cadenas, y `publicState` solo se puede usar en campos de cadena privados.

NodeContract asigna a cada campo sensitivity=public|secret|credential|localPath|inlineFile|sourceCode, que solo describe la naturaleza del campo. `authoringPolicy` siempre es `allowed`. Los campos como el código fuente de los scripts (javaScript/injectJavaScript.content), las rutas locales (la ruta de cada acción de archivo, la carpeta de capturas de pantalla), los archivos inline, Cookie/LocalStorage y las claves de 2FA pueden recibir directamente un literal o una referencia. GET los devuelve tal cual y las ejecuciones no tienen restricciones. Los llamadores deben almacenar y ocultar este contenido por su cuenta; consulta [Límites de datos y de ejecución](/es/browser-rpa/api/common#l%C3%ADmites-de-datos-y-de-ejecuci%C3%B3n).

## 4. Los seis nodos de estructura

| type | data | blocks | Semántica de ejecución |
|  --- | --- | --- | --- |
| start | title/description; customVariables; taskSettings (configuración de la tarea de la plantilla, ver más abajo); los inputsValues descriptivos de la inicialización se pueden conservar, pero no aportan parámetros de ejecución reales | Omitido o [] | Va primero en la raíz; declara las variables personalizadas de este flujo de trabajo |
| end | inputsValues.status/message; para status se recomienda un success o failed fijo; message puede ser un WorkflowValue; null se convierte en una cadena vacía, los objetos pasan por JSON.stringify y los demás valores pasan por String, por lo que el valor final es una cadena | Omitido o [] | Termina el flujo de trabajo actual; status=failed hace que falle; de lo contrario, se completa correctamente; las escrituras públicas rechazan otros literales deterministas; el resultado sin procesar público es la cadena de message |
| group | title/name/description/collapsed | Array de nodos obligatorio, puede estar vacío; **no puede contener otro grupo** (los grupos no se pueden anidar, igual que en el editor; de lo contrario, se devuelve RPA_INVALID_NODE) | Organiza el orden y no produce un resultado de ejecución al que se pueda hacer referencia por sí solo; se aplana en tiempo de ejecución, pero el flujo de trabajo guardado conserva el grupo |
| case | title/description opcionales (te recomendamos describir qué significa la rama; si se omite, se completa el título predeterminado `分支`); conditionGroups:[{content:Condition[]}], **solo se permite un grupo** | Array de nodos obligatorio | Solo directamente dentro de ifElse; las condiciones del grupo se combinan con AND; para expresar "o", agrega más ramas; se toma el primer case que coincide, según el orden de los case |
| caseDefault | title/description opcionales (te recomendamos describir qué significa la rama; si se omite, se completa el título predeterminado `默认分支`) | Array de nodos obligatorio | Se ejecuta solo cuando ifElse no coincide con ningún case; como máximo uno, y debe ser el último |
| exceptionBlock | title/description opcionales | Array de nodos obligatorio, puede estar vacío | Se usa solo como blocks directos de un nodo configurado con "Ejecutar rama de tratamiento de excepciones"; exactamente dos, primero la rama de éxito y después la rama de fallo; consulta [Ramas de tratamiento de excepciones](#ramas-de-tratamiento-de-excepciones) |


El objeto start.data.taskSettings contiene la configuración a nivel de plantilla que el editor guarda desde "Configuración de la tarea". GET la devuelve tal cual, y puedes volver a escribirla sin cambios o modificarla. Para ver los campos y los valores, consulta `$defs.start` en workflow.schema.json. La configuración solo surte efecto en ejecuciones reales (una ejecución del flujo de trabajo completo en el editor, una ejecución iniciada mediante la Local API o una tarea programada). No tiene efecto en la depuración de un solo paso o de un grupo, y el taskSettings de una plantilla secundaria llamada tampoco tiene efecto. Puntos clave:

- delayMinutes: La ejecución primero permanece en cola sin ocupar el entorno, y solo inicia el navegador a la hora indicada en `startAfter` (un campo del resumen de la ejecución; en las tareas programadas, la referencia es la hora programada). La ejecución se puede cancelar mientras está en cola.
- timeoutSeconds: El tiempo empieza a contar cuando termina el retraso y se inicia el navegador. Cuando se agota el tiempo de espera, se cierra el navegador del entorno principal y la ejecución falla con el código de error RPA_TASK_TIMEOUT. Los nodos que se están ejecutando en ese momento (incluidos los nodos de bucle, de condición y de flujo secundario que los contienen) también se registran como failed con RPA_TASK_TIMEOUT. No se reintentan ni pasan por el tratamiento de excepciones. El tiempo de espera de la tarea y los tiempos de espera de los nodos se aplican de forma independiente.
- completionTabs / completionBrowser: Después de un éxito o un fallo, estos ajustes actúan sobre el entorno principal (el entorno que se usó al iniciar la ejecución). No se hace nada cuando el usuario detiene la ejecución. Los entornos abiertos por el nodo "Iniciar navegador" no se ven afectados.
- headless, launchArguments, disableAutofill, allowSavePasswords y clearCacheOnClose solo se aplican a los navegadores que inicia esta ejecución (incluidos los que inicia el nodo "Iniciar navegador"). No tienen efecto en los entornos que ya estaban abiertos antes de la ejecución. Un navegador headless requiere la versión 130 o posterior del kernel del navegador (de lo contrario, RPA_HEADLESS_CORE_UNSUPPORTED), y siempre se cierra cuando termina la tarea, incluso cuando el usuario la detiene.


Las escrituras públicas de case solo aceptan conditionGroups, con exactamente un grupo de condiciones (igual que en el editor; más de un grupo devuelve RPA_WORKFLOW_SCHEMA_INVALID con reason=limit). Cuando se lee el inputsValues.condition heredado, la capa de la API lo proyecta en un conditionGroups de un solo elemento. Si ambos están presentes, es un error estructural dentro del flujo de trabajo: guardar o actualizar devuelve 422, y una llamada que solo valida devuelve 200 con valid=false y una incidencia. Ninguna de las dos formas se puede ignorar de forma silenciosa. Ningún grupo puede estar vacío, y cada condición requiere un operando izquierdo. Los operadores son eq/ne/gt/lt/gte/lte/contains/notContains/exists/notExists, y solo exists/notExists pueden omitir right. Los operadores gt/gte/lt/lte comparan números o cadenas numéricas. Cuando cualquiera de los dos lados es null (por ejemplo, una referencia a un nodo que se omitió después de fallar), la condición no se cumple. Los demás valores que no se pueden convertir en números devuelven VALUE_CONVERSION_FAILED. Escribe un operando como una constante `{"type":"constant","content":…}` o como una referencia `{"type":"ref","content":["nodeId","data","field"]}`. El content de una referencia **debe ser un array de segmentos de ruta** (igual que en el editor). Si lo escribes como la cadena `"nodeId.data.field"`, el editor lo trata como no completado, y la escritura devuelve RPA_NODE_INPUT_INVALID (reason=required). No puedes convertir un grupo de condiciones completo en un ref.

El workflow.outputs de la raíz es la asignación real de salidas del flujo de trabajo, a diferencia de las descripciones del editor en el data.outputs de un nodo. Cuando no se declara explícitamente, el motor de ejecución deriva `{result:"${<endId>.data.result}"}` del nodo end que está al final de la raíz. Un workflow.outputs explícito anula este valor predeterminado; por eso, call_child.data.outputs.result del ejemplo de flujo secundario proviene de esta asignación. Cada referencia de la declaración también pasa por las comprobaciones de alcance, de tipo y de política de ejecución.

Los nodos de estructura no cuentan como acciones ejecutables, así que, al leer las capacidades, no consideres que start o group faltan en tiempo de ejecución. El nodo breakLoop es una acción de control. Solo se puede colocar en el cuerpo de un bucle del flujo de trabajo actual, y sus blocks deben omitirse o estar vacíos. Un break en un flujo secundario no puede salir del bucle del llamador.

Cuando crees un bucle, escribe siempre `"accumulatorMode": "none"` (escribe otro valor cuando necesites acumular resultados), lo que coincide con los bucles creados en el editor del cliente. Si se omite, se trata como `none`, lo que coincide con lo que muestra el editor. La salida `index` del bucle es la iteración actual y **empieza en 1** (la primera iteración es 1). En el modo times, `item` es igual que `index`. En el modo list/elements, `item` es el elemento o valor actual y, en una lista de objetos, `item` es `{key,value}`. En los campos que eligen el enésimo elemento por posición (como serial de getElement, que también empieza en 1), haz referencia directamente a `${loopId.data.index}` y no sumes 1. Cuando el bucle termina, `index` es el número de la última iteración, o 0 si el bucle se ejecutó cero veces. En el modo while, escribe loopConditions solo como un array de reglas, `[{"field":"index","operator":"lt","value":3}]` (igual que en el editor; no se acepta un grupo de condiciones `{content:[…]}`). Cuando se alcanza maxIterations, el bucle termina con normalidad y exitReason es max_iterations.

## 5. Variables personalizadas y referencias

Cada elemento de start.data.customVariables es `{id,name,type,initialValue}`. Su type es string/number/boolean/array/object, e initialValue debe coincidir con el tipo. El id debe ser único y poder expresarse con la sintaxis de rutas. Haz referencia a la variable con `${custom.<id>}`, no por su nombre. Las variables personalizadas se inicializan de forma independiente en cada ejecución completa y en cada llamada a un flujo secundario. La API pública no expone la depuración, por lo que los valores no se heredan entre ejecuciones.

Solo hay una forma de escribir variables personalizadas (igual que en el editor): decláralas en start.data.customVariables y cámbialas con `browser_updateCustomVariable`. El variableId debe ser estático y estar ya declarado, y la operación debe ser aplicable al tipo de la variable. No puedes escribir dinámicamente parámetros arbitrarios ni variables del sistema. El editor no tiene ningún nodo setCustomVariable, así que escribir uno devuelve RPA_WORKFLOW_SCHEMA_INVALID. Un nodo setCustomVariable que haya quedado en una plantilla existente falla antes de la ejecución (RPA_ACTION_UNSUPPORTED, con el ID y la ruta del nodo).

```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}` lee un parámetro inicial, `${nodeId.data.field}` lee los datos de ejecución de un nodo, `${custom.id}` lee una variable personalizada, y `${system.browser.id}` y las rutas similares leen el contexto del sistema. Una referencia de valor completo conserva el tipo original, y una referencia dentro de una cadena concatenada se convierte en texto. WorkflowNumber recibe un número o una expresión aritmética restringida, no un objeto ref. `${…}` solo puede contener una ruta de referencia, no aritmética: `${loop.data.index + 1}` devuelve RPA_REFERENCE_EXPRESSION_UNSUPPORTED. En un campo numérico, escribe `"${loop.data.index}+1"` (la referencia se escribe sola y la aritmética va fuera de `${}`). Los campos de texto normales no evalúan la aritmética. Las referencias en browserUi.inputs/bindings de un nodo de acción se escriben **solo como texto `${path}`** (igual que en el editor), no como objetos envoltorio del tipo `{type:'ref'}`. Los campos de elemento y de marco también reciben solo texto de referencia como `${previousNode.data.element}`; no escribas a mano objetos ElementRef/FrameRef. Escribir un objeto envoltorio devuelve RPA_WORKFLOW_SCHEMA_INVALID o RPA_NODE_INPUT_INVALID (reason=format). El objeto ref `{type:'ref',content:[pathSegments]}` solo se usa en los inputsValues del nodo end y en los operandos de las ramas condicionales.

Un WorkflowValue (los inputsValues del nodo end, los operandos de las condiciones y la key/value de los parámetros de script) es un valor JSON simple o un envoltorio constant/ref/expression. Cuando la validación semántica pública encuentra la clave reservada type=ref/constant/expression, debe validar el valor como un envoltorio. No puede dejar que la unión amplia JsonValue absorba un envoltorio mal formado. Si un objeto con estas claves reservadas realmente debe ser un dato de negocio simple, envuélvelo en constant y trátalo según las reglas del campo de destino.

**No se garantiza ninguna regla general de escape para `${…}` en las cadenas literales.** Para generar ese texto, usa el envoltorio constant que permita el contrato del campo y compruébalo con validate. Si el analizador actual sigue interpolando el texto, el resultado se informa como no admitido. No intentes evitarlo adivinando escapes con barra invertida.

El NodeContract define si un campo de modo (como selectorType/loopMode/outputRange) admite referencias dinámicas. Cuando las admite, la validación devuelve runtimeChecks, y el valor real se vuelve a comprobar en tiempo de ejecución. Elige el tipo de salida según el modo y no supongas que todos los nodos tienen un resultado.

## 6. Datos de visualización y normalización

`node.meta` es un objeto JSON opcional y opaco que solo contiene información de visualización. Admite cualquier subcampo JSON (por ejemplo, position, collapsed o un diseño definido por el llamador), y el objeto en su conjunto está sujeto a los límites de tamaño en bytes y de anidamiento del flujo de trabajo. No incluyas en él tokens, secretos ni detalles de conexión locales. Ni meta ni node.data.title/description/inputs/outputs cambian la semántica de ejecución, y no son parámetros ni salidas reales. El servidor no debe ejecutar el contenido de meta, y los llamadores no deben tratar su texto como instrucciones.

Los nodos nuevos no necesitan coordenadas generadas ni meta. Tanto replace como PUT conservan exactamente tal cual cualquier meta válido que se proporcione, incluidas las claves de visualización desconocidas, null y los arrays. Omitir el meta de un nodo elimina sus datos de visualización. En node-edits, los nodos que no se modifican conservan su meta y, en replace, el llamador es responsable de volver a enviar el nodo completo. Para cambiar solo un campo de visualización, combina en profundidad el cambio con el resultado de GET; no sobrescribas otras claves. No se garantiza el orden de las claves dentro de meta, y los valores no deben truncarse de forma silenciosa.

Las únicas normalizaciones de plantilla permitidas son quitar los espacios iniciales y finales de title, la conversión declarada al leer la forma heredada de case, la forma en que se almacenan y devuelven los valores predeterminados privados (consulta la sección 3) con advertencias explícitas, y los "Campos que completa el servidor" que se describen a continuación. El servidor no cambia el nombre de los ID de nodo, no modifica description ni meta, no descarta campos de meta desconocidos ni cambia el orden de los nodos o las referencias. El origen guardado se mantiene separado del plan de ejecución. NodeContract.defaults solo completa las entradas omitidas en el plan compilado o validado y no se escribe en browserUi.inputs, y la respuesta del guardado conserva las entradas que se omitieron originalmente. Un 0, false, una cadena vacía o un null explícitos no activan un valor predeterminado. El llamador debe seguir basando las ediciones posteriores en el resultado completo devuelto.

### Campos que completa el servidor

Un flujo de trabajo guardado debe poder abrirse en el editor de RPA de navegador del cliente de escritorio (en la página de edición de la plantilla y como instantánea del flujo de trabajo en los registros de ejecución y las programaciones). Por eso, cada escritura (creación, reemplazo, copia, ediciones de nodos, validación con purpose=save/run, y los guardados y las ejecuciones de borrador del cliente) completa los campos que faltan en cada nodo de acción (`browser_<action>`) con lo que escribe el editor cuando crea el mismo nodo. Después, el resultado se comprueba con las reglas de carga del editor:

| Campo | Regla de completado |
|  --- | --- |
| `data.browserUi.inputs` / `bindings` | `{}` cuando se omite; los valores predeterminados de las entradas del nodo no se escriben en inputs |
| `data.browserUi.exception` | Cuando se omite, o cuando faltan algunos campos, cada campo que falta recibe el valor predeterminado del editor (consulta [Política de excepciones del nodo](#pol%C3%ADtica-de-excepciones-del-nodo-workflowexception)); los campos escritos explícitamente se conservan tal cual |
| `data.title` | Cuando se omite, se completa con el nombre del nodo en el editor, con su redacción original en chino. Es solo un valor de respaldo. Escribe un nombre que describa el propósito del nodo. Cuando el nombre se omite, está vacío o es igual al nombre predeterminado, el servidor devuelve la advertencia `RPA_NODE_TITLE_GENERIC` (ver más abajo) |
| `data.inputs` / `data.inputsValues` | Cuando se omiten, `{"type":"object","properties":{}}` y `{}`, respectivamente; los inputsValues de un nodo de acción deben ser un objeto vacío |
| `data.outputs` | Siempre lo genera el servidor a partir del tipo de nodo y de browserUi.inputs. Describe las variables a las que pueden hacer referencia los nodos posteriores. Los llamadores no necesitan completarlo; si lo hacen, prevalece el resultado generado |
| `data` de los nodos start / end | Las claves que faltan se completan a partir de los nodos start y end que crea el editor para una plantilla nueva: start recibe `title` `初始化`; end recibe `title` `结束`, `inputs`/`inputsValues` (status=success y un message vacío, lo que da el mismo resultado de ejecución que omitirlos) y `outputs`. Las claves escritas explícitamente (incluidos un title personalizado y status=failed) se conservan tal cual |
| `data.title` de case / caseDefault | Cuando se omite, se completan los nombres de rama predeterminados del editor: `分支` para case y `默认分支` para caseDefault. Un nombre escrito explícitamente (incluida una cadena vacía) se conserva tal cual |


Como resultado, los nodos de acción y los nodos start/end que se vuelven a leer con GET siempre contienen la estructura completa anterior, y la forma compacta al enviar (solo browserAction y browserUi.inputs) sigue siendo válida. Un flujo de trabajo que el editor sigue sin poder abrir después de completar los campos (por ejemplo, el tipo de nodo no coincide con browserAction o una rama condicional no está dentro de un nodo de condición) devuelve 422, e issues.path apunta al nodo afectado. El contenido completo que guarda el propio editor del cliente nunca se reescribe.

**Recordatorio de nombre**: El editor del cliente solo muestra los nombres de los nodos y de las ramas de una plantilla. Por eso, la creación, el reemplazo, las ediciones de nodos y `POST /validations` devuelven una advertencia `RPA_NODE_TITLE_GENERIC` por cada nodo de acción y cada case/caseDefault cuyo nombre se omita, esté vacío o sea igual al nombre predeterminado en el editor. Cada advertencia tiene un path que apunta al `data/title` del nodo e incluye `nodeId`. La advertencia no impide guardar ni ejecutar. Los nodos start/end, group y exceptionBlock no se comprueban, y copiar una plantilla no devuelve esta advertencia. Cambia el nombre de esos nodos para que describa su propósito (por ejemplo, "Esperar a que aparezcan los resultados de búsqueda" o "Buscar el video de destino").

## 7. Asignación exacta del resultado final

En el caso de éxito, se evalúa `end.data.inputsValues.message` → null se convierte en `""`, los objetos y los arrays pasan por JSON.stringify y los demás valores pasan por String → los datos de ejecución del nodo end, `end.data.result` (cadena). Cuando no se proporciona workflow.outputs explícitamente, el compilador deriva `{ "result": "${<endId>.data.result}" }`, por lo que `data.result.outputs.result` en la respuesta de GET de la ejecución es exactamente esta cadena. Si workflow.outputs se define explícitamente, el resultado sigue esa asignación y no hay ningún campo result implícito. Con status=failed, el flujo de trabajo termina como un fallo y no pretende producir un resultado correcto.

Por ejemplo, si el valor de getUrl(type=search,key=item) es `"42"` y end.message hace referencia a ese valor, el outputs.result final es `"42"`. Cuando la clave no existe, getUrl.value="" y el outputs.result final es `""`. Esto no significa que el nodo haya fallado. Si end.message hace referencia a todo el objeto data de getUrl, el resultado es la cadena JSON de ese objeto. No confundas el resultado a nivel de nodo con el resultado a nivel de ejecución.

## 8. URL y límites de la evidencia de la validación

Un parámetro inicial de URL solo necesita declararse como string; URL no es un tipo de variable aparte. En la validación de guardado, un literal fijo en gotoUrl.url debe ser una URL HTTP(S) absoluta. Para una referencia que aún no tiene valor de ejecución, la validación comprueba su declaración y su alcance, y la incluye en runtimeChecks. La validación no puede asegurar que la URL sea válida o accesible. La verificación previa de la ejecución vuelve a comprobar el formato de la URL con los parámetros reales. La conectividad del sitio web, las redirecciones y los cambios de la página solo se pueden confirmar durante la ejecución. Un array runtimeChecks vacío no prueba que una ejecución vaya a tener éxito. Cuando valid=false, corrige los problemas y vuelve a validar.

## 9. Formas de referencia, base y cambios de visualización

La forma literal es un valor JSON simple para el campo de destino. La forma template es una cadena que contiene `${…}` (una referencia de valor completo conserva su tipo, y la concatenación convierte el valor en texto). La forma numericExpression es una expresión aritmética acotada con las cuatro operaciones básicas y referencias numéricas, tal como la admite WorkflowNumber; no es JavaScript. La forma reference es `{type:"ref",content:[pathSegments]}` y solo aparece en los inputsValues del nodo end y en los operandos de las condiciones (no se usa en el browserUi de un nodo de acción). El esquema describe lo que es posible estructuralmente, y referenceRules restringe las formas que el campo admite públicamente. Se deben cumplir ambos. El campo gotoUrl.url admite literal/template.

Con getUrl.type=href, value y url son ambos la dirección actual completa en el momento de la lectura, incluidos query/hash. Si una navegación anterior se redirigió, es la dirección de la página actual después de la redirección. Con origin, value es el esquema, el host y el puerto. Con search, value es el primer valor de la clave de consulta indicada, o una cadena vacía si la clave no existe, y url sigue siendo la dirección completa.

Un origen inline sin base es un candidato independiente para una plantilla nueva. El servidor no puede deducir de qué plantilla existente proviene, así que no comprueba ninguna versión guardada y no permite retained. Cuando modifiques una plantilla, debes enviar base para que la comprobación de versión pueda proteger esta verificación previa. Guardar sigue requiriendo If-Match. Si el llamador no puede acceder a la base o a la plantilla, el servidor devuelve primero 403/404, no RPA_TEMPLATE_VERSION_CONFLICT, y no revela la versión.

Cuando un usuario del cliente guarda un diseño de visualización o edita un formulario, ese usuario también cuenta como otro escritor. Esto debería incrementar la versión de la plantilla e invalidar los ETag antiguos. El simple hecho de abrir una plantilla no es una operación de escritura que la API garantice, así que no concluyas a partir de ello que la versión no cambió. Vuelve a leer siempre la plantilla actual antes de seguir editando.

## 10. Elección de los nodos de espera

"Esperar después de visitar" puede usar gotoUrl.postWaitMs o un waitTime independiente, y ambas esperas se suman. Si el usuario también quiere editar el nodo de espera por separado, te recomendamos un postWaitMs=0 explícito junto con un waitTime independiente, lo que evita contar la espera dos veces. Es la opción de composición predeterminada, no una restricción del protocolo. En waitTime, fixed.timeout admite milisegundos fraccionarios finitos, pero no se garantiza la precisión de temporización de la ejecución. Ambos extremos de randomInterval también admiten fracciones (para las reglas de los valores, consulta el contrato de browser_waitTime). El meta de la respuesta (Metadata) es información de rastreo HTTP, mientras que node.meta es información de visualización del lienzo. Ninguno de los dos se puede usar para completar el otro.

Cuando cambies el ID de un nodo, debes corregir todas las referencias al mismo tiempo. Reemplaza la plantilla completa con PUT o, en un solo lote de node-edits, elimina el nodo antiguo, inserta el nodo nuevo y reemplaza cada nodo que haga referencia a él. La propia operación replace no puede cambiar node.id. Con cualquiera de los dos enfoques, valida primero el candidato completo, conserva los datos del usuario y usa el If-Match actual y una clave nueva para la intención de escritura.

## Política de excepciones del nodo (WorkflowException)

La configuración va en `node.data.browserUi.exception`, al mismo nivel que inputs y bindings. No se escribe dentro de inputs. Para conocer la estructura de los campos, los rangos de valores y los valores predeterminados, consulta el [esquema de WorkflowException](/es/browser-rpa/local-api#contrato-local-legible-por-m%C3%A1quina).

Cuando se omite todo el objeto exception o cualquiera de sus campos, el servidor completa cada campo que falta antes de guardar, con el valor predeterminado que el editor del cliente asigna a un nodo nuevo (consulta [Campos que completa el servidor](#campos-que-completa-el-servidor)). Puedes ver los valores completos al volver a leer la plantilla. Los campos escritos explícitamente se conservan tal cual. Los valores completados son los mismos que los del mismo nodo creado en el editor y los que se muestran en el panel de configuración de excepciones del editor. La ejecución usa los valores completados.

| Campo | Valor que se completa si se omite | Valores y semántica |
|  --- | --- | --- |
| policy | `"interrupt"` | interrupt: la ejecución se detiene cuando el nodo falla. skip: conserva el registro del nodo fallido y continúa. handle: procesa el fallo con handler y luego continúa o se detiene. Un tiempo de espera agotado del nodo se trata según policy, como cualquier otro fallo. Si, una vez agotado el tiempo de espera, la operación original sigue sin terminar al cabo de otro período igual, el ejecutor primero se desconecta y vuelve a tomar el control del mismo entorno (conservando la pestaña actual original) y luego aplica policy. Si la toma de control falla (el contexto de ejecución quedó aislado) o se cancela la ejecución, skip/handle no pueden forzar que la ejecución continúe. |
| handler | No se completa; el ejecutor lo trata como `"screenshot"` | Solo surte efecto cuando policy=handle y no se usan [ramas de tratamiento de excepciones](#ramas-de-tratamiento-de-excepciones). screenshot: continúa después de una captura de pantalla correcta o se detiene si la captura falla. stop: detiene el resto del flujo de trabajo. remark: registra una nota del entorno. |
| screenshot | `true` | Intenta tomar una captura de pantalla cuando el nodo falla definitivamente. Definir false desactiva las capturas de pantalla normales de los fallos, pero policy=handle con handler=screenshot sigue requiriendo una captura. Es posible que no se pueda tomar una captura cuando la página está cerrada, la ejecución se cancela o el contexto de ejecución quedó aislado. Una captura fallida no reemplaza el error original del nodo. Los nodos de archivos locales useExcel (Leer Excel), exportExcel (Escribir Excel), importText (Importar texto) y saveData (Guardar texto) nunca toman capturas de pantalla, porque sus fallos no están relacionados con una página del navegador. En estos nodos, handler=screenshot solo registra el error y continúa. |
| timeout | `30000` para los nodos de acción; `0` (sin límite) para los nodos de control | Milisegundos, un **entero** en el rango 0–2147483647 (igual que en el editor; un valor fraccionario devuelve RPA_WORKFLOW_SCHEMA_INVALID). `0` significa sin límite de tiempo. Es el tiempo de espera de una sola ejecución del nodo, y también está limitado por el tiempo restante de toda la ejecución. No es el tiempo de espera HTTP de la Local API. El nodo injectJavaScript también está limitado por su entrada executionTimeoutMs. |
| retry | `false` | Habilita los reintentos cuando falla una acción atómica. |
| retryTimes | `1` | Surte efecto cuando retry=true. Un entero en el rango 1–10 que define el número de intentos adicionales; la acción se ejecuta como máximo 1+retryTimes veces. |
| retryInterval | `2` | Intervalo entre reintentos, en segundos, en el rango 0–2147483. Esta unidad es distinta de la de timeout, que usa milisegundos. |


**Cuando se omite timeout, los nodos de acción (incluidos los nodos de navegación como gotoUrl) reciben 30 segundos, y los nodos de control (loop, ifElse, breakLoop, applySubProcess, updateCustomVariable) reciben `0`, que significa sin límite de tiempo.** Un nodo de control sin límite de tiempo solo está limitado por el tiempo restante de toda la ejecución, por el maxIterations del bucle y por la cancelación. Cada acción hija que contiene se sigue ejecutando con su propio timeout (30 segundos de forma predeterminada), así que una sola acción en una página lenta necesita un timeout explícitamente mayor. Un timeout definido explícitamente en un nodo de control abarca toda la llamada y todos sus nodos hijos, y el nodo falla con TIMEOUT cuando se agota ese tiempo.

El editor del cliente también escribe 0 (sin límite) en los nodos de control nuevos y 30000 en los nodos de acción nuevos. Cualquier nodo que no necesite límite de tiempo puede definir 0 explícitamente. Un valor de 2147483647 guardado por versiones anteriores sigue siendo válido y también significa sin límite de tiempo; no se reescribe al leerlo. Cuando los agentes de IA componen flujos de trabajo, deben definir exception explícitamente según la necesidad del negocio, en lugar de depender de los valores predeterminados.

Los reintentos se aplican a las acciones atómicas. Los nodos de control no usan estos ajustes para reintentar todo su grafo secundario. Un tiempo de espera agotado del nodo también se reintenta según la configuración (esto puede repetir una acción que ya surtió efecto). Si, una vez agotado el tiempo de espera, la operación original sigue sin terminar al cabo de otro período igual, el reintento solo se produce después de volver a tomar el control del entorno. No hay reintento automático después de una cancelación o de una toma de control fallida. Ni skip ni un handle correcto cambian un nodo fallido a success, así que igualmente debes revisar hasNodeErrors.

Por ejemplo, a continuación se muestra un bucle que se ejecuta durante 10 minutos como máximo y que omite un elemento que falla y continúa, y un nodo en una página lenta que lee un valor y hace dos reintentos cuando falla:

```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
            }
          }
        }
      }
    ]
  }
]
```

Después de que una captura de pantalla se publica correctamente, `data.items` de `GET /runs/{id}/artifacts` contiene los metadatos de ese artefacto, y los `artifacts` del registro de ejecución del nodo que generó la captura hacen referencia al mismo id. La API no proporciona una URL de descarga ni el contenido del archivo. `path` es la ruta de la captura de pantalla en la computadora local.

### Ramas de tratamiento de excepciones

Un nodo de acción (incluidas las acciones de control como applySubProcess, updateCustomVariable y breakLoop, pero no ifElse ni loop, que tienen sus propios blocks) puede entregar su fallo a las dos ramas del lienzo, la de éxito y la de fallo. Funciona igual que "Ejecutar rama de tratamiento de excepciones" en el editor del cliente. Para configurarlo:

- Define `data.exception` como `{"mode":"branchHandle"}` (al mismo nivel que `data.browserUi`, no dentro de browserUi.exception).
- Define `data.browserUi.exception.policy` como `"handle"`.
- Haz que `blocks` contenga exactamente dos nodos `exceptionBlock`: el primero es la rama de éxito y el segundo, la rama de fallo. La función de cada rama la determina solo el orden del array. Los títulos y los ID pueden ser cualquier valor, y una rama puede no contener ningún nodo.


Semántica de ejecución:

| Resultado final del nodo padre | Comportamiento |
|  --- | --- |
| Éxito (incluido el éxito después de reintentos) | Ejecuta solo la rama de éxito y luego continúa con los nodos posteriores al nodo padre |
| Fallo (reintentos agotados) | Ejecuta solo la rama de fallo y luego continúa. El registro del nodo padre sigue en failed y conserva el error original y la captura de pantalla del fallo, con `nextAction=continue`; la ejecución tiene hasNodeErrors=true |
| Cancelado, o la operación original seguía sin terminar después del tiempo de espera y falló la nueva toma de control del entorno (el contexto de ejecución quedó aislado) | No entra en la rama de fallo; la ejecución termina, igual que con las demás políticas |


- En el modo de ramas, `handler` no tiene efecto (no hay captura de pantalla sustitutiva, ni nota, ni detención). Que se tome o no una captura de pantalla del fallo depende solo de `screenshot`.
- El `data` del nodo padre se resuelve como null según la regla de los "nodos que continúan después de un fallo". Dentro de la rama de fallo, puedes hacer referencia a `${parentId.error.code}` y `${parentId.status}`.
- Las dos ramas son mutuamente excluyentes. Un nodo de una rama no puede hacer referencia a un nodo de la otra rama (RPA_REFERENCE_NOT_VISIBLE), y no se puede hacer referencia a un `exceptionBlock` en sí mismo. Cuando un nodo posterior a las ramas hace referencia a un nodo de dentro de una rama, la referencia necesita una comprobación en tiempo de ejecución.
- Cuando falla un nodo dentro de una rama, se trata según su propio exception y no vuelve a entrar en la rama de fallo del nodo padre. Un reintento del nodo padre no vuelve a ejecutar las ramas.
- Una estructura que no coincide devuelve RPA_STRUCTURE_INVALID: mode=branchHandle pero blocks no tiene exactamente dos nodos exceptionBlock, policy no es handle, la configuración está en ifElse/loop o un exceptionBlock no está dentro de un nodo de ese tipo.
- Un `data.exception.mode` definido como `skipStep` / `stopTask` es solo un marcador del editor. La ejecución sigue policy, y el nodo no puede tener hijos 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}}}}
    ]}
  ]
}
```

### Nodos de control, estados terminales y etapas de validación

Los nodos de control del catálogo público son browser_ifElse, browser_loop, browser_breakLoop, browser_applySubProcess y browser_updateCustomVariable (que un nodo esté disponible sigue dependiendo del catálogo de la instancia). Estos nodos aceptan un objeto exception. El campo timeout limita toda la llamada de control y sus llamadas hijas, y es 0 (sin límite) cuando se omite. Los campos policy/handler/screenshot tratan los fallos de la llamada de control, incluidos los errores que se propagan hasta la llamada. Las señales de control normales break, end y stop no se tratan como fallos reintentables. Los campos retry/retryTimes/retryInterval deben seguir superando la validación de campos, pero los nodos de control ignoran los reintentos en tiempo de ejecución y no vuelven a ejecutar todo su grafo secundario. Las acciones atómicas de los nodos hijos se ejecutan según su propio exception.

Un nodo con handler=remark se puede guardar y también se puede ejecutar externamente mediante la Local API, igual que en una ejecución en el cliente.

Nodos que continúan después de un fallo: cuando un nodo se ejecutó, falló definitivamente y continuó según su exception (policy=skip, o al continuar después de handle), las referencias posteriores a los campos de su `data` se resuelven como `null`. Una referencia de valor completo (como `{type:'ref',content:['read','data','value']}` o la cadena completa `"${read.data.value}"`) obtiene `null`, y una referencia concatenada en una cadena template (como `"Title: ${read.data.value}"`) obtiene una cadena vacía. Las referencias a rutas que no están bajo data, como `${id.status}` y `${id.error}`, no cambian. Una referencia a un nodo que no existe, a un nodo que aún no se ha ejecutado o a un campo que no existe en un nodo que se completó correctamente sigue fallando en tiempo de ejecución con MISSING_VARIABLE. Las reglas de las comprobaciones estáticas de referencias antes de guardar y de ejecutar no cambian. Por lo tanto, los nodos posteriores pueden hacer referencia directamente a un nodo de recopilación de datos que podría omitirse, sin un nodo de variable adicional para "borrar/registrar". En una condición, una comparación gt/gte/lt/lte con null no se cumple. Para distinguir entre "no se leyó nada" y "se leyó 0", comprueba primero con exists.

La tabla siguiente describe solo el resultado predeterminado después de que falla un único nodo ejecutado. Supone que el resultado no queda anulado por una cancelación, el aislamiento del contexto de ejecución, un fallo posterior, una evaluación de salidas fallida o una instrucción end explícita:

| Política | Siguiente acción | run.status | hasNodeErrors |
|  --- | --- | --- | --- |
| interrupt | Interrumpe la ejecución | failed | true |
| skip | Continúa con los nodos siguientes | success (cuando todos los nodos posteriores se ejecutan con normalidad) | true |
| handle + screenshot, la captura de pantalla se toma correctamente | Continúa con los nodos siguientes | success (cuando todos los nodos posteriores se ejecutan con normalidad) | true |
| handle + screenshot, la captura de pantalla falla | Interrumpe la ejecución | failed | true |
| handle + stop | No ejecuta más nodos | stopped | true |


Se trata de semántica de ejecución, no de reglas para inferir los resultados en lugar de consultarlos. Una cancelación puede dar como resultado cancelled. Un tiempo de espera agotado del nodo da como resultado failed (TIMEOUT) y se trata con retry/screenshot/policy. Cuando se agota el tiempo de espera de la tarea, o el navegador del entorno principal se cierra durante la ejecución, el nodo en ejecución termina como failed, igual que la ejecución (RPA_TASK_TIMEOUT / ENVIRONMENT_CLOSED), y retry/policy no se aplican. Cuando no se puede confirmar una detención, la ejecución termina como failed con error.code OUTCOME_UNKNOWN. Al final, lee siempre los valores reales de run.status, hasNodeErrors e isolation.

El JSON Schema de WorkflowException solo restringe la forma de los campos; las reglas de enteros y de rangos las aplica la validación semántica. Incluso después de superar la comprobación local del esquema, debes llamar igualmente a validations. Una sola llamada de una acción atómica intenta como máximo una captura de pantalla del fallo después de agotar sus reintentos. Varias llamadas en un bucle, o fallos separados de nodos padre e hijos, pueden producir varias capturas de pantalla.

Ejemplo completo de cómo asociar una política de excepciones a un nodo (el selector `[` provoca a propósito un fallo en tiempo de ejecución para que puedas observar el tratamiento del fallo):

```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 dónde aparecen los campos de artefactos en los registros de nodos y cómo consultarlos página por página, consulta [Listar ejecuciones de nodos](/es/browser-rpa/api/list-run-nodes). Para ver la forma de la colección de artefactos, consulta [Listar artefactos de la ejecución](/es/browser-rpa/api/list-run-artifacts).