@cosyte/astm 0.0.3 → 0.0.5

package/dist/index.mjs

@@ -1,8 +1,8 @@
 // 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"
@@ -119,21 +119,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",
   /**
@@ -143,7 +143,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",
   /**
@@ -152,35 +152,57 @@ 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.
    */
   ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND: "ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND",
+  /**
+   * A later `H` (header) record declared a **different** delimiter set from the one in force, and the
+   * parser **followed it**: that header and every record after it are read with the newly-declared
+   * delimiters, until the next `H`. Records already read keep the set that was in force when they were
+   * read: a redeclaration never reinterprets bytes that have already been consumed.
+   *
+   * A stream carrying several messages back to back is ordinary, and a header that simply **repeats**
+   * the delimiters already in force is a no-op that warns nothing. This code fires only when the set
+   * actually changes, because that is the point at which a reader still using the old set would begin
+   * merging fields together.
+   */
+  ASTM_RECORD_DELIMITERS_REDECLARED: "ASTM_RECORD_DELIMITERS_REDECLARED",
+  /**
+   * A later `H` (header) record could not declare a usable delimiter set: it was too short, or the
+   * field separator it named also appeared among the other three, leaving the four roles
+   * indistinguishable. The delimiters **already in force are kept** and every record is still surfaced;
+   * a set is never guessed and no record is dropped.
+   *
+   * The same condition on the *first* header is unrecoverable and remains the
+   * `ASTM_RECORD_UNDECLARED_DELIMITERS` fatal: there is no earlier set to fall back to.
+   */
+  ASTM_RECORD_UNREADABLE_REDECLARATION: "ASTM_RECORD_UNREADABLE_REDECLARATION",
   /**
    * The downgraded form an active vendor {@link AstmProfile} produces from a deviation it *expects*
    * (see `src/profiles/`). The original warning is **never dropped**: its code moves to
    * {@link AstmRecordWarning.toleratedCode}, the warning is re-badged `PROFILE_QUIRK_APPLIED` with
    * `expected: true` and the tolerating profile named, so a consumer can filter known, grounded noise
-   * while the fact of the deviation — and where it was — survives. A profile can only ever reach this
+   * while the fact of the deviation, and where it was, survives. A profile can only ever reach this
    * path for a **non-safety-critical** code (enforced at profile-definition time); a safety-critical
    * deviation (a result value, flag, status, patient identifier, code system, or a frame-integrity
    * warning) can **never** be tolerated, so it can never be re-badged here.
@@ -190,14 +212,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, 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, the delimiters already in force were kept.",
     position
   };
 }
@@ -211,63 +247,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
   };
 }
@@ -531,12 +567,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.
    */
@@ -550,7 +586,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"
@@ -558,28 +594,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
   };
 }
@@ -588,21 +624,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
@@ -613,20 +649,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 } : {}
   };
 }
@@ -734,7 +770,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
       );
     }
@@ -777,14 +813,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",
@@ -897,6 +933,17 @@ function tokenizeRecord(record, d, onUnknownEscape) {
   const rawFields = splitEscapeAware(record, d.field, d.escape);
   return rawFields.map((raw, fieldIndex) => toField(raw, d, () => onUnknownEscape?.(fieldIndex)));
 }
