@cosyte/astm 0.0.4 → 0.0.5

package/README.md

@@ -1,6 +1,6 @@
 # @cosyte/astm
 
-> ASTM parser, serializer, and builder for Node.js and TypeScript — **lenient on parse,
+> ASTM parser, serializer, and builder for Node.js and TypeScript: **lenient on parse,
 > spec-clean on emit**.
 
 `@cosyte/astm` is a zero-dependency TypeScript toolkit that follows the cosyte parser archetype: a lenient
@@ -32,8 +32,8 @@ reference parser, [`@cosyte/hl7`](https://github.com/cosyte/hl7).
 - **Emit.** `serializeAstmRecords` and `buildAstmMessage` emit canonical `H|\^&` records with embedded
   delimiters re-escaped and nothing clinical fabricated; `composeAstmFrames` and `serializeFramedAstm`
   frame them with computed checksums, frame numbers, and the 240-byte split. Both layers round-trip by
-  construction, and a delimiter set that fails any of the three conditions readback requires — one
-  character per separator, no `CR`/`LF`, no two the same — is a typed error rather than bytes written
+  construction, and a delimiter set that fails any of the three conditions readback requires (one
+  character per separator, no `CR`/`LF`, no two the same) is a typed error rather than bytes written
   and lost.
 - **Vendor profiles.** `defineAstmProfile()` builds a provenance-backed profile whose tolerances
   downgrade _expected_, non-safety-critical deviations to a `PROFILE_QUIRK_APPLIED` warning without
@@ -69,7 +69,7 @@ A checksum mismatch, a sequence gap, an unterminated frame, and an oversize (>24
 ## Drive the transport (framed vs raw) + the LTP protocol
 
 ASTM transport is not uniform: **serial** always frames, but over **TCP it varies within a single
-vendor** — the cobas 4800 and Iguana keep the full `ENQ`/`ACK` + `STX`/checksum framing, while the
+vendor**, the cobas 4800 and Iguana keep the full `ENQ`/`ACK` + `STX`/checksum framing, while the
 cobas b121 drops it and streams de-framed record bytes directly. Detect which you have, then drive the
 pure protocol reducer with your own socket I/O.
 
@@ -85,7 +85,7 @@ import {
 // 1. Route by the stream's leading byte (STX/ENQ ⇒ framed; a bare record letter ⇒ raw).
 const { framing } = detectFraming(leadingBytes); // "framed" | "raw"  (override: { override: "raw" })
 if (framing === "raw") {
-  // cobas b121 raw-TCP: no handshake, no frames — parse the record bytes directly.
+  // cobas b121 raw-TCP: no handshake, no frames, parse the record bytes directly.
   parseAstmRecords(rawBytes);
 }
 
@@ -95,19 +95,19 @@ function onControlOrFrame(event) {
   const { state: next, actions, warnings } = ltpReduce(state, event);
   state = next;
   for (const a of actions) {
-    if (a.type === "sendAck") socket.write(Uint8Array.of(0x06)); // ACK  — only ever for a good frame
-    if (a.type === "sendNak") socket.write(Uint8Array.of(0x15)); // NAK  — bad checksum ⇒ retransmit
+    if (a.type === "sendAck") socket.write(Uint8Array.of(0x06)); // ACK, only ever for a good frame
+    if (a.type === "sendNak") socket.write(Uint8Array.of(0x15)); // NAK, bad checksum ⇒ retransmit
     if (a.type === "deliverRecord") parseAstmRecords(a.record); // a complete, trusted record
   }
-  void warnings; // ASTM_LTP_* — value-free (a code + at most a frame number)
+  void warnings; // ASTM_LTP_*, value-free (a code + at most a frame number)
 }
 // Feed events as you read them: { type: "enq" }, { type: "frame", frame: decodeAstmFrames(b).frames[0] }, …
 ```
 
 The reducer is deterministic and fully testable without a socket. Its inviolable rule: a frame the
-codec did not vouch for — bad checksum, unterminated, or out of sequence — yields `sendNak`, **never** a
+codec did not vouch for (bad checksum, unterminated, or out of sequence) yields `sendNak`, **never** a
 fabricated `sendAck`, and is **never** appended to a record. A `NAK` drives retransmit, not acceptance.
-The interactive contention/timeout/retransmit **timing** is the consumer's — this layer models the
+The interactive contention/timeout/retransmit **timing** is the consumer's: this layer models the
 state transitions, not the wall-clock timers.
 
 ## Install
@@ -130,7 +130,7 @@ patient(msg)?.practiceAssignedId; // kept distinct from laboratoryAssignedId (th
 msg.warnings; // stable, value-free positional tolerance warnings (never throws on quirks)
 ```
 
-The parser is **lenient by default** — vendor quirks become warnings, not failures — and refuses to
+The parser is **lenient by default** (vendor quirks become warnings, not failures) and refuses to
 produce a confident wrong value: an embedded escaped delimiter reads as one component, an unknown
 record type is surfaced (never dropped), and a missing unit is flagged (never defaulted). A
 `{ strict: true }` mode escalates every tolerated deviation to a thrown error.
@@ -138,7 +138,7 @@ record type is surfaced (never dropped), and a missing unit is flagged (never de
 ### Several messages in one stream
 
 A message runs from its `H` header to its `L` terminator, so a stream can carry several. `messages()`
-splits a parsed stream into them, and each entry carries only its own records — so a patient is only
+splits a parsed stream into them, and each entry carries only its own records, so a patient is only
 ever paired with the results that message actually carried:
 
 ```ts
@@ -168,7 +168,7 @@ already names the message.
 ## Map local codes to LOINC (LIVD, bring-your-own)
 
 An analyzer sends a proprietary local test code in the Universal Test ID; a standard LOINC is mapped
-downstream. Supply your own IICC LIVD ("LOINC to Vendor IVD") catalog and annotate a message — the
+downstream. Supply your own IICC LIVD ("LOINC to Vendor IVD") catalog and annotate a message, the
 mapping is **additive and advisory**: it never touches the raw code or value, and an unmapped or
 ambiguous code is surfaced as such, **never a guessed LOINC**.
 
@@ -187,31 +187,31 @@ warnings; // ASTM_LIVD_UNMAPPED_CODE / ASTM_LIVD_AMBIGUOUS_MAPPING (value-free)
 
 **No LOINC / SNOMED / LIVD dictionary is bundled.** LOINC is © Regenstrief (redistributable only with
 its attribution notice) and the public CDC LIVD file is SARS-CoV-2-specific and carries
-separately-licensed SNOMED CT — so the package ships no terminology data and you bring the catalog (and
+separately-licensed SNOMED CT, so the package ships no terminology data and you bring the catalog (and
 its license obligations).
 
 > **Scope your catalog to the source device fleet.** The ASTM Universal Test ID carries no manufacturer
 > to disambiguate against, so the catalog keys on the vendor transmission code alone. Two different
-> instruments that reuse the same code for different analytes would both match — supply a catalog built
+> instruments that reuse the same code for different analytes would both match: supply a catalog built
 > for the analyzers you actually receive from. (Conflicting entries _within_ one catalog are caught and
 > surfaced as `ambiguous`, never resolved to a guess.)
 
 ## The cosyte parser archetype
 
-- **Postel's Law** — liberal parser (lenient default + warnings), conservative serializer (always
+- **Postel's Law**: liberal parser (lenient default + warnings), conservative serializer (always
   spec-clean), so quirks don't propagate downstream on round-trip.
-- **Tiered tolerance** — Tier 0/1 silent, Tier 2 warning + recovery (escalates in strict mode),
+- **Tiered tolerance**: Tier 0/1 silent, Tier 2 warning + recovery (escalates in strict mode),
   Tier 3 fatal always.
-- **Stable warning codes** — warnings carry stable string codes + positional context; consumers
+- **Stable warning codes**: warnings carry stable string codes + positional context; consumers
   branch on `w.code`, so renaming a code is a breaking change.
-- **Zero runtime dependencies** — Node stdlib only (healthcare integrations vet every dependency).
-- **Dual ESM + CJS** — built with `tsup`, validated with `attw`.
-- **Immutability** — parsed models are immutable; mutation is via explicit methods.
-- **Profile system** — a `defineAstmProfile()` API for vendor quirks, with built-in profiles authored
+- **Zero runtime dependencies**: Node stdlib only (healthcare integrations vet every dependency).
+- **Dual ESM + CJS**: built with `tsup`, validated with `attw`.
+- **Immutability**: parsed models are immutable; mutation is via explicit methods.
+- **Profile system**: a `defineAstmProfile()` API for vendor quirks, with built-in profiles authored
   through the same public API. A profile only ever downgrades an _expected_, non-safety-critical warning
   to `PROFILE_QUIRK_APPLIED` (it never alters a value) and may force the raw-vs-framed transport; a
   default-deny safety gate refuses to tolerate any safety-critical deviation at definition time.
-- **Terminology recognizer, not a dictionary** — LIVD-aware LOINC recognition is bring-your-own
+- **Terminology recognizer, not a dictionary.** LIVD-aware LOINC recognition is bring-your-own
   (`applyLivd` over a consumer-supplied catalog): additive, advisory, and never a guessed LOINC. No
   LOINC / SNOMED / LIVD data is bundled.
 

package/dist/index.cjs

@@ -2,9 +2,9 @@
 
 // src/common/errors.ts
 var 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. */
   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`. */
   ASTM_RECORD_NO_HEADER: "ASTM_RECORD_NO_HEADER",
   /** The `H` record is too short to declare the four delimiters (field/repeat/component/escape). */
   ASTM_RECORD_UNDECLARED_DELIMITERS: "ASTM_RECORD_UNDECLARED_DELIMITERS"
@@ -121,21 +121,21 @@ function primaryCode(u) {
 
 // src/common/warnings.ts
 var 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. */
   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. */
   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. */
   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.
    */
   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).
    */
   ASTM_RECORD_UNDEFINED_ABNORMAL_FLAG: "ASTM_RECORD_UNDEFINED_ABNORMAL_FLAG",
   /**
@@ -145,7 +145,7 @@ var WARNING_CODES = {
   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**.
    */
   ASTM_RECORD_UNPARSEABLE_REFERENCE_RANGE: "ASTM_RECORD_UNPARSEABLE_REFERENCE_RANGE",
   /**
@@ -154,25 +154,25 @@ var WARNING_CODES = {
    */
   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**.
    */
   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**.
    */
   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.
    */
   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.
    */
@@ -181,7 +181,7 @@ var 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
@@ -190,13 +190,13 @@ var WARNING_CODES = {
    */
   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.
    */
   ASTM_RECORD_UNREADABLE_REDECLARATION: "ASTM_RECORD_UNREADABLE_REDECLARATION",
   /**
@@ -204,7 +204,7 @@ var 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.
@@ -214,28 +214,28 @@ var WARNING_CODES = {
 function unknownRecordType(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_UNKNOWN_TYPE,
-    message: "Unrecognized record type \u2014 surfaced verbatim as an unsupported record.",
+    message: "Unrecognized record type, surfaced verbatim as an unsupported record.",
     position
   };
 }
 function nonStandardDelimiters(position) {
   return {
     code: WARNING_CODES.ASTM_NONSTANDARD_DELIMITERS,
-    message: "Header declared non-canonical delimiters \u2014 read from the header and honored.",
+    message: "Header declared non-canonical delimiters, read from the header and honored.",
     position
   };
 }
 function delimitersRedeclared(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_DELIMITERS_REDECLARED,
-    message: "A later header declared different delimiters \u2014 honored from that header onward; earlier records keep the set they were read with.",
+    message: "A later header declared different delimiters, honored from that header onward; earlier records keep the set they were read with.",
     position
   };
 }
 function unreadableRedeclaration(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_UNREADABLE_REDECLARATION,
-    message: "A later header could not declare a usable delimiter set \u2014 the delimiters already in force were kept.",
+    message: "A later header could not declare a usable delimiter set, the delimiters already in force were kept.",
     position
   };
 }
@@ -249,63 +249,63 @@ function unknownEscapeSequence(position) {
 function ambiguousValueSplit(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_AMBIGUOUS_VALUE_SPLIT,
-    message: "Result value contained an unescaped component delimiter \u2014 full raw value and split both surfaced.",
+    message: "Result value contained an unescaped component delimiter, full raw value and split both surfaced.",
     position
   };
 }
 function undefinedAbnormalFlag(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_UNDEFINED_ABNORMAL_FLAG,
-    message: "Abnormal flag is not in HL7 Table 0078 \u2014 surfaced as undefined, never as normal.",
+    message: "Abnormal flag is not in HL7 Table 0078, surfaced as undefined, never as normal.",
     position
   };
 }
 function undefinedResultStatus(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_UNDEFINED_RESULT_STATUS,
-    message: "Result status is not a recognized status letter \u2014 surfaced as undefined.",
+    message: "Result status is not a recognized status letter, surfaced as undefined.",
     position
   };
 }
 function unparseableReferenceRange(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_UNPARSEABLE_REFERENCE_RANGE,
-    message: "Reference range did not match a recognized form \u2014 surfaced verbatim, no bound invented.",
+    message: "Reference range did not match a recognized form, surfaced verbatim, no bound invented.",
     position
   };
 }
 function unitsAbsent(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_UNITS_ABSENT,
-    message: "Numeric result value carried no units \u2014 never defaulted, guessed, or converted.",
+    message: "Numeric result value carried no units, never defaulted, guessed, or converted.",
     position
   };
 }
 function orphanComment(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_ORPHAN_COMMENT,
-    message: "Comment had no valid preceding parent \u2014 attached to the message root, never dropped.",
+    message: "Comment had no valid preceding parent, attached to the message root, never dropped.",
     position
   };
 }
 function partialTimestamp(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_PARTIAL_TIMESTAMP,
-    message: "Timestamp digit run truncates a component \u2014 preserved verbatim, never zero-filled.",
+    message: "Timestamp digit run truncates a component, preserved verbatim, never zero-filled.",
     position
   };
 }
 function uninterpretedQueryStatus(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_UNINTERPRETED_QUERY_STATUS,
-    message: "Query request-information status surfaced verbatim \u2014 code set paywalled, never interpreted.",
+    message: "Query request-information status surfaced verbatim, code set paywalled, never interpreted.",
     position
   };
 }
 function ambiguousMessageKind(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND,
-    message: "Message carried both a Q (request) and an R (result) record \u2014 classified host-query; Q dominates.",
+    message: "Message carried both a Q (request) and an R (result) record, classified host-query; Q dominates.",
     position
   };
 }
@@ -569,12 +569,12 @@ var 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.
    */
   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.
    */
@@ -588,7 +588,7 @@ var FRAME_WARNING_CODES = {
   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`).
    */
   ASTM_FRAME_OVERSIZE: "ASTM_FRAME_OVERSIZE"
@@ -596,28 +596,28 @@ var FRAME_WARNING_CODES = {
 function frameBadChecksum(position) {
   return {
     code: FRAME_WARNING_CODES.ASTM_FRAME_BAD_CHECKSUM,
-    message: "Frame checksum mismatch \u2014 surfaced untrusted, never merged into a record.",
+    message: "Frame checksum mismatch, surfaced untrusted, never merged into a record.",
     position
   };
 }
 function frameSequenceGap(position) {
   return {
     code: FRAME_WARNING_CODES.ASTM_FRAME_SEQUENCE_GAP,
-    message: "Frame number out of sequence \u2014 possible dropped frame, never silently bridged.",
+    message: "Frame number out of sequence, possible dropped frame, never silently bridged.",
     position
   };
 }
 function frameUnterminated(position) {
   return {
     code: FRAME_WARNING_CODES.ASTM_FRAME_UNTERMINATED,
-    message: "Unterminated frame \u2014 partial bytes surfaced untrusted, no partial record invented.",
+    message: "Unterminated frame, partial bytes surfaced untrusted, no partial record invented.",
     position
   };
 }
 function frameOversize(position) {
   return {
     code: FRAME_WARNING_CODES.ASTM_FRAME_OVERSIZE,
-    message: "Frame text exceeded the 240-byte limit without a split \u2014 flagged, never dropped.",
+    message: "Frame text exceeded the 240-byte limit without a split, flagged, never dropped.",
     position
   };
 }
@@ -626,21 +626,21 @@ function frameOversize(position) {
 var 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.)
    */
   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.
    */
   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
@@ -651,20 +651,20 @@ var LTP_WARNING_CODES = {
 function ltpAmbiguousTransport() {
   return {
     code: LTP_WARNING_CODES.ASTM_LTP_AMBIGUOUS_TRANSPORT,
-    message: "Leading byte was neither a frame start (STX/ENQ) nor a record letter \u2014 defaulted to framed; override with a profile to force raw."
+    message: "Leading byte was neither a frame start (STX/ENQ) nor a record letter, defaulted to framed; override with a profile to force raw."
   };
 }
 function ltpUnexpectedEvent(frameNumber) {
   return {
     code: LTP_WARNING_CODES.ASTM_LTP_UNEXPECTED_EVENT,
-    message: "Control event arrived in a state that did not expect it \u2014 handled defensively, never read as acceptance.",
+    message: "Control event arrived in a state that did not expect it, handled defensively, never read as acceptance.",
     ...frameNumber !== void 0 ? { frameNumber } : {}
   };
 }
 function ltpFrameRejected(frameNumber) {
   return {
     code: LTP_WARNING_CODES.ASTM_LTP_FRAME_REJECTED,
-    message: "Frame rejected (bad checksum, unterminated, or out of sequence) \u2014 NAK sent, retransmit expected, never accepted.",
+    message: "Frame rejected (bad checksum, unterminated, or out of sequence), NAK sent, retransmit expected, never accepted.",
     ...frameNumber !== void 0 ? { frameNumber } : {}
   };
 }
@@ -772,7 +772,7 @@ function validateTolerations(tolerate, profileName) {
     }
     if (isSafetyCriticalCode(t.code)) {
       throw new AstmProfileDefinitionError(
-        `Profile '${profileName}' may not tolerate '${t.code}' \u2014 it is a safety-critical warning code (a result value / flag / status / range / units, patient or comment context, message-kind ambiguity, code system, or a frame / LTP integrity warning). A profile quiets benign structural noise, never a deviation that could change a clinical reading or corrupt the wire \u2014 it can never make a bad checksum "ok" or a cancelled result read "final."`,
+        `Profile '${profileName}' may not tolerate '${t.code}': it is a safety-critical warning code (a result value / flag / status / range / units, patient or comment context, message-kind ambiguity, code system, or a frame / LTP integrity warning). A profile quiets benign structural noise, never a deviation that could change a clinical reading or corrupt the wire: it can never make a bad checksum "ok" or a cancelled result read "final."`,
         profileName
       );
     }
@@ -815,14 +815,14 @@ function defineAstmProfile(opts) {
 // src/profiles/default.ts
 var defaultProfile = defineAstmProfile({
   name: "default",
-  description: "Conservative baseline \u2014 tolerates nothing; every deviation surfaces as a warning.",
+  description: "Conservative baseline: tolerates nothing; every deviation surfaces as a warning.",
   tolerate: []
 });
 
 // src/profiles/reference-corpus.ts
 var referenceCorpus = defineAstmProfile({
   name: "referenceCorpus",
-  description: "Non-standard-escape tolerance grounded firsthand in the escape-agnostic OSS reference corpus (python-astm / senaite). Syntactic encoding noise only \u2014 the value is preserved verbatim, never a safety-critical value.",
+  description: "Non-standard-escape tolerance grounded firsthand in the escape-agnostic OSS reference corpus (python-astm / senaite). Syntactic encoding noise only: the value is preserved verbatim, never a safety-critical value.",
   provenance: {
     source: "kxepal/python-astm codec.py (BSD) + senaite.astm / senaite.lis2a",
     reference: "https://github.com/kxepal/python-astm/blob/master/astm/codec.py ; https://github.com/senaite/senaite.astm",
@@ -1086,7 +1086,7 @@ function buildRecord(line2, recordIndex, d, warnings) {
     case "Q":
       return buildQuery(recordIndex, fields, warnings);
     // `M` (manufacturer) and `S` (scientific) are vendor-defined free-form data surfaced VERBATIM and
-    // NEVER interpreted into typed clinical fields — the exact wire line is preserved for round-trip.
+    // NEVER interpreted into typed clinical fields: the exact wire line is preserved for round-trip.
     case "M":
       return { type: "M", recordIndex, fields, rawLine: line2 };
     case "S":
@@ -1119,7 +1119,7 @@ function buildPatient(recordIndex, fields, warnings) {
     recordIndex,
     fields,
     ...definedString("seq", fieldScalar(astmField(fields, 2))),
-    // The three patient identifiers stay DISTINCT — practice-assigned (3), laboratory-assigned (4),
+    // The three patient identifiers stay DISTINCT: practice-assigned (3), laboratory-assigned (4),
     // and a third ID (5) never collapse into one; conflating them is the primary misfiling path.
     ...definedString("practiceAssignedId", fieldScalar(astmField(fields, 3))),
     ...definedString("laboratoryAssignedId", fieldScalar(astmField(fields, 4))),
@@ -1142,7 +1142,7 @@ function buildOrder(recordIndex, fields) {
     ...hasContent(utidField) ? { universalTestId: recognizeUniversalTestId(utidField.components) } : {},
     // Priority (6), action code (~12), and report type (~26) are surfaced verbatim. The `~` field
     // indices and the code sets are `[OSS-derived]` (paywalled), so they are never mapped to a
-    // guessed meaning — see the JSDoc on `OrderRecord`.
+    // guessed meaning: see the JSDoc on `OrderRecord`.
     ...definedString("priority", fieldScalar(astmField(fields, 6))),
     ...definedString("actionCode", fieldScalar(astmField(fields, 12))),
     ...definedString("reportType", fieldScalar(astmField(fields, 26)))
@@ -1541,7 +1541,7 @@ var AMBIGUOUS_CODES = {
   ASTM_AMBIGUOUS_MULTI_PATIENT: "ASTM_AMBIGUOUS_MULTI_PATIENT"
 };
 var AstmAmbiguousStreamError = class extends Error {
-  /** The stable discriminant — see {@link AMBIGUOUS_CODES}. */
+  /** The stable discriminant: see {@link AMBIGUOUS_CODES}. */
   code;
   /** Where the ambiguity became visible: the second header, or the second `P`. Value-free. */
   position;
@@ -1686,14 +1686,14 @@ function defineLivdCatalog(entries) {
 var 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.
    */
   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.
    */
   ASTM_LIVD_AMBIGUOUS_MAPPING: "ASTM_LIVD_AMBIGUOUS_MAPPING"
@@ -1701,14 +1701,14 @@ var LIVD_WARNING_CODES = {
 function livdUnmappedCode(position) {
   return {
     code: LIVD_WARNING_CODES.ASTM_LIVD_UNMAPPED_CODE,
-    message: "Reported test code had no LIVD mapping \u2014 surfaced unmapped, never a guessed LOINC.",
+    message: "Reported test code had no LIVD mapping, surfaced unmapped, never a guessed LOINC.",
     position
   };
 }
 function livdAmbiguousMapping(position) {
   return {
     code: LIVD_WARNING_CODES.ASTM_LIVD_AMBIGUOUS_MAPPING,
-    message: "Reported test code mapped to multiple distinct LOINCs \u2014 surfaced ambiguous, never one guessed.",
+    message: "Reported test code mapped to multiple distinct LOINCs, surfaced ambiguous, never one guessed.",
     position
   };
 }
@@ -2152,7 +2152,7 @@ function encodeFrame(text, frameNumber, isFinal) {
 }
 function composeAstmFrames(records, options = {}) {
   if (records.length === 0) {
-    throw new AstmFrameEncodeError("Cannot frame an empty record list \u2014 nothing to transmit.");
+    throw new AstmFrameEncodeError("Cannot frame an empty record list: nothing to transmit.");
   }
   const out = [];
   let frameNumber = options.startFrameNumber ?? FIRST_FRAME_NUMBER;
@@ -2160,7 +2160,7 @@ function composeAstmFrames(records, options = {}) {
     const bytes = toBytes(record);
     if (bytes.length === 0) {
       throw new AstmFrameEncodeError(
-        "Cannot frame an empty record \u2014 a frame must carry record bytes.",
+        "Cannot frame an empty record: a frame must carry record bytes.",
         recordIndex
       );
     }
@@ -2199,7 +2199,7 @@ function concatBytes3(chunks) {
 }
 
 // src/index.ts
-var VERSION = "0.0.4";
+var VERSION = "0.0.5";
 
 exports.ALL_ASTM_WARNING_CODES = ALL_ASTM_WARNING_CODES;
 exports.AMBIGUOUS_CODES = AMBIGUOUS_CODES;