@cosyte/astm 0.0.7 → 0.0.9

package/dist/index.mjs

@@ -119,12 +119,65 @@ 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,
+   * never dropped. Treat it as a possible lost message boundary, because a header the reader did
+   * not recognize as one does not open a new message.
+   */
   ASTM_RECORD_UNKNOWN_TYPE: "ASTM_RECORD_UNKNOWN_TYPE",
+  /**
+   * The delimiters in force found **no field separator at all** in a record that carries content
+   * beyond its type letter, so the whole record read back as a single field and none of its modeled
+   * fields could be recovered. The raw line is surfaced intact and nothing is dropped, but on a
+   * result record it means the value, the units and the status are all absent from the parsed model.
+   *
+   * This is one signature of a record being read with a delimiter set that does not belong to it,
+   * which is how a delimiter-scoping mistake turns into lost values. It is reported rather than
+   * repaired, because recovering the fields would mean guessing which set the sender meant.
+   *
+   * **Its absence is not evidence that a record was read in its own set.** This tests one of the
+   * four delimiter roles, the field separator, and only in its total form, where that separator
+   * occurs in the line (unescaped). Two whole classes of the same loss are outside it: a foreign set
+   * whose field separator happens to occur somewhere in the line still splits (on the wrong
+   * boundaries, silently, and this can happen to one record inside a run of these warnings); and a
+   * set differing in the repeat, component or escape role usually splits into fields normally,
+   * where a mis-split component can cost a test identity while the value survives, and where an
+   * `&X&` sequence whose body is a delimiter is an opaque atom, so that delimiter does not split
+   * and every field after it shifts. The escape role's worst case has narrowed and not
+   * disappeared: an escape character heading no sequence is now read as a literal and reported
+   * under {@link WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER} rather than merging the rest of the
+   * record, but a delimiter swallowed inside an `&X&` body is reported only by
+   * {@link WARNING_CODES.ASTM_UNKNOWN_ESCAPE_SEQUENCE}, which is tolerable. Treat this code as a
+   * report that one record definitely lost its fields, never as a sweep that would have fired if
+   * any had.
+   */
+  ASTM_RECORD_FIELDS_UNSEPARATED: "ASTM_RECORD_FIELDS_UNSEPARATED",
   /** 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. */
   ASTM_UNKNOWN_ESCAPE_SEQUENCE: "ASTM_UNKNOWN_ESCAPE_SEQUENCE",
