@cosyte/dicom 0.0.14 → 0.0.15

package/dist/index.d.cts

@@ -329,13 +329,31 @@ interface ParseOptions {
      *
      * 🛑 **THE ESCALATED DIAGNOSTIC CARRIES SOURCE BYTES THAT THE WARNING DOES
      * NOT.** A `DicomParseWarning.message` is a frozen registry string with only
-     * structural tokens filled in, so it is safe to log whole **on a well-formed
-     * file, and it is not unconditionally safe**: the `{tag}` slot is filled by a
-     * shape check, which cannot refuse a tag a lying Value Length composed out of
-     * somebody's value (measured, `PRE-EXISTING`, disclosed rather than guarded
-     * because withholding the tag would take it off every private element in every
-     * conformant file). The `DicomParseError` this option raises in its place is a
-     * different and larger surface: it also carries `snippet`,
+     * structural tokens filled in: `{tag}` renders only a tag PS3.6's element
+     * registry carries a literal row for, `{vr}` only one of the 34 VRs PS3.5
+     * section 6.2 defines, and a raw length or byte value a header carries is
+     * bound out of the factory signature rather than rendered. That now holds on
+     * the `deidentify()` codes too:
+     * `DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE` and
+     * `DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE` rendered `Element.rawBytes.length`
+     * through `0.0.14`, which equals the declared Value Length and was reachable
+     * from a fabricated header, and both slots are gone. So is
+     * `DICOM_ITEM_CROSSES_SEQUENCE_END`'s remaining-bytes count, because **a raw
+     * number shifted by a constant the reader can compute is that raw number**: it
+     * was the enclosing sequence's declared Value Length less the bytes of that
+     * sequence already consumed. **The exceptions are named in one place that is
+     * not a record of a past change, and are deliberately not restated here** -
+     * the `WARNING_MESSAGES` docblock in `./warnings.ts`, which this JSDoc used to
+     * carry a copy of.
+     * **This is a statement about `w.message` and about nothing else**: the two
+     * byte counts still exist on `report.undefinedVrElements[].byteLength` and
+     * `report.unauditableSequences[].byteLength`, model fields on a type whose own
+     * docs say it is not a value-free surface. **No
+     * safe-to-log verdict is stated here** - that sentence was corrected twice and
+     * is deleted rather than tried a third time; the mechanism is above and the
+     * treatment is in the package's troubleshooting docs. The `DicomParseError`
+     * this option raises in its place is a different and larger surface: it also
+     * carries `snippet`,
      * **16 raw bytes, unredacted** (D-10), read at the warning's own `byteOffset`.
      * A message-only PHI review of the lenient path therefore does not transfer to
      * the strict one. Log `err.code`, `err.byteOffset` and `err.message`; treat
