Traditional Approaches:

• XML/JSON nesting: Hierarchical document structures using explicit delimiters and closing tags
• ASN.1 encoding: Type-Length-Value (TLV) structures supporting nested compositions
• Protocol Buffers: Nested message definitions with length-prefixed encoding
• CBOR/MessagePack: Binary formats supporting nested maps and arrays

These traditional approaches typically require one of two strategies:

1. Delimiter-based: Using opening/closing markers (like {} in JSON) that require scanning to find boundaries
2. Length-prefixed: Prepending total length, requiring either buffering entire structures or two-pass processing

Both approaches create challenges for stream processing where data arrives incrementally and must be processed without buffering entire structures. Additionally, traditional formats typically optimize for either text readability (XML/JSON) or binary compactness (Protocol Buffers), but not both simultaneously.

Multiplexing in Telecommunications:

The term "multiplexing" originates from telecommunications, where multiple signals are combined over a shared medium. Traditional multiplexing techniques include:

• Time-division multiplexing (TDM): Signals take turns using the channel
• Frequency-division multiplexing (FDM): Signals use different frequency bands
• Code-division multiplexing (CDM): Signals use different encoding schemes

CESR's hierarchical composition applies multiplexing concepts to cryptographic data streams, enabling multiple logical streams to be interleaved and nested within a single physical stream.

KERI's Approach

CESR achieves hierarchical composition through a novel combination of count codes, 24-bit alignment, and self-framing primitives that enables efficient stream processing of nested structures in both text and binary domains.

Count Codes and Group Framing

As documented in Document 8, CESR uses count codes (also called group codes) as special framing codes that specify the number of primitives in a group. A count code is itself a primitive that:

• Indicates the type of group (e.g., signatures, witnesses, seals)
• Specifies the count of primitives in the group
• Maintains 24-bit alignment like all CESR primitives
• Functions as an independently composable primitive

This last property is crucial: because count codes are themselves primitives, they can be included in higher-level groups, enabling recursive nesting.

Example structure (conceptual):

[Count Code: 3 primitives]
  [Primitive 1]
  [Primitive 2]
  [Count Code: 2 primitives]  ← Nested group
    [Primitive 3]
    [Primitive 4]

The outer count code indicates 3 primitives follow, but one of those "primitives" is itself a count code introducing a nested group. This recursive structure enables arbitrary hierarchy depth.

Pipelining Through Multiplexing

As explained in Document 3 and Document 4, hierarchical composition enables pipelining operations consisting of:

1. Multiplexing: Combining multiple self-framing primitives into a complex hierarchical stream
2. De-multiplexing: Unraveling the hierarchical stream back into individual primitives

These operations are efficient because:

• No buffering required: Count codes specify exactly how many primitives to extract
• Single-pass parsing: Parsers can process streams incrementally without lookahead
• Preserved boundaries: Each primitive's boundaries are maintained through nesting
• Domain-independent: Multiplexing/de-multiplexing work identically in text and binary

Text-Binary Duality

Hierarchical composition maintains CESR's fundamental composability property across domains. As documented in Document 6, this means:

T(cat(b[k])) = cat(T(b[k])) for all k
B(cat(t[k])) = cat(B(t[k])) for all k

Where T(B) converts binary to text, B(T) converts text to binary, and cat() concatenates primitives. This property holds at every level of the hierarchy:

• A hierarchical structure in text domain converts to binary as a group
• The binary representation can be converted back to text
• The round-trip produces the original text structure
• Individual primitives at any nesting level remain separable

This is achieved through 24-bit boundary alignment - every primitive (including count codes) aligns on 24-bit boundaries, which is the least common multiple of 6 bits (Base64 character width) and 8 bits (byte width). This alignment ensures that domain conversions never create bit-level dependencies between adjacent primitives, even in nested structures.

Self-Framing at Every Level

As defined in Document 18, self-framing means each element contains its own type, size, and value information. Hierarchical composition preserves this property at every nesting level:

• Top-level primitives are self-framing
• Count codes are self-framing (type + count)
• Nested groups are self-framing through their count codes
• Primitives within groups remain individually self-framing

This recursive self-framing enables cold start stream parsing - a parser can begin processing at any point in a hierarchical stream and correctly identify primitive boundaries without external schema information.

Application in KERI Event Streams

