WEL error codes ​

WEL errors include a stable code. The code remains the same when the error message changes or is translated. Use the code to search for an error, configure alerts, or include it in a support request.

_ is the input your expression receives in these examples. Refer to Input variables for more information.

Error codes are organized into the following categories:

CategoryRangeDescription
Parse and static analysisE001–E027The expression itself is malformed. Not catchable.
Type errorsE100–E108A value isn't the type an operation needs. Catchable.
Runtime errorsE200–E230The data is wrong, missing, or out of range. Catchable.
Host errorsE300–E301An explicit HostFx call was unresolved or failed. Catchable.
StopsE400–E401, E450The host stops the whole operation. Not catchable.
Schema errorsE500–E503The expression's output doesn't match the schema the host declared for it. Not caught by |?, since it runs after the expression evaluates.

Identify the family ​

The error family identifies the source of the error.

  • E0xx: The expression is wrong for every input, and it can't be caught, because nothing can recover from a script that won't parse. These surface as you write the expression, not in production.

  • E1xx and E2xx: The expression is valid, but this particular record doesn't have the shape it expected, such as a missing field or a string where a number belongs. These are the errors most likely to surface in production, often partway through a batch that otherwise runs cleanly. They are catchable, so you can decide what should happen.

  • E3xx: The expression is valid, but an explicit HostFx call either wasn't resolved or failed. Both are catchable, so you can decide what should happen when a host integration doesn't supply what the expression asked for.

  • E4xx: The host stopped the operation because a limit was reached or the host service failed. None of these errors are catchable.

  • E5xx: The host declared a schema that the expression's result failed to follow. These errors occur after the expression runs and checks the result against the schema, so |? doesn't catch them. Refer to Schema errors.

Catchability ​

The try-fallback operator |? catches a catchable error and returns a fallback instead. A non-catchable error propagates.

wel
_.customer.email |? 'unknown'
Integer(_.qty) |? 0

Compare |? and | ​

The distinction between |? and | matters most of all, and a mix-up here is a common source of confusion.

OperatorHandlesDoesn't handle
|A null valueAn error
|?An errorN/A

Reading a field that doesn't exist raises E104. It doesn't produce null, so | won't save you:

wel
_.customer.nickname | 'none'      // still raises E104
_.customer.nickname |? 'none'     // returns 'none'

Use | when the key exists and its value may be null or blank, usually with presence, which normalizes every kind of absence to null:

wel
presence(_.display_name) | 'Unknown'

Use |? when the shape itself may differ.

A FALLBACK IS A DECISION, NOT A FIX

|? 0 on a currency field means a malformed amount silently becomes zero, and the job reports success. That is sometimes right and sometimes an invoice that quietly goes out wrong.

Use a fallback when the absence is expected and the default is genuinely correct. Let the error propagate when it isn't. A failed job is visible, and a wrong number isn't.

Parse and static analysis errors ​

WEL raises these errors before evaluation begins. They occur for every input and aren't catchable.

