@cosyte/astm 0.0.3 → 0.0.4

package/dist/index.d.ts

@@ -107,6 +107,28 @@ declare const WARNING_CODES: {
      * 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
@@ -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
@@ -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).
@@ -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;
 }
@@ -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.**
  *
@@ -1244,7 +1299,7 @@ type ReferenceRangeKind = "closed" | "open-low" | "open-high" | "unparsed";
  * **`[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
@@ -1297,10 +1352,9 @@ declare function parseReferenceRange(raw: string): ReferenceRange;
  * 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;
 }
@@ -1417,7 +1482,7 @@ interface OrderRecord extends RecordBase {
  *
  * 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
@@ -1529,7 +1594,7 @@ interface CommentRecord extends RecordBase {
  * 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. */
@@ -1559,7 +1624,7 @@ interface QueryRecord extends RecordBase {
     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
+     * **`[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.
@@ -1578,7 +1643,16 @@ 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;
 }
 /**
@@ -1588,7 +1662,16 @@ interface ManufacturerRecord extends RecordBase {
  */
 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;
 }
 /**
@@ -1599,8 +1682,8 @@ interface TerminatorRecord extends RecordBase {
 }
 /**
  * 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
+ * `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 {
@@ -1667,8 +1750,17 @@ 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`
@@ -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).
@@ -1789,28 +1891,58 @@ 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.
  */
 
 /**
@@ -1832,13 +1964,34 @@ 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);
 }
+/**
+ * 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&`)
@@ -1847,12 +2000,17 @@ declare class AstmSerializeError extends Error {
  * 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";
@@ -1888,12 +2051,32 @@ declare function serializeAstmRecord(record: AstmRecord, d?: Delimiters): string
  *
  * 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,7 +2107,7 @@ 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:
@@ -2094,17 +2281,29 @@ declare function buildAstmMessage(input: MessageInput): string;
  * 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";
@@ -2147,8 +2353,10 @@ declare function orders(msg: AstmMessage): readonly OrderRecord[];
  * `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.
  *
- * @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,6 +2367,9 @@ 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 —
  * never floated to the wrong one.
@@ -2179,8 +2390,10 @@ declare function commentsFor(msg: AstmMessage, parent: AstmRecord): readonly Com
  * 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
@@ -2254,6 +2653,36 @@ 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
@@ -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.
  */
 
 /**
@@ -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 "|")
@@ -2365,8 +2798,8 @@ declare class AstmParseError extends Error {
  * 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.
  */
 
 /**
@@ -2683,7 +3116,7 @@ declare function resolveProfileTransport(profile: AstmProfile | undefined): Astm
  * 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.
@@ -2800,8 +3233,7 @@ declare const defaultProfile: AstmProfile;
  * 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` /
  *   `decode_component` / `decode_repeated_component` split fields, components, and
@@ -2814,7 +3246,7 @@ 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*
+ *   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
@@ -2828,8 +3260,7 @@ declare const defaultProfile: AstmProfile;
  *
  * **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.
  */
 
 /**
@@ -2883,13 +3314,13 @@ 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
+ * **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
+ * 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.
  *
@@ -3011,8 +3442,8 @@ 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_*`.
  *
@@ -3111,7 +3542,7 @@ 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
  * mutates, alters, or drops** the raw reported code or value. Recognition is an
@@ -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.
@@ -3561,7 +3992,7 @@ 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`
@@ -3824,12 +4255,18 @@ declare class AstmFrameStrictError extends Error {
  * — **never 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
@@ -3837,7 +4274,7 @@ declare class AstmFrameStrictError extends Error {
  * 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}
+ * The LTP **protocol** layer 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
  * {@link ltpReduce} is a **pure, socket-free** receiver-side state machine over
@@ -3845,7 +4282,19 @@ declare class AstmFrameStrictError extends Error {
  * 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.
+ *
+ * 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 };