+  /**
+   * An escape character appeared where no escape sequence starts (an escape sequence is the escape
+   * character, one body character, and the escape character again). It is read as the **literal
+   * character it is** and kept byte-for-byte in the decoded value. Nothing is dropped and no byte is
+   * invented: this flags that the sender did not write the character the spec-clean way, which
+   * is `&E&`.
+   *
+   * **What it replaced is the reason it exists.** The codec used to read such a character as the
+   * opening of a sequence that never closed and merge the whole remainder of the record into the
+   * field it sat in, reporting nothing at all. One `&` in a result value cost the units, the
+   * abnormal flag and the status together and left the status reading `unspecified` rather than
+   * `final`; one in a surname cost the patient's birth date and sex. Emit then re-escaped the merged
+   * text into a spec-clean-looking line that read back as the same wrong value, so the mis-read
+   * survived a round trip without ever surfacing.
+   *
+   * **This code is not a statement about the rest of the record.** It reports one character. A
+   * *different* escape character in the same record may still head a real three-character sequence,
+   * and if that sequence's body happens to be a delimiter (`&|&` under the canonical set) the atom
+   * rule means that delimiter does not split. That case is reported separately, under
+   * {@link WARNING_CODES.ASTM_UNKNOWN_ESCAPE_SEQUENCE}, and it can still cost a field boundary.
+   */
+  ASTM_UNPAIRED_ESCAPE_CHARACTER: "ASTM_UNPAIRED_ESCAPE_CHARACTER",
   /**
    * 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
@@ -212,7 +265,14 @@ var WARNING_CODES = {
 function unknownRecordType(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_UNKNOWN_TYPE,
-    message: "Unrecognized record type, surfaced verbatim as an unsupported record.",
+    message: "Unrecognized record type, surfaced verbatim as an unsupported record. If this record was a header, message grouping did not open a new message here.",
+    position
+  };
+}
+function fieldsUnseparated(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_FIELDS_UNSEPARATED,
+    message: "The delimiters in force found no field separator in this record, so its whole content read back as one field and none of its modeled fields could be recovered. The raw line is surfaced intact, and no field is reconstructed, because the set the sender used is unknown.",
     position
   };
 }
@@ -244,6 +304,13 @@ function unknownEscapeSequence(position) {
     position
   };
 }
+function unpairedEscapeCharacter(position) {
+  return {
+    code: WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER,
+    message: "An escape character headed no escape sequence, read as the literal character it is rather than opening a sequence that never closes. The spec-clean form is the escaped one.",
+    position
+  };
+}
 function ambiguousValueSplit(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_AMBIGUOUS_VALUE_SPLIT,
@@ -412,17 +479,157 @@ function classifyMessage(records) {
   let hasQuery = false;
   let hasResults = false;
   let hasOrders = false;
+  let hasUnrecognized = false;
   for (const r of records) {
     if (r.type === "Q") hasQuery = true;
     else if (r.type === "R") hasResults = true;
     else if (r.type === "O") hasOrders = true;
+    else if (r.type === "unsupported") hasUnrecognized = true;
   }
   let kind;
   if (hasQuery) kind = "host-query";
+  else if (hasUnrecognized) kind = "indeterminate";
   else if (hasResults) kind = "results";
   else if (hasOrders) kind = "orders";
   else kind = "indeterminate";
-  return { kind, hasQuery, hasResults, hasOrders, isHostQueryRequest: kind === "host-query" };
+  return {
+    kind,
+    hasQuery,
+    hasResults,
+    hasOrders,
+    hasUnrecognized,
+    isHostQueryRequest: kind === "host-query"
+  };
+}
+
+// src/frames/warnings.ts
+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
+   * 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
+   * 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.
+   */
+  ASTM_FRAME_SEQUENCE_GAP: "ASTM_FRAME_SEQUENCE_GAP",
+  /**
+   * A frame opened with `STX` but no valid terminator + checksum was found before the stream ended
+   * (or before the next `STX`), or a record's frames ended on an intermediate `ETB` with no final
+   * `ETX`. The partial bytes are surfaced flagged untrusted and **no partial record is invented**
+   * (warn in lenient, thrown in `strict`).
+   */
+  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
+   * (warn in lenient, thrown in `strict`).
+   */
+  ASTM_FRAME_OVERSIZE: "ASTM_FRAME_OVERSIZE"
+};
+function frameBadChecksum(position) {
+  return {
+    code: FRAME_WARNING_CODES.ASTM_FRAME_BAD_CHECKSUM,
+    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, possible dropped frame, never silently bridged.",
+    position
+  };
+}
+function frameUnterminated(position) {
+  return {
+    code: FRAME_WARNING_CODES.ASTM_FRAME_UNTERMINATED,
+    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, flagged, never dropped.",
+    position
+  };
+}
+
+// src/ltp/warnings.ts
+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,
+   * 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
+   * 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`
+   * 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
+   * 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
+   * drives retransmit, not acceptance.
+   */
+  ASTM_LTP_FRAME_REJECTED: "ASTM_LTP_FRAME_REJECTED"
+};
+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, 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, 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), NAK sent, retransmit expected, never accepted.",
+    ...frameNumber !== void 0 ? { frameNumber } : {}
+  };
+}
+
+// src/profiles/safety.ts
+var TOLERABLE_CODES = Object.freeze(
+  /* @__PURE__ */ new Set([
+    WARNING_CODES.ASTM_NONSTANDARD_DELIMITERS,
+    WARNING_CODES.ASTM_UNKNOWN_ESCAPE_SEQUENCE,
+    WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER,
+    WARNING_CODES.ASTM_RECORD_UNINTERPRETED_QUERY_STATUS
+  ])
+);
+var ALL_WARNING_CODES = [
+  ...Object.values(WARNING_CODES),
+  ...Object.values(FRAME_WARNING_CODES),
+  ...Object.values(LTP_WARNING_CODES)
+];
+var ALL_ASTM_WARNING_CODES = Object.freeze(
+  new Set(ALL_WARNING_CODES)
+);
+var SAFETY_CRITICAL_CODES = Object.freeze(
+  new Set(ALL_WARNING_CODES.filter((c) => !TOLERABLE_CODES.has(c)))
+);
+function isSafetyCriticalCode(code) {
+  return SAFETY_CRITICAL_CODES.has(code);
 }
 
 // src/profiles/apply.ts
@@ -440,6 +647,7 @@ function toleranceApplies(tolerance, warning) {
 }
 function applyAstmProfile(profile, warning) {
   if (warning.expected === true) return warning;
+  if (isSafetyCriticalCode(warning.code)) return warning;
   for (const tolerance of profile.tolerate) {
     if (toleranceApplies(tolerance, warning)) {
       return profileQuirkApplied(warning, profile.name);
@@ -561,136 +769,6 @@ var AstmProfileDefinitionError = class extends Error {
   }
 };
 
-// src/frames/warnings.ts
-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
-   * 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
-   * 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.
-   */
-  ASTM_FRAME_SEQUENCE_GAP: "ASTM_FRAME_SEQUENCE_GAP",
-  /**
-   * A frame opened with `STX` but no valid terminator + checksum was found before the stream ended
-   * (or before the next `STX`), or a record's frames ended on an intermediate `ETB` with no final
-   * `ETX`. The partial bytes are surfaced flagged untrusted and **no partial record is invented**
-   * (warn in lenient, thrown in `strict`).
-   */
-  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
-   * (warn in lenient, thrown in `strict`).
-   */
-  ASTM_FRAME_OVERSIZE: "ASTM_FRAME_OVERSIZE"
-};
-function frameBadChecksum(position) {
-  return {
-    code: FRAME_WARNING_CODES.ASTM_FRAME_BAD_CHECKSUM,
-    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, possible dropped frame, never silently bridged.",
-    position
-  };
-}
-function frameUnterminated(position) {
-  return {
-    code: FRAME_WARNING_CODES.ASTM_FRAME_UNTERMINATED,
-    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, flagged, never dropped.",
-    position
-  };
-}
-
-// src/ltp/warnings.ts
-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,
-   * 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
-   * 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`
-   * 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
-   * 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
-   * drives retransmit, not acceptance.
-   */
-  ASTM_LTP_FRAME_REJECTED: "ASTM_LTP_FRAME_REJECTED"
-};
-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, 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, 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), NAK sent, retransmit expected, never accepted.",
-    ...frameNumber !== void 0 ? { frameNumber } : {}
-  };
-}
-
-// src/profiles/safety.ts
-var TOLERABLE_CODES = Object.freeze(
-  /* @__PURE__ */ new Set([
-    WARNING_CODES.ASTM_RECORD_UNKNOWN_TYPE,
-    WARNING_CODES.ASTM_NONSTANDARD_DELIMITERS,
-    WARNING_CODES.ASTM_UNKNOWN_ESCAPE_SEQUENCE,
-    WARNING_CODES.ASTM_RECORD_UNINTERPRETED_QUERY_STATUS
-  ])
-);
-var ALL_WARNING_CODES = [
-  ...Object.values(WARNING_CODES),
-  ...Object.values(FRAME_WARNING_CODES),
-  ...Object.values(LTP_WARNING_CODES)
-];
-var ALL_ASTM_WARNING_CODES = Object.freeze(
-  new Set(ALL_WARNING_CODES)
-);
-var SAFETY_CRITICAL_CODES = Object.freeze(
-  new Set(ALL_WARNING_CODES.filter((c) => !TOLERABLE_CODES.has(c)))
-);
-function isSafetyCriticalCode(code) {
-  return SAFETY_CRITICAL_CODES.has(code);
-}
-
 // src/profiles/validate.ts
 var KNOWN_OPTION_KEYS = [
   "name",
@@ -770,7 +848,7 @@ function validateTolerations(tolerate, profileName) {
     }
     if (isSafetyCriticalCode(t.code)) {
       throw new AstmProfileDefinitionError(
-        `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."`,
+        `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, an unrecognized record type, or a frame / LTP integrity warning). A profile quiets benign structural noise, never a deviation that could change a clinical reading, report a lost message boundary, or corrupt the wire: it can never make a bad checksum "ok", a cancelled result read "final", or quiet the warning that says two messages were read as one.`,
         profileName
       );
     }
@@ -820,7 +898,7 @@ var defaultProfile = defineAstmProfile({
 // 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: 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). Mostly syntactic encoding noise, with one measured exception: an escape sequence whose body is itself a delimiter is an opaque atom, so that delimiter does not split and a result can lose its units and its status. Read the values; do not rely on this profile leaving only cosmetic deviations behind.",
   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",
@@ -830,7 +908,7 @@ var referenceCorpus = defineAstmProfile({
   tolerate: [
     {
       code: "ASTM_UNKNOWN_ESCAPE_SEQUENCE",
-      rationale: "The OSS reference stack (python-astm codec.py, firsthand-verified) treats '&' as literal data and never decodes escape sequences, so streams from that ecosystem carry non-standard '&\u2026&' bodies our escape-aware tokenizer flags. The body is preserved byte-for-byte in the value; the deviation is recognizable, syntactic, and non-clinical."
+      rationale: "The OSS reference stack (python-astm codec.py, firsthand-verified) treats '&' as literal data and never decodes escape sequences, so streams from that ecosystem carry non-standard '&\u2026&' bodies our escape-aware tokenizer flags. The body is preserved byte-for-byte in the value. NOT always non-clinical, and this is measured rather than assumed: where the body is a delimiter, that delimiter never became a field boundary, so `28.6&|&U/L` reads as one value with no units and no final status. Tolerating this code hides that too."
     }
   ]
 });
@@ -855,7 +933,10 @@ function getDefaultAstmProfile() {
 }
 
 // src/common/escapes.ts
-function decodeEscapes(leaf, d, onUnknown) {
+function isEscapeSequenceAt(text, i, escape) {
+  return text.charAt(i) === escape && text.charAt(i + 2) === escape;
+}
+function decodeEscapes(leaf, d, onUnknown, onUnpaired) {
   const esc = d.escape;
   if (!leaf.includes(esc)) return leaf;
   let out = "";
@@ -867,12 +948,13 @@ function decodeEscapes(leaf, d, onUnknown) {
       i += 1;
       continue;
     }
-    const close = leaf.indexOf(esc, i + 1);
-    if (close === -1) {
-      out += leaf.slice(i);
-      break;
+    if (!isEscapeSequenceAt(leaf, i, esc)) {
+      out += ch;
+      i += 1;
+      onUnpaired?.();
+      continue;
     }
-    const body = leaf.slice(i + 1, close);
+    const body = leaf.charAt(i + 1);
     const replacement = escapeBody(body, d);
     if (replacement === void 0) {
       out += esc + body + esc;
@@ -880,7 +962,7 @@ function decodeEscapes(leaf, d, onUnknown) {
     } else {
       out += replacement;
     }
-    i = close + 1;
+    i += 3;
   }
   return out;
 }
@@ -905,14 +987,9 @@ function splitEscapeAware(text, delimiter, escape) {
   let i = 0;
   while (i < text.length) {
     const ch = text.charAt(i);
-    if (ch === escape) {
-      const close = text.indexOf(escape, i + 1);
-      if (close === -1) {
-        current += text.slice(i);
-        break;
-      }
-      current += text.slice(i, close + 1);
-      i = close + 1;
+    if (ch === escape && isEscapeSequenceAt(text, i, escape)) {
+      current += text.slice(i, i + 3);
+      i += 3;
       continue;
     }
     if (ch === delimiter) {
@@ -929,26 +1006,38 @@ function splitEscapeAware(text, delimiter, escape) {
 }
 
 // src/records/tokenize.ts
-function tokenizeRecord(record, d, onUnknownEscape) {
+function tokenizeRecord(record, d, onUnknownEscape, onUnpairedEscape) {
   const rawFields = splitEscapeAware(record, d.field, d.escape);
-  return rawFields.map((raw, fieldIndex) => toField(raw, d, () => onUnknownEscape?.(fieldIndex)));
+  return rawFields.map(
+    (raw, fieldIndex) => toField(
+      raw,
+      d,
+      () => onUnknownEscape?.(fieldIndex),
+      () => onUnpairedEscape?.(fieldIndex)
+    )
+  );
 }
-function tokenizeHeader(record, d, onUnknownEscape) {
+function tokenizeHeader(record, d, onUnknownEscape, onUnpairedEscape) {
   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));
+  const data = tokenizeRecord(
+    record.slice(defEnd + 1),
+    d,
+    (i) => onUnknownEscape?.(i + 2),
+    (i) => onUnpairedEscape?.(i + 2)
+  );
   return [...head, ...data];
 }
 function opaqueField(raw) {
   return { raw, components: [raw], repeats: [[raw]] };
 }
-function toField(raw, d, onUnknownEscape) {
+function toField(raw, d, onUnknownEscape, onUnpairedEscape) {
   const rawRepeats = splitEscapeAware(raw, d.repeat, d.escape);
   const repeats = rawRepeats.map(
     (rep) => splitEscapeAware(rep, d.component, d.escape).map(
-      (comp) => decodeEscapes(comp, d, onUnknownEscape)
+      (comp) => decodeEscapes(comp, d, onUnknownEscape, onUnpairedEscape)
     )
   );
   const components = repeats[0] ?? [""];
@@ -1063,7 +1152,15 @@ function buildRecord(line2, recordIndex, d, warnings) {
       unknownEscapeSequence({ recordIndex, recordType: rawType, fieldIndex: fieldIndex + 1 })
     );
   };
-  const fields = rawType === "H" ? tokenizeHeader(line2, d, onUnknownEscape) : tokenizeRecord(line2, d, onUnknownEscape);
+  const onUnpairedEscape = (fieldIndex) => {
+    warnings.push(
+      unpairedEscapeCharacter({ recordIndex, recordType: rawType, fieldIndex: fieldIndex + 1 })
+    );
+  };
+  const fields = rawType === "H" ? tokenizeHeader(line2, d, onUnknownEscape, onUnpairedEscape) : tokenizeRecord(line2, d, onUnknownEscape, onUnpairedEscape);
+  if (fields.length === 1 && line2.slice(1).trim().length > 0) {
+    warnings.push(fieldsUnseparated({ recordIndex, recordType: rawType }));
+  }
   switch (rawType) {
     case "H":
       return {
@@ -2197,8 +2294,8 @@ function concatBytes3(chunks) {
 }
 
 // src/index.ts
-var VERSION = "0.0.7";
+var VERSION = "0.0.9";
 
-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 };
+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, fieldsUnseparated, 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, unpairedEscapeCharacter, unparseableReferenceRange, unreadableRedeclaration };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map