+function tokenizeHeader(record, d, onUnknownEscape) {
+  const defEnd = record.indexOf(d.field, 2);
+  const definition = defEnd === -1 ? record.slice(2) : record.slice(2, defEnd);
+  const head = [opaqueField(record.slice(0, Math.min(1, record.length))), opaqueField(definition)];
+  if (defEnd === -1) return head;
+  const data = tokenizeRecord(record.slice(defEnd + 1), d, (i) => onUnknownEscape?.(i + 2));
+  return [...head, ...data];
+}
+function opaqueField(raw) {
+  return { raw, components: [raw], repeats: [[raw]] };
+}
 function toField(raw, d, onUnknownEscape) {
   const rawRepeats = splitEscapeAware(raw, d.repeat, d.escape);
   const repeats = rawRepeats.map(
@@ -950,9 +997,13 @@ function parseAstmRecords(raw, options = {}) {
   if (isNonStandard(delimiters)) {
     warnings.push(nonStandardDelimiters({ recordIndex: 0, recordType: "H" }));
   }
-  const built = lines.map(
-    (line2, recordIndex) => buildRecord(line2, recordIndex, delimiters, warnings)
-  );
+  let active = delimiters;
+  const built = lines.map((line2, recordIndex) => {
+    if (recordIndex > 0 && line2.charAt(0) === "H") {
+      active = adoptRedeclaredDelimiters(line2, active, recordIndex, warnings);
+    }
+    return buildRecord(line2, recordIndex, active, warnings);
+  });
   const records = attachComments(built, warnings);
   const classification = classifyMessage(records);
   if (classification.hasQuery && classification.hasResults) {
@@ -982,6 +1033,21 @@ function resolveProfile(options) {
   if (options.profile !== void 0) return options.profile;
   return getDefaultAstmProfile();
 }
+function adoptRedeclaredDelimiters(line2, active, recordIndex, warnings) {
+  const position = { recordIndex, recordType: "H" };
+  const declared = readDelimiters(line2);
+  if (declared === void 0) {
+    warnings.push(unreadableRedeclaration(position));
+    return active;
+  }
+  if (sameDelimiters(declared, active)) return active;
+  warnings.push(delimitersRedeclared(position));
+  if (isNonStandard(declared)) warnings.push(nonStandardDelimiters(position));
+  return declared;
+}
+function sameDelimiters(a, b) {
+  return a.field === b.field && a.repeat === b.repeat && a.component === b.component && a.escape === b.escape;
+}
 function decodeBytes(bytes) {
   let out = "";
   for (const b of bytes) out += String.fromCharCode(b);
@@ -992,11 +1058,12 @@ function astmField(fields, n) {
 }
 function buildRecord(line2, recordIndex, d, warnings) {
   const rawType = line2.charAt(0);
-  const fields = tokenizeRecord(line2, d, (fieldIndex) => {
+  const onUnknownEscape = (fieldIndex) => {
     warnings.push(
       unknownEscapeSequence({ recordIndex, recordType: rawType, fieldIndex: fieldIndex + 1 })
     );
-  });
+  };
+  const fields = rawType === "H" ? tokenizeHeader(line2, d, onUnknownEscape) : tokenizeRecord(line2, d, onUnknownEscape);
   switch (rawType) {
     case "H":
       return {
@@ -1017,7 +1084,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":
@@ -1050,7 +1117,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))),
@@ -1073,7 +1140,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)))
@@ -1218,19 +1285,57 @@ function definedString(key, value) {
 
 // src/records/serialize.ts
 var AstmSerializeError = class extends Error {
-  /** Stable discriminant; `ASTM_EMIT_UNENCODABLE_VALUE` for a `CR`/`LF` in a value. */
+  /**
+   * Stable discriminant. `ASTM_EMIT_UNENCODABLE_VALUE` for a `CR`/`LF` in a value;
+   * `ASTM_EMIT_INVALID_DELIMITERS` for a delimiter set that cannot be emitted
+   * reversibly.
+   */
   code;
   /** 0-based ordinal of the record within the message, when known. */
   recordIndex;
   /** @internal */
-  constructor(message, recordIndex) {
+  constructor(message, recordIndex, code = "ASTM_EMIT_UNENCODABLE_VALUE") {
     super(message);
     this.name = "AstmSerializeError";
-    this.code = "ASTM_EMIT_UNENCODABLE_VALUE";
+    this.code = code;
     if (recordIndex !== void 0) this.recordIndex = recordIndex;
   }
 };
+var DELIMITER_ROLES = ["field", "repeat", "component", "escape"];
+var CONTROL_CHARACTER = /[\u0000-\u001f\u007f]/;
+function assertEmittableDelimiters(d, recordIndex) {
+  const invalid = (reason) => {
+    throw new AstmSerializeError(
+      `Cannot emit against these delimiters: ${reason}.`,
+      recordIndex,
+      "ASTM_EMIT_INVALID_DELIMITERS"
+    );
+  };
+  if (typeof d !== "object" || d === null) {
+    invalid("a delimiter set is required");
+  }
+  for (const role of DELIMITER_ROLES) {
+    const char = d[role];
+    if (typeof char !== "string" || char.length !== 1) {
+      invalid(`the ${role} delimiter must be exactly one character`);
+    }
+    if (char === "\r" || char === "\n") {
+      invalid(`the ${role} delimiter must not be a record terminator (CR/LF)`);
+    }
+  }
+  DELIMITER_ROLES.forEach((a, i) => {
+    for (const b of DELIMITER_ROLES.slice(i + 1)) {
+      if (d[a] === d[b]) {
+        invalid(`the ${a} and ${b} delimiters must not be the same character`);
+      }
+    }
+  });
+}
 function encodeComponent(leaf, d, recordIndex) {
+  assertEmittableDelimiters(d, recordIndex);
+  return encodeLeaf(leaf, d, recordIndex);
+}
+function encodeLeaf(leaf, d, recordIndex) {
   if (leaf.includes("\r") || leaf.includes("\n")) {
     throw new AstmSerializeError(
       "A value contains a record terminator (CR/LF), which cannot be escaped without breaking framing.",
@@ -1240,28 +1345,58 @@ function encodeComponent(leaf, d, recordIndex) {
   return leaf.split(d.escape).join(d.escape + "E" + d.escape).split(d.field).join(d.escape + "F" + d.escape).split(d.component).join(d.escape + "S" + d.escape).split(d.repeat).join(d.escape + "R" + d.escape);
 }
 function encodeField(repeats, d, recordIndex) {
-  return repeats.map((rep) => rep.map((c) => encodeComponent(c, d, recordIndex)).join(d.component)).join(d.repeat);
+  return repeats.map((rep) => rep.map((c) => encodeLeaf(c, d, recordIndex)).join(d.component)).join(d.repeat);
 }
 function serializeAstmRecord(record, d = CANONICAL_DELIMITERS) {
-  if (record.type === "M" || record.type === "S") return record.rawLine;
+  assertEmittableDelimiters(d, record.recordIndex);
+  return serializeRecordChecked(record, d);
+}
+function serializeRecordChecked(record, d) {
+  if (record.type === "M" || record.type === "S") return serializeVerbatimRecord(record, d);
   if (record.type === "H") return serializeHeader(record, d);
   return record.fields.map((f) => encodeField(f.repeats, d, record.recordIndex)).join(d.field);
 }
+function serializeVerbatimRecord(record, d) {
+  if (recoversVerbatim(record, d)) return record.rawLine;
+  return record.fields.map((f) => encodeField(f.repeats, d, record.recordIndex)).join(d.field);
+}
+function recoversVerbatim(record, d) {
+  return sameFieldTree(tokenizeRecord(record.rawLine, d), record.fields);
+}
+function sameFieldTree(a, b) {
+  if (a.length !== b.length) return false;
+  return a.every((fieldA, i) => {
+    const fieldB = b[i];
+    if (fieldB === void 0) return false;
+    if (fieldA.repeats.length !== fieldB.repeats.length) return false;
+    return fieldA.repeats.every((repA, r) => {
+      const repB = fieldB.repeats[r];
+      if (repB === void 0 || repA.length !== repB.length) return false;
+      return repA.every((comp, c) => comp === repB[c]);
+    });
+  });
+}
 function serializeHeader(header, d) {
-  const head = "H" + d.field + d.repeat + d.component + d.escape;
-  const src = header.delimiters;
-  const defEnd = header.rawLine.indexOf(src.field, 2);
-  if (defEnd === -1) return head;
-  const dataPortion = header.rawLine.slice(defEnd + 1);
-  const dataFields = tokenizeRecord(dataPortion, src);
+  const head = "H" + d.field + d.repeat + d.component + d.escape + declarationResidual(header, d);
+  const dataFields = header.fields.slice(2);
   const rest = dataFields.map((f) => d.field + encodeField(f.repeats, d, header.recordIndex)).join("");
   return head + rest;
 }
+function declarationResidual(header, d) {
+  const declaration = header.fields[1]?.raw ?? "";
+  const roles = d.repeat + d.component + d.escape;
+  if (!declaration.startsWith(roles)) return "";
+  const residual = declaration.slice(roles.length);
+  if (residual.includes(d.field) || CONTROL_CHARACTER.test(residual)) return "";
+  return residual;
+}
 function serializeAstmRecords(input, d = CANONICAL_DELIMITERS) {
+  assertEmittableDelimiters(d);
   const records = Array.isArray(input) ? input : input.records;
-  return records.map((r) => serializeAstmRecord(r, d) + "\r").join("");
+  return records.map((r) => serializeRecordChecked(r, d) + "\r").join("");
 }
 function serializeField(field, d = CANONICAL_DELIMITERS) {
+  assertEmittableDelimiters(d);
   return encodeField(field.repeats, d);
 }
 
@@ -1396,17 +1531,108 @@ function buildAstmMessage(input) {
   return lines.map((l) => l + "\r").join("");
 }
 
+// src/records/messages.ts
+var AMBIGUOUS_CODES = {
+  /** The stream carries more than one `H` … `L` message, so a stream-wide answer spans patients. */
+  ASTM_AMBIGUOUS_MULTI_MESSAGE: "ASTM_AMBIGUOUS_MULTI_MESSAGE",
+  /** The one message in the stream carries more than one `P`, so "the patient" is not determined. */
+  ASTM_AMBIGUOUS_MULTI_PATIENT: "ASTM_AMBIGUOUS_MULTI_PATIENT"
+};
+var AstmAmbiguousStreamError = class extends Error {
+  /** The stable discriminant: see {@link AMBIGUOUS_CODES}. */
+  code;
+  /** Where the ambiguity became visible: the second header, or the second `P`. Value-free. */
+  position;
+  /** How many `H` … `L` messages the stream carries. */
+  messageCount;
+  /** How many `P` records the message in question carries. */
+  patientCount;
+  /** @internal */
+  constructor(code, message, position, counts) {
+    super(message);
+    this.name = "AstmAmbiguousStreamError";
+    this.code = code;
+    this.position = position;
+    this.messageCount = counts.messageCount;
+    this.patientCount = counts.patientCount;
+  }
+};
+function messages(msg) {
+  const groups = [];
+  let current;
+  for (const record of msg.records) {
+    if (record.type === "H" || current === void 0) {
+      current = [];
+      groups.push(current);
+    }
+    current.push(record);
+  }
+  return Object.freeze(
+    groups.map((records, index) => {
+      const header = records.find((r) => r.type === "H") ?? msg.header;
+      const patients = records.filter((r) => r.type === "P");
+      return Object.freeze({
+        index,
+        header,
+        delimiters: header.delimiters,
+        records: Object.freeze(records),
+        patient: patients.length === 1 ? patients[0] : void 0,
+        patients: Object.freeze(patients),
+        results: Object.freeze(records.filter((r) => r.type === "R")),
+        orders: Object.freeze(records.filter((r) => r.type === "O")),
+        comments: Object.freeze(records.filter((r) => r.type === "C")),
+        queries: Object.freeze(records.filter((r) => r.type === "Q"))
+      });
+    })
+  );
+}
+function surveyMessages(msg) {
+  let count = 0;
+  let secondHeader;
+  for (const record of msg.records) {
+    if (record.type !== "H") continue;
+    count += 1;
+    if (count === 2) secondHeader = record;
+  }
+  return { count, secondHeader };
+}
+function assertSingleMessage(msg, accessor) {
+  const { count, secondHeader } = surveyMessages(msg);
+  if (count <= 1) return;
+  throw new AstmAmbiguousStreamError(
+    AMBIGUOUS_CODES.ASTM_AMBIGUOUS_MULTI_MESSAGE,
+    `${accessor} is scoped to the whole stream, and this stream carries ${String(count)} messages, so its answer would span patients. Use messages() and read each message's own records.`,
+    { recordIndex: secondHeader?.recordIndex ?? 0, recordType: "H" },
+    { messageCount: count, patientCount: 0 }
+  );
+}
+function assertSinglePatient(msg, accessor) {
+  const patients = msg.records.filter((r) => r.type === "P");
+  if (patients.length <= 1) return;
+  throw new AstmAmbiguousStreamError(
+    AMBIGUOUS_CODES.ASTM_AMBIGUOUS_MULTI_PATIENT,
+    `${accessor} cannot name one patient: this message carries ${String(patients.length)} P records. Read them from messages()[n].patients and pair each with the records it owns.`,
+    { recordIndex: patients[1]?.recordIndex ?? 0, recordType: "P" },
+    { messageCount: 1, patientCount: patients.length }
+  );
+}
+
 // src/records/extractors.ts
 function results(msg) {
+  assertSingleMessage(msg, "results()");
   return msg.records.filter((r) => r.type === "R");
 }
 function patient(msg) {
+  assertSingleMessage(msg, "patient()");
+  assertSinglePatient(msg, "patient()");
   return msg.records.find((r) => r.type === "P");
 }
 function orders(msg) {
+  assertSingleMessage(msg, "orders()");
   return msg.records.filter((r) => r.type === "O");
 }
 function comments(msg) {
+  assertSingleMessage(msg, "comments()");
   return msg.records.filter((r) => r.type === "C");
 }
 function commentsFor(msg, parent) {
@@ -1415,6 +1641,7 @@ function commentsFor(msg, parent) {
   );
 }
 function query(msg) {
+  assertSingleMessage(msg, "query()");
   return msg.records.filter((r) => r.type === "Q");
 }
 
@@ -1457,14 +1684,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"
@@ -1472,14 +1699,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
   };
 }
@@ -1923,7 +2150,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;
@@ -1931,7 +2158,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
       );
     }
@@ -1970,8 +2197,8 @@ function concatBytes3(chunks) {
 }
 
 // src/index.ts
-var VERSION = "0.0.3";
+var VERSION = "0.0.5";
 
-export { ALL_ASTM_WARNING_CODES, ACK as ASTM_ACK, ENQ as ASTM_ENQ, EOT as ASTM_EOT, NAK as ASTM_NAK, AstmFrameEncodeError, AstmFrameStrictError, AstmParseError, AstmProfileDefinitionError, AstmSerializeError, AstmStrictError, CANONICAL_DELIMITERS, FATAL_CODES, FRAME_WARNING_CODES, LIVD_WARNING_CODES, LTP_WARNING_CODES, SAFETY_CRITICAL_CODES, TOLERABLE_CODES, VERSION, WARNING_CODES, ambiguousMessageKind, ambiguousValueSplit, applyAstmProfile, applyAstmProfileToWarnings, applyLivd, astmDateToLocalISO, astmProfiles, attachComments, buildAstmMessage, classifyMessage, comments, commentsFor, composeAstmFrames, computeChecksum, decodeAstmFrames, decodeEscapes, deepFreeze, defineAstmProfile, defineLivdCatalog, detectFraming, encodeComponent, fieldScalar, frameBadChecksum, frameOversize, frameSequenceGap, frameUnterminated, getAstmProfile, getDefaultAstmProfile, interpretAbnormalFlag, interpretResultStatus, isNonStandard, isSafetyCriticalCode, listAstmProfiles, livdAmbiguousMapping, livdUnmappedCode, lookupLivdForRecord, ltpAmbiguousTransport, ltpFrameRejected, ltpInitialState, ltpReduce, ltpUnexpectedEvent, nonStandardDelimiters, orders, orphanComment, parseAstmDate, parseAstmRecords, parseChecksumHex, parseFramedAstm, parseReferenceRange, partialTimestamp, patient, primaryCode, profileQuirkApplied, query, readDelimiters, recognizeUniversalTestId, resolveProfileTransport, results, serializeAstmRecord, serializeAstmRecords, serializeField, serializeFramedAstm, setDefaultAstmProfile, splitEscapeAware, toChecksumHex, tokenizeRecord, undefinedAbnormalFlag, undefinedResultStatus, uninterpretedQueryStatus, unitsAbsent, unknownEscapeSequence, unknownRecordType, unparseableReferenceRange };
+export { ALL_ASTM_WARNING_CODES, AMBIGUOUS_CODES, ACK as ASTM_ACK, ENQ as ASTM_ENQ, EOT as ASTM_EOT, NAK as ASTM_NAK, AstmAmbiguousStreamError, AstmFrameEncodeError, AstmFrameStrictError, AstmParseError, AstmProfileDefinitionError, AstmSerializeError, AstmStrictError, CANONICAL_DELIMITERS, FATAL_CODES, FRAME_WARNING_CODES, LIVD_WARNING_CODES, LTP_WARNING_CODES, SAFETY_CRITICAL_CODES, TOLERABLE_CODES, VERSION, WARNING_CODES, ambiguousMessageKind, ambiguousValueSplit, applyAstmProfile, applyAstmProfileToWarnings, applyLivd, astmDateToLocalISO, astmProfiles, attachComments, buildAstmMessage, classifyMessage, comments, commentsFor, composeAstmFrames, computeChecksum, decodeAstmFrames, decodeEscapes, deepFreeze, defineAstmProfile, defineLivdCatalog, delimitersRedeclared, detectFraming, encodeComponent, fieldScalar, frameBadChecksum, frameOversize, frameSequenceGap, frameUnterminated, getAstmProfile, getDefaultAstmProfile, interpretAbnormalFlag, interpretResultStatus, isNonStandard, isSafetyCriticalCode, listAstmProfiles, livdAmbiguousMapping, livdUnmappedCode, lookupLivdForRecord, ltpAmbiguousTransport, ltpFrameRejected, ltpInitialState, ltpReduce, ltpUnexpectedEvent, messages, nonStandardDelimiters, orders, orphanComment, parseAstmDate, parseAstmRecords, parseChecksumHex, parseFramedAstm, parseReferenceRange, partialTimestamp, patient, primaryCode, profileQuirkApplied, query, readDelimiters, recognizeUniversalTestId, resolveProfileTransport, results, serializeAstmRecord, serializeAstmRecords, serializeField, serializeFramedAstm, setDefaultAstmProfile, splitEscapeAware, toChecksumHex, tokenizeHeader, tokenizeRecord, undefinedAbnormalFlag, undefinedResultStatus, uninterpretedQueryStatus, unitsAbsent, unknownEscapeSequence, unknownRecordType, unparseableReferenceRange, unreadableRedeclaration };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map