@cosyte/astm 0.0.4 → 0.0.5

package/dist/index.d.cts

@@ -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,25 +84,25 @@ 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.
      */
@@ -111,7 +111,7 @@ declare const WARNING_CODES: {
      * 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.
+     * 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
@@ -120,13 +120,13 @@ declare const WARNING_CODES: {
      */
     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
+     * 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.
+     * `ASTM_RECORD_UNDECLARED_DELIMITERS` fatal: there is no earlier set to fall back to.
      */
     readonly ASTM_RECORD_UNREADABLE_REDECLARATION: "ASTM_RECORD_UNREADABLE_REDECLARATION";
     /**
@@ -134,7 +134,7 @@ declare const WARNING_CODES: {
      * (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.
@@ -170,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;
 }
@@ -206,7 +206,7 @@ declare function nonStandardDelimiters(position: AstmPosition): AstmRecordWarnin
 /**
  * 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
+ * honored from that header onward. Positional context only: never the delimiters
  * themselves.
  *
  * @example
@@ -242,7 +242,7 @@ declare function unreadableRedeclaration(position: AstmPosition): AstmRecordWarn
 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
@@ -346,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
@@ -373,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|\^&`:
@@ -405,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
@@ -430,14 +430,14 @@ 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 `undefined` when the record cannot declare all four delimiters — it is
+ * 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
+ * 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.
  *
@@ -468,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. */
@@ -482,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
@@ -504,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.
      */
@@ -516,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.
  *
@@ -535,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.
  *
@@ -556,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
@@ -568,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";
@@ -591,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;
@@ -617,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`.
@@ -633,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.
@@ -659,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
@@ -689,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.
      */
@@ -708,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";
@@ -785,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**.
  */
@@ -809,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
@@ -838,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
@@ -846,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,
  * };
  * ```
@@ -901,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";
 /**
@@ -925,7 +925,7 @@ 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 vendor profile forces raw for
+     * 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;
@@ -975,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
@@ -984,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
@@ -1025,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;
@@ -1035,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
@@ -1072,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;
@@ -1082,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
@@ -1097,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."
      */
@@ -1150,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
@@ -1202,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.
@@ -1216,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";
@@ -1232,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
@@ -1255,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.
@@ -1284,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";
@@ -1296,7 +1296,7 @@ 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. Anything that does not match these
@@ -1326,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.
  *
@@ -1349,7 +1349,7 @@ 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.
  *
  * `H`/`P`/`O`/`R`/`C`/`Q`/`M`/`S`/`L` are modeled; every other type letter is an
@@ -1388,7 +1388,7 @@ interface RecordBase {
 interface HeaderRecord extends RecordBase {
     readonly type: "H";
     /**
-     * The four delimiters **this** header put into force — the set its own fields, and every record
+     * 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
@@ -1403,7 +1403,7 @@ interface HeaderRecord extends RecordBase {
      * 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
+     * {@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.
      */
@@ -1422,63 +1422,63 @@ 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.
@@ -1486,94 +1486,94 @@ interface OrderRecord extends RecordBase {
  * (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;
@@ -1582,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]`**
  * 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
+     * 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
+     * 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**.
  *
@@ -1647,7 +1647,7 @@ interface ManufacturerRecord extends RecordBase {
      * 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
+     * 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
@@ -1656,7 +1656,7 @@ interface ManufacturerRecord extends RecordBase {
     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}).
  */
@@ -1666,7 +1666,7 @@ interface ScientificRecord extends RecordBase {
      * 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
+     * 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
@@ -1675,7 +1675,7 @@ interface ScientificRecord extends RecordBase {
     readonly rawLine: string;
 }
 /**
- * The `L` (terminator) record — closes a message.
+ * The `L` (terminator) record: closes a message.
  */
 interface TerminatorRecord extends RecordBase {
     readonly type: "L";
@@ -1684,7 +1684,7 @@ interface TerminatorRecord extends RecordBase {
  * Any record whose type letter is not modeled (a genuinely unknown letter).
  * `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.
+ * `ASTM_RECORD_UNKNOWN_TYPE` warning, never dropped.
  */
 interface UnsupportedRecord extends RecordBase {
     readonly type: "unsupported";
@@ -1696,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 {
@@ -1732,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;
@@ -1758,12 +1758,12 @@ interface AstmMessage {
      *
      * 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
+     * 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.
@@ -1771,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
@@ -1789,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;
@@ -1809,7 +1809,7 @@ interface AstmParseOptions {
  * 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
+ * {@link AstmMessage}, lenient by default: vendor quirks become typed warnings, and
  * only three unrecoverable structural conditions are fatal.
  */
 
@@ -1838,7 +1838,7 @@ 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. 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.
@@ -1847,7 +1847,7 @@ declare class AstmStrictError extends Error {
  * 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
+ * `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.
  *
@@ -1867,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.
  *
@@ -1901,19 +1901,19 @@ declare function attachComments(records: readonly AstmRecord[], warnings: AstmRe
  * each record with a `CR`.
  *
  * **Round-trip.** `parseAstmRecords(serializeAstmRecords(msg))` reproduces the modeled
- * records — the same components, the same typed accessors, and the canonical delimiter
+ * 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` —
+ * **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
+ * 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
@@ -1921,7 +1921,7 @@ declare function attachComments(records: readonly AstmRecord[], warnings: AstmRe
  * 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
+ * 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
@@ -1935,19 +1935,19 @@ declare function attachComments(records: readonly AstmRecord[], warnings: AstmRe
  * 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
+ * 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
+ * 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).
@@ -1978,9 +1978,9 @@ declare class AstmSerializeError extends Error {
 /**
  * The reasons emit refuses rather than writing a stream that cannot be read back.
  *
- * - `ASTM_EMIT_UNENCODABLE_VALUE` — a component holds a record terminator
+ * - `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
+ * - `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.
@@ -1993,7 +1993,7 @@ declare class AstmSerializeError extends Error {
  */
 type AstmSerializeErrorCode = "ASTM_EMIT_UNENCODABLE_VALUE" | "ASTM_EMIT_INVALID_DELIMITERS";
 /**
- * Escape-encode one component leaf for spec-clean emit — the inverse of
+ * 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
@@ -2009,7 +2009,7 @@ type AstmSerializeErrorCode = "ASTM_EMIT_UNENCODABLE_VALUE" | "ASTM_EMIT_INVALID
  * @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
+ *   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
@@ -2023,8 +2023,8 @@ 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** declaration of `d`, never escaped — escaping it would corrupt the
- * very declaration a reader depends on — followed by any characters the modeled
+ * 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
@@ -2035,7 +2035,7 @@ declare function encodeComponent(leaf: string, d: Delimiters, recordIndex?: numb
  * @returns The record's wire text, terminator excluded.
  * @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
+ *   readback requires (`ASTM_EMIT_INVALID_DELIMITERS`): necessary conditions, not
  *   sufficient ones, so a set can pass them and still not reverse.
  * @example
  * ```ts
@@ -2047,11 +2047,11 @@ 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 — every
+ * 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
@@ -2060,11 +2060,11 @@ declare function serializeAstmRecord(record: AstmRecord, d?: Delimiters): string
  *
  * **`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
+ * 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 —
+ * `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
@@ -2075,7 +2075,7 @@ declare function serializeAstmRecord(record: AstmRecord, d?: Delimiters): string
  * @returns The serialized record stream (`CR` after every record).
  * @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
+ *   readback requires (`ASTM_EMIT_INVALID_DELIMITERS`): necessary conditions, not
  *   sufficient ones, so a set can pass them and still not reverse.
  * @example
  * ```ts
@@ -2095,7 +2095,7 @@ declare function serializeAstmRecords(input: AstmMessage | readonly AstmRecord[]
  * @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
+ *   readback requires (`ASTM_EMIT_INVALID_DELIMITERS`): necessary conditions, not
  *   sufficient ones, so a set can pass them and still not reverse.
  * @example
  * ```ts
@@ -2114,13 +2114,13 @@ declare function serializeField(field: AstmField, d?: Delimiters): string;
  *
  * - **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
@@ -2133,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 {
@@ -2246,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.
      */
@@ -2258,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.
@@ -2278,7 +2278,7 @@ 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 and immutable: they read the already-parsed model and never re-parse,
@@ -2287,7 +2287,7 @@ declare function buildAstmMessage(input: MessageInput): string;
  * **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 —
+ * 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
@@ -2303,7 +2303,7 @@ declare function buildAstmMessage(input: MessageInput): string;
  * @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}.
+ *   carries more than one message: see {@link messages}.
  * @example
  * ```ts
  * import { parseAstmRecords, results } from "@cosyte/astm";
@@ -2318,7 +2318,7 @@ declare function results(msg: AstmMessage): readonly ResultRecord[];
  * 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.
+ * both, the old behaviour, the first `P` in the stream, is the wrong-patient path itself.
  *
  * @param msg - A parsed single-message stream carrying at most one patient.
  * @returns The patient record, or `undefined` when the message carries none.
@@ -2339,7 +2339,7 @@ declare function patient(msg: AstmMessage): PatientRecord | undefined;
  * @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}.
+ *   carries more than one message: see {@link messages}.
  * @example
  * ```ts
  * import { parseAstmRecords, orders } from "@cosyte/astm";
@@ -2351,12 +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 **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}.
+ *   carries more than one message: see {@link messages}.
  * @example
  * ```ts
  * import { parseAstmRecords, comments } from "@cosyte/astm";
@@ -2371,7 +2371,7 @@ declare function comments(msg: AstmMessage): readonly CommentRecord[];
  * 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.
@@ -2387,13 +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 **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}.
+ *   carries more than one message: see {@link messages}.
  * @example
  * ```ts
  * import { parseAstmRecords, query } from "@cosyte/astm";
@@ -2404,13 +2404,13 @@ 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.
+ * 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
+ * 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.
  *
@@ -2431,20 +2431,20 @@ declare function query(msg: AstmMessage): readonly QueryRecord[];
  * 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
+ * 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
+ * **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
+ * {@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
+ * 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
@@ -2478,11 +2478,11 @@ declare const AMBIGUOUS_CODES: {
     /** 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}. */
+/** 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
+ * 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
@@ -2506,7 +2506,7 @@ type AmbiguousCode = (typeof AMBIGUOUS_CODES)[keyof typeof AMBIGUOUS_CODES];
  * ```
  */
 declare class AstmAmbiguousStreamError extends Error {
-    /** The stable discriminant — see {@link AMBIGUOUS_CODES}. */
+    /** 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;
@@ -2532,7 +2532,7 @@ interface AstmStreamMessage {
     /** 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 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.
      */
@@ -2540,7 +2540,7 @@ interface AstmStreamMessage {
     /** 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`
+     * 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.
      *
@@ -2600,14 +2600,14 @@ declare function messages(msg: AstmMessage): readonly AstmStreamMessage[];
  * 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
@@ -2686,7 +2686,7 @@ declare function tokenizeHeader(record: string, d: Delimiters, onUnknownEscape?:
 /**
  * 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
@@ -2705,7 +2705,7 @@ declare function fieldScalar(field: AstmField | undefined): string | undefined;
  * `AstmParseError` is thrown directly and consumers narrow via the `code`
  * 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
+ * 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
@@ -2730,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];
 /**
@@ -2774,7 +2774,7 @@ declare class AstmParseError extends Error {
 }
 
 /**
- * The ASTM escape codec — the 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 against
@@ -2788,12 +2788,12 @@ 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.
@@ -2832,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
@@ -2877,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
@@ -2892,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).
  *
@@ -2925,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
@@ -2976,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`.
@@ -3011,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.
@@ -3044,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),
@@ -3076,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.
@@ -3090,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."
  *
@@ -3108,11 +3108,11 @@ 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
@@ -3123,32 +3123,32 @@ declare function resolveProfileTransport(profile: AstmProfile | undefined): Astm
  *
  * 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
@@ -3174,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}.
  *
@@ -3187,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).
@@ -3205,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.
  */
 
@@ -3229,13 +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):
  *
- * - **`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
@@ -3247,15 +3247,15 @@ declare const defaultProfile: AstmProfile;
  *   names) that our **escape-aware** tokenizer flags as
  *   `ASTM_UNKNOWN_ESCAPE_SEQUENCE`. We are deliberately stricter than the OSS
  *   references here, so the warning is *expected*
- *   noise when talking to that ecosystem — recognizable and non-clinical.
+ *   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
@@ -3265,7 +3265,7 @@ declare const defaultProfile: AstmProfile;
 
 /**
  * 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
@@ -3285,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).
  */
 
@@ -3295,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
@@ -3315,17 +3315,17 @@ declare const astmProfiles: {
  * from an IICC LIVD ("LOINC to Vendor IVD") mapping the consumer provides.
  *
  * **Bring-your-own, by design.** `@cosyte/astm` bundles
- * **no** LOINC, SNOMED, or LIVD data — LOINC is © Regenstrief (redistributable
+ * **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, and this module lets a consumer
- * *supply* their own LIVD file to map those codes — the terminology data, and its
+ * *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
@@ -3342,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.
  *
@@ -3354,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;
@@ -3376,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.
  */
@@ -3387,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[];
@@ -3407,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.
@@ -3443,13 +3443,13 @@ declare function defineLivdCatalog(entries: readonly LivdEntry[]): LivdCatalog;
 
 /**
  * The **terminology** warning registry (`ASTM_LIVD_*`) for the LIVD-aware LOINC
- * recognition layer — the fourth of the package's registries,
+ * 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
@@ -3460,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.
  */
 
@@ -3477,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";
@@ -3503,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" },
  * };
  * ```
@@ -3544,13 +3544,13 @@ declare function livdAmbiguousMapping(position: AstmPosition): AstmLivdWarning;
 /**
  * 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.
@@ -3560,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 = {
@@ -3589,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.
  *
@@ -3614,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;
 }
 /**
@@ -3625,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[];
 }
 /**
@@ -3701,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`.
@@ -3739,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},
@@ -3767,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)
@@ -3814,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
@@ -3826,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";
@@ -3873,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."
@@ -3903,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
@@ -3936,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;
 
 /**
@@ -3961,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.
  */
@@ -3982,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
@@ -3995,7 +3995,7 @@ declare function decodeAstmFrames(bytes: Uint8Array, options?: FrameOptions): De
  * 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.
@@ -4007,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.
  *
@@ -4016,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.
  *
@@ -4042,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
@@ -4074,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.
  */
@@ -4115,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,
  * ]);
@@ -4127,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
@@ -4155,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.
@@ -4194,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.
@@ -4211,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
@@ -4246,19 +4246,19 @@ 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, patient/order identity
  * depth + the `C` comment record + partial-timestamp hardening, and the
  * request-information (`Q`) record + host-query classification + verbatim `M`/`S`
- * records 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
@@ -4269,19 +4269,19 @@ declare class AstmFrameStrictError extends Error {
  * 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 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
+ * 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.
+ * `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