@cosyte/dicom 0.0.15 → 0.0.17

package/dist/index.d.cts

@@ -491,6 +491,7 @@ declare const WARNING_CODES: {
     readonly DICOM_DEIDENT_METHOD_NOT_ADDED: "DICOM_DEIDENT_METHOD_NOT_ADDED";
     readonly DICOM_DEIDENT_METHOD_NOT_LO: "DICOM_DEIDENT_METHOD_NOT_LO";
     readonly DICOM_DEIDENT_METHOD_PRIOR_RETAINED: "DICOM_DEIDENT_METHOD_PRIOR_RETAINED";
+    readonly DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH: "DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH";
     readonly DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE: "DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE";
     readonly DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE: "DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE";
     readonly DICOM_PRIVATE_CREATOR_UNKNOWN: "DICOM_PRIVATE_CREATOR_UNKNOWN";
@@ -2974,10 +2975,19 @@ interface DeidentifyOptions {
      * legally carry. The Profile name is now one Value of 61 characters and each
      * active option is its own, so no option subset can exceed the maximum.
      *
-     * **Your string is not bounded here.** A value of your own longer than 64
-     * characters is written through as given, with no warning: it is yours, and
-     * splitting or truncating it would invent a record you did not write. Split it
-     * on `\` yourself if a strict receiver is in your path.
+     * **Your string is not bounded here, but it is no longer silent.** A value of
+     * your own longer than 64 characters is written through as given - it is
+     * yours, and splitting or truncating it would invent a record you did not
+     * write - and `report.warnings` carries
+     * `DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH` to say so. Split it on `\` yourself
+     * if a strict receiver is in your path. The same code covers an over-long
+     * value the **source file** wrote and this run kept, which in the common case
+     * is this library's own 76-character text from a release before the default
+     * became multi-valued. The measurement is over **bytes**: a Value of 64 bytes
+     * or fewer can never carry more than 64 characters, so it cannot miss one that
+     * is genuinely over, but PS3.5 §6.2 specifies the bound in characters rather
+     * than bytes and excludes Code Extension escape sequences from the count, so it
+     * raises on any conformant Value whose bytes outnumber its counted characters.
      *
      * PS3.15 E.1.1 says this string is "inserted in or added to" the attribute, so
      * a value the incoming Data Set already carried is kept and this one is
@@ -3016,7 +3026,9 @@ interface DeidentifyOptions {
      * When the prior value **is** kept, `report.warnings` carries
      * `DICOM_DEIDENT_METHOD_PRIOR_RETAINED`: `(0012,0063)` is not in Table E.1-1, so
      * nothing in the run inspected or redacted those bytes, and a name a sender
-     * wrote there is in output stamped `(0012,0062) = YES`.
+     * wrote there is in output stamped `(0012,0062) = YES`. That code discloses the
+     * **retention** only; the **length** of what is written, from whatever source,
+     * is disclosed by `DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH` and by nothing else.
      */
     readonly deidentificationMethod?: string;
 }

package/dist/index.d.ts

@@ -491,6 +491,7 @@ declare const WARNING_CODES: {
     readonly DICOM_DEIDENT_METHOD_NOT_ADDED: "DICOM_DEIDENT_METHOD_NOT_ADDED";
     readonly DICOM_DEIDENT_METHOD_NOT_LO: "DICOM_DEIDENT_METHOD_NOT_LO";
     readonly DICOM_DEIDENT_METHOD_PRIOR_RETAINED: "DICOM_DEIDENT_METHOD_PRIOR_RETAINED";
+    readonly DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH: "DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH";
     readonly DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE: "DICOM_DEIDENT_SEQUENCE_NOT_AUDITABLE";
     readonly DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE: "DICOM_DEIDENT_UNDEFINED_VR_NOT_AUDITABLE";
     readonly DICOM_PRIVATE_CREATOR_UNKNOWN: "DICOM_PRIVATE_CREATOR_UNKNOWN";
@@ -2974,10 +2975,19 @@ interface DeidentifyOptions {
      * legally carry. The Profile name is now one Value of 61 characters and each
      * active option is its own, so no option subset can exceed the maximum.
      *
-     * **Your string is not bounded here.** A value of your own longer than 64
-     * characters is written through as given, with no warning: it is yours, and
-     * splitting or truncating it would invent a record you did not write. Split it
-     * on `\` yourself if a strict receiver is in your path.
+     * **Your string is not bounded here, but it is no longer silent.** A value of
+     * your own longer than 64 characters is written through as given - it is
+     * yours, and splitting or truncating it would invent a record you did not
+     * write - and `report.warnings` carries
+     * `DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH` to say so. Split it on `\` yourself
+     * if a strict receiver is in your path. The same code covers an over-long
+     * value the **source file** wrote and this run kept, which in the common case
+     * is this library's own 76-character text from a release before the default
+     * became multi-valued. The measurement is over **bytes**: a Value of 64 bytes
+     * or fewer can never carry more than 64 characters, so it cannot miss one that
+     * is genuinely over, but PS3.5 §6.2 specifies the bound in characters rather
+     * than bytes and excludes Code Extension escape sequences from the count, so it
+     * raises on any conformant Value whose bytes outnumber its counted characters.
      *
      * PS3.15 E.1.1 says this string is "inserted in or added to" the attribute, so
      * a value the incoming Data Set already carried is kept and this one is
@@ -3016,7 +3026,9 @@ interface DeidentifyOptions {
      * When the prior value **is** kept, `report.warnings` carries
      * `DICOM_DEIDENT_METHOD_PRIOR_RETAINED`: `(0012,0063)` is not in Table E.1-1, so
      * nothing in the run inspected or redacted those bytes, and a name a sender
-     * wrote there is in output stamped `(0012,0062) = YES`.
+     * wrote there is in output stamped `(0012,0062) = YES`. That code discloses the
+     * **retention** only; the **length** of what is written, from whatever source,
+     * is disclosed by `DICOM_DEIDENT_METHOD_VALUE_OVER_LENGTH` and by nothing else.
      */
     readonly deidentificationMethod?: string;
 }

package/dist/index.mjs

@@ -9,7 +9,7 @@ var __export = (target, all) => {
 };
 
 // src/version.ts
-var VERSION = "0.0.15";
+var VERSION = "0.0.17";
 
 // src/dictionary/index.ts
 var dictionary_exports = {};
@@ -12197,6 +12197,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",
@@ -12275,6 +12277,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
@@ -12403,6 +12419,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,
@@ -15749,6 +15768,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.from(method, "latin1"));
   const none = { replacedPrior: false, retainedPrior: false, replacedNonLoPrior: false };
@@ -15846,6 +15869,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 }));