@@ -2706,12 +2724,21 @@ interface UndefinedVrFinding {
      *
      * **An input-derived count, and on this finding specifically that is not a
      * formality.** For the sibling findings the length came from a header the
-     * sender wrote; here the two length bytes can themselves be value bytes, like
-     * the tag bytes. What is published is the *number* they decode to, never the
-     * bytes - the same footing as every `{n}` in the warning registry, which is
-     * documented there as "an input-derived count". A number is not a rendering,
-     * and the reach is at most a character or so, but do not describe this field
-     * as "structural, never a value" the way its siblings are described.
+     * sender wrote; here the four length bytes can themselves be value bytes, like
+     * the tag bytes. What is published is the *number* they decode to, and one
+     * `readUInt32LE` puts the bytes back: a fabricated header reading `"SO\0\0"`
+     * publishes `20307`, two letters of a surname. Do not describe this field as
+     * "structural, never a value" the way its siblings are described.
+     *
+     * **🩺 IT IS NO LONGER "the same footing as every `{n}` in the warning
+     * registry", AND THAT SENTENCE WAS THE ONE THIS FIELD SHIPPED WITH.**
+     * `DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE` rendered exactly this number and
+     * does not any more - it is bound out of `undefinedVrNotAuditable`'s
+     * signature. So this field is now a **model field**, on the same standing
+     * exception as `removedPrivateTags`, `unauditableSequences[].tag`, `uidMap`
+     * and `contextPath`: narrowing it is a product call, because a bound empties
+     * it on every well-formed file, where it is exactly the audit number the field
+     * exists to carry. Deliberately unchanged; see this type's own summary.
      */
     readonly byteLength: number;
     /**
@@ -2754,6 +2781,18 @@ interface UndefinedVrFinding {
  *   and still answers it whenever the fabricated VR is outside the 34 PS3.5
  *   §6.2 defines. It cannot when the fabricated VR is one of them, because those
  *   two files are byte-identical.
+ * - **`undefinedVrElements[].byteLength` and
+ *   `unauditableSequences[].byteLength`** - the declared Value Length read off
+ *   the element header, so on a fabricated header it is four document bytes
+ *   wearing a decimal: `"SO\0\0"` publishes `20307`, two letters of a surname,
+ *   put back with one `readUInt32LE`. **They JOINED this list rather than
+ *   always having been on it.** Through `0.0.14` the two
+ *   `DICOM_DEIDENT_*_NOT_AUDITABLE` **messages** rendered the same number;
+ *   binding it out of those factory signatures left these model fields as its
+ *   only publisher, which is a smaller surface and not a closed one. Narrowing
+ *   them is a product call rather than a defect fix: a bound empties the field
+ *   on every well-formed file, where the number is exactly the audit
+ *   information it exists to carry.
  * - **`contextPath`, on all four findings that carry one** - see
  *   {@link DeidentifiedAttribute.contextPath}, which holds the measurement. The
  *   segment tags come off the wire with no table behind them, so a fabricated

package/dist/index.d.ts

@@ -329,13 +329,31 @@ interface ParseOptions {
      *
      * 🛑 **THE ESCALATED DIAGNOSTIC CARRIES SOURCE BYTES THAT THE WARNING DOES
      * NOT.** A `DicomParseWarning.message` is a frozen registry string with only
-     * structural tokens filled in, so it is safe to log whole **on a well-formed
-     * file, and it is not unconditionally safe**: the `{tag}` slot is filled by a
-     * shape check, which cannot refuse a tag a lying Value Length composed out of
-     * somebody's value (measured, `PRE-EXISTING`, disclosed rather than guarded
-     * because withholding the tag would take it off every private element in every
-     * conformant file). The `DicomParseError` this option raises in its place is a
-     * different and larger surface: it also carries `snippet`,
+     * structural tokens filled in: `{tag}` renders only a tag PS3.6's element
+     * registry carries a literal row for, `{vr}` only one of the 34 VRs PS3.5
+     * section 6.2 defines, and a raw length or byte value a header carries is
+     * bound out of the factory signature rather than rendered. That now holds on
+     * the `deidentify()` codes too:
+     * `DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE` and
+     * `DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE` rendered `Element.rawBytes.length`
+     * through `0.0.14`, which equals the declared Value Length and was reachable
+     * from a fabricated header, and both slots are gone. So is
+     * `DICOM_ITEM_CROSSES_SEQUENCE_END`'s remaining-bytes count, because **a raw
+     * number shifted by a constant the reader can compute is that raw number**: it
+     * was the enclosing sequence's declared Value Length less the bytes of that
+     * sequence already consumed. **The exceptions are named in one place that is
+     * not a record of a past change, and are deliberately not restated here** -
+     * the `WARNING_MESSAGES` docblock in `./warnings.ts`, which this JSDoc used to
+     * carry a copy of.
+     * **This is a statement about `w.message` and about nothing else**: the two
+     * byte counts still exist on `report.undefinedVrElements[].byteLength` and
+     * `report.unauditableSequences[].byteLength`, model fields on a type whose own
+     * docs say it is not a value-free surface. **No
+     * safe-to-log verdict is stated here** - that sentence was corrected twice and
+     * is deleted rather than tried a third time; the mechanism is above and the
+     * treatment is in the package's troubleshooting docs. The `DicomParseError`
+     * this option raises in its place is a different and larger surface: it also
+     * carries `snippet`,
      * **16 raw bytes, unredacted** (D-10), read at the warning's own `byteOffset`.
      * A message-only PHI review of the lenient path therefore does not transfer to
      * the strict one. Log `err.code`, `err.byteOffset` and `err.message`; treat
@@ -2706,12 +2724,21 @@ interface UndefinedVrFinding {
      *
      * **An input-derived count, and on this finding specifically that is not a
      * formality.** For the sibling findings the length came from a header the
-     * sender wrote; here the two length bytes can themselves be value bytes, like
-     * the tag bytes. What is published is the *number* they decode to, never the
-     * bytes - the same footing as every `{n}` in the warning registry, which is
-     * documented there as "an input-derived count". A number is not a rendering,
-     * and the reach is at most a character or so, but do not describe this field
-     * as "structural, never a value" the way its siblings are described.
+     * sender wrote; here the four length bytes can themselves be value bytes, like
+     * the tag bytes. What is published is the *number* they decode to, and one
+     * `readUInt32LE` puts the bytes back: a fabricated header reading `"SO\0\0"`
+     * publishes `20307`, two letters of a surname. Do not describe this field as
+     * "structural, never a value" the way its siblings are described.
+     *
+     * **🩺 IT IS NO LONGER "the same footing as every `{n}` in the warning
+     * registry", AND THAT SENTENCE WAS THE ONE THIS FIELD SHIPPED WITH.**
+     * `DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE` rendered exactly this number and
+     * does not any more - it is bound out of `undefinedVrNotAuditable`'s
+     * signature. So this field is now a **model field**, on the same standing
+     * exception as `removedPrivateTags`, `unauditableSequences[].tag`, `uidMap`
+     * and `contextPath`: narrowing it is a product call, because a bound empties
+     * it on every well-formed file, where it is exactly the audit number the field
+     * exists to carry. Deliberately unchanged; see this type's own summary.
      */
     readonly byteLength: number;
     /**
@@ -2754,6 +2781,18 @@ interface UndefinedVrFinding {
  *   and still answers it whenever the fabricated VR is outside the 34 PS3.5
  *   §6.2 defines. It cannot when the fabricated VR is one of them, because those
  *   two files are byte-identical.
+ * - **`undefinedVrElements[].byteLength` and
+ *   `unauditableSequences[].byteLength`** - the declared Value Length read off
+ *   the element header, so on a fabricated header it is four document bytes
+ *   wearing a decimal: `"SO\0\0"` publishes `20307`, two letters of a surname,
+ *   put back with one `readUInt32LE`. **They JOINED this list rather than
+ *   always having been on it.** Through `0.0.14` the two
+ *   `DICOM_DEIDENT_*_NOT_AUDITABLE` **messages** rendered the same number;
+ *   binding it out of those factory signatures left these model fields as its
+ *   only publisher, which is a smaller surface and not a closed one. Narrowing
+ *   them is a product call rather than a defect fix: a bound empties the field
+ *   on every well-formed file, where the number is exactly the audit
+ *   information it exists to carry.
  * - **`contextPath`, on all four findings that carry one** - see
  *   {@link DeidentifiedAttribute.contextPath}, which holds the measurement. The
  *   segment tags come off the wire with no table behind them, so a fabricated

package/dist/index.mjs

@@ -9,7 +9,7 @@ var __export = (target, all) => {
 };
 
 // src/version.ts
-var VERSION = "0.0.14";
+var VERSION = "0.0.15";
 
 // src/dictionary/index.ts
 var dictionary_exports = {};
@@ -11785,6 +11785,11 @@ function safePrivateCreator(creator, profile) {
 function renderVr(vr) {
   return vr !== void 0 && KNOWN_VRS.has(vr) ? vr : WITHHELD;
 }
+var TAG_SHAPE = /^[0-9A-F]{8}$/u;
+function renderTag(tag) {
+  if (tag === void 0 || !TAG_SHAPE.test(tag)) return WITHHELD;
+  return lookup(tag) === void 0 ? WITHHELD : tag;
+}
 
 // src/parser/fatals.ts
 var SUPPORTED_TRANSFER_SYNTAXES = "1.2.840.10008.1.2, 1.2.840.10008.1.2.1, 1.2.840.10008.1.2.2, 1.2.840.10008.1.2.1.99";
@@ -11833,7 +11838,7 @@ var FATAL_MESSAGES = Object.freeze({
   // four bytes are not what they claim to be.
   FILE_META_GROUP_LENGTH_OVERRUNS: {
     code: FATAL_CODES.INVALID_FILE_META,
-    message: "(0002,0000) FileMetaInformationGroupLength declares more bytes than remain in the input; {n} bytes remain. The declared length is withheld; the byte offset locates the group."
+    message: "(0002,0000) FileMetaInformationGroupLength declares more bytes than remain in the input. The declared length and the count of bytes that remain are withheld; the byte offset locates the group."
   },
   FILE_META_TRANSFER_SYNTAX_MISSING: {
     code: FATAL_CODES.INVALID_FILE_META,
@@ -11876,7 +11881,7 @@ var FATAL_MESSAGES = Object.freeze({
   },
   ELEMENT_LENGTH_EXCEEDS_BUFFER: {
     code: FATAL_CODES.INVALID_FILE_META,
-    message: "An element declares a Value Length reaching past the end of the bytes being read; {n} bytes remain. Its tag and its declared length are withheld; the byte offset locates it."
+    message: "An element declares a Value Length reaching past the end of the bytes being read. Its tag, its declared length and the count of bytes that remain are withheld; the byte offset locates it."
   },
   UNEXPECTED_TAG_INSIDE_SEQUENCE: {
     code: FATAL_CODES.INVALID_FILE_META,
@@ -11947,8 +11952,8 @@ function unsupportedTransferSyntax(buffer, offset, ts) {
 function fileMetaTruncated(buffer, offset) {
   return at("FILE_META_TRUNCATED", buffer, offset);
 }
-function fileMetaGroupLengthOverruns(buffer, offset, remaining) {
-  return at("FILE_META_GROUP_LENGTH_OVERRUNS", buffer, offset, { n: remaining });
+function fileMetaGroupLengthOverruns(buffer, offset) {
+  return at("FILE_META_GROUP_LENGTH_OVERRUNS", buffer, offset);
 }
 function fileMetaTransferSyntaxMissing(buffer, offset) {
   return at("FILE_META_TRANSFER_SYNTAX_MISSING", buffer, offset);
@@ -11977,8 +11982,8 @@ function undefinedLengthOnNonSqExplicit(buffer, offset, vr) {
 function undefinedLengthOnNonSqImplicit(buffer, offset, vr) {
   return at("UNDEFINED_LENGTH_ON_NON_SQ_IMPLICIT", buffer, offset, { vr });
 }
-function elementLengthExceedsBuffer(buffer, offset, remaining) {
-  return at("ELEMENT_LENGTH_EXCEEDS_BUFFER", buffer, offset, { n: remaining });
+function elementLengthExceedsBuffer(buffer, offset) {
+  return at("ELEMENT_LENGTH_EXCEEDS_BUFFER", buffer, offset);
 }
 function unexpectedTagInsideSequence(buffer, offset) {
   return at("UNEXPECTED_TAG_INSIDE_SEQUENCE", buffer, offset);
@@ -12204,19 +12209,38 @@ var WARNING_MESSAGES = Object.freeze({
   DICOM_FILE_META_GROUP_LENGTH_MISSING: "(0002,0000) FileMetaInformationGroupLength missing; scanning forward to first non-(0002,xxxx) element.",
   DICOM_FILE_META_GROUP_LENGTH_MISMATCH: "(0002,0000) FileMetaInformationGroupLength declared {n} bytes; actual File Meta group size is {n2} bytes. Trusting actual.",
   DICOM_UNDEFINED_LENGTH_IN_EXPLICIT_VR: "Element ({tag}) uses undefined length (0xFFFFFFFF) under an Explicit VR transfer syntax.",
-  DICOM_ODD_LENGTH_VALUE_PADDED: "Element ({tag}) has odd declared length {n}; cursor advanced by one padding byte to maintain alignment.",
+  // The declared length is gone from this string and the reason is measured, not
+  // cautious: this code fires on ANY element header, including one a lying Value
+  // Length upstream composed out of somebody's value, and it then rendered four
+  // payload bytes as {tag} and four more as the decimal {n} - eight consecutive
+  // bytes of a name in one message. See `oddLengthValuePadded`.
+  DICOM_ODD_LENGTH_VALUE_PADDED: "Element ({tag}) has an odd declared length; cursor advanced by one padding byte to maintain alignment. The declared length is withheld; the byte offset identifies the element.",
   DICOM_VR_MISMATCH: "Element ({tag}) on-wire VR is {vr2}; dictionary lists {vr}. Trusting on-wire VR.",
   // No tag, and the reason is the one `nonzeroReservedBytes` states: this code's
   // three siblings below fire only on an ODD group, and an odd group is the one
   // class of tag no closed table this library holds can ever vouch for. See
   // `privateTagNoCreator`.
   DICOM_PRIVATE_TAG_NO_CREATOR: "A private element has no Private Creator registered for its block; treating as VR=UN. Its tag is withheld; the byte offset identifies the element.",
-  DICOM_GROUP_LENGTH_IN_DATASET: "Retired Group Length element ({tag}) encountered in dataset; preserved as-is.",
+  // No tag, and it is the membership bound in `renderTag` that made the slot
+  // dead rather than a judgement here: this code fires on a (gggg,0000), the
+  // element number is a constant of the code, and PS3.6 carries a literal row
+  // for exactly one such tag - (0002,0000), which is File Meta and never
+  // reaches this code. So every tag this slot could ever have rendered was one
+  // no closed table names, leaving the group number as sixteen free bits of a
+  // header that may itself be fabricated. See `groupLengthInDataset`.
+  DICOM_GROUP_LENGTH_IN_DATASET: "A retired Group Length element (gggg,0000) was encountered in the dataset; preserved as-is. Its group number is withheld; the byte offset identifies the element.",
   // The tag is deliberately absent, and this is the only *parser* message where
   // that is true. See `nonzeroReservedBytes`. Kept terse for the same reason the
   // de-identify messages are: it is emitted once per element, and element count
   // is attacker-chosen.
-  DICOM_NONZERO_RESERVED_BYTES: "Non-zero reserved bytes between VR and length (first byte {n}, second byte {n2}); ignoring. Tag withheld; the byte offset identifies the element.",
+  // 🩺 THE TWO BYTE VALUES ARE GONE FOR THE REASON THE TAG WAS ALREADY GONE, AND
+  // LEAVING THEM MADE THAT BOUND HALF A BOUND. This code's trigger is "these two
+  // bytes are not what PS3.5 7.1.2 says they must be", so the header may not be
+  // a header - and then the reserved pair is two bytes from inside some
+  // element's value, printed as two decimals that reverse with no work at all.
+  // Measured on a name-bearing payload across six under-declare deltas. See
+  // `nonzeroReservedBytes`.
+  DICOM_NONZERO_RESERVED_BYTES: "Non-zero reserved bytes between VR and length; ignoring. Their two values are withheld with the tag; the byte offset identifies the element.",
   DICOM_SQ_NOT_DESCENDED: "Element ({tag}) resolved to VR=SQ from the dictionary but its defined-length value is not a valid item stream; kept as opaque bytes and NOT descended, so nothing nested inside it is visible to navigation, and deidentify() cannot audit it. See DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE.",
   DICOM_UN_PARSED_AS_SQ: "Element ({tag}) has VR=UN with undefined length; descended as Implicit VR LE sequence per CP-246.",
   DICOM_EMPTY_ITEM_IN_SEQUENCE: "Sequence ({tag}) contains an empty item (length=0); tolerated.",
@@ -12251,11 +12275,18 @@ var WARNING_MESSAGES = Object.freeze({
   // No value and no length, for the same reason as the code above: the retained
   // text is the file's own. The tag is a constant of this code.
   DICOM_DEIDENT_METHOD_PRIOR_RETAINED: "A De-identification Method (0012,0063) value the source file already carried was kept beside the one this run recorded, as PS3.15 E.1.1 requires. That attribute is not in Table E.1-1, so no rule in this run inspected, audited or redacted those bytes: if the sender wrote identifying text there it is in the de-identified output, under (0012,0062) = YES. The text is withheld from this message.",
-  // The Item's own declared length is deliberately absent. See
-  // `itemCrossesSequenceEnd`; `{n2}` stays because the emit site's
-  // `endLimit < buffer.length` conjunct bounds it by the buffer.
-  DICOM_ITEM_CROSSES_SEQUENCE_END: "Item ({tag}) declares a length reaching past its enclosing sequence's declared end, so it reads the enclosing Data Set's bytes; {n2} bytes remained inside the sequence. The file's two length fields disagree (PS3.5 7.5.1 and 7.5.2 govern them); the item's is used. The declared length is withheld; the byte offset locates the item.",
-  DICOM_PIXEL_DATA_LENGTH_MISMATCH: "(7FE0,0010) PixelData declared length {n} does not match computed {n2} bytes.",
+  // BOTH of the disagreeing length fields are deliberately absent, and the
+  // second one is the eighth instance of `DICOM-DIAGNOSTIC-PHI-RESIDUALS`: the
+  // remaining-bytes count this string used to carry was the enclosing sequence's
+  // declared Value Length less the bytes of that sequence already consumed. See
+  // `itemCrossesSequenceEnd`.
+  DICOM_ITEM_CROSSES_SEQUENCE_END: "Item ({tag}) declares a length reaching past its enclosing sequence's declared end, so it reads the enclosing Data Set's bytes. The file's two length fields disagree (PS3.5 7.5.1 and 7.5.2 govern them); the item's is used. Both declared lengths are withheld; the byte offset locates the item.",
+  // Declared but not emitted by this build. The declared length is bound out
+  // anyway: it is a raw 32-bit read off a header, so activating this code later
+  // with the slot still here would ship the leak this slice closed one code
+  // over. `{n2}` stays - it is the product this parser computed from the image
+  // description attributes, not a number it read. The tag is a constant.
+  DICOM_PIXEL_DATA_LENGTH_MISMATCH: "(7FE0,0010) PixelData declared length does not match the computed {n2} bytes. The declared length is withheld; the byte offset identifies the element.",
   DICOM_IMPLICIT_VR_FOR_PRIVATE_TAG_WITHOUT_VR: "A private element under Implicit VR LE has no VR override; falling back to UN. Its tag is withheld; the byte offset identifies the element.",
   DICOM_PRIVATE_CREATOR_UNKNOWN: "A private element has a Private Creator the active profile's private dictionary does not name; falling back to UN. The creator string is not reproduced here - read the (gggg,00EE) element if you need it. Its tag is withheld; the byte offset identifies the element.",
   DICOM_BURNED_IN_ANNOTATION_NOT_REMOVED: "Pixel Data is present and Burned In Annotation is not 'NO'; this metadata-only de-identifier cannot inspect or clean pixels. Recognizable text may remain burned into the image.",
@@ -12267,19 +12298,31 @@ var WARNING_MESSAGES = Object.freeze({
   // its two producers is an element the profile declares a Sequence while the
   // wire says UN or OB, so naming a VR here would state a fact about the file
   // that the file contradicts - on the one channel this class designates.
-  DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE: "Element ({tag}) is a Sequence carrier with no parsed items, so its {n} recorded bytes could not be audited (PS3.15 E.1.1); emptied. See report.unauditableSequences.",
+  // The recorded byte count is gone from this string, and the reason is the same
+  // one that took the declared length out of `DICOM_ODD_LENGTH_VALUE_PADDED`:
+  // `Element.rawBytes.length` EQUALS the Value Length off the element header, so
+  // when that header is fabricated the decimal is four document bytes. See
+  // `sequenceNotAuditable`. `report.unauditableSequences[].byteLength` still
+  // carries it, on a type documented as not value-free.
+  DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE: "Element ({tag}) is a Sequence carrier with no parsed items, so its recorded bytes could not be audited (PS3.15 E.1.1); emptied. The byte count is withheld; see report.unauditableSequences.",
   // Deliberately short for the same reason as the code above: one per element,
   // and the element count is chosen by the input.
   //
-  // NEITHER THE TAG NOR THE VR IS ECHOED, and that is specific to this code
-  // rather than caution. Every other factory's {tag} is composed from a real
-  // Data Element header; the condition that raises THIS one is that the header
-  // was fabricated from bytes inside some element's value, so its four tag bytes
-  // and its two VR bytes are document content. `renderTag` shape-checks a tag
-  // and cannot refuse one, so the withholding has to happen at the call site.
+  // NEITHER THE TAG NOR THE VR NOR THE BYTE COUNT IS ECHOED, and that is
+  // specific to this code rather than caution. Every other factory's {tag} is
+  // composed from a real Data Element header; the condition that raises THIS one
+  // is that the header was fabricated from bytes inside some element's value, so
+  // its four tag bytes, its two VR bytes AND its four length bytes are document
+  // content. `renderTag` is a membership test against PS3.6's registry and would
+  // refuse this one - but a slot that has to rely on that is a slot a future
+  // call site can still be handed, so the withholding stays at the call site
+  // where it does not depend on a table. The length had no table to fall back on
+  // at all: the message withheld the two fields a renderer could check and then
+  // printed the one it could not, which is the shape this code was already
+  // written to refuse.
   // The byte offset locates the element instead, and is a position this parser
   // counted rather than anything the document said.
-  DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE: "An element at byte offset {n2} carries an on-wire VR that is not one of the 34 PS3.5 6.2 defines, so its {n} value bytes are not a Value Field this library decoded; emptied (PS3.15 E.1.1). Its tag and VR are withheld: an earlier under-declared length can make them fragments of some element's value. See report.undefinedVrElements.",
+  DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE: "An element at byte offset {n2} carries an on-wire VR that is not one of the 34 PS3.5 6.2 defines, so its value bytes are not a Value Field this library decoded; emptied (PS3.15 E.1.1). Its tag, VR and byte count are withheld: an earlier under-declared length can make them fragments of some element's value. See report.undefinedVrElements.",
   DICOM_BOM_IN_TEXT_VR: "Element ({tag}) {vr} value begins with a UTF-8 BOM; stripped on decode.",
   DICOM_TRAILING_NULL_IN_TEXT_VR: "Element ({tag}) {vr} value has a trailing NULL pad where SPACE is expected; trimmed.",
   DICOM_UI_TRAILING_SPACE: "Element ({tag}) UI value is SPACE-padded; UI requires NULL padding (PS3.5 \xA76.2). Trimmed.",
@@ -12290,10 +12333,6 @@ var WARNING_MESSAGES = Object.freeze({
   DICOM_UNSUPPORTED_CHARSET: "(0008,0005) Specific Character Set value {n} names a defined term this build does not support; decoding text as UTF-8 best-effort. The term is not reproduced here - read the element if you need it.",
   DICOM_CHARSET_AMBIGUOUS_SEPARATOR: "(0008,0005) Specific Character Set value {n} is ambiguous under the active code extensions; decoding text as UTF-8 best-effort."
 });
-var TAG_SHAPE = /^[0-9A-F]{8}$/u;
-function renderTag(tag) {
-  return tag !== void 0 && TAG_SHAPE.test(tag) ? tag : WITHHELD;
-}
 function build2(code, position, tokens = {}) {
   const message = WARNING_MESSAGES[code].replace("{tag}", renderTag(tokens.tag)).replace("{vr2}", renderVr(tokens.vr2)).replace("{vr}", renderVr(tokens.vr)).replace("{n2}", String(tokens.n2 ?? 0)).replace("{n}", String(tokens.n ?? 0));
   return { code, message, position };
@@ -12313,11 +12352,8 @@ function fileMetaGroupLengthMismatch(position, declared, actual) {
 function undefinedLengthInExplicitVR(position, tag) {
   return build2(WARNING_CODES.DICOM_UNDEFINED_LENGTH_IN_EXPLICIT_VR, position, { tag });
 }
-function oddLengthValuePadded(position, tag, declaredLength) {
-  return build2(WARNING_CODES.DICOM_ODD_LENGTH_VALUE_PADDED, position, {
-    tag,
-    n: declaredLength
-  });
+function oddLengthValuePadded(position, tag) {
+  return build2(WARNING_CODES.DICOM_ODD_LENGTH_VALUE_PADDED, position, { tag });
 }
 function vrMismatch(position, tag, dictVR, fileVR) {
   return build2(WARNING_CODES.DICOM_VR_MISMATCH, position, { tag, vr: dictVR, vr2: fileVR });
@@ -12325,14 +12361,11 @@ function vrMismatch(position, tag, dictVR, fileVR) {
 function privateTagNoCreator(position) {
   return build2(WARNING_CODES.DICOM_PRIVATE_TAG_NO_CREATOR, position);
 }
-function groupLengthInDataset(position, tag) {
-  return build2(WARNING_CODES.DICOM_GROUP_LENGTH_IN_DATASET, position, { tag });
+function groupLengthInDataset(position) {
+  return build2(WARNING_CODES.DICOM_GROUP_LENGTH_IN_DATASET, position);
 }
-function nonzeroReservedBytes(position, first, second) {
-  return build2(WARNING_CODES.DICOM_NONZERO_RESERVED_BYTES, position, {
-    n: first,
-    n2: second
-  });
+function nonzeroReservedBytes(position) {
+  return build2(WARNING_CODES.DICOM_NONZERO_RESERVED_BYTES, position);
 }
 function unParsedAsSQ(position, tag) {
   return build2(WARNING_CODES.DICOM_UN_PARSED_AS_SQ, position, { tag });
@@ -12340,11 +12373,8 @@ function unParsedAsSQ(position, tag) {
 function sqNotDescended(position, tag) {
   return build2(WARNING_CODES.DICOM_SQ_NOT_DESCENDED, position, { tag });
 }
-function itemCrossesSequenceEnd(position, tag, availableLength) {
-  return build2(WARNING_CODES.DICOM_ITEM_CROSSES_SEQUENCE_END, position, {
-    tag,
-    n2: availableLength
-  });
+function itemCrossesSequenceEnd(position, tag) {
+  return build2(WARNING_CODES.DICOM_ITEM_CROSSES_SEQUENCE_END, position, { tag });
 }
 function emptyItemInSequence(position, tag) {
   return build2(WARNING_CODES.DICOM_EMPTY_ITEM_IN_SEQUENCE, position, { tag });
@@ -12380,15 +12410,11 @@ function embeddedAttributeRemoved(position, tag, vr, count) {
     n: count
   });
 }
-function sequenceNotAuditable(position, tag, byteLength) {
-  return build2(WARNING_CODES.DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE, position, {
-    tag,
-    n: byteLength
-  });
+function sequenceNotAuditable(position, tag) {
+  return build2(WARNING_CODES.DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE, position, { tag });
 }
-function undefinedVrNotAuditable(position, byteLength) {
+function undefinedVrNotAuditable(position) {
   return build2(WARNING_CODES.DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE, position, {
-    n: byteLength,
     n2: position.byteOffset
   });
 }
@@ -12559,7 +12585,7 @@ function readExplicitElementHeader(cursor, _ctx, emit) {
     const reserved1 = cursor.buffer[cursor.position + 1];
     cursor.position += 2;
     if ((reserved0 ?? 0) !== 0 || (reserved1 ?? 0) !== 0) {
-      emit(nonzeroReservedBytes({ byteOffset: headerStart }, reserved0 ?? 0, reserved1 ?? 0));
+      emit(nonzeroReservedBytes({ byteOffset: headerStart }));
     }
     length = cursor.readUInt32();
     headerLength = 12;
@@ -12599,7 +12625,7 @@ function parseFileMeta(buffer, datasetStart, ctx, emit) {
   if (firstElement.tag === "00020000" && firstElement.vr === "UL" && firstElement.value.length === 4) {
     declaredFmLength = firstElement.value.readUInt32LE(0);
     if (cursor.position + declaredFmLength > buffer.length) {
-      throw fileMetaGroupLengthOverruns(buffer, fmStart, buffer.length - cursor.position);
+      throw fileMetaGroupLengthOverruns(buffer, fmStart);
     }
   } else {
     emit(fileMetaGroupLengthMissing({ byteOffset: fmStart, fileMeta: true }));
@@ -13238,13 +13264,7 @@ function parseSequence(buffer, valueStart, ctx, emit, opts) {
         cursor.position = inner.endOffset;
       } else {
         if (opts.explicitLength !== void 0 && endLimit < buffer.length && cursor.position + itemLength > endLimit) {
-          emit(
-            itemCrossesSequenceEnd(
-              { byteOffset: itemHeaderStart },
-              itemTag,
-              Math.max(0, endLimit - cursor.position)
-            )
-          );
+          emit(itemCrossesSequenceEnd({ byteOffset: itemHeaderStart }, itemTag));
         }
         if (cursor.position + itemLength > buffer.length) {
           throw itemLengthExceedsBuffer(buffer, itemHeaderStart);
@@ -13442,7 +13462,7 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
       throw undefinedLengthOnNonSqImplicit(buffer, headerStart, vr);
     }
     if (cursor.position + length > buffer.length) {
-      throw elementLengthExceedsBuffer(buffer, headerStart, buffer.length - cursor.position);
+      throw elementLengthExceedsBuffer(buffer, headerStart);
     }
     const valueStart = cursor.position;
     const valueEnd = valueStart + length;
@@ -13479,7 +13499,7 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
       }
     }
     if (element === 0 && group !== 2) {
-      emit(groupLengthInDataset(position, tag));
+      emit(groupLengthInDataset(position));
     }
     if (group % 2 === 1 && element >= 16 && element <= 255) {
       registerPrivateCreator(tag, valueSlice, ctx);
@@ -13562,7 +13582,7 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
       }
     }
     if (length !== UNDEFINED_LENGTH2 && length % 2 === 1) {
-      emit(oddLengthValuePadded(position, tag, length));
+      emit(oddLengthValuePadded(position, tag));
     }
     if (vr === "SQ") {
       const valueStart2 = cursor.position;
@@ -13689,7 +13709,7 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
       throw undefinedLengthOnNonSqExplicit(buffer, headerStart, vr);
     }
     if (cursor.position + length > buffer.length) {
-      throw elementLengthExceedsBuffer(buffer, headerStart, buffer.length - cursor.position);
+      throw elementLengthExceedsBuffer(buffer, headerStart);
     }
     const valueStart = cursor.position;
     const valueEnd = valueStart + length;
@@ -13697,7 +13717,7 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
     cursor.position = valueEnd;
     const elementHexNum = parseInt(tag.slice(4, 8), 16);
     if (elementHexNum === 0 && groupNum !== 2) {
-      emit(groupLengthInDataset(position, tag));
+      emit(groupLengthInDataset(position));
     }
     if (groupNum % 2 === 1 && elementHexNum >= 16 && elementHexNum <= 255) {
       registerPrivateCreator(tag, valueSlice, ctx);
@@ -15497,7 +15517,7 @@ function emptyUndefinedVrElement(el, ctx, contextPath, out) {
     byteLength: el.rawBytes.length,
     ...contextPath.length > 0 ? { contextPath: [...contextPath] } : {}
   });
-  out.warnings.push(undefinedVrNotAuditable({ byteOffset: el.byteOffset }, el.rawBytes.length));
+  out.warnings.push(undefinedVrNotAuditable({ byteOffset: el.byteOffset }));
 }
 function isUnauditableSequence(el) {
   return el.vr === "SQ" && el.items === void 0;
@@ -15514,9 +15534,7 @@ function emptyUnauditableCarrier(el, ctx, contextPath, out, replacement) {
     byteLength: el.rawBytes.length,
     ...contextPath.length > 0 ? { contextPath: [...contextPath] } : {}
   });
-  out.warnings.push(
-    sequenceNotAuditable({ byteOffset: el.byteOffset }, el.tag, el.rawBytes.length)
-  );
+  out.warnings.push(sequenceNotAuditable({ byteOffset: el.byteOffset }, el.tag));
 }
 function creatorsInScope(source) {
   const byBlock = /* @__PURE__ */ new Map();