dicom-synth 1.4.0 → 1.6.0

package/dist/esm/schema/parametric.js

@@ -0,0 +1,327 @@
+// src/schema/parametric.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+
+// src/syntheticFixtures/uid.ts
+import { randomBytes } from "node:crypto";
+function lcg(seed) {
+  let s = seed >>> 0;
+  return () => {
+    s = Math.imul(1664525, s) + 1013904223 >>> 0;
+    return s;
+  };
+}
+var PARAMETRIC_STREAM_OFFSET = 2246822507;
+function seededStream(seed, offset, a, b) {
+  return lcg(seed * 999983 + offset + a * 1000003 + b * 7919 >>> 0);
+}
+
+// src/schema/validate.ts
+var TYPE_CAPABILITIES = {
+  "valid-image": { image: true },
+  "invalid-uid-image": { image: true },
+  "vendor-warnings-image": { image: true },
+  "fake-signature": { image: false },
+  "non-dicom": { image: false },
+  dicomdir: { image: false }
+};
+var VALID_MODALITIES = {
+  CT: true,
+  PT: true,
+  MR: true,
+  CR: true
+};
+var VALID_LAYOUTS = {
+  flat: true,
+  hierarchical: true
+};
+var VALID_TRANSFER_SYNTAXES = {
+  "explicit-vr-little-endian": true,
+  "implicit-vr-little-endian": true
+};
+var MAX_PIXEL_BYTES = 512 * 1024 * 1024;
+var VALID_VIOLATIONS = {
+  "uid-too-long": true,
+  "non-conformant-uid": true,
+  "missing-meta-header": true,
+  "malformed-sq-delimiter": true,
+  "vr-max-length-exceeded": true,
+  "missing-type1-tag": true
+};
+var HEX_TAG_RE = /^[0-9a-fA-F]{8}$/;
+var KEYWORD_RE = /^[A-Z][A-Za-z0-9]*$/;
+function validatePositiveInt(value, path) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    throw new Error(
+      `${path}: must be a positive integer; got ${JSON.stringify(value)}`
+    );
+  }
+}
+function validateSeed(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(
+      `${path}: must be a finite number; got ${JSON.stringify(value)}`
+    );
+  }
+}
+function validateSizeKbLimit(kb, path) {
+  if (kb * 1024 > MAX_PIXEL_BYTES) {
+    throw new Error(`${path}: exceeds the 512 MB limit`);
+  }
+}
+function validateEnum(value, valid, path) {
+  if (typeof value !== "string" || !Object.hasOwn(valid, value)) {
+    throw new Error(
+      `${path}: must be one of ${Object.keys(valid).join(", ")}; got ${JSON.stringify(value)}`
+    );
+  }
+}
+function validateTagKey(key, path) {
+  if (!HEX_TAG_RE.test(key) && !KEYWORD_RE.test(key)) {
+    throw new Error(
+      `${path}: invalid tag key "${key}" \u2014 must be a DICOM keyword name (e.g. "Modality") or an 8-hex-char tag (e.g. "00080060")`
+    );
+  }
+}
+function validateEntry(entry, path) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    throw new Error(`${path}: must be an object`);
+  }
+  const e = entry;
+  validateEnum(e.type, TYPE_CAPABILITIES, `${path}.type`);
+  const type = e.type;
+  const caps = TYPE_CAPABILITIES[type];
+  if ("count" in e) validatePositiveInt(e.count, `${path}.count`);
+  for (const field of [
+    "modality",
+    "rows",
+    "columns",
+    "frames",
+    "targetSizeKb",
+    "tags",
+    "violations",
+    "transferSyntax"
+  ]) {
+    if (!caps.image && field in e)
+      throw new Error(`${path}.${field}: not supported for type "${type}"`);
+  }
+  if ("transferSyntax" in e) {
+    validateEnum(
+      e.transferSyntax,
+      VALID_TRANSFER_SYNTAXES,
+      `${path}.transferSyntax`
+    );
+  }
+  if ("modality" in e) {
+    validateEnum(e.modality, VALID_MODALITIES, `${path}.modality`);
+  }
+  if ("tags" in e) validateTags(e.tags, `${path}.tags`);
+  if ("violations" in e) {
+    if (!Array.isArray(e.violations)) {
+      throw new Error(`${path}.violations: must be an array`);
+    }
+    for (const [i, v] of e.violations.entries()) {
+      validateEnum(v, VALID_VIOLATIONS, `${path}.violations[${i}]`);
+    }
+  }
+  const hasDims = "rows" in e || "columns" in e || "frames" in e;
+  if ("targetSizeKb" in e) {
+    if (hasDims) {
+      throw new Error(
+        `${path}: targetSizeKb cannot be combined with rows/columns/frames \u2014 use one sizing mechanism`
+      );
+    }
+    validatePositiveInt(e.targetSizeKb, `${path}.targetSizeKb`);
+    validateSizeKbLimit(e.targetSizeKb, `${path}.targetSizeKb`);
+  } else if (hasDims) {
+    if (!("rows" in e) || !("columns" in e)) {
+      throw new Error(`${path}: rows and columns must be provided together`);
+    }
+    validatePositiveInt(e.rows, `${path}.rows`);
+    validatePositiveInt(e.columns, `${path}.columns`);
+    if ("frames" in e) validatePositiveInt(e.frames, `${path}.frames`);
+    const rows = e.rows;
+    const columns = e.columns;
+    const frames = typeof e.frames === "number" ? e.frames : 1;
+    if (rows * columns * frames * 2 > MAX_PIXEL_BYTES) {
+      throw new Error(
+        `${path}: pixel data (${rows}\xD7${columns}\xD7${frames}\xD72 bytes) exceeds the 512 MB limit`
+      );
+    }
+  }
+  return e;
+}
+function validateTags(tags, path) {
+  if (typeof tags !== "object" || tags === null || Array.isArray(tags)) {
+    throw new Error(`${path}: must be an object`);
+  }
+  for (const key of Object.keys(tags)) {
+    validateTagKey(key, path);
+  }
+}
+function validateRange(value, path) {
+  if (typeof value === "number") {
+    validatePositiveInt(value, path);
+    return value;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `${path}: must be a positive integer or { min, max }; got ${JSON.stringify(value)}`
+    );
+  }
+  const r = value;
+  validatePositiveInt(r.min, `${path}.min`);
+  validatePositiveInt(r.max, `${path}.max`);
+  if (r.min > r.max) {
+    throw new Error(`${path}: min (${r.min}) must be \u2264 max (${r.max})`);
+  }
+  return value;
+}
+function rangeMax(range) {
+  return typeof range === "number" ? range : range.max;
+}
+function validateParametricStudies(studies, path) {
+  if (typeof studies !== "object" || studies === null || Array.isArray(studies)) {
+    throw new Error(`${path}: must be an object`);
+  }
+  const s = studies;
+  for (const field of ["count", "seriesPerStudy", "filesPerSeries"]) {
+    if (!(field in s)) throw new Error(`${path}.${field}: is required`);
+    validateRange(s[field], `${path}.${field}`);
+  }
+  if ("fileSizeKb" in s) {
+    validateRange(s.fileSizeKb, `${path}.fileSizeKb`);
+    validateSizeKbLimit(rangeMax(s.fileSizeKb), `${path}.fileSizeKb`);
+  }
+  if ("modalities" in s) {
+    if (!Array.isArray(s.modalities) || s.modalities.length === 0) {
+      throw new Error(`${path}.modalities: must be a non-empty array`);
+    }
+    for (const [i, m] of s.modalities.entries()) {
+      validateEnum(m, VALID_MODALITIES, `${path}.modalities[${i}]`);
+    }
+  }
+  if ("tags" in s) validateTags(s.tags, `${path}.tags`);
+  return s;
+}
+function validateEdgeCase(edgeCase, path) {
+  const e = validateEntry(edgeCase, path);
+  if ("frequency" in e) {
+    if ("count" in e) {
+      throw new Error(
+        `${path}: frequency cannot be combined with count \u2014 frequency draws the count at resolution time`
+      );
+    }
+    const f = e.frequency;
+    if (typeof f !== "number" || !(f >= 0 && f <= 1)) {
+      throw new Error(
+        `${path}.frequency: must be a number between 0 and 1; got ${JSON.stringify(f)}`
+      );
+    }
+  }
+  return e;
+}
+function validateParametricSpec(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error("ParametricSpec: must be a JSON object");
+  }
+  const r = raw;
+  if (!("studies" in r)) {
+    throw new Error("ParametricSpec.studies: is required");
+  }
+  const studies = validateParametricStudies(r.studies, "studies");
+  const edgeCases = [];
+  if ("edgeCases" in r) {
+    if (!Array.isArray(r.edgeCases)) {
+      throw new Error("ParametricSpec.edgeCases: must be an array");
+    }
+    for (const [i, e] of r.edgeCases.entries()) {
+      edgeCases.push(validateEdgeCase(e, `edgeCases[${i}]`));
+    }
+  }
+  if ("seed" in r) validateSeed(r.seed, "ParametricSpec.seed");
+  if ("layout" in r) {
+    validateEnum(r.layout, VALID_LAYOUTS, "ParametricSpec.layout");
+  }
+  return {
+    studies,
+    ...edgeCases.length > 0 ? { edgeCases } : {},
+    ...r.seed !== void 0 ? { seed: r.seed } : {},
+    ...r.layout !== void 0 ? { layout: r.layout } : {}
+  };
+}
+
+// src/schema/parametric.ts
+function sample(next, range) {
+  if (typeof range === "number") return range;
+  return range.min + next() % (range.max - range.min + 1);
+}
+function pick(next, items) {
+  return items[next() % items.length];
+}
+function fraction(next) {
+  return next() / 4294967296;
+}
+function resolveParametricSpec(spec) {
+  const validated = validateParametricSpec(spec);
+  const seed = validated.seed ?? randomBytes2(4).readUInt32BE(0);
+  const next = seededStream(seed, PARAMETRIC_STREAM_OFFSET, 0, 0);
+  const params = validated.studies;
+  const studies = [];
+  let totalFiles = 0;
+  const studyCount = sample(next, params.count);
+  for (let st = 0; st < studyCount; st++) {
+    const seriesCount = sample(next, params.seriesPerStudy);
+    const series = [];
+    for (let se = 0; se < seriesCount; se++) {
+      const fileCount = sample(next, params.filesPerSeries);
+      totalFiles += fileCount;
+      const modality = params.modalities ? pick(next, params.modalities) : void 0;
+      const base = {
+        type: "valid-image",
+        ...modality !== void 0 ? { modality } : {}
+      };
+      const entries2 = [];
+      if (params.fileSizeKb !== void 0 && typeof params.fileSizeKb !== "number") {
+        for (let f = 0; f < fileCount; f++) {
+          entries2.push({
+            ...base,
+            targetSizeKb: sample(next, params.fileSizeKb)
+          });
+        }
+      } else {
+        entries2.push({
+          ...base,
+          ...params.fileSizeKb !== void 0 ? { targetSizeKb: params.fileSizeKb } : {},
+          ...fileCount > 1 ? { count: fileCount } : {}
+        });
+      }
+      series.push({ entries: entries2 });
+    }
+    studies.push({
+      series,
+      ...params.tags !== void 0 ? { tags: params.tags } : {}
+    });
+  }
+  const entries = [];
+  for (const edgeCase of validated.edgeCases ?? []) {
+    const { frequency, ...entry } = edgeCase;
+    if (frequency === void 0) {
+      entries.push(entry);
+      continue;
+    }
+    let drawn = 0;
+    for (let i = 0; i < totalFiles; i++) {
+      if (fraction(next) < frequency) drawn++;
+    }
+    if (drawn > 0) entries.push({ ...entry, count: drawn });
+  }
+  return {
+    ...entries.length > 0 ? { entries } : {},
+    studies,
+    seed,
+    ...validated.layout !== void 0 ? { layout: validated.layout } : {}
+  };
+}
+export {
+  resolveParametricSpec
+};

