The critical limitation of naive Base64 encoding is that it cannot preserve primitive boundaries when converting concatenated binary strings. Standard Base64 uses trailing = pad characters that create ambiguity at concatenation points, making it impossible to reliably parse individual primitives after group conversion.

KERI's Approach

The 24-Bit Alignment Constraint

CESR achieves composability through strict 24-bit boundary alignment - the least common multiple of:

• 6 bits (Base64 character encoding)
• 8 bits (byte encoding)

This constraint ensures that:

• Text domain primitives are integer multiples of 4 Base64 characters (24 bits)
• Binary domain primitives are integer multiples of 3 bytes (24 bits)
• No bits from adjacent primitives share the same character/byte after conversion

Pre-Padding Innovation

Unlike naive Base64 that uses trailing = pad characters, CESR employs leading pad bytes ("lead bytes") prepended to raw binary values before Base64 conversion. The pad size calculation is:

ps = (3 - (N mod 3)) mod 3

where ps is pad size and N is raw binary length in bytes.

For a one-byte value requiring 2 lead bytes, the pre-padded binary converts to 4 Base64 characters where the first 2 characters encode the lead bytes. These characters can be replaced with a derivation code without affecting the value encoding, creating qualified primitives that are both self-describing and composable.

Three-Domain Architecture

CESR operates across three interconnected domains:

1. Raw Domain (R): Raw binary used by cryptographic libraries, represented as (code, raw) tuples
2. Text Domain (T): Fully qualified Base64 using URL-safe characters [A-Z, a-z, 0-9, -, _]
3. Binary Domain (B): Fully qualified binary representation for efficient streaming

The composability property enables complete transformation circuits:

R→T(R)→T→B(T)→B→R(B)→R
R→B(R)→B→T(B)→T→R(T)→R

Self-Framing Foundation

Composability depends critically on CESR's self-framing property. Each primitive includes:

• Type information: Derivation code indicating cryptographic algorithm
• Size information: Length encoded in the framing code
• Value: The actual cryptographic material

This enables parsers to extract primitives from concatenated streams without external delimiters or schemas.

Practical Implications

Development and Production Benefits

Composability provides distinct advantages across the software lifecycle:

Development Phase:

• Human-readable text format for debugging
• Over-the-wire inspection without special tools
• Easy compliance verification
• Simple versioning and error correction
• Minimal custom tooling requirements

Production Phase:

• Compact binary representation for bandwidth efficiency
• High-performance parsing and validation
• Streamable and datagram-compatible
• Pipelined processing capabilities

Stream Processing Architecture

Composability enables sophisticated stream processing patterns:

Multiplexing: Combining multiple self-framing primitives into complex streams using count codes

Demultiplexing: Unraveling primitives from composite streams while preserving individual boundaries

Hierarchical Composition: Group framing codes function as independently composable primitives, enabling nested structures

Pipelining: Processing streams across multiple cores at network speeds (40 GHz) rather than processor speeds (5 GHz)

Cryptographic Integrity

Composability ensures cryptographic operations remain valid across domain transformations:

• Digital signatures computed in one domain verify correctly after conversion
• SAIDs (Self-Addressing Identifiers) maintain integrity across representations
• Key event logs can be transmitted in either domain without re-signing
• Witness receipts remain verifiable regardless of encoding

Interoperability Guarantees

The composability property provides strong interoperability guarantees:

• Systems preferring text encoding can communicate with binary-optimized systems
• Archival storage can use one format while transmission uses another
• Debugging tools can work with text representations of production binary streams
• Protocol evolution doesn't break existing implementations

The Google Translate Analogy

The CESR specification uses an effective analogy to illustrate composability:

Google Translate is not composable - repeatedly translating text from English to Dutch and back degrades the message until reaching a stable but altered state. Each translation loses information.

CESR is composable - like having two "languages" (text and binary) where:

• Content can be concatenated and converted freely between formats
• No data degradation occurs regardless of conversion frequency
• The semantic content remains identical in both representations

Trade-offs and Constraints

While composability provides significant benefits, it imposes constraints:

Alignment Overhead: The 24-bit boundary requirement may introduce padding that slightly increases size for some primitives

Encoding Complexity: Implementations must correctly handle pre-padding and derivation codes, which is more complex than naive Base64

Format Restrictions: Only Base64 URL-safe characters are permitted in text domain, excluding the = pad character entirely

Parsing Requirements: Parsers must understand CESR framing codes and version strings to correctly process streams

However, these constraints are carefully designed to be minimal while ensuring the composability property holds universally across all CESR primitives and compositions.

Significance for KERI

Composability is not merely a convenience feature but a foundational architectural requirement for KERI:

• Key events must maintain integrity across network boundaries where different systems may prefer different encodings
• Witnesses and watchers may use different representations internally
• Credential presentations may need text format for human review but binary for transmission
• Transaction event logs must be verifiable regardless of storage format

The composability property ensures that KERI's cryptographic guarantees hold universally, regardless of which encoding domain is used at any point in the protocol flow. This enables the flexible, interoperable, and scalable identity infrastructure that KERI provides.