@cosyte/astm 0.0.3 → 0.0.5

package/dist/index.d.ts

@@ -3,8 +3,8 @@
  * record layer.
  *
  * **PHI discipline (the whole point).** A position identifies *where* a
- * deviation occurred — the record's ordinal index, its type letter, and the
- * 1-based field / component indices — and **never** carries a field value. A
+ * deviation occurred (the record's ordinal index, its type letter, and the
+ * 1-based field / component indices) and **never** carries a field value. A
  * warning or error may be logged verbatim without leaking a patient name, an
  * identifier, or a result value.
  */
@@ -51,21 +51,21 @@ interface AstmPosition {
  * ```
  */
 declare const WARNING_CODES: {
-    /** A record's type letter is not one of the modeled types — surfaced as an unsupported record. */
+    /** A record's type letter is not one of the modeled types: surfaced as an unsupported record. */
     readonly ASTM_RECORD_UNKNOWN_TYPE: "ASTM_RECORD_UNKNOWN_TYPE";
-    /** The header declared delimiters other than the canonical `H|\^&` — tolerated, noted. */
+    /** The header declared delimiters other than the canonical `H|\^&`: tolerated, noted. */
     readonly ASTM_NONSTANDARD_DELIMITERS: "ASTM_NONSTANDARD_DELIMITERS";
-    /** An escape sequence body was not one of `&F&`/`&S&`/`&R&`/`&E&` — preserved verbatim. */
+    /** An escape sequence body was not one of `&F&`/`&S&`/`&R&`/`&E&`: preserved verbatim. */
     readonly ASTM_UNKNOWN_ESCAPE_SEQUENCE: "ASTM_UNKNOWN_ESCAPE_SEQUENCE";
     /**
      * A result value field carried an *unescaped* component delimiter, so it split into more than one
-     * component. Both the full raw value and the split are surfaced and this warning fires — the
+     * component. Both the full raw value and the split are surfaced and this warning fires: the
      * ambiguity is never resolved silently into a truncated value.
      */
     readonly ASTM_RECORD_AMBIGUOUS_VALUE_SPLIT: "ASTM_RECORD_AMBIGUOUS_VALUE_SPLIT";
     /**
      * A result's abnormal-flag field (`R` field 7) carried a letter outside HL7 Table 0078. The flag is
-     * surfaced as `undefined` — never dropped, and **never coerced to `normal`** (a clinical error).
+     * surfaced as `undefined`: never dropped, and **never coerced to `normal`** (a clinical error).
      */
     readonly ASTM_RECORD_UNDEFINED_ABNORMAL_FLAG: "ASTM_RECORD_UNDEFINED_ABNORMAL_FLAG";
     /**
@@ -75,7 +75,7 @@ declare const WARNING_CODES: {
     readonly ASTM_RECORD_UNDEFINED_RESULT_STATUS: "ASTM_RECORD_UNDEFINED_RESULT_STATUS";
     /**
      * A result's reference-range field (`R` field 6) did not match a recognized form (`low-high`,
-     * `<high`, `>low`). The text is surfaced verbatim as `unparsed` — a bound is **never fabricated**.
+     * `<high`, `>low`). The text is surfaced verbatim as `unparsed`: a bound is **never fabricated**.
      */
     readonly ASTM_RECORD_UNPARSEABLE_REFERENCE_RANGE: "ASTM_RECORD_UNPARSEABLE_REFERENCE_RANGE";
     /**
@@ -84,35 +84,57 @@ declare const WARNING_CODES: {
      */
     readonly ASTM_RECORD_UNITS_ABSENT: "ASTM_RECORD_UNITS_ABSENT";
     /**
-     * A `C` (comment) record had no valid preceding `H`/`P`/`O`/`R` parent — an **orphan**. The comment
+     * A `C` (comment) record had no valid preceding `H`/`P`/`O`/`R` parent: an **orphan**. The comment
      * is attached to the message root (`attachedToRoot: true`) and surfaced, **never dropped**.
      */
     readonly ASTM_RECORD_ORPHAN_COMMENT: "ASTM_RECORD_ORPHAN_COMMENT";
     /**
      * A `YYYYMMDDHHMMSS` timestamp had an odd digit run that truncates a two-digit component in half
      * (e.g. a partial day/hour). The raw run is preserved and the structured value stops at the last
-     * **complete** component — the dangling digit is **never zero-filled into a fabricated time**.
+     * **complete** component: the dangling digit is **never zero-filled into a fabricated time**.
      */
     readonly ASTM_RECORD_PARTIAL_TIMESTAMP: "ASTM_RECORD_PARTIAL_TIMESTAMP";
     /**
      * A `Q` (request-information) record carried a request-information status code (field 13). The code
      * *set* is `[OSS-derived / paywalled]` with no publicly-groundable enumeration, so the parser
      * interprets **none** of them: the status is surfaced verbatim and this value-free warning flags that
-     * it was passed through **uninterpreted** — never mapped to a guessed meaning.
+     * it was passed through **uninterpreted**, never mapped to a guessed meaning.
      */
     readonly ASTM_RECORD_UNINTERPRETED_QUERY_STATUS: "ASTM_RECORD_UNINTERPRETED_QUERY_STATUS";
     /**
-     * A message carried **both** a `Q` (request) and an `R` (result) record — a contradictory shape. The
+     * A message carried **both** a `Q` (request) and an `R` (result) record: a contradictory shape. The
      * message is classified `host-query` (the `Q` **dominates**, so it is never read as a result set) and
      * this warning flags the anomaly. Positional context only; no field value.
      */
     readonly ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND: "ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND";
+    /**
+     * A later `H` (header) record declared a **different** delimiter set from the one in force, and the
+     * parser **followed it**: that header and every record after it are read with the newly-declared
+     * delimiters, until the next `H`. Records already read keep the set that was in force when they were
+     * read: a redeclaration never reinterprets bytes that have already been consumed.
+     *
+     * A stream carrying several messages back to back is ordinary, and a header that simply **repeats**
+     * the delimiters already in force is a no-op that warns nothing. This code fires only when the set
+     * actually changes, because that is the point at which a reader still using the old set would begin
+     * merging fields together.
+     */
+    readonly ASTM_RECORD_DELIMITERS_REDECLARED: "ASTM_RECORD_DELIMITERS_REDECLARED";
+    /**
+     * A later `H` (header) record could not declare a usable delimiter set: it was too short, or the
+     * field separator it named also appeared among the other three, leaving the four roles
+     * indistinguishable. The delimiters **already in force are kept** and every record is still surfaced;
+     * a set is never guessed and no record is dropped.
+     *
+     * The same condition on the *first* header is unrecoverable and remains the
+     * `ASTM_RECORD_UNDECLARED_DELIMITERS` fatal: there is no earlier set to fall back to.
+     */
+    readonly ASTM_RECORD_UNREADABLE_REDECLARATION: "ASTM_RECORD_UNREADABLE_REDECLARATION";
     /**
      * The downgraded form an active vendor {@link AstmProfile} produces from a deviation it *expects*
      * (see `src/profiles/`). The original warning is **never dropped**: its code moves to
      * {@link AstmRecordWarning.toleratedCode}, the warning is re-badged `PROFILE_QUIRK_APPLIED` with
      * `expected: true` and the tolerating profile named, so a consumer can filter known, grounded noise
-     * while the fact of the deviation — and where it was — survives. A profile can only ever reach this
+     * while the fact of the deviation, and where it was, survives. A profile can only ever reach this
      * path for a **non-safety-critical** code (enforced at profile-definition time); a safety-critical
      * deviation (a result value, flag, status, patient identifier, code system, or a frame-integrity
      * warning) can **never** be tolerated, so it can never be re-badged here.
@@ -148,14 +170,14 @@ interface AstmRecordWarning {
      * `true` when an active vendor {@link AstmProfile} *expected* this deviation and re-badged it as a
      * {@link WARNING_CODES.PROFILE_QUIRK_APPLIED}. An `expected` warning does **not** escalate to a
      * thrown `AstmStrictError` in strict mode (the whole point of the profile is that this deviation is
-     * known and benign) — it is still recorded, so nothing is hidden. Absent on an untolerated warning.
+     * known and benign): it is still recorded, so nothing is hidden. Absent on an untolerated warning.
      */
     readonly expected?: boolean;
     /** The name of the {@link AstmProfile} that tolerated this warning, when `expected`. */
     readonly profile?: string;
     /**
      * When `code` is {@link WARNING_CODES.PROFILE_QUIRK_APPLIED}, the original warning code the profile
-     * tolerated — so a consumer can still see *which* deviation was re-badged as expected.
+     * tolerated, so a consumer can still see *which* deviation was re-badged as expected.
      */
     readonly toleratedCode?: WarningCode;
 }
@@ -181,6 +203,31 @@ declare function unknownRecordType(position: AstmPosition): AstmRecordWarning;
  * ```
  */
 declare function nonStandardDelimiters(position: AstmPosition): AstmRecordWarning;
+/**
+ * Build an `ASTM_RECORD_DELIMITERS_REDECLARED` warning. Emitted when a later `H`
+ * record declares a delimiter set different from the one in force; the new set is
+ * honored from that header onward. Positional context only: never the delimiters
+ * themselves.
+ *
+ * @example
+ * ```ts
+ * import { delimitersRedeclared } from "@cosyte/astm";
+ * delimitersRedeclared({ recordIndex: 5, recordType: "H" });
+ * ```
+ */
+declare function delimitersRedeclared(position: AstmPosition): AstmRecordWarning;
+/**
+ * Build an `ASTM_RECORD_UNREADABLE_REDECLARATION` warning. Emitted when a later
+ * `H` record cannot declare a usable delimiter set; the set already in force is
+ * kept and every record is still surfaced.
+ *
+ * @example
+ * ```ts
+ * import { unreadableRedeclaration } from "@cosyte/astm";
+ * unreadableRedeclaration({ recordIndex: 2, recordType: "H" });
+ * ```
+ */
+declare function unreadableRedeclaration(position: AstmPosition): AstmRecordWarning;
 /**
  * Build an `ASTM_UNKNOWN_ESCAPE_SEQUENCE` warning. The sequence is preserved
  * verbatim in the decoded value; the warning body carries neither the sequence
@@ -195,7 +242,7 @@ declare function nonStandardDelimiters(position: AstmPosition): AstmRecordWarnin
 declare function unknownEscapeSequence(position: AstmPosition): AstmRecordWarning;
 /**
  * Build an `ASTM_RECORD_AMBIGUOUS_VALUE_SPLIT` warning. Emitted when a result
- * value field split on an unescaped component delimiter — the full raw value and
+ * value field split on an unescaped component delimiter: the full raw value and
  * the split are both surfaced, never a silent truncation.
  *
  * @example
@@ -299,7 +346,7 @@ declare function uninterpretedQueryStatus(position: AstmPosition): AstmRecordWar
  */
 declare function ambiguousMessageKind(position: AstmPosition): AstmRecordWarning;
 /**
- * Build a `PROFILE_QUIRK_APPLIED` warning — the downgraded form an active vendor profile produces from
+ * Build a `PROFILE_QUIRK_APPLIED` warning: the downgraded form an active vendor profile produces from
  * a deviation it *expects*. The original warning is **not dropped**: its `code` moves to
  * `toleratedCode`, the warning is re-badged `PROFILE_QUIRK_APPLIED`, `expected` is set, and the
  * tolerating profile is named. The original `position` and `message` are preserved (both PHI-free by
@@ -326,7 +373,7 @@ declare function profileQuirkApplied(original: AstmRecordWarning, profileName: s
  *
  * ASTM/CLSI-LIS02 messages are **self-describing**: every `H` (header) record
  * declares the four delimiters it uses, in the bytes immediately after the `H`.
- * A parser MUST read them from the record and MUST NOT hardcode them — a vendor
+ * A parser MUST read them from the record and MUST NOT hardcode them: a vendor
  * is free to declare non-standard delimiters and a conformant reader follows.
  *
  * The canonical declaration is `H|\^&`:
@@ -358,18 +405,18 @@ declare function profileQuirkApplied(original: AstmRecordWarning, profileName: s
  * ```
  */
 interface Delimiters {
-    /** Field separator — the char immediately after `H` in the header. */
+    /** Field separator: the char immediately after `H` in the header. */
     readonly field: string;
-    /** Repeat (repetition) separator — ASTM `\` by default. */
+    /** Repeat (repetition) separator: ASTM `\` by default. */
     readonly repeat: string;
-    /** Component separator — ASTM `^` by default. */
+    /** Component separator: ASTM `^` by default. */
     readonly component: string;
-    /** Escape character — ASTM `&` by default (introduces `&F&`/`&S&`/`&R&`/`&E&`). */
+    /** Escape character: ASTM `&` by default (introduces `&F&`/`&S&`/`&R&`/`&E&`). */
     readonly escape: string;
 }
 /**
  * The canonical ASTM delimiter set (`H|\^&`). Used only as documentation and as
- * a comparison baseline for the non-standard-delimiter warning — never as a
+ * a comparison baseline for the non-standard-delimiter warning: never as a
  * parse-time default (delimiters are always read from the header).
  *
  * @example
@@ -383,10 +430,18 @@ declare const CANONICAL_DELIMITERS: Delimiters;
  * Read the four delimiters from a header record's raw text (a single `H`
  * record, its terminator already stripped).
  *
- * Returns `{ ok: false }` when the record cannot declare all four delimiters —
- * it is shorter than `H` + a field separator + a 3-char delimiter definition —
- * which the caller escalates to the `ASTM_RECORD_UNDECLARED_DELIMITERS` fatal.
- * This function does not throw; delimiter resolution and the fatal decision are
+ * Returns `undefined` when the record cannot declare all four delimiters: it is
+ * shorter than `H` + a field separator + a 3-char delimiter definition, or the
+ * field separator it names also appears among the other three.
+ *
+ * What the caller does with that depends on **which** header it is. On the first
+ * header it is the `ASTM_RECORD_UNDECLARED_DELIMITERS` fatal, because there is no
+ * earlier set to fall back to. On any later header (a stream may carry several
+ * messages, each declaring its own set) the delimiters already in force are kept
+ * and an `ASTM_RECORD_UNREADABLE_REDECLARATION` warning is raised instead; a set is
+ * never guessed and no record is dropped.
+ *
+ * This function does not throw: delimiter resolution and the escalation decision are
  * kept separate so the reader stays pure and testable.
  *
  * @param headerRecord - The raw `H` record text (no trailing CR/LF).
@@ -413,12 +468,12 @@ declare function readDelimiters(headerRecord: string): Delimiters | undefined;
 declare function isNonStandard(d: Delimiters): boolean;
 
 /**
- * The ASTM date/time value — `YYYYMMDDHHMMSS`, precision-preserving, no timezone.
+ * The ASTM date/time value: `YYYYMMDDHHMMSS`, precision-preserving, no timezone.
  *
  * ASTM timestamps are a run of digits, most-significant first, truncated at
  * whatever precision the instrument reports. There is **no timezone field**:
  * the value is local to the instrument and this parser never assumes UTC. A
- * date-only value (`YYYYMMDD`) is a normal, complete value at day precision —
+ * date-only value (`YYYYMMDD`) is a normal, complete value at day precision:
  * **not** an error and never zero-filled into a fake time.
  */
 /** The precision to which an {@link AstmDate} is populated. */
@@ -427,7 +482,7 @@ type AstmDatePrecision = "year" | "month" | "day" | "hour" | "minute" | "second"
  * A parsed ASTM date/time. Immutable plain data; the populated fields extend
  * exactly as far as {@link AstmDate.precision}. Absent components are left
  * `undefined` rather than defaulted, so a consumer can tell "midnight" from
- * "no time given". No timezone is modeled — the value is instrument-local.
+ * "no time given". No timezone is modeled: the value is instrument-local.
  *
  * @example
  * ```ts
@@ -449,10 +504,10 @@ interface AstmDate {
     /** How far the components are populated. */
     readonly precision: AstmDatePrecision;
     /**
-     * `true` when the digit run does **not** align to a whole-component boundary — an odd number of
+     * `true` when the digit run does **not** align to a whole-component boundary: an odd number of
      * digits that cuts a two-digit component (month/day/hour/minute/second) in half (lengths 5, 7, 9,
      * 11, 13). The full run is preserved in {@link AstmDate.raw} and the structured value is truncated
-     * to the last **complete** component — the dangling digit is **never zero-filled into a fabricated
+     * to the last **complete** component: the dangling digit is **never zero-filled into a fabricated
      * time**. Absent (never `false`) for a clean value. A caller surfaces this as a value-free
      * `ASTM_RECORD_PARTIAL_TIMESTAMP` warning.
      */
@@ -461,7 +516,7 @@ interface AstmDate {
 /**
  * Parse an ASTM `YYYYMMDDHHMMSS` value, preserving whatever precision is
  * present. Returns `undefined` for a value that is not a usable timestamp (fewer
- * than four leading digits for the year, or non-digit content) — a caller keeps
+ * than four leading digits for the year, or non-digit content): a caller keeps
  * the raw field text either way, so nothing is lost. A partial value is parsed,
  * never rejected.
  *
@@ -480,7 +535,7 @@ interface AstmDate {
 declare function parseAstmDate(raw: string): AstmDate | undefined;
 /**
  * Render an {@link AstmDate} as an ISO-8601-*like* string truncated to its
- * precision, with **no** `Z` and **no** offset — because ASTM carries no
+ * precision, with **no** `Z` and **no** offset: because ASTM carries no
  * timezone and appending one would fabricate information. A consumer that knows
  * the instrument's zone can attach it; this function never assumes UTC.
  *
@@ -501,9 +556,9 @@ declare function astmDateToLocalISO(d: AstmDate): string;
  * spec's component order is LOINC-slot / test-name / coding-scheme / local-code.
  * In the field the way real analyzers emit it:
  *
- * - **component 1** is a LOINC slot — *almost always empty*; a few vendors place
+ * - **component 1** is a LOINC slot: *almost always empty*; a few vendors place
  *   an inline LOINC when one exists;
- * - **component 4** is the vendor/local code — the identifier that is actually
+ * - **component 4** is the vendor/local code: the identifier that is actually
  *   present, and therefore the **primary** identifier here.
  *
  * Following the sibling parsers' conservative posture, this module is a
@@ -513,11 +568,11 @@ declare function astmDateToLocalISO(d: AstmDate): string;
  */
 /** Where a Universal Test ID's usable identifier came from. */
 type UniversalTestIdProvenance = 
-/** Component 1 (the LOINC slot) is populated — a candidate LOINC, recognized not validated. */
+/** Component 1 (the LOINC slot) is populated: a candidate LOINC, recognized not validated. */
 "inline-loinc-candidate"
 /** Component 4 (the vendor/local code) carries the identifier. */
  | "local-code"
-/** Only the test name (component 2) is present — no code. */
+/** Only the test name (component 2) is present: no code. */
  | "name-only"
 /** Nothing usable in the field. */
  | "empty";
@@ -536,13 +591,13 @@ type UniversalTestIdProvenance =
 interface UniversalTestId {
     /** The field's components, verbatim and in order. */
     readonly components: readonly string[];
-    /** Component 1 when populated — a *candidate* LOINC (provenance only, never validated). */
+    /** Component 1 when populated: a *candidate* LOINC (provenance only, never validated). */
     readonly loincCandidate?: string;
-    /** Component 2 — the test / battery name, when present. */
+    /** Component 2: the test / battery name, when present. */
     readonly testName?: string;
-    /** Component 3 — the coding-scheme selector, when present. */
+    /** Component 3: the coding-scheme selector, when present. */
     readonly codingScheme?: string;
-    /** Component 4 — the vendor/local code: the primary identifier when no inline LOINC is given. */
+    /** Component 4, the vendor/local code: the primary identifier when no inline LOINC is given. */
     readonly localCode?: string;
     /** Where the primary identifier came from. */
     readonly provenance: UniversalTestIdProvenance;
@@ -562,7 +617,7 @@ declare function recognizeUniversalTestId(components: readonly string[]): Univer
 /**
  * The primary code to key a result on: the inline LOINC candidate when a vendor
  * supplied one, otherwise the local (vendor) code. Returns `undefined` when the
- * field carries no code at all (name-only or empty) — never a guess.
+ * field carries no code at all (name-only or empty): never a guess.
  *
  * @param u - A recognized Universal Test ID.
  * @returns The primary code, or `undefined`.
@@ -578,7 +633,7 @@ declare function primaryCode(u: UniversalTestId): string | undefined;
  * Positional context for frame-codec warnings and errors.
  *
  * **PHI discipline (the whole point).** A frame deviation is located by **frame
- * number + byte offset** and nothing else — never the record text a frame
+ * number + byte offset** and nothing else: never the record text a frame
  * carries. A frame warning or error may be logged verbatim without ever leaking a
  * result value, a patient identifier, or any other field the reassembled record
  * bytes contain.
@@ -604,12 +659,12 @@ interface AstmFramePosition {
 }
 
 /**
- * The **frame** warning registry (`ASTM_FRAME_*`) for the ASTM/CLSI-LIS01 codec —
+ * The **frame** warning registry (`ASTM_FRAME_*`) for the ASTM/CLSI-LIS01 codec:
  * the second of the package's two registries, alongside the record layer's
  * `ASTM_RECORD_*` (both share only the `EMPTY_INPUT` fatal).
  *
  * A frame warning is the lenient codec's record of a tolerated byte-level
- * deviation: it never crashes, never invents a value, and — critically — never
+ * deviation: it never crashes, never invents a value, and, critically, never
  * lets an untrusted frame be silently merged into a record. Every warning carries
  * a stable code plus an {@link AstmFramePosition} (frame number + byte offset) and
  * **never** the record bytes a frame carries (PHI discipline). Consumers compare
@@ -634,12 +689,12 @@ declare const FRAME_WARNING_CODES: {
      * A frame's two-hex-char checksum did not match the modulo-256 sum recomputed over its bytes. The
      * frame is surfaced with `trusted: false` and its text is **never merged** into a reassembled
      * record (default **warn** in lenient mode, escalated to a thrown error in `strict`). Corruption is
-     * never silently trusted — the "checksums are routinely not validated" claim was refuted; we
+     * never silently trusted: the "checksums are routinely not validated" claim was refuted; we
      * validate.
      */
     readonly ASTM_FRAME_BAD_CHECKSUM: "ASTM_FRAME_BAD_CHECKSUM";
     /**
-     * A frame's sequence number was not the expected next value (`1 → … → 7 → 0 → …`) — a frame was
+     * A frame's sequence number was not the expected next value (`1 → … → 7 → 0 → …`): a frame was
      * possibly dropped. The stream is **never silently concatenated across the gap** as if contiguous;
      * the in-progress record is tainted and not emitted as a clean reassembly.
      */
@@ -653,7 +708,7 @@ declare const FRAME_WARNING_CODES: {
     readonly ASTM_FRAME_UNTERMINATED: "ASTM_FRAME_UNTERMINATED";
     /**
      * A frame's record text exceeded the 240-byte limit without a split. The frame is still surfaced
-     * (and, if its checksum validates, reassembled) — the deviation is flagged, not silently dropped
+     * (and, if its checksum validates, reassembled): the deviation is flagged, not silently dropped
      * (warn in lenient, thrown in `strict`).
      */
     readonly ASTM_FRAME_OVERSIZE: "ASTM_FRAME_OVERSIZE";
@@ -730,14 +785,14 @@ declare function frameOversize(position: AstmFramePosition): AstmFrameWarning;
 
 /**
  * The **LTP** warning registry (`ASTM_LTP_*`) for the ASTM/CLSI-LIS01 protocol
- * layer — the third of the package's registries, alongside the record layer's
+ * layer: the third of the package's registries, alongside the record layer's
  * `ASTM_RECORD_*` and the frame codec's `ASTM_FRAME_*`.
  *
  * An LTP warning is the protocol reducer's (or the transport detector's) record
  * of a tolerated session-level deviation: an ambiguous framed/raw stream, a
  * control event that arrived in a state that did not expect it, or a frame the
  * receiver had to reject (`NAK`) rather than accept. Every warning carries a
- * stable code plus, at most, a **frame number** — never the record bytes a frame
+ * stable code plus, at most, a **frame number**: never the record bytes a frame
  * carries (PHI discipline). Consumers compare `warning.code ===
  * LTP_WARNING_CODES.<CODE>`; renaming a code is a **breaking change**.
  */
@@ -754,21 +809,21 @@ declare function frameOversize(position: AstmFramePosition): AstmFrameWarning;
 declare const LTP_WARNING_CODES: {
     /**
      * The transport detector could not tell a framed stream from a raw (unframed) one from its leading
-     * byte — it was neither `STX`/`ENQ` nor a bare record letter. It **defaults to framed** and warns,
+     * byte: it was neither `STX`/`ENQ` nor a bare record letter. It **defaults to framed** and warns,
      * never guessing silently into data loss; a profile override forces the mode. (cobas b121 drops
-     * framing over TCP; cobas 4800 / Iguana retain it — both realities exist, so an unrecognizable lead
+     * framing over TCP; cobas 4800 / Iguana retain it, both realities exist, so an unrecognizable lead
      * is defaulted, not assumed.)
      */
     readonly ASTM_LTP_AMBIGUOUS_TRANSPORT: "ASTM_LTP_AMBIGUOUS_TRANSPORT";
     /**
-     * A control event arrived in a protocol state that did not expect it — e.g. an inbound `ACK`/`NAK`
+     * A control event arrived in a protocol state that did not expect it: e.g. an inbound `ACK`/`NAK`
      * at a receiver (which sends, never receives, those), or an `ENQ` mid-transfer. The event is
      * surfaced and handled defensively (an unexpected `ACK`/`NAK` is **never** read as acceptance of
      * data); it never advances the transfer as if valid.
      */
     readonly ASTM_LTP_UNEXPECTED_EVENT: "ASTM_LTP_UNEXPECTED_EVENT";
     /**
-     * The receiver rejected a received frame with a `NAK` instead of accepting it — because its
+     * The receiver rejected a received frame with a `NAK` instead of accepting it: because its
      * checksum failed, it was unterminated, or its frame number was out of sequence. The frame's text
      * is **never** appended to the record and the transfer does **not** advance; the receiver awaits the
      * sender's retransmit. This is the protocol-level face of the frame codec's fail-safe: a bad frame
@@ -783,7 +838,7 @@ declare const LTP_WARNING_CODES: {
 type LtpWarningCode = (typeof LTP_WARNING_CODES)[keyof typeof LTP_WARNING_CODES];
 /**
  * A single LTP protocol / transport warning: a stable code, a value-free
- * human-readable message, and — for a frame-scoped deviation — the frame number
+ * human-readable message, and, for a frame-scoped deviation, the frame number
  * only. Never carries a frame's record bytes.
  *
  * @example
@@ -791,7 +846,7 @@ type LtpWarningCode = (typeof LTP_WARNING_CODES)[keyof typeof LTP_WARNING_CODES]
  * import type { AstmLtpWarning } from "@cosyte/astm";
  * const w: AstmLtpWarning = {
  *   code: "ASTM_LTP_FRAME_REJECTED",
- *   message: "Frame rejected — NAK sent, retransmit expected.",
+ *   message: "Frame rejected, NAK sent, retransmit expected.",
  *   frameNumber: 2,
  * };
  * ```
@@ -846,22 +901,22 @@ declare function ltpFrameRejected(frameNumber?: number): AstmLtpWarning;
  * (RS-232) always uses full E1381 framing. Over **TCP it varies within a single
  * vendor**: the Roche cobas 4800 and iNTERFACEWARE Iguana retain the full
  * `ENQ`/`ACK` + `STX`/checksum framing over TCP (**framed-TCP**), while the cobas
- * b121 drops all low-level framing — "TCP itself ensures correctness" — and streams
+ * b121 drops all low-level framing, "TCP itself ensures correctness", and streams
  * de-framed record bytes directly (**raw-TCP**). A reader must handle both and must
  * not assume the handshake is present.
  *
  * {@link detectFraming} decides which it is from the stream's leading byte: `STX`
  * or `ENQ` ⇒ framed (feed it to the frame codec + {@link ltpReduce}); a bare record
  * letter ⇒ raw (feed it straight to `parseAstmRecords`). Anything else is
- * **ambiguous**, and the fail-safe is to **default to framed** and warn — never to
- * guess silently into data loss — with an explicit override for a profile that
+ * **ambiguous**, and the fail-safe is to **default to framed** and warn, never to
+ * guess silently into data loss, with an explicit override for a profile that
  * knows better.
  */
 
 /**
  * The transport framing of an ASTM byte stream: `"framed"` (E1381 `STX`/checksum
  * frames, the serial and framed-TCP realities) or `"raw"` (framing dropped,
- * de-framed record bytes streamed directly — the raw-TCP reality).
+ * de-framed record bytes streamed directly, the raw-TCP reality).
  */
 type AstmFraming = "framed" | "raw";
 /**
@@ -870,8 +925,8 @@ type AstmFraming = "framed" | "raw";
 interface DetectFramingOptions {
     /**
      * A profile-supplied override. When set, detection is bypassed entirely and this
-     * value is returned with no warning — the way a Phase-8 vendor profile forces
-     * raw for a cobas b121 or framed for a cobas 4800 regardless of the leading byte.
+     * value is returned with no warning: the way a vendor profile forces raw for
+     * a cobas b121 or framed for a cobas 4800 regardless of the leading byte.
      */
     readonly override?: AstmFraming;
 }
