Thrift binary protocol: value and message codecs as pure functions.

Encoding takes a type descriptor — the same shape the generated struct_info/1, enum_info/1 and function_info/2 introspection functions return — and produces iodata. Decoding consumes a binary and returns the remaining bytes, so callers can stream.

Structs travel as maps keyed by binary field names. On decode, unknown field ids are skipped by wire type, so newer writers stay readable.

Decoding distinguishes more (the binary is a truncated but otherwise valid encoding — read more bytes and retry) from {error, _} (the bytes cannot be a valid encoding). That is what lets the buffered transport parse incrementally off a socket.

Before encoding or decoding, a descriptor is compiled: wire type bytes are precomputed, struct fields are indexed by id in a map, and the required fields are separated out. {ref, Module, Name} schemas are compiled once and cached in persistent_term under their names, so resolving a nested struct is a constant-time lookup. Inline {Kind, Fields} descriptors (such as the function_info/2 params structs) are memoized per process under exact equality — generated descriptors are literals, so the memo hit is a pointer comparison.

Generated types modules ship specialized wire codecs (the encode_<name>_wire/1 / decode_<name>_wire/1 pair plus the binary_codec/1 lookup, emitted by the generator): ref descriptors of named structs dispatch there, so the hot path runs direct binary patterns instead of this engine's compiled-scheme interpreter. The interpreter stays for inline descriptors (RPC param/result structs), hand-written descriptors, and as the fallback when the probe finds no binary_codec/1. Compact and JSON are unaffected — they never consult the probe.

The caches assume generated types modules are never hot-swapped between incompatible versions.