@cosyte/astm 0.0.17 → 0.0.19

package/dist/index.d.ts

@@ -180,10 +180,11 @@ declare const WARNING_CODES: {
     readonly 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
@@ -214,30 +215,230 @@ declare const 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.
      */
     readonly 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.
+     */
+    readonly 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.
+     */
+    readonly ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS: "ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS";
     /** An escape sequence body was not one of `&F&`/`&S&`/`&R&`/`&E&`: preserved verbatim. */
     readonly ASTM_UNKNOWN_ESCAPE_SEQUENCE: "ASTM_UNKNOWN_ESCAPE_SEQUENCE";
     /**
@@ -493,15 +694,21 @@ declare function ambiguousEscapeAlignment(position: AstmPosition): AstmRecordWar
 /**
  * Build an `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS` warning. Emitted when a competing escape
  * alignment decided a **field** boundary and the escape character the reading taken resumes on
- * heads no sequence of its own, so every field after that point sits one place further right than
+ * heads no sequence this codec can interpret, so every field after that point sits one place further
+ * right than
  * the competing alignment puts it. On a result record that reaches the units and the **result
  * status**: a trailing status letter lands in field 9 under the reading taken and in no field at
- * all under the competing one.
- *
- * A profile may **not** tolerate this code. It fires alongside
- * {@link WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER}, which remains tolerable and reports the
- * strictly weaker fact that one escape character was read as a literal, and alongside
- * {@link WARNING_CODES.ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT} where that also applies. The reading
+ * all under the competing one. **Except where the sequence past the boundary carries the field
+ * separator itself**, where the two readings read the same number of fields in different places and
+ * no field index moves; see {@link WARNING_CODES.ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS}.
+ *
+ * A profile may **not** tolerate this code. **Which tolerable escape report accompanies it depends
+ * on the tail**: {@link WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER} where the tail heads no
+ * sequence at all, and {@link WARNING_CODES.ASTM_UNKNOWN_ESCAPE_SEQUENCE} where it heads one whose
+ * body is unrecognized. Both report strictly weaker facts, and wherever the escape role is a
+ * character distinct from the three splitting roles one of them always fires beside this code. It
+ * fires alongside {@link WARNING_CODES.ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT} where that also
+ * applies. The reading
  * is unchanged: this reports the shift, it does not repair it.
  *
  * @example
@@ -511,6 +718,70 @@ declare function ambiguousEscapeAlignment(position: AstmPosition): AstmRecordWar
  * ```
  */
 declare function alignmentShiftedFields(position: AstmPosition): AstmRecordWarning;
+/**
+ * Build an `ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD` warning. Emitted when a competing escape
+ * alignment decided a **repeat** boundary and the escape character the reading taken resumes on
+ * heads no sequence this codec can interpret, so the field is read as more repeats than the
+ * competing alignment
+ * gives it. No field-indexed slot moves, and that is the difference from
+ * {@link alignmentShiftedFields}. Where the gained boundary is the **first** in the field it still
+ * reaches a modeled slot, because a field's modeled value and components are taken from its first
+ * repeat alone: everything past the boundary stays in `repeats` and leaves every modeled slot, so a
+ * result value truncates and a Universal Test ID or a patient name loses the components that sat
+ * after it. At a **later** boundary nothing modeled moves and this still fires, which is
+ * over-reporting relative to those slots and never under-reporting, and **where the sequence past
+ * the boundary carries the repeat separator itself** the two readings read the same number of
+ * repeats in different places, so the field is not read as more repeats at all; see
+ * {@link WARNING_CODES.ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD}.
+ *
+ * A profile may **not** tolerate this code. **Which tolerable escape report accompanies it depends
+ * on the tail**: {@link WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER} where the tail heads no
+ * sequence at all, and {@link WARNING_CODES.ASTM_UNKNOWN_ESCAPE_SEQUENCE} where it heads one whose
+ * body is unrecognized. Both report strictly weaker facts, and wherever the escape role is a
+ * character distinct from the three splitting roles one of them always fires beside this code. It
+ * fires alongside {@link WARNING_CODES.ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT} where that also
+ * applies. The reading
+ * is unchanged: this reports the gained boundary, it does not repair it.
+ *
+ * @example
+ * ```ts
+ * import { alignmentTruncatedField } from "@cosyte/astm";
+ * alignmentTruncatedField({ recordIndex: 2, recordType: "R", fieldIndex: 4 });
+ * ```
+ */
+declare function alignmentTruncatedField(position: AstmPosition): AstmRecordWarning;
+/**
+ * Build an `ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS` warning. Emitted when a competing escape
+ * alignment decided a **component** boundary and the escape character the reading taken resumes on
+ * heads no sequence this codec can interpret, so every component after that point sits one place
+ * further right
+ * than the competing alignment puts it. No field number changes and nothing leaves the record, and
+ * that is the difference from {@link alignmentShiftedFields} and {@link alignmentTruncatedField}:
+ * what moves is which modeled slot each component lands in, so a Universal Test ID's coding scheme
+ * and local code, or a patient's given and middle names, are read out of positions the competing
+ * alignment does not put them in. **Every gained boundary at or before the last modeled component
+ * index moves those slots, not only the first**; past that index, and inside a **later repeat**,
+ * nothing named moves and this still fires, which is over-reporting and never under-reporting, and
+ * **where the sequence past the boundary carries the component separator itself** the two readings
+ * read the same number of components in different places, so no component index moves at all. See
+ * {@link WARNING_CODES.ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS}.
+ *
+ * A profile may **not** tolerate this code. **Which tolerable escape report accompanies it depends
+ * on the tail**: {@link WARNING_CODES.ASTM_UNPAIRED_ESCAPE_CHARACTER} where the tail heads no
+ * sequence at all, and {@link WARNING_CODES.ASTM_UNKNOWN_ESCAPE_SEQUENCE} where it heads one whose
+ * body is unrecognized. Both report strictly weaker facts, and wherever the escape role is a
+ * character distinct from the three splitting roles one of them always fires beside this code. It
+ * fires alongside {@link WARNING_CODES.ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT} where that also
+ * applies. The reading
+ * is unchanged: this reports the moved components, it does not repair them.
+ *
+ * @example
+ * ```ts
+ * import { alignmentShiftedComponents } from "@cosyte/astm";
+ * alignmentShiftedComponents({ recordIndex: 2, recordType: "R", fieldIndex: 3 });
+ * ```
+ */
+declare function alignmentShiftedComponents(position: AstmPosition): AstmRecordWarning;
 /**
  * Build an `ASTM_RECORD_DELIMITERS_REDECLARED` warning. Emitted when a later `H`
  * record declares a delimiter set different from the one in force; the new set is
@@ -3242,11 +3513,20 @@ declare function classifyMessage(records: readonly AstmRecord[]): AstmMessageCla
  *   readings the bytes carry.
  * @param onAlignmentShiftedFields - Called (with the 0-based field index) for each
  *   contested **field** boundary the reading took while resuming on an escape
- *   character that heads no sequence, so every later field is one place further
- *   right than the competing alignment puts it. Wired only to the field split: a
+ *   character that heads no sequence this codec can interpret. Wired only to the field split: a
  *   repeat or component boundary divides one field and so moves no field-indexed
  *   slot. That is a choice and not a consequence, because components are modeled
- *   inside a field; see {@link ShiftedFieldsSink}.
+ *   inside a field. **What the boundary costs, and the one class in which nothing
+ *   moves index, are stated in {@link ShiftedFieldsSink} and not restated here.**
+ * @param onAlignmentTruncatedField - Called (with the 0-based field index) for that
+ *   same condition on the **repeat** split, where no field-indexed slot moves.
+ *   **What the boundary costs, its two index bounds and the one class in which nothing
+ *   moves index are stated in {@link TruncatedFieldSink} and not restated here.**
+ * @param onAlignmentShiftedComponents - Called (with the 0-based field index) for that same
+ *   condition on the **component** split, where no field-indexed slot moves and nothing leaves the
+ *   record. **What the boundary costs, its three index bounds and the one class in which nothing
+ *   moves index are stated in {@link ShiftedComponentsSink} and not restated here.** All three
+ *   splitting roles are wired now.
  * @returns The record's fields.
  * @example
  * ```ts
@@ -3255,7 +3535,7 @@ declare function classifyMessage(records: readonly AstmRecord[]): AstmMessageCla
  * fields[3].components[0]; // "28.6"
  * ```
  */
-declare function tokenizeRecord(record: string, d: Delimiters, onUnknownEscape?: (fieldIndex: number) => void, onUnpairedEscape?: (fieldIndex: number) => void, onSwallowedDelimiter?: (fieldIndex: number) => void, onAmbiguousAlignment?: (fieldIndex: number) => void, onAlignmentShiftedFields?: (fieldIndex: number) => void): AstmField[];
+declare function tokenizeRecord(record: string, d: Delimiters, onUnknownEscape?: (fieldIndex: number) => void, onUnpairedEscape?: (fieldIndex: number) => void, onSwallowedDelimiter?: (fieldIndex: number) => void, onAmbiguousAlignment?: (fieldIndex: number) => void, onAlignmentShiftedFields?: (fieldIndex: number) => void, onAlignmentTruncatedField?: (fieldIndex: number) => void, onAlignmentShiftedComponents?: (fieldIndex: number) => void): AstmField[];
 /**
  * Tokenize an `H` (header) record into its fields.
  *
@@ -3288,9 +3568,15 @@ declare function tokenizeRecord(record: string, d: Delimiters, onUnknownEscape?:
  *   each competing escape alignment in the data portion. The declaration is opaque,
  *   so the characters it names literally never report here either.
  * @param onAlignmentShiftedFields - Called with the 0-based whole-record field index
- *   for each contested field boundary in the data portion whose reading resumes on
- *   an escape character heading no sequence. The declaration is opaque, so it never
- *   reports here either.
+ *   for each contested field boundary in the data portion whose reading resumes on an
+ *   escape character heading no sequence this codec can interpret. The declaration is
+ *   opaque, so it never reports here either.
+ * @param onAlignmentTruncatedField - Called with the 0-based whole-record field index
+ *   for each contested **repeat** boundary in the data portion on that same tail
+ *   test. The declaration is opaque, so it never reports here either.
+ * @param onAlignmentShiftedComponents - Called with the 0-based whole-record field index for each
+ *   contested **component** boundary in the data portion on that same tail test. The declaration is
+ *   opaque, so it never reports here either.
  * @returns The header's fields.
  * @example
  * ```ts
@@ -3300,7 +3586,7 @@ declare function tokenizeRecord(record: string, d: Delimiters, onUnknownEscape?:
  * fields[4].raw; // "sender"
  * ```
  */
-declare function tokenizeHeader(record: string, d: Delimiters, onUnknownEscape?: (fieldIndex: number) => void, onUnpairedEscape?: (fieldIndex: number) => void, onSwallowedDelimiter?: (fieldIndex: number) => void, onAmbiguousAlignment?: (fieldIndex: number) => void, onAlignmentShiftedFields?: (fieldIndex: number) => void): AstmField[];
+declare function tokenizeHeader(record: string, d: Delimiters, onUnknownEscape?: (fieldIndex: number) => void, onUnpairedEscape?: (fieldIndex: number) => void, onSwallowedDelimiter?: (fieldIndex: number) => void, onAmbiguousAlignment?: (fieldIndex: number) => void, onAlignmentShiftedFields?: (fieldIndex: number) => void, onAlignmentTruncatedField?: (fieldIndex: number) => void, onAlignmentShiftedComponents?: (fieldIndex: number) => void): AstmField[];
 /**
  * The primary scalar of a field: its first repeat's first component, decoded.
  * Returns `undefined` for a truly empty field so callers can distinguish
@@ -3475,17 +3761,39 @@ declare class AstmParseError extends Error {
  * asks whether this codec's vocabulary prefers the reading taken *at* the contested
  * position. It says nothing about what the reading taken makes of the bytes *after*
  * the boundary, and that is where the two alignments really diverge: they resume
- * one character apart, so they disagree about the whole tail. Where the escape
- * character the reading taken resumes on heads no sequence at all, the boundary was
- * bought with a byte this reading cannot read, while the competing alignment is
+ * one character apart, so they disagree about the bytes past the boundary, and
+ * on most tails about the whole of them. Where the escape
+ * character the reading taken resumes on heads no sequence this codec can
+ * **interpret** (it heads none at all, or it heads one whose body is not a recognized
+ * mnemonic and is therefore preserved verbatim rather than read), the boundary was
+ * bought with bytes this reading cannot read, while the competing alignment is
  * precisely the reading that can. On the **field** separator that gained boundary
  * shifts every later field one place, so a result record's units and **result
  * status** are read out of slots the competing alignment does not put them in, and
  * a status of `final` can be a consequence of the alignment rather than something
  * the sender wrote there. That is `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS`; see
- * {@link ShiftedFieldsSink}, including the tail and the two other delimiter roles it
- * deliberately stays silent on, and why neither silence is a claim that nothing was
- * lost there.
+ * {@link ShiftedFieldsSink}, including the one tail it deliberately stays silent on,
+ * why that silence is what keeps this off conformant traffic, and why it is still not
+ * a claim that nothing was lost there.
+ *
+ * **The same question asked on the repeat separator has a different answer, so it
+ * has a code of its own.** A gained repeat boundary moves no field-indexed slot, and
+ * where it is the **first** boundary in the field it still reaches a modeled slot,
+ * because a field's modeled reading is taken from its first repeat alone: everything
+ * past that boundary leaves the record, so a result value truncates and a Universal
+ * Test ID or a patient name loses the components that sat after it. That is
+ * `ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD`; see {@link TruncatedFieldSink}, including
+ * what it does at a later boundary, where it fires and no modeled slot moves.
+ *
+ * **The same question asked on the component separator has a third answer again, and
+ * so a third code.** There the components neither leave the record nor change field
+ * number: they move one slot along, because components are modeled *inside* a field.
+ * A Universal Test ID's coding scheme and local code, and a patient's given and middle
+ * names, are then read out of positions the competing alignment does not put them in.
+ * That is `ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS`; see {@link ShiftedComponentsSink},
+ * including what it does inside a later repeat, where it fires and no modeled slot
+ * moves. All three roles are wired now; there is no fourth, because nothing splits on
+ * the escape role.
  *
  * Re-escaping (the inverse, for spec-clean emit) lives in the serializer and is
  * deliberately not implemented here.
@@ -3570,11 +3878,18 @@ type SwallowedDelimiterSink = () => void;
 type AmbiguousAlignmentSink = (segmentIndex: number) => void;
 /**
  * A callback the split calls when a competing escape alignment decided a boundary
- * **and the reading taken cannot read the byte immediately past it**: the escape
- * character the leftmost reading resumes on heads no escape sequence at all, so it
- * is kept as a bare literal (reported separately as
- * `ASTM_UNPAIRED_ESCAPE_CHARACTER`), while the competing alignment is exactly the
- * reading that gives that character a job, as the close of its own triple.
+ * **and the reading taken cannot read what lies immediately past it**: the escape
+ * character the leftmost reading resumes on heads no sequence this codec can
+ * *interpret*, while the competing alignment is exactly the reading that gives that
+ * character a job, as the close of its own triple. Two tails satisfy that, and they
+ * are reported alike because they cost alike:
+ *
+ * - **It heads no sequence at all**, so it is kept as a bare literal and reported
+ *   separately as `ASTM_UNPAIRED_ESCAPE_CHARACTER`.
+ * - **It heads a sequence whose body is not a recognized mnemonic**, so the triple is
+ *   preserved verbatim, never guessed at, and reported separately as
+ *   `ASTM_UNKNOWN_ESCAPE_SEQUENCE`. **Consuming a triple is not interpreting one**,
+ *   and the boundary is bought with bytes this reading cannot read either way.
  *
  * Wired **only to the split taken on the field separator**, because that is the
  * whole of its claim: a gained *field* boundary shifts every later field one place,
@@ -3587,11 +3902,16 @@ type AmbiguousAlignmentSink = (segmentIndex: number) => void;
  * reaches nothing outside it, so it moves no **field-indexed** slot and is
  * deliberately outside this. **That bound is a choice, not a consequence, and the
  * difference matters**: components are modeled *inside* a field (a Universal Test
- * ID's coding scheme and local code, a patient name's parts), so a gained component
- * boundary does move a modeled slot. That is measured, unreported by anything, and
- * open, not something this sink covers. The callback lets the parser surface a
- * value-free `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS` warning. Optional so the split
- * can be used purely.
+ * ID's coding scheme and local code, a patient name's parts), so a gained repeat or
+ * component boundary does reach a modeled slot. The **repeat** half of that is
+ * reported by {@link TruncatedFieldSink}, on the same tail test and under its own
+ * code, because what it costs is a different thing. The **component** half is
+ * reported by {@link ShiftedComponentsSink}, on that same tail test and under a code of
+ * its own again, because what it costs is a third thing: there the components move one
+ * slot along rather than leaving the record. The
+ * callback lets the parser surface a value-free
+ * `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS` warning. Optional so the split can be used
+ * purely.
  *
  * **It is a report, not a repair.** The split is unchanged, every decoded byte is
  * identical, and the status read is the status that was always read. What is new is
@@ -3606,29 +3926,230 @@ type AmbiguousAlignmentSink = (segmentIndex: number) => void;
  * questions are different, so neither test is widened to answer the other.
  *
  * **The tail is weighed one construct deep, and that bound is stated rather than
- * left to be found.** Two tails are excluded, with the same reason: the bytes past
- * the boundary prefer the reading taken.
- *
- * - **The escape character heads a sequence this codec recognizes.** Then the
- *   reading taken interprets it and leaves nothing bare, while the competing
- *   alignment would leave it bare. Under a set naming the field separator `F`,
- *   `28.6&F&F&F&U/L` is the sender escaping that separator, writing it, and
- *   escaping it again: entirely well formed, and refusing it is the over-refusal
- *   that sank the preceding candidate criterion for this family.
- * - **The escape character heads a sequence whose body this codec does not
- *   recognize.** Then the reading taken still consumes it as a sequence and carries
- *   one unreadable body, while the competing alignment would leave *two* escape
- *   characters bare. The preference is stronger there, not weaker.
- *
- * What that bound leaves open is the second of those tails, where the field shift
- * is real and this stays silent. It is measured and named rather than closed by
- * widening the test, because widening it would report a boundary the bytes prefer.
+ * left to be found.** Exactly one tail is excluded: **the escape character heads a
+ * sequence this codec recognizes.** Then the reading taken interprets a construct
+ * and leaves nothing unread, while the competing alignment would leave it bare.
+ * Under a set naming the field separator `F`, `28.6&F&F&F&U/L` is the sender
+ * escaping that separator, writing it, and escaping it again: entirely well formed,
+ * and refusing it is the over-refusal that sank the preceding candidate criterion
+ * for this family.
+ *
+ * **That exclusion is not a matter of degree, which is why it is the only one.** It
+ * is the sole tail on which a stream's escaping can be clean at all: on the other
+ * two the package already reports a deviation, so this report can never be the
+ * reason a well-formed stream is refused. A tail comparison that instead weighs
+ * which alignment the bytes *prefer* would exclude the unrecognized body too (the
+ * competing alignment leaves two escape characters bare there against the reading
+ * taken's one unreadable body) and it is the wrong question: these codes report a
+ * **cost**, not a preference, and the cost is identical under both reported tails.
+ *
+ * **That silence is a TRADE, and it is not a claim that nothing was lost there.** The
+ * gained field boundary is exactly as real on the excluded tail, and it can be
+ * entirely silent: under the canonical set `R|1|^^^687|28.6&F&|&F&U/L||||F` reads
+ * **nine** fields against the competing alignment's eight with `warnings: []`, so a
+ * result status of `final` is read out of a slot the other reading does not have.
+ * 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 SHIFT IS NOT UNIVERSAL OVER THE FIRING POPULATION, AND THE EXCEPTION IS
+ * 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**: no field
+ * index moves, and what differs is the **contents** of the fields at and after the
+ * boundary. Under the canonical set `R|1|^^^687|28.6&F&|&|&U/L||||F` reads nine
+ * fields under both, with the status `F` in field 9 under both, and units of `&|&U/L`
+ * against `&U/L`. That class is bounded and costs no stream its disposition: the tail
+ * body is then a splitting delimiter in force, so
+ * `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.
  *
  * @param segmentIndex - The 0-based index of the field being accumulated when the
- *   shifting boundary was taken. Every field after it is one place further right
- *   than the competing alignment puts it.
+ *   contested boundary was taken. Every field after it is one place further right
+ *   than the competing alignment puts it, **except** where the sequence past the
+ *   boundary carries the field separator as its body, where the two readings return
+ *   the same number of fields with different contents instead.
  */
 type ShiftedFieldsSink = (segmentIndex: number) => void;
+/**
+ * A callback the split calls on **exactly the condition {@link ShiftedFieldsSink}
+ * reports**, wired instead to the split taken on the **repeat** separator. The two
+ * sinks test the same predicate, because the predicate is about the bytes and the
+ * split does not know which role it is being taken on; they are separate so the
+ * caller that does know can name what the gained boundary costs, which is not the
+ * same thing in the two roles. Do not "simplify" them into one: the codes would then
+ * have to make one claim covering both, and the claim is different.
+ *
+ * **What a gained repeat boundary costs, and it is not a shift.** No field-indexed
+ * slot moves: the units slot and the result-status slot are read out of the same
+ * field numbers under either alignment. What the report says is that **the field is
+ * read as more repeats than the competing alignment gives it**, and that holds
+ * wherever it fires **except on the named class below**, where the two readings read
+ * the same number of repeats in different places. What it costs depends on **which**
+ * boundary was gained, and the two cases are stated separately rather than folded
+ * into one claim:
+ *
+ * - **The gained boundary is the FIRST in the field, and then a modeled slot is
+ *   lost.** A field's modeled value and its components are taken from its **first
+ *   repeat alone**, so everything past the boundary is still on the wire, still in
+ *   `repeats`, and gone from every modeled slot. Under a set naming the repeat
+ *   separator `F`, the value `28.6&S&F&U/L` reads as the two repeats `28.6^` and
+ *   `&U/L`, and every value extractor answers `28.6^`, while the competing alignment
+ *   reads one repeat carrying all of it. The same boundary inside a Universal Test ID
+ *   field leaves the components of the first repeat only, so a UTID whose bytes carry
+ *   a test code can come back as a single component holding a decoded delimiter, with
+ *   the coding scheme and local code read from nothing at all. A patient name loses
+ *   its given and middle names the same way.
+ * - **The gained boundary is a LATER one, and then no modeled slot moves.** The first
+ *   repeat is identical under both alignments, so the value, the components and every
+ *   slot taken from them read the same either way; what differs is the repeat
+ *   structure after the first. **This still fires there, deliberately and measurably**
+ *   (`5.0F28.6&S&F&U/L` under that same set), because 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**, which is the direction this package errs in. Narrowing the sink
+ *   to the first boundary would change which streams a published package refuses and
+ *   wants its own measurement, so the bound is written down instead of guessed at.
+ *
+ * **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. What is new is that the gained boundary is reported by
+ * a code no profile may tolerate, where before it was covered only by tolerable ones.
+ *
+ * **The tail is weighed one construct deep, exactly as in {@link ShiftedFieldsSink},
+ * and one tail is excluded for the same reason.** Where the escape character the
+ * reading taken resumes on heads a sequence this codec **recognizes**, it interprets
+ * a construct and the two 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, with nothing reported at all. Refusing that is the over-refusal that
+ * sank an earlier candidate criterion for this family, and that tail is the only one
+ * on which a stream's escaping can be clean. Where the tail heads a sequence whose
+ * body is *unrecognized*, the reading taken consumes a triple it cannot read, the
+ * truncation is the same truncation, and this reports it.
+ *
+ * **That silence is a TRADE, and it is not a claim that nothing was lost there.** The
+ * gained repeat boundary is exactly as real on the excluded tail and can be entirely
+ * silent: under the canonical set `28.6&S&\&S&U/L` reads a value of `28.6^` with
+ * `warnings: []`, so `^U/L` leaves every modeled slot at a boundary the bytes do not
+ * force. Reporting it would refuse a stream whose escaping is working.
+ *
+ * **⚠️ THE TRUNCATION IS NOT UNIVERSAL OVER THE FIRING POPULATION, AND THE EXCEPTION
+ * IS 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**: the
+ * field is not read as more repeats than the competing alignment gives it, and what
+ * differs is the **contents**. Under the canonical set `28.6&F&\&\&U/L` reads two
+ * repeats under both. That class is bounded and costs no stream its disposition: the
+ * tail body is then a splitting delimiter in force, so
+ * `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.
+ *
+ * @param segmentIndex - The 0-based index of the repeat being accumulated when the
+ *   contested boundary was taken, so `0` is the boundary that ends the first repeat
+ *   and is the one that reaches a modeled slot. It is **not** a field index: the
+ *   caller splitting one field into repeats already knows which field it is in, and
+ *   reports that.
+ */
+type TruncatedFieldSink = (segmentIndex: number) => void;
+/**
+ * A callback the split calls on **exactly the condition {@link ShiftedFieldsSink}
+ * reports**, wired instead to the split taken on the **component** separator. The
+ * third and last of the three sinks that share that one predicate, for the reason the
+ * other two share it: the predicate is about the bytes and the split does not know
+ * which role it is being taken on, so the caller that does know names what the gained
+ * boundary costs. Do not "simplify" the three into one: the codes would then have to
+ * make one claim covering all of them, and the three claims are different.
+ *
+ * **What a gained component boundary costs, and it is neither of the other two.** No
+ * field number changes, so nothing shifts between field-indexed slots, and nothing
+ * leaves the record, so nothing truncates. Components are modeled **inside** a field,
+ * so what happens is that every component after the gained boundary is one place
+ * further right than the competing alignment puts it, and the slots that indexes into
+ * are named things: a Universal Test ID's LOINC-candidate slot, test name, **coding
+ * scheme** and **local code**; a patient name's last, first and middle. Under the
+ * canonical set `&F&^&GLU^L^687` reads four components, so `L` is the coding scheme
+ * and `687` the vendor's local code, while the competing alignment reads three and
+ * `687` is the **coding scheme**. `DOE&F&^&JANE^A` reads a given name of `&JANE` and a
+ * middle name of `A`, while the competing alignment makes `A` the **given** name with
+ * no middle name at all.
+ *
+ * **Every gained boundary at or before the LAST MODELED COMPONENT INDEX moves a
+ * modeled slot, not only the first.** That is the structural difference from
+ * {@link TruncatedFieldSink}: a field is modeled out of its first repeat alone, so
+ * there only the first gained boundary reaches a modeled slot, while here the shift
+ * propagates from wherever the boundary sits to the end of the component list.
+ *
+ * **TWO bounds run the other way, and the report fires inside both, which is
+ * over-reporting and never under-reporting.** Neither is an oversight and neither is
+ * closed by narrowing the guard, because narrowing changes which streams a published
+ * package refuses and wants its own measurement. Both axes are swept on their own
+ * rather than left to the shared corpus, which holds them fixed.
+ *
+ * - **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 and leaves every named slot byte-identical under both
+ *   alignments, and this fires there.
+ * - **Inside a LATER repeat nothing modeled moves at all.** `components` is
+ *   `repeats[0]`, so a component boundary gained inside the second or a later repeat
+ *   changes only `repeats[n]` for that `n`.
+ *
+ * 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. What is
+ * new is that the moved slots are reported by a code no profile may tolerate, where
+ * before they were covered only by tolerable ones. **Withholding them is a separate
+ * question, deliberately not answered here**: 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 in the other two sinks, and one
+ * tail is excluded for the same reason.** Where the escape character the reading taken
+ * 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,
+ * with nothing reported at all. Refusing that is the over-refusal that sank an earlier
+ * candidate criterion for this family, and that tail is the only one on which a
+ * stream's escaping can be clean. Where the tail heads a sequence whose body is
+ * *unrecognized*, the reading taken consumes a triple it cannot read, the slots move
+ * exactly as far, and this reports it.
+ *
+ * **That silence is a TRADE, and it is not a claim that nothing was lost there.** The
+ * gained component boundary is exactly as real on the excluded tail and can be
+ * entirely silent: under the canonical set `&F&^&F&GLU^L^687` reads one component more
+ * than the competing alignment with `warnings: []`, so a coding scheme and a local code
+ * still sit where an alignment guess put them. Reporting it would refuse a stream whose
+ * escaping is working.
+ *
+ * **⚠️ THE MOVE IS NOT UNIVERSAL OVER THE FIRING POPULATION, AND THE EXCEPTION IS NAMED
+ * RATHER THAN LEFT TO BE FOUND.** It is a **third** bound running the other way, and it
+ * differs from the two above: those two fire where nothing named moves because of where
+ * the boundary sits, while this one is about the bytes past it. Where the sequence past
+ * the boundary 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**:
+ * no component index moves, and what differs is the **contents**. Under the canonical
+ * set `DOE&F&^&^&JANE^A` reads three components under both, with `A` the middle name
+ * under both. That class is bounded and costs no stream its disposition: the tail body
+ * is then a splitting delimiter in force, so
+ * `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.
+ *
+ * @param segmentIndex - The 0-based index of the component being accumulated when the
+ *   contested boundary was taken. Every component after it is one place further right
+ *   than the competing alignment puts it, **except** where the sequence past the
+ *   boundary carries the component separator as its body, where the two readings return
+ *   the same number of components with different contents instead. It is **not** a field
+ *   index, and it is **not** a repeat index: the caller splitting one repeat into
+ *   components already knows both, and reports the field.
+ */
+type ShiftedComponentsSink = (segmentIndex: number) => void;
 /**
  * Decode the four recognized ASTM escape mnemonics in a single already-split
  * leaf (a component string), substituting the *active* delimiters read from the
@@ -3694,10 +4215,20 @@ declare function decodeEscapes(leaf: string, d: Delimiters, onUnknown?: UnknownE
  *   closing escape character could instead have opened a sequence holding this
  *   delimiter, so the boundary taken here is not the only reading of the bytes.
  * @param onShiftedFields - Called once per contested boundary where the escape
- *   character this reading resumes on heads no sequence of its own, so the boundary
- *   was bought with a byte the reading cannot read. Wired only by the split taken on
- *   the field separator: see {@link ShiftedFieldsSink} for why, and for the tail it
- *   deliberately does not report.
+ *   character this reading resumes on heads no sequence this codec can *interpret*
+ *   (none at all, or one whose body is not a recognized mnemonic), so the boundary
+ *   was bought with bytes the reading cannot read. Wired only by the split taken on
+ *   the field separator: see {@link ShiftedFieldsSink} for why, and for the one tail
+ *   it deliberately does not report.
+ * @param onTruncatedField - Called on that same condition, wired only by the split
+ *   taken on the repeat separator, where the cost is not a shift. **What it is, its
+ *   two index bounds and the one class in which nothing moves index are stated in
+ *   {@link TruncatedFieldSink} and not restated here.**
+ * @param onShiftedComponents - Called on that same condition again, wired only by the
+ *   split taken on the component separator, where nothing shifts between fields and
+ *   nothing leaves the record. **What the boundary costs, its three index bounds and
+ *   the one class in which nothing moves index are stated in
+ *   {@link ShiftedComponentsSink} and not restated here.**
  * @returns The raw segments, in order.
  * @example
  * ```ts
@@ -3707,7 +4238,7 @@ declare function decodeEscapes(leaf: string, d: Delimiters, onUnknown?: UnknownE
  * splitEscapeAware("O&Brien^John", "^", "&"); // ["O&Brien", "John"]  (unpaired: literal)
  * ```
  */
-declare function splitEscapeAware(text: string, delimiter: string, escape: string, onAmbiguousAlignment?: AmbiguousAlignmentSink, onShiftedFields?: ShiftedFieldsSink): string[];
+declare function splitEscapeAware(text: string, delimiter: string, escape: string, onAmbiguousAlignment?: AmbiguousAlignmentSink, onShiftedFields?: ShiftedFieldsSink, onTruncatedField?: TruncatedFieldSink, onShiftedComponents?: ShiftedComponentsSink): string[];
 
 /**
  * Deep-freeze helper for the immutable ASTM model.
@@ -4074,8 +4605,11 @@ declare function resolveProfileTransport(profile: AstmProfile | undefined): Astm
  * **A further reader landed with `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS`, and it is
  * the first one that reaches a MODELED SLOT rather than a boundary.** It reports
  * that a contested alignment decided a **field** boundary while the reading taken
- * resumes on an escape character heading no sequence, so every later field sits one
- * place further right than the competing alignment puts it. On a result record that
+ * resumes on an escape character heading no sequence this codec can interpret, so
+ * every later field sits one place further right than the competing alignment puts
+ * it (**except where the sequence past the boundary carries the field separator
+ * itself**, where the two readings read the same number of fields in different
+ * places). On a result record that
  * moves the units and the **result status**: the sender's trailing letter is read out
  * of field 9 under the reading taken and out of no field at all under the other, so a
  * status of `final` can be a consequence of the alignment rather than something the
@@ -4089,6 +4623,57 @@ declare function resolveProfileTransport(profile: AstmProfile | undefined): Astm
  * in a value alters no boundary at all), and the case where it accompanies a shifted
  * field is now reported by a code no profile may re-badge.
  *
+ * **`ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD` landed next, on the same contested
+ * position and the same tail test, and it reaches a modeled slot by the other
+ * route.** It reports a contested alignment deciding a **repeat** boundary. Nothing
+ * shifts: no field-indexed slot moves, which is exactly why the shift report could
+ * not cover it. What it reports is that the field is read as more repeats than the
+ * competing alignment gives it (**except where the sequence past the boundary carries
+ * the repeat separator itself**, where the two readings read the same number of
+ * repeats in different places), and **where that gained boundary is the first one in
+ * the field** it reaches a modeled slot, because a field's modeled value and
+ * components are taken from its **first repeat alone**: everything past it stays in
+ * `repeats` and leaves every modeled slot, so a result value truncates and a
+ * Universal Test ID or a patient name comes back holding only the components that sat
+ * before it. Until it existed the warnings on those streams were
+ * `ASTM_NONSTANDARD_DELIMITERS` and `ASTM_UNPAIRED_ESCAPE_CHARACTER`, both on the list
+ * below, so the widest gate-legal profile plus `{ strict: true }` accepted a truncated
+ * value and an emptied test identity. **At a later boundary it fires and no modeled
+ * slot moves**, which is over-reporting relative to those slots and never
+ * under-reporting: measured, and stated on the code itself rather than left to be
+ * found. It is safety-critical by construction and must never be admitted.
+ * Re-reading the survivors against it moved no admission, and the reason is the one
+ * the entry above already turns on: each of them re-badges the code it names and no
+ * other, and what this condition now raises is a code no profile may name.
+ *
+ * **`ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS` completes the set, on the same
+ * contested position and the same tail test, wired to the third and last splitting
+ * role.** It reports a contested alignment deciding a **component** boundary. Nothing
+ * shifts between fields and nothing leaves the record, which is why neither of the two
+ * above could cover it: components are modeled **inside** a field, so every component
+ * after the gained boundary is one place further right than the competing alignment
+ * puts it (**except where the sequence past the boundary carries the component
+ * separator itself**, where the two readings read the same number of components in
+ * different places). That indexes into named slots. A Universal Test ID's four components are the
+ * LOINC-candidate slot, the test name, the **coding scheme** and the **local code**, so
+ * `&F&^&GLU^L^687` reads `687` as the vendor's local code under the reading taken and
+ * as the **coding scheme** under the competing one; a patient name's three are last,
+ * first and middle, so `DOE&F&^&JANE^A` reads `A` as the middle name under the reading
+ * taken and as the **given** name under the other. Until it existed the only warning on
+ * those streams was `ASTM_UNPAIRED_ESCAPE_CHARACTER`, on the list below, so the widest
+ * gate-legal profile plus `{ strict: true }` accepted a test identity and a patient name
+ * whose parts were decided by the alignment. **Unlike the repeat role, every gained
+ * boundary at or before the last modeled component index moves those slots and not only
+ * the first**, because the shift propagates to the end of the component list. **THREE
+ * bounds run the other way and it fires inside all three**, which is over-reporting and
+ * never under-reporting: past the last modeled index nothing NAMED moves (a name models
+ * three components, a Universal Test ID four); inside a later repeat nothing modeled moves
+ * at all; and on the class named above nothing moves index at all. All three axes are
+ * measured on sweeps of their own rather than on the shared corpus, which holds them
+ * fixed. It is safety-critical by construction and must never be
+ * admitted. Re-reading the survivors against it moved no admission, for the reason the
+ * two entries above already turn on.
+ *
  * **So the ones that remain are recorded with the reading each one survives**, not
  * merely with the value it preserves. Each was re-derived against **every** reader of
  * record structure named above (this sentence deliberately names no count: it has
@@ -4147,6 +4732,17 @@ declare function resolveProfileTransport(profile: AstmProfile | undefined): Astm
  *   time, and this entry survives it on the same narrower claim: what that reader
  *   raises is a different code, which a profile cannot name and cannot tolerate.
  *
+ *   **A THIRD reader landed with the widened tail bound, and it is named here for the
+ *   same reason.** `headsInterpretableSequence` in `../common/escapes.ts` asks the
+ *   mnemonic test about the escape character just past a contested boundary, so an
+ *   **unrecognized** body there, which is exactly the condition this code reports, now
+ *   also decides whether `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS`,
+ *   `ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD` or `ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS`
+ *   fires. Three sinks, one predicate, and this entry survives all three on the same
+ *   narrower claim: none of the codes they raise may be named by a profile.
+ *   **Re-derive this list whenever something new starts reading record structure**: the
+ *   count is now three and this is the second time it has grown.
+ *
  *   **This entry used to be recorded as questionable, and what made it questionable
  *   is now a separate code that is not on this list.** The argument above is about
  *   the *decoded value*, and it holds. What it did not cover is that the
@@ -4174,21 +4770,35 @@ declare function resolveProfileTransport(profile: AstmProfile | undefined): Astm
  *   decoded value, so the value is identical with or without the profile. Note what
  *   makes this admissible is a property of the *parse*, not of the warning: reading
  *   the character as a literal is unconditional, and tolerating the code changes
- *   nothing about how the record splits. No reader sees it, on the same grounds as
- *   the entry above: the type letter is read before any decoding, the split reader
+ *   nothing about how the record splits. None of the three readers named at the top of
+ *   this file sees it: the type letter is read before any decoding, the split reader
  *   counts fields the escape-aware tokenizer has already finished dividing, and a
- *   decoded value is never cut back into records. Contrast the condition it
+ *   decoded value is never cut back into records. **Three later readers DO see it**, and
+ *   they are named below rather than left out of this bullet. Contrast the condition it
  *   replaced, which **would** have failed part 1: reading the same character as an
  *   unterminated sequence merged every field after it into one, and a code reporting
  *   that would have been a report of lost values.
  *
- *   **The alignment reader is not a reader of this condition, and the distinction is
- *   worth stating rather than leaving to be checked.** It asks whether the character
- *   two positions past a sequence *is* the escape character, never whether that
- *   character heads a sequence of its own, which is the question this code answers.
- *   The two are independent in both directions, measured: `28.6&Z&|&U/L` raises this
- *   code and the alignment code together, and `28.6&Z&|&U&L` raises the alignment
- *   code with no unpaired character anywhere in it.
+ *   **The alignment reader is not a reader of this condition**, and that much still
+ *   holds: it asks whether the character two positions past a sequence *is* the escape
+ *   character, never whether that character heads a sequence of its own. The two are
+ *   independent in both directions, measured: `28.6&Z&|&U/L` raises this code and the
+ *   alignment code together, and `28.6&Z&|&U&L` raises the alignment code with no
+ *   unpaired character anywhere in it.
+ *
+ *   **The TAIL readers are a different matter, and "no reader sees it" is
+ *   therefore FALSE of this entry and must not be restored.** There are three of them
+ *   now, one per splitting role: `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS`,
+ *   `ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD` and
+ *   `ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS` all fire where the character at
+ *   `i + 4` heads no sequence this codec can interpret, and heading no sequence at all
+ *   is one of the two ways to satisfy that, so this code's own question is asked about
+ *   the character just past a contested boundary. That is a reader of the reported
+ *   condition, so this entry survives on the same narrower claim the unknown-sequence
+ *   entry above already uses, not on nothing reading it: a profile re-badges the code
+ *   it names and no other, and what those three readers raise is not tolerable in any
+ *   case. If a future reader of this condition ever produces something a profile
+ *   **can** tolerate, this entry stops being admissible and comes off the list.
  * - `ASTM_RECORD_UNINTERPRETED_QUERY_STATUS`: a request-information status carried
  *   verbatim as a leaf field on a `Q` record; the code set is paywalled and is not
  *   interpreted, profile or not. Classification reads whether a `Q` record is
@@ -4202,7 +4812,9 @@ declare function resolveProfileTransport(profile: AstmProfile | undefined): Astm
  * an unrecognized record type, a record the delimiters in force could not split, a
  * declaration naming one character in two roles, a delimiter an unrecognized escape
  * sequence kept out of the split, a boundary a competing escape alignment disagrees
- * about, a bad frame checksum / sequence gap / unterminated
+ * about, a field whose modeled reading stops at a boundary only one alignment has,
+ * a component list only one alignment aligns that way,
+ * a bad frame checksum / sequence gap / unterminated
  * / oversize frame, an ambiguous transport, an unexpected protocol event, or a
  * rejected frame: is forbidden.
  *
@@ -4249,6 +4861,24 @@ declare function resolveProfileTransport(profile: AstmProfile | undefined): Astm
  * reading `final` that the competing alignment of the same bytes puts in no field at
  * all.
  *
+ * `ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD` is not on this list and must not be added
+ * to it either. It reports the same contested alignment deciding a **repeat**
+ * boundary, where no slot changes hands and a modeled reading is cut off instead: the
+ * field is read out of its first repeat alone, so where that boundary is the first
+ * one a value truncates and a Universal Test ID's coding scheme and local code are
+ * read from bytes that are no longer in any modeled slot. Reporting a value that is
+ * not the whole of what the sender wrote fails the first half of the two-clause test
+ * outright.
+ *
+ * `ASTM_RECORD_ALIGNMENT_SHIFTED_COMPONENTS` is not on this list and must not be added
+ * to it either. It reports the same contested alignment deciding a **component**
+ * boundary, where nothing leaves the record and no field number changes, and every
+ * component after it moves one slot along instead: a Universal Test ID's coding scheme
+ * and local code, and a patient's given and middle names, are read out of positions the
+ * competing alignment does not put them in. Reporting a code system, a vendor's local
+ * code or a given name that the bytes do not unambiguously carry fails the first half of
+ * the two-clause test outright.
+ *
  * @example
  * ```ts
  * import { TOLERABLE_CODES } from "@cosyte/astm";
@@ -5593,4 +6223,4 @@ declare class AstmFrameStrictError extends Error {
  */
 declare const VERSION: string;
 
-export { ALL_ASTM_WARNING_CODES, AMBIGUOUS_CODES, ACK as ASTM_ACK, ENQ as ASTM_ENQ, EOT as ASTM_EOT, NAK as ASTM_NAK, type AbnormalFlag, type AbnormalFlagCode, type AbnormalFlagMeaning, type AmbiguousAlignmentSink, type AmbiguousCode, type AnyAstmWarningCode, AstmAmbiguousStreamError, type AstmDate, type AstmDatePrecision, type AstmField, type AstmFrame, AstmFrameEncodeError, type AstmFrameEncodeErrorCode, type AstmFramePosition, AstmFrameStrictError, type AstmFrameWarning, type AstmFraming, type AstmLivdWarning, type AstmLtpWarning, type AstmMessage, type AstmMessageClassification, type AstmMessageKind, AstmParseError, type AstmParseOptions, type AstmPosition, type AstmProfile, AstmProfileDefinitionError, type AstmProfileProvenance, type AstmQuirkMatch, type AstmQuirkTolerance, type AstmRecord, type AstmRecordInput, type AstmRecordWarning, AstmSerializeError, type AstmSerializeErrorCode, type AstmStreamMessage, AstmStrictError, CANONICAL_DELIMITERS, type CommentInput, type CommentRecord, type ComposeFramesOptions, type DecodeAstmFramesResult, type DefineAstmProfileOptions, type DelimiterDeclarationFault, type DelimiterReadResult, type Delimiters, type DetectFramingOptions, type DetectFramingResult, FATAL_CODES, FRAME_WARNING_CODES, type FatalCode, type FrameChecksum, type FrameOptions, type FrameTerminator, type FrameWarningCode, type FramedAstmResult, type HeaderInput, type HeaderRecord, LIVD_WARNING_CODES, LTP_WARNING_CODES, type LivdAnnotation, type LivdCatalog, type LivdEntry, type LivdLookup, type LivdMapping, type LivdResult, type LivdWarningCode, type LtpAction, type LtpEvent, type LtpPhase, type LtpState, type LtpTransition, type LtpWarningCode, type ManufacturerRecord, type MessageInput, type OrderInput, type OrderRecord, type PatientInput, type PatientName, type PatientNameInput, type PatientRecord, type QueryInput, type QueryRecord, type ReferenceRange, type ReferenceRangeKind, type ResultInput, type ResultRecord, type ResultStatus, type ResultStatusCode, type ResultStatusMeaning, SAFETY_CRITICAL_CODES, type ScientificRecord, type ShiftedFieldsSink, type SwallowedDelimiterSink, TOLERABLE_CODES, type TerminatorRecord, type UniversalTestId, type UniversalTestIdProvenance, type UnknownEscapeSink, type UnpairedEscapeSink, type UnsupportedRecord, VERSION, type VerbatimInput, WARNING_CODES, type WarningCode, alignmentShiftedFields, ambiguousEscapeAlignment, ambiguousMessageKind, ambiguousValueSplit, applyAstmProfile, applyAstmProfileToWarnings, applyLivd, astmDateToLocalISO, astmProfiles, attachComments, buildAstmMessage, classifyMessage, comments, commentsFor, composeAstmFrames, computeChecksum, decodeAstmFrames, decodeEscapes, deepFreeze, defineAstmProfile, defineLivdCatalog, delimiterRoleCollision, delimiterSwallowedByEscape, delimitersRedeclared, detectFraming, encodeComponent, fieldScalar, fieldsUnseparated, frameBadChecksum, frameOversize, frameSequenceGap, frameUnterminated, getAstmProfile, getDefaultAstmProfile, hasCollidingRoles, 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, readDelimiterDeclaration, readDelimiters, recognizeUniversalTestId, resolveProfileTransport, results, serializeAstmRecord, serializeAstmRecords, serializeField, serializeFramedAstm, setDefaultAstmProfile, splitEscapeAware, toChecksumHex, tokenizeHeader, tokenizeRecord, undefinedAbnormalFlag, undefinedResultStatus, uninterpretedQueryStatus, unitsAbsent, unknownEscapeSequence, unknownRecordType, unpairedEscapeCharacter, 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, type AbnormalFlag, type AbnormalFlagCode, type AbnormalFlagMeaning, type AmbiguousAlignmentSink, type AmbiguousCode, type AnyAstmWarningCode, AstmAmbiguousStreamError, type AstmDate, type AstmDatePrecision, type AstmField, type AstmFrame, AstmFrameEncodeError, type AstmFrameEncodeErrorCode, type AstmFramePosition, AstmFrameStrictError, type AstmFrameWarning, type AstmFraming, type AstmLivdWarning, type AstmLtpWarning, type AstmMessage, type AstmMessageClassification, type AstmMessageKind, AstmParseError, type AstmParseOptions, type AstmPosition, type AstmProfile, AstmProfileDefinitionError, type AstmProfileProvenance, type AstmQuirkMatch, type AstmQuirkTolerance, type AstmRecord, type AstmRecordInput, type AstmRecordWarning, AstmSerializeError, type AstmSerializeErrorCode, type AstmStreamMessage, AstmStrictError, CANONICAL_DELIMITERS, type CommentInput, type CommentRecord, type ComposeFramesOptions, type DecodeAstmFramesResult, type DefineAstmProfileOptions, type DelimiterDeclarationFault, type DelimiterReadResult, type Delimiters, type DetectFramingOptions, type DetectFramingResult, FATAL_CODES, FRAME_WARNING_CODES, type FatalCode, type FrameChecksum, type FrameOptions, type FrameTerminator, type FrameWarningCode, type FramedAstmResult, type HeaderInput, type HeaderRecord, LIVD_WARNING_CODES, LTP_WARNING_CODES, type LivdAnnotation, type LivdCatalog, type LivdEntry, type LivdLookup, type LivdMapping, type LivdResult, type LivdWarningCode, type LtpAction, type LtpEvent, type LtpPhase, type LtpState, type LtpTransition, type LtpWarningCode, type ManufacturerRecord, type MessageInput, type OrderInput, type OrderRecord, type PatientInput, type PatientName, type PatientNameInput, type PatientRecord, type QueryInput, type QueryRecord, type ReferenceRange, type ReferenceRangeKind, type ResultInput, type ResultRecord, type ResultStatus, type ResultStatusCode, type ResultStatusMeaning, SAFETY_CRITICAL_CODES, type ScientificRecord, type ShiftedComponentsSink, type ShiftedFieldsSink, type SwallowedDelimiterSink, TOLERABLE_CODES, type TerminatorRecord, type TruncatedFieldSink, type UniversalTestId, type UniversalTestIdProvenance, type UnknownEscapeSink, type UnpairedEscapeSink, type UnsupportedRecord, VERSION, type VerbatimInput, WARNING_CODES, type WarningCode, alignmentShiftedComponents, alignmentShiftedFields, alignmentTruncatedField, ambiguousEscapeAlignment, ambiguousMessageKind, ambiguousValueSplit, applyAstmProfile, applyAstmProfileToWarnings, applyLivd, astmDateToLocalISO, astmProfiles, attachComments, buildAstmMessage, classifyMessage, comments, commentsFor, composeAstmFrames, computeChecksum, decodeAstmFrames, decodeEscapes, deepFreeze, defineAstmProfile, defineLivdCatalog, delimiterRoleCollision, delimiterSwallowedByEscape, delimitersRedeclared, detectFraming, encodeComponent, fieldScalar, fieldsUnseparated, frameBadChecksum, frameOversize, frameSequenceGap, frameUnterminated, getAstmProfile, getDefaultAstmProfile, hasCollidingRoles, 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, readDelimiterDeclaration, readDelimiters, recognizeUniversalTestId, resolveProfileTransport, results, serializeAstmRecord, serializeAstmRecords, serializeField, serializeFramedAstm, setDefaultAstmProfile, splitEscapeAware, toChecksumHex, tokenizeHeader, tokenizeRecord, undefinedAbnormalFlag, undefinedResultStatus, uninterpretedQueryStatus, unitsAbsent, unknownEscapeSequence, unknownRecordType, unpairedEscapeCharacter, unparseableReferenceRange, unreadableRedeclaration };