@cosyte/astm 0.0.20 → 0.0.21

package/CHANGELOG.md

@@ -444,6 +444,10 @@ this file is maintained by hand (Changesets handles the version bump and publish
   that could ever protect conformant traffic, and refusing it is the over-refusal that sank a
   criterion measured and rejected for this same family. The widened predicate **cannot** refuse an
   escape-clean stream: every position it now rejects already raises an escape deviation of its own.
+  **Both sentences in this paragraph are scoped later in this same release**, under "The companion
+  universal is false where the declaration names the escape character in a splitting role too": they
+  hold wherever the escape role is a character distinct from the three splitting roles, and not where
+  it is not. They are kept as written because the measurement this entry records starts from them.
 
   **That remaining silence is a TRADE, and it is not a claim that nothing was lost there.** On the
   excluded tail the gained boundary is exactly as real, and it is not merely under-reported: it is
@@ -1072,6 +1076,126 @@ this file is maintained by hand (Changesets handles the version bump and publish
 
 ### Documented
 
+- **The corpus that certifies the contested-alignment correction never observed one of the three
+  codes it certifies, and three of the figures the correction quotes were asserted only as "more
+  than zero".** `PRE-EXISTING`, all three named by the refuter passes on the preceding slice and
+  backlogged there rather than closed. No guard moves: no runtime code is added, removed or renamed,
+  no split changes, no extracted value moves, no stream's disposition changes, and no exported
+  surface moves.
+  - **The companion corpus wired only the repeat and component roles, so the
+    `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS` orphan population was outside it.** Which role a
+    declaration puts the swept character in decides where the collision is; which delimiter the
+    contested reading gains a boundary on decides which of the three codes fires. They are
+    independent axes, and both arms of that corpus held the second one fixed by keeping the
+    contested construct inside a single field of the carrier. Measured, that corpus observes
+    `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS` **zero** times, which is now asserted rather than left to
+    be noticed. Two field arms sweep it: the collision stays in the repeat or component role, where
+    it is expressible, while the gained boundary is on the field separator, which the swept
+    character never is. That is what puts a field-code orphan in reach even though the field role
+    cannot collide with the escape role. The arms pin their own figures: the distinct arm is 1,296
+    tuples where 432 fire and **0** are orphans, the colliding arm is 1,296 tuples where 360 fire
+    and **144** are orphans, and every one of those 144 carries
+    `ASTM_RECORD_DELIMITER_ROLE_COLLISION` and is refused by the widest profile the safety gate
+    permits, before and after. `H|F^F` with `C|1|I|FFF|F|G` is one of them, written out in full. The
+    union assertions that carry the correction now read over all four arms, and on the wider
+    "any tail code fired" population rather than on the one code each arm was built to observe.
+  - **Three figures could drift with the suite staying green.** The report-count corpus asserted its
+    firing population, its under-stating class and its over-stating class as "more than zero", so a
+    corpus that had quietly lost nine tenths of each would still have passed. They are pinned now
+    (3,072 firing, 1,568 carrying one warning on a displacement of two, 320 carrying two warnings on
+    a displacement of one, 64 in the tie class), together with the whole joint distribution of
+    report count against displacement, so any cell that moves reds the suite and names itself.
+    Pinning the table surfaced a fact none of the three figures carried: **there is no cell at zero
+    reports and zero displacement.** Every tuple this code says nothing about is displaced anyway,
+    by one or by two, which is the standing exclusion for a recognized tail doing what it is for and
+    is the silent third direction in which counting warnings fails.
+  - **The retired universal, and the sites this entry changed.** The three test files that were
+    recorded, plus `alignment-unrecognized-tail.test.ts` and
+    `alignment-criterion-population.test.ts`, which word the same fact differently, plus the
+    corollary about the escape companion at the "refuses NOT ONE escape-clean stream" tests in the
+    first three. Each is cut or scoped rather than re-qualified in fresh words: the unqualified
+    sentence is gone, the corpus's own bound (it holds the escape role at `&`) is stated in its
+    place, and what that bound is worth is named at the file that measures it. The predicate's own
+    implementation site in `src/common/escapes.ts` is scoped too, and the claim in the doc block on
+    the private `headsInterpretableSequence` that it was "the single place that says what happens
+    there" is deleted rather than repaired, having already been false against the README. Neither string reaches `dist/index.d.ts`, and no
+    behaviour, no warning code and no documented surface moves. The paragraph earlier in this
+    release that states it unqualified is kept as written, because the measurement it records starts
+    from it, and now says where it is scoped.
+
+- **Two claims the contested-alignment codes rest on were false, and both were on consumer
+  surfaces.** `PRE-EXISTING`, both named by the third refuter pass on the tail-residue slice and
+  backlogged there rather than closed. No guard moves, no code is added, removed or renamed, no
+  split changes, no extracted value moves, and no stream's disposition changes. The remedy is the
+  claim, for the fifth time in this family.
+  - **The companion universal is false where the declaration names the escape character in a
+    splitting role too.** The three tail codes rest on a defence against over-refusal: firing
+    requires an escape character heading no sequence this codec can interpret, and the package
+    already reports each of those, so a stream whose escaping raises nothing can never be refused.
+    That was written and asserted as a universal over the whole firing population. Every corpus in
+    this family fixes the escape role at `&`, so none of them could see the case that breaks it. On
+    a colliding set one byte both opens a sequence and ends a segment, the split claims it first,
+    and neither escape report ever sees a sequence to raise: a tail code fires with **neither**
+    companion. Measured on the committed corpus in
+    `test/records/alignment-companion-universal.test.ts`, whose figures that file pins so they can be
+    re-derived: the distinct arm is 2,304 tuples, 1,536 fire, **0** are orphans; the collides arm is
+    1,008 tuples, 648 fire, **288** are orphans, and **0** orphan in either arm lacks
+    `ASTM_RECORD_DELIMITER_ROLE_COLLISION`. The defence
+    therefore survives in the form it was needed in (no stream whose escaping **and** whose
+    declaration are both clean is refused by a tail code) and not in the form it was written in.
+    **That replacement is scoped to the STREAM and does not hold per message**: the collision is
+    reported once per set change rather than once per record, so a second header re-declaring the
+    same colliding set raises nothing while the tail codes in its message fire again, leaving a
+    consumer that scopes warnings to a message looking at one of the three codes standing entirely
+    alone. Also measured, and stated because "three splitting roles" reads as three reachable
+    collisions: the **field** role cannot collide with the escape role at all, because the
+    declaration is the three characters after the field separator and stops at the next one, so
+    such a header terminates itself one character short and is refused.
+  - **"One place further right" understates.** It is a floor, not a figure, and it was already
+    known to be wrong in one direction (the tie class, where the offset is zero). It is wrong in
+    the other direction too, and every corpus in this family fixes the axis that shows it: they
+    carry exactly one contested construct per record. The competing reading resumes a character
+    further on at each contested position, so it falls further out of step and the gap widens once
+    per construct. `A&Z&|&BX&Z&|&F&C` reads **three** fields against **one**, and a chain of n
+    constructs displaces by n, measured to n = 6. **The number of warnings is not the displacement
+    either, in either direction**: over 3,072 firing tuples on a two-construct corpus, one warning
+    sits on a displacement of two in 1,568 of them (a gained boundary whose tail is a recognized
+    mnemonic is excluded from the report and still displaces) and two warnings sit on a
+    displacement of one in 320 (one of the constructs is a tie). A consumer cannot recover the
+    offset by counting, and the corrected surfaces say to read the raw line instead. The practical
+    consequence is that one code covers two opposite outcomes: on
+    `R|1|^^^687|28.6&F&|&Z&U/L||||F` the sender's trailing `F` lands **in** the status slot and
+    reads as `final`, while on `R|1|^^^687|28.6&Z&|&BX&Z&|&F&U/L||||F` the same displacement runs
+    twice, the `F` overshoots, and the status reads `unspecified`.
+  - **Every other surface now names the KIND of cost and leaves the MAGNITUDE to one paragraph.**
+    That is the rule the tail-residue slice paid three refuter passes for: a paraphrase at each sink
+    is a separate claim that goes stale on its own, and seven copies of one had survived two sweeps.
+    Both corrected statements live on `ShiftedFieldsSink`, which is exported and therefore reaches
+    `dist/index.d.ts`, and which all three warning factories already point at. The magnitude was
+    being paraphrased in **three** different vocabularies ("one place further right", "shifts every
+    later field one place", "moves one slot along"), which is why the first sweep of this slice
+    missed most of them; a newline-folded grep over all three found nineteen, in
+    `src/common/escapes.ts`, `src/common/warnings.ts` (including the three `WARNING_CODES` registry
+    entries and the three runtime messages), `src/profiles/safety.ts`,
+    `src/profiles/reference-corpus.ts` (a runtime string), `src/records/parse.ts`,
+    `src/records/tokenize.ts`, `README.md`, `docs-content/troubleshooting.md`,
+    `docs-content/quickstart.md` and `docs-content/limitations.md`. All of them are corrected. The
+    three runtime **messages**, which no gate in this repo reads for truth, now say the displacement
+    is not fixed, name its three values, and tell the operator that counting warnings does not give
+    it.
+  - **"At least one place" was rejected as the replacement wording**, although it was the obvious
+    one: it contradicts the tie class named in the same sentence, where the displacement is zero.
+    Every corrected surface says the displacement is **not fixed** and names its three values
+    instead.
+  - **Both were RED before and are GREEN after, against the retired assertions verbatim.**
+    `alignment-shifted-fields.test.ts` asserted `leftmost.length === competing.length + 1` and
+    `alignment-unrecognized-tail.test.ts` asserted an escape companion on every firing tuple; on the
+    swept axes the first reads 10 against an expected 9 and the second reads false. Both files now
+    scope those assertions to the corpus that measures them instead of stating them as universals.
+    Pinned in `test/records/alignment-companion-universal.test.ts` and
+    `test/records/alignment-offset-rephasing.test.ts`, each sweeping the axis its family's corpora
+    hold fixed, each carrying a negative control that is run rather than declared.
+
 - **A header delimiter-declaration surplus loses all 31 of the C0/`DEL` characters that can reach
   it, and the published surfaces stated the preservation rule without that exception.**
   `PRE-EXISTING`; the

package/README.md

@@ -244,7 +244,10 @@ gained repeat or component boundary does reach a modeled slot, and each of those
 its own below. It stays silent in exactly one case,
 where the trailing escape character heads a sequence this reader RECOGNIZES: that is the escape
 mechanism working, and refusing it would refuse well-formed traffic. That is the only tail on which
-a stream's escaping can be clean, which is why it is the only exclusion. **That silence is a trade
+a stream's escaping can be clean, and so the only exclusion, **wherever the escape role is a
+character distinct from the three splitting roles**. Where a header names the escape character in a
+splitting role too, these codes can fire with neither escape report beside them, and what refuses the
+stream is `ASTM_RECORD_DELIMITER_ROLE_COLLISION` instead. **That silence is a trade
 and not a claim that nothing was lost there**: the gained field boundary is exactly as real, and on
 that tail it is `warnings: []`, so `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 nothing reported at all. Read
@@ -285,8 +288,10 @@ read as more repeats at all, and that class was already refused by
 survive a re-emit either: catch it on the first read.
 
 **And where that gained boundary is a COMPONENT boundary, nothing leaves the record and the slots
-MOVE.** Components are modeled inside a field, so every component after the gained boundary sits one
-place further right than the competing alignment puts it. On the canonical set,
+MOVE.** Components are modeled inside a field, so every component after the gained boundary sits
+further right than the competing alignment puts it, by a displacement that is **not fixed**: one
+place where the field carries a single contested construct, one more for each additional one, and
+none at all on the tie class. Counting warnings does not give it. On the canonical set,
 `R|1|&F&^&GLU^L^687|28.6|U/L||||F` reads a Universal Test ID of four components, so `L` is the coding
 scheme and `687` the vendor's local code; the competing alignment reads three, and `687` is the
 **coding scheme**. A code-system selector and a vendor's local code are not the same thing.
@@ -407,15 +412,15 @@ outside it:
   where the leftmost alignment lets a delimiter split that a competing alignment would have held,
   gains a boundary instead of losing one and raises `ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT`, also
   not tolerable. Where that gained boundary is a **field** boundary and the reading taken resumes on
-  an escape character heading no sequence it can interpret, every later field shifts one place and a
+  an escape character heading no sequence it can interpret, every later field shifts and a
   result's units
   and status are read out of slots the other alignment does not put them in: that raises
   `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS`, not tolerable either. Where it is a **repeat** boundary
   nothing shifts, but the field is read out of its first repeat alone, so a gained first boundary
   truncates a value and costs a test identity or a patient name the components that sat after it:
   that raises `ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD`, not tolerable either. Where it is a
-  **component** boundary nothing leaves the record and every component after it moves one slot
-  along, so a coding scheme, a vendor local code or a given name is read out of a position the other
+  **component** boundary nothing leaves the record and every component after it moves along the
+  component list, so a coding scheme, a vendor local code or a given name is read out of a position the other
   alignment does not put it in: that raises `ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS`, not
   tolerable either.
 

package/dist/index.cjs

@@ -273,9 +273,12 @@ var WARNING_CODES = {
    * 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 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.
+   * alignment is exactly the reading that can. Every field after that point sits further
+   * right than the competing alignment puts it, by a displacement that is **not fixed**: one place
+   * on a record carrying a single contested construct, one more for each additional one, and none
+   * at all **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. Counting these warnings does not give it; see
+   * {@link ShiftedFieldsSink}.
    *
    * **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
@@ -320,7 +323,8 @@ var WARNING_CODES = {
    *   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
+   *   escaping can be clean, on the declarations {@link ShiftedFieldsSink} scopes that to, 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.
@@ -398,8 +402,8 @@ var WARNING_CODES = {
    *
    * **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
+   *   there the components stay in the record and move along the component list, 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.
@@ -408,8 +412,8 @@ var WARNING_CODES = {
    *   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
+   *   over-refusal. That is the only tail on which a stream's escaping can be clean, on the
+   *   declarations {@link ShiftedFieldsSink} scopes that to, 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
@@ -444,10 +448,11 @@ var WARNING_CODES = {
    * {@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
+   * **The components are neither shifted out of the record nor dropped from it: they MOVE along the
+   * component list.** 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, by the
+   * displacement {@link ShiftedFieldsSink} states, **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:
@@ -499,7 +504,8 @@ var WARNING_CODES = {
    * *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 on which a stream's escaping can be clean, on the declarations
+   * {@link ShiftedFieldsSink} scopes that to, 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**.
@@ -685,21 +691,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 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.",
+    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. How far the later fields are displaced is NOT fixed: one place where the record carries a single contested construct, one more for each additional one, and none at all on one measured class, where the sequence past the boundary carries the field separator itself and the two readings read the same number of fields with different contents. So a result's units and status may be read out of slots the sender did not put them in. Counting these warnings does not give the displacement. Read the raw line. 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.",
+    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. How many more repeats this field is read as is NOT fixed: one where the record carries a single contested construct, one more for each additional one, and none at all on one measured class, where the sequence past the boundary carries the repeat separator itself. 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. Counting these warnings does not give the difference. Read the raw line. 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.",
+    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. How far the later components of this field are displaced is NOT fixed: one place where the field carries a single contested construct, one more for each additional one, and none at all on one measured class, where the sequence past the boundary carries the component separator itself and the two readings read the same number of components with different contents. 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. Counting these warnings does not give the displacement. Read the raw line. The reading was kept and every byte is preserved.",
     position
   };
 }
@@ -1328,7 +1334,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 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."
+      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 along the component list, 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."
     }
   ]
 });
@@ -2902,7 +2908,7 @@ function concatBytes3(chunks) {
 }
 
 // src/index.ts
-var VERSION = "0.0.20";
+var VERSION = "0.0.21";
 
 exports.ALL_ASTM_WARNING_CODES = ALL_ASTM_WARNING_CODES;
 exports.AMBIGUOUS_CODES = AMBIGUOUS_CODES;