@@ -920,7 +975,7 @@ declare function detectFraming(bytes: Uint8Array, options?: DetectFramingOptions
  * plus an optional **transport override** (the raw-vs-framed-TCP knob). It mirrors
  * the sibling `@cosyte/hl7` `defineProfile` and `@cosyte/ccda` `defineCcdaProfile`
  * shape (`name` / `lineage` / `describe()` / `extends`-merge) but models ASTM's
- * quirks — a warning code the stream is expected to trip, and its framing reality —
+ * quirks (a warning code the stream is expected to trip, and its framing reality)
  * rather than HL7 v2 Z-segments or C-CDA template deviations.
  *
  * A profile **never changes an extracted value**. It operates purely at the
@@ -929,29 +984,29 @@ declare function detectFraming(bytes: Uint8Array, options?: DetectFramingOptions
  * layer (forcing framed/raw before a single byte is parsed). The two load-bearing
  * safety rules, enforced by `defineAstmProfile`:
  *
- * 1. **A profile can never tolerate a safety-critical warning code** — a result
+ * 1. **A profile can never tolerate a safety-critical warning code**: a result
  *    value, abnormal flag, result status, reference range, units, patient/comment
  *    context, message-kind ambiguity, code system, or any frame/LTP integrity
  *    warning (see `src/profiles/safety.ts`). Naming one is a *definition-time
- *    throw*, not a silent relaxation — so a profile can never make a bad checksum
+ *    throw*, not a silent relaxation, so a profile can never make a bad checksum
  *    "ok" or a cancelled result read "final."
  * 2. **A tolerated deviation is downgraded, never dropped.** The parser still
  *    records it (re-coded {@link WARNING_CODES.PROFILE_QUIRK_APPLIED}, flagged
  *    `expected: true`, carrying the original `toleratedCode`) so nothing is
- *    silently hidden — Postel's Law with a receipt.
+ *    silently hidden, Postel's Law with a receipt.
  */
 
 /**
- * Any warning code from any of the three registries — the record layer
+ * Any warning code from any of the three registries: the record layer
  * (`ASTM_RECORD_*` / `ASTM_NONSTANDARD_DELIMITERS` / `ASTM_UNKNOWN_ESCAPE_SEQUENCE`),
  * the frame codec (`ASTM_FRAME_*`), or the LTP protocol layer (`ASTM_LTP_*`). A
  * {@link QuirkTolerance} may *name* any of them, but the safety gate refuses all
- * but the small, benign, record-layer subset — so the union exists mainly to let
+ * but the small, benign, record-layer subset, so the union exists mainly to let
  * the gate reject a frame/LTP code with a precise, typed message.
  */
 type AnyAstmWarningCode = WarningCode | FrameWarningCode | LtpWarningCode;
 /**
- * Provenance for an {@link AstmProfile} — the **real, cited public artifact** a
+ * Provenance for an {@link AstmProfile}: the **real, cited public artifact** a
  * profile's quirks are grounded in. A quirk is encoded only when a real
  * (de-identified) document or a redistributable reference corpus grounds it; this
  * record is where that grounding is stated, so a reviewer can trace every
@@ -970,7 +1025,7 @@ type AnyAstmWarningCode = WarningCode | FrameWarningCode | LtpWarningCode;
 interface AstmProfileProvenance {
     /** Short human-readable name of the grounding source (corpus, transcript, or spec). */
     readonly source: string;
-    /** A citation the grounding can be traced to — a URL, DOI, or repo+path. */
+    /** A citation the grounding can be traced to: a URL, DOI, or repo+path. */
     readonly reference: string;
     /** When the grounding was last verified (ISO date) or the pinned commit SHA. */
     readonly retrieved?: string;
@@ -980,7 +1035,7 @@ interface AstmProfileProvenance {
 /**
  * Optional structural narrowing for a {@link QuirkTolerance}. When present, the
  * tolerance applies only to warnings whose PHI-free {@link AstmPosition} matches
- * every provided field — so a profile can expect a deviation on one record type
+ * every provided field, so a profile can expect a deviation on one record type
  * (e.g. an unknown escape only inside `R` result values) without blanket-tolerating
  * it everywhere. Matching is on **structural identifiers only** (record-type
  * letter, 1-based field index); there is no matching on any field *value*, by
@@ -1017,7 +1072,7 @@ interface AstmQuirkMatch {
 interface AstmQuirkTolerance {
     /** The existing, non-safety-critical warning code this profile expects. */
     readonly code: AnyAstmWarningCode;
-    /** Why the profile expects this deviation — grounded in its provenance. */
+    /** Why the profile expects this deviation: grounded in its provenance. */
     readonly rationale: string;
     /** Optional structural narrowing (record type / field index). */
     readonly match?: AstmQuirkMatch;
@@ -1027,7 +1082,7 @@ interface AstmQuirkTolerance {
  * {@link defineAstmProfile}; consumers pass it to `parseAstmRecords(raw, { profile })`
  * (or register it as the process default), and feed its {@link AstmProfile.transport}
  * to `detectFraming(bytes, { override })`. Hand-authoring the object literal is
- * supported but discouraged — the factory validates the safety rules and attaches
+ * supported but discouraged: the factory validates the safety rules and attaches
  * `describe()`.
  *
  * @example
@@ -1042,13 +1097,13 @@ interface AstmProfile {
     readonly name: string;
     /** Optional human-readable description. */
     readonly description?: string;
-    /** Resolved lineage — `[...parents, name]`, first-occurrence deduped. */
+    /** Resolved lineage: `[...parents, name]`, first-occurrence deduped. */
     readonly lineage: readonly string[];
     /** The expected, non-safety-critical deviations this profile tolerates. */
     readonly tolerate: readonly AstmQuirkTolerance[];
     /**
      * The raw-vs-framed-TCP override. When set, a consumer forces this framing via
-     * `detectFraming(bytes, { override: profile.transport })` — the way a profile
+     * `detectFraming(bytes, { override: profile.transport })`, the way a profile
      * that knows a vendor's transport reality (e.g. framing dropped over raw TCP)
      * bypasses leading-byte auto-detection. Absent means "let detection decide."
      */
@@ -1084,9 +1139,9 @@ interface DefineAstmProfileOptions {
 }
 
 /**
- * Safety-critical result semantics for the ASTM `R` (result) record — Phase 2.
+ * Safety-critical result semantics for the ASTM `R` (result) record.
  *
- * Phase 1 surfaced the `R` record's flag, status, units, and reference-range
+ * The parser surfaces the `R` record's flag, status, units, and reference-range
  * fields **raw**. This module turns those raw letters into modeled, **fail-safe**
  * semantics, under one rule: **never a confident wrong value.**
  *
@@ -1095,33 +1150,33 @@ interface DefineAstmProfileOptions {
  *   coerced to `normal`**.
  * - A **result status** (field 9) is modeled so a **correction (`C`)** or a
  *   **cancellation (`X`)** can never read as an active-final result, and an
- *   **absent** status is a typed `unspecified` — **never assumed `F` (final)**.
+ *   **absent** status is a typed `unspecified`: **never assumed `F` (final)**.
  * - A **reference range** (field 6) is parsed into a low/high (or open-ended)
- *   pair; an unparseable range is surfaced **verbatim** — a bound is **never
+ *   pair; an unparseable range is surfaced **verbatim**, a bound is **never
  *   fabricated**.
  *
  * Every bound and code is surfaced verbatim; nothing is collapsed, reconciled,
  * or converted. Units are handled at the record layer (a numeric value without
- * units warns; units are never defaulted, guessed, or converted — see
+ * units warns; units are never defaulted, guessed, or converted, see
  * `./parse.ts`).
  */
 /**
  * The recognized abnormal-flag letters, from **HL7 v2.2 Table 0078** (the flag
- * *value* set — a published fact set, not CLSI prose). Read in the context of an
+ * *value* set, a published fact set, not CLSI prose). Read in the context of an
  * `R` record's field 7: here `S`/`R`/`I` are the microbiology susceptibility
  * codes and `R` is **not** the repeat delimiter.
  */
 type AbnormalFlagCode = "L" | "H" | "LL" | "HH" | "<" | ">" | "N" | "A" | "AA" | "U" | "D" | "B" | "W" | "S" | "R" | "I";
 /**
  * The modeled meaning of a recognized {@link AbnormalFlagCode}, plus the two
- * fail-safe sentinels: `undefined` (a flag was present but is not in Table 0078)
- * — which is **never** collapsed to `normal`.
+ * fail-safe sentinels: `undefined` (a flag was present but is not in Table 0078),
+ * which is **never** collapsed to `normal`.
  */
 type AbnormalFlagMeaning = "below-normal" | "above-normal" | "critically-below-normal" | "critically-above-normal" | "below-scale" | "above-scale" | "normal" | "abnormal" | "very-abnormal" | "significant-change-up" | "significant-change-down" | "better" | "worse" | "susceptible" | "resistant" | "intermediate" | "undefined";
 /**
  * A recognized (or explicitly *un*recognized) abnormal flag. The raw field text
  * is always preserved; `recognized` is `false` and `meaning` is `"undefined"`
- * for any letter outside Table 0078 — the flag is surfaced, never dropped, and
+ * for any letter outside Table 0078, the flag is surfaced, never dropped, and
  * **never coerced to `normal`**.
  *
  * @example
@@ -1147,7 +1202,7 @@ interface AbnormalFlag {
  *
  * Leading/trailing whitespace is ignored for the lookup but the `raw` text is
  * preserved verbatim. An unrecognized flag yields `{ recognized: false, meaning:
- * "undefined" }` — surfaced, never dropped, and **never `"normal"`**.
+ * "undefined" }`, surfaced, never dropped, and **never `"normal"`**.
  *
  * @param raw - The verbatim field-7 text.
  * @returns The interpreted flag.
@@ -1161,13 +1216,13 @@ interface AbnormalFlag {
 declare function interpretAbnormalFlag(raw: string): AbnormalFlag;
 /**
  * The recognized result-status letters (`R`-record field 9). The clinically
- * load-bearing members are **`C` (correction — supersedes a previously
+ * load-bearing members are **`C` (correction, supersedes a previously
  * transmitted value)** and **`X` (cannot be done / cancelled)**.
  */
 type ResultStatusCode = "F" | "C" | "P" | "R" | "S" | "I" | "X";
 /**
  * The modeled meaning of a result status, plus two fail-safe sentinels:
- * `unspecified` (the field was absent — **never assumed `final`**) and
+ * `unspecified` (the field was absent, **never assumed `final`**) and
  * `undefined` (a letter was present but is not a recognized status).
  */
 type ResultStatusMeaning = "final" | "correction" | "preliminary" | "previously-transmitted" | "partial" | "pending" | "cancelled" | "unspecified" | "undefined";
@@ -1177,11 +1232,11 @@ type ResultStatusMeaning = "final" | "correction" | "preliminary" | "previously-
  *
  * - **`isActiveFinal`** is `true` **only** for a plain `F` (final). It is `false`
  *   for a correction (`C`), a cancellation (`X`), a preliminary/partial/pending
- *   result, an absent status, and an unrecognized one — so a superseded or
+ *   result, an absent status, and an unrecognized one, so a superseded or
  *   cancelled result can **never** read as current/final.
- * - **`supersedes`** is `true` for `C` — this value replaces a previously
+ * - **`supersedes`** is `true` for `C`: this value replaces a previously
  *   transmitted one.
- * - **`cancelled`** is `true` for `X` — the result cannot be done / was cancelled.
+ * - **`cancelled`** is `true` for `X`: the result cannot be done / was cancelled.
  *
  * @example
  * ```ts
@@ -1200,17 +1255,17 @@ interface ResultStatus {
     readonly meaning: ResultStatusMeaning;
     /** Whether the raw text matched a recognized status letter. */
     readonly recognized: boolean;
-    /** `true` **only** for a plain `F` (final) — never for `C`, `X`, absent, or unrecognized. */
+    /** `true` **only** for a plain `F` (final): never for `C`, `X`, absent, or unrecognized. */
     readonly isActiveFinal: boolean;
-    /** `true` for `C` — this value supersedes a previously transmitted result. */
+    /** `true` for `C`: this value supersedes a previously transmitted result. */
     readonly supersedes: boolean;
-    /** `true` for `X` — the result cannot be done / was cancelled. */
+    /** `true` for `X`: the result cannot be done / was cancelled. */
     readonly cancelled: boolean;
 }
 /**
  * Interpret an `R`-record result-status field (field 9).
  *
- * An **absent** status (`undefined` or empty) is typed `unspecified` — **never
+ * An **absent** status (`undefined` or empty) is typed `unspecified`: **never
  * assumed `final`**. A **present but unrecognized** letter is `undefined`
  * (recognized `false`). In every non-`F` case `isActiveFinal` is `false`, so a
  * correction, a cancellation, or an unknown status can never read as current.
@@ -1229,10 +1284,10 @@ declare function interpretResultStatus(raw: string | undefined): ResultStatus;
 /**
  * The shape of a parsed reference range.
  *
- * - `closed` — both a low and a high bound (`3.5-5.0`).
- * - `open-low` — an upper bound only (`<5`): everything at or below `high`.
- * - `open-high` — a lower bound only (`>10`): everything at or above `low`.
- * - `unparsed` — the text did not match a recognized form; both bounds are
+ * - `closed`: both a low and a high bound (`3.5-5.0`).
+ * - `open-low`: an upper bound only (`<5`), so everything at or below `high`.
+ * - `open-high`: a lower bound only (`>10`), so everything at or above `low`.
+ * - `unparsed`: the text did not match a recognized form; both bounds are
  *   absent and the raw text is surfaced. **A bound is never fabricated.**
  */
 type ReferenceRangeKind = "closed" | "open-low" | "open-high" | "unparsed";
@@ -1241,10 +1296,10 @@ type ReferenceRangeKind = "closed" | "open-low" | "open-high" | "unparsed";
  * (never coerced to a float, never rounded, never converted) so nothing is lost
  * or fabricated.
  *
- * **`[OSS-derived]` — the exact lower/upper delimiter (`-`) and the open-ended
+ * **`[OSS-derived]`: the exact lower/upper delimiter (`-`) and the open-ended
  * `<x`/`>x` forms are taken from the permissively-licensed OSS reference parsers
  * and cross-verified vendor transcripts; they are not confirmed against the
- * purchased CLSI LIS02-A2 (roadmap §10 Q1). Anything that does not match these
+ * purchased CLSI LIS02-A2. Anything that does not match these
  * forms is surfaced verbatim as `unparsed`, never guessed into a bound.**
  *
  * @example
@@ -1271,8 +1326,8 @@ interface ReferenceRange {
  * open-ended) pair.
  *
  * Recognized forms are `low-high` (closed), `<high` (open-low), and `>low`
- * (open-high). Anything else — including an ambiguous multi-dash string or a
- * bare non-numeric token — is returned as `kind: "unparsed"` with the raw text
+ * (open-high). Anything else, including an ambiguous multi-dash string or a
+ * bare non-numeric token, is returned as `kind: "unparsed"` with the raw text
  * preserved and **no bound invented**. Bounds are surfaced as verbatim text, not
  * coerced to numbers.
  *
@@ -1294,13 +1349,12 @@ declare function parseReferenceRange(raw: string): ReferenceRange;
  * A message is a header (which carries the resolved delimiters as provenance), an
  * ordered list of typed records, and the Tier-2 warnings the lenient parser
  * accumulated. Every record keeps its raw {@link AstmField}s **and** the typed
- * accessors relevant to its type — the raw tree is always present so nothing the
+ * accessors relevant to its type: the raw tree is always present so nothing the
  * parser did not model is lost.
  *
- * Phase-1 scope: `H`/`P`/`O`/`R`/`L` are modeled; every other type letter is an
- * {@link UnsupportedRecord} (surfaced, never dropped). Result-flag/status
- * *semantics*, comments/query/`M`/`S`, framing, and serialization are later
- * phases — this layer surfaces the safety-critical values **raw**.
+ * `H`/`P`/`O`/`R`/`C`/`Q`/`M`/`S`/`L` are modeled; every other type letter is an
+ * {@link UnsupportedRecord} (surfaced, never dropped). Alongside the modeled
+ * views, this layer always surfaces the safety-critical values **raw**.
  */
 
 /**
@@ -1333,14 +1387,25 @@ interface RecordBase {
  */
 interface HeaderRecord extends RecordBase {
     readonly type: "H";
-    /** The four delimiters resolved from this header. */
+    /**
+     * The four delimiters **this** header put into force: the set its own fields, and every record
+     * after it, were read with.
+     *
+     * A stream may carry several messages (`H` … `L`) and each header declares its own set, so on a
+     * multi-header stream these can differ between headers; {@link AstmMessage.delimiters} is the
+     * first header's. When a later header cannot declare a usable set, the set already in force is
+     * kept and reported here (with an `ASTM_RECORD_UNREADABLE_REDECLARATION` warning) rather than a
+     * guessed one.
+     */
     readonly delimiters: Delimiters;
     /**
-     * The header's exact wire text (terminator excluded), preserved because the
-     * escape character appears **literally** inside the delimiter-definition field
-     * (`\^&`), which the generic escape-aware tokenizer cannot split cleanly. The
-     * delimiters are read from this raw text (never from {@link RecordBase.fields}),
-     * and the serializer reconstructs the header's data fields from it.
+     * The header's exact wire text (terminator excluded), kept as **provenance**: the
+     * delimiters are read from this raw text, never from {@link RecordBase.fields}.
+     *
+     * It is **not** what the serializer emits from. To change a header field, edit
+     * {@link RecordBase.fields}: `fields[0]` is the type letter, `fields[1]` is the
+     * delimiter declaration, and the header's ASTM data fields follow from `fields[2]`.
+     * Editing this string instead has no effect on emit.
      */
     readonly rawLine: string;
 }
@@ -1357,158 +1422,158 @@ interface PatientName {
  * The `P` (patient) record.
  *
  * **Safety:** the practice-assigned ID (field 3) and the laboratory-assigned ID
- * (field 4) are modeled as **distinct** fields and never collapsed — conflating
+ * (field 4) are modeled as **distinct** fields and never collapsed, conflating
  * them is the primary result-misfiling path.
  */
 interface PatientRecord extends RecordBase {
     readonly type: "P";
-    /** Field 2 — sequence number. */
+    /** Field 2: sequence number. */
     readonly seq?: string;
-    /** Field 3 — practice-assigned patient ID. Distinct from {@link PatientRecord.laboratoryAssignedId}. */
+    /** Field 3: practice-assigned patient ID. Distinct from {@link PatientRecord.laboratoryAssignedId}. */
     readonly practiceAssignedId?: string;
-    /** Field 4 — laboratory-assigned patient ID. Distinct from {@link PatientRecord.practiceAssignedId}. */
+    /** Field 4: laboratory-assigned patient ID. Distinct from {@link PatientRecord.practiceAssignedId}. */
     readonly laboratoryAssignedId?: string;
     /**
-     * Field 5 — a third patient identifier (e.g. a national/alternate ID), surfaced verbatim. Kept
-     * separate from the practice- and laboratory-assigned IDs — the three never collapse into one.
+     * Field 5: a third patient identifier (e.g. a national/alternate ID), surfaced verbatim. Kept
+     * separate from the practice- and laboratory-assigned IDs: the three never collapse into one.
      */
     readonly patientIdThree?: string;
-    /** Field 6 — patient name (`Last^First^Middle`). */
+    /** Field 6: patient name (`Last^First^Middle`). */
     readonly name?: PatientName;
-    /** Field 7 — mother's maiden name, surfaced verbatim (a surname component; PHI). */
+    /** Field 7: mother's maiden name, surfaced verbatim (a surname component; PHI). */
     readonly mothersMaidenName?: string;
-    /** Field 8 — birthdate (`YYYYMMDDHHMMSS`, precision-preserving; a truncated run sets `truncated`). */
+    /** Field 8: birthdate (`YYYYMMDDHHMMSS`, precision-preserving; a truncated run sets `truncated`). */
     readonly birthDate?: AstmDate;
-    /** Field 9 — sex, surfaced raw (`M`/`F`/`U`/vendor value). */
+    /** Field 9: sex, surfaced raw (`M`/`F`/`U`/vendor value). */
     readonly sex?: string;
 }
 /**
- * The `O` (order) record — binds a result to a specimen.
+ * The `O` (order) record: binds a result to a specimen.
  */
 interface OrderRecord extends RecordBase {
     readonly type: "O";
-    /** Field 2 — sequence number. */
+    /** Field 2: sequence number. */
     readonly seq?: string;
-    /** Field 3 — specimen / accession ID. */
+    /** Field 3: specimen / accession ID. */
     readonly specimenId?: string;
-    /** Field 4 — instrument specimen ID. */
+    /** Field 4: instrument specimen ID. */
     readonly instrumentSpecimenId?: string;
-    /** Field 5 — Universal Test ID (same caret structure as a result's). */
+    /** Field 5: Universal Test ID (same caret structure as a result's). */
     readonly universalTestId?: UniversalTestId;
     /**
-     * Field 6 — priority, surfaced raw (e.g. `S` STAT, `R` routine, `A` ASAP). Vendor letters vary;
+     * Field 6: priority, surfaced raw (e.g. `S` STAT, `R` routine, `A` ASAP). Vendor letters vary;
      * the code set is `[OSS-derived]` (the exact enumeration is in the paywalled CLSI LIS02-A2), so the
      * value is surfaced verbatim and **never mapped to a guessed meaning**.
      */
     readonly priority?: string;
     /**
-     * Field 12 — action code, surfaced raw (e.g. `C` cancel, `A` add, `N` new). The exact field index
-     * (`~12`) and the code set are `[OSS-derived]` (paywalled) — surfaced verbatim, never interpreted.
+     * Field 12: action code, surfaced raw (e.g. `C` cancel, `A` add, `N` new). The exact field index
+     * (`~12`) and the code set are `[OSS-derived]` (paywalled): surfaced verbatim, never interpreted.
      */
     readonly actionCode?: string;
     /**
-     * Field 26 — report type, surfaced raw (e.g. `F` final, `P` preliminary, `X` cancel). The exact
-     * field index (`~26`) and the code set are `[OSS-derived]` (paywalled) — surfaced verbatim.
+     * Field 26: report type, surfaced raw (e.g. `F` final, `P` preliminary, `X` cancel). The exact
+     * field index (`~26`) and the code set are `[OSS-derived]` (paywalled): surfaced verbatim.
      */
     readonly reportType?: string;
 }
 /**
- * The `R` (result) record — the value itself.
+ * The `R` (result) record: the value itself.
  *
  * The raw safety-critical fields (value, `units`, `referenceRange`,
  * `abnormalFlags`, `resultStatus`) are always surfaced exactly as received.
- * Phase 2 adds the **modeled, fail-safe** semantics alongside them: `flag`
+ * The **modeled, fail-safe** semantics sit alongside them: `flag`
  * (Table 0078, `undefined` never coerced to normal), `status` (a `C`/`X` never
  * reads as active-final; an absent status is `unspecified`, never `final`), and
  * `range` (open/closed bounds surfaced verbatim, never fabricated). The raw
- * strings and the modeled views coexist — nothing is collapsed or reconciled.
+ * strings and the modeled views coexist: nothing is collapsed or reconciled.
  */
 interface ResultRecord extends RecordBase {
     readonly type: "R";
-    /** Field 2 — sequence number. */
+    /** Field 2: sequence number. */
     readonly seq?: string;
-    /** Field 3 — Universal Test ID (local code in component 4 is the primary identifier). */
+    /** Field 3: Universal Test ID (local code in component 4 is the primary identifier). */
     readonly universalTestId?: UniversalTestId;
     /**
-     * Field 4 — the measured value. In the ordinary single-component case this is the decoded scalar.
+     * Field 4: the measured value. In the ordinary single-component case this is the decoded scalar.
      * When the value field carried an *unescaped* component delimiter (an ambiguity), this is the
-     * **full raw field text** — never a truncated component — and {@link ResultRecord.valueComponents}
+     * **full raw field text**, never a truncated component, and {@link ResultRecord.valueComponents}
      * plus an `ASTM_RECORD_AMBIGUOUS_VALUE_SPLIT` warning are also present.
      */
     readonly value?: string;
     /**
      * Field 4 split into components, present only when the value field carried an *unescaped* component
-     * delimiter — i.e. it read as more than one component. Surfaced alongside the full raw value (and a
+     * delimiter: i.e. it read as more than one component. Surfaced alongside the full raw value (and a
      * warning) so an ambiguous split is visible, never resolved silently.
      */
     readonly valueComponents?: readonly string[];
-    /** Field 5 — units (vendor free text; a missing unit is not defaulted). */
+    /** Field 5: units (vendor free text; a missing unit is not defaulted). */
     readonly units?: string;
-    /** Field 6 — reference range, surfaced raw. */
+    /** Field 6: reference range, surfaced raw. */
     readonly referenceRange?: string;
     /**
-     * Field 6 — the reference range parsed into low/high (or open-ended) bounds, present only when the
+     * Field 6: the reference range parsed into low/high (or open-ended) bounds, present only when the
      * field carried a value. An unparseable range is `kind: "unparsed"` with the raw text preserved and
      * **no bound fabricated**. Bounds are verbatim numeric text, never coerced to floats.
      */
     readonly range?: ReferenceRange;
-    /** Field 7 — abnormal flags, surfaced raw (HL7 Table 0078 values). */
+    /** Field 7: abnormal flags, surfaced raw (HL7 Table 0078 values). */
     readonly abnormalFlags?: string;
     /**
-     * Field 7 — the abnormal flag interpreted against HL7 Table 0078, present only when the field
-     * carried a value. An unrecognized flag is `{ recognized: false, meaning: "undefined" }` — surfaced,
+     * Field 7: the abnormal flag interpreted against HL7 Table 0078, present only when the field
+     * carried a value. An unrecognized flag is `{ recognized: false, meaning: "undefined" }`, surfaced,
      * never dropped, and **never coerced to `normal`**.
      */
     readonly flag?: AbnormalFlag;
-    /** Field 9 — result status, surfaced raw (`F`/`C`/`X`/…). */
+    /** Field 9: result status, surfaced raw (`F`/`C`/`X`/…). */
     readonly resultStatus?: string;
     /**
-     * Field 9 — the modeled result status. **Always present** (an absent field yields a typed
+     * Field 9: the modeled result status. **Always present** (an absent field yields a typed
      * `unspecified`, never assumed `final`), so `status.isActiveFinal` is always a reliable boolean: it
      * is `true` only for a plain `F`, and `false` for a correction (`C`), a cancellation (`X`), a
      * partial/preliminary/pending, an absent, or an unrecognized status.
      */
     readonly status: ResultStatus;
-    /** Field 11 — operator. */
+    /** Field 11: operator. */
     readonly operator?: string;
-    /** Field 12 — test started timestamp. */
+    /** Field 12: test started timestamp. */
     readonly startedAt?: AstmDate;
-    /** Field 13 — test completed timestamp. */
+    /** Field 13: test completed timestamp. */
     readonly completedAt?: AstmDate;
-    /** Field 14 — instrument identifier. */
+    /** Field 14: instrument identifier. */
     readonly instrument?: string;
 }
 /**
- * The `C` (comment) record — free-text context attached to a parent record.
+ * The `C` (comment) record: free-text context attached to a parent record.
  *
  * A comment is **attached by position** to the immediately-preceding `H`/`P`/`O`/`R` record
  * ({@link CommentRecord.parentIndex}); consecutive comments share that parent. **Fail-safe:** a
- * comment with no valid preceding parent is an **orphan** — it is attached to the message root
+ * comment with no valid preceding parent is an **orphan**: it is attached to the message root
  * ({@link CommentRecord.attachedToRoot} `true`) and a value-free `ASTM_RECORD_ORPHAN_COMMENT` warning
- * fires — **never silently dropped**, so a comment carrying (e.g.) "QC / non-compliant" context can
+ * fires, **never silently dropped**, so a comment carrying (e.g.) "QC / non-compliant" context can
  * never float away unnoticed.
  */
 interface CommentRecord extends RecordBase {
     readonly type: "C";
-    /** Field 2 — sequence number. */
+    /** Field 2: sequence number. */
     readonly seq?: string;
-    /** Field 3 — comment source (who/what produced it), surfaced verbatim. */
+    /** Field 3: comment source (who/what produced it), surfaced verbatim. */
     readonly source?: string;
     /**
-     * Field 4 — the comment text, surfaced as the **full** field text (all components), never
+     * Field 4: the comment text, surfaced as the **full** field text (all components), never
      * truncated to the first component. The component structure is in {@link CommentRecord.textComponents}.
      */
     readonly text?: string;
     /**
-     * Field 4 — the comment text split into its decoded components (comment text is component-capable;
+     * Field 4: the comment text split into its decoded components (comment text is component-capable;
      * multiple components are a normal structured comment, **not** an ambiguity). Present only when the
      * field carried more than one component.
      */
     readonly textComponents?: readonly string[];
     /**
-     * Field 5 — comment type code, surfaced verbatim. **`[OSS-derived]`:** `I` (instrument) is the only
+     * Field 5: comment type code, surfaced verbatim. **`[OSS-derived]`:** `I` (instrument) is the only
      * value seen in the permissively-licensed real transcripts; other values (e.g. `G`/`T`/`P`) are
-     * defined only in the paywalled CLSI LIS02-A2 and are **not** interpreted here — the raw code is
+     * defined only in the paywalled CLSI LIS02-A2 and are **not** interpreted here: the raw code is
      * surfaced, never mapped to a guessed meaning.
      */
     readonly commentType?: string;
@@ -1517,57 +1582,57 @@ interface CommentRecord extends RecordBase {
      * the comment is an orphan attached to the message root (see {@link CommentRecord.attachedToRoot}).
      */
     readonly parentIndex?: number;
-    /** `true` when no valid parent preceded — the comment is attached to the message root (and warned). */
+    /** `true` when no valid parent preceded: the comment is attached to the message root (and warned). */
     readonly attachedToRoot: boolean;
 }
 /**
- * The `Q` (Request Information) record — the host-query request.
+ * The `Q` (Request Information) record: the host-query request.
  *
  * A `Q` record asks the LIS for information (e.g. outstanding orders for a
  * specimen); its **presence classifies the whole message as a request, never a
  * result set** (see {@link AstmMessage.classification}). Its safety-relevant
- * fields — the starting/ending range ID and the request-information status — are
+ * fields, the starting/ending range ID and the request-information status, are
  * surfaced **verbatim**; the field *positions* are the public ASTM E1394 layout,
  * but their internal structure and code meanings are **`[OSS-derived / paywalled]`**
- * (roadmap §10 Q3) and are therefore **never interpreted or guessed**.
+ * and are therefore **never interpreted or guessed**.
  */
 interface QueryRecord extends RecordBase {
-    /** Field 2 — sequence number. */
+    /** Field 2: sequence number. */
     readonly seq?: string;
     readonly type: "Q";
     /**
-     * Field 3 — starting range ID number, surfaced as the **full** verbatim field text (never truncated
+     * Field 3: starting range ID number, surfaced as the **full** verbatim field text (never truncated
      * to a component). Its caret component structure (e.g. patient ID ^ specimen ID) is
-     * **`[OSS-derived / paywalled]`** — the raw split is available via {@link RecordBase.fields}, but the
+     * **`[OSS-derived / paywalled]`**: the raw split is available via {@link RecordBase.fields}, but the
      * *meaning* of each component is **never** assigned here.
      */
     readonly startingRangeId?: string;
-    /** Field 4 — ending range ID number, surfaced verbatim (same `[OSS-derived]` caveat as field 3). */
+    /** Field 4: ending range ID number, surfaced verbatim (same `[OSS-derived]` caveat as field 3). */
     readonly endingRangeId?: string;
     /**
-     * Field 5 — Universal Test ID (the same caret structure as an `O`/`R` record's), recognized by
+     * Field 5: Universal Test ID (the same caret structure as an `O`/`R` record's), recognized by
      * provenance only. When the field is the literal universal-query keyword, {@link QueryRecord.queriesAllTests}
-     * is set instead — see its caveat.
+     * is set instead: see its caveat.
      */
     readonly universalTestId?: UniversalTestId;
     /**
      * `true` when field 5 is the literal `ALL` universal-query keyword (case-insensitive). **`[OSS-derived
      * / paywalled]`:** the token is surfaced because it appears in the OSS references, but its exact
      * host-query *behavior* (which tests a bare `ALL` selects, and whether the vendor answers with a full
-     * `H/P/O/L` or a `P/O`-only response) is paywalled and vendor-specific — **not decided here**.
+     * `H/P/O/L` or a `P/O`-only response) is paywalled and vendor-specific, **not decided here**.
      */
     readonly queriesAllTests: boolean;
     /**
-     * Field 13 — request-information status code(s), surfaced **verbatim**. The status code *set* is
-     * **`[OSS-derived / paywalled]`** (roadmap §10 Q3): with no publicly-groundable enumeration, this
-     * parser recognizes **none** of them and interprets nothing — every present status is surfaced raw
+     * Field 13: request-information status code(s), surfaced **verbatim**. The status code *set* is
+     * **`[OSS-derived / paywalled]`**: with no publicly-groundable enumeration, this
+     * parser recognizes **none** of them and interprets nothing, every present status is surfaced raw
      * and flagged with a value-free `ASTM_RECORD_UNINTERPRETED_QUERY_STATUS` warning. Never mapped to a
      * guessed meaning.
      */
     readonly requestInformationStatus?: string;
 }
 /**
- * The `M` (manufacturer) record — vendor-defined free-form data
+ * The `M` (manufacturer) record: vendor-defined free-form data
  * (QC / calibration / maintenance), surfaced **VERBATIM** and **never interpreted
  * into typed clinical fields**.
  *
@@ -1578,30 +1643,48 @@ interface QueryRecord extends RecordBase {
  */
 interface ManufacturerRecord extends RecordBase {
     readonly type: "M";
-    /** The record's exact wire text (terminator excluded), preserved byte-for-byte for round-trip. */
+    /**
+     * The record's exact wire text (terminator excluded), preserved byte-for-byte.
+     *
+     * Emit reproduces these bytes exactly whenever a reader using the delimiters being
+     * emitted against would recover the fields this record models: always the case when
+     * the record is already in those delimiters, and also when it carries no delimiter
+     * either set would split on. Otherwise the record is re-encoded from
+     * {@link RecordBase.fields}, so the row can never go out in delimiters the header does
+     * not declare. To change a value, edit `fields`; editing this string has no effect on emit.
+     */
     readonly rawLine: string;
 }
 /**
- * The `S` (scientific) record — vendor-defined free-form data, surfaced
+ * The `S` (scientific) record: vendor-defined free-form data, surfaced
  * **VERBATIM** and **never interpreted into typed clinical fields** (same posture
  * as {@link ManufacturerRecord}).
  */
 interface ScientificRecord extends RecordBase {
     readonly type: "S";
-    /** The record's exact wire text (terminator excluded), preserved byte-for-byte for round-trip. */
+    /**
+     * The record's exact wire text (terminator excluded), preserved byte-for-byte.
+     *
+     * Emit reproduces these bytes exactly whenever a reader using the delimiters being
+     * emitted against would recover the fields this record models: always the case when
+     * the record is already in those delimiters, and also when it carries no delimiter
+     * either set would split on. Otherwise the record is re-encoded from
+     * {@link RecordBase.fields}, so the row can never go out in delimiters the header does
+     * not declare. To change a value, edit `fields`; editing this string has no effect on emit.
+     */
     readonly rawLine: string;
 }
 /**
- * The `L` (terminator) record — closes a message.
+ * The `L` (terminator) record: closes a message.
  */
 interface TerminatorRecord extends RecordBase {
     readonly type: "L";
 }
 /**
  * Any record whose type letter is not modeled (a genuinely unknown letter).
- * `H`/`P`/`O`/`R`/`C`/`L` (Phases 1–3) and `Q`/`M`/`S` (Phase 4) are all modeled;
- * anything else is surfaced with its raw fields intact and flagged with an
- * `ASTM_RECORD_UNKNOWN_TYPE` warning — never dropped.
+ * `H`/`P`/`O`/`R`/`C`/`Q`/`M`/`S`/`L` are all modeled; anything else is surfaced
+ * with its raw fields intact and flagged with an
+ * `ASTM_RECORD_UNKNOWN_TYPE` warning, never dropped.
  */
 interface UnsupportedRecord extends RecordBase {
     readonly type: "unsupported";
@@ -1613,30 +1696,30 @@ type AstmRecord = HeaderRecord | PatientRecord | OrderRecord | ResultRecord | Co
 /**
  * How a message is classified by the host-query flow.
  *
- * - `host-query` — the message carries at least one `Q` record: it is a **request
+ * - `host-query` (the message carries at least one `Q` record): it is a **request
  *   for information**, and **must never be read as a result set** (the load-bearing
  *   safety distinction of this layer). `Q` **dominates**: a `Q` present classifies
  *   the message as a request even if a result record is also present (an anomaly,
- *   separately warned) — so a `Q`-bearing message is never silently treated as a
+ *   separately warned), so a `Q`-bearing message is never silently treated as a
  *   result upload.
- * - `results` — no `Q`, at least one `R` (result) record: a result upload / response.
- * - `orders` — no `Q`, no `R`, at least one `O` (order) record: an order download,
+ * - `results` (no `Q`, at least one `R` result record): a result upload / response.
+ * - `orders` (no `Q`, no `R`, at least one `O` order record): an order download,
  *   or a query response before results are attached.
- * - `indeterminate` — none of the above (e.g. header + terminator only). Not
+ * - `indeterminate`: none of the above (e.g. header + terminator only). Not
  *   guessed into one of the other kinds.
  */
 type AstmMessageKind = "host-query" | "results" | "orders" | "indeterminate";
 /**
  * The message-level classification from the host-query flow. `isHostQueryRequest`
  * is the single boolean a consumer should gate on before treating records as
- * results — it is `true` **iff** a `Q` record is present.
+ * results: it is `true` **iff** a `Q` record is present.
  *
  * @example
  * ```ts
  * import { parseAstmRecords } from "@cosyte/astm";
  * const req = parseAstmRecords("H|\\^&\rP|1\rQ|1|^SPEC-7||ALL\rL|1\r");
  * req.classification.kind;               // "host-query"
- * req.classification.isHostQueryRequest; // true — never read its records as results
+ * req.classification.isHostQueryRequest; // true, never read its records as results
  * ```
  */
 interface AstmMessageClassification {
@@ -1649,7 +1732,7 @@ interface AstmMessageClassification {
     /** At least one `O` (order) record is present. */
     readonly hasOrders: boolean;
     /**
-     * `true` **iff** `kind === "host-query"` (a `Q` record is present) — the safety surface: gate on this
+     * `true` **iff** `kind === "host-query"` (a `Q` record is present), the safety surface: gate on this
      * before treating records as results, so a query is never misread as a result upload.
      */
     readonly isHostQueryRequest: boolean;
@@ -1667,11 +1750,20 @@ interface AstmMessageClassification {
  * ```
  */
 interface AstmMessage {
+    /** The **first** header in the stream. A multi-header stream's later headers are in {@link AstmMessage.records}. */
     readonly header: HeaderRecord;
     readonly records: readonly AstmRecord[];
+    /**
+     * The delimiters the **first** header declared.
+     *
+     * A stream may carry several messages (`H` … `L`), and a later header may declare a different set,
+     * which is honored from that header onward. So this is not necessarily the set every record was
+     * read with: each header reports its own on {@link HeaderRecord.delimiters}, and a change is
+     * flagged `ASTM_RECORD_DELIMITERS_REDECLARED`.
+     */
     readonly delimiters: Delimiters;
     /**
-     * The host-query classification of this message — whether it is a request (`Q`
+     * The host-query classification of this message: whether it is a request (`Q`
      * present), a result upload, an order download, or indeterminate. Gate on
      * {@link AstmMessageClassification.isHostQueryRequest} before reading records as
      * results.
@@ -1679,7 +1771,7 @@ interface AstmMessage {
     readonly classification: AstmMessageClassification;
     readonly warnings: readonly AstmRecordWarning[];
     /**
-     * The vendor profile that was active for this parse, when one applied — its
+     * The vendor profile that was active for this parse, when one applied: its
      * `name` and resolved `lineage` (attribution only; the profile object itself is
      * not embedded). Absent when no profile applied. A profile that tolerated a
      * deviation shows up as a `PROFILE_QUIRK_APPLIED` entry in {@link warnings}, not
@@ -1697,7 +1789,7 @@ interface AstmParseOptions {
     /**
      * When `true`, escalate any Tier-2 deviation to a thrown {@link AstmStrictError}
      * instead of accumulating a warning. Off by default. A deviation a profile
-     * *expected* (a `PROFILE_QUIRK_APPLIED`) does **not** escalate — it is known,
+     * *expected* (a `PROFILE_QUIRK_APPLIED`) does **not** escalate: it is known,
      * benign, and still recorded.
      */
     readonly strict?: boolean;
@@ -1714,11 +1806,11 @@ interface AstmParseOptions {
 /**
  * The record-layer entry point: {@link parseAstmRecords}.
  *
- * Phase 1 assumes **already-de-framed** record bytes (the E1381/LIS01 framing
- * layer is a later phase). It reads the four delimiters from the header, tokenizes
- * every record escape-aware, and builds the immutable {@link AstmMessage} — lenient
- * by default: vendor quirks become typed warnings, and only three unrecoverable
- * structural conditions are fatal.
+ * It assumes **already-de-framed** record bytes; {@link parseFramedAstm} composes
+ * the E1381/LIS01 framing layer with this one. It reads the four delimiters from each
+ * `H` record, tokenizes every record escape-aware, and builds the immutable
+ * {@link AstmMessage}, lenient by default: vendor quirks become typed warnings, and
+ * only three unrecoverable structural conditions are fatal.
  */
 
 /**
@@ -1746,8 +1838,18 @@ declare class AstmStrictError extends Error {
  *
  * The stream is a sequence of records separated by `CR` (with `LF`/`CRLF`
  * tolerated); the first record must be an `H` header, which declares the
- * delimiters used by the rest. Lenient by default — set `strict` to reject any
- * tolerated deviation.
+ * delimiters. Lenient by default: set `strict` to reject any tolerated deviation.
+ *
+ * **Several messages in one stream.** A message runs `H` … `L`, so a stream may carry
+ * more than one, and each `H` declares the delimiters for the records that follow it.
+ * A later header that declares a **different** set is honored from that header onward
+ * and flagged `ASTM_RECORD_DELIMITERS_REDECLARED`; records already read keep the set
+ * they were read with, so a redeclaration never reinterprets earlier bytes. A header
+ * that merely restates the set in force is a no-op and warns nothing. A later header
+ * that cannot declare a usable set keeps the delimiters already in force and warns
+ * `ASTM_RECORD_UNREADABLE_REDECLARATION`: a set is never guessed, and no record is
+ * dropped. Per-header sets are on each {@link HeaderRecord.delimiters};
+ * {@link AstmMessage.delimiters} is the first header's.
  *
  * @param raw - The de-framed record bytes, as a string or `Uint8Array` (decoded
  *   latin1 so byte values survive 1:1).
@@ -1765,9 +1867,9 @@ declare class AstmStrictError extends Error {
  */
 declare function parseAstmRecords(raw: string | Uint8Array, options?: AstmParseOptions): AstmMessage;
 /**
- * Attach every `C` (comment) record to its parent by position — the immediately-preceding
+ * Attach every `C` (comment) record to its parent by position: the immediately-preceding
  * `H`/`P`/`O`/`R` record; consecutive comments share that parent. **Fail-safe:** a comment with no
- * valid preceding parent is an **orphan** — it is attached to the message root (`attachedToRoot:
+ * valid preceding parent is an **orphan**, it is attached to the message root (`attachedToRoot:
  * true`) with an `ASTM_RECORD_ORPHAN_COMMENT` warning, **never dropped**. Returns a new array; the
  * non-comment records pass through unchanged.
  *
@@ -1789,33 +1891,63 @@ declare function parseAstmRecords(raw: string | Uint8Array, options?: AstmParseO
 declare function attachComments(records: readonly AstmRecord[], warnings: AstmRecordWarning[]): AstmRecord[];
 
 /**
- * The record-layer **emit** side: {@link serializeAstmRecords} — Phase 7.
+ * The record-layer **emit** side: {@link serializeAstmRecords}.
  *
  * The inverse of `parseAstmRecords`. Where the parser is liberal (vendor quirks
  * become warnings), the serializer is **conservative**: it always emits a
  * spec-clean stream with the **canonical** delimiter set (`H|\^&`), re-escapes
  * every embedded delimiter so an embedded `|`/`^`/`\`/`&` in a value can never
- * break framing (the exact inverse of the Phase-1 escape codec), and terminates
+ * break framing (the exact inverse of the escape codec), and terminates
  * each record with a `CR`.
  *
- * **Round-trip by construction.** Serialization emits from a record's **decoded**
- * component tree (`AstmField.repeats`) and re-escapes each leaf, so
- * `parseAstmRecords(serializeAstmRecords(msg))` reproduces the same modelled
- * fields — the same components, the same typed accessors, and the canonical
- * delimiter set (a non-canonical source is normalized to `H|\^&`, a documented
- * Phase-7 behavior; round-tripping a vendor's own delimiters is a Phase-8
- * profile concern).
+ * **Round-trip.** `parseAstmRecords(serializeAstmRecords(msg))` reproduces the modeled
+ * records: the same components, the same typed accessors, and the canonical delimiter
+ * set (a non-canonical source is normalized to `H|\^&` by default). Normalizing sets the
+ * four delimiter **roles**; it does not delete a declaration's surplus characters, so a
+ * canonically-declared header that arrived carrying surplus keeps it on the default path
+ * too.
+ *
+ * **One delimiter set for the whole stream.** Every record (including `H`, `M` and `S`)
+ * is emitted against the delimiters being emitted with, and the header declares that same
+ * set. `M` and `S` carry vendor free-form data and are reproduced **byte-for-byte** from
+ * their preserved `rawLine` whenever a reader using those delimiters would recover exactly
+ * the fields they model, which is the case for any stream already in the emit delimiter
+ * set. When it is not, the record arrived under one delimiter set and is being emitted
+ * under another, the record is re-encoded from its decoded tree instead, so its fields
+ * survive as fields rather than collapsing into one on the next read.
+ *
+ * **Emit follows the model.** Every record type, `H` included, is emitted from its decoded
+ * `AstmField.repeats` tree, so an edit to a record's `fields` is reflected on emit. The one
+ * part of a record that is never taken from the model is the header's delimiter
+ * declaration, and only in the three positions that carry a role: those always state the
+ * repeat, component and escape characters actually in use, whatever the model says. Any
+ * further characters the declaration carried, a reader assigns them no role, come from
+ * the model like everything else, so a header that arrived as `H|\^&#` goes back out as
+ * `H|\^&#` rather than losing the `#`. That holds on the **default** canonical path as
+ * well as when a set is passed explicitly: the surplus of a canonically-declared header
+ * survives normalization, because normalization is about the four roles and the surplus
+ * has none.
  *
  * **Never break framing.** A component leaf that contains a record terminator
  * (`CR`/`LF`) cannot be escaped by the ASTM escape codec (only the four declared
  * delimiters have mnemonics), so emitting it would silently corrupt the wire.
  * The serializer refuses: an embedded `CR`/`LF` is a typed {@link AstmSerializeError},
  * never emitted raw.
+ *
+ * **Check the delimiter set before writing.** Three conditions are required for the
+ * emitted bytes to read back as the records that produced them (each separator exactly
+ * one character, no separator a `CR`/`LF`, no two separators the same character) and a
+ * set failing any of them is a typed {@link AstmSerializeError}
+ * (`ASTM_EMIT_INVALID_DELIMITERS`) rather than output this library's own parser would
+ * reject or silently re-read with a different field tree. These are **necessary**
+ * conditions, not a guarantee of readback: a set can pass all three and still produce a
+ * stream that reads back wrong, a separator that collides with a record's type letter
+ * is the known case, and it corrupts identically with or without this check.
  */
 
 /**
  * Thrown by the record/frame emit side when a value cannot be serialized into a
- * spec-clean stream — specifically when a component contains a record terminator
+ * spec-clean stream: specifically when a component contains a record terminator
  * (`CR`/`LF`), which the ASTM escape codec cannot encode and which would break
  * framing if emitted raw. Carries a stable code + positional context, never the
  * offending value (PHI discipline).
@@ -1832,27 +1964,53 @@ declare function attachComments(records: readonly AstmRecord[], warnings: AstmRe
  * ```
  */
 declare class AstmSerializeError extends Error {
-    /** Stable discriminant; `ASTM_EMIT_UNENCODABLE_VALUE` for a `CR`/`LF` in a value. */
-    readonly code: "ASTM_EMIT_UNENCODABLE_VALUE";
+    /**
+     * Stable discriminant. `ASTM_EMIT_UNENCODABLE_VALUE` for a `CR`/`LF` in a value;
+     * `ASTM_EMIT_INVALID_DELIMITERS` for a delimiter set that cannot be emitted
+     * reversibly.
+     */
+    readonly code: AstmSerializeErrorCode;
     /** 0-based ordinal of the record within the message, when known. */
     readonly recordIndex?: number;
     /** @internal */
-    constructor(message: string, recordIndex?: number);
+    constructor(message: string, recordIndex?: number, code?: AstmSerializeErrorCode);
 }
 /**
- * Escape-encode one component leaf for spec-clean emit — the inverse of
+ * The reasons emit refuses rather than writing a stream that cannot be read back.
+ *
+ * - `ASTM_EMIT_UNENCODABLE_VALUE`: a component holds a record terminator
+ *   (`CR`/`LF`), which the escape codec has no mnemonic for.
+ * - `ASTM_EMIT_INVALID_DELIMITERS`: the delimiter set to emit against failed one
+ *   of the three conditions readback requires (see {@link serializeAstmRecords}).
+ *   Those conditions are necessary rather than sufficient, so this code means a
+ *   set was rejected, not that every unreversible set is.
+ *
+ * @example
+ * ```ts
+ * import type { AstmSerializeErrorCode } from "@cosyte/astm";
+ * const code: AstmSerializeErrorCode = "ASTM_EMIT_INVALID_DELIMITERS";
+ * ```
+ */
+type AstmSerializeErrorCode = "ASTM_EMIT_UNENCODABLE_VALUE" | "ASTM_EMIT_INVALID_DELIMITERS";
+/**
+ * Escape-encode one component leaf for spec-clean emit: the inverse of
  * `decodeEscapes`. The **escape character itself is encoded first** (`&` → `&E&`)
  * so a later delimiter substitution can never double-encode the `&` it just
  * introduced; then the field / component / repeat delimiters map to their
  * mnemonics.
  *
  * A `CR`/`LF` in the leaf has no escape mnemonic and would break framing, so it
- * is rejected with an {@link AstmSerializeError} rather than emitted raw.
+ * is rejected with an {@link AstmSerializeError} rather than emitted raw, as is a
+ * delimiter set the result could not be read back with.
  *
  * @param leaf - One already-decoded component string.
  * @param d - The delimiters to emit against (canonical for spec-clean output).
  * @param recordIndex - The enclosing record's index, for error context.
  * @returns The escaped component text.
+ * @throws {@link AstmSerializeError} for a `CR`/`LF` in the leaf
+ *   (`ASTM_EMIT_UNENCODABLE_VALUE`), or for a delimiter set failing one of the
+ *   three conditions readback requires (`ASTM_EMIT_INVALID_DELIMITERS`), which
+ *   are necessary, not sufficient, so a set can pass them and still not reverse.
  * @example
  * ```ts
  * import { encodeComponent, CANONICAL_DELIMITERS } from "@cosyte/astm";
@@ -1865,15 +2023,20 @@ declare function encodeComponent(leaf: string, d: Delimiters, recordIndex?: numb
  * terminator). Emits with the given delimiters, defaulting to the canonical set.
  *
  * The header (`H`) is special-cased: its delimiter-definition field is emitted as
- * the **literal** canonical declaration (`\^&`), never escaped — escaping it would
- * corrupt the very declaration a reader depends on. Manufacturer (`M`) and
- * scientific (`S`) records are surfaced **byte-identically** from their preserved
- * `rawLine` — verbatim in, verbatim out.
+ * the **literal** declaration of `d`, never escaped, escaping it would corrupt the
+ * very declaration a reader depends on, followed by any characters the modeled
+ * declaration carried beyond the three a reader takes its roles from. Manufacturer
+ * (`M`) and scientific (`S`) records are reproduced **byte-identically** from their
+ * preserved `rawLine` when they are already in `d`, and re-encoded from their fields
+ * when they are not, so their fields never collapse into one on the next read.
  *
  * @param record - The record to serialize.
  * @param d - The delimiters to emit against; defaults to `H|\^&`.
  * @returns The record's wire text, terminator excluded.
- * @throws {@link AstmSerializeError} when a component contains an unencodable `CR`/`LF`.
+ * @throws {@link AstmSerializeError} when a component contains an unencodable `CR`/`LF`
+ *   (`ASTM_EMIT_UNENCODABLE_VALUE`), or when `d` fails one of the three conditions
+ *   readback requires (`ASTM_EMIT_INVALID_DELIMITERS`): necessary conditions, not
+ *   sufficient ones, so a set can pass them and still not reverse.
  * @example
  * ```ts
  * import { serializeAstmRecord, parseAstmRecords } from "@cosyte/astm";
@@ -1884,16 +2047,36 @@ declare function encodeComponent(leaf: string, d: Delimiters, recordIndex?: numb
 declare function serializeAstmRecord(record: AstmRecord, d?: Delimiters): string;
 /**
  * Serialize a whole ASTM message (or a bare record list) to a spec-clean,
- * `CR`-terminated record stream — the inverse of `parseAstmRecords`.
+ * `CR`-terminated record stream: the inverse of `parseAstmRecords`.
  *
  * Emit is **conservative**: the canonical `H|\^&` delimiters, every embedded
  * delimiter re-escaped, each record closed with a `CR`. A message parsed with
- * non-canonical delimiters is **normalized** to the canonical set on emit (a
- * documented Phase-7 behavior — vendor-delimiter round-tripping is Phase 8).
+ * non-canonical delimiters is **normalized** to the canonical set on emit: every
+ * record, `M` and `S` included, so the emitted stream is in one delimiter set and
+ * re-parsing it recovers every field. Passing `d` explicitly emits against that set
+ * instead, and the header declares it. Normalization replaces the four delimiter
+ * **roles**; a header declaration carrying characters beyond the three that hold a
+ * role keeps them, on this path as on any other, rather than being truncated.
+ *
+ * **`d` is checked before anything is written.** Each of the four separators must be
+ * exactly one character, none may be a record terminator, and no two may share a
+ * character: otherwise the emitted bytes cannot be read back as the records that
+ * produced them, and emit has no warning channel with which to say so. A set that
+ * fails is an {@link AstmSerializeError} with code `ASTM_EMIT_INVALID_DELIMITERS`.
+ * This is stricter than the parser, which reads some sets it cannot reverse, so
+ * `serializeAstmRecords(msg, msg.delimiters)` can refuse a message that parsed:
+ * in exactly the cases where it used to emit a stream that read back wrong. The
+ * three conditions are necessary rather than sufficient: a set that passes them can
+ * still read back wrong if a separator collides with a record's type letter, which
+ * this check does not claim to catch.
  *
  * @param input - A parsed {@link AstmMessage} or a list of {@link AstmRecord}s.
+ * @param d - The delimiters to emit against; defaults to the canonical `H|\^&` set.
  * @returns The serialized record stream (`CR` after every record).
- * @throws {@link AstmSerializeError} when a component contains an unencodable `CR`/`LF`.
+ * @throws {@link AstmSerializeError} when a component contains an unencodable `CR`/`LF`
+ *   (`ASTM_EMIT_UNENCODABLE_VALUE`), or when `d` fails one of the three conditions
+ *   readback requires (`ASTM_EMIT_INVALID_DELIMITERS`): necessary conditions, not
+ *   sufficient ones, so a set can pass them and still not reverse.
  * @example
  * ```ts
  * import { parseAstmRecords, serializeAstmRecords } from "@cosyte/astm";
@@ -1910,6 +2093,10 @@ declare function serializeAstmRecords(input: AstmMessage | readonly AstmRecord[]
  * @param field - The field to serialize.
  * @param d - The delimiters to emit against; defaults to `H|\^&`.
  * @returns The escaped field text.
+ * @throws {@link AstmSerializeError} when a component contains an unencodable `CR`/`LF`
+ *   (`ASTM_EMIT_UNENCODABLE_VALUE`), or when `d` fails one of the three conditions
+ *   readback requires (`ASTM_EMIT_INVALID_DELIMITERS`): necessary conditions, not
+ *   sufficient ones, so a set can pass them and still not reverse.
  * @example
  * ```ts
  * import { serializeField, tokenizeRecord, CANONICAL_DELIMITERS } from "@cosyte/astm";
@@ -1920,20 +2107,20 @@ declare function serializeAstmRecords(input: AstmMessage | readonly AstmRecord[]
 declare function serializeField(field: AstmField, d?: Delimiters): string;
 
 /**
- * The record-layer **builder**: {@link buildAstmMessage} — Phase 7.
+ * The record-layer **builder**: {@link buildAstmMessage}.
  *
  * A builder produces spec-clean E1394 records **by construction** from typed
  * caller input, under two disciplines:
  *
  * - **Never fabricate.** A builder emits **only** the values the caller supplied.
  *   An unsupplied field is left **empty**, never filled with a default clinical
- *   value — no defaulted result status, abnormal flag, units, value, or patient
+ *   value: no defaulted result status, abnormal flag, units, value, or patient
  *   identifier. (Leaving a field empty is not a guess; inventing an `F` status or
  *   an `N` flag would be.) A consumer that parses a built result whose status the
  *   caller omitted reads `status.meaning === "unspecified"`, never `"final"`.
  * - **Compute, don't guess, the structure.** The record type letters, the
  *   delimiter declaration (canonical `H|\^&`), the message terminator (`L`), and
- *   the per-record sequence counters are **structural** — computed by the builder,
+ *   the per-record sequence counters are **structural**: computed by the builder,
  *   not clinical values. The caller may override any sequence number.
  *
  * Every value is escape-encoded on emit (via the serializer), so an embedded
@@ -1946,98 +2133,98 @@ interface PatientNameInput {
     readonly first?: string;
     readonly middle?: string;
 }
-/** Input for a `P` (patient) record. The three IDs stay distinct — none defaults from another. */
+/** Input for a `P` (patient) record. The three IDs stay distinct: none defaults from another. */
 interface PatientInput {
     readonly type: "P";
     /** Structural sequence number; auto-computed when omitted. */
     readonly seq?: string;
-    /** Field 3 — practice-assigned patient ID. */
+    /** Field 3: practice-assigned patient ID. */
     readonly practiceAssignedId?: string;
-    /** Field 4 — laboratory-assigned patient ID. */
+    /** Field 4: laboratory-assigned patient ID. */
     readonly laboratoryAssignedId?: string;
-    /** Field 5 — a third patient identifier. */
+    /** Field 5: a third patient identifier. */
     readonly patientIdThree?: string;
-    /** Field 6 — patient name (`Last^First^Middle`). */
+    /** Field 6: patient name (`Last^First^Middle`). */
     readonly name?: PatientNameInput;
-    /** Field 7 — mother's maiden name. */
+    /** Field 7: mother's maiden name. */
     readonly mothersMaidenName?: string;
-    /** Field 8 — birthdate (`YYYYMMDDHHMMSS`), emitted verbatim, never reformatted. */
+    /** Field 8: birthdate (`YYYYMMDDHHMMSS`), emitted verbatim, never reformatted. */
     readonly birthDate?: string;
-    /** Field 9 — sex, emitted verbatim (never defaulted). */
+    /** Field 9: sex, emitted verbatim (never defaulted). */
     readonly sex?: string;
 }
 /** Input for an `O` (order) record. */
 interface OrderInput {
     readonly type: "O";
     readonly seq?: string;
-    /** Field 3 — specimen / accession ID. */
+    /** Field 3: specimen / accession ID. */
     readonly specimenId?: string;
-    /** Field 4 — instrument specimen ID. */
+    /** Field 4: instrument specimen ID. */
     readonly instrumentSpecimenId?: string;
-    /** Field 5 — Universal Test ID components (verbatim, in order; e.g. `["", "", "", "687"]`). */
+    /** Field 5: Universal Test ID components (verbatim, in order; e.g. `["", "", "", "687"]`). */
     readonly universalTestId?: readonly string[];
-    /** Field 6 — priority, emitted verbatim. */
+    /** Field 6: priority, emitted verbatim. */
     readonly priority?: string;
-    /** Field 12 — action code, emitted verbatim. */
+    /** Field 12: action code, emitted verbatim. */
     readonly actionCode?: string;
-    /** Field 26 — report type, emitted verbatim. */
+    /** Field 26: report type, emitted verbatim. */
     readonly reportType?: string;
 }
 /** Input for an `R` (result) record. No clinical field is defaulted; unsupplied ⇒ empty. */
 interface ResultInput {
     readonly type: "R";
     readonly seq?: string;
-    /** Field 3 — Universal Test ID components (verbatim). */
+    /** Field 3: Universal Test ID components (verbatim). */
     readonly universalTestId?: readonly string[];
-    /** Field 4 — the measured value, emitted verbatim (never defaulted). */
+    /** Field 4: the measured value, emitted verbatim (never defaulted). */
     readonly value?: string;
-    /** Field 5 — units (vendor free text; never defaulted, guessed, or converted). */
+    /** Field 5: units (vendor free text; never defaulted, guessed, or converted). */
     readonly units?: string;
-    /** Field 6 — reference range, emitted verbatim. */
+    /** Field 6: reference range, emitted verbatim. */
     readonly referenceRange?: string;
-    /** Field 7 — abnormal flags, emitted verbatim (never defaulted to `N`). */
+    /** Field 7: abnormal flags, emitted verbatim (never defaulted to `N`). */
     readonly abnormalFlags?: string;
-    /** Field 9 — result status, emitted verbatim (never defaulted to `F`). */
+    /** Field 9: result status, emitted verbatim (never defaulted to `F`). */
     readonly resultStatus?: string;
-    /** Field 11 — operator. */
+    /** Field 11: operator. */
     readonly operator?: string;
-    /** Field 12 — test-started timestamp (`YYYYMMDDHHMMSS`), verbatim. */
+    /** Field 12: test-started timestamp (`YYYYMMDDHHMMSS`), verbatim. */
     readonly startedAt?: string;
-    /** Field 13 — test-completed timestamp, verbatim. */
+    /** Field 13: test-completed timestamp, verbatim. */
     readonly completedAt?: string;
-    /** Field 14 — instrument identifier. */
+    /** Field 14: instrument identifier. */
     readonly instrument?: string;
 }
 /** Input for a `C` (comment) record. */
 interface CommentInput {
     readonly type: "C";
     readonly seq?: string;
-    /** Field 3 — comment source. */
+    /** Field 3: comment source. */
     readonly source?: string;
-    /** Field 4 — comment text (a single component). Use {@link CommentInput.textComponents} for a structured comment. */
+    /** Field 4: comment text (a single component). Use {@link CommentInput.textComponents} for a structured comment. */
     readonly text?: string;
-    /** Field 4 — comment text as explicit components (takes precedence over `text` when set). */
+    /** Field 4: comment text as explicit components (takes precedence over `text` when set). */
     readonly textComponents?: readonly string[];
-    /** Field 5 — comment type code, emitted verbatim. */
+    /** Field 5: comment type code, emitted verbatim. */
     readonly commentType?: string;
 }
 /** Input for a `Q` (request-information) record. */
 interface QueryInput {
     readonly type: "Q";
     readonly seq?: string;
-    /** Field 3 — starting range ID, emitted verbatim. */
+    /** Field 3: starting range ID, emitted verbatim. */
     readonly startingRangeId?: string;
-    /** Field 4 — ending range ID, emitted verbatim. */
+    /** Field 4: ending range ID, emitted verbatim. */
     readonly endingRangeId?: string;
-    /** Field 5 — Universal Test ID components; ignored when {@link QueryInput.queriesAllTests} is set. */
+    /** Field 5: Universal Test ID components; ignored when {@link QueryInput.queriesAllTests} is set. */
     readonly universalTestId?: readonly string[];
-    /** Field 5 — emit the literal `ALL` universal-query keyword instead of a Universal Test ID. */
+    /** Field 5: emit the literal `ALL` universal-query keyword instead of a Universal Test ID. */
     readonly queriesAllTests?: boolean;
-    /** Field 13 — request-information status, emitted verbatim. */
+    /** Field 13: request-information status, emitted verbatim. */
     readonly requestInformationStatus?: string;
 }
 /**
- * Input for an `M` (manufacturer) or `S` (scientific) record — vendor-defined
+ * Input for an `M` (manufacturer) or `S` (scientific) record: vendor-defined
  * free-form data. Emitted verbatim from the caller's fields; never interpreted.
  */
 interface VerbatimInput {
@@ -2059,7 +2246,7 @@ interface MessageInput {
     /** The body records, in order. `H` and `L` are supplied by the builder. */
     readonly records: readonly AstmRecordInput[];
     /**
-     * Field 3 of the auto-appended `L` (terminator) record — the termination code
+     * Field 3 of the auto-appended `L` (terminator) record: the termination code
      * (e.g. `N` normal). Omitted by default (not defaulted to a value the caller
      * did not choose); the `L` seq is always emitted.
      */
@@ -2071,7 +2258,7 @@ interface MessageInput {
  * The builder emits the canonical `H|\^&` header (plus any header fields), then
  * every body record with each supplied field at its correct 1-based position and
  * every value escape-encoded, then an `L` terminator. **Nothing clinical is
- * defaulted** — an unsupplied field is empty, never a guessed value — and the
+ * defaulted** (an unsupplied field is empty, never a guessed value) and the
  * structural pieces (delimiters, record types, sequence counters, terminator) are
  * computed. The result parses back to an equal message: build → parse fidelity by
  * construction.
@@ -2091,20 +2278,32 @@ interface MessageInput {
 declare function buildAstmMessage(input: MessageInput): string;
 
 /**
- * Typed extractors over an {@link AstmMessage} — the one-line "pull the value out"
+ * Typed extractors over an {@link AstmMessage}: the one-line "pull the value out"
  * surface that is the package's north star.
  *
- * They are thin, total, and immutable: they read the already-parsed model and
- * never re-parse, never mutate, and never fabricate. `results()` returns every
- * `R` record in order; `patient()` returns the first `P` record (the identity a
- * result files against), or `undefined` when the message carries none.
+ * They are thin and immutable: they read the already-parsed model and never re-parse,
+ * never mutate, and never fabricate.
+ *
+ * **They are scoped to a single message, and they enforce it.** An `AstmMessage` models a
+ * whole record **stream**, which may carry several `H` … `L` messages back to back. These
+ * extractors read across the whole stream, so on a multi-message stream `patient()` used to
+ * answer with the first `P` in the stream while `results()` answered with every `R` in it:
+ * pairing the two attributed one patient's results to another, silently and with no warning.
+ * They now **refuse** that stream: an {@link AstmAmbiguousStreamError} instead of a confident
+ * wrong answer, which is the same rule the rest of this parser follows. {@link messages} is
+ * the path that works on any stream, and `commentsFor()` keeps working on every stream
+ * because its parent record already names the message.
+ *
+ * @see {@link messages}
  */
 
 /**
  * Every result (`R`) record in the message, in wire order.
  *
- * @param msg - A parsed message.
+ * @param msg - A parsed **single-message** stream.
  * @returns The result records (possibly empty).
+ * @throws {@link AstmAmbiguousStreamError} (`ASTM_AMBIGUOUS_MULTI_MESSAGE`) when the stream
+ *   carries more than one message: see {@link messages}.
  * @example
  * ```ts
  * import { parseAstmRecords, results } from "@cosyte/astm";
@@ -2114,13 +2313,18 @@ declare function buildAstmMessage(input: MessageInput): string;
  */
 declare function results(msg: AstmMessage): readonly ResultRecord[];
 /**
- * The first patient (`P`) record, or `undefined` when the message has none.
+ * The message's patient (`P`) record, or `undefined` when the message carries none.
  *
- * A message can carry several `P` records (multiple patients in a batch); this
- * returns the first. Consumers needing all of them can filter `msg.records`.
+ * This is the identity a result files against, so it is answered only when the stream
+ * determines exactly one. It **refuses** the two shapes where "the patient" is a guess: a
+ * stream carrying several messages, and a single message carrying several `P` records. In
+ * both, the old behaviour, the first `P` in the stream, is the wrong-patient path itself.
  *
- * @param msg - A parsed message.
- * @returns The first patient record, or `undefined`.
+ * @param msg - A parsed single-message stream carrying at most one patient.
+ * @returns The patient record, or `undefined` when the message carries none.
+ * @throws {@link AstmAmbiguousStreamError} (`ASTM_AMBIGUOUS_MULTI_MESSAGE`) when the stream
+ *   carries more than one message, or (`ASTM_AMBIGUOUS_MULTI_PATIENT`) when its one message
+ *   carries more than one `P`. Use {@link messages} and read `patients` in both cases.
  * @example
  * ```ts
  * import { parseAstmRecords, patient } from "@cosyte/astm";
@@ -2132,8 +2336,10 @@ declare function patient(msg: AstmMessage): PatientRecord | undefined;
 /**
  * Every order (`O`) record in the message, in wire order.
  *
- * @param msg - A parsed message.
+ * @param msg - A parsed **single-message** stream.
  * @returns The order records (possibly empty).
+ * @throws {@link AstmAmbiguousStreamError} (`ASTM_AMBIGUOUS_MULTI_MESSAGE`) when the stream
+ *   carries more than one message: see {@link messages}.
  * @example
  * ```ts
  * import { parseAstmRecords, orders } from "@cosyte/astm";
@@ -2145,10 +2351,12 @@ declare function orders(msg: AstmMessage): readonly OrderRecord[];
 /**
  * Every comment (`C`) record in the message, in wire order. Each carries the
  * `parentIndex` of the `H`/`P`/`O`/`R` it attaches to (or `attachedToRoot` when
- * it is an orphan) — use {@link commentsFor} to get the comments of one record.
+ * it is an orphan): use {@link commentsFor} to get the comments of one record.
  *
- * @param msg - A parsed message.
+ * @param msg - A parsed **single-message** stream.
  * @returns The comment records (possibly empty).
+ * @throws {@link AstmAmbiguousStreamError} (`ASTM_AMBIGUOUS_MULTI_MESSAGE`) when the stream
+ *   carries more than one message: see {@link messages}.
  * @example
  * ```ts
  * import { parseAstmRecords, comments } from "@cosyte/astm";
@@ -2159,8 +2367,11 @@ declare function orders(msg: AstmMessage): readonly OrderRecord[];
 declare function comments(msg: AstmMessage): readonly CommentRecord[];
 /**
  * The comment (`C`) records attached to a given parent record, in wire order.
+ *
+ * Unlike the other extractors this works on **any** stream, single- or multi-message: the
+ * parent record it is handed already names the message, so there is nothing to disambiguate.
  * Returns the comments whose `parentIndex` is that record's `recordIndex`, so a
- * comment carrying (e.g.) QC context is read against the record it modifies —
+ * comment carrying (e.g.) QC context is read against the record it modifies:
  * never floated to the wrong one.
  *
  * @param msg - A parsed message.
@@ -2176,11 +2387,13 @@ declare function comments(msg: AstmMessage): readonly CommentRecord[];
 declare function commentsFor(msg: AstmMessage, parent: AstmRecord): readonly CommentRecord[];
 /**
  * Every request-information (`Q`) record in the message, in wire order. A non-empty
- * result means the message is a **host-query request**, not a result set — see
+ * result means the message is a **host-query request**, not a result set: see
  * {@link AstmMessage.classification} (`isHostQueryRequest`).
  *
- * @param msg - A parsed message.
+ * @param msg - A parsed **single-message** stream.
  * @returns The query records (possibly empty).
+ * @throws {@link AstmAmbiguousStreamError} (`ASTM_AMBIGUOUS_MULTI_MESSAGE`) when the stream
+ *   carries more than one message: see {@link messages}.
  * @example
  * ```ts
  * import { parseAstmRecords, query } from "@cosyte/astm";
@@ -2190,9 +2403,195 @@ declare function commentsFor(msg: AstmMessage, parent: AstmRecord): readonly Com
  */
 declare function query(msg: AstmMessage): readonly QueryRecord[];
 
+/**
+ * Message grouping: the safe replacement for the stream-scoped extractors.
+ *
+ * A parsed {@link AstmMessage} models a whole **record stream**, and a stream may carry
+ * several messages back to back: a message runs from an `H` header to its `L` terminator.
+ * The flat extractors in `./extractors.js` read the whole stream, so on a multi-message
+ * stream `patient(msg)` answered with the first `P` in the stream while `results(msg)`
+ * answered with every `R` in it: pairing the two, which is exactly what the package's
+ * one-line north star does, attributed one patient's results to another. It needed no
+ * redeclaration and no unusual delimiters, and it warned about nothing.
+ *
+ * {@link messages} is the fix: it splits the stream into the messages it actually
+ * contains, and each one carries only its own records, so a patient and a result are only
+ * ever paired inside the message that carried both.
+ *
+ * **Where a message begins.** A new message opens at every `H` record and runs to the
+ * record before the next `H` (or the end of the stream). That is deliberately the *same*
+ * boundary the parser already uses to scope delimiters: the active delimiter set is
+ * re-read at each `H` and governs that header and the records that follow it, so message
+ * boundaries and delimiter scope cannot disagree. The `L` terminator **closes** a message
+ * but does not open a scope, so anything between an `L` and the next `H` stays with the
+ * message its header opened rather than being dropped. Grouping is therefore **total**:
+ * every record of the stream lands in exactly one message, none duplicated, none lost.
+ *
+ * **What the standard grounds, and what it does not.** CLSI LIS02-A2 §2 is definitional
+ * about the unit itself: a message is bounded by the `H` record at one end and the `L`
+ * record at the other. That clause is in CLSI's free sample and is the whole of what is
+ * claimed from the standard here. It does **not** settle which record *opens* a new scope
+ * partway through a stream, so treating a second `H` as the start of the next message
+ * (rather than, say, requiring an intervening `L`) is a reasoned choice, not a citation. It
+ * is made this way because it is the boundary this parser already enforces for delimiters,
+ * and because it never drops a record.
+ *
+ * **What is deliberately not modeled.** ASTM's within-message record hierarchy, which `P`
+ * a given `R` files against when one message carries several patients, is not modeled
+ * here. The clauses that would ground it (the message-level structure diagram, and the `P`
+ * sequence-number rule) are withheld from the free sample and are paywalled, so rather than
+ * guess a scoping rule this layer refuses to answer: a message carrying more than one `P`
+ * leaves {@link AstmStreamMessage.patient} `undefined` and surfaces all of them on
+ * {@link AstmStreamMessage.patients}. Multi-patient messages are real, at least one
+ * openly-published vendor interface grammar makes the patient group repeatable on the
+ * download direction, so this is a deferral with a known shape, not a claim that the case
+ * does not arise, and not a claim that the standard is silent about it.
+ *
+ * **The OSS corpus was checked and offers no prior art.** It is informative here, unlike
+ * for delimiter questions, but only negatively: the two commonly-cited reference
+ * implementations both dissolve the message unit. One dispatches records to per-type
+ * callbacks one at a time with no carried state, leaving the grouping to the integrator;
+ * the other merges every message of a transport session into one envelope of flat
+ * per-record-type buckets, from which the association cannot be recovered at all. A flat
+ * model is the incumbent shape, and the misattribution above is what it costs.
+ */
+
+/**
+ * Stable codes for the two ways a flat, stream-scoped accessor can fail to name a single
+ * answer. Renaming a code is a **breaking change**.
+ *
+ * @example
+ * ```ts
+ * import { parseAstmRecords, patient, AMBIGUOUS_CODES, AstmAmbiguousStreamError } from "@cosyte/astm";
+ * try {
+ *   patient(parseAstmRecords(raw));
+ * } catch (err) {
+ *   if (err instanceof AstmAmbiguousStreamError) {
+ *     err.code === AMBIGUOUS_CODES.ASTM_AMBIGUOUS_MULTI_MESSAGE;
+ *   }
+ * }
+ * ```
+ */
+declare const AMBIGUOUS_CODES: {
+    /** The stream carries more than one `H` … `L` message, so a stream-wide answer spans patients. */
+    readonly ASTM_AMBIGUOUS_MULTI_MESSAGE: "ASTM_AMBIGUOUS_MULTI_MESSAGE";
+    /** The one message in the stream carries more than one `P`, so "the patient" is not determined. */
+    readonly ASTM_AMBIGUOUS_MULTI_PATIENT: "ASTM_AMBIGUOUS_MULTI_PATIENT";
+};
+/** A value from {@link AMBIGUOUS_CODES}: the discriminant on {@link AstmAmbiguousStreamError}. */
+type AmbiguousCode = (typeof AMBIGUOUS_CODES)[keyof typeof AMBIGUOUS_CODES];
+/**
+ * Thrown by a flat extractor when the stream it was handed does not determine a single
+ * answer: either because it carries several messages, or because its one message carries
+ * several patients.
+ *
+ * The throw **is** the fix. A caller who gets this error is strictly better off than one
+ * who silently received another patient's results, and the remedy is mechanical: walk
+ * {@link messages} and read each message's own records.
+ *
+ * **PHI:** carries a stable code, a position, and two counts. Never a field value, never a
+ * patient identifier.
+ *
+ * @example
+ * ```ts
+ * import { parseAstmRecords, messages, results, AstmAmbiguousStreamError } from "@cosyte/astm";
+ * const msg = parseAstmRecords(raw);
+ * try {
+ *   results(msg);
+ * } catch (err) {
+ *   if (err instanceof AstmAmbiguousStreamError) {
+ *     for (const m of messages(msg)) m.results.length;
+ *   }
+ * }
+ * ```
+ */
+declare class AstmAmbiguousStreamError extends Error {
+    /** The stable discriminant: see {@link AMBIGUOUS_CODES}. */
+    readonly code: AmbiguousCode;
+    /** Where the ambiguity became visible: the second header, or the second `P`. Value-free. */
+    readonly position: AstmPosition;
+    /** How many `H` … `L` messages the stream carries. */
+    readonly messageCount: number;
+    /** How many `P` records the message in question carries. */
+    readonly patientCount: number;
+    /** @internal */
+    constructor(code: AmbiguousCode, message: string, position: AstmPosition, counts: {
+        readonly messageCount: number;
+        readonly patientCount: number;
+    });
+}
+/**
+ * One `H` … `L` message inside a parsed stream, with its own records and nothing else.
+ *
+ * This is the unit the flat extractors were always assumed to be reading. `AstmMessage`
+ * models the whole stream; this models a message within it.
+ */
+interface AstmStreamMessage {
+    /** 0-based ordinal of this message within the stream. */
+    readonly index: number;
+    /** This message's header record. */
+    readonly header: HeaderRecord;
+    /**
+     * The delimiter set in force for this message: the header's own resolved set, which is
+     * the set its records were actually read with. When a later header's declaration was
+     * unusable, this is the set that stayed in force, never a guessed one.
+     */
+    readonly delimiters: Delimiters;
+    /** Every record of this message in wire order, the header first. */
+    readonly records: readonly AstmRecord[];
+    /**
+     * This message's patient, but **only when the message determines one**: the single `P`
+     * when it carries exactly one, and `undefined` when it carries none **or** several.
+     * `patients.length` distinguishes those two cases; there is no third meaning.
+     *
+     * A message carrying several patients is not answered with the first one, because
+     * "the first `P`" is precisely the guess that files a result against the wrong person.
+     */
+    readonly patient: PatientRecord | undefined;
+    /** Every `P` record in this message, in wire order (usually zero or one). */
+    readonly patients: readonly PatientRecord[];
+    /** Every `R` (result) record in this message, in wire order. */
+    readonly results: readonly ResultRecord[];
+    /** Every `O` (order) record in this message, in wire order. */
+    readonly orders: readonly OrderRecord[];
+    /** Every `C` (comment) record in this message, in wire order. */
+    readonly comments: readonly CommentRecord[];
+    /**
+     * Every `Q` (request-information) record in this message, in wire order.
+     *
+     * For this message's host-query classification, call `classifyMessage(m.records)`. The
+     * `classification` on the parsed model is folded over the **whole stream**, so it is not
+     * per-message and is not mirrored here; deriving it from a message's own records is.
+     */
+    readonly queries: readonly QueryRecord[];
+}
+/**
+ * Split a parsed stream into the `H` … `L` messages it carries.
+ *
+ * This is the safe path and it never throws: a single-message stream yields exactly one
+ * entry, and pairing a patient with a result inside one entry is correct by construction.
+ *
+ * Returns an **array**, not an iterator: the stream is already fully parsed and frozen, so
+ * there is no work to defer, and every other extractor in this package returns a
+ * `readonly` array.
+ *
+ * @param msg - A parsed stream.
+ * @returns The messages, in wire order; never empty for a parsed stream.
+ * @example
+ * ```ts
+ * import { parseAstmRecords, messages } from "@cosyte/astm";
+ * const stream = parseAstmRecords("H|\\^&\rP|1|PRAC-1\rR|1|^^^687|1.0|U/L||N||F\rL|1\r");
+ * for (const m of messages(stream)) {
+ *   m.patient?.practiceAssignedId; // "PRAC-1"
+ *   m.results[0]?.value; // "1.0"
+ * }
+ * ```
+ */
+declare function messages(msg: AstmMessage): readonly AstmStreamMessage[];
+
 /**
  * The **host-query flow**: classify a message as a request, a result upload, an
- * order download, or indeterminate — Phase 4.
+ * order download, or indeterminate.
  *
  * On real analyzers the host-query mode is first-class and sometimes mandatory
  * (on the Roche cobas 4800 there is *no* results-sending-only option): the
@@ -2201,14 +2600,14 @@ declare function query(msg: AstmMessage): readonly QueryRecord[];
  * order flow, so this module makes the distinction **explicit**:
  *
  * **The `Q` record dominates.** Any message carrying a `Q` (request-information)
- * record is classified `host-query` — a request — and is **never** treated as a
+ * record is classified `host-query`, a request, and is **never** treated as a
  * result set, even if a result record is also present (an anomaly, which the
  * parser flags separately with `ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND`). This is the
  * whole point: a `Q`-bearing message can never silently read as a result upload.
  */
 
 /**
- * Classify a record stream by the host-query flow. Pure and total — it only reads
+ * Classify a record stream by the host-query flow. Pure and total: it only reads
  * the record type letters, never a field value.
  *
  * `Q` dominates: a message with any `Q` record is a `host-query` request even when
@@ -2254,10 +2653,40 @@ declare function classifyMessage(records: readonly AstmRecord[]): AstmMessageCla
  * ```
  */
 declare function tokenizeRecord(record: string, d: Delimiters, onUnknownEscape?: (fieldIndex: number) => void): AstmField[];
+/**
+ * Tokenize an `H` (header) record into its fields.
+ *
+ * A header cannot go through {@link tokenizeRecord}: its second field is the
+ * **delimiter declaration**, which carries the escape character *literally*
+ * rather than as an escape sequence. The generic escape-aware split treats that
+ * lone escape character as the opening of an unterminated escape and swallows
+ * the whole remainder of the record into one field, so every data field after
+ * the declaration is lost. This tokenizer instead takes the declaration verbatim
+ * as one opaque field and applies the ordinary escape-aware tokenizer to the
+ * data portion that follows it.
+ *
+ * `fields[0]` is the type-letter field and `fields[1]` is the delimiter
+ * declaration (verbatim, never escape-decoded); the header's ASTM data fields
+ * follow from `fields[2]`.
+ *
+ * @param record - The raw `H` record text (terminator already stripped).
+ * @param d - The delimiters declared by this header.
+ * @param onUnknownEscape - Called with the 0-based whole-record field index for
+ *   each unrecognized escape sequence in the data portion.
+ * @returns The header's fields.
+ * @example
+ * ```ts
+ * import { tokenizeHeader, CANONICAL_DELIMITERS } from "@cosyte/astm";
+ * const fields = tokenizeHeader("H|\\^&|||sender", CANONICAL_DELIMITERS);
+ * fields[1].raw; // "\\^&"
+ * fields[4].raw; // "sender"
+ * ```
+ */
+declare function tokenizeHeader(record: string, d: Delimiters, onUnknownEscape?: (fieldIndex: number) => void): AstmField[];
 /**
  * The primary scalar of a field: its first repeat's first component, decoded.
  * Returns `undefined` for a truly empty field so callers can distinguish
- * "absent" from a value — never defaulting a missing value.
+ * "absent" from a value: never defaulting a missing value.
  *
  * @example
  * ```ts
@@ -2274,9 +2703,13 @@ declare function fieldScalar(field: AstmField | undefined): string | undefined;
  * Tier-3 **fatal** codes mark input the parser cannot recover into a structured
  * `AstmMessage`; anything less severe is a Tier-2 warning (see `./warnings.ts`).
  * `AstmParseError` is thrown directly and consumers narrow via the `code`
- * discriminant. The set is additions-only across phases — the record layer
- * introduces three, one of which (`EMPTY_INPUT`) is shared with every future
- * layer (the frame codec adds its own `ASTM_FRAME_*` fatals later).
+ * discriminant. {@link FatalCode} is **closed**: these three are all of it. The frame
+ * codec reuses `EMPTY_INPUT` (an empty stream is fatal in both its lenient and strict
+ * modes) but does not widen the union, its own thrown errors are separate types with
+ * their own discriminants: {@link AstmFrameEncodeError} carries
+ * `ASTM_FRAME_EMPTY_RECORD`, and {@link AstmFrameStrictError} carries the rejected
+ * warnings rather than a `code`. So narrowing an `AstmParseError` on `code` will only
+ * ever see a value from this set.
  */
 
 /**
@@ -2297,15 +2730,15 @@ declare function fieldScalar(field: AstmField | undefined): string | undefined;
  * ```
  */
 declare const FATAL_CODES: {
-    /** Input was empty or whitespace-only — there is nothing to parse. Shared across layers. */
+    /** Input was empty or whitespace-only: there is nothing to parse. Shared across layers. */
     readonly EMPTY_INPUT: "EMPTY_INPUT";
-    /** The first record is not an `H` (header) record — an ASTM message must lead with `H`. */
+    /** The first record is not an `H` (header) record: an ASTM message must lead with `H`. */
     readonly ASTM_RECORD_NO_HEADER: "ASTM_RECORD_NO_HEADER";
     /** The `H` record is too short to declare the four delimiters (field/repeat/component/escape). */
     readonly ASTM_RECORD_UNDECLARED_DELIMITERS: "ASTM_RECORD_UNDECLARED_DELIMITERS";
 };
 /**
- * A value from {@link FATAL_CODES} — the type carried by a thrown {@link AstmParseError}.
+ * A value from {@link FATAL_CODES}: the type carried by a thrown {@link AstmParseError}.
  */
 type FatalCode = (typeof FATAL_CODES)[keyof typeof FATAL_CODES];
 /**
@@ -2341,11 +2774,11 @@ declare class AstmParseError extends Error {
 }
 
 /**
- * The ASTM escape codec — the Phase-1 fix for a documented silent-misread class.
+ * The ASTM escape codec: the fix for a documented silent-misread class.
  *
  * ASTM escapes an embedded delimiter with the escape character on both sides of
- * a single mnemonic letter (the InterSystems mnemonics, cross-verified in the
- * roadmap's OSS references):
+ * a single mnemonic letter (the InterSystems mnemonics, cross-verified against
+ * the OSS reference implementations):
  *
  * ```
  *   &F&  → field delimiter      (default "|")
@@ -2355,18 +2788,18 @@ declare class AstmParseError extends Error {
  * ```
  *
  * **Why this is a requirement, not a nicety.** A result value can legitimately
- * contain a component delimiter — e.g. a titre written `1^40`. On the wire that
+ * contain a component delimiter: e.g. a titre written `1^40`. On the wire that
  * is escaped as `1&S&40`. A parser that splits a field into components on the
  * raw component delimiter and *never decodes the escape* is safe here (the
  * escape body `&S&` contains no literal `^`), but a parser that **decodes first
  * and splits second** turns `1&S&40` into `1^40` and then mis-splits it into two
- * components — the silent misread `python-astm` / `Chistousov` exhibit. The
+ * components: the silent misread `python-astm` / `Chistousov` exhibit. The
  * correct order, implemented here, is **escape-aware split, then decode each
  * leaf**: the escape sequence survives the split intact and only then decodes to
  * a single literal, so `1&S&40` reads as exactly one component.
  *
- * Re-escaping (the inverse, for spec-clean emit) belongs to the serialize phase
- * (P7) and is deliberately not implemented here.
+ * Re-escaping (the inverse, for spec-clean emit) lives in the serializer and is
+ * deliberately not implemented here.
  */
 
 /**
@@ -2399,7 +2832,7 @@ declare function decodeEscapes(leaf: string, d: Delimiters, onUnknown?: UnknownE
 /**
  * Split `text` on `delimiter`, treating any escape sequence (`escape …
  * escape`) as an opaque atom so a delimiter that appears *inside* an escape body
- * never causes a split. Returns the raw (still-encoded) segments — decoding is
+ * never causes a split. Returns the raw (still-encoded) segments: decoding is
  * the caller's next step, per the escape-aware-split-then-decode contract.
  *
  * For the four canonical mnemonics this is belt-and-suspenders (their bodies are
@@ -2444,12 +2877,12 @@ declare function splitEscapeAware(text: string, delimiter: string, escape: strin
 declare function deepFreeze<T>(value: T): T;
 
 /**
- * `defineAstmProfile()` — the public factory for building immutable
+ * `defineAstmProfile()`: the public factory for building immutable
  * {@link AstmProfile} objects with the safety rules enforced and `describe()`
  * attached. Mirrors the sibling `@cosyte/hl7` `defineProfile()` / `@cosyte/ccda`
  * `defineCcdaProfile()` shape (name / lineage / `extends`-merge / `describe`) while
- * modelling ASTM quirks — a tolerated warning code with provenance, plus the
- * optional raw-vs-framed transport override — rather than HL7 v2 Z-segments or
+ * modelling ASTM quirks (a tolerated warning code with provenance, plus the
+ * optional raw-vs-framed transport override) rather than HL7 v2 Z-segments or
  * C-CDA template deviations.
  *
  * Zero runtime deps. No `any`; immutability at the return boundary via
@@ -2459,7 +2892,7 @@ declare function deepFreeze<T>(value: T): T;
 /**
  * Build a frozen {@link AstmProfile} from a validated options object. Throws
  * {@link AstmProfileDefinitionError} on a bad name, an unknown option key, an
- * invalid `transport`, or an invalid `tolerate` entry — including the **safety
+ * invalid `transport`, or an invalid `tolerate` entry, including the **safety
  * rule**: a profile may never tolerate a safety-critical warning code (default-deny
  * across all three registries).
  *
@@ -2492,18 +2925,18 @@ declare function defineAstmProfile(opts: DefineAstmProfileOptions): AstmProfile;
 /**
  * The definition-time error for the `@cosyte/astm` vendor-profile subsystem.
  *
- * A profile is validated when it is *defined*, not when it is applied — so a
+ * A profile is validated when it is *defined*, not when it is applied, so a
  * misconfigured profile (a bad name, an unknown option key, a tolerated code that
  * is unknown or **safety-critical**) fails loudly at construction, long before it
  * could quiet a real deviation. This is the class that failure throws. It is a
  * programming error (a bad profile literal), distinct from `AstmParseError` (bad
- * input) — so consumers narrow on it separately.
+ * input), so consumers narrow on it separately.
  */
 /**
  * Thrown by `defineAstmProfile` when a profile definition is invalid: a missing or
  * empty `name`, an unknown option key, an invalid `transport` value, or a
- * `tolerate` entry whose code is unknown, whose `rationale` is empty, or — the
- * load-bearing safety rule — whose code is **safety-critical** (a result value,
+ * `tolerate` entry whose code is unknown, whose `rationale` is empty, or, the
+ * load-bearing safety rule, whose code is **safety-critical** (a result value,
  * abnormal flag, result status, reference range, units, patient/comment context,
  * message-kind, code system, or any frame/LTP integrity warning). Carries the
  * offending profile's `name` when it is known, so a multi-profile build names the
@@ -2543,14 +2976,14 @@ declare class AstmProfileDefinitionError extends Error {
  * option always wins, and `profile: null` opts out of the default for a single call.
  *
  * The single mutable module-scoped `let` is the only such state in the profile
- * subsystem — an intentional, documented trade-off (identical to the siblings).
+ * subsystem: an intentional, documented trade-off (identical to the siblings).
  * Tests that set a default MUST clear it in teardown (`setDefaultAstmProfile(null)`)
  * to avoid cross-test bleed.
  */
 
 /**
  * Look up a built-in profile by name. Returns `undefined` when no built-in has that
- * name (a user-defined profile is not in this registry — pass it directly).
+ * name (a user-defined profile is not in this registry, pass it directly).
  *
  * @param name - The built-in profile name.
  * @returns The profile, or `undefined`.
@@ -2578,7 +3011,7 @@ declare function listAstmProfiles(): readonly string[];
  * clear. An explicit `parseAstmRecords(raw, { profile })` always wins;
  * `{ profile: null }` opts out of the default for a single call.
  *
- * **Test hygiene:** the only mutable module-scoped state here — tests that call this
+ * **Test hygiene:** the only mutable module-scoped state here, tests that call this
  * MUST clear it in teardown or default-profile bleed infects later tests.
  *
  * @param profile - The profile to register as default, or `null` to clear.
@@ -2611,7 +3044,7 @@ declare function getDefaultAstmProfile(): AstmProfile | undefined;
  * plus the transport-override accessor the framing detector consumes.
  *
  * A profile **never touches an extracted value**. The warning transform operates
- * purely at the warning layer — downgrading a deviation it *expects* into a
+ * purely at the warning layer: downgrading a deviation it *expects* into a
  * `PROFILE_QUIRK_APPLIED` warning (flagged `expected`, carrying the original
  * `toleratedCode`) while leaving every un-expected warning untouched. Because the
  * transform only ever rewrites a warning object (never a record, field, or value),
@@ -2643,7 +3076,7 @@ declare function applyAstmProfile(profile: AstmProfile, warning: AstmRecordWarni
  * Apply a profile across a whole warning list, returning a NEW array (the input is
  * never mutated). Returned unchanged (same reference contents, a shallow copy) when
  * `profile` is `undefined`, so the no-profile path pays only a copy. Every tolerated
- * warning is re-badged; every other warning passes through by identity — nothing is
+ * warning is re-badged; every other warning passes through by identity, nothing is
  * dropped, reordered, or reallocated beyond the re-badge.
  *
  * @param warnings - The accumulated record warnings.
@@ -2657,7 +3090,7 @@ declare function applyAstmProfile(profile: AstmProfile, warning: AstmRecordWarni
  */
 declare function applyAstmProfileToWarnings(warnings: readonly AstmRecordWarning[], profile: AstmProfile | undefined): AstmRecordWarning[];
 /**
- * The profile's transport override, if any — the value a consumer feeds to
+ * The profile's transport override, if any: the value a consumer feeds to
  * `detectFraming(bytes, { override })` to force framed/raw and bypass leading-byte
  * auto-detection. `undefined` means "let detection decide."
  *
@@ -2675,47 +3108,47 @@ declare function resolveProfileTransport(profile: AstmProfile | undefined): Astm
 /**
  * The safety spine of the profile subsystem: the set of warning codes a profile is
  * **forbidden** to tolerate. A vendor profile exists to quiet known, benign
- * structural noise — never to hide a deviation that could change a clinical
+ * structural noise: never to hide a deviation that could change a clinical
  * reading or corrupt the wire.
  *
  * **Design: default-deny.** Rather than enumerate the *forbidden* codes (a list you
- * can forget to extend when a new warning ships — the exact incompleteness a
+ * can forget to extend when a new warning ships, the exact incompleteness a
  * safety gate must not have), this module enumerates the tiny set of **explicitly
  * tolerable** codes and treats *every other* code, across all three registries
  * (record `ASTM_RECORD_*`, frame `ASTM_FRAME_*`, protocol `ASTM_LTP_*`), as
- * safety-critical. A warning code added in a future phase is therefore
+ * safety-critical. A warning code added later is therefore
  * safety-critical **by default** until someone deliberately, reviewably adds it to
  * the allow-list below. Widening the allow-list can only ever be an explicit,
  * argued act; forgetting to touch this file can never *weaken* the gate.
  *
  * The four tolerable codes are the only deviations that (a) are structural/
  * syntactic vendor noise and (b) **cannot alter, drop, or fabricate an extracted
- * value** — because a profile only ever re-badges a *warning*, never re-parses. In
+ * value**: because a profile only ever re-badges a *warning*, never re-parses. In
  * every one, the underlying datum is already surfaced verbatim regardless of the
  * profile:
  *
- * - `ASTM_RECORD_UNKNOWN_TYPE` — an unmodeled record type, surfaced verbatim as an
+ * - `ASTM_RECORD_UNKNOWN_TYPE`: an unmodeled record type, surfaced verbatim as an
  *   `unsupported` record carrying no interpreted clinical field.
- * - `ASTM_NONSTANDARD_DELIMITERS` — the header's own declared delimiters are read
+ * - `ASTM_NONSTANDARD_DELIMITERS`: the header's own declared delimiters are read
  *   and honored either way; this only notes they differ from the canonical set.
- * - `ASTM_UNKNOWN_ESCAPE_SEQUENCE` — an unrecognized `&…&` body is **preserved
+ * - `ASTM_UNKNOWN_ESCAPE_SEQUENCE`: an unrecognized `&…&` body is **preserved
  *   byte-for-byte** in the decoded value (the escape codec never guesses); the
  *   warning is a purely syntactic advisory, the value is identical with or without
  *   the profile.
- * - `ASTM_RECORD_UNINTERPRETED_QUERY_STATUS` — a `Q`-record request-information
+ * - `ASTM_RECORD_UNINTERPRETED_QUERY_STATUS`: a `Q`-record request-information
  *   status surfaced verbatim on a *request* record; the code set is paywalled and
  *   is never interpreted, profile or not.
  *
- * Everything a wrong value could hide from — a result value split ambiguity, an
+ * Everything a wrong value could hide from: a result value split ambiguity, an
  * undefined abnormal flag or result status, an unparseable reference range, absent
  * units, a mis-attached comment, a partial timestamp, a query-vs-result ambiguity,
  * a bad frame checksum / sequence gap / unterminated / oversize frame, an
- * ambiguous transport, an unexpected protocol event, or a rejected frame — is
+ * ambiguous transport, an unexpected protocol event, or a rejected frame: is
  * forbidden.
  */
 
 /**
- * The **only** warning codes a profile may list in its `tolerate` set — benign,
+ * The **only** warning codes a profile may list in its `tolerate` set: benign,
  * structural/syntactic vendor noise that cannot alter, drop, or fabricate an
  * extracted value. Frozen so it cannot be mutated at runtime to smuggle a code in.
  * Adding to this set is a deliberate, reviewable act (and each addition must be an
@@ -2741,7 +3174,7 @@ declare const TOLERABLE_CODES: ReadonlySet<AnyAstmWarningCode>;
  */
 declare const ALL_ASTM_WARNING_CODES: ReadonlySet<AnyAstmWarningCode>;
 /**
- * The forbidden set — computed as **every known code minus the tolerable
+ * The forbidden set: computed as **every known code minus the tolerable
  * allow-list**, so it is complete by construction. Frozen. A code appears here iff
  * it is a real warning code that is not in {@link TOLERABLE_CODES}.
  *
@@ -2754,7 +3187,7 @@ declare const ALL_ASTM_WARNING_CODES: ReadonlySet<AnyAstmWarningCode>;
  */
 declare const SAFETY_CRITICAL_CODES: ReadonlySet<AnyAstmWarningCode>;
 /**
- * True when `code` is a known warning code that is **not** tolerable — i.e. a
+ * True when `code` is a known warning code that is **not** tolerable: i.e. a
  * profile may never list it. A code that is not a real warning code at all returns
  * `false` here (the validator reports "unknown code" separately, a distinct
  * failure with a distinct message).
@@ -2772,14 +3205,14 @@ declare function isSafetyCriticalCode(code: string): boolean;
 
 /**
  * The `default` conservative baseline profile. Tolerates **nothing** and forces no
- * transport — every deviation surfaces as its own warning, unmodified, and framing
+ * transport: every deviation surfaces as its own warning, unmodified, and framing
  * is auto-detected. It exists so "no profile" and "the default profile" are the
  * same, explicit behaviour, and so a consumer can name the baseline when composing
  * (`extends: astmProfiles.default`) without importing a special sentinel. Absence of
- * a profile means this conservative default applied — not that a stream was fully
+ * a profile means this conservative default applied: not that a stream was fully
  * understood.
  *
- * Authored through the public `defineAstmProfile()` API — zero privileged coupling;
+ * Authored through the public `defineAstmProfile()` API: zero privileged coupling;
  * it is exactly what a user would write.
  */
 
@@ -2796,14 +3229,13 @@ declare function isSafetyCriticalCode(code: string): boolean;
 declare const defaultProfile: AstmProfile;
 
 /**
- * The `referenceCorpus` profile — a **non-vendor**, evidence-backed tolerance
+ * The `referenceCorpus` profile: a **non-vendor**, evidence-backed tolerance
  * grounded firsthand in the **redistributable OSS reference corpus**, not an
  * invented per-vendor deviation matrix.
  *
- * Grounding (firsthand-verified 2026-07-21; the corpus is permissively licensed and
- * in scope for grounding, per the roadmap):
+ * Grounding (firsthand-verified 2026-07-21; the corpus is permissively licensed):
  *
- * - **`kxepal/python-astm` `codec.py`** (BSD) — its `decode_record` /
+ * - **`kxepal/python-astm` `codec.py`** (BSD), its `decode_record` /
  *   `decode_component` / `decode_repeated_component` split fields, components, and
  *   repeats on the raw delimiters and **never un-escape** ASTM escape sequences: the
  *   source contains zero handling of `&F&`/`&S&`/`&R&`/`&E&`, and the escape
@@ -2814,27 +3246,26 @@ declare const defaultProfile: AstmProfile;
  *   or non-standard `&…&` body inside a free-text field (units, comments, test
  *   names) that our **escape-aware** tokenizer flags as
  *   `ASTM_UNKNOWN_ESCAPE_SEQUENCE`. We are deliberately stricter than the OSS
- *   references here (roadmap §6 differential note), so the warning is *expected*
- *   noise when talking to that ecosystem — recognizable and non-clinical.
+ *   references here, so the warning is *expected*
+ *   noise when talking to that ecosystem: recognizable and non-clinical.
  *
  * **Why this is safe.** The escape codec **preserves an unrecognized `&…&` body
  * byte-for-byte** in the decoded value (`decodeEscapes` never guesses); the value a
  * consumer reads is identical whether or not this profile is active. The profile
- * only re-badges the *warning* — no value, flag, status, or identifier is altered
+ * only re-badges the *warning*: no value, flag, status, or identifier is altered
  * or dropped. And by the safety gate in `defineAstmProfile`, it **cannot** tolerate
  * a result value / flag / status / range / units, a patient or comment context, a
- * message-kind ambiguity, or any frame / LTP integrity warning — those always
+ * message-kind ambiguity, or any frame / LTP integrity warning: those always
  * surface, profile or not.
  *
  * **Honesty.** This is a *reference-corpus* profile, not a claim about any named
  * analyzer vendor. No per-vendor ("cobas does X") behaviour is asserted; a named
- * vendor profile awaits a firsthand vendor-attributed quirk document and stays
- * deferred (`REAL-CORPUS`).
+ * vendor profile awaits a firsthand vendor-attributed quirk document.
  */
 
 /**
  * Tolerates the non-standard-escape noise that streams from the escape-agnostic OSS
- * reference stack (`python-astm` / `senaite`) carry — the value is preserved
+ * reference stack (`python-astm` / `senaite`) carry: the value is preserved
  * verbatim; only the syntactic warning is expected.
  *
  * @example
@@ -2854,7 +3285,7 @@ declare const referenceCorpus: AstmProfile;
  * set, the definition-time error, and the profile types.
  *
  * The individual built-ins are reached via `astmProfiles.referenceCorpus` etc., not
- * as top-level named exports — mirrors the sibling `profiles` namespace convention
+ * as top-level named exports: mirrors the sibling `profiles` namespace convention
  * ("default" is too generic for a top-level export).
  */
 
@@ -2864,7 +3295,7 @@ declare const referenceCorpus: AstmProfile;
  * redistributable OSS reference corpus), each authored via the public
  * `defineAstmProfile()` API and carrying its cited provenance. Named per-vendor
  * profiles (cobas / Sysmex / …) are **deferred** pending a firsthand
- * vendor-attributed quirk document — the engine fully supports them; we do not ship
+ * vendor-attributed quirk document: the engine fully supports them; we do not ship
  * ungrounded ones.
  *
  * @example
@@ -2883,18 +3314,18 @@ declare const astmProfiles: {
  * The **consumer-supplied** LIVD catalog: a vendor-test-code → LOINC index built
  * from an IICC LIVD ("LOINC to Vendor IVD") mapping the consumer provides.
  *
- * **Bring-your-own, by design (roadmap §5, Phase 9).** `@cosyte/astm` bundles
- * **no** LOINC, SNOMED, or LIVD data — LOINC is © Regenstrief (redistributable
+ * **Bring-your-own, by design.** `@cosyte/astm` bundles
+ * **no** LOINC, SNOMED, or LIVD data: LOINC is © Regenstrief (redistributable
  * only with its attribution notice) and the public CDC LIVD publication is a
  * SARS-CoV-2-specific file that also carries SNOMED CT (separately licensed), not
  * a general-analyte, public-domain catalog. So the package stays a **structural
  * recognizer, not a dictionary**: it recognizes the Universal Test ID's LOINC slot
- * and surfaces vendor codes verbatim (Phase 1), and this module lets a consumer
- * *supply* their own LIVD file to map those codes — the terminology data, and its
+ * and surfaces vendor codes verbatim, and this module lets a consumer
+ * *supply* their own LIVD file to map those codes, the terminology data, and its
  * license obligations, are the consumer's.
  *
  * **Grounded firsthand on the IICC LIVD digital format / HL7 LIVD IG.** The
- * mapping key is the **Vendor Analyte Code** — the vendor *transmission code* the
+ * mapping key is the **Vendor Analyte Code**: the vendor *transmission code* the
  * instrument sends for an automated test, which is exactly the local code an ASTM
  * analyzer puts in the Universal Test ID (`R`/`O` field, component 4). The mapping
  * target is the **LOINC Code** (with the LOINC Long Common Name as an optional
@@ -2911,7 +3342,7 @@ declare const astmProfiles: {
  * a catalog-hygiene concern the consumer owns.
  */
 /**
- * One LIVD mapping row a consumer supplies — a vendor test code and the LOINC it
+ * One LIVD mapping row a consumer supplies: a vendor test code and the LOINC it
  * maps to, plus optional human-readable / provenance fields. Modeled on the IICC
  * LIVD digital format's data elements.
  *
@@ -2923,20 +3354,20 @@ declare const astmProfiles: {
  */
 interface LivdEntry {
     /**
-     * The **Vendor Analyte Code** — the vendor transmission code the instrument sends (the local code
+     * The **Vendor Analyte Code**: the vendor transmission code the instrument sends (the local code
      * in an ASTM Universal Test ID, component 4). The mapping key; compared **verbatim** (exact,
-     * case-sensitive) against the reported code — never normalized or fuzzy-matched.
+     * case-sensitive) against the reported code, never normalized or fuzzy-matched.
      */
     readonly vendorCode: string;
     /**
      * The **LOINC Code** this vendor code maps to (e.g. `"1920-8"`). Taken from the consumer's catalog
-     * as-is and **never validated, altered, or invented** — the parser does not ship a LOINC table and
+     * as-is and **never validated, altered, or invented**: the parser does not ship a LOINC table and
      * cannot check it; it only carries what the catalog says.
      */
     readonly loinc: string;
-    /** The **LOINC Long Common Name**, when the catalog supplies it — an optional human-readable label. */
+    /** The **LOINC Long Common Name**, when the catalog supplies it: an optional human-readable label. */
     readonly loincLongName?: string;
-    /** The **Vendor Analyte Name** — the vendor's human-readable analyte label, when supplied. */
+    /** The **Vendor Analyte Name**: the vendor's human-readable analyte label, when supplied. */
     readonly vendorAnalyteName?: string;
     /** The device **Manufacturer**, when the catalog scopes the mapping to a device (optional provenance). */
     readonly manufacturer?: string;
@@ -2945,7 +3376,7 @@ interface LivdEntry {
 }
 /**
  * The outcome of looking a vendor code up in a {@link LivdCatalog}. A distinct
- * value per safe disposition — a hit is `mapped`; a miss is `unmapped`; a code that
+ * value per safe disposition: a hit is `mapped`; a miss is `unmapped`; a code that
  * matched more than one **distinct** LOINC is `ambiguous` with the candidates
  * surfaced but **none chosen**. There is deliberately no "guessed" case.
  */
@@ -2956,11 +3387,11 @@ type LivdLookup =
     readonly loinc: string;
     readonly loincLongName?: string;
 }
-/** No entry for this code — a miss. The code stays verbatim; no LOINC is invented. */
+/** No entry for this code: a miss. The code stays verbatim; no LOINC is invented. */
  | {
     readonly status: "unmapped";
 }
-/** More than one distinct LOINC — surfaced for inspection, never resolved to one. */
+/** More than one distinct LOINC: surfaced for inspection, never resolved to one. */
  | {
     readonly status: "ambiguous";
     readonly candidates: readonly string[];
@@ -2976,7 +3407,7 @@ interface LivdCatalog {
     /**
      * Look a vendor code up, verbatim (exact, case-sensitive). Returns `mapped` on a
      * single-LOINC hit, `unmapped` on a miss, and `ambiguous` when the code carries
-     * more than one distinct LOINC — never a guess.
+     * more than one distinct LOINC: never a guess.
      *
      * @param vendorCode - The reported vendor/local test code.
      * @returns The lookup outcome.
@@ -3011,14 +3442,14 @@ interface LivdCatalog {
 declare function defineLivdCatalog(entries: readonly LivdEntry[]): LivdCatalog;
 
 /**
- * The **terminology** warning registry (`ASTM_LIVD_*`) for the Phase-9
- * LIVD-aware LOINC recognition layer — the fourth of the package's registries,
+ * The **terminology** warning registry (`ASTM_LIVD_*`) for the LIVD-aware LOINC
+ * recognition layer: the fourth of the package's registries,
  * alongside the record layer's `ASTM_RECORD_*`, the frame codec's `ASTM_FRAME_*`,
  * and the protocol reducer's `ASTM_LTP_*`.
  *
  * A terminology warning is the record of a **safe non-mapping**: a reported
  * vendor test code that a consumer-supplied LIVD catalog did not map to a single
- * LOINC. It never carries a LOINC the catalog did not vouch for — the whole point
+ * LOINC. It never carries a LOINC the catalog did not vouch for: the whole point
  * of the layer is that an unmapped or ambiguous code is surfaced as *unmapped*,
  * **never a guessed LOINC** (mis-identifying a test is safety-critical). Every
  * warning carries a stable code plus positional context ({@link AstmPosition}) and
@@ -3029,7 +3460,7 @@ declare function defineLivdCatalog(entries: readonly LivdEntry[]): LivdCatalog;
  * profile safety gate's universe (`ALL_ASTM_WARNING_CODES`): a LIVD non-mapping is
  * a post-parse advisory produced by the opt-in {@link applyLivd} helper, not a
  * parse-time deviation a vendor profile could ever "tolerate". A profile referencing
- * one is rejected as an unknown code — correctly, since there is nothing here to
+ * one is rejected as an unknown code: correctly, since there is nothing here to
  * quiet.
  */
 
@@ -3046,14 +3477,14 @@ declare function defineLivdCatalog(entries: readonly LivdEntry[]): LivdCatalog;
 declare const LIVD_WARNING_CODES: {
     /**
      * A record carried a vendor/local test code, but the consumer-supplied LIVD catalog held **no**
-     * entry for it. The code stays surfaced verbatim and the mapping is `unmapped` — a LOINC is
+     * entry for it. The code stays surfaced verbatim and the mapping is `unmapped`: a LOINC is
      * **never** guessed. Purely advisory: the raw code and value are untouched.
      */
     readonly ASTM_LIVD_UNMAPPED_CODE: "ASTM_LIVD_UNMAPPED_CODE";
     /**
      * A vendor/local test code matched **more than one distinct LOINC** in the catalog (e.g. the same
      * transmission code used by two devices for different analytes). The mapping is `ambiguous` and the
-     * candidate LOINCs are surfaced for inspection, but **none is chosen** — refusing to pick is the
+     * candidate LOINCs are surfaced for inspection, but **none is chosen**: refusing to pick is the
      * fail-safe, since guessing wrong mis-identifies the test.
      */
     readonly ASTM_LIVD_AMBIGUOUS_MAPPING: "ASTM_LIVD_AMBIGUOUS_MAPPING";
@@ -3072,7 +3503,7 @@ type LivdWarningCode = (typeof LIVD_WARNING_CODES)[keyof typeof LIVD_WARNING_COD
  * import type { AstmLivdWarning } from "@cosyte/astm";
  * const w: AstmLivdWarning = {
  *   code: "ASTM_LIVD_UNMAPPED_CODE",
- *   message: "Reported test code had no LIVD mapping — surfaced unmapped, never a guessed LOINC.",
+ *   message: "Reported test code had no LIVD mapping, surfaced unmapped, never a guessed LOINC.",
  *   position: { recordIndex: 3, recordType: "R" },
  * };
  * ```
@@ -3111,15 +3542,15 @@ declare function livdUnmappedCode(position: AstmPosition): AstmLivdWarning;
 declare function livdAmbiguousMapping(position: AstmPosition): AstmLivdWarning;
 
 /**
- * The **additive, advisory** LIVD annotation layer (Phase 9). {@link applyLivd}
+ * The **additive, advisory** LIVD annotation layer. {@link applyLivd}
  * reads a parsed {@link AstmMessage} and a consumer-supplied {@link LivdCatalog}
- * and returns a **separate** layer of per-record LOINC annotations — it **never
+ * and returns a **separate** layer of per-record LOINC annotations: it **never
  * mutates, alters, or drops** the raw reported code or value. Recognition is an
  * annotation, not a rewrite: the wire stays exactly as parsed.
  *
  * **The never-fabricate rule (the safety-critical point).** A vendor code with no
  * single LIVD mapping surfaces as a typed `unmapped`/`ambiguous`/`no-code`
- * annotation — **never** a guessed LOINC. A wrong LOINC mis-identifies a test, so
+ * annotation: **never** a guessed LOINC. A wrong LOINC mis-identifies a test, so
  * the layer only ever reports a LOINC the wire itself carried (an inline LOINC
  * candidate) or one the consumer's catalog vouched for (labeled `derived`), and
  * otherwise reports nothing but the miss.
@@ -3129,14 +3560,14 @@ declare function livdAmbiguousMapping(position: AstmPosition): AstmLivdWarning;
  * The outcome of annotating one record's Universal Test ID against a LIVD catalog.
  * A distinct case per disposition; there is no case in which a LOINC is guessed.
  *
- * - `mapped` — the vendor/local code resolved to a single LOINC **via the catalog**
+ * - `mapped`, the vendor/local code resolved to a single LOINC **via the catalog**
  *   (labeled `derived: true`, `source: "livd"`).
- * - `inline-loinc` — the wire itself carried a LOINC in the Universal Test ID's slot
+ * - `inline-loinc`, the wire itself carried a LOINC in the Universal Test ID's slot
  *   (component 1); surfaced `source: "wire"`, **not** derived and **not** validated.
- * - `unmapped` — a vendor/local code with no catalog entry.
- * - `ambiguous` — a vendor/local code matching more than one distinct LOINC; the
+ * - `unmapped`: a vendor/local code with no catalog entry.
+ * - `ambiguous`: a vendor/local code matching more than one distinct LOINC; the
  *   candidates are surfaced but **none is chosen**.
- * - `no-code` — the record carried no usable test code at all (name-only/empty), so
+ * - `no-code`: the record carried no usable test code at all (name-only/empty), so
  *   there was nothing to map.
  */
 type LivdMapping = {
@@ -3158,7 +3589,7 @@ type LivdMapping = {
     readonly status: "no-code";
 };
 /**
- * One record's LIVD annotation — which record, the code that was looked up
+ * One record's LIVD annotation, which record, the code that was looked up
  * (verbatim), how it was recognized, and the mapping outcome. Additive: it points
  * at the record by index and never replaces it.
  *
@@ -3183,7 +3614,7 @@ interface LivdAnnotation {
     readonly reportedCode?: string;
     /** How the reported code was recognized in the Universal Test ID (provenance only, never a lookup). */
     readonly provenance: UniversalTestIdProvenance;
-    /** The mapping outcome — never a guessed LOINC. */
+    /** The mapping outcome: never a guessed LOINC. */
     readonly mapping: LivdMapping;
 }
 /**
@@ -3194,7 +3625,7 @@ interface LivdAnnotation {
 interface LivdResult {
     /** One annotation per `R`/`O` record, in wire order. */
     readonly annotations: readonly LivdAnnotation[];
-    /** A value-free warning per `unmapped`/`ambiguous` code — never per `mapped`/`inline-loinc`/`no-code`. */
+    /** A value-free warning per `unmapped`/`ambiguous` code: never per `mapped`/`inline-loinc`/`no-code`. */
     readonly warnings: readonly AstmLivdWarning[];
 }
 /**
@@ -3270,7 +3701,7 @@ interface FrameChecksum {
 }
 /**
  * One decoded ASTM frame. `text` is the frame's record-byte payload (the bytes
- * between the frame number and the terminator, escapes untouched — this is the
+ * between the frame number and the terminator, escapes untouched, this is the
  * framing layer, not the record layer). `trusted` is the single flag a consumer
  * gates on: it is `true` only for a fully-terminated frame whose checksum
  * validated, and such frames are the only ones reassembled into `records`.
@@ -3308,7 +3739,7 @@ interface AstmFrame {
  */
 interface DecodeAstmFramesResult {
     /**
-     * The reassembled record byte-strings — one entry per complete record (a run of
+     * The reassembled record byte-strings: one entry per complete record (a run of
      * frames closed by an `ETX`), in wire order. **Only** clean reassemblies appear:
      * a record whose frames included a bad checksum, a sequence gap, or an
      * unterminated frame is **omitted** (its frames are still in {@link DecodeAstmFramesResult.frames},
@@ -3336,16 +3767,16 @@ interface FrameOptions {
  * The value model for the pure LTP protocol reducer ({@link ltpReduce}).
  *
  * The reducer models the **receiver** side of an ASTM/CLSI-LIS01 (LIS01-A2)
- * session — the host/LIS receiving an upload — because that is where the one
+ * session, the host/LIS receiving an upload, because that is where the one
  * safety decision lives: whether to `ACK` (accept) or `NAK` (reject) a frame that
  * just arrived. It is a **pure function** of the current {@link LtpState} and one
  * inbound {@link LtpEvent}, returning an {@link LtpTransition} (the next state plus
  * the actions the consumer should take and any warnings). No sockets, no timers,
- * no I/O — the consumer owns the wire and the clock; the reducer owns the logic.
+ * no I/O: the consumer owns the wire and the clock; the reducer owns the logic.
  */
 
 /**
- * The protocol phase. The line is either **neutral** (idle — awaiting an `ENQ` to
+ * The protocol phase. The line is either **neutral** (idle, awaiting an `ENQ` to
  * establish, or reset there after an `EOT`) or in **transfer** (establishment
  * accepted; frames and their per-frame `ACK`/`NAK` flow until the sender's `EOT`).
  * The classic three-phase LIS01 model (establishment → transfer → termination)
@@ -3383,7 +3814,7 @@ interface LtpState {
     /** `true` when a record is mid-reassembly (an `ETB` frame was accepted, awaiting its `ETX`). */
     readonly recordOpen: boolean;
     /**
-     * The bytes accumulated so far for the in-progress record — the concatenation of
+     * The bytes accumulated so far for the in-progress record: the concatenation of
      * the `ETB` frames accepted since the last `ETX`. Empty when no record is open.
      * These bytes are **never** delivered on their own: only an `ETX` completes a
      * record, at which point they (plus the final frame's text) become one entry in
@@ -3395,7 +3826,7 @@ interface LtpState {
  * An inbound protocol event the consumer feeds the reducer: one of the four LTP
  * control signals (`ENQ`/`ACK`/`NAK`/`EOT`) read off the wire, or a `frame` the
  * consumer already decoded with `decodeAstmFrames` (the reducer reuses the codec's
- * `trusted`/`checksum` verdict — it never re-derives it).
+ * `trusted`/`checksum` verdict, it never re-derives it).
  */
 type LtpEvent = {
     readonly type: "enq";
@@ -3442,14 +3873,14 @@ interface LtpTransition {
  * The pure LTP protocol reducer: {@link ltpReduce} and {@link ltpInitialState}.
  *
  * A deterministic, socket-free receiver-side state machine for ASTM/CLSI-LIS01
- * (LIS01-A2). The consumer owns the wire — it reads bytes, decodes frames with
- * `decodeAstmFrames`, and drives this reducer one {@link LtpEvent} at a time — and
+ * (LIS01-A2). The consumer owns the wire (it reads bytes, decodes frames with
+ * `decodeAstmFrames`, and drives this reducer one {@link LtpEvent} at a time) and
  * the reducer decides, purely, what happens next: whether to `ACK` or `NAK`, when a
  * record is complete, and when the session returns to neutral.
  *
  * **The one inviolable rule (borrowed from `mllp`'s ACK-failsafe discipline):** a
- * frame the codec did not vouch for — a bad checksum, an unterminated frame, or one
- * out of sequence — is answered with `NAK`, **never** a fabricated positive `ACK`,
+ * frame the codec did not vouch for (a bad checksum, an unterminated frame, or one
+ * out of sequence) is answered with `NAK`, **never** a fabricated positive `ACK`,
  * and its bytes are **never** appended to a record or delivered. A `NAK` drives
  * retransmit, not acceptance. This is the protocol-level twin of the frame codec's
  * "a bad-checksum frame is never merged into a record."
@@ -3472,14 +3903,14 @@ interface LtpTransition {
  */
 declare function ltpInitialState(): LtpState;
 /**
- * Advance the LTP session by one inbound event — a pure function, no I/O.
+ * Advance the LTP session by one inbound event: a pure function, no I/O.
  *
  * Behaviour by phase:
- * - **neutral** — `enq` accepts establishment (`sendAck`, enter transfer); `eot` is
+ * - **neutral**: `enq` accepts establishment (`sendAck`, enter transfer); `eot` is
  *   a benign line reset (no-op); `ack`/`nak` are unexpected at a receiver (surfaced,
  *   never read as acceptance); a `frame` before establishment is tolerated
- *   (Postel's Law) — the session auto-establishes and processes it, with a warning.
- * - **transfer** — a `frame` is accepted (`sendAck`, appended, sequence advanced) only
+ *   (Postel's Law), the session auto-establishes and processes it, with a warning.
+ * - **transfer**: a `frame` is accepted (`sendAck`, appended, sequence advanced) only
  *   when it is trusted *and* carries the expected number; a duplicate of the last
  *   accepted frame is idempotently re-`ACK`ed without re-appending; a bad or
  *   out-of-sequence frame is `NAK`ed and dropped. `eot` terminates the transfer and
@@ -3505,18 +3936,18 @@ declare function ltpReduce(state: LtpState, event: LtpEvent): LtpTransition;
  * (was E1381), plus the bare-record-letter set the transport detector keys on.
  *
  * The frame codec (`../frames`) owns the *inside* of a frame (`STX FN text
- * ETB/ETX CS CRLF`); this module owns the *handshake around* frames — the
+ * ETB/ETX CS CRLF`); this module owns the *handshake around* frames, the
  * establishment/transfer/termination signalling that the {@link ltpReduce}
  * reducer consumes. These are the raw byte values; the reducer and the transport
  * detector are the only consumers.
  */
-/** Enquiry (`0x05`) — the sender's request to establish a transfer. */
+/** Enquiry (`0x05`): the sender's request to establish a transfer. */
 declare const ENQ = 5;
-/** Acknowledge (`0x06`) — the receiver accepted the last establishment or frame. */
+/** Acknowledge (`0x06`): the receiver accepted the last establishment or frame. */
 declare const ACK = 6;
-/** Negative acknowledge (`0x15`) — the receiver rejected the last frame; retransmit, do not accept. */
+/** Negative acknowledge (`0x15`): the receiver rejected the last frame; retransmit, do not accept. */
 declare const NAK = 21;
-/** End of transmission (`0x04`) — the sender terminated the transfer; the line returns to neutral. */
+/** End of transmission (`0x04`): the sender terminated the transfer; the line returns to neutral. */
 declare const EOT = 4;
 
 /**
@@ -3530,7 +3961,7 @@ declare const EOT = 4;
  * **both** modes: a bad-checksum frame is surfaced flagged untrusted and **never**
  * merged into a record, and a sequence gap is **never** silently bridged.
  *
- * This is the framing layer only — it does not parse record grammar. Hand a
+ * This is the framing layer only: it does not parse record grammar. Hand a
  * reassembled record to `parseAstmRecords`, or use `parseFramedAstm` to compose
  * both layers at the edge.
  */
@@ -3540,8 +3971,8 @@ declare const EOT = 4;
  *
  * Bytes outside a frame (before the first `STX`, or between a frame's trailing
  * `LF` and the next `STX`) are skipped: in ASTM they are low-level transfer
- * control (`ENQ`/`ACK`/`NAK`/`EOT` — the Phase 6 protocol layer), never record
- * content, so skipping them is not data loss.
+ * control (`ENQ`/`ACK`/`NAK`/`EOT`), never record content, so skipping them is
+ * not data loss.
  *
  * @param bytes - The framed byte stream.
  * @param options - Decode options; lenient unless `strict` is set.
@@ -3551,7 +3982,7 @@ declare const EOT = 4;
  * @example
  * ```ts
  * import { decodeAstmFrames } from "@cosyte/astm";
- * // One final frame carrying the record text "R|1|" — checksum "AF" over FN..ETX (mod 256).
+ * // One final frame carrying the record text "R|1|": checksum "AF" over FN..ETX (mod 256).
  * const bytes = new Uint8Array([0x02, 0x31, 0x52, 0x7c, 0x31, 0x7c, 0x03, 0x41, 0x46, 0x0d, 0x0a]);
  * const { records, frames } = decodeAstmFrames(bytes);
  * frames[0]?.frameNumber; // 1
@@ -3561,10 +3992,10 @@ declare const EOT = 4;
 declare function decodeAstmFrames(bytes: Uint8Array, options?: FrameOptions): DecodeAstmFramesResult;
 
 /**
- * The frame-layer **emit** side: {@link composeAstmFrames} — Phase 7.
+ * The frame-layer **emit** side: {@link composeAstmFrames}.
  *
  * The exact inverse of {@link decodeAstmFrames}. Given the reassembled record
- * byte-strings (one entry per complete record — the same shape `decodeAstmFrames`
+ * byte-strings (one entry per complete record, the same shape `decodeAstmFrames`
  * *produces*), it wraps each into one or more `<STX> FN text <ETB|ETX> CS <CR><LF>`
  * frames, so `decodeAstmFrames(composeAstmFrames(records)).records` reproduces the
  * input records exactly.
@@ -3576,7 +4007,7 @@ declare function decodeAstmFrames(bytes: Uint8Array, options?: FrameOptions): De
  * - the **frame number** `0`–`7`, starting at `1` and rolling over `7 → 0 → 1`,
  *   continuous across every frame in the stream (as the decoder's sequence check
  *   expects);
- * - the **240-byte text split** — a record longer than 240 bytes is split across
+ * - the **240-byte text split**: a record longer than 240 bytes is split across
  *   frames closed by `ETB` (intermediate) with a final `ETX`; the seven framing
  *   control bytes are never counted toward the 240.
  *
@@ -3585,7 +4016,7 @@ declare function decodeAstmFrames(bytes: Uint8Array, options?: FrameOptions): De
  */
 /**
  * Thrown by {@link composeAstmFrames} when the input cannot be framed into a
- * spec-clean stream — an empty record list, or a record with no bytes (a frame
+ * spec-clean stream: an empty record list, or a record with no bytes (a frame
  * must carry a record; an empty one is a structural error, never an empty frame).
  * Carries a stable code + the offending record index, never record bytes.
  *
@@ -3611,12 +4042,12 @@ declare class AstmFrameEncodeError extends Error {
 interface ComposeFramesOptions {
     /**
      * The frame number to start the sequence at (`0`–`7`). Defaults to
-     * {@link FIRST_FRAME_NUMBER} (`1`) — the ASTM convention.
+     * {@link FIRST_FRAME_NUMBER} (`1`): the ASTM convention.
      */
     readonly startFrameNumber?: number;
 }
 /**
- * Frame reassembled record bytes into a spec-clean ASTM/CLSI-LIS01 byte stream —
+ * Frame reassembled record bytes into a spec-clean ASTM/CLSI-LIS01 byte stream:
  * the inverse of {@link decodeAstmFrames}.
  *
  * Each record is split at 240 text bytes into `ETB`-closed intermediate frames
@@ -3643,11 +4074,11 @@ declare function composeAstmFrames(records: readonly (Uint8Array | string)[], op
  * Composing the two layers at the edge: {@link parseFramedAstm}.
  *
  * The framing layer ({@link decodeAstmFrames}) and the record layer
- * (`parseAstmRecords`) share nothing but the payload boundary — a frame carries
+ * (`parseAstmRecords`) share nothing but the payload boundary: a frame carries
  * record bytes; a record knows nothing about frames. This helper joins them at the
  * one point they meet: decode a framed stream into trusted, reassembled record
  * bytes, then parse those bytes into an {@link AstmMessage}. It is deliberately
- * thin — a consumer that already holds de-framed record bytes calls
+ * thin: a consumer that already holds de-framed record bytes calls
  * `parseAstmRecords` directly, and a consumer that only wants frames calls
  * `decodeAstmFrames` directly.
  */
@@ -3684,7 +4115,7 @@ interface FramedAstmResult {
  * @example
  * ```ts
  * import { parseFramedAstm } from "@cosyte/astm";
- * // A single final frame carrying "H|\^&\r" — checksum "E5" over FN..ETX (mod 256).
+ * // A single final frame carrying "H|\^&\r": checksum "E5" over FN..ETX (mod 256).
  * const bytes = new Uint8Array([
  *   0x02, 0x31, 0x48, 0x7c, 0x5c, 0x5e, 0x26, 0x0d, 0x03, 0x45, 0x35, 0x0d, 0x0a,
  * ]);
@@ -3696,7 +4127,7 @@ interface FramedAstmResult {
 declare function parseFramedAstm(bytes: Uint8Array, options?: FrameOptions & AstmParseOptions): FramedAstmResult;
 /**
  * Serialize an ASTM message (or a bare record list) and frame it into a spec-clean
- * byte stream in one call — the inverse of {@link parseFramedAstm}, composing the
+ * byte stream in one call: the inverse of {@link parseFramedAstm}, composing the
  * two emit layers at the edge.
  *
  * Each record is serialized to spec-clean, `CR`-terminated wire text (canonical
@@ -3724,15 +4155,15 @@ declare function serializeFramedAstm(input: AstmMessage | readonly AstmRecord[],
  * The ASTM/CLSI-LIS01 modulo-256 frame checksum.
  *
  * The checksum is the sum, modulo 256, of every byte **after** the `STX` up to
- * and **including** the `ETB`/`ETX` terminator — i.e. the frame number, the record
+ * and **including** the `ETB`/`ETX` terminator: i.e. the frame number, the record
  * text, and the terminator byte. It is carried on the wire as **two hexadecimal
  * characters**. This module computes it (`computeChecksum`), formats it for emit
- * (`toChecksumHex` — always **uppercase**), and reads it back leniently
- * (`parseChecksumHex` — **accepts lowercase**), matching the real-vendor quirk that
+ * (`toChecksumHex`, always **uppercase**), and reads it back leniently
+ * (`parseChecksumHex`, **accepts lowercase**), matching the real-vendor quirk that
  * some analyzers emit a lowercase checksum.
  */
 /**
- * Sum bytes `[start, endInclusive]` of `bytes` modulo 256 — the ASTM frame
+ * Sum bytes `[start, endInclusive]` of `bytes` modulo 256: the ASTM frame
  * checksum span (frame number through the terminator, inclusive).
  *
  * @param bytes - The full decoded byte stream.
@@ -3763,7 +4194,7 @@ declare function toChecksumHex(checksum: number): string;
 /**
  * Read the two-hex-char checksum at `bytes[i0]`/`bytes[i1]`, **case-insensitively**
  * (a lowercase checksum is a tolerated real-vendor quirk). Returns `undefined` when
- * either position is out of range or not a hex digit — the caller then treats the
+ * either position is out of range or not a hex digit: the caller then treats the
  * frame as having no readable declared checksum, never as a match.
  *
  * @param bytes - The full decoded byte stream.
@@ -3780,7 +4211,7 @@ declare function toChecksumHex(checksum: number): string;
 declare function parseChecksumHex(bytes: Uint8Array, i0: number, i1: number): number | undefined;
 
 /**
- * The frame codec's thrown error — the `strict`-mode counterpart to its lenient
+ * The frame codec's thrown error: the `strict`-mode counterpart to its lenient
  * warnings.
  *
  * The frame layer is lenient by default (byte-level deviations become
@@ -3815,37 +4246,55 @@ declare class AstmFrameStrictError extends Error {
 }
 
 /**
- * Public entry point for the `@cosyte/astm` package — the ASTM/CLSI-LIS02
+ * Public entry point for the `@cosyte/astm` package: the ASTM/CLSI-LIS02
  * **record** layer.
  *
  * The north star: hand a de-framed ASTM record stream to {@link parseAstmRecords}
- * and pull a result's value, units, and flag out in one line — lenient on parse
- * (vendor quirks become typed warnings, never silent loss), and — the whole point
- * — **never a confident wrong value**. Delimiters are read from each header,
+ * and pull a result's value, units, and flag out in one line. Parsing is lenient
+ * (vendor quirks become typed warnings, never silent loss) and, the whole point,
+ * **never returns a confident wrong value**. Delimiters are read from each header,
  * embedded escapes are decoded before a value is split, the practice- and
  * laboratory-assigned patient IDs stay distinct, and every deviation is a stable,
- * value-free warning. Result flag/status semantics (P2), patient/order identity
- * depth + the `C` comment record + partial-timestamp hardening (P3), and the
+ * value-free warning. Result flag/status semantics, patient/order identity
+ * depth + the `C` comment record + partial-timestamp hardening, and the
  * request-information (`Q`) record + host-query classification + verbatim `M`/`S`
- * records (P4) are all modeled — the **record-content layer is now feature-complete**.
+ * records are all modeled: the **record-content layer is now feature-complete**.
+ *
+ * A parsed model is a whole record **stream**, and a stream may carry several `H` … `L`
+ * messages. {@link messages} splits it into them, so a patient and a result are only ever
+ * paired inside the message that carried both; the flat extractors ({@link patient},
+ * {@link results}, …) read the whole stream and therefore **refuse** one they cannot answer
+ * for, with an {@link AstmAmbiguousStreamError}, rather than answering across patients.
  *
- * The E1381/CLSI-LIS01 **framing** layer (P5) lives alongside the record layer and
+ * The E1381/CLSI-LIS01 **framing** layer lives alongside the record layer and
  * shares nothing but the payload boundary: {@link decodeAstmFrames} decodes a framed
  * byte stream (`<STX> FN text <ETB|ETX> CS <CR><LF>`) into frames + reassembled
- * record bytes — verifying the modulo-256 checksum (a bad frame is surfaced
+ * record bytes: verifying the modulo-256 checksum (a bad frame is surfaced
  * untrusted, never merged), tracking frame-number sequencing (a gap is never
  * silently bridged), and reassembling the 240-byte-limited multi-frame records.
  * {@link parseFramedAstm} composes the two layers at the edge.
  *
- * The LTP **protocol** layer (P6) sits above the frame codec: {@link detectFraming}
- * auto-detects the transport reality — framed (serial / cobas 4800 / Iguana) vs raw
- * (cobas b121, framing dropped) — from the stream's leading byte, and
+ * The LTP **protocol** layer sits above the frame codec: {@link detectFraming}
+ * auto-detects the transport reality from the stream's leading byte, framed
+ * (serial / cobas 4800 / Iguana) vs raw (cobas b121, framing dropped).
  * {@link ltpReduce} is a **pure, socket-free** receiver-side state machine over
  * `ENQ`/`ACK`/`NAK`/`EOT` + frame-received events. The consumer owns the wire; the
  * reducer decides. Its inviolable rule mirrors `mllp`'s ACK-failsafe: a frame the
  * codec did not vouch for is answered with `NAK`, **never** a fabricated positive
- * `ACK`, and never merged into a record — a `NAK` drives retransmit, not acceptance.
- * Serialize/build (P7) is deferred.
+ * `ACK`, and never merged into a record, a `NAK` drives retransmit, not acceptance.
+ *
+ * The **emit** half is the conservative inverse of the record and framing layers.
+ * {@link buildAstmMessage} constructs records from typed caller input, emitting only
+ * the values the caller supplied; {@link serializeAstmRecords} writes them out with the
+ * canonical `H|\^&` delimiters by default, re-escaping every embedded delimiter in a
+ * decoded component leaf (every record type is emitted from its decoded `fields`, except that
+ * `M`/`S` bytes pass through untouched when they already read correctly under the emit set, so
+ * an edit to the model is reflected on emit and the whole stream goes out in the one
+ * delimiter set the header declares); {@link composeAstmFrames} wraps them into frames whose
+ * modulo-256 checksum is
+ * computed rather than accepted; and {@link serializeFramedAstm} composes the last two.
+ * The protocol layer has no emit inverse by design: {@link ltpReduce} returns the actions
+ * to take, and the consumer owns the wire.
  */
 /**
  * Library version string, kept in lockstep with `package.json#version`.
@@ -3863,4 +4312,4 @@ declare class AstmFrameStrictError extends Error {
  */
 declare const VERSION: string;
 
-export { ALL_ASTM_WARNING_CODES, ACK as ASTM_ACK, ENQ as ASTM_ENQ, EOT as ASTM_EOT, NAK as ASTM_NAK, type AbnormalFlag, type AbnormalFlagCode, type AbnormalFlagMeaning, type AnyAstmWarningCode, type AstmDate, type AstmDatePrecision, type AstmField, type AstmFrame, AstmFrameEncodeError, type AstmFramePosition, AstmFrameStrictError, type AstmFrameWarning, type AstmFraming, type AstmLivdWarning, type AstmLtpWarning, type AstmMessage, type AstmMessageClassification, type AstmMessageKind, AstmParseError, type AstmParseOptions, type AstmPosition, type AstmProfile, AstmProfileDefinitionError, type AstmProfileProvenance, type AstmQuirkMatch, type AstmQuirkTolerance, type AstmRecord, type AstmRecordInput, type AstmRecordWarning, AstmSerializeError, AstmStrictError, CANONICAL_DELIMITERS, type CommentInput, type CommentRecord, type ComposeFramesOptions, type DecodeAstmFramesResult, type DefineAstmProfileOptions, type Delimiters, type DetectFramingOptions, type DetectFramingResult, FATAL_CODES, FRAME_WARNING_CODES, type FatalCode, type FrameChecksum, type FrameOptions, type FrameTerminator, type FrameWarningCode, type FramedAstmResult, type HeaderInput, type HeaderRecord, LIVD_WARNING_CODES, LTP_WARNING_CODES, type LivdAnnotation, type LivdCatalog, type LivdEntry, type LivdLookup, type LivdMapping, type LivdResult, type LivdWarningCode, type LtpAction, type LtpEvent, type LtpPhase, type LtpState, type LtpTransition, type LtpWarningCode, type ManufacturerRecord, type MessageInput, type OrderInput, type OrderRecord, type PatientInput, type PatientName, type PatientNameInput, type PatientRecord, type QueryInput, type QueryRecord, type ReferenceRange, type ReferenceRangeKind, type ResultInput, type ResultRecord, type ResultStatus, type ResultStatusCode, type ResultStatusMeaning, SAFETY_CRITICAL_CODES, type ScientificRecord, TOLERABLE_CODES, type TerminatorRecord, type UniversalTestId, type UniversalTestIdProvenance, type UnknownEscapeSink, type UnsupportedRecord, VERSION, type VerbatimInput, WARNING_CODES, type WarningCode, ambiguousMessageKind, ambiguousValueSplit, applyAstmProfile, applyAstmProfileToWarnings, applyLivd, astmDateToLocalISO, astmProfiles, attachComments, buildAstmMessage, classifyMessage, comments, commentsFor, composeAstmFrames, computeChecksum, decodeAstmFrames, decodeEscapes, deepFreeze, defineAstmProfile, defineLivdCatalog, detectFraming, encodeComponent, fieldScalar, frameBadChecksum, frameOversize, frameSequenceGap, frameUnterminated, getAstmProfile, getDefaultAstmProfile, interpretAbnormalFlag, interpretResultStatus, isNonStandard, isSafetyCriticalCode, listAstmProfiles, livdAmbiguousMapping, livdUnmappedCode, lookupLivdForRecord, ltpAmbiguousTransport, ltpFrameRejected, ltpInitialState, ltpReduce, ltpUnexpectedEvent, nonStandardDelimiters, orders, orphanComment, parseAstmDate, parseAstmRecords, parseChecksumHex, parseFramedAstm, parseReferenceRange, partialTimestamp, patient, primaryCode, profileQuirkApplied, query, readDelimiters, recognizeUniversalTestId, resolveProfileTransport, results, serializeAstmRecord, serializeAstmRecords, serializeField, serializeFramedAstm, setDefaultAstmProfile, splitEscapeAware, toChecksumHex, tokenizeRecord, undefinedAbnormalFlag, undefinedResultStatus, uninterpretedQueryStatus, unitsAbsent, unknownEscapeSequence, unknownRecordType, unparseableReferenceRange };
+export { ALL_ASTM_WARNING_CODES, AMBIGUOUS_CODES, ACK as ASTM_ACK, ENQ as ASTM_ENQ, EOT as ASTM_EOT, NAK as ASTM_NAK, type AbnormalFlag, type AbnormalFlagCode, type AbnormalFlagMeaning, type AmbiguousCode, type AnyAstmWarningCode, AstmAmbiguousStreamError, type AstmDate, type AstmDatePrecision, type AstmField, type AstmFrame, AstmFrameEncodeError, type AstmFramePosition, AstmFrameStrictError, type AstmFrameWarning, type AstmFraming, type AstmLivdWarning, type AstmLtpWarning, type AstmMessage, type AstmMessageClassification, type AstmMessageKind, AstmParseError, type AstmParseOptions, type AstmPosition, type AstmProfile, AstmProfileDefinitionError, type AstmProfileProvenance, type AstmQuirkMatch, type AstmQuirkTolerance, type AstmRecord, type AstmRecordInput, type AstmRecordWarning, AstmSerializeError, type AstmSerializeErrorCode, type AstmStreamMessage, AstmStrictError, CANONICAL_DELIMITERS, type CommentInput, type CommentRecord, type ComposeFramesOptions, type DecodeAstmFramesResult, type DefineAstmProfileOptions, type Delimiters, type DetectFramingOptions, type DetectFramingResult, FATAL_CODES, FRAME_WARNING_CODES, type FatalCode, type FrameChecksum, type FrameOptions, type FrameTerminator, type FrameWarningCode, type FramedAstmResult, type HeaderInput, type HeaderRecord, LIVD_WARNING_CODES, LTP_WARNING_CODES, type LivdAnnotation, type LivdCatalog, type LivdEntry, type LivdLookup, type LivdMapping, type LivdResult, type LivdWarningCode, type LtpAction, type LtpEvent, type LtpPhase, type LtpState, type LtpTransition, type LtpWarningCode, type ManufacturerRecord, type MessageInput, type OrderInput, type OrderRecord, type PatientInput, type PatientName, type PatientNameInput, type PatientRecord, type QueryInput, type QueryRecord, type ReferenceRange, type ReferenceRangeKind, type ResultInput, type ResultRecord, type ResultStatus, type ResultStatusCode, type ResultStatusMeaning, SAFETY_CRITICAL_CODES, type ScientificRecord, TOLERABLE_CODES, type TerminatorRecord, type UniversalTestId, type UniversalTestIdProvenance, type UnknownEscapeSink, type UnsupportedRecord, VERSION, type VerbatimInput, WARNING_CODES, type WarningCode, ambiguousMessageKind, ambiguousValueSplit, applyAstmProfile, applyAstmProfileToWarnings, applyLivd, astmDateToLocalISO, astmProfiles, attachComments, buildAstmMessage, classifyMessage, comments, commentsFor, composeAstmFrames, computeChecksum, decodeAstmFrames, decodeEscapes, deepFreeze, defineAstmProfile, defineLivdCatalog, delimitersRedeclared, detectFraming, encodeComponent, fieldScalar, frameBadChecksum, frameOversize, frameSequenceGap, frameUnterminated, getAstmProfile, getDefaultAstmProfile, interpretAbnormalFlag, interpretResultStatus, isNonStandard, isSafetyCriticalCode, listAstmProfiles, livdAmbiguousMapping, livdUnmappedCode, lookupLivdForRecord, ltpAmbiguousTransport, ltpFrameRejected, ltpInitialState, ltpReduce, ltpUnexpectedEvent, messages, nonStandardDelimiters, orders, orphanComment, parseAstmDate, parseAstmRecords, parseChecksumHex, parseFramedAstm, parseReferenceRange, partialTimestamp, patient, primaryCode, profileQuirkApplied, query, readDelimiters, recognizeUniversalTestId, resolveProfileTransport, results, serializeAstmRecord, serializeAstmRecords, serializeField, serializeFramedAstm, setDefaultAstmProfile, splitEscapeAware, toChecksumHex, tokenizeHeader, tokenizeRecord, undefinedAbnormalFlag, undefinedResultStatus, uninterpretedQueryStatus, unitsAbsent, unknownEscapeSequence, unknownRecordType, unparseableReferenceRange, unreadableRedeclaration };