Signatures and Native Data
Enterprise 3.3.0+. Signatures use FUME/JSONata notation such as <s:s> or <nn:n>. Native declarations require a valid signature. Mapping signatures default to <x?o?:x>: optional input and optional object bindings. Mapping signatures cannot repeat arguments, take more than two arguments, or make the second argument anything other than an optional object.
Validation and coercion
s, n, b, l, a, o, x and unions describe accepted inputs; ? permits omission, + repeats where supported, and - enables current-context defaulting. <s-:s> accepts an explicit string or defaults an omitted native argument to current input when that input is a string. <a<s>:a> applies the signature engine's scalar-to-array coercion to a matching scalar and checks array elements. Ordinary signature validation happens before dispatch; an incompatible argument produces an evaluator signature error, not a worker transport error.
Callable mappings use (input?, bindings?). Omitted input uses current evaluator input; explicit missing/undefined is preserved as missing rather than defaulted by omission. The signature validates/coerces explicit input before evaluation. Native signatures cannot contain function-valued argument types, including nested/union function types. A native function can itself be supplied to a FUME higher-order helper:
$map(["a", "b"], $basicUpper)
The result is ["A","B"]. Passing a FUME lambda to native code is not supported.
An annotated return type is not runtime return validation. Returning a number from a function annotated :s is not converted or rejected merely by that annotation. The transport still validates every actual result; authors must test application-level result schemas.
Transport values
Accepted values are undefined, null, booleans, finite numbers, strings, arrays and plain data objects, including null-prototype objects. The tagged IPC codec preserves false, 0, empty strings, missing values, explicit undefined object properties and sparse array holes. It is not plain JSON round-tripping. Decoded objects have a null prototype; use Object.hasOwn, not instance methods.
The codec rejects functions/FUME lambdas, BigInt, symbols and symbol keys, nonfinite numbers, cycles, proxies, class instances, accessors and nonenumerable object data. Arrays must be ordinary arrays; arbitrary extra properties are rejected. Evaluator sequence flags are accepted and normalized as transport array data, not a mechanism for sending custom metadata. Shared references are copied as data, not transferred as identity. Dates, Buffers, streams, service handles and executable objects must be converted to permitted data before returning.
Input arguments, results and callback inputs/results are checked in both directions. Config and manifest values are stricter JSON-only data: no undefined, sparse holes or executable values. Limits count the tagged UTF-8 representation, nesting depth and a fixed 100,000-node safety bound, so payload budget is not identical to raw HTTP body bytes. HTTP request limits remain separate. There is no binary/streaming transport.
Missing values are preserved inside IPC but an HTTP response still obeys the existing server's serialization contract. Do not use HTTP JSON to claim preservation of JavaScript undefined properties or sparse holes.