@cosyte/astm 0.0.17 → 0.0.18

package/dist/index.d.ts

@@ -238,6 +238,73 @@ declare const WARNING_CODES: {
      * 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 at all**.
+     * 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 is true wherever it fires. 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, reported by nothing where
+     *   the earlier body is a recognized mnemonic, and open. It is not covered here, because wiring a
+     *   sink to another split is another criterion wanting its own population measurement.
+     * - **The tail is weighed one construct deep**, exactly as for the shift report. Where the escape
+     *   character the reading resumes on heads a sequence this codec *recognizes*, the bytes prefer
+     *   the reading taken 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,
+     *   and refusing it would be an over-refusal of a well-formed stream. Where it heads a sequence
+     *   whose body is *unrecognized*, the competing alignment would leave **two** escape characters
+     *   bare, so the preference is stronger again, and this stays silent there even though the gained
+     *   boundary is real. That last case is the named residue: measured, not overlooked.
+     *
+     * **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";
     /** An escape sequence body was not one of `&F&`/`&S&`/`&R&`/`&E&`: preserved verbatim. */
     readonly ASTM_UNKNOWN_ESCAPE_SEQUENCE: "ASTM_UNKNOWN_ESCAPE_SEQUENCE";
     /**
@@ -511,6 +578,32 @@ 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 of its own, 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; see
+ * {@link WARNING_CODES.ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD}.
+ *
+ * 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
+ * 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_DELIMITERS_REDECLARED` warning. Emitted when a later `H`
  * record declares a delimiter set different from the one in force; the new set is
@@ -3247,6 +3340,13 @@ declare function classifyMessage(records: readonly AstmRecord[]): AstmMessageCla
  *   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}.
+ * @param onAlignmentTruncatedField - Called (with the 0-based field index) for that
+ *   same condition on the **repeat** split, where no field-indexed slot moves and the
+ *   field is instead read as more repeats than the competing alignment gives it.
+ *   Where that boundary is the **first** in the field the field's own modeled reading
+ *   stops at it, because a field is modeled out of its first repeat alone; at a later
+ *   one nothing modeled moves and this still fires. See {@link TruncatedFieldSink}.
+ *   The component split is wired to neither, deliberately.
  * @returns The record's fields.
  * @example
  * ```ts
@@ -3255,7 +3355,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): AstmField[];
 /**
  * Tokenize an `H` (header) record into its fields.
  *
@@ -3291,6 +3391,9 @@ declare function tokenizeRecord(record: string, d: Delimiters, onUnknownEscape?:
  *   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.
+ * @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.
  * @returns The header's fields.
  * @example
  * ```ts
@@ -3300,7 +3403,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): 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
@@ -3483,9 +3586,19 @@ declare class AstmParseError extends Error {
  * 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 tail it deliberately stays silent on, and
+ * why that silence is 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
+ * **component** separator is a third question again and is deliberately not answered
+ * here, because there the components do not disappear, they shift.
  *
  * Re-escaping (the inverse, for spec-clean emit) lives in the serializer and is
  * deliberately not implemented here.
@@ -3587,11 +3700,14 @@ 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
+ * measured, reported by nothing, and open: not something either 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.
  *
  * **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
@@ -3629,6 +3745,68 @@ type AmbiguousAlignmentSink = (segmentIndex: number) => void;
  *   than the competing alignment puts it.
  */
 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 is true
+ * wherever it fires. What that 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 for the same reason.** Where the escape character the reading taken resumes on
+ * heads a sequence this codec recognizes, the bytes prefer the reading taken 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.
+ * Refusing that is the over-refusal that sank an earlier candidate criterion for this
+ * family. Where it heads a sequence whose body is *unrecognized*, the competing
+ * alignment would leave two escape characters bare, so the preference is stronger
+ * again. **The truncation in that second case is real and this stays silent about
+ * it**: a named residue, measured, not overlooked, and not closed by widening the
+ * test, because widening it would report a boundary the bytes prefer.
+ *
+ * @param segmentIndex - The 0-based index of the repeat being accumulated when the
+ *   gained 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;
 /**
  * Decode the four recognized ASTM escape mnemonics in a single already-split
  * leaf (a component string), substituting the *active* delimiters read from the
@@ -3698,6 +3876,11 @@ declare function decodeEscapes(leaf: string, d: Delimiters, onUnknown?: UnknownE
  *   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.
+ * @param onTruncatedField - Called on that same condition, wired only by the split
+ *   taken on the repeat separator, where the cost is not a shift but a field read as
+ *   more repeats than the competing alignment gives it. Where that boundary is the
+ *   **first** in the field the field's modeled reading stops at it; at a later one
+ *   nothing modeled moves and this still fires. See {@link TruncatedFieldSink}.
  * @returns The raw segments, in order.
  * @example
  * ```ts
@@ -3707,7 +3890,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): string[];
 
 /**
  * Deep-freeze helper for the immutable ASTM model.
@@ -4089,6 +4272,27 @@ 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, 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.
+ *
  * **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
@@ -4174,21 +4378,33 @@ 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. **Two 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 two TAIL readers are a different matter, and "no reader sees it" is
+ *   therefore FALSE of this entry and must not be restored.** Both
+ *   `ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS` and
+ *   `ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD` fire on `!isEscapeSequenceAt(text, i + 4,
+ *   escape)`, which is exactly the question this code answers, 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 two 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 +4418,8 @@ 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 bad frame checksum / sequence gap / unterminated
  * / oversize frame, an ambiguous transport, an unexpected protocol event, or a
  * rejected frame: is forbidden.
  *
@@ -4249,6 +4466,15 @@ 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.
+ *
  * @example
  * ```ts
  * import { TOLERABLE_CODES } from "@cosyte/astm";
@@ -5593,4 +5819,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 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, 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 };

package/dist/index.mjs

@@ -327,6 +327,73 @@ var WARNING_CODES = {
    * silent and is correct about its own bytes. A clean re-read is not evidence.
    */
   ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS: "ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS",
+  /**
+   * Two escape alignments of the same bytes disagreed about a **repeat** boundary, the reading
+   * taken kept it, and the escape character that reading resumes on **heads no sequence at all**.
+   * 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 is true wherever it fires. 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, reported by nothing where
+   *   the earlier body is a recognized mnemonic, and open. It is not covered here, because wiring a
+   *   sink to another split is another criterion wanting its own population measurement.
+   * - **The tail is weighed one construct deep**, exactly as for the shift report. Where the escape
+   *   character the reading resumes on heads a sequence this codec *recognizes*, the bytes prefer
+   *   the reading taken 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,
+   *   and refusing it would be an over-refusal of a well-formed stream. Where it heads a sequence
+   *   whose body is *unrecognized*, the competing alignment would leave **two** escape characters
+   *   bare, so the preference is stronger again, and this stays silent there even though the gained
+   *   boundary is real. That last case is the named residue: measured, not overlooked.
+   *
+   * **Catch it on the first read.** Emit rewrites the preserved sequences into recognized
+   * mnemonics, and those bytes carry the reading that was taken unambiguously, so a
+   * second-generation read is silent and is correct about its own bytes. A clean re-read is not
+   * evidence.
+   */
+  ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD: "ASTM_RECORD_ALIGNMENT_TRUNCATED_FIELD",
   /** An escape sequence body was not one of `&F&`/`&S&`/`&R&`/`&E&`: preserved verbatim. */
   ASTM_UNKNOWN_ESCAPE_SEQUENCE: "ASTM_UNKNOWN_ESCAPE_SEQUENCE",
   /**
@@ -486,6 +553,13 @@ function alignmentShiftedFields(position) {
     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, which the other alignment uses to close one. 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. The reading was kept and every byte is preserved.",
+    position
+  };
+}
 function delimitersRedeclared(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_DELIMITERS_REDECLARED,
@@ -1111,7 +1185,7 @@ var referenceCorpus = defineAstmProfile({
   tolerate: [
     {
       code: "ASTM_UNKNOWN_ESCAPE_SEQUENCE",
-      rationale: "The OSS reference stack (python-astm codec.py, firsthand-verified) treats '&' as literal data and never decodes escape sequences, so streams from that ecosystem carry non-standard '&\u2026&' bodies our escape-aware tokenizer flags. The body is preserved byte-for-byte in the value. NOT always non-clinical, and this is measured rather than assumed: where the body is a delimiter, that delimiter never became a field boundary, so `28.6&|&U/L` reads as one value with no units and no final status. That subset now also raises ASTM_RECORD_DELIMITER_SWALLOWED_BY_ESCAPE, which this profile cannot tolerate, so tolerating this code no longer hides it. The same holds for the mirror case, where a sequence ends where another could have begun and a delimiter splits that the other alignment would have held: that raises ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT, which this profile cannot tolerate either. Where that gained boundary is a field boundary and the reading taken resumes on an escape character heading no sequence, every later field shifts and a result's units and status move with it, which raises ASTM_RECORD_ALIGNMENT_SHIFTED_FIELDS, untolerable here as well."
+      rationale: "The OSS reference stack (python-astm codec.py, firsthand-verified) treats '&' as literal data and never decodes escape sequences, so streams from that ecosystem carry non-standard '&\u2026&' bodies our escape-aware tokenizer flags. The body is preserved byte-for-byte in the value. NOT always non-clinical, and this is measured rather than assumed: where the body is a delimiter, that delimiter never became a field boundary, so `28.6&|&U/L` reads as one value with no units and no final status. That subset now also raises ASTM_RECORD_DELIMITER_SWALLOWED_BY_ESCAPE, which this profile cannot tolerate, so tolerating this code no longer hides it. The same holds for the mirror case, where a sequence ends where another could have begun and a delimiter splits that the other alignment would have held: that raises ASTM_RECORD_AMBIGUOUS_ESCAPE_ALIGNMENT, which this profile cannot tolerate either. Where that gained boundary is a field boundary and the reading taken resumes on an escape character heading no sequence, 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. Both of those carry the same tail bound and stay silent where the escape character past the boundary heads a sequence of its own, recognized or not, which is much of this corpus: tolerating this code does not quiet them, but their absence is not a statement that nothing was lost."
     }
   ]
 });
@@ -1185,7 +1259,7 @@ function isMnemonicBody(body) {
 function escapeBody(body, d) {
   return isMnemonicBody(body) ? d[MNEMONIC_ROLES[body]] : void 0;
 }
-function splitEscapeAware(text, delimiter, escape, onAmbiguousAlignment, onShiftedFields) {
+function splitEscapeAware(text, delimiter, escape, onAmbiguousAlignment, onShiftedFields, onTruncatedField) {
   if (text.length === 0) return [""];
   const out = [];
   let current = "";
@@ -1199,6 +1273,7 @@ function splitEscapeAware(text, delimiter, escape, onAmbiguousAlignment, onShift
       }
       if (contested && !isEscapeSequenceAt(text, i + 4, escape)) {
         onShiftedFields?.(out.length);
+        onTruncatedField?.(out.length);
       }
       current += text.slice(i, i + 3);
       i += 3;
@@ -1218,7 +1293,7 @@ function splitEscapeAware(text, delimiter, escape, onAmbiguousAlignment, onShift
 }
 
 // src/records/tokenize.ts
-function tokenizeRecord(record, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment, onAlignmentShiftedFields) {
+function tokenizeRecord(record, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment, onAlignmentShiftedFields, onAlignmentTruncatedField) {
   const rawFields = splitEscapeAware(
     record,
     d.field,
@@ -1233,11 +1308,15 @@ function tokenizeRecord(record, d, onUnknownEscape, onUnpairedEscape, onSwallowe
       () => onUnknownEscape?.(fieldIndex),
       () => onUnpairedEscape?.(fieldIndex),
       () => onSwallowedDelimiter?.(fieldIndex),
-      () => onAmbiguousAlignment?.(fieldIndex)
+      () => onAmbiguousAlignment?.(fieldIndex),
+      // The repeat split runs INSIDE one field, so the index it hands back is a repeat index and is
+      // discarded: what a caller needs is which field carries the contested boundary, and that is
+      // the index this map is already iterating.
+      () => onAlignmentTruncatedField?.(fieldIndex)
     )
   );
 }
-function tokenizeHeader(record, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment, onAlignmentShiftedFields) {
+function tokenizeHeader(record, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment, onAlignmentShiftedFields, onAlignmentTruncatedField) {
   const defEnd = record.indexOf(d.field, 2);
   const definition = defEnd === -1 ? record.slice(2) : record.slice(2, defEnd);
   const head = [opaqueField(record.slice(0, Math.min(1, record.length))), opaqueField(definition)];
@@ -1249,17 +1328,27 @@ function tokenizeHeader(record, d, onUnknownEscape, onUnpairedEscape, onSwallowe
     (i) => onUnpairedEscape?.(i + 2),
     (i) => onSwallowedDelimiter?.(i + 2),
     (i) => onAmbiguousAlignment?.(i + 2),
-    (i) => onAlignmentShiftedFields?.(i + 2)
+    (i) => onAlignmentShiftedFields?.(i + 2),
+    (i) => onAlignmentTruncatedField?.(i + 2)
   );
   return [...head, ...data];
 }
 function opaqueField(raw) {
   return { raw, components: [raw], repeats: [[raw]] };
 }
-function toField(raw, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment) {
-  const rawRepeats = splitEscapeAware(raw, d.repeat, d.escape, () => {
-    onAmbiguousAlignment();
-  });
+function toField(raw, d, onUnknownEscape, onUnpairedEscape, onSwallowedDelimiter, onAmbiguousAlignment, onAlignmentTruncatedField) {
+  const rawRepeats = splitEscapeAware(
+    raw,
+    d.repeat,
+    d.escape,
+    () => {
+      onAmbiguousAlignment();
+    },
+    void 0,
+    () => {
+      onAlignmentTruncatedField();
+    }
+  );
   const repeats = rawRepeats.map(
     (rep) => splitEscapeAware(rep, d.component, d.escape, () => {
       onAmbiguousAlignment();
@@ -1410,6 +1499,11 @@ function buildRecord(line2, recordIndex, d, warnings) {
       alignmentShiftedFields({ recordIndex, recordType: rawType, fieldIndex: fieldIndex + 1 })
     );
   };
+  const onAlignmentTruncatedField = (fieldIndex) => {
+    warnings.push(
+      alignmentTruncatedField({ recordIndex, recordType: rawType, fieldIndex: fieldIndex + 1 })
+    );
+  };
   const fields = rawType === "H" ? tokenizeHeader(
     line2,
     d,
@@ -1417,7 +1511,8 @@ function buildRecord(line2, recordIndex, d, warnings) {
     onUnpairedEscape,
     onSwallowedDelimiter,
     onAmbiguousAlignment,
-    onAlignmentShiftedFields
+    onAlignmentShiftedFields,
+    onAlignmentTruncatedField
   ) : tokenizeRecord(
     line2,
     d,
@@ -1425,7 +1520,8 @@ function buildRecord(line2, recordIndex, d, warnings) {
     onUnpairedEscape,
     onSwallowedDelimiter,
     onAmbiguousAlignment,
-    onAlignmentShiftedFields
+    onAlignmentShiftedFields,
+    onAlignmentTruncatedField
   );
   if (fields.length === 1 && line2.slice(1).trim().length > 0) {
     warnings.push(fieldsUnseparated({ recordIndex, recordType: rawType }));
@@ -2638,8 +2734,8 @@ function concatBytes3(chunks) {
 }
 
 // src/index.ts
-var VERSION = "0.0.17";
+var VERSION = "0.0.18";
 
-export { ALL_ASTM_WARNING_CODES, AMBIGUOUS_CODES, ACK as ASTM_ACK, ENQ as ASTM_ENQ, EOT as ASTM_EOT, NAK as ASTM_NAK, AstmAmbiguousStreamError, AstmFrameEncodeError, AstmFrameStrictError, AstmParseError, AstmProfileDefinitionError, AstmSerializeError, AstmStrictError, CANONICAL_DELIMITERS, FATAL_CODES, FRAME_WARNING_CODES, LIVD_WARNING_CODES, LTP_WARNING_CODES, SAFETY_CRITICAL_CODES, TOLERABLE_CODES, VERSION, WARNING_CODES, 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, AstmAmbiguousStreamError, AstmFrameEncodeError, AstmFrameStrictError, AstmParseError, AstmProfileDefinitionError, AstmSerializeError, AstmStrictError, CANONICAL_DELIMITERS, FATAL_CODES, FRAME_WARNING_CODES, LIVD_WARNING_CODES, LTP_WARNING_CODES, SAFETY_CRITICAL_CODES, TOLERABLE_CODES, VERSION, WARNING_CODES, 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 };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map