package/dist/esm/schema/validate.js

@@ -39,6 +39,25 @@ function validatePositiveInt(value, path) {
     );
   }
 }
+function validateSeed(value, path) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new Error(
+      `${path}: must be a finite number; got ${JSON.stringify(value)}`
+    );
+  }
+}
+function validateSizeKbLimit(kb, path) {
+  if (kb * 1024 > MAX_PIXEL_BYTES) {
+    throw new Error(`${path}: exceeds the 512 MB limit`);
+  }
+}
+function validateEnum(value, valid, path) {
+  if (typeof value !== "string" || !Object.hasOwn(valid, value)) {
+    throw new Error(
+      `${path}: must be one of ${Object.keys(valid).join(", ")}; got ${JSON.stringify(value)}`
+    );
+  }
+}
 function validateTagKey(key, path) {
   if (!HEX_TAG_RE.test(key) && !KEYWORD_RE.test(key)) {
     throw new Error(
@@ -51,11 +70,7 @@ function validateEntry(entry, path) {
     throw new Error(`${path}: must be an object`);
   }
   const e = entry;
-  if (typeof e.type !== "string" || !Object.hasOwn(TYPE_CAPABILITIES, e.type)) {
-    throw new Error(
-      `${path}.type: must be one of ${Object.keys(TYPE_CAPABILITIES).join(", ")}; got ${JSON.stringify(e.type)}`
-    );
-  }
+  validateEnum(e.type, TYPE_CAPABILITIES, `${path}.type`);
   const type = e.type;
   const caps = TYPE_CAPABILITIES[type];
   if ("count" in e) validatePositiveInt(e.count, `${path}.count`);
@@ -73,18 +88,14 @@ function validateEntry(entry, path) {
       throw new Error(`${path}.${field}: not supported for type "${type}"`);
   }
   if ("transferSyntax" in e) {
-    if (!Object.hasOwn(VALID_TRANSFER_SYNTAXES, e.transferSyntax)) {
-      throw new Error(
-        `${path}.transferSyntax: must be one of ${Object.keys(VALID_TRANSFER_SYNTAXES).join(", ")}`
-      );
-    }
+    validateEnum(
+      e.transferSyntax,
+      VALID_TRANSFER_SYNTAXES,
+      `${path}.transferSyntax`
+    );
   }
   if ("modality" in e) {
-    if (typeof e.modality !== "string" || !Object.hasOwn(VALID_MODALITIES, e.modality)) {
-      throw new Error(
-        `${path}.modality: must be one of ${Object.keys(VALID_MODALITIES).join(", ")}; got ${JSON.stringify(e.modality)}`
-      );
-    }
+    validateEnum(e.modality, VALID_MODALITIES, `${path}.modality`);
   }
   if ("tags" in e) validateTags(e.tags, `${path}.tags`);
   if ("violations" in e) {
@@ -92,11 +103,7 @@ function validateEntry(entry, path) {
       throw new Error(`${path}.violations: must be an array`);
     }
     for (const [i, v] of e.violations.entries()) {
-      if (typeof v !== "string" || !Object.hasOwn(VALID_VIOLATIONS, v)) {
-        throw new Error(
-          `${path}.violations[${i}]: must be one of ${Object.keys(VALID_VIOLATIONS).join(", ")}; got ${JSON.stringify(v)}`
-        );
-      }
+      validateEnum(v, VALID_VIOLATIONS, `${path}.violations[${i}]`);
     }
   }
   const hasDims = "rows" in e || "columns" in e || "frames" in e;
@@ -107,9 +114,7 @@ function validateEntry(entry, path) {
       );
     }
     validatePositiveInt(e.targetSizeKb, `${path}.targetSizeKb`);
-    if (e.targetSizeKb * 1024 > MAX_PIXEL_BYTES) {
-      throw new Error(`${path}.targetSizeKb: exceeds the 512 MB limit`);
-    }
+    validateSizeKbLimit(e.targetSizeKb, `${path}.targetSizeKb`);
   } else if (hasDims) {
     if (!("rows" in e) || !("columns" in e)) {
       throw new Error(`${path}: rows and columns must be provided together`);
@@ -194,28 +199,110 @@ function validateDatasetSpec(raw) {
   const studies = rawStudies.map(
     (study, i) => validateStudy(study, `studies[${i}]`)
   );
-  if ("seed" in r) {
-    if (typeof r.seed !== "number" || !Number.isFinite(r.seed)) {
+  if ("seed" in r) validateSeed(r.seed, "DatasetSpec.seed");
+  if ("layout" in r) {
+    validateEnum(r.layout, VALID_LAYOUTS, "DatasetSpec.layout");
+  }
+  return {
+    ...entries.length > 0 ? { entries } : {},
+    ...studies.length > 0 ? { studies } : {},
+    ...r.seed !== void 0 ? { seed: r.seed } : {},
+    ...r.layout !== void 0 ? { layout: r.layout } : {}
+  };
+}
+function validateRange(value, path) {
+  if (typeof value === "number") {
+    validatePositiveInt(value, path);
+    return value;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(
+      `${path}: must be a positive integer or { min, max }; got ${JSON.stringify(value)}`
+    );
+  }
+  const r = value;
+  validatePositiveInt(r.min, `${path}.min`);
+  validatePositiveInt(r.max, `${path}.max`);
+  if (r.min > r.max) {
+    throw new Error(`${path}: min (${r.min}) must be \u2264 max (${r.max})`);
+  }
+  return value;
+}
+function rangeMax(range) {
+  return typeof range === "number" ? range : range.max;
+}
+function validateParametricStudies(studies, path) {
+  if (typeof studies !== "object" || studies === null || Array.isArray(studies)) {
+    throw new Error(`${path}: must be an object`);
+  }
+  const s = studies;
+  for (const field of ["count", "seriesPerStudy", "filesPerSeries"]) {
+    if (!(field in s)) throw new Error(`${path}.${field}: is required`);
+    validateRange(s[field], `${path}.${field}`);
+  }
+  if ("fileSizeKb" in s) {
+    validateRange(s.fileSizeKb, `${path}.fileSizeKb`);
+    validateSizeKbLimit(rangeMax(s.fileSizeKb), `${path}.fileSizeKb`);
+  }
+  if ("modalities" in s) {
+    if (!Array.isArray(s.modalities) || s.modalities.length === 0) {
+      throw new Error(`${path}.modalities: must be a non-empty array`);
+    }
+    for (const [i, m] of s.modalities.entries()) {
+      validateEnum(m, VALID_MODALITIES, `${path}.modalities[${i}]`);
+    }
+  }
+  if ("tags" in s) validateTags(s.tags, `${path}.tags`);
+  return s;
+}
+function validateEdgeCase(edgeCase, path) {
+  const e = validateEntry(edgeCase, path);
+  if ("frequency" in e) {
+    if ("count" in e) {
       throw new Error(
-        `DatasetSpec.seed: must be a finite number; got ${JSON.stringify(r.seed)}`
+        `${path}: frequency cannot be combined with count \u2014 frequency draws the count at resolution time`
       );
     }
-  }
-  if ("layout" in r) {
-    if (typeof r.layout !== "string" || !Object.hasOwn(VALID_LAYOUTS, r.layout)) {
+    const f = e.frequency;
+    if (typeof f !== "number" || !(f >= 0 && f <= 1)) {
       throw new Error(
-        `DatasetSpec.layout: must be one of ${Object.keys(VALID_LAYOUTS).join(", ")}; got ${JSON.stringify(r.layout)}`
+        `${path}.frequency: must be a number between 0 and 1; got ${JSON.stringify(f)}`
       );
     }
   }
+  return e;
+}
+function validateParametricSpec(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error("ParametricSpec: must be a JSON object");
+  }
+  const r = raw;
+  if (!("studies" in r)) {
+    throw new Error("ParametricSpec.studies: is required");
+  }
+  const studies = validateParametricStudies(r.studies, "studies");
+  const edgeCases = [];
+  if ("edgeCases" in r) {
+    if (!Array.isArray(r.edgeCases)) {
+      throw new Error("ParametricSpec.edgeCases: must be an array");
+    }
+    for (const [i, e] of r.edgeCases.entries()) {
+      edgeCases.push(validateEdgeCase(e, `edgeCases[${i}]`));
+    }
+  }
+  if ("seed" in r) validateSeed(r.seed, "ParametricSpec.seed");
+  if ("layout" in r) {
+    validateEnum(r.layout, VALID_LAYOUTS, "ParametricSpec.layout");
+  }
   return {
-    ...entries.length > 0 ? { entries } : {},
-    ...studies.length > 0 ? { studies } : {},
+    studies,
+    ...edgeCases.length > 0 ? { edgeCases } : {},
     ...r.seed !== void 0 ? { seed: r.seed } : {},
     ...r.layout !== void 0 ? { layout: r.layout } : {}
   };
 }
 export {
   HEX_TAG_RE,
-  validateDatasetSpec
+  validateDatasetSpec,
+  validateParametricSpec
 };

package/dist/esm/syntheticFixtures/uid.js

@@ -19,6 +19,7 @@ function seededUid(next, role) {
   return formatUid(next(), next(), role);
 }
 var GROUP_STREAM_OFFSET = 2654435769;
+var PARAMETRIC_STREAM_OFFSET = 2246822507;
 function seededStream(seed, offset, a, b) {
   return lcg(seed * 999983 + offset + a * 1000003 + b * 7919 >>> 0);
 }
@@ -63,6 +64,8 @@ function makeUidGenerator(seed) {
   };
 }
 export {
+  PARAMETRIC_STREAM_OFFSET,
   makeGroupUidGenerator,
-  makeUidGenerator
+  makeUidGenerator,
+  seededStream
 };

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

@@ -0,0 +1,13 @@
+import type { DatasetSpec } from '../schema/types.js';
+export type DescribeOptions = {
+    keepTags?: string[];
+};
+export type DescribeResult = {
+    spec: DatasetSpec;
+    stats: {
+        dicomFiles: number;
+        skipped: number;
+        unknownModality: number;
+    };
+};
+export declare function describeDirectory(dir: string, options?: DescribeOptions): DescribeResult;

package/dist/types/index.d.ts

@@ -1,5 +1,7 @@
 export { type CollectionManifest, type GeneratedFile, generateCollectionFromSpec, generateFile, 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';
-export type { DatasetLayout, DatasetSpec, DicomdirSpec, DicomTagOverrides, FakeSignatureSpec, FileSpec, ImageSpec, InvalidUidImageSpec, Modality, NonDicomSpec, SeriesEntrySpec, SeriesSpec, StudySpec, TransferSyntax, ValidImageSpec, VendorWarningsImageSpec, ViolationClass, } from './schema/types.js';
-export { validateDatasetSpec } from './schema/validate.js';
+export { resolveParametricSpec } from './schema/parametric.js';
+export type { DatasetLayout, DatasetSpec, DicomdirSpec, DicomTagOverrides, FakeSignatureSpec, FileSpec, ImageSpec, InvalidUidImageSpec, Modality, NonDicomSpec, ParametricEdgeCase, ParametricSpec, ParametricStudies, Range, SeriesEntrySpec, SeriesSpec, StudySpec, TransferSyntax, ValidImageSpec, VendorWarningsImageSpec, ViolationClass, } from './schema/types.js';
+export { validateDatasetSpec, validateParametricSpec, } from './schema/validate.js';

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

@@ -0,0 +1,2 @@
+import type { DatasetSpec, ParametricSpec } from './types.js';
+export declare function resolveParametricSpec(spec: ParametricSpec): DatasetSpec;

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

@@ -61,4 +61,25 @@ export type DatasetSpec = {
     seed?: number;
     layout?: DatasetLayout;
 };
+export type Range = number | {
+    min: number;
+    max: number;
+};
+export type ParametricStudies = {
+    count: Range;
+    seriesPerStudy: Range;
+    filesPerSeries: Range;
+    fileSizeKb?: Range;
+    modalities?: Modality[];
+    tags?: DicomTagOverrides;
+};
+export type ParametricEdgeCase = EntrySpec & {
+    frequency?: number;
+};
+export type ParametricSpec = {
+    seed?: number;
+    studies: ParametricStudies;
+    edgeCases?: ParametricEdgeCase[];
+    layout?: DatasetLayout;
+};
 export {};

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

@@ -1,3 +1,4 @@
-import type { DatasetSpec } from './types.js';
+import type { DatasetSpec, ParametricSpec } from './types.js';
 export declare const HEX_TAG_RE: RegExp;
 export declare function validateDatasetSpec(raw: unknown): DatasetSpec;
+export declare function validateParametricSpec(raw: unknown): ParametricSpec;

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

@@ -3,6 +3,8 @@ export type UidSet = {
     series: string;
     sop: string;
 };
+export declare const PARAMETRIC_STREAM_OFFSET = 2246822507;
+export declare function seededStream(seed: number, offset: number, a: number, b: number): () => number;
 export type GroupUidGenerator = {
     study: (studyIndex: number) => string;
     series: (studyIndex: number, seriesIndex: number) => string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dicom-synth",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Toolkit for synthetic DICOM fixtures and public fixture fetch/cache.",
   "license": "Apache-2.0",
   "type": "module",
@@ -23,7 +23,8 @@
   "types": "dist/types/index.d.ts",
   "bin": {
     "dicom-synth-generate": "./bin/dicom-synth-generate.mjs",
-    "dicom-synth-fetch": "./bin/dicom-synth-fetch.mjs"
+    "dicom-synth-fetch": "./bin/dicom-synth-fetch.mjs",
+    "dicom-synth-describe": "./bin/dicom-synth-describe.mjs"
   },
   "exports": {
     ".": {
@@ -82,7 +83,7 @@
     "@typescript-eslint/eslint-plugin": "^8.46.1",
     "@typescript-eslint/parser": "^8.46.1",
     "dcmjs": "^0.51.1",
-    "esbuild": "^0.25.9",
+    "esbuild": "^0.28.1",
     "eslint": "^9.38.0",
     "globals": "^16.4.0",
     "husky": "^9.1.7",