@cosyte/dicom 0.0.17 → 0.0.19

package/dist/index.cjs

@@ -11,7 +11,7 @@ var __export = (target, all) => {
 };
 
 // src/version.ts
-var VERSION = "0.0.17";
+var VERSION = "0.0.19";
 
 // 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);
@@ -12636,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;
   }
@@ -12646,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 }));
@@ -12663,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;
     }
@@ -12687,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;
       }
@@ -12706,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 = {
@@ -12790,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;
@@ -13207,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"
@@ -13243,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;
       }
@@ -13252,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));
@@ -13268,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 }));
@@ -13288,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;
@@ -13322,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) {
@@ -13360,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 {
@@ -13404,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;
     }
@@ -13413,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);
@@ -13480,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;
@@ -13559,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;
     }
@@ -13572,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;
       }
@@ -13580,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;
     }
@@ -13727,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;
@@ -13791,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 = {
@@ -13845,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 });
@@ -13863,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,
@@ -15913,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;