dicom-synth 1.17.0 → 1.19.0

package/dist/esm/syntheticFixtures/uid.js

@@ -1,12 +1,156 @@
+// 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/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 data = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const padded = new Uint8Array((data.length + 8 >> 6) + 1 << 6);
+  padded.set(data);
+  padded[data.length] = 128;
+  new DataView(padded.buffer).setBigUint64(
+    padded.length - 8,
+    BigInt(data.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) {

package/dist/esm/syntheticFixtures/violations.js

@@ -17,6 +17,17 @@ function loadDcmjs() {
 }
 var dcmjs = loadDcmjs();
 
+// src/platform/bytes.ts
+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;
+}
+
 // src/syntheticFixtures/violations.ts
 var dcmjsAny = dcmjs;
 function parseBuffer(buffer) {
@@ -27,7 +38,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 = {
@@ -92,11 +103,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:

package/dist/types/collection/generate.d.ts

@@ -0,0 +1,43 @@
+import type { DatasetSpec, FileSpec } from '../schema/types.js';
+import { type TagContext } from '../syntheticFixtures/tagTemplate.js';
+import type { UidSet } from '../syntheticFixtures/uid.js';
+export type GeneratedFile = {
+    filename: string;
+    relativePath: string;
+    buffer: Uint8Array;
+    type: FileSpec['type'];
+    index: number;
+};
+export declare function resolveUid(salt: string | undefined, index: number, override?: Partial<UidSet>): UidSet;
+export declare function effectiveSalt(spec: {
+    uidSalt?: string;
+    seed?: number;
+}): string | undefined;
+export declare function generateFile(spec: FileSpec, options?: {
+    index?: number;
+    seed?: number;
+    uidSalt?: string;
+    padWidth?: number;
+    uid?: Partial<UidSet>;
+    context?: Partial<TagContext>;
+}): Promise<GeneratedFile>;
+export declare function withResolvedSeed(spec: DatasetSpec): DatasetSpec;
+export declare function withResolvedSalt(spec: DatasetSpec): DatasetSpec;
+export type FilePlan = {
+    fileSpec: FileSpec;
+    index: number;
+    uidOverride?: Partial<UidSet>;
+    context: TagContext;
+    filename: string;
+    relativePath: string;
+};
+export declare function planCollection(spec: DatasetSpec): Generator<FilePlan>;
+export declare function materialisePlan(plan: FilePlan, salt: string | undefined): Promise<GeneratedFile>;
+export declare function generateCollectionFromSpec(spec: DatasetSpec): AsyncGenerator<GeneratedFile>;
+export type CollectionPreviewItem = {
+    relativePath: string;
+    type: FileSpec['type'];
+    index: number;
+    approxBytes: number;
+};
+export declare function previewCollection(spec: DatasetSpec): AsyncGenerator<CollectionPreviewItem>;

package/dist/types/collection/writer.d.ts

@@ -1,34 +1,7 @@
 import type { DatasetSpec, FileSpec } from '../schema/types.js';
-import { type TagContext } from '../syntheticFixtures/tagTemplate.js';
-import type { UidSet } from '../syntheticFixtures/uid.js';
-export type GeneratedFile = {
-    filename: string;
-    relativePath: string;
-    buffer: Buffer;
-    type: FileSpec['type'];
-    index: number;
-};
 export type CollectionManifest = Array<{
     path: string;
     type: FileSpec['type'];
     index: number;
 }>;
-export declare function generateFile(spec: FileSpec, options?: {
-    index?: number;
-    seed?: number;
-    uidSalt?: string;
-    padWidth?: number;
-    uid?: Partial<UidSet>;
-    context?: Partial<TagContext>;
-}): Promise<GeneratedFile>;
-export declare function withResolvedSeed(spec: DatasetSpec): DatasetSpec;
-export declare function withResolvedSalt(spec: DatasetSpec): DatasetSpec;
-export declare function generateCollectionFromSpec(spec: DatasetSpec): AsyncGenerator<GeneratedFile>;
-export type CollectionPreviewItem = {
-    relativePath: string;
-    type: FileSpec['type'];
-    index: number;
-    approxBytes: number;
-};
-export declare function previewCollection(spec: DatasetSpec): AsyncGenerator<CollectionPreviewItem>;
 export declare function writeCollectionFromSpec(spec: DatasetSpec, outDir: string): Promise<CollectionManifest>;

package/dist/types/describe/describe.d.ts

@@ -4,6 +4,7 @@ export type DescribeOptions = {
     sizeTolerance?: number;
     preserveUids?: boolean;
     uidSalt?: string;
+    keepPrivateTags?: boolean;
     captureTree?: boolean;
 };
 export type DescribeResult = {
@@ -13,8 +14,18 @@ export type DescribeResult = {
         skipped: number;
         unknownModality: number;
         nonDicomFiles: number;
+        privateBinarySkipped: number;
     };
 };
-export declare function readHeaderOnly(path: string): Record<string, unknown> | null;
+type RawDictElement = {
+    vr?: string;
+    Value?: unknown[];
+};
+export type ParsedFile = {
+    record: Record<string, unknown>;
+    rawDict: Record<string, RawDictElement>;
+};
+export declare function readHeaderOnly(path: string): ParsedFile | null;
 export declare function tagValuesEqual(a: unknown, b: unknown): boolean;
 export declare function describeDirectory(dir: string, options?: DescribeOptions): DescribeResult;
+export {};

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
-export { type CollectionManifest, type CollectionPreviewItem, type GeneratedFile, generateCollectionFromSpec, generateFile, previewCollection, withResolvedSalt, withResolvedSeed, writeCollectionFromSpec, } from './collection/writer.js';
+export { type CollectionPreviewItem, type GeneratedFile, generateCollectionFromSpec, generateFile, previewCollection, withResolvedSalt, withResolvedSeed, } from './collection/generate.js';
+export { type CollectionManifest, writeCollectionFromSpec, } from './collection/writer.js';
 export { type DescribeOptions, type DescribeResult, describeDirectory, } from './describe/describe.js';
 export { defaultPublicCasesPath, loadCaseById, loadCasesFromJson, loadDefaultCases, type PublicCaseRecord, type PublicCaseSource, } from './public-fixtures/catalog.js';
 export { caseCachePath, fetchPublicCaseToCache, verifySha256, } from './public-fixtures/fetch.js';

package/dist/types/nonStandardDicom/dicomdir.d.ts

@@ -7,9 +7,4 @@ export declare const DICOMDIR_SOP_CLASS_UID = "1.2.840.10008.1.3.10";
  * so it passes signature checks but is detectable by SOP class UID.
  * dcmjs cannot write DICOMDIR, so this uses a raw byte layout.
  */
-export declare function buildDicomdirBuffer(): Buffer;
-/**
- * Write a minimal DICOMDIR-signature file to `filePath`.
- * The parent directory is created if it does not exist.
- */
-export declare function writeDicomdirFile(filePath: string): void;
+export declare function buildDicomdirBuffer(): Uint8Array;

package/dist/types/platform/bytes.d.ts

@@ -0,0 +1,4 @@
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function utf8Bytes(text: string): Uint8Array;
+export declare function concatBytes(...parts: Uint8Array[]): Uint8Array;
+export declare function patternBytes(length: number, pattern: string): Uint8Array;

package/dist/types/platform/random.d.ts

@@ -0,0 +1,2 @@
+export declare function randomUint32(): number;
+export declare function randomHex(byteLength: number): string;

package/dist/types/platform/sha256.d.ts

@@ -0,0 +1 @@
+export declare function sha256(input: string | Uint8Array): Uint8Array;

package/dist/types/schema/validate.d.ts

@@ -1,6 +1,7 @@
 import type { DatasetSpec, FileSpec, ParametricSpec } from './types.js';
 export declare function isImageType(type: FileSpec['type']): boolean;
 export declare const HEX_TAG_RE: RegExp;
+export declare function isPrivateHexTag(key: string): boolean;
 export declare function isRawTagValue(value: unknown): value is {
     vr: string;
     value: unknown;

package/dist/types/syntheticFixtures/generator.d.ts

@@ -9,9 +9,9 @@ export declare function applyTagOverrides(dataset: Record<string, unknown>, tags
 export declare function syncMetaWithDataset(meta: Record<string, unknown>, dataset: Record<string, unknown>, rawElements?: RawElementMap): void;
 export declare function buildMeta(uid: UidSet, modality: Modality, transferSyntax?: TransferSyntax): Record<string, unknown>;
 export declare function buildBaseImageDataset(uid: UidSet, modality: Modality): Record<string, unknown>;
-export declare function serializeDict(meta: Record<string, unknown>, dataset: Record<string, unknown>, rawElements?: RawElementMap): Buffer;
+export declare function serializeDict(meta: Record<string, unknown>, dataset: Record<string, unknown>, rawElements?: RawElementMap): Uint8Array;
 export declare function sizedNonDicomBytes(spec: NonDicomSpec): number | undefined;
 export declare function buildBufferForSpec(spec: FileSpec, uid: UidSet): {
-    buffer: Buffer;
+    buffer: Uint8Array;
     rawElements?: RawElementMap;
 };

package/dist/types/syntheticFixtures/violations.d.ts

@@ -1,3 +1,3 @@
 import type { ViolationClass } from '../schema/types.js';
 import type { RawElementMap } from './generator.js';
-export declare function applyViolations(buffer: Buffer, violations: ViolationClass[], rawElements?: RawElementMap): Buffer;
+export declare function applyViolations(buffer: Uint8Array, violations: ViolationClass[], rawElements?: RawElementMap): Uint8Array;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dicom-synth",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "description": "Toolkit for synthetic DICOM fixtures and public fixture fetch/cache.",
   "license": "Apache-2.0",
   "type": "module",