EXI is the result of extensive work carried out by the W3C's XML Binary Characterization (XBC) and Efficient XML Interchange (EXI) Working Groups. XBC was chartered to investigate the costs and benefits of an alternative form of XML, and formulate a way to objectively evaluate the potential of a substitute format for XML. Based on XBC's recommendations, EXI was chartered, first to measure, evaluate, and compare the performance of various XML technologies (using metrics developed by XBC ), and then, if it appeared suitable, to formulate a recommendation for a W3C format specification. The measurements results and analyses, are presented elsewhere . The format described in this document is the specification so recommended.

The functional requirements of the EXI format are those that were prepared by the XBC WG in their analysis of the desirable properties of a high performance encoding for XML . Those properties were derived from a very broad set of use cases also identified by the XBC working group .

The design of the format presented here, is largely based on the results of the measurements carried out by the group to evaluate the performance characteristics (mainly of processing efficiency and compactness) of various existing formats. The EXI format is based on Efficient XML , including for example the basis heuristic grammar approach, compression algorithm, and resulting entropy encoding.

EXI is compatible with XML at the XML Information Set level, rather than at the XML syntax level. This permits it to encapsulate an efficient alternative syntax and grammar for XML, while facilitating at least the potential for minimizing the impact on XML application interoperability.

The key words MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, MAY, and OPTIONAL, when they appear EMPHASIZED in this document, are to be interpreted as described in RFC 2119 . Other terminology used to describe the EXI format is defined in the body of this specification.

The term event and stream is used throughout this document to denote EXI event and EXI stream respectively unless the words are qualified differently to mean otherwise.

This document specifies an abstract grammar for EXI. In grammar notation, all terminal symbols are represented in plain text and all non-terminal symbols are represented in italics. Grammar productions are represented as follows:

A set of one or more grammar productions that share the same left-hand-side non-terminal symbol are often presented together along with event codes that uniquely identify events among the collocated productions as follows:

Section introduces additional notations for describing productions and event codes in grammars. Those additional notations facilitates concise representation of the EXI grammar system.

In this document, the term qname is used to denote a QName. When used to qualify terminal symbols in grammars (see for notation), to identify built-in element grammars (see ) and global type grammars (see ), or to distinguish value channels in EXI compression (see ), such uses of qname represent QName values, which are tuples of { uri, local-name }. Otherwise, a qname represents a QName value affixed with a prefix part to make a triplet of { prefix, uri, local-name }, where the absence of prefix is indicated by "" (an empty string). Two qnames are considered equal when they have the same uri and the same local-name to each other regardless of prefix values.

Terminal symbols that are qualified with a qname permit the use of a wildcard symbol (*) in place of or as part of a qname. The forms of terminal symbols involving qname wildcards used in grammars and their definitions are described in the table below.

Several prefixes are used throughout this document to designate certain namespaces. The bindings shown below are assumed, however, any prefixes can be used in practice if they are properly bound to the namespaces.

In describing the layout of an EXI format construct, a pair of square brackets [ ] are used to surround the name of a field to denote that the occurrence of the field is optional in the structure of the part or component that contains the field.

In arithmetic expressions, the notation ⌈x⌉ where x represents a real number denotes the ceiling of x, that is, the smallest integer greater than or equal to x.

An EXI header MAY start with an EXI Cookie, which is a four byte field that serves to indicate that the stream of which it is a part is an EXI stream. The four byte field consists of four characters " $ " , " E ", " X " and " I " in that order, each represented as an ASCII octet, as follows.

This four byte sequence is particular to EXI and specific enough to distinguish EXI streams from a broad range of data types currently used on the Web. While the EXI cookie is optional, its use is RECOMMENDED in the EXI header when the EXI stream is exchanged in a context where longer, more solid content-based datatype identification is desired than what is provided by Distinguishing Bits whose role is rather narrowly focused on distinguishing EXI streams from XML documents.

The second part in the EXI header is the Distinguishing Bits, which is a two bit field of which the first bit contains the value 1 and the second bit contains the value 0, as follows.

Unlike the optional EXI cookie that MAY occur to precede this field, the presence of Distinguishing Bits is REQUIRED in the EXI header. It is used to distinguish EXI streams from text XML documents in the absence of an EXI cookie. This two bit sequence is the minimum that suffices to distinguish EXI streams from XML documents since it is the minimum length bit pattern that cannot occur as the first two bits of a well-formed XML document represented in any one of the conventional character encodings, such as UTF-8, UTF-16, UCS-2, UCS-4, EBCDIC, ISO 8859, Shift-JIS and EUC, according to XML 1.0 . Therefore, XML Processors are expected to reject an EXI stream as early as they read and process the first byte from the stream.