Hierarchical composition is essential for KERI event structures, which contain nested components:

Key Event Structure (from Document 24):

• Header + Configuration = Key Event Data
• Key Event Data + Signatures = Key Event Message

This hierarchical structure is encoded using CESR count codes:

1. Outer count code indicates total message structure
2. Nested count code for signature group
3. Individual signature primitives within the group

ACDC Structures (from Document 9):

ACDCs (Authentic Chained Data Containers) use hierarchical composition for:

• Nested field maps: Attributes containing sub-attributes
• Edge sections: Graphs of connected ACDCs
• Compact disclosure: SAIDs replacing nested blocks
• Selective disclosure: Arrays of blinded attribute blocks

The specification mandates insertion-ordered field maps that preserve canonical ordering through hierarchical nesting, enabling deterministic SAID computation across nested structures.

Practical Implications

Scalable High-Bandwidth Applications

As noted in Document 1 and Document 5, hierarchical composition enables management at scale for high-bandwidth applications through:

Efficient Stream Processing:

• Single-pass parsing without buffering entire structures
• Incremental processing as data arrives
• Parallel processing of independent branches
• Minimal memory footprint for nested structures

Flexible Data Organization:

• Complex event structures with multiple signature groups
• Nested credential chains in ACDC presentations
• Hierarchical witness configurations
• Multi-level delegation trees

Use Cases in KERI Ecosystem

1. Multi-Signature Events:

A rotation event with multiple signature groups:

[Event Header]
[Event Configuration]
[Count Code: 2 signature groups]
  [Count Code: 3 signatures - current keys]
    [Signature 1]
    [Signature 2]
    [Signature 3]
  [Count Code: 2 signatures - witnesses]
    [Witness Signature 1]
    [Witness Signature 2]

Hierarchical composition allows the event to contain nested signature groups, each with its own count code, enabling efficient verification of different signature types.

2. ACDC Presentation Chains:

A presentation exchange disclosing multiple chained credentials:

[Presentation Message]
[Count Code: 3 ACDCs]
  [ACDC 1 - Root Credential]
    [Attribute Section]
    [Edge Section]
      [Count Code: 2 edges]
        [Edge to ACDC 2]
        [Edge to ACDC 3]
  [ACDC 2 - Delegated Credential]
  [ACDC 3 - Role Credential]

The hierarchical structure represents the directed acyclic graph (DAG) of credential relationships while maintaining efficient stream encoding.

3. Witness Pool Configurations:

A KEL (Key Event Log) with hierarchical witness structure:

[Inception Event]
[Witness Configuration]
[Count Code: 2 witness pools]
  [Count Code: 5 witnesses - primary pool]
    [Witness 1 AID]
    [Witness 2 AID]
    [Witness 3 AID]
    [Witness 4 AID]
    [Witness 5 AID]
  [Count Code: 3 witnesses - backup pool]
    [Witness 6 AID]
    [Witness 7 AID]
    [Witness 8 AID]

Hierarchical composition enables complex witness topologies with primary and backup pools, each independently managed.

Benefits

Efficiency:

• No schema required: Self-describing structures at every level
• Stream processing: Incremental parsing without buffering
• Compact encoding: Binary domain provides minimal overhead
• Fast verification: Direct access to nested signatures

Flexibility:

• Arbitrary nesting depth: No artificial limits on hierarchy
• Mixed primitive types: Different types can be nested freely
• Dynamic structures: Count codes adapt to varying group sizes
• Extensibility: New group types can be added without breaking existing parsers

Interoperability:

• Text-binary duality: Same logical structure in both domains
• Deterministic encoding: Canonical representation for signatures
• Language-agnostic: No dependency on specific programming language features
• Transport-agnostic: Works over any byte or character stream

Trade-offs

Complexity:

• Requires understanding of count codes and framing
• Parser implementation more complex than flat structures
• Debugging nested structures requires specialized tools

Overhead:

• Count codes add bytes/characters to the stream
• 24-bit alignment may introduce padding in some cases
• Nested structures have multiple count codes

Constraints:

• Must maintain 24-bit alignment at all levels
• Count codes have maximum count limits
• Deeply nested structures may impact parser stack depth

However, these trade-offs are justified by the significant benefits in scalability, efficiency, and interoperability that hierarchical composition provides for complex cryptographic event streams in decentralized identity systems.