@cosyte/dicom 0.0.16 → 0.0.18

package/dist/index.cjs

@@ -11,7 +11,7 @@ var __export = (target, all) => {
 };
 
 // src/version.ts
-var VERSION = "0.0.16";
+var VERSION = "0.0.18";
 
 // src/dictionary/index.ts
 var dictionary_exports = {};
@@ -11668,23 +11668,52 @@ var FATAL_CODES = {
   UNSUPPORTED_TRANSFER_SYNTAX: "UNSUPPORTED_TRANSFER_SYNTAX",
   EMPTY_INPUT: "EMPTY_INPUT"
 };
+var OFFSET_FRAMES = {
+  /**
+   * Byte 0 is byte 0 of the buffer handed to `parseDicom`. The only frame in
+   * which indexing the caller's own input by `byteOffset` is meaningful.
+   */
+  INPUT: "input",
+  /**
+   * Byte 0 is byte 0 of the inflated Data Set of a Deflated Explicit VR LE
+   * object (`1.2.840.10008.1.2.1.99`). The compressed input holds no such
+   * byte, so the offset does not index it at any scale.
+   */
+  INFLATED_DATASET: "inflated-dataset",
+  /**
+   * Byte 0 is byte 0 of a slice this parser cut from inside a Value Field: a
+   * defined-length Sequence Item's value, or an `SQ`/`UN` value handed to a
+   * descent. **Where that slice begins is deliberately not published** - see
+   * this table's own note.
+   */
+  VALUE_SLICE: "value-slice"
+};
 var DicomParseError = class extends Error {
   code;
   byteOffset;
+  /**
+   * The coordinate system {@link DicomParseError.byteOffset} is counted in.
+   * See {@link OFFSET_FRAMES}.
+   */
+  offsetFrame;
   snippet;
   contextPath;
   /**
    * Construct a new `DicomParseError`. All fields except `contextPath` are
-   * required so every thrower populates positional context per `TOL-02`.
+   * required so every thrower populates positional context per `TOL-02` - and
+   * `offsetFrame` is required for the same reason `byteOffset` is, because an
+   * offset whose frame is optional is an offset whose frame is usually
+   * missing.
    *
    * @internal
    */
-  constructor(code, message, byteOffset, snippet, contextPath) {
-    const formatted = `[${code}] ${message} (offset=${String(byteOffset)})` + (contextPath !== void 0 && contextPath.length > 0 ? ` \u2026 in ${contextPath.join("/")}` : "");
+  constructor(code, message, byteOffset, offsetFrame, snippet, contextPath) {
+    const formatted = `[${code}] ${message} (offset=${String(byteOffset)} frame=${offsetFrame})` + (contextPath !== void 0 && contextPath.length > 0 ? ` \u2026 in ${contextPath.join("/")}` : "");
     super(formatted);
     this.name = "DicomParseError";
     this.code = code;
     this.byteOffset = byteOffset;
+    this.offsetFrame = offsetFrame;
     this.snippet = snippet;
     this.contextPath = contextPath;
   }
@@ -11710,7 +11739,12 @@ function makeEmitter(ctx) {
       w.code,
       w.message,
       w.position.byteOffset,
-      buildSnippet(ctx.buffer, w.position.byteOffset),
+      // Both come off the SAME frame object, so an escalation cannot name one
+      // frame and cut its bytes from another. `DicomParseWarning.position`
+      // itself carries no frame - that is `PRE-EXISTING` and stated on
+      // `DicomPosition`, not closed here.
+      ctx.frame.name,
+      buildSnippet(ctx.frame.buffer, w.position.byteOffset),
       w.position.contextPath
     );
   };
@@ -11836,8 +11870,11 @@ var FATAL_MESSAGES = Object.freeze({
     message: "File Meta is truncated."
   },
   // The declared group length is deliberately absent. It is four bytes of the
-  // document read as a 32-bit integer, and this code fires precisely when those
-  // four bytes are not what they claim to be.
+  // document read as a 32-bit integer. **NOT because this code fires only when
+  // those four bytes are fabricated** - an honestly truncated file raises it
+  // with a perfectly correct group length, measured - but because they are four
+  // bytes a sender wrote in either reading, and in the other one they are part
+  // of somebody's value.
   FILE_META_GROUP_LENGTH_OVERRUNS: {
     code: FATAL_CODES.INVALID_FILE_META,
     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."
@@ -11922,88 +11959,89 @@ function renderTransferSyntax(ts) {
 function renderZlibCode(code) {
   return code !== void 0 && ZLIB_CODES.has(code) ? code : WITHHELD;
 }
-function build(key, byteOffset, snippet, tokens = {}) {
+function build(key, byteOffset, offsetFrame, snippet, tokens = {}) {
   const entry = FATAL_MESSAGES[key];
   const message = entry.message.replace("{vr}", renderVr(tokens.vr)).replace("{ts}", renderTransferSyntax(tokens.ts)).replace("{zlib}", renderZlibCode(tokens.zlib)).replace("{n}", String(tokens.n ?? 0));
-  return new DicomParseError(entry.code, message, byteOffset, snippet);
+  return new DicomParseError(entry.code, message, byteOffset, offsetFrame, snippet);
 }
-function at(key, buffer, offset, tokens = {}) {
-  return build(key, offset, buildSnippet(buffer, offset), tokens);
+function at(key, frame, offset, tokens = {}) {
+  return build(key, offset, frame.name, buildSnippet(frame.buffer, offset), tokens);
 }
 function emptyInput() {
-  return build("EMPTY_INPUT", 0, "");
+  return build("EMPTY_INPUT", 0, OFFSET_FRAMES.INPUT, "");
 }
 function emptyInputAfterNormalization() {
-  return build("EMPTY_INPUT_AFTER_NORMALIZATION", 0, "");
+  return build("EMPTY_INPUT_AFTER_NORMALIZATION", 0, OFFSET_FRAMES.INPUT, "");
 }
-function notDicomPart10Required(buffer, offset) {
-  return at("NOT_DICOM_PART_10_REQUIRED", buffer, offset);
+function notDicomPart10Required(frame, offset) {
+  return at("NOT_DICOM_PART_10_REQUIRED", frame, offset);
 }
-function notDicomPart10(buffer, offset) {
-  return at("NOT_DICOM_PART_10", buffer, offset);
+function notDicomPart10(frame, offset) {
+  return at("NOT_DICOM_PART_10", frame, offset);
 }
-function unsupportedTransferSyntax(buffer, offset, ts) {
+function unsupportedTransferSyntax(frame, offset, ts) {
   const name = uid(ts)?.name ?? "";
   return build(
     "UNSUPPORTED_TRANSFER_SYNTAX",
     offset,
-    name.length > 0 ? name : buildSnippet(buffer, offset),
+    frame.name,
+    name.length > 0 ? name : buildSnippet(frame.buffer, offset),
     { ts }
   );
 }
-function fileMetaTruncated(buffer, offset) {
-  return at("FILE_META_TRUNCATED", buffer, offset);
+function fileMetaTruncated(frame, offset) {
+  return at("FILE_META_TRUNCATED", frame, offset);
 }
-function fileMetaGroupLengthOverruns(buffer, offset) {
-  return at("FILE_META_GROUP_LENGTH_OVERRUNS", buffer, offset);
+function fileMetaGroupLengthOverruns(frame, offset) {
+  return at("FILE_META_GROUP_LENGTH_OVERRUNS", frame, offset);
 }
-function fileMetaTransferSyntaxMissing(buffer, offset) {
-  return at("FILE_META_TRANSFER_SYNTAX_MISSING", buffer, offset);
+function fileMetaTransferSyntaxMissing(frame, offset) {
+  return at("FILE_META_TRANSFER_SYNTAX_MISSING", frame, offset);
 }
-function truncatedDatasetHeader(buffer, offset) {
-  return at("TRUNCATED_DATASET_HEADER", buffer, offset);
+function truncatedDatasetHeader(frame, offset) {
+  return at("TRUNCATED_DATASET_HEADER", frame, offset);
 }
-function truncatedFffeHeader(buffer, offset) {
-  return at("TRUNCATED_FFFE_HEADER", buffer, offset);
+function truncatedFffeHeader(frame, offset) {
+  return at("TRUNCATED_FFFE_HEADER", frame, offset);
 }
-function truncatedExplicitVrHeader(buffer, offset) {
-  return at("TRUNCATED_EXPLICIT_VR_HEADER", buffer, offset);
+function truncatedExplicitVrHeader(frame, offset) {
+  return at("TRUNCATED_EXPLICIT_VR_HEADER", frame, offset);
 }
-function sqItemHeaderTruncated(buffer, offset) {
-  return at("SQ_ITEM_HEADER_TRUNCATED", buffer, offset);
+function sqItemHeaderTruncated(frame, offset) {
+  return at("SQ_ITEM_HEADER_TRUNCATED", frame, offset);
 }
-function unexpectedFffeAtDatasetLevel(buffer, offset) {
-  return at("UNEXPECTED_FFFE_AT_DATASET_LEVEL", buffer, offset);
+function unexpectedFffeAtDatasetLevel(frame, offset) {
+  return at("UNEXPECTED_FFFE_AT_DATASET_LEVEL", frame, offset);
 }
-function unexpectedFffeAtDatasetRoot(buffer, offset) {
-  return at("UNEXPECTED_FFFE_AT_DATASET_ROOT", buffer, offset);
+function unexpectedFffeAtDatasetRoot(frame, offset) {
+  return at("UNEXPECTED_FFFE_AT_DATASET_ROOT", frame, offset);
 }
-function undefinedLengthOnNonSqExplicit(buffer, offset, vr) {
-  return at("UNDEFINED_LENGTH_ON_NON_SQ_EXPLICIT", buffer, offset, { vr });
+function undefinedLengthOnNonSqExplicit(frame, offset, vr) {
+  return at("UNDEFINED_LENGTH_ON_NON_SQ_EXPLICIT", frame, offset, { vr });
 }
-function undefinedLengthOnNonSqImplicit(buffer, offset, vr) {
-  return at("UNDEFINED_LENGTH_ON_NON_SQ_IMPLICIT", buffer, offset, { vr });
+function undefinedLengthOnNonSqImplicit(frame, offset, vr) {
+  return at("UNDEFINED_LENGTH_ON_NON_SQ_IMPLICIT", frame, offset, { vr });
 }
-function elementLengthExceedsBuffer(buffer, offset) {
-  return at("ELEMENT_LENGTH_EXCEEDS_BUFFER", buffer, offset);
+function elementLengthExceedsBuffer(frame, offset) {
+  return at("ELEMENT_LENGTH_EXCEEDS_BUFFER", frame, offset);
 }
-function unexpectedTagInsideSequence(buffer, offset) {
-  return at("UNEXPECTED_TAG_INSIDE_SEQUENCE", buffer, offset);
+function unexpectedTagInsideSequence(frame, offset) {
+  return at("UNEXPECTED_TAG_INSIDE_SEQUENCE", frame, offset);
 }
-function encapsulatedFragmentExceedsBuffer(buffer, offset) {
-  return at("ENCAPSULATED_FRAGMENT_EXCEEDS_BUFFER", buffer, offset);
+function encapsulatedFragmentExceedsBuffer(frame, offset) {
+  return at("ENCAPSULATED_FRAGMENT_EXCEEDS_BUFFER", frame, offset);
 }
-function itemLengthExceedsBuffer(buffer, offset) {
-  return at("ITEM_LENGTH_EXCEEDS_BUFFER", buffer, offset);
+function itemLengthExceedsBuffer(frame, offset) {
+  return at("ITEM_LENGTH_EXCEEDS_BUFFER", frame, offset);
 }
-function sqNestingDepthExceeded(buffer, offset, limit) {
-  return at("SQ_NESTING_DEPTH_EXCEEDED", buffer, offset, { n: limit });
+function sqNestingDepthExceeded(frame, offset, limit) {
+  return at("SQ_NESTING_DEPTH_EXCEEDED", frame, offset, { n: limit });
 }
-function inflatedPayloadExceedsCap(buffer, offset, cap) {
-  return at("INFLATED_PAYLOAD_EXCEEDS_CAP", buffer, offset, { n: cap });
+function inflatedPayloadExceedsCap(frame, offset, cap) {
+  return at("INFLATED_PAYLOAD_EXCEEDS_CAP", frame, offset, { n: cap });
 }
-function inflateFailed(buffer, offset, code) {
-  return at("INFLATE_FAILED", buffer, offset, ...code !== void 0 ? [{ zlib: code }] : []);
+function inflateFailed(frame, offset, code) {
+  return at("INFLATE_FAILED", frame, offset, ...code !== void 0 ? [{ zlib: code }] : []);
 }
 function copyValueBytes(src) {
   const out = buffer.Buffer.allocUnsafeSlow(src.length);
@@ -12199,6 +12237,8 @@ var WARNING_CODES = {
   // emitted by deidentify(), never by the parser
   DICOM_DEIDENT_METHOD_PRIOR_RETAINED: "DICOM_DEIDENT_METHOD_PRIOR_RETAINED",
   // emitted by deidentify(), never by the parser
+  DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH: "DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH",
+  // emitted by deidentify(), never by the parser
   DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE: "DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE",
   // emitted by deidentify(), never by the parser
   DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE: "DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE",
@@ -12277,6 +12317,20 @@ 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.",
+  // No value, no length, no count AND NO ORIGIN. 64 is a constant of the VR, not
+  // a measurement over input; the offending Value's own length IS a measurement
+  // over input and is the number DICOM-DIAGNOSTIC-PHI-RESIDUALS bound out of six
+  // other messages. How many Values are over is the same kind of number, and
+  // which one of them the caller supplied versus which the file did is not
+  // decidable when the two are equal.
+  //
+  // 🛑 AND IT SAYS "LONGER THAN 64 BYTES", NOT "OVER THE MAXIMUM". A graded pass
+  // refuted the draft that called 64 bytes "the largest an LO Value may be under
+  // a single-byte repertoire": PS3.5 6.2 specifies these lengths "in characters
+  // rather than bytes" and excludes Code Extension escape sequences from the
+  // count, so a conformant 64-character Value can exceed 64 bytes under a
+  // single-byte repertoire too. The message states what was measured.
+  DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH: "The De-identification Method (0012,0063) this run wrote carries a Value longer than 64 bytes. PS3.5 Table 6.2-1 bounds an LO Value at 64 characters, per Value and not per Value Field, and PS3.5 6.2 specifies that length in characters rather than bytes and excludes Code Extension escape sequences from the count: a Value of 64 bytes or fewer can never carry more than 64 characters, but a longer one is not necessarily over the maximum. This run never shortens, splits or truncates a Value it did not compose: a caller-supplied method, and a value the source file already carried, are both written through as given. A receiver that enforces the VR may reject the attribute that records the de-identification. The value, its length, how many Values are over and which of them came from where are all withheld from this message.",
   // 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
@@ -12405,6 +12459,9 @@ function deidentMethodNotLo(position) {
 function deidentMethodPriorRetained(position) {
   return build2(WARNING_CODES.DICOM_DEIDENT_METHOD_PRIOR_RETAINED, position);
 }
+function deidentMethodValueOverLength(position) {
+  return build2(WARNING_CODES.DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH, position);
+}
 function embeddedAttributeRemoved(position, tag, vr, count) {
   return build2(WARNING_CODES.DICOM_DEIDENT_EMBEDDED_ATTRIBUTE_REMOVED, position, {
     tag,
@@ -12617,7 +12674,7 @@ function parseFileMeta(buffer$1, datasetStart, ctx, emit) {
     firstElement = readExplicitLeElement(cursor);
   } catch (err) {
     if (err instanceof RangeError) {
-      throw fileMetaTruncated(buffer$1, fmStart);
+      throw fileMetaTruncated(ctx.frame, fmStart);
     }
     throw err;
   }
@@ -12627,7 +12684,7 @@ function parseFileMeta(buffer$1, datasetStart, ctx, emit) {
   if (firstElement.tag === "00020000" && firstElement.vr === "UL" && firstElement.value.length === 4) {
     declaredFmLength = firstElement.value.readUInt32LE(0);
     if (cursor.position + declaredFmLength > buffer$1.length) {
-      throw fileMetaGroupLengthOverruns(buffer$1, fmStart);
+      throw fileMetaGroupLengthOverruns(ctx.frame, fmStart);
     }
   } else {
     emit(fileMetaGroupLengthMissing({ byteOffset: fmStart, fileMeta: true }));
@@ -12644,7 +12701,7 @@ function parseFileMeta(buffer$1, datasetStart, ctx, emit) {
       next = readExplicitLeElement(cursor);
     } catch (err) {
       if (err instanceof RangeError) {
-        throw fileMetaTruncated(buffer$1, fmStart);
+        throw fileMetaTruncated(ctx.frame, fmStart);
       }
       throw err;
     }
@@ -12668,7 +12725,7 @@ function parseFileMeta(buffer$1, datasetStart, ctx, emit) {
         next = readExplicitLeElement(cursor);
       } catch (err) {
         if (err instanceof RangeError) {
-          throw fileMetaTruncated(buffer$1, fmStart);
+          throw fileMetaTruncated(ctx.frame, fmStart);
         }
         throw err;
       }
@@ -12687,7 +12744,7 @@ function parseFileMeta(buffer$1, datasetStart, ctx, emit) {
   }
   const tsElement = fmElements.find((e) => e.tag === "00020010");
   if (tsElement === void 0 || tsElement.vr !== "UI") {
-    throw fileMetaTransferSyntaxMissing(buffer$1, fmStart);
+    throw fileMetaTransferSyntaxMissing(ctx.frame, fmStart);
   }
   const extraElements = fmElements.filter((e) => !MODELED_FM_TAGS.has(e.tag)).map((e) => Object.freeze({ tag: e.tag, vr: e.vr, value: buffer.Buffer.from(e.value) }));
   const fileMeta = {
@@ -12771,13 +12828,13 @@ function parsePart10Header(buffer, ctx, emit) {
     return { datasetStart: 132, hadPreamble: true };
   }
   if (ctx.stripPreamble === "require") {
-    throw notDicomPart10Required(buffer, 0);
+    throw notDicomPart10Required(ctx.frame, 0);
   }
   if (looksLikeFileMetaGroupLengthAtOffsetZero(buffer)) {
     emit(missingPreamble({ byteOffset: 0 }));
     return { datasetStart: 0, hadPreamble: false };
   }
-  throw notDicomPart10(buffer, 0);
+  throw notDicomPart10(ctx.frame, 0);
 }
 function looksLikeFileMetaGroupLengthAtOffsetZero(buffer) {
   if (buffer.length < 12) return false;
@@ -13188,7 +13245,7 @@ function parseSequence(buffer, valueStart, ctx, emit, opts) {
   ctx.nestingDepth += 1;
   if (ctx.nestingDepth > NESTING_DEPTH_LIMIT) {
     ctx.nestingDepth -= 1;
-    throw sqNestingDepthExceeded(buffer, valueStart, NESTING_DEPTH_LIMIT);
+    throw sqNestingDepthExceeded(ctx.frame, valueStart, NESTING_DEPTH_LIMIT);
   }
   ctx.encodingContextStack.push(
     opts.encapsulatedPixelData === true ? "EncapsulatedPixelData" : "SqItem"
@@ -13224,7 +13281,7 @@ function parseSequence(buffer, valueStart, ctx, emit, opts) {
         itemLength = cursor.readUInt32();
       } catch (err) {
         if (err instanceof RangeError) {
-          throw sqItemHeaderTruncated(buffer, itemHeaderStart);
+          throw sqItemHeaderTruncated(ctx.frame, itemHeaderStart);
         }
         throw err;
       }
@@ -13233,7 +13290,7 @@ function parseSequence(buffer, valueStart, ctx, emit, opts) {
         return { items, endOffset: cursor.position };
       }
       if (itemTag !== ITEM_TAG) {
-        throw unexpectedTagInsideSequence(buffer, itemHeaderStart);
+        throw unexpectedTagInsideSequence(ctx.frame, itemHeaderStart);
       }
       if (itemLength === 0) {
         emit(emptyItemInSequence({ byteOffset: itemHeaderStart }, itemTag));
@@ -13249,7 +13306,7 @@ function parseSequence(buffer, valueStart, ctx, emit, opts) {
       }
       if (opts.encapsulatedPixelData === true) {
         if (cursor.position + itemLength > buffer.length) {
-          throw encapsulatedFragmentExceedsBuffer(buffer, itemHeaderStart);
+          throw encapsulatedFragmentExceedsBuffer(ctx.frame, itemHeaderStart);
         }
         cursor.position += itemLength;
         items.push(new Item({ warnings: [], elements: /* @__PURE__ */ new Map(), index: itemIndex }));
@@ -13269,16 +13326,16 @@ function parseSequence(buffer, valueStart, ctx, emit, opts) {
           emit(itemCrossesSequenceEnd({ byteOffset: itemHeaderStart }, itemTag));
         }
         if (cursor.position + itemLength > buffer.length) {
-          throw itemLengthExceedsBuffer(buffer, itemHeaderStart);
+          throw itemLengthExceedsBuffer(ctx.frame, itemHeaderStart);
         }
         const itemSlice = buffer.subarray(cursor.position, cursor.position + itemLength);
-        const enclosingFrame = ctx.buffer;
+        const enclosingFrame = ctx.frame;
         let inner;
         try {
-          ctx.buffer = itemSlice;
+          ctx.frame = { buffer: itemSlice, name: OFFSET_FRAMES.VALUE_SLICE };
           inner = opts.innerStrategy(itemSlice, 0, ctx, emit);
         } finally {
-          ctx.buffer = enclosingFrame;
+          ctx.frame = enclosingFrame;
         }
         items.push(new Item({ warnings: [], elements: inner.elements, index: itemIndex }));
         cursor.position += itemLength;
@@ -13303,17 +13360,17 @@ function tryParseDefinedLengthSQ(buffer, valueStart, valueLength, ctx, emit, imp
   const savedWarningsLen = ctx.warnings.length;
   try {
     const slice = buffer.subarray(valueStart, valueStart + valueLength);
-    const enclosingFrame = ctx.buffer;
+    const enclosingFrame = ctx.frame;
     let result;
     try {
-      ctx.buffer = slice;
+      ctx.frame = { buffer: slice, name: OFFSET_FRAMES.VALUE_SLICE };
       result = parseSequence(slice, 0, ctx, emit, {
         explicitLength: valueLength,
         littleEndian: true,
         innerStrategy: implicitLeInner
       });
     } finally {
-      ctx.buffer = enclosingFrame;
+      ctx.frame = enclosingFrame;
     }
     return { success: true, items: result.items };
   } catch (err) {
@@ -13341,13 +13398,13 @@ function tryParseUnAsSQ(buffer, valueStart, valueLength, ctx, emit, implicitLeIn
       // CP-246: Implicit VR LE inner per D-30.
       innerStrategy: implicitLeInner
     };
-    const enclosingFrame = ctx.buffer;
+    const enclosingFrame = ctx.frame;
     let result;
     try {
-      ctx.buffer = slice;
+      ctx.frame = { buffer: slice, name: OFFSET_FRAMES.VALUE_SLICE };
       result = parseSequence(slice, 0, ctx, emit, opts);
     } finally {
-      ctx.buffer = enclosingFrame;
+      ctx.frame = enclosingFrame;
     }
     emit(unParsedAsSQ({ byteOffset: valueStart }, tag));
     return {
@@ -13385,7 +13442,7 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
       length = cursor.readUInt32();
     } catch (err) {
       if (err instanceof RangeError) {
-        throw truncatedDatasetHeader(buffer, headerStart);
+        throw truncatedDatasetHeader(ctx.frame, headerStart);
       }
       throw err;
     }
@@ -13394,7 +13451,7 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
       if (opts.stopOnItemDelim === true && tag === "FFFEE00D") {
         return { elements, endOffset: cursor.position };
       }
-      throw unexpectedFffeAtDatasetRoot(buffer, headerStart);
+      throw unexpectedFffeAtDatasetRoot(ctx.frame, headerStart);
     }
     const position = { byteOffset: headerStart };
     const vr = resolveImplicitVR(tag, ctx, emit, position);
@@ -13461,10 +13518,10 @@ function parseImplicitLE(buffer, datasetStart, ctx, emit, opts = {}) {
           continue;
         }
       }
-      throw undefinedLengthOnNonSqImplicit(buffer, headerStart, vr);
+      throw undefinedLengthOnNonSqImplicit(ctx.frame, headerStart, vr);
     }
     if (cursor.position + length > buffer.length) {
-      throw elementLengthExceedsBuffer(buffer, headerStart);
+      throw elementLengthExceedsBuffer(ctx.frame, headerStart);
     }
     const valueStart = cursor.position;
     const valueEnd = valueStart + length;
@@ -13540,7 +13597,7 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
       peekGroup = cursor.readUInt16At(cursor.position);
     } catch (err) {
       if (err instanceof RangeError) {
-        throw truncatedDatasetHeader(buffer, headerStart);
+        throw truncatedDatasetHeader(ctx.frame, headerStart);
       }
       throw err;
     }
@@ -13553,7 +13610,7 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
         cursor.readUInt32();
       } catch (err) {
         if (err instanceof RangeError) {
-          throw truncatedFffeHeader(buffer, headerStart);
+          throw truncatedFffeHeader(ctx.frame, headerStart);
         }
         throw err;
       }
@@ -13561,14 +13618,14 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
       if (opts.stopOnItemDelim === true && fffeTag === "FFFEE00D") {
         return { elements, endOffset: cursor.position };
       }
-      throw unexpectedFffeAtDatasetLevel(buffer, headerStart);
+      throw unexpectedFffeAtDatasetLevel(ctx.frame, headerStart);
     }
     let header;
     try {
       header = readExplicitElementHeader(cursor, ctx, emit);
     } catch (err) {
       if (err instanceof RangeError) {
-        throw truncatedExplicitVrHeader(buffer, headerStart);
+        throw truncatedExplicitVrHeader(ctx.frame, headerStart);
       }
       throw err;
     }
@@ -13708,10 +13765,10 @@ function _parseExplicit(buffer, datasetStart, ctx, emit, mode, opts = {}) {
       continue;
     }
     if (length === UNDEFINED_LENGTH2) {
-      throw undefinedLengthOnNonSqExplicit(buffer, headerStart, vr);
+      throw undefinedLengthOnNonSqExplicit(ctx.frame, headerStart, vr);
     }
     if (cursor.position + length > buffer.length) {
-      throw elementLengthExceedsBuffer(buffer, headerStart);
+      throw elementLengthExceedsBuffer(ctx.frame, headerStart);
     }
     const valueStart = cursor.position;
     const valueEnd = valueStart + length;
@@ -13772,11 +13829,14 @@ function parseDeflatedLEWithCap(buffer, datasetStart, ctx, emit, maxInflatedByte
     const code = errAny.code;
     const message = errAny.message ?? String(err);
     if (code === "ERR_BUFFER_TOO_LARGE" || err instanceof RangeError && /maxOutputLength|too large/i.test(message)) {
-      throw inflatedPayloadExceedsCap(buffer, datasetStart, maxInflatedBytes);
+      throw inflatedPayloadExceedsCap(ctx.frame, datasetStart, maxInflatedBytes);
     }
-    throw inflateFailed(buffer, datasetStart, code);
+    throw inflateFailed(ctx.frame, datasetStart, code);
   }
-  const innerCtx = { ...ctx, buffer: inflated };
+  const innerCtx = {
+    ...ctx,
+    frame: { buffer: inflated, name: OFFSET_FRAMES.INFLATED_DATASET }
+  };
   const innerChokepoint = makeEmitter(innerCtx);
   const innerEmit = (w) => {
     const wrapped = {
@@ -13826,7 +13886,7 @@ function parseDicom(input, options = {}) {
   const tsUid = fileMeta.transferSyntaxUID;
   const strategy = TRANSFER_SYNTAX_PARSERS[tsUid];
   if (strategy === void 0) {
-    throw unsupportedTransferSyntax(buffer, fileMetaEnd, tsUid);
+    throw unsupportedTransferSyntax(ctx.frame, fileMetaEnd, tsUid);
   }
   const { elements } = strategy(buffer, fileMetaEnd, ctx, emit);
   return new Dataset({ fileMeta, warnings: ctx.warnings, elements });
@@ -13844,7 +13904,9 @@ function normalizeInput(input) {
 }
 function buildContext(buffer, options, warnings) {
   const base = {
-    buffer,
+    // The root frame. Every nested frame is entered from here by a swap that
+    // moves the bytes and the name together; see `ParseFrame`.
+    frame: { buffer, name: OFFSET_FRAMES.INPUT },
     strict: options.strict === true,
     stripPreamble: options.stripPreamble ?? "tolerate",
     warnings,
@@ -15751,6 +15813,10 @@ function defaultMethod(active) {
 }
 var VALUE_DELIMITER = 92;
 var MAX_SHORT_FORM_VALUE_BYTES = 65534;
+var LO_VALUE_MAX_CHARS = 64;
+function hasValueOverLoMaximum(field) {
+  return splitValues(field).some((value) => value.length > LO_VALUE_MAX_CHARS);
+}
 function addDeidentificationMethod(existing, method) {
   const added = trimTrailingPad(buffer.Buffer.from(method, "latin1"));
   const none = { replacedPrior: false, retainedPrior: false, replacedNonLoPrior: false };
@@ -15848,6 +15914,11 @@ function deidentify(ds, options = {}) {
       deidentMethodNotLo({ byteOffset: priorMethod?.byteOffset ?? 0, fileMeta: false })
     );
   }
+  if (hasValueOverLoMaximum(deidentMethod.value)) {
+    warnings.push(
+      deidentMethodValueOverLength({ byteOffset: priorMethod?.byteOffset ?? 0, fileMeta: false })
+    );
+  }
   if (hasUncleanedBurnedIn(ds)) {
     const offset = ds.get(TAG_PIXEL_DATA)?.byteOffset ?? 0;
     warnings.push(burnedInAnnotationNotRemoved({ byteOffset: offset, fileMeta: false }));
@@ -15885,6 +15956,7 @@ exports.Dictionary = dictionary_exports;
 exports.Element = Element;
 exports.FATAL_CODES = FATAL_CODES;
 exports.Item = Item;
+exports.OFFSET_FRAMES = OFFSET_FRAMES;
 exports.ProfileDefinitionError = ProfileDefinitionError;
 exports.SERIALIZE_ERROR_CODES = SERIALIZE_ERROR_CODES;
 exports.Sequence = Sequence;