dicom-synth 1.18.0 → 1.19.0

package/dist/esm/collection/writer.js

@@ -1,13 +1,90 @@
 // src/collection/writer.ts
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { mkdirSync as mkdirSync3 } from "node:fs";
+import { mkdirSync as mkdirSync2 } from "node:fs";
 import { writeFile } from "node:fs/promises";
-import { dirname, resolve as resolve3 } from "node:path";
+import { dirname, resolve as resolve2 } from "node:path";
 
 // src/schema/limits.ts
 var MAX_PIXEL_BYTES = 512 * 1024 * 1024;
 var MAX_STREAM_BYTES = 50 * 1024 * 1024 * 1024;
 
+// src/syntheticFixtures/streamWrite.ts
+import { closeSync, mkdirSync, openSync, writeSync } from "node:fs";
+import { resolve } from "node:path";
+
+// src/loadDcmjs.ts
+import dcmjsDefaultImport, * as dcmjsNamespace from "dcmjs";
+function loadDcmjs() {
+  if (dcmjsNamespace.data?.DicomDict) {
+    return dcmjsNamespace;
+  }
+  const d = dcmjsDefaultImport;
+  if (d?.data?.DicomDict) {
+    return d;
+  }
+  if (d?.default?.data?.DicomDict) {
+    return d.default;
+  }
+  throw new Error(
+    "dcmjs failed to load (missing data.DicomDict). Install dcmjs >= 0.29."
+  );
+}
+var dcmjs = loadDcmjs();
+
+// src/platform/bytes.ts
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function utf8Bytes(text) {
+  return new TextEncoder().encode(text);
+}
+function concatBytes(...parts) {
+  const out = new Uint8Array(parts.reduce((sum, p) => sum + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function patternBytes(length, pattern) {
+  const out = new Uint8Array(length);
+  const seed = utf8Bytes(pattern);
+  if (length === 0 || seed.length === 0) return out;
+  out.set(seed.subarray(0, Math.min(seed.length, length)));
+  let filled = Math.min(seed.length, length);
+  while (filled < length) {
+    const chunk = Math.min(filled, length - filled);
+    out.copyWithin(filled, 0, chunk);
+    filled += chunk;
+  }
+  return out;
+}
+
+// src/nonStandardDicom/dicomdir.ts
+var DICOMDIR_SOP_CLASS_UID = "1.2.840.10008.1.3.10";
+function buildDicomdirBuffer() {
+  const uid = DICOMDIR_SOP_CLASS_UID;
+  const buf = new Uint8Array(256);
+  const view = new DataView(buf.buffer);
+  buf.set(utf8Bytes("DICM"), 128);
+  let off = 132;
+  view.setUint16(off, 2, true);
+  off += 2;
+  view.setUint16(off, 2, true);
+  off += 2;
+  buf.set(utf8Bytes("UI"), off);
+  off += 2;
+  view.setUint16(off, uid.length, true);
+  off += 2;
+  buf.set(utf8Bytes(uid), off);
+  off += uid.length;
+  return buf.subarray(0, off);
+}
+
 // src/syntheticFixtures/tagTemplate.ts
 var TEMPLATE_VOCAB = [
   "index",
@@ -63,47 +140,6 @@ function positionalName(prefix, ordinal) {
   return `${prefix}-${String(ordinal).padStart(3, "0")}`;
 }
 
-// src/loadDcmjs.ts
-import dcmjsDefaultImport, * as dcmjsNamespace from "dcmjs";
-function loadDcmjs() {
-  if (dcmjsNamespace.data?.DicomDict) {
-    return dcmjsNamespace;
-  }
-  const d = dcmjsDefaultImport;
-  if (d?.data?.DicomDict) {
-    return d;
-  }
-  if (d?.default?.data?.DicomDict) {
-    return d.default;
-  }
-  throw new Error(
-    "dcmjs failed to load (missing data.DicomDict). Install dcmjs >= 0.29."
-  );
-}
-var dcmjs = loadDcmjs();
-
-// src/nonStandardDicom/dicomdir.ts
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-var DICOMDIR_SOP_CLASS_UID = "1.2.840.10008.1.3.10";
-function buildDicomdirBuffer() {
-  const uid = DICOMDIR_SOP_CLASS_UID;
-  const buf = Buffer.alloc(256, 0);
-  buf.write("DICM", 128, 4, "ascii");
-  let off = 132;
-  buf.writeUInt16LE(2, off);
-  off += 2;
-  buf.writeUInt16LE(2, off);
-  off += 2;
-  buf.write("UI", off, 2, "ascii");
-  off += 2;
-  buf.writeUInt16LE(uid.length, off);
-  off += 2;
-  buf.write(uid, off, uid.length, "ascii");
-  off += uid.length;
-  return buf.subarray(0, off);
-}
-
 // src/syntheticFixtures/generator.ts
 var MODALITY_PRESETS = {
   CT: {
@@ -246,7 +282,7 @@ function serializeDict(meta, dataset, rawElements) {
   if (rawElements) {
     Object.assign(dicomDict.dict, rawElements);
   }
-  return Buffer.from(dicomDict.write({ allowInvalidVRLength: true }));
+  return new Uint8Array(dicomDict.write({ allowInvalidVRLength: true }));
 }
 var MAX_DIMENSION = 65535;
 function applySizing(dataset, meta, spec, rawElements) {
@@ -291,8 +327,8 @@ function buildImageBuffer(spec, uid) {
   return { buffer: serializeDict(meta, dataset, rawElements), rawElements };
 }
 function buildFakeSignatureBuffer() {
-  const buf = Buffer.alloc(200, 0);
-  buf.write("XXXX", 128, 4, "ascii");
+  const buf = new Uint8Array(200);
+  buf.set(utf8Bytes("XXXX"), 128);
   return buf;
 }
 function sizedNonDicomBytes(spec) {
@@ -300,8 +336,8 @@ function sizedNonDicomBytes(spec) {
 }
 function buildNonDicomBuffer(spec) {
   const bytes = sizedNonDicomBytes(spec);
-  if (bytes !== void 0) return Buffer.alloc(bytes, "not dicom ");
-  return Buffer.from(spec.content ?? "not dicom", "utf8");
+  if (bytes !== void 0) return patternBytes(bytes, "not dicom ");
+  return utf8Bytes(spec.content ?? "not dicom");
 }
 function buildBufferForSpec(spec, uid) {
   switch (spec.type) {
@@ -322,19 +358,150 @@ function buildBufferForSpec(spec, uid) {
   }
 }
 
-// src/syntheticFixtures/streamWrite.ts
-import { closeSync, mkdirSync as mkdirSync2, openSync, writeSync } from "node:fs";
-import { resolve as resolve2 } from "node:path";
+// src/platform/random.ts
+function randomHex(byteLength) {
+  return bytesToHex(
+    globalThis.crypto.getRandomValues(new Uint8Array(byteLength))
+  );
+}
+
+// src/platform/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function sha256(input) {
+  const data2 = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const padded = new Uint8Array((data2.length + 8 >> 6) + 1 << 6);
+  padded.set(data2);
+  padded[data2.length] = 128;
+  new DataView(padded.buffer).setBigUint64(
+    padded.length - 8,
+    BigInt(data2.length * 8),
+    false
+  );
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const w = new Uint32Array(64);
+  const view = new DataView(padded.buffer);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let t = 0; t < 16; t++) w[t] = view.getUint32(offset + t * 4, false);
+    for (let t = 16; t < 64; t++) {
+      const s0 = rotr(w[t - 15], 7) ^ rotr(w[t - 15], 18) ^ w[t - 15] >>> 3;
+      const s1 = rotr(w[t - 2], 17) ^ rotr(w[t - 2], 19) ^ w[t - 2] >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let t = 0; t < 64; t++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = hh + S1 + ch + K[t] + w[t] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  for (let i = 0; i < 8; i++) outView.setUint32(i * 4, h[i], false);
+  return out;
+}
 
 // src/syntheticFixtures/uid.ts
-import { createHash, randomBytes } from "node:crypto";
 function hashUid(salt, key) {
-  const digest = createHash("sha256").update(salt).update(" ").update(key).digest();
-  const n = BigInt(`0x${digest.subarray(0, 16).toString("hex")}`);
+  const digest = sha256(`${salt} ${key}`);
+  const n = BigInt(`0x${bytesToHex(digest.subarray(0, 16))}`);
   return `2.25.${n.toString()}`;
 }
 function randomUid() {
-  const n = BigInt(`0x${randomBytes(16).toString("hex")}`);
+  const n = BigInt(`0x${randomHex(16)}`);
   return `2.25.${n.toString()}`;
 }
 function seedToSalt(seed) {
@@ -370,6 +537,9 @@ var PIXEL_DATA_OB_HEADER = Buffer.from([224, 127, 16, 0, 79, 66]);
 var ITEM_TAG_GROUP = 65534;
 var ITEM_TAG_ELEMENT = 57344;
 var SEQUENCE_DELIMITER_ELEMENT = 57565;
+function asBuffer(bytes) {
+  return Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
 function itemTag(element, byteLength = 0) {
   const b = Buffer.alloc(8);
   b.writeUInt16LE(ITEM_TAG_GROUP, 0);
@@ -400,7 +570,7 @@ function writeNative(outPath, params, dims, zeroChunk) {
   dataset.Rows = dims.rows;
   dataset.Columns = dims.columns;
   const minimalPixelBytes = dataset.PixelData.byteLength;
-  const probe = serializeDict(meta, dataset, rawElements);
+  const probe = asBuffer(serializeDict(meta, dataset, rawElements));
   const pixelElement = Buffer.alloc(12);
   PIXEL_DATA_OW_HEADER.copy(pixelElement);
   pixelElement.writeUInt32LE(minimalPixelBytes, 8);
@@ -433,7 +603,7 @@ function writeEncapsulated(outPath, params, pixelBytes, fragmentBytes, zeroChunk
   syncMetaWithDataset(meta, dataset, rawElements);
   dataset.PixelData = [new Uint8Array([]).buffer, new Uint8Array([0, 0]).buffer];
   dataset._vrMap = { PixelData: "OB" };
-  const probe = serializeDict(meta, dataset, rawElements);
+  const probe = asBuffer(serializeDict(meta, dataset, rawElements));
   const idx = probe.indexOf(PIXEL_DATA_OB_HEADER);
   if (idx < 0 || probe.readUInt32LE(idx + 8) !== 4294967295) {
     throw new Error("failed to locate encapsulated PixelData element header");
@@ -474,7 +644,7 @@ function streamLargeImage(outPath, options) {
   const modality = options.modality ?? "CT";
   const uid = options.uid ?? makeUidGenerator(options.uidSalt ?? seedToSalt(options.seed))(0);
   const identity = { modality, uid, tags: options.tags };
-  mkdirSync2(resolve2(outPath, ".."), { recursive: true });
+  mkdirSync(resolve(outPath, ".."), { recursive: true });
   const zeroChunk = Buffer.alloc(Math.max(1, chunkBytes));
   const probe = serializeDict(
     buildMeta(uid, modality),
@@ -519,7 +689,7 @@ function parseBuffer(buffer) {
   return dcmjsAny.data.DicomMessage.readFile(ab);
 }
 function reserialize(parsed) {
-  return Buffer.from(parsed.write({ allowInvalidVRLength: true }));
+  return new Uint8Array(parsed.write({ allowInvalidVRLength: true }));
 }
 var OVERLONG_UID = `2.25.${"0".repeat(60)}`;
 var VIOLATION_LEVEL = {
@@ -584,11 +754,12 @@ function applyByteLevel(buffer, violations) {
         result = result.subarray(132);
         break;
       case "malformed-sq-delimiter": {
-        const delimiter = Buffer.alloc(8);
-        delimiter.writeUInt16LE(65534, 0);
-        delimiter.writeUInt16LE(57565, 2);
-        delimiter.writeUInt32LE(4, 4);
-        result = Buffer.concat([result, delimiter]);
+        const delimiter = new Uint8Array(8);
+        const view = new DataView(delimiter.buffer);
+        view.setUint16(0, 65534, true);
+        view.setUint16(2, 57565, true);
+        view.setUint32(4, 4, true);
+        result = concatBytes(result, delimiter);
         break;
       }
       default:
@@ -609,7 +780,7 @@ function applyViolations(buffer, violations, rawElements) {
   );
 }
 
-// src/collection/writer.ts
+// src/collection/generate.ts
 var NO_EXTENSION_TYPES = /* @__PURE__ */ new Set([
   "fake-signature",
   "non-dicom"
@@ -748,12 +919,6 @@ function hierarchicalName(studyOrdinal, seriesIndex, instanceNumber) {
     relativePath: `study-${pad3(studyOrdinal + 1)}/series-${pad3(seriesIndex + 1)}/${name}`
   };
 }
-function withResolvedSeed(spec) {
-  return spec.seed === void 0 ? { ...spec, seed: randomBytes2(4).readUInt32BE(0) } : spec;
-}
-function withResolvedSalt(spec) {
-  return spec.uidSalt === void 0 ? { ...spec, uidSalt: randomBytes2(16).toString("hex") } : spec;
-}
 function computeNames(type, index, padWidth, grouped, quirks) {
   let names;
   if (grouped) {
@@ -923,49 +1088,23 @@ async function materialisePlan(plan, salt) {
   });
   return { ...file, filename: plan.filename, relativePath: plan.relativePath };
 }
-async function* generateCollectionFromSpec(spec) {
-  const salt = effectiveSalt(spec);
-  for (const plan of planCollection(spec)) {
-    yield await materialisePlan(plan, salt);
-  }
-}
-async function* previewCollection(spec) {
-  const salt = effectiveSalt(spec);
-  for (const plan of planCollection(spec)) {
-    const knownBytes = plan.fileSpec.type === "large-image" ? plan.fileSpec.targetBytes : plan.fileSpec.type === "non-dicom" ? sizedNonDicomBytes(plan.fileSpec) : void 0;
-    if (knownBytes !== void 0) {
-      yield {
-        relativePath: plan.relativePath,
-        type: plan.fileSpec.type,
-        index: plan.index,
-        approxBytes: knownBytes
-      };
-    } else {
-      const file = await materialisePlan(plan, salt);
-      yield {
-        relativePath: plan.relativePath,
-        type: plan.fileSpec.type,
-        index: plan.index,
-        approxBytes: file.buffer.length
-      };
-    }
-  }
-}
+
+// src/collection/writer.ts
 async function writeCollectionFromSpec(spec, outDir) {
-  const root = resolve3(outDir);
-  mkdirSync3(root, { recursive: true });
+  const root = resolve2(outDir);
+  mkdirSync2(root, { recursive: true });
   const manifest = [];
   const salt = effectiveSalt(spec);
   const createdDirs = /* @__PURE__ */ new Set([root]);
   const ensureDir = (filePath) => {
     const dir = dirname(filePath);
     if (!createdDirs.has(dir)) {
-      mkdirSync3(dir, { recursive: true });
+      mkdirSync2(dir, { recursive: true });
       createdDirs.add(dir);
     }
   };
   for (const plan of planCollection(spec)) {
-    const filePath = resolve3(root, plan.relativePath);
+    const filePath = resolve2(root, plan.relativePath);
     ensureDir(filePath);
     if (plan.fileSpec.type === "large-image") {
       const large = plan.fileSpec;
@@ -994,10 +1133,5 @@ async function writeCollectionFromSpec(spec, outDir) {
   return manifest;
 }
 export {
-  generateCollectionFromSpec,
-  generateFile,
-  previewCollection,
-  withResolvedSalt,
-  withResolvedSeed,
   writeCollectionFromSpec
 };

package/dist/esm/describe/describe.js

@@ -1,5 +1,5 @@
 // src/describe/describe.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash } from "node:crypto";
 import {
   closeSync,
   openSync,
@@ -687,11 +687,148 @@ function validateDatasetSpec(raw) {
   };
 }
 
+// src/platform/bytes.ts
+function bytesToHex(bytes) {
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+
+// src/platform/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var rotr = (x, n) => x >>> n | x << 32 - n;
+function sha256(input) {
+  const data2 = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const padded = new Uint8Array((data2.length + 8 >> 6) + 1 << 6);
+  padded.set(data2);
+  padded[data2.length] = 128;
+  new DataView(padded.buffer).setBigUint64(
+    padded.length - 8,
+    BigInt(data2.length * 8),
+    false
+  );
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const w = new Uint32Array(64);
+  const view = new DataView(padded.buffer);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let t = 0; t < 16; t++) w[t] = view.getUint32(offset + t * 4, false);
+    for (let t = 16; t < 64; t++) {
+      const s0 = rotr(w[t - 15], 7) ^ rotr(w[t - 15], 18) ^ w[t - 15] >>> 3;
+      const s1 = rotr(w[t - 2], 17) ^ rotr(w[t - 2], 19) ^ w[t - 2] >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let t = 0; t < 64; t++) {
+      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = hh + S1 + ch + K[t] + w[t] >>> 0;
+      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  const out = new Uint8Array(32);
+  const outView = new DataView(out.buffer);
+  for (let i = 0; i < 8; i++) outView.setUint32(i * 4, h[i], false);
+  return out;
+}
+
 // src/syntheticFixtures/uid.ts
-import { createHash, randomBytes } from "node:crypto";
 function hashUid(salt, key) {
-  const digest = createHash("sha256").update(salt).update(" ").update(key).digest();
-  const n = BigInt(`0x${digest.subarray(0, 16).toString("hex")}`);
+  const digest = sha256(`${salt} ${key}`);
+  const n = BigInt(`0x${bytesToHex(digest.subarray(0, 16))}`);
   return `2.25.${n.toString()}`;
 }
 
@@ -1032,7 +1169,7 @@ function hashUidTags(uids, salt, map) {
   return tags;
 }
 function deriveSalt(studyUids) {
-  const h = createHash2("sha256");
+  const h = createHash("sha256");
   for (const uid of [...studyUids].sort()) h.update(uid).update("\n");
   return h.digest("hex");
 }