Systems that use EXI streams as well as XML documents can reliably look at the Distinguishing Bits to determine whether to interpret a particular stream as XML or EXI.

The fourth part in the EXI header is the EXI Format Version, which identifies the version of the EXI format being used. EXI format version numbers are integers. Each version of the EXI Format Specification specifies the corresponding EXI format version number to be used by conforming implementations. The EXI format version number that corresponds with this version of the EXI format specification is 0 (zero).

The first bit of the version field indicates whether the version is a preview or final version of the EXI format. A value of 0 indicates this is a final version and a value of 1 indicates this is a preview version. Final versions correspond to final, approved versions of the EXI format specification. An EXI processor that implements a final version of the EXI format specification is REQUIRED to process EXI streams that have a version field with its first bit set to 0 followed by a version number that corresponds to the version of the EXI specification the processor implements. Preview versions of the EXI format are useful for gaining implementation and deployment experience prior to finalizing a particular version of the EXI format. While preview versions may match drafts of this specification, they are not governed by this specification and the behaviour of EXI processors encountering preview versions of the EXI format is implementation dependent. Implementers are free to coordinate to achieve interoperability between different preview versions of the EXI format.

Following the first bit of the version is a sequence of one or more 4-bit unsigned integers representing the version number. The version number is determined by summing this sequence of 4-bit unsigned values. The sequence is terminated by any 4-bit unsigned integer with a value in the range 0-14. As such, the first 15 version numbers are represented by 4 bits, the next 15 are represented by 8 bits, etc.

Given an EXI stream with its stream cursor positioned just past the first bit of the EXI format version field, the EXI format version number can be computed by going through the following steps with version number initially set to 1.

The following are example EXI format version numbers.

EXI processors conforming with the final version of this specification MUST use the 5-bit value 0 0000 as the version number.

The fifth part of the EXI header is the EXI Options, which provides a way to specify the options used to encode the body of the EXI stream. The EXI Options are represented as an EXI Options document, which is an XML document encoded using the EXI format described in this specification. This results in a very compact header format that can be read and written with very little additional software.

The presence of EXI Options in its entirety is optional in EXI header, and it is predicated on the value of the presence bit that follows the Distinguishing Bits. When EXI Options are present in the header, an EXI Processor MUST observe the specified options to process the EXI stream that follows. Otherwise, an EXI Procesor may obtain the EXI options using another mechanism. There are no fallback option values provided by this specification for use in the absence of the whole EXI Options part.

EXI processors MAY provide external means for applications or users to specify EXI Options when the EXI header is absent. Such EXI processors are typically used in controlled systems where the knowledge about the effective EXI Options is shared prior to the exchange of EXI streams . The mechanism to communicate out-of-bound EXI Options and their representation used in such systems are implementation dependent.

The following table describes the EXI options specified in the options field.

Appendix provides an XML Schema describing the EXI Options document. This schema is designed to produce smaller headers for option combinations used when compactness is critical.

The EXI Options document is encoded as an EXI body informed by the above mentioned schema using the default options specified by the following XML document. An EXI Options document consists only of EXI body, and MUST NOT start with an EXI header.

The alignment option is used to control the alignment of event codes and content items. The value is one of bit-packed, byte-alignment or pre-compression, of which bit-packed is the default value assumed when the "alignment" element is absent in the EXI Options document. When the value of compression option is set to true, the way event codes and associated contents are represented is governed by the rule specified in instead of the alignment option value, thus the compression option value "true" effectively rescinds the effect of an alignment option value.

Alignment option value bit-packed indicates that the the event codes and associated content are packed in bits without any paddings in-between.

Alignment option value byte-alignment indicates that the event codes and associated content are aligned on byte boundaries. While byte-alignment generally results in EXI streams of larger sizes compared with their bit-packed equivalents, byte-alignment may provide a help in some use cases that involve frequent copying of large arrays of scalar data directly out of the stream. It can also make it possible to work with data in-place and can make it easier to debug encoded data by allowing items on aligned boundaries to be easily located in the stream.

Alignment option value pre-compression alignment indicates that all steps involved in compression (see section ) are to be done with the exception of the final step of applying the DEFLATE algorithm. The primary use case of pre-compression is to avoid a duplicate compression step when compression capability is built into the transport protocol. In this case, pre-compression just prepares the stream for later compression.

The compression option is a Boolean used to increase compactness using additional computational resources. The default value "false" is assumed when the "compression" element is absent in the EXI Options document. When set to true, the event codes and associated content are compressed according to regardless of the alignment option value.

The strict option is a Boolean used to increase compactness by using a strict interpretation of the schemas and omitting preservation of certain items, such as comments, processing instructions and namespace prefixes. The default value "false" is assumed when the "strict" element is absent in the EXI Options document. When set to true, NS, CM, PI, ER and SC events are pruned from EXI grammars, and schema-informed element and type grammars are restricted to only permit items declared in the schemas. The "strict" element MUST NOT appear in an EXI options document when the "preserve" element is present in the same options document.

The fragment option is a Boolean that indicates whether the EXI body is an EXI document or an EXI fragment. When set to true, the EXI body is an EXI fragment. Otherwise, the EXI body is an EXI document. Unlike EXI documents, EXI fragments are capable of representing multiple elements at the root level. They are analogous in concept to external general parsed entities in XML in that they consist of a sequence of elements, processing instructions and comments in containers of their own that are physically separate from the documents in which they are to be used. An EXI fragment is formally defined in terms of its grammar in Sections and . The XML Information Set an EXI stream is mapped onto contains a document information item if the stream represents an EXI document, otherwise, the XML Information Set does not have a document information item if the stream represents an EXI fragment. The order among elements, processing instructions and comments that appear at the root in an EXI fragment is deemed significant and MUST be preserved by EXI processors.

The preserve option is a set of Booleans that can be set independently to control whether certain information items are preserved in the EXI stream. describes the set of information items effected by the preserve option. The "preserve" element MUST NOT appear in an EXI options document when the "strict" element is present in the same options document.

The selfContained option is a Boolean used to enable the use of self contained elements in the EXI stream. Self contained elements may be read independently from the rest of the EXI body, allowing them to be indexed for random access. The "selfContained" element MUST NOT appear in an EXI options document when the "compression" or "pre-compression" elements are present in the same options document.

The schemaID option may be used to identify the schema information used when encoding the EXI body. When the "schemaID" element in the EXI options document contains the xsi:nil attribute, no schema information was used when encoding the EXI body. When the value of the "schemaID" element is empty, no user defined schema information was used when encoding the EXI body; however, the built-in XML Schema types may have been used with the xsi:type attribute to specify element types. When the schemaID option is absent (i.e., undefined), no statement is made about the schema information used to encode the EXI body and this information MUST be communicated out of band. This specification does not dictate the syntax or semantics of other values specified in this field. An example schemaID scheme is the use of URI that is apt for globally identifying schema resources on the Web. The parties involved in the exchange are free to agree on the scheme of schemaID field that is appropriate for their use to uniquely identify the schema information.

The datatypeRepresentationMap option, represented by a "datatypeRepresentationMap" element, identifies datatype representations used to encode values in the EXI body as described in .

The blockSize option specifies the block size used for EXI compression. When the blockSize option is absent, the default blocksize of 1,000,000 is used. The default blockSize is intentionally large but can be reduced for processing large documents on devices with limited memory.

The valueMaxLength option specifies the maximum length of string values representing value content items to be considered for addition to the string table. When the valueMaxLength option is absent, the maximum length is unbounded. String values representing value content items that have length larger than the valueMaxLength option value are excluded from further consideration on account of valuePartitionCapacity for addition to the string table.

The valuePartitionCapacity option specifies the total capacity of the global and all local value partitions of a string table, where the measurement unit of the capacity is the number of unique enitiries. When the valuePartitionCapacity option is absent, an unbounded capacity is assumed. A string representing a value content item that has length smaller than or equal to the valueMaxLength option value and is not found in the value partitions at the time of the value occurrence is to be added into the string table only when doing so would not cause the number of unique values in value partitions to exceed the capacity. The use of valuePartitionCapacity option value and the way the number of unique values are counted for value partitions are described in .

The structure of an EXI stream is described by the EXI grammars, which are formally specified in section . Each grammar defines which events are permitted to occur at any given point in the EXI stream and provides a pre-assigned event code for each event.

For example, the grammar productions below describe the events that can occur in a schema-informed EXI stream after the Start-Document (SD) event provided there are four global elements defined in the schema and provide an event code for each event:

At the point in an EXI stream where the above grammar productions are in effect, the event code of Start Element "A" (i.e. SE("A")) is 0. The event code of a DOCTYPE (DT) event at this point in the stream is 4.1, and so on.

Each event code is represented by a sequence of 1 to 3 parts that uniquely identify an event. Event code parts are encoded in order starting with the first part followed by subsequent parts.

When the value of compression option is false, and bit-packed alignment option is used for the current processing of the stream, the ith part of an event code is encoded using the minimum number of bits required to distinguish it from the ith part of the other sibling event codes in the current grammar. Specifically, the ith part of an event code is encoded as an n-bit unsigned integer (), of which n is ⌈ log ₂ m ⌉ where m is the number of distinct values used as the ith part of its own and all its sibling event codes in the current grammar. Two event codes are siblings at the ith part if and only if they share the same values in all preceding parts. All event codes are siblings at the first part.

On the other hand, when the value of compression option is true, or either byte-alignment or pre-compression alignment option is used, the ith part of an event code is encoded using the minimum number of bytes instead of bits required to distinguish it from the ith part of the other sibling event codes in the current grammar. Each part is encoded as an n-bit unsigned integer (), of which n is ⌈ log ₂ m ⌉ where m is the number of distinct values used as the ith part of its own and all its sibling event codes in the current grammar. The number of bytes used for the n-bit unsigned integer representation in this case is equal to ⌈ n / 8 ⌉.

Regardless of the values of compression option and alignment option, if there is only one distinct value for a given part, the part is omitted (i.e., encoded in log ₂ 1 = 0 bits = 0 bytes).

For example, the nine event codes shown in the DocContent grammar above have a value ranging from 0 to 4 for their first part. There are five distinct values needed to identify the first part of these event codes. Therefore, when EXI compression and alignment are not in effect, the first part can be encoded in ⌈ log ₂ 5 ⌉ = 3 bits. In the same fashion, the number of bits used for encoding second and third part (if present) are calculated as ⌈ log ₂ 4 ⌉ = 2 bits and ⌈ log ₂ 2 ⌉ = 1 bits, respectively. On the other hand, when EXI compression or alignment is in effect, the number of bytes used for each part is ⌈ 3 / 8 ⌉ = 1 bytes for the first part, ⌈ 2 / 8 ⌉ = 1 bytes for the second part and ⌈ 1 / 8 ⌉ = 1 bytes for the third part.

The table below illustrates how the event codes of each event in the DocContent grammar above is encoded.

Some XML applications do not require the entire XML feature set and would prefer to eliminate the overhead associated with unused features. For example, the SOAP 1.2 specification prohibits the use of XML processing-instructions. In addition, there are many data-exchange use cases that do not require XML comments or DTDs.

Applications can use a set of fidelity options to specify the XML features they require. As specified in section , EXI processors MUST use these fidelity options to prune the events that are not required from the grammars, improving compactness and processing efficiency.

The table below lists the fidelity options supported by this version of the EXI specification and describes the effect setting these options has on the EXI stream.

The following sections describe the encoding rules of built-in EXI datatype representations for representing values in EXI streams.

Values of enumerated types are encoded as n-bit Unsigned Integers () where n = ⌈ log ₂ m ⌉ and m is the number of items in the enumerated type. The value assigned to each item corresponds to its ordinal position in the enumeration in schema-order starting with position zero (0).

Exceptions are for schema types derived from others by union and their subtypes, QName or Notation and types derived therefrom by restriction. The values of such types are processed by their respective built-in EXI datatype representations instead of being represented as enumerations.

EXI uses a string table to assign "compact identifiers" to some string values. Occurrences of string values found in the string table are represented using the associated compact identifier rather than encoding the entire "string literal". The string table is initially pre-populated with string values that are likely to occur in certain contexts and is dynamically expanded to include additional string values encountered in the document. The following content items are encoded using a string table:

When a string value is found in the string table, the value is encoded using the compact identifier and no changes are made to the string table as a result. When a string value is not found in the string table, its string literal is encoded as a String without using a compact identifier, only after which the string table is augmented by including the string value with an assigned compact identifier unless the string value represents a value content item and fails to satisfy the criteria in effect by virtue of valuePartitionCapacity and valueMaxLength options .

