@cosyte/astm 0.0.17 → 0.0.19

package/dist/index.cjs

@@ -271,10 +271,11 @@ var WARNING_CODES = {
   ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT: "ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT",
   /**
    * Two escape alignments of the same bytes disagreed about a **field** boundary, the reading taken
-   * kept it, and the escape character that reading resumes on **heads no sequence at all**, so the
-   * boundary was bought with a byte this reading cannot read while the competing alignment is
-   * exactly the reading that can. Every field after that point sits one place further right than the
-   * competing alignment puts it.
+   * kept it, and the escape character that reading resumes on **heads no sequence this codec can
+   * interpret**, so the boundary was bought with bytes this reading cannot read while the competing
+   * alignment is exactly the reading that can. Every field after that point sits one place further
+   * right than the competing alignment puts it, **except on the one class named at the end of this
+   * entry**, where the two readings instead read the same number of fields in different places.
    *
    * **The shift is the harm, and on a result record it reaches the status slot.** Measured on the
    * canonical set, `R|1|^^^687|28.6&F&|&U/L||||F` reads **9** fields under the reading taken and
@@ -305,30 +306,230 @@ var WARNING_CODES = {
    *   modeled *inside* a field: a Universal Test ID's four components are the LOINC-candidate slot,
    *   the test name, the **coding scheme** and the **local code**, and a patient name's three are
    *   last, first and middle. A gained component boundary shifts those, so a local code can be read
-   *   as a coding scheme and a given name as a middle name. Measured, and **where the earlier body is
-   *   a recognized mnemonic, reported by nothing** (only the tolerable
-   *   {@link WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER} fires, so a gate-legal profile accepts it).
-   *   An **unrecognized** earlier body raises
-   *   {@link WARNING_CODES.ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT} there and is refused, which is the
-   *   same split this code's own exclusion takes. It is a separate, open condition rather than something this
-   *   code covers, because wiring this sink to another split is a different criterion needing its own
-   *   population measurement. The repeat role costs the **value**, which this code does not report
-   *   either.
-   * - **The tail is weighed one construct deep.** Where the escape character the reading taken
-   *   resumes on heads a sequence this codec *recognizes*, the reading taken interprets it and the
-   *   competing alignment would leave it bare, so the bytes prefer the reading taken: under a set
-   *   naming the field separator `F`, `28.6&F&F&F&U/L` is that separator escaped, written, and
-   *   escaped again, and refusing it would be an over-refusal of a well-formed stream. Where it
-   *   heads a sequence whose body is *unrecognized*, the reading taken still consumes it while the
-   *   competing alignment would leave **two** escape characters bare, so the preference is stronger
-   *   again, and this stays silent there even though the field shift is real. That last case is the
-   *   named residue: measured, not overlooked.
+   *   as a coding scheme and a given name as a middle name. Measured, and it used to be reported by
+   *   nothing where the earlier body was a recognized mnemonic (only the tolerable
+   *   {@link WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER} fired, so a gate-legal profile accepted
+   *   it). It is now reported by
+   *   {@link WARNING_CODES.ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS}, a separate code on the same
+   *   tail test wired to the component split, because wiring this sink to another split is a
+   *   different criterion needing its own population measurement. It is still not something **this**
+   *   code covers. The repeat role costs the **value**, which this code does not report either, and
+   *   which {@link WARNING_CODES.ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD} reports.
+   * - **The tail is weighed one construct deep, and exactly one tail is excluded.** Where the escape
+   *   character the reading taken resumes on heads a sequence this codec *recognizes*, the reading
+   *   taken interprets a construct and leaves nothing unread: under a set naming the field separator
+   *   `F`, `28.6&F&F&F&U/L` is that separator escaped, written, and escaped again, entirely well
+   *   formed, and refusing it would be an over-refusal. That is the only tail on which a stream's
+   *   escaping can be clean, which is why it is the only exclusion. Where the tail heads a sequence
+   *   whose body is *unrecognized*, the reading taken consumes a triple it cannot read, preserved
+   *   verbatim and never guessed at, the field shift is the same shift, and **this reports it**.
+   *   Consuming a triple is not interpreting one.
+   * - **That remaining silence is a TRADE, not a claim that nothing was lost.** The gained field
+   *   boundary is exactly as real on the excluded tail, and there it is not merely under-reported:
+   *   it is `warnings: []`. Under the canonical set `R|1|^^^687|28.6&F&|&F&U/L||||F` reads **nine**
+   *   fields against the competing alignment's eight and hands back a status of **`final`** with an
+   *   empty warning list. Reporting it would refuse a stream whose escaping is working, which is
+   *   the trade this bound makes. **Read the raw line when an escape character sits next to a
+   *   delimiter, whether or not anything fired.**
+   *
+   * **⚠️ THE ONE CLASS WHERE NO FIELD INDEX MOVES, NAMED RATHER THAN LEFT TO BE FOUND.** Where the
+   * sequence past the boundary carries the **field separator itself** as its body, the reading taken
+   * holds that character inside an opaque atom while the competing alignment splits on it, so the
+   * two readings return the **same number** of fields in **different places**. Under the canonical
+   * set `R|1|^^^687|28.6&F&|&|&U/L||||F` reads nine fields under both, the status `F` sits in field
+   * 9 under both, and what differs is the units: `&|&U/L` against `&U/L`. This still fires there,
+   * which is over-reporting relative to the field indexes and never under-reporting, and the class
+   * costs no stream its disposition: that tail body is a splitting delimiter in force, so
+   * {@link WARNING_CODES.ASTM_RECORD_DELIMITER_SWALLOWED_BY_ESCAPE} has already refused the record.
+   * What holds on **every** firing tuple is that the two readings disagree and that both consume
+   * every byte, so neither is forced.
    *
    * **Catch it on the first read.** Emit rewrites the preserved sequences into recognized mnemonics,
    * and those bytes carry the reading that was taken unambiguously, so a second-generation read is
    * silent and is correct about its own bytes. A clean re-read is not evidence.
    */
   ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS: "ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS",
+  /**
+   * Two escape alignments of the same bytes disagreed about a **repeat** boundary, the reading
+   * taken kept it, and the escape character that reading resumes on **heads no sequence this codec
+   * can interpret**. Same contested position and same tail test as
+   * {@link WARNING_CODES.ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS}, on a different delimiter role, and
+   * what it costs is a different thing, which is why it is a different code.
+   *
+   * **Nothing shifts, and that is not the same as nothing being lost.** No field-indexed slot
+   * moves: the units and the result status are read out of the same field numbers under either
+   * alignment. What this reports is that **the field is read as more repeats than the competing
+   * alignment gives it**, which holds wherever it fires **except on the one class named at the end
+   * of this entry**. What that costs depends on **which** boundary was gained, and the two cases
+   * are stated separately rather than folded into one claim.
+   *
+   * **Where it is the FIRST boundary in the field, a modeled slot is lost**, because a field's
+   * modeled value and components are taken from its **first repeat alone**. Everything past the
+   * boundary stays on the wire and stays in `repeats`, and leaves every modeled slot:
+   *
+   * - **A value truncates.** Under `H|F^&`, `R|1|^^^687|28.6&S&F&U/L||||F` reads the value field as
+   *   the two repeats `28.6^` and `&U/L`, so a consumer reads `28.6^` and the rest of the value is
+   *   gone. The competing alignment reads one repeat carrying all of it.
+   * - **A modeled component list is deleted rather than shifted.** The same boundary inside a
+   *   Universal Test ID leaves the components of the first repeat only: under `H|F^&`,
+   *   `R|1|&F&F&687|28.6|U/L||||F` reads a UTID of one component holding a decoded field separator,
+   *   with no coding scheme and no local code, where the bytes carry `687`. A patient name loses
+   *   its given and middle names the same way. That is the half of this condition the shift report
+   *   could not cover, because components are modeled **inside** a field.
+   *
+   * Before this code the only warnings on those streams were **tolerable** ones
+   * ({@link WARNING_CODES.ASTM_NONSTANDARD_DELIMITERS} and, where the tail applies,
+   * {@link WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER}), so the widest gate-legal profile plus
+   * `{ strict: true }` accepted a truncated value and an emptied Universal Test ID.
+   *
+   * **Where it is a LATER boundary, no modeled slot moves and this still fires.** The first repeat
+   * is identical under both alignments, so the value, the components and every slot taken from them
+   * read the same either way (`R|1|^^^687|5.0F28.6&S&F&U/L||||F` under `H|F^&` reads a value of
+   * `5.0` under both), and what differs is the repeat structure after the first. It fires there
+   * deliberately: the boundary is still one the bytes do not force and a consumer reading `repeats`
+   * is still reading an alignment guess. Relative to the modeled slots that is **over-reporting,
+   * never under-reporting**. Narrowing it to the first boundary would change which streams a
+   * published package refuses and wants its own measurement, so the bound is written down instead.
+   *
+   * **It is a report, not a repair.** The split is unchanged, every decoded byte is identical,
+   * `repeats` still carries every one of them, and the value read is the value that was always
+   * read. Picking the other alignment would be a different guess with no more evidence behind it,
+   * on a published package.
+   *
+   * **Two further deliberate bounds, both stated rather than left to be found.**
+   * - **Only the repeat role.** The **component** role reaches a modeled slot too, and differently:
+   *   there the components stay in the record and move one slot along, so a local code reads as a
+   *   coding scheme and a given name as a middle name. That is measured and is now reported by
+   *   {@link WARNING_CODES.ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS}, a third code on the same tail
+   *   test wired to the component split. It is still not covered **here**, because wiring a sink to
+   *   another split is another criterion, which is why it took its own population measurement.
+   * - **The tail is weighed one construct deep**, exactly as for the shift report, **and exactly
+   *   one tail is excluded.** Where the escape character the reading resumes on heads a sequence
+   *   this codec *recognizes*, it interprets a construct and the repeats are the ones the sender
+   *   wrote: under a set naming the repeat separator `F`, `28.6&F&F&F&U/L` is that separator
+   *   escaped, written, and escaped again, entirely well formed, and refusing it would be an
+   *   over-refusal. That is the only tail on which a stream's escaping can be clean, which is why it
+   *   is the only exclusion. Where the tail heads a sequence whose body is *unrecognized*, the
+   *   reading taken consumes a triple it cannot read, preserved verbatim and never guessed at, the
+   *   truncation is the same truncation, and **this reports it**.
+   * - **That remaining silence is a TRADE, not a claim that nothing was lost.** On the excluded tail
+   *   the gained boundary is exactly as real and it is `warnings: []`: under the canonical set
+   *   `R|1|^^^687|28.6&S&\&S&U/L|U/L||||F` reads a value of `28.6^`, and `^U/L` leaves every
+   *   modeled slot, with an empty warning list. Reporting it would refuse a stream whose escaping
+   *   is working.
+   *
+   * **⚠️ THE ONE CLASS WHERE THE FIELD IS NOT READ AS MORE REPEATS, NAMED RATHER THAN LEFT TO BE
+   * FOUND.** Where the sequence past the boundary carries the **repeat separator itself** as its
+   * body, the reading taken holds that character inside an opaque atom while the competing
+   * alignment splits on it, so the two readings return the **same number** of repeats in
+   * **different places** and what differs is their contents: under the canonical set
+   * `28.6&F&\&\&U/L` reads two repeats under both. This still fires there, which is over-reporting
+   * relative to the repeat count and never under-reporting, and the class costs no stream its
+   * disposition: that tail body is a splitting delimiter in force, so
+   * {@link WARNING_CODES.ASTM_RECORD_DELIMITER_SWALLOWED_BY_ESCAPE} has already refused the record.
+   * What holds on **every** firing tuple is that the two readings disagree and that both consume
+   * every byte, so neither is forced.
+   *
+   * **Catch it on the first read.** Emit rewrites the preserved sequences into recognized
+   * mnemonics, and those bytes carry the reading that was taken unambiguously, so a
+   * second-generation read is silent and is correct about its own bytes. A clean re-read is not
+   * evidence.
+   */
+  ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD: "ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD",
+  /**
+   * Two escape alignments of the same bytes disagreed about a **component** boundary, the reading
+   * taken kept it, and the escape character that reading resumes on **heads no sequence this codec
+   * can interpret**. Same contested position and same tail test as
+   * {@link WARNING_CODES.ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS} and
+   * {@link WARNING_CODES.ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD}, on the third and last splitting
+   * role, and what it costs is a third thing again, which is why it is a third code.
+   *
+   * **The components are neither shifted out of the record nor dropped from it: they MOVE one slot
+   * along.** A field's components are modeled *inside* it, so a gained component boundary shifts
+   * every component after it exactly as a gained field boundary shifts every later field, **except
+   * on the one class named at the end of this entry**, where the two readings instead read the same
+   * number of components in different places. Nothing leaves the record and nothing changes field
+   * number; what changes is which modeled slot each component lands in, and those slots are named
+   * things:
+   *
+   * - **A Universal Test ID's coding scheme and local code.** Under the canonical set,
+   *   `R|1|&F&^&GLU^L^687|28.6|U/L||||F` reads four components, so `L` is the coding scheme and
+   *   `687` the vendor's local code. The competing alignment reads three, so `L` is the test name
+   *   and **`687` is the coding scheme**. A local code and a code-system selector are not the same
+   *   thing, and a consumer routing on one of them routes on the alignment.
+   * - **A patient's given and middle names.** `P|1||MRN-0001||DOE&F&^&JANE^A||19700101|F` reads a
+   *   given name of `&JANE` and a middle name of `A` under the reading taken, and under the
+   *   competing one `A` is the **given** name with no middle name at all.
+   *
+   * Before this code the only warning on those streams was the **tolerable**
+   * {@link WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER}, so the widest gate-legal profile plus
+   * `{ strict: true }` accepted a test identity and a patient name whose parts were decided by the
+   * alignment rather than by the sender.
+   *
+   * **Every gained boundary at or before the LAST MODELED COMPONENT INDEX moves a slot, not only
+   * the first, and that is the difference from the repeat role.** There the field is modeled out of
+   * its first repeat alone, so only the first gained boundary reaches a modeled slot; here the shift
+   * propagates from wherever the boundary sits to the end of the component list.
+   *
+   * **TWO bounds run the other way, and this fires inside both**, which is **over-reporting, never
+   * under-reporting**: the direction this package errs in. Both axes are swept on their own rather
+   * than left to the shared corpus, which holds them fixed, and neither is closed by narrowing the
+   * guard, because narrowing changes which streams a published package refuses and wants its own
+   * measurement.
+   *
+   * - **Past the last modeled component index, nothing NAMED moves.** A model reads a fixed number
+   *   of components: a patient name three (last, first, middle), a Universal Test ID four. A
+   *   contested boundary further right than that still shifts the components after it while every
+   *   named slot reads byte-identically under both alignments.
+   * - **Inside a LATER repeat nothing modeled moves at all**, because `components` is the first
+   *   repeat, so what changes is `repeats[n]` for that `n` alone.
+   *
+   * It fires in both because the boundary is still one the bytes do not force, and a consumer
+   * reading `components` or `repeats` is still reading an alignment guess.
+   *
+   * **It is a report, not a repair.** The split is unchanged, every decoded byte is identical, and
+   * the components read are the components that were always read. Picking the other alignment would
+   * be a different guess with no more evidence behind it, on a published package. **Withholding the
+   * moved slots is a separate question and is deliberately not answered here**, for the reason the
+   * shift report already gives: declining to model a slot changes an extracted value for every
+   * consumer of a package already on the registry.
+   *
+   * **The tail is weighed one construct deep**, exactly as for the other two, **and exactly one tail
+   * is excluded.** Where the escape character the reading resumes on heads a sequence this codec
+   * *recognizes*, it interprets a construct and the components are the ones the sender wrote: under
+   * a set naming the component separator `F`, `GLU&F&F&F&L` is that separator escaped, written, and
+   * escaped again, entirely well formed, and refusing it would be an over-refusal. That is the only
+   * tail on which a stream's escaping can be clean, which is why it is the only exclusion. Where the
+   * tail heads a sequence whose body is *unrecognized*, the reading taken consumes a triple it
+   * cannot read, preserved verbatim and never guessed at, the slots move exactly as far, and **this
+   * reports it**.
+   *
+   * **That remaining silence is a TRADE, not a claim that nothing was lost.** On the excluded tail
+   * the gained boundary is exactly as real and it is `warnings: []`: under the canonical set
+   * `&F&^&F&GLU^L^687` reads one component more than the competing alignment, so `L` is the coding
+   * scheme and `687` the local code under one reading and `687` the **coding scheme** under the
+   * other, with an empty warning list. Reporting it would refuse a stream whose escaping is
+   * working.
+   *
+   * **⚠️ THE ONE CLASS WHERE NO COMPONENT INDEX MOVES, NAMED RATHER THAN LEFT TO BE FOUND.** It is a
+   * **third** bound running the other way, and unlike the two above it is about the bytes past the
+   * boundary rather than about where the boundary sits. Where the sequence past it carries the
+   * **component separator itself** as its body, the reading taken holds that character inside an
+   * opaque atom while the competing alignment splits on it, so the two readings return the **same
+   * number** of components in **different places** and what differs is their contents: under the
+   * canonical set `P|1||MRN-0001||DOE&F&^&^&JANE^A||19700101|F` reads three components under both,
+   * with `A` the middle name under both. This still fires there, and the class costs no stream its
+   * disposition: that tail body is a splitting delimiter in force, so
+   * {@link WARNING_CODES.ASTM_RECORD_DELIMITER_SWALLOWED_BY_ESCAPE} has already refused the record.
+   * What holds on **every** firing tuple is that the two readings disagree and that both consume
+   * every byte, so neither is forced.
+   *
+   * **Catch it on the first read.** Emit rewrites the preserved sequences into recognized
+   * mnemonics, and those bytes carry the reading that was taken unambiguously, so a
+   * second-generation read is silent and is correct about its own bytes. A clean re-read is not
+   * evidence.
+   */
+  ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS: "ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS",
   /** An escape sequence body was not one of `&F&`/`&S&`/`&R&`/`&E&`: preserved verbatim. */
   ASTM_UNKNOWN_ESCAPE_SEQUENCE: "ASTM_UNKNOWN_ESCAPE_SEQUENCE",
   /**
@@ -484,7 +685,21 @@ function ambiguousEscapeAlignment(position) {
 function alignmentShiftedFields(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS,
-    message: "A field boundary here is one of two escape alignments the bytes carry, and the reading that took it resumes on an escape character heading no sequence, which the other alignment uses to close one. Every later field is one place further right than the other reading puts it, so a result's units and status may be read out of slots the sender did not put them in. The reading was kept and every byte is preserved.",
+    message: "A field boundary here is one of two escape alignments the bytes carry, and the reading that took it resumes on an escape character heading no sequence this reader can interpret, which the other alignment uses to close one. The two readings disagree, and both consume every byte, so neither is forced. Usually every later field is one place further right than the other reading puts it, so a result's units and status may be read out of slots the sender did not put them in; one measured class does not shift at all, where the sequence past the boundary carries the field separator itself and the two readings read the same number of fields with different contents. The reading was kept and every byte is preserved.",
+    position
+  };
+}
+function alignmentTruncatedField(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD,
+    message: "A repeat boundary here is one of two escape alignments the bytes carry, and the reading that took it resumes on an escape character heading no sequence this reader can interpret, which the other alignment uses to close one. The two readings disagree, and both consume every byte, so neither is forced. Usually this field is read as more repeats than the other reading gives it, and its modeled value and components are taken from the first repeat alone, so where that boundary is the first one the rest of the field leaves every modeled slot; one measured class reads the same number of repeats, where the sequence past the boundary carries the repeat separator itself. The reading was kept and every byte is preserved.",
+    position
+  };
+}
+function alignmentShiftedComponents(position) {
+  return {
+    code: WARNING_CODES.ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS,
+    message: "A component boundary here is one of two escape alignments the bytes carry, and the reading that took it resumes on an escape character heading no sequence this reader can interpret, which the other alignment uses to close one. The two readings disagree, and both consume every byte, so neither is forced. Usually every later component of this field sits one place further right than the other reading puts it, so a test identity's coding scheme and local code, or a patient's given and middle names, may be read out of slots the sender did not put them in; one measured class does not move at all, where the sequence past the boundary carries the component separator itself and the two readings read the same number of components with different contents. The reading was kept and every byte is preserved.",
     position
   };
 }
@@ -1113,7 +1328,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. 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. That subset now also raises ASTM_RECORD_DELIMITER_SWALLOWED_BY_ESCAPE, which this profile cannot tolerate, so tolerating this code no longer hides it. The same holds for the mirror case, where a sequence ends where another could have begun and a delimiter splits that the other alignment would have held: that raises ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT, which this profile cannot tolerate either. Where that gained boundary is a field boundary and the reading taken resumes on an escape character heading no sequence, every later field shifts and a result's units and status move with it, which raises ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS, untolerable here as well."
+      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. That subset now also raises ASTM_RECORD_DELIMITER_SWALLOWED_BY_ESCAPE, which this profile cannot tolerate, so tolerating this code no longer hides it. The same holds for the mirror case, where a sequence ends where another could have begun and a delimiter splits that the other alignment would have held: that raises ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT, which this profile cannot tolerate either. Where that gained boundary is a field boundary and the reading taken resumes on an escape character heading no sequence this reader can interpret, every later field shifts and a result's units and status move with it, which raises ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS, untolerable here as well. Where that same gained boundary is a repeat boundary, nothing shifts but the field is read out of its first repeat alone, so a value truncates and a test identity empties, which raises ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD, untolerable here too. Where it is a component boundary, nothing leaves the record and no field number changes, and every component after it moves one slot along, so a test identity's coding scheme and local code and a patient's given and middle names are read out of positions the other alignment does not put them in, which raises ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS, untolerable here as well. Each of those three shift claims has one measured exception, where the sequence past the boundary carries the splitting delimiter itself: the two readings then read the same number of segments in different places, nothing moves index, and the record was already refused by ASTM_RECORD_DELIMITER_SWALLOWED_BY_ESCAPE. All three carry the same tail bound and stay silent in exactly one case, where the escape character past the boundary heads a sequence this reader RECOGNIZES, which is the escape mechanism working. How often that happens on this corpus is NOT measured and must not be guessed at: the firsthand grounding above is of the DECODE path only, and a relayed stream can still carry a device-written mnemonic. Tolerating this code does not quiet those three, and their absence is not a statement that nothing was lost."
     }
   ]
 });
@@ -1141,6 +1356,9 @@ function getDefaultAstmProfile() {
 function isEscapeSequenceAt(text, i, escape) {
   return text.charAt(i) === escape && text.charAt(i + 2) === escape;
 }
+function headsInterpretableSequence(text, i, escape) {
+  return isEscapeSequenceAt(text, i, escape) && isMnemonicBody(text.charAt(i + 1));
+}
 function decodeEscapes(leaf, d, onUnknown, onUnpaired, onSwallowedDelimiter) {
   const esc = d.escape;
   if (!leaf.includes(esc)) return leaf;
@@ -1187,7 +1405,7 @@ function isMnemonicBody(body) {
 function escapeBody(body, d) {
   return isMnemonicBody(body) ? d[MNEMONIC_ROLES[body]] : void 0;
 }
-function splitEscapeAware(text, delimiter, escape, onAmbiguousAlignment, onShiftedFields) {
+function splitEscapeAware(text, delimiter, escape, onAmbiguousAlignment, onShiftedFields, onTruncatedField, onShiftedComponents) {
   if (text.length === 0) return [""];
   const out = [];
   let current = "";
@@ -1199,8 +1417,10 @@ function splitEscapeAware(text, delimiter, escape, onAmbiguousAlignment, onShift
       if (contested && !isMnemonicBody(text.charAt(i + 1))) {
         onAmbiguousAlignment?.(out.length);
       }
-      if (contested && !isEscapeSequenceAt(text, i + 4, escape)) {
+      if (contested && !headsInterpretableSequence(text, i + 4, escape)) {
         onShiftedFields?.(out.length);
+        onTruncatedField?.(out.length);
+        onShiftedComponents?.(out.length);
       }
       current += text.slice(i, i + 3);
       i += 3;
@@ -1220,7 +1440,7 @@ function splitEscapeAware(text, delimiter, escape, onAmbiguousAlignment, onShift
 }
 
 // src/records/tokenize.ts
-function tokenizeRecord(record, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment, onAlignmentShiftedFields) {
+function tokenizeRecord(record, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment, onAlignmentShiftedFields, onAlignmentTruncatedField, onAlignmentShiftedComponents) {
   const rawFields = splitEscapeAware(
     record,
     d.field,
@@ -1235,11 +1455,18 @@ function tokenizeRecord(record, d, onUnknownEscape, onUnpairedEscape, onSwallowe
       () => onUnknownEscape?.(fieldIndex),
       () => onUnpairedEscape?.(fieldIndex),
       () => onSwallowedDelimiter?.(fieldIndex),
-      () => onAmbiguousAlignment?.(fieldIndex)
+      () => onAmbiguousAlignment?.(fieldIndex),
+      // The repeat split runs INSIDE one field, so the index it hands back is a repeat index and is
+      // discarded: what a caller needs is which field carries the contested boundary, and that is
+      // the index this map is already iterating.
+      () => onAlignmentTruncatedField?.(fieldIndex),
+      // Likewise for the component split, which runs inside one repeat of one field: the index it
+      // hands back is a component index and is discarded for the same reason.
+      () => onAlignmentShiftedComponents?.(fieldIndex)
     )
   );
 }
-function tokenizeHeader(record, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment, onAlignmentShiftedFields) {
+function tokenizeHeader(record, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment, onAlignmentShiftedFields, onAlignmentTruncatedField, onAlignmentShiftedComponents) {
   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)];
@@ -1251,21 +1478,42 @@ function tokenizeHeader(record, d, onUnknownEscape, onUnpairedEscape, onSwallowe
     (i) => onUnpairedEscape?.(i + 2),
     (i) => onSwallowedDelimiter?.(i + 2),
     (i) => onAmbiguousAlignment?.(i + 2),
-    (i) => onAlignmentShiftedFields?.(i + 2)
+    (i) => onAlignmentShiftedFields?.(i + 2),
+    (i) => onAlignmentTruncatedField?.(i + 2),
+    (i) => onAlignmentShiftedComponents?.(i + 2)
   );
   return [...head, ...data];
 }
 function opaqueField(raw) {
   return { raw, components: [raw], repeats: [[raw]] };
 }
-function toField(raw, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment) {
-  const rawRepeats = splitEscapeAware(raw, d.repeat, d.escape, () => {
-    onAmbiguousAlignment();
-  });
-  const repeats = rawRepeats.map(
-    (rep) => splitEscapeAware(rep, d.component, d.escape, () => {
+function toField(raw, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment, onAlignmentTruncatedField, onAlignmentShiftedComponents) {
+  const rawRepeats = splitEscapeAware(
+    raw,
+    d.repeat,
+    d.escape,
+    () => {
       onAmbiguousAlignment();
-    }).map(
+    },
+    void 0,
+    () => {
+      onAlignmentTruncatedField();
+    }
+  );
+  const repeats = rawRepeats.map(
+    (rep) => splitEscapeAware(
+      rep,
+      d.component,
+      d.escape,
+      () => {
+        onAmbiguousAlignment();
+      },
+      void 0,
+      void 0,
+      () => {
+        onAlignmentShiftedComponents();
+      }
+    ).map(
       (comp) => decodeEscapes(comp, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter)
     )
   );
@@ -1412,6 +1660,16 @@ function buildRecord(line2, recordIndex, d, warnings) {
       alignmentShiftedFields({ recordIndex, recordType: rawType, fieldIndex: fieldIndex + 1 })
     );
   };
+  const onAlignmentTruncatedField = (fieldIndex) => {
+    warnings.push(
+      alignmentTruncatedField({ recordIndex, recordType: rawType, fieldIndex: fieldIndex + 1 })
+    );
+  };
+  const onAlignmentShiftedComponents = (fieldIndex) => {
+    warnings.push(
+      alignmentShiftedComponents({ recordIndex, recordType: rawType, fieldIndex: fieldIndex + 1 })
+    );
+  };
   const fields = rawType === "H" ? tokenizeHeader(
     line2,
     d,
@@ -1419,7 +1677,9 @@ function buildRecord(line2, recordIndex, d, warnings) {
     onUnpairedEscape,
     onSwallowedDelimiter,
     onAmbiguousAlignment,
-    onAlignmentShiftedFields
+    onAlignmentShiftedFields,
+    onAlignmentTruncatedField,
+    onAlignmentShiftedComponents
   ) : tokenizeRecord(
     line2,
     d,
@@ -1427,7 +1687,9 @@ function buildRecord(line2, recordIndex, d, warnings) {
     onUnpairedEscape,
     onSwallowedDelimiter,
     onAmbiguousAlignment,
-    onAlignmentShiftedFields
+    onAlignmentShiftedFields,
+    onAlignmentTruncatedField,
+    onAlignmentShiftedComponents
   );
   if (fields.length === 1 && line2.slice(1).trim().length > 0) {
     warnings.push(fieldsUnseparated({ recordIndex, recordType: rawType }));
@@ -2640,7 +2902,7 @@ function concatBytes3(chunks) {
 }
 
 // src/index.ts
-var VERSION = "0.0.17";
+var VERSION = "0.0.19";
 
 exports.ALL_ASTM_WARNING_CODES = ALL_ASTM_WARNING_CODES;
 exports.AMBIGUOUS_CODES = AMBIGUOUS_CODES;
@@ -2664,7 +2926,9 @@ exports.SAFETY_CRITICAL_CODES = SAFETY_CRITICAL_CODES;
 exports.TOLERABLE_CODES = TOLERABLE_CODES;
 exports.VERSION = VERSION;
 exports.WARNING_CODES = WARNING_CODES;
+exports.alignmentShiftedComponents = alignmentShiftedComponents;
 exports.alignmentShiftedFields = alignmentShiftedFields;
+exports.alignmentTruncatedField = alignmentTruncatedField;
 exports.ambiguousEscapeAlignment = ambiguousEscapeAlignment;
 exports.ambiguousMessageKind = ambiguousMessageKind;
 exports.ambiguousValueSplit = ambiguousValueSplit;