@cosyte/x12 0.0.14 → 0.0.16

package/dist/index.d.cts

@@ -285,9 +285,7 @@ interface X12ParseWarning {
  * Neither side is echoed, not truncated and not hashed. A control number is
  * free-form trading-partner text on five of the six slots (only ISA-13 is
  * fixed-width), routinely carries a batch or patient-account identifier in
- * the field, and is entirely sender-controlled. Read `isa.elements[13]`,
- * `iea.elements[2]`, `gs.elements[6]`, `ge.elements[2]`, `st.elements[2]`
- * and `se.elements[2]` off the model when you need the values.
+ * the field, and is entirely sender-controlled.
  *
  * @example
  * ```ts
@@ -319,8 +317,7 @@ declare function pre005010(position: X12Position): X12ParseWarning;
  * Build an `X12_GROUP_COUNT_MISMATCH` warning. Emitted when IEA-01 does not
  * equal the actual number of GS..GE groups present in the interchange.
  * Trading partners use this to detect transmission truncation. Both numbers
- * stay on the model (`iea.elements[1]` and `ix.groups.length`) and neither
- * is silently corrected.
+ * stay on the model and neither is silently corrected.
  *
  * @example
  * ```ts
@@ -332,8 +329,7 @@ declare function groupCountMismatch(position: X12Position): X12ParseWarning;
 /**
  * Build an `X12_TRANSACTION_COUNT_MISMATCH` warning. Emitted when GE-01
  * does not equal the actual number of ST..SE transaction sets present in
- * the group. Both numbers stay on the model (`ge.elements[1]` and
- * `group.transactions.length`).
+ * the group. Both numbers stay on the model.
  *
  * @example
  * ```ts
@@ -588,10 +584,15 @@ declare function missingRequiredLoop(position: X12Position, loop: X12RequiredLoo
  * Build an `X12_837_UNKNOWN_VARIANT` warning. Emitted when the 837 helper
  * cannot resolve the variant from ST-03's implementation-convention
  * reference AND no SVx service-line segment is present to fall back on.
- * The parsed submission still ships with `variant: "unknown"` and the
- * verbatim reference on `submission.implementationConventionReference`; the
+ * The parsed submission still ships with `variant: "unknown"`, and the
  * walker does its best on shared structure (envelope, HL, claim header) and
- * skips variant-specific service-line decoding.
+ * skips variant-specific service-line decoding. **This message deliberately
+ * points at no model field.** Recognition reads `ST-03` as FRAMED while
+ * `submission.implementationConventionReference` is decoded of any `?` release
+ * escape, so on a document that escapes a delimiter inside `ST-03` the two
+ * differ and the model field can hold an identifier this code just said was
+ * not recognised (`X12-ST03-READ-NOT-RELEASE-AWARE`). A pointer stood here and
+ * in the message text and is DELETED, not reworded.
  *
  * `get837Claims` anchors this at the **ST**, which is `tx.segments[0]` and
  * carries the ST-03 the resolution reads. Through `0.0.10` it passed
@@ -1454,6 +1455,12 @@ declare const NON_SPEC_SEGMENT_ID = "(non-spec)";
  * decodes to an empty segment (`id: ""`, `elements: [""]`); callers that
  * care can guard.
  *
+ * **A degenerate delimiter set whose ELEMENT SEPARATOR is itself `?` splits
+ * literally**, because one byte cannot both separate and escape. Only that
+ * role is guarded here: a `?` repetition or component separator is a
+ * different call and is deliberately unchanged (see
+ * {@link "./release.js".splitWithRelease}).
+ *
  * @example
  * ```ts
  * import { decodeSegment } from "@cosyte/x12";
@@ -1916,7 +1923,9 @@ interface Ta1Segment {
  *
  * `elements` on the ST and SE segments themselves IS decoded at envelope
  * time so envelope invariants can be checked (ST-02 ↔ SE-02 control-number
- * reconciliation, SE-01 segment count).
+ * reconciliation, SE-01 segment count). **Read "decoded" as element-SPLIT and
+ * nothing more: the strings are PRE-`?`-unescape**, and a reader that publishes
+ * one to a consumer unescapes it first (`X12-ST03-READ-NOT-RELEASE-AWARE`).
  *
  * @example
  * ```ts
@@ -2483,9 +2492,10 @@ declare function unescapeRelease(input: string, delimiters: Delimiters, emit: (w
  * the untyped-refusal defect this package has fixed elsewhere. This is a pure
  * text utility with no spec, no element and no caller context to name, so
  * `TypeError` is the accurate answer for a wrong-typed argument. **Nothing
- * inside this library can reach it**: all nine builders route every element
+ * inside this library can reach it**: every builder routes its elements
  * through `src/builder/caller-string.ts`, which refuses first with the calling
- * builder's own typed, code-tagged error. This throw is the backstop for a
+ * builder's own typed, code-tagged error. (No count: it is asserted by
+ * `test/builder-string-type.test.ts` and was stale here.) This throw is the backstop for a
  * consumer calling the export directly, where the alternative was silent data
  * loss.
  *
@@ -5720,22 +5730,23 @@ declare function get837Claims(delimiters: Delimiters, tx: X12TransactionSet, opt
 
 /**
  * Interchange + group + transaction identity for the built 837. The builder
- * fixes GS-01 to `"HC"` and the ST-03 / GS-08 version to the variant's TR3
- * (`005010X222A2` / `X223A3` / `X224A2`) so the caller never hand-codes them.
- *
- * **🩺 Known limitation, disclosed rather than changed: those three are
- * published errata guides, but they are neither the identifiers HIPAA
- * adopts at 45 CFR 162.1102 nor the ones payer companion guides commonly
- * require in ST-03 / GS-08** (CMS and several state Medicaid guides state
- * `005010X222A1` for Professional, `005010X223A2` for Institutional and
- * `005010X224A2` for Dental). **A partner that requires one of those will
- * reject a Professional or Institutional 837 this builder emits, and there
- * is currently no way for a caller to override the value.** Nothing here
- * was re-stamped on that evidence: which published guide identifier a
- * trading partner accepts is a partner fact, not a spec fact, and silently
- * changing bytes this library already emitted would break the partners it
- * works with today. `KNOWN-LIMITATIONS.md` carries this as an open
- * residual. The READ side is unaffected - `get837Claims` recognises all of
+ * fixes GS-01 to `"HC"`, and defaults the ST-03 / GS-08 reference to the
+ * variant's TR3 (`005010X222A2` / `X223A3` / `X224A2`) so the caller never
+ * has to hand-code it.
+ *
+ * **🩺 That default is not what every trading partner accepts, so
+ * {@link Build837EnvelopeSpec.implementationConventionReference} overrides
+ * it.** The three defaults are published errata guides, but they are
+ * neither the identifiers HIPAA adopts at 45 CFR 162.1102 nor the ones
+ * payer companion guides commonly require in ST-03 / GS-08 (CMS and several
+ * state Medicaid guides state `005010X222A1` for Professional and
+ * `005010X223A2` for Institutional). **A partner that requires one of those
+ * will reject a Professional or Institutional 837 built on the default**,
+ * and the override is how you send what your partner asked for. The default
+ * itself was deliberately NOT re-stamped: which published guide identifier
+ * a partner accepts is a partner fact rather than a spec fact, and changing
+ * bytes this library already emitted would break the partners it works with
+ * today. The READ side is unaffected - `get837Claims` recognises all of
  * these references.
  *
  * @example
@@ -5764,6 +5775,44 @@ interface Build837EnvelopeSpec {
     readonly groupControlNumber: string;
     /** ST-02 / SE-02 - transaction set control number. */
     readonly transactionSetControlNumber: string;
+    /**
+     * 🩺 ST-03 **and** GS-08 - the implementation convention reference this
+     * 837 declares. Default: the variant's TR3 (`005010X222A2` Professional,
+     * `005010X223A3` Institutional, `005010X224A2` Dental).
+     *
+     * **Set it to whatever your trading partner's companion guide requires**,
+     * for example `005010X222A1` on a professional claim to a payer that asks
+     * for it. Which published identifier a partner accepts is a partner fact,
+     * so this library will not choose for you: it defaults to a real published
+     * guide and gets out of the way. **One value is written to both elements**,
+     * because this builder has always written the same reference to ST-03 and
+     * GS-08 and nothing grounds a caller making them differ. That is a statement
+     * about the bytes this field emits, not about what each element may legally
+     * hold: GS-08 is data element 480 (`AN 1/12`) and ST-03 is element 1705
+     * (`AN 1/35`), and nothing here bounds the length.
+     *
+     * Refused, all `X12_837_BUILD_INVALID_SPEC`. An **empty** string, because a
+     * trailing empty element is dropped on emit, so it would delete ST-03 and
+     * GS-08 rather than send them empty. One carrying an **active delimiter or
+     * the release character**, because these two elements cannot carry it even
+     * escaped: the ST and GS segments are read by a splitter that is not
+     * release-aware, so the declaration would silently become two elements. And
+     * one **this library's own reader resolves to a different variant**
+     * (`005010X223A2` handed to `build837P`): the file would declare one variant
+     * and carry another's service segments, and `get837Claims` would then decode
+     * none of its service lines. Those are what this field adds, on top of the
+     * element-type guard every string slot already has, which refuses a
+     * non-string with the same code - no total is published. **Anything else is
+     * emitted as given** - the set of published errata is not provably
+     * exhaustive, so an identifier this library does not carry is the caller's
+     * call, not an error.
+     *
+     * 🩺 A guard on this element cannot make the element trustworthy. An active
+     * delimiter in a DIFFERENT envelope field splits its own segment and shifts
+     * every element after it, so ST-03 / GS-08 are then read out of a
+     * neighbour's slot. `KNOWN-LIMITATIONS.md` carries the measurement.
+     */
+    readonly implementationConventionReference?: string;
     /** ISA-05 - interchange sender qualifier. Default `"ZZ"`. */
     readonly senderQualifier?: string;
     /** ISA-07 - interchange receiver qualifier. Default `"ZZ"`. */
@@ -6475,8 +6524,9 @@ interface Build837Spec {
 
 /**
  * `build837P` / `build837I` / `build837D` - pure-function builders for a
- * 005010 837 Healthcare Claim (Professional `X222A2`, Institutional
- * `X223A3`, Dental `X224A2`). NEVER auto-sends, NEVER opens a socket, NEVER
+ * 005010 837 Healthcare Claim (Professional, Institutional, Dental; the
+ * ST-03 / GS-08 guide reference defaults to `X222A2` / `X223A3` / `X224A2`
+ * and the caller may state another). NEVER auto-sends, NEVER opens a socket, NEVER
  * touches the filesystem. The library mechanically emits the claim it is
  * told; a spec whose billing-provider → subscriber → (claims | patient)
  * tree cannot form a valid HL hierarchy is REFUSED via {@link
@@ -6505,7 +6555,9 @@ interface Build837Spec {
  */
 
 /**
- * `build837P` - assemble a 005010X222A2 Professional 837 around the spec.
+ * `build837P` - assemble a Professional 837 around the spec, declaring
+ * `005010X222A2` unless `envelope.implementationConventionReference` states
+ * the guide your trading partner requires.
  *
  * @example
  * ```ts
@@ -6537,8 +6589,10 @@ interface Build837Spec {
  */
 declare function build837P(spec: Build837Spec): X12Interchange;
 /**
- * `build837I` - assemble a 005010X223A3 Institutional 837 around the spec.
- * Service lines must be `variant: "I"` (SV2).
+ * `build837I` - assemble an Institutional 837 around the spec, declaring
+ * `005010X223A3` unless `envelope.implementationConventionReference` states
+ * the guide your trading partner requires. Service lines must be
+ * `variant: "I"` (SV2).
  *
  * @example
  * ```ts
@@ -6549,8 +6603,10 @@ declare function build837P(spec: Build837Spec): X12Interchange;
  */
 declare function build837I(spec: Build837Spec): X12Interchange;
 /**
- * `build837D` - assemble a 005010X224A2 Dental 837 around the spec. Service
- * lines must be `variant: "D"` (SV3); per-line tooth detail rides on TOO.
+ * `build837D` - assemble a Dental 837 around the spec, declaring
+ * `005010X224A2` unless `envelope.implementationConventionReference` states
+ * the guide your trading partner requires. Service lines must be
+ * `variant: "D"` (SV3); per-line tooth detail rides on TOO.
  *
  * @example
  * ```ts
@@ -12288,7 +12344,9 @@ type Ta1AckCode = (typeof TA1_ACK_CODES)[keyof typeof TA1_ACK_CODES];
  * TA1-05 interchange note code (ASC X12 code list I18). Codes `000`–`028`
  * are defined by the standard; values past `028` exist in some standard
  * revisions and are accepted on parse (Postel's Law) but not enumerated
- * here - the parsed model carries the raw string for verbatim preservation.
+ * here - the parsed model carries the un-narrowed string on `noteCodeRaw`,
+ * post-`?`-unescape as of `X12-TA1-RESIDUALS`. **A clause here said "verbatim"
+ * and is deleted rather than reworded**; `raw.elements[5]` is the byte surface.
  *
  * `000` is the canonical "no error" note paired with a `TA1-04 == 'A'`
  * acceptance. The build-time safety guard refuses a fabricated `A` paired
@@ -12365,9 +12423,11 @@ declare const TA1_NOTE_CODES: {
 /**
  * String-literal union over {@link TA1_NOTE_CODES} - the standard-issued
  * note codes `000`–`028`. Real-world inbound TA1 may carry a value past
- * `028` (some revisions extend the list); `parseTA1` exposes the raw
- * string in that case so the verbatim value survives even when the union
- * cannot statically type it.
+ * `028` (some revisions extend the list); `parseTA1` exposes the
+ * un-narrowed string on `noteCodeRaw` in that case, so the value survives
+ * even when the union cannot statically type it. **It is post-`?`-unescape
+ * as of `X12-TA1-RESIDUALS`, and a clause here calling it VERBATIM is
+ * deleted rather than reworded** - `raw.elements[5]` is the byte surface.
  */
 type Ta1NoteCode = (typeof TA1_NOTE_CODES)[keyof typeof TA1_NOTE_CODES];
 
@@ -12589,13 +12649,23 @@ interface X12Ack999 {
  * - `interchangeTime` - TA1-03: HHMM (echoes inbound ISA-10).
  * - `ackCode` - TA1-04: {@link Ta1AckCode}.
  * - `noteCode` - TA1-05: typed when the value is a known I18 code
- *   ({@link Ta1NoteCode}); the raw string is preserved verbatim alongside
- *   so unknown extensions round-trip.
- * - `noteCodeRaw` - verbatim TA1-05 string. Equal to `noteCode` when the
- *   value is a known I18 code; equal to the raw inbound text when not.
+ *   ({@link Ta1NoteCode}); `noteCodeRaw` carries the un-narrowed string
+ *   alongside so unknown extensions survive. **A clause here said that
+ *   string is preserved VERBATIM and is deleted, not reworded:**
+ *   `X12-TA1-RESIDUALS` made it post-unescape, and `raw.elements[5]` is
+ *   the verbatim surface.
+ * - `noteCodeRaw` - the un-narrowed TA1-05 string. Equal to `noteCode` when
+ *   the value is a known I18 code; equal to the decoded inbound text when
+ *   not.
  * - `raw` - the underlying envelope-level {@link Ta1Segment}, for
  *   byte-exact round-trip.
  *
+ * **The five decoded fields are POST-`?`-unescape; `raw` is the verbatim
+ * byte surface and is not.** `X12-TA1-RESIDUALS` moved the decoded half:
+ * before it, a released TA1-01 read back carrying its `?` and matched no
+ * ISA-13, while every dot-path read of the same element already unescaped.
+ * Read `raw.elements` when you want the bytes.
+ *
  * @example
  * ```ts
  * import type { X12AckTA1 } from "@cosyte/x12";
@@ -12862,6 +12932,93 @@ declare function build999(spec: Build999Spec): X12Interchange;
  * library does NOT silently invent envelope bytes around it - the caller's
  * application boundary owns whether the TA1 is embedded in an outbound
  * interchange or sent as a standalone TA1-only interchange.
+ *
+ * ## 🩺 Why every element is released, and what that changed
+ *
+ * `raw` used to be `[...five caller values].join(elementSeparator)` with
+ * nothing in between, so a caller value carrying an active delimiter took
+ * a slot of its own and shifted every element after it down one. TA1-04 is
+ * the disposition and TA1-05 the note, so the shift landed the read on the
+ * wrong pair, and `parseTA1` narrows an out-of-enum TA1-04 to `R`:
+ * **an Accept this library emitted read back as a Reject**, with the TA1-01
+ * reassociation key merged into TA1-02 and `warnings: []` on every channel.
+ * The inverse is the less safe one and also existed: a `noteCode` of
+ * literally `"A"` (a value the type forbids and nothing checks at run time)
+ * shifted onto TA1-04 and made a **Reject read back as an Accept**, which a
+ * sender never resubmits against.
+ *
+ * The grounding is inside the package, not in a spec clause, which is the
+ * same tiebreak `X12-ENVELOPE-SPLITTER-NOT-RELEASE-AWARE` recorded: one
+ * function disagreed with itself. This module emitted bytes that this
+ * package's own reader decoded into a different disposition than the one
+ * the caller asked for, and every other builder already released the same
+ * class of element through the same helper.
+ *
+ * **It changes bytes, and that is the cost that kept it open for a slice.**
+ * A value containing none of the four delimiters or the release character
+ * is emitted byte-for-byte as before, which is every conformant TA1. A
+ * value containing one is now released, so its bytes differ from the ones
+ * `0.0.14` and earlier put on the wire. What that costs is stated outright
+ * below rather than argued away, and **without a total**: two drafts of this
+ * account published a closed one and both were refuted.
+ *
+ * - **The consumer predicate moves in BOTH directions.** Read the property
+ *   rather than a direction list: `parseTA1` of a `buildTA1` output now
+ *   reports the disposition and note the CALLER passed, where before it
+ *   reported whatever element the shift left in TA1-04. So
+ *   `ackCode === "R"` stops firing where an Accept had been shifted onto
+ *   it, and starts firing where a Reject had been shifted off it -
+ *   `interchangeTime: "12*A"` with `ackCode: "R"` read `"A"` before and
+ *   reads `"R"` here, every field a valid member of its union. What is
+ *   one-directional is the safety, which is a different statement.
+ * - **Only three values in the escaped set ever shifted the segment's own
+ *   element framing**: the element separator, the segment terminator, and
+ *   a `?` immediately before the separator. **`^` and `:` moved the
+ *   dot-path reader instead, and releasing them is a GAIN there.**
+ *   `getSegmentValue(ta1, "01")` answered `"0000"` before for a control
+ *   number of `"0000^0001"`, truncating the reassociation key to the first
+ *   repetition, and answers `"0000^0001"` here; the composite read `"01-1"`
+ *   answered `"0000"` for `"0000:0001"`. **The measured pure cost is a
+ *   MID-STRING `?`, and only on the surfaces documented as raw**: `raw` and
+ *   `elements` read `"0000??0001"` where they read `"0000?0001"`, while the
+ *   dot-path read of THAT value unescapes and answered `"0000?0001"` on
+ *   both. Read the clause as scoped to the mid-string `?`, because it is
+ *   not true of `^` or `:` three sentences up. **`getSegmentValue` takes an
+ *   `X12Segment` and `Ta1Segment` carries no `id`, so add one to read a TA1
+ *   through it.** No total is published: that is what was measured, not a
+ *   closed account.
+ *   **🩺 A CLAUSE NAMING `parseTA1`'s FIELDS AS A THIRD SUCH SURFACE STOOD
+ *   HERE AND IS DELETED, NOT REWORDED.** `X12-TA1-RESIDUALS` made those
+ *   fields post-unescape, so it is measured false; do not restate it.
+ * - **A caller who was pre-releasing the value themselves** (the remedy
+ *   `KNOWN-LIMITATIONS.md` named while this was open) is now escaping
+ *   twice: `"00000001??"` in, `"00000001????"` out. The framing and the
+ *   disposition stay correct, and this one regresses on BOTH kinds of
+ *   surface - the dot-path read answers `"00000001??"` where it answered
+ *   `"00000001?"`. Drop the hand-rolled escape.
+ *
+ * **And an EMPTY control number USED to go out unrefused.** `escapeRelease`
+ * early-returns on `""` and this module had no required-field guard, so
+ * `interchangeControlNumber: ""` emitted `TA1**260601*1200*A*000` with no
+ * error, through `0.0.15`. `X12-EMPTY-CONTROL-NUMBER-FABRICATED` closed it:
+ * see {@link "../../builder/caller-control-number.js".requireControlNumber}.
+ * `X12-CONTROL-NUMBER-GUARD-NOT-TYPE-CHECKED` then made the same guard
+ * type-check, so TA1-01 draws a refusal naming TA1-01 rather than the escaper's
+ * one naming only the builder - same class, same code, different words. The
+ * guard is still byte-strict, so a whitespace-only TA1-01 still builds.
+ *
+ * **The other four slots were left open by that slice and `X12-TA1-RESIDUALS`
+ * closes them.** TA1-01's guard was the only required-field guard this module
+ * had, so `interchangeDate`, `interchangeTime`, `ackCode` and `noteCode` each
+ * emitted an absent element on `""` with `warnings: []`. **TA1-05's cell has to
+ * be read against a NON-Accept disposition, or `enforceAcceptIsClean` reaches
+ * it first and the reading measures that guard instead** - see
+ * {@link requireTa1Element}, which carries the grounding and the residual it
+ * deliberately leaves.
+ *
+ * And the release is scoped to the delimiter set the caller states through
+ * {@link BuildTA1Options} - see that interface for why guessing one is a
+ * value corruption rather than a safe default.
  */
 
 /**
@@ -12876,7 +13033,18 @@ declare function build999(spec: Build999Spec): X12Interchange;
  * - `ackCode === "A"` paired with `noteCode !== "000"` →
  *   {@link "./errors.js".ACK_BUILD_ERROR_CODES.X12_TA1_ACCEPT_WITH_NOTE}.
  *   Accept must mean accept. Use `E` (accept with errors) when the
- *   inbound had structural defects you elected to ignore.
+ *   inbound had structural defects you elected to ignore. This one runs
+ *   FIRST and its precedence is unchanged.
+ * - Any of the five element values that is not a `string` →
+ *   {@link "./errors.js".ACK_BUILD_ERROR_CODES.X12_ACK_INVALID_SPEC}. This
+ *   is not a bonus guard: releasing a value means routing it through
+ *   {@link "../../builder/caller-string.js".makeCallerEscaper}, and the
+ *   bare `escapeRelease` underneath it returns its empty accumulator for a
+ *   `number`, so escaping without the type check would have replaced the
+ *   shifted-element defect with a silently VANISHED TA1-01. **A number or
+ *   an `undefined` control number used to emit as `TA1*12345*…` (the
+ *   number surviving onto `elements`, in a `readonly string[]`) or
+ *   `TA1**250101*…`; both now refuse.**
  *
  * @param spec - The TA1 fields. `interchangeControlNumber` echoes the
  *               inbound ISA-13; `interchangeDate` / `interchangeTime` echo
@@ -12914,13 +13082,28 @@ declare function build999(spec: Build999Spec): X12Interchange;
  */
 declare function buildTA1(spec: BuildTA1Spec, options?: BuildTA1Options): Ta1Segment;
 /**
- * Options accepted by {@link buildTA1}. Both fields are optional - pass
- * none for the cosyte default envelope (`*` element separator). Override
- * only when the TA1 is being embedded in an outer envelope whose declared
- * delimiters differ from the cosyte default.
+ * Options accepted by {@link buildTA1}: the delimiter set the returned
+ * segment will be read against. Every field is optional and defaults to the
+ * cosyte parser archetype (`*` element, `^` repetition, `:` component, `~`
+ * segment), which is the same four `build999` takes on
+ * {@link "./types.js".Build999EnvelopeSpec}.
+ *
+ * **The three non-element fields exist for ESCAPING and nothing else.**
+ * `buildTA1` still emits no segment terminator, no repetition and no
+ * composite. It has to know them because a caller value carrying one of
+ * them has to be released, and because escaping a byte that is NOT a
+ * delimiter where the segment lands corrupts the value: `unescapeRelease`
+ * preserves `?X` verbatim for any `X` outside the declared set, so a value
+ * released against a guessed delimiter comes back carrying a stray `?`.
+ * **If you embed a TA1 in an envelope whose delimiters are not the
+ * archetype, state them here** - the defaults are an assumption this
+ * function cannot verify, exactly as they were before it escaped anything.
  */
 interface BuildTA1Options {
     readonly elementSeparator?: string;
+    readonly repetitionSeparator?: string;
+    readonly componentSeparator?: string;
+    readonly segmentTerminator?: string;
 }
 
 /**
@@ -13008,9 +13191,7 @@ interface BuildTA1Options {
  * Every warning it emits is built by the same value-free factories the parser
  * uses: `message` is a frozen-registry lookup and `position` locates the
  * control segment, so a declared count or control number can never reach a
- * diagnostic. Read the declared and actual values off the model
- * (`se.elements[1]` against `tx.rawSegments.length`, `ge.elements[1]` against
- * `group.transactions.length`, `iea.elements[1]` against `ix.groups.length`).
+ * diagnostic.
  */
 
 /**