CodeMessageResolution
E001Script requires a newer WEL version than the runtime supportsThe expression uses a feature this engine doesn't have. Check the engine version.
E002Unexpected tokenA caret (^) in the message points at the offending token. Fix the syntax error at that point.
E003Unterminated string literalClose the quote (' or "), escape an apostrophe with \' or switch to double quotes, or use \n/\r or a triple-quoted form ('''...''' or """...""") to include a line break directly.
E004Invalid number literalCheck for a stray separator or a malformed exponent.
E005Invalid binary literalKeep a 0x"..." literal to hex digits only.
E006Unexpected end of inputCheck for a missing close: A bracket ([), a parenthesis ((), or a do with no body.
E007Invalid regular expressionEnsure the pattern follows ECMAScript regular expression syntax. This error is for patterns written directly in the expression. Refer to E213 when the pattern is built from data at runtime.
E008Binary() can't contain non-ASCII charactersUse encode_string with an explicit encoding instead.
E009Variable is already definedRename the inner binding. WEL doesn't allow shadowing.
E010Undefined variableCheck for a typo, or a name used outside the let that binds it.
E011Undefined functionCheck the standard library for the function name, or correct the typo.
E012Wrong number of argumentsCheck the signature on the function's reference entry.
E013Invalid locale configurationCheck the locale settings on the action.
E014Expression nesting too deepBreak the expression into let bindings.
E015Identifier too longShorten the name to 64 Unicode scalar values or fewer after NFC normalization.
E016Invalid format specificationCheck the format string in an f-string or format function.
E017Invalid hostfx referenceCheck the host function reference syntax.
E018HostFx namespace isn't allowedCheck which namespaces are permitted in this context.
E019Number literal too longReduce the digits, or read the value as a String and convert it.
E020Invalid constant for constructorMatch the literal to what the constructor accepts. For example, Duration('P1D') raises this because Duration takes clock durations such as PT24H. This is also raised when an Integer or Decimal literal or constant exceeds the 1024-byte magnitude limit. Refer to Data types for more information.
E021Expression is too largeSplit the expression across additional steps.
E022Key collision in a literalRemove or rename the duplicate key.
E023Skip can't be called or piped intoWrite Skip, not Skip(), and don't use it as the left side of |, |?, or >>.
E024Character isn't allowed at this identifier positionCheck for a stray symbol or a character copied from outside the editor.

E025, E026, and E027 are warnings. They report alongside the result rather than stopping the expression:

CodeMessageResolution
E025Identifier contains an uncommon characterThe name includes a zero-width character (such as ZWNJ/ZWJ) or a compatibility character changed by NFKC normalization, such as full width or mathematical-bold letters. Rename using plain letters, digits, and underscores to silence the warning.
E026Identifier contains a mixed-script confusableThe name mixes letters from scripts that look alike, such as Latin and Cyrillic, using a curated confusable character (for example, Cyrillic а in аdmin). Keep a single script per identifier.
E027Identifiers are visually confusableNames active in the same scope share a curated visual skeleton, such as Latin a and Cyrillic а. Rename them so they're visually distinct.

Type errors ​

WEL raises these errors when a value isn't the type an operation needs. All type errors are catchable.

WEL doesn't automatically coerce arguments to satisfy a function or operator. Convert values explicitly when their input type doesn't match the required type. Refer to Conversion functions for details.

CodeMessageResolution
E100Type mismatch: expected one type, got anotherConvert the type explicitly, or ensure and, or, not, and an if condition only receive Bool (or Null/Skip).
E101Operator isn't supported for these typesCheck both operands and convert one of them.
E102Cannot cast one type to anotherThe value isn't in a format the constructor accepts. Clean the value, or use |? to supply a default.
E103Mixed precision between Decimal and FloatMake both sides the same type. Refer to Data types for more information.
E104Cannot access field on this typeThe field is missing, or the value isn't a Map. Use has_key?, or |? for a default.
E105Lambda expects a different number of argumentsCheck the lambda's parameters against what the higher-order function passes it. For example, filter_by on a Map passes two arguments, the key and the value, not one.
E106Function expects a different number of argumentsCheck the signature.
E107Lambda can't be used as a value herePass the lambda to a function that takes one. The lambda is only valid as an argument, not a standalone value.
E108Operator isn't supported for this typeRemove the operator, or convert the operand to a type it supports.

E103 is about money ​

Decimal and Float won't mix. A silent mix would destroy the exactness that makes Decimal worth using. The result is approximate when a Float enters the calculation, and nothing downstream can tell.

The fix is typically to make the other operand a Decimal rather than to convert the Decimal to a Float when you hit E103 on a total.

RECIPES ENABLE MIXED PRECISION BY DEFAULT

The Transform data action has a Mixed precision field which configures whether Decimal and Float can mix. This field defaults to allow, which means E103 doesn't raise for recipe actions unless you set the field to deny.

Runtime errors ​

WEL raises these errors during evaluation when an input value can't be processed. All runtime errors are catchable.

Data shape and access ​

The following errors occur when the data doesn't have the shape or value an operation expects:

CodeMessageResolution
E200Undefined or indeterminate arithmetic resultGuard the divisor to prevent dividing by zero or a similarly undefined operation.
E201Index out of boundsThe list is shorter than expected. Use first, last, or |?.
E202Cannot access property of nullA parent field is null. Use |? or check with present?.
E203Guard condition failedCheck the guard-site variables and values the message lists to see what was rejected, then fix the input or the condition.
E204one! expects exactly one elementUse a different function, such as first, last, or |?, if zero or multiple matches is a valid outcome. one! is strict by design. It raises this instead of silently picking one record when the lookup matches zero or several.
E205Cannot concatenate with nullWrap the value: presence(x) | ''.
E207Cannot compute on an empty listEnsure the list isn't empty. avg of nothing has no answer.
E224Undefined nameCheck for a typo, or a name used before it's bound.
E225Invalid value: expected one of a set, or the text doesn't match the parse optionsUse one of the allowed option tokens listed by the error message, or use the format the parse function expects.

Parsing and formats ​

The following errors occur when a value can't be parsed as, or converted to, the expected format:

CodeMessageResolution
E206Invalid or unsupported encodingCheck the name against encodings().
E208Invalid URLCheck that the value is a well-formed URL.
E209JSON parse errorCheck the line and column the message gives. The input text isn't valid JSON. A structurally valid object with a duplicate key raises E223 instead.
E210JSON serialize errorConvert the value to a JSON-representable type before serializing it.
E212Temporal constraint violationThe date, time, or duration components are each individually valid but don't fit together. For example, a month has too many days or an offset doesn't match the named time zone. A component that's invalid on its own, such as hour: 200, raises E211 instead.
E213Invalid regular expressionUse escape_for_regex on interpolated values. Unlike E007's static pattern, this one is built at runtime, such as with an f-string or concatenation, so an unescaped special character in the data can break the pattern for some records and not others.
E214Invalid timezoneUse an IANA name such as Europe/London.
E215Ambiguous or non-existent datetimeSet on_gap or on_fold to resolve the ambiguity. The datetime falls on a daylight-saving boundary.
E226Invalid data for the encodingCheck that the bytes are valid in the encoding the message names.
E227Character can't be encodedCheck with convertible_to_encoding? whether the target encoding can represent the character.
E228Rounding required but mode is exactAccept a rounding mode, or treat it as bad data. The value doesn't fit the requested places.

Options, paths, and limits ​

The following errors occur when an options map, a path expression, or a size limit rejects the input:

CodeMessageResolution
E211Value out of rangeCheck the message for the permitted range. For example, ^ with a negative exponent on an Integer or Decimal base, or an Integer/Decimal magnitude over 1024 bytes computed at runtime.
E218Invalid map fieldA recognized key in an options map holds a value of the wrong type or shape. Check the message for the field name and the type it expects. An unrecognized key raises E225 instead.
E219Invalid JSONPath expressionCheck the path syntax.
E220Unsupported JSONPath featureFilters, unions, and function extensions are outside the supported subset. Use deep_collect_by instead.
E221Result too largeAn operation would produce more elements than the limit allows. Filter before expanding.
E222Value nesting too deepFlatten the value before processing it further.
E223Key collisionRemove or rename the duplicate key in the source data. The message names the function that found two entries for the same key while building a Map or parsing an object.
E229Invalid JSON Pointer syntaxCheck the pointer against RFC 6901 syntax. The pointer must start with a leading /, encode a literal / as ~1 and ~ as ~0 within a token, and use non-negative list indices with no leading zeros.
E230JSON Pointer resolution failedThe pointer is well-formed, but the path doesn't exist. This can be caused by a missing key, an out-of-bounds index, or a segment that walks into a non-container value. Use json_pointer's |? support for an optional path.

Cryptography and other ​

CodeMessageResolution
E216Cryptographic operation failedThis is often caused by a key that's shorter than the algorithm requires: HS256 needs at least 32 bytes, HS384 at least 48, HS512 at least 64. Check the message for the exact cause.
E217A general errorThis is a generic failure code, check the message for details.

Host errors ​

WEL raises these errors when an explicit HostFx call either wasn't resolved or failed. Both are catchable.

CodeMessageResolution
E300Unresolved hostfxA host value wasn't supplied for the namespace and key the expression referenced. Use |? to supply a fallback.
E301HostFx call failedThe host attempted the call and it failed in a way the expression can recover from. Use |? to supply a fallback, or check the host integration's configuration.

Stops ​

WEL raises these errors when the host stops the whole operation rather than letting the expression continue. None of these are catchable: There's nothing left of the evaluation to recover into.

CodeMessageResolution
E400Evaluation depth exceededFlatten the expression, or break it into let bindings across more than one step.
E401Memory limit exceededProcess the data in smaller batches.
E450Host function failedThe host itself failed in a way the expression can't recover from, as opposed to E301's recoverable call failure. Check the host integration or connection.

Schema errors ​

A host can declare a schema for the expression's result, such as the Transform data action's Output schema. Schema validation runs after the expression evaluates, checking the result against that schema. Because it's a separate step from evaluation, |? doesn't see these errors. They don't propagate through the expression at all.

CodeMessageResolution
E500Required field is missing or blankA required schema field received no value, null, Skip, or a blank value with no default. Supply the field, or mark it optional in the schema.
E501Value cannot be coerced to the field's declared typeThe expression's output doesn't match the schema's declared type for that field, and WEL couldn't convert it. Check the field's actual type against the schema.
E502A schema assertion failed or couldn't be evaluatedCheck the wel_assertions entry on the schema.
E503Schema definition nests deeper than the limitFlatten the schema definition.

Common errors ​

The following errors commonly result from input that doesn't match the type or shape expected by an expression:

CodeUsually means
E100A field arrived as a String and is being used as a number, or the reverse.
E104An optional field is absent from this record.
E102A value won't convert, such as an empty string where a number was expected.
E103A Decimal amount met a Float somewhere in the arithmetic.

Reduce these errors by converting input fields to their expected types at the start of a transformation and handling optional values explicitly. Use presence(...) | default for fields that are genuinely optional. Refer to Conversion functions and Common functions for details.

  • Data types: The data types relevant to these errors.
  • Operators: More information about | and |?.
  • Conversion functions: How to construct each data type.
  • Transform data: The action where a failing expression runs, including the Output schema it uses for schema validation.

Last updated: