Parsing API

Parse one FIX message into a structured ParsedMessage with nested repeating groups and coerced field values, returning diagnostics as data. Never throws — every problem (malformed field, unknown tag, group-count mismatch, bad checksum, …) is a returned FixIssue.

If the input holds several concatenated messages, only the first frame is parsed; use parseAll for the whole buffer.

The parse is dictionary-driven: groups are reconstructed using each group's first body field as the entry boundary (FIX has no group delimiters), and data fields whose value may embed the separator are read by their preceding Length field. Field order in the input is tolerated; the structure is what matters.

When the MsgType is unknown to the dictionary (or absent), the message is parsed flat — fields are kept at the top level with no group reconstruction, and a repeated tag is reported (parse/duplicate-tag) keeping the first. A parse/unknown-msgtype issue is also emitted.

dict may also be a FIXT transport/application pair (FixtDictionaries): the message is then parsed over the pair's merged view — envelope and session messages from the transport, bodies from the application dictionary, with begin-string-mismatch comparing against the transport's FIXT.1.1. With a resolveApp hook, each message's ApplVerID(1128) (falling back to the pair's defaultApplVerID) routes it to the right application dictionary.

Parse every message in a buffer of concatenated frames. Returns one ParseResult per message, in order; an empty array for empty input. Never throws.

Options for parse and parseAll.

The result of parse: the structured message plus any diagnostics.

A parsed FIX message: a structured, nested view of one frame. Repeating groups are reconstructed as arrays of objects (not parallel arrays). The shape mirrors EncodeMessage so it re-encodes cheaply via toEncodeMessage.

One parsed scalar field. raw is the verbatim wire value and the source of truth for re-encoding (so leading-zero codes, float formatting, and binary data round-trip exactly); value is the typed convenience form, never used for re-encode.

One entry of a repeating group: its own fields and any nested groups, keyed by tag.

Convert a ParsedMessage back into an EncodeMessage suitable for encode, using each field's verbatim ParsedField.raw value so the round-trip preserves the exact wire content. Framing fields (8/9/10) are carried but ignored by the encoder, which recomputes them.

Coerce one raw wire value to its typed form per the field's datatype.

Design rules:

• Multi-value lists split first. A MultipleValueString field (e.g. ExecInst) splits into a string[] of its space-delimited tokens before enum opacity applies, because such fields are enumerated per token — the result is a list of opaque enum tokens ("1 2 5" → ["1", "2", "5"]) the M3 validator can check element-by-element.
• Enumerated single values are opaque. A non-list field with an enumValues table keeps its raw string ("1", "004", "USD") — never a number — so leading-zero codes survive and enum membership (checked by the M3 validator) compares like-for-like.
• Dates/times stay strings. UTCTimestamp/UTCDateOnly/LocalMktDate/month-year are returned verbatim; the engine is pure and deterministic and does not introduce a Date (which would entangle time zones and lose the on-the-wire form).
• Floats keep their wire form for re-encode via the raw string the parser retains alongside this value; the number here is a convenience that may lose insignificant digits ("23.0" → 23), so it is never the source of truth for round-tripping.

Never throws.

The result of coercing one wire value: the decoded value plus any diagnostics.

A FIX field value after datatype coercion:

• number for int/float families,
• boolean for Boolean,
• string[] for MultipleValueString,
• string for everything else (plain strings, enums, dates, currency/country codes, and data — all kept verbatim).

When a value cannot be coerced to its declared type (e.g. "x" for an int field), the raw string is returned unchanged and an error FixIssue is reported, so a single malformed field never corrupts the rest of the parse and re-encoding still round-trips.

Split a raw FIX message into ordered [tag, value] pairs.

This is a purely lexical pass: it preserves field order (so repeating groups can be reconstructed downstream), keeps duplicate tags as separate entries, and never throws. Two correctness fixes over the original implementation:

• = in values. The tag/value boundary is the first =, found with String.indexOf, not split('=') — so a value that itself contains = (common in data/Text payloads and Base64) survives intact.
• Bytes in, text out. A Uint8Array is decoded as UTF-8, so non-ASCII field values round-trip without Buffer.

Note: a trailing separator after the final field (the normal on-the-wire form) yields no empty token; input with no separators yields at most one token. Length-prefixed data fields whose value embeds a raw SOH are not special-cased here — that requires dictionary knowledge and is handled by the parser.

Options for tokenize.

A single decoded FIX field: its numeric tag and its raw, still-encoded value.

The value is the verbatim characters between = and the terminating SOH; no datatype coercion, trimming, or enum resolution is applied here (that is the dictionary-driven parser's job). The tag is NaN when the tag portion was not a valid integer — callers decide whether that is an error.

Tokenize a single message into ordered [tag, value] pairs with length-aware handling of data fields: when a Length field (one that some data field points to via FieldDef.lengthField) is read, the immediately following data field's value is taken as exactly that many UTF-8 bytes — even if it contains the SOH separator — so binary payloads survive intact. For every other field this matches tokenize.

Like tokenize, it is purely lexical and never throws: it preserves field order and duplicates, skips empty segments, and emits a NaN tag for a segment with no =.

Split a buffer that may hold several concatenated FIX messages into one byte slice per message. This fixes the legacy behaviour where only the first message in a buffer survived.

Boundaries are computed from each message's BodyLength (tag 9), which is the only robust method: a data field value may itself embed the SOH separator or even a 8=/10= byte sequence, so scanning for those markers would mis-split. The math is byte-accurate (operates on UTF-8 bytes, not string code units). When a message's BodyLength is missing or unusable, it falls back to slicing up to the next SOH+8= boundary so malformed input still degrades gracefully instead of being lost.

Leading/trailing bytes outside any 8=…10= frame are ignored. Never throws.

Options for splitMessages and scanFields.