The string table is divided into partitions and each partition is optimized for more frequent use of either compact identifiers or string literals depending on the purpose of the partition. Section describes how EXI string table is partitioned. Section describes how string values are encoded when the associated partition is optimized for more frequent use of compact identifiers. Section describes how string values are encoded when the associated partition is optimized for more frequent use of string literals.

The life cycle of a string table spans the processing of a single EXI stream. String tables are not represented in an EXI stream or exchanged between EXI processors. A string table cannot be reused across multiple EXI streams; therefore, EXI processors MUST use a string table that is equivalent to the one that would have been newly created and pre-populated with initial values for processing each EXI stream.

By default, each typed value in an EXI stream is represented by the associated built-in EXI datatype representation (e.g., see ). However, EXI processors MAY provide the capability to specify different built-in EXI datatype representations or user-defined datatype representations for representing specific schema datatypes. This capability is called Datatype Representation Map .

EXI processors that support Datatype Representation Map MAY provide external means to define and install user-defined datatype representations , of which EXI processors are free to choose implementation dependent mechanisms. EXI processors MAY also provide means for applications or users to specify alternate built-in EXI datatype representations or user-defined datatype representations for representing specific schema datatypes, the mechanisms of which are again implementation dependent.

When an EXI processor encodes an EXI stream using Datatype Representation Map , it MUST specify in the EXI header each schema datatype that is not represented using the default built-in EXI datatype representation and the alternate built-in EXI datatype representation or user-defined datatype representation used for each one unless the whole EXI Options part of the header is omitted. An EXI processor that attempts to decode an EXI stream that specifies a user-defined datatype representation in the EXI header that it does not recognize MAY report a warning, but this is not an error. However, when an EXI processor encounters a typed value that was encoded by a user-defined datatype representation that it does not support, it MUST report an error.

The EXI options header, when it appears in an EXI stream, MUST include a "datatypeRepresentationMap" element for each schema datatype that is not represented using the default built-in EXI datatype representation. The "datatypeRepresentationMap" element includes two child elements. The qname of the first child element identifies the schema datatype that is not represented using the default built-in EXI datatype representation and the qname of the second child element identifies the alternate built-in EXI datatype representation or user-defined datatype representation used to represent that type. Built-in EXI datatype representations are identified by the type identifiers in .

For example, the following "datatypeRepresentationMap" element indicates all values of type xsd:decimal in the EXI stream are represented using the built-in String datatype representation, which has the type ID xsd:string:

It is the responsibility of an EXI processor to interface with a particular implementation of built-in EXI datatype representations or user-defined datatype representations properly. In the example above, an EXI processor may need to provide a string value of the data being processed that is typed as xsd:decimal in order to interface with an implementation of built-in String datatype representation. In such a case, some EXI processors may have started with a decimal value and such processors may well translate the value into a string before passing the data to the implementation of built-in String datatype representation while other EXI processors may already have a string value of the data so that it can pass the value directly to the implementation of built-in String datatype representation without any translation.

As another example, the following "datatypeRepresentationMap" element indicates all values of the used-defined datatype geo:geometricSurface are represented using the user-defined datatype representation geo:geometricInterpolator:

Each production rule in the EXI grammar includes an event code value that approximates the likelihood the associated production rule will be matched over the other productions with the same left-hand-side non-terminal symbol. Ultimately, the event codes determine the value(s) by which each non-terminal symbol will be represented in the EXI stream.

To understand how a given event code approximates the likelihood a given production will matched, it is useful to visualize the event codes for a set of production rules that have the same non-terminal symbol on the left-hand-side as a tree. For example, the following set of productions:

represents a set of information items that might occur as element content after the start tag. Using the production event codes, we can visualize this set of productions as follows:

As discussed in section , applications MAY provide a set of fidelity options to specify the XML features they require. EXI processors MUST use these fidelity options to prune the events that are not required from the grammars, improving compactness and processing efficiency.

For example, the following set of productions represent the set of information items that might occur as element content after the start tag.

If an application sets the fidelity options preserve.comments, preserve.pis and preserve.dtd to false, the productions matching comment (CM), processing instruction (PI) and entity reference (ER) events are pruned from the grammar, producing the following set of productions:

Removing these productions from the grammar tells EXI processors that comments and processing instructions will never occur in the EXI stream, which reduces the entropy of the stream allowing it to be encoded in fewer bits.

Each time a production is removed from a grammar, the event codes of the other productions with the same non-terminal symbol on the left-hand-side MUST be adjusted to keep them contiguous if its removal has left the remaining productions with non-contiguous event codes.

This section describes the built-in XML grammar used by EXI when no additional information is available to describe the contents of the EXI stream. The built-in XML grammar is used when no schema exists, and for schema extensions and deviations that are not declared by the schema.

A built-in XML grammar is self-evolving. The built-in grammar continuously reflects the knowledge being learned while processing an EXI stream onto itself in order to keep refining itself for subsequent use of the grammar within the extent of processing a single stream.

This section describes the schema-informed grammars used by EXI when schema information is available to describe the contents of the EXI stream. Schema-informed grammars are independent of any particular schema language and can be derived from W3C XML Schemas, RELAX NG schemas, DTDs or other schema languages for describing what is likely to occur in an EXI stream.

Schema-informed grammars accept all XML documents and fragments regardless of whether and how closely they match the schema. The encoder encodes individual events using schema-informed grammars where they are available and falls back to the built-in XML grammars where they are not. In general, events for which a schema-informed grammar exists will be encoded more efficiently.

Unlike built-in XML grammars, schema-informed grammars are static and do not evolve, which permits the reuse of schema-informed grammars across the processing of multiple EXI streams. This is a single outstanding difference between the two grammar systems.

With such differences, however, their uses are not exclusive, but are connected together at individual grammar level. Of particular note is that built-in grammars that are called upon for schema-deviated parts are still subject to dynamic grammar learning during the rest of the EXI stream processing as is described in .

Conformant EXI streams consist of a sequence of octets that follows the syntax of EXI stream that is defined in this document. EXI format provides a way to involve user-defined datatype representations in EXI streams processing, which is an extension point that, when used in conjunction with relevant datatype representations specifications external to this document, leads to the formulation of Extended EXI streams.

Conformance of extended EXI streams are relative to the syntax defined by the relevant user-defined datatype representations specifications. The definitions of user-defined datatype representations syntax are out of the scope of this document. An extended EXI stream is a conformant extended EXI streams if replacing value items represented using user-defined datatype representations with their intrinsic representations would make the stream a conformant EXI streams. When the use of user-defined datatype representations is expected, and agreed upon prior to the exchange of EXI streams, the parties intended to participate in the exchange not only need to share the knowledge about the datatype representations, but also MUST advertise the stream as "EXI streams with regards to datatype representations S" instead of simply as "EXI streams" when they are asked to do so, where S is an unordered set of datatype representations. An "EXI streams with regards to datatype representations S" where S is the set of datatype representations can be processed by an EXI stream decoder only if the processor has the shared knowledge about each one of the datatype representations in the set S. EXI stream decoders MAY fail with an error when they receive an extended EXI Stream that uses an user-defined datatype representations that it does not understand.

The structural syntax of EXI streams and extended EXI streams is described by the abstract EXI grammar system defined in this document. Although this document specifies the normative way in which XML Schema schemas are mapped into the EXI grammar system to make a schema-informed grammar, EXI allows the use of other schema languages to process EXI streams or extended EXI streams so far as there is a well known EXI grammar binding to the schema language and the binding preserves the semantics part of the EXI grammar system. EXI streams or extended EXI streams generated using schemas of such schema language are still conformant. The definitions of grammar binding to schema languages other than XML Schema is out of the scope of this document, and each community of schema languages is encouraged to define a binding to make the most efficiency out of EXI when schemas of that language are available .

The conformance of EXI Processors are defined separately for each of the two processor roles, EXI stream encoders and EXI stream decoders; the conformance of the former is described in terms of the conformance of the EXI streams or extended EXI streams that they produce, while that of the latter is based on the set of format features that EXI stream decoders are prepared with for processing conformant EXI streams or conformant extended EXI streams.

An EXI stream encoder is conformant if and only if it is capable of generating conformant EXI streams or conformant extended EXI streams given any input structured data it is made to work on. On the other hand, EXI stream decoders MUST support all format features described in this document as they are explained, except for the capability of handling Datatype Representation Map which is an optional feature. EXI stream decoders that do not implement Datatype Representation Map feature MUST report an error with a meaningful message upon encountering a "datatypeRepresentationMap" element while processing EXI options documents in EXI headers.

Both an EXI stream encoder and an EXI stream decoder MAY support only a certain range of values for the EXI header option blockSize. For interoperability between processors, every EXI processors SHOULD at least support the blockSize option value of 1,000,000.