dicom-synth 1.4.0 → 1.5.0

package/README.md

@@ -381,6 +381,42 @@ The validator throws with a human-readable message on any structural error.
 
 ---
 
+## Parametric designer
+
+A `ParametricSpec` describes a dataset by ranges instead of explicit entries. `resolveParametricSpec` resolves it — deterministically for a given seed — into a concrete `DatasetSpec` that can be inspected, saved, and re-run.
+
+```ts
+import { resolveParametricSpec, writeCollectionFromSpec } from 'dicom-synth'
+
+const resolved = resolveParametricSpec({
+  seed: 42,
+  studies: {
+    count: { min: 2, max: 4 },          // ranges are inclusive
+    seriesPerStudy: { min: 1, max: 3 },
+    filesPerSeries: { min: 5, max: 20 },
+    fileSizeKb: { min: 100, max: 600 }, // sampled per file
+    modalities: ['CT', 'PT'],           // one drawn per series
+  },
+  edgeCases: [{ type: 'invalid-uid-image', frequency: 0.05 }],
+  layout: 'hierarchical',
+})
+await writeCollectionFromSpec(resolved, './out')
+```
+
+- Every field of `studies` accepts a fixed number or an inclusive `{ min, max }` range (`Range`).
+- `fileSizeKb` maps to `targetSizeKb`; a fixed value collapses each series into one counted entry, a range samples per file.
+- `edgeCases` are `EntrySpec`s appended to the flat `entries` of the resolved spec. With `frequency` (0–1), the count is drawn per file across the whole dataset — the resolved spec records the actual draw. Without it, the entry is appended as-is (use `count` for absolute numbers). At small dataset sizes a low frequency may draw zero occurrences.
+- The seed (drawn randomly when omitted) is embedded in the resolved spec, so resolution is always reproducible.
+
+```ts
+import type { ParametricSpec, ParametricStudies, ParametricEdgeCase, Range } from 'dicom-synth'
+import { validateParametricSpec } from 'dicom-synth'
+```
+
+See `examples/parametric.json` for a JSON example and `examples/convert-data-shape.mjs` for converting an exported tree-shape JSON into a `DatasetSpec` (skips non-DICOM files).
+
+---
+
 ## CLI
 
 ```bash
@@ -392,8 +428,21 @@ dicom-synth-generate --schema-inline '{"entries":[{"type":"valid-image","count":
 
 # Default output directory is ./fixtures/generated
 dicom-synth-generate --schema dataset.json
+
+# Resolve and generate from a parametric spec; save the resolved DatasetSpec
+dicom-synth-generate --parametric examples/parametric.json --out ./out --emit-spec resolved.json
+
+# Preview the manifest (paths, types, sizes) without writing anything
+dicom-synth-generate --parametric examples/parametric.json --dry-run
 ```
 
+| Flag | Effect |
+|---|---|
+| `--schema <path>` / `--schema-inline <json>` / `--parametric <path>` | Input spec (mutually exclusive) |
+| `--out <dir>` | Output directory (default `./fixtures/generated`) |
+| `--emit-spec <path>` | Write the resolved `DatasetSpec` JSON (requires `--parametric`) |
+| `--dry-run` | Generate in memory and print the manifest; nothing is written |
+
 The default schema (`examples/default.json`) generates one each of `valid-image`, `invalid-uid-image`, and `vendor-warnings-image`:
 
 ```bash
@@ -471,7 +520,8 @@ pnpm fetch:public-case -- pydicom-CT-small
 | Path | Responsibility |
 |---|---|
 | `src/schema/types.ts` | All public TypeScript types (`FileSpec`, `DatasetSpec`, `ViolationClass`, etc.) |
-| `src/schema/validate.ts` | `validateDatasetSpec` — validates a raw JSON value against the schema |
+| `src/schema/validate.ts` | `validateDatasetSpec` / `validateParametricSpec` — validate raw JSON values against the schema |
+| `src/schema/parametric.ts` | `resolveParametricSpec` — seeded `ParametricSpec` → `DatasetSpec` resolution |
 | `src/syntheticFixtures/generator.ts` | Internal buffer builders keyed on `FileSpec` type |
 | `src/syntheticFixtures/uid.ts` | Seeded and random UID generation |
 | `src/syntheticFixtures/violations.ts` | Post-processing violation injection |
@@ -481,6 +531,8 @@ pnpm fetch:public-case -- pydicom-CT-small
 | `bin/dicom-synth-generate.mjs` | Published generate CLI (requires `pnpm build`) |
 | `bin/dicom-synth-fetch.mjs` | Published fetch CLI (requires `pnpm build`) |
 | `examples/default.json` | Default `DatasetSpec` — one each of `valid-image`, `invalid-uid-image`, `vendor-warnings-image` |
+| `examples/parametric.json` | Example `ParametricSpec` for the `--parametric` CLI path |
+| `examples/convert-data-shape.mjs` | Example converter: tree-shape JSON → `DatasetSpec` |
 
 ---
 
@@ -506,9 +558,8 @@ Git hooks: see [CONTRIBUTING.md](CONTRIBUTING.md).
 
 ## Future development
 
-- **Size targeting** — generate a file of approximately N KB via a `targetSizeKb` field
-- **Parametric dataset designer** — range-based spec (`{min, max}` for counts/sizes) that resolves deterministically into a concrete `DatasetSpec`
-- **Dry-run mode** — emit the manifest (paths, types, grouping) without writing files
+- **Describe tool** — scan an existing DICOM tree and emit a matching `DatasetSpec` (counts, grouping, sizes, modalities; no PHI)
+- **Dimension edge-case recipes** — documented presets for geometry pathologies (1×65535 strips, high frame counts)
 - **Compressed transfer syntaxes** — JPEG-LS, JPEG 2000, RLE
 - **Private fixture catalogues** — same SHA-256 fetch/cache pattern for credentials-backed sources (e.g. S3)
 

package/bin/dicom-synth-generate.mjs

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
-import { readFileSync } from 'node:fs'
+import { readFileSync, writeFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 import {
+  generateCollectionFromSpec,
+  resolveParametricSpec,
   validateDatasetSpec,
   writeCollectionFromSpec,
 } from '../dist/esm/index.js'
 
 function usage() {
   console.error(
-    'Usage: dicom-synth-generate --schema <path> [--out <dir>]\n' +
-      '       dicom-synth-generate --schema-inline <json> [--out <dir>]',
+    'Usage: dicom-synth-generate --schema <path> [--out <dir>] [--dry-run]\n' +
+      '       dicom-synth-generate --schema-inline <json> [--out <dir>] [--dry-run]\n' +
+      '       dicom-synth-generate --parametric <path> [--out <dir>] [--emit-spec <path>] [--dry-run]',
   )
   process.exit(1)
 }
@@ -19,36 +22,50 @@ const args = process.argv.slice(2)
 if (args.length === 0) usage()
 
 let rawSpec
+let specSource
 let outDir = resolve('./fixtures/generated')
+let emitSpecPath
+let dryRun = false
+
+function readSpecArg(flag, value) {
+  if (rawSpec !== undefined) {
+    console.error(
+      'Error: --schema, --schema-inline and --parametric are mutually exclusive',
+    )
+    process.exit(1)
+  }
+  specSource = flag
+  if (flag === '--schema-inline') {
+    try {
+      rawSpec = JSON.parse(value)
+    } catch (err) {
+      console.error(`Error parsing inline schema: ${err.message}`)
+      process.exit(1)
+    }
+  } else {
+    try {
+      rawSpec = JSON.parse(readFileSync(resolve(value), 'utf8'))
+    } catch (err) {
+      console.error(`Error reading ${flag.slice(2)} file: ${err.message}`)
+      process.exit(1)
+    }
+  }
+}
 
 for (let i = 0; i < args.length; i++) {
   if (
-    (args[i] === '--schema' || args[i] === '--schema-inline') &&
+    (args[i] === '--schema' ||
+      args[i] === '--schema-inline' ||
+      args[i] === '--parametric') &&
     args[i + 1]
   ) {
-    if (rawSpec !== undefined) {
-      console.error(
-        'Error: --schema and --schema-inline are mutually exclusive',
-      )
-      process.exit(1)
-    }
-    if (args[i] === '--schema') {
-      try {
-        rawSpec = JSON.parse(readFileSync(resolve(args[++i]), 'utf8'))
-      } catch (err) {
-        console.error(`Error reading schema file: ${err.message}`)
-        process.exit(1)
-      }
-    } else {
-      try {
-        rawSpec = JSON.parse(args[++i])
-      } catch (err) {
-        console.error(`Error parsing inline schema: ${err.message}`)
-        process.exit(1)
-      }
-    }
+    readSpecArg(args[i], args[++i])
   } else if (args[i] === '--out' && args[i + 1]) {
     outDir = resolve(args[++i])
+  } else if (args[i] === '--emit-spec' && args[i + 1]) {
+    emitSpecPath = resolve(args[++i])
+  } else if (args[i] === '--dry-run') {
+    dryRun = true
   } else {
     console.error(`Unknown argument: ${args[i]}`)
     usage()
@@ -57,29 +74,72 @@ for (let i = 0; i < args.length; i++) {
 
 if (rawSpec === undefined) usage()
 
-let spec
-try {
-  spec = validateDatasetSpec(rawSpec)
-} catch (err) {
-  console.error(`Schema validation error: ${err.message}`)
+function printTypeCounts(counts) {
+  for (const [type, count] of Object.entries(counts)) {
+    console.log(`  ${type}: ${count}`)
+  }
+}
+
+if (emitSpecPath !== undefined && specSource !== '--parametric') {
+  console.error('Error: --emit-spec requires --parametric')
   process.exit(1)
 }
 
-let manifest
+let spec
 try {
-  manifest = await writeCollectionFromSpec(spec, outDir)
+  spec =
+    specSource === '--parametric'
+      ? resolveParametricSpec(rawSpec)
+      : validateDatasetSpec(rawSpec)
 } catch (err) {
-  console.error(`Error writing collection: ${err.message}`)
+  console.error(`Schema validation error: ${err.message}`)
   process.exit(1)
 }
 
-// Summary by type
-const counts = {}
-for (const entry of manifest) {
-  counts[entry.type] = (counts[entry.type] ?? 0) + 1
+if (emitSpecPath !== undefined) {
+  try {
+    writeFileSync(emitSpecPath, `${JSON.stringify(spec, null, 2)}\n`)
+    console.log(`Wrote resolved spec to ${emitSpecPath}`)
+  } catch (err) {
+    console.error(`Error writing resolved spec: ${err.message}`)
+    process.exit(1)
+  }
 }
 
-console.log(`Wrote ${manifest.length} file(s) to ${outDir}`)
-for (const [type, count] of Object.entries(counts)) {
-  console.log(`  ${type}: ${count}`)
+if (dryRun) {
+  const counts = {}
+  let fileCount = 0
+  let byteCount = 0
+  try {
+    for await (const file of generateCollectionFromSpec(spec)) {
+      console.log(
+        `${file.relativePath}  (${file.type}, ${(file.buffer.length / 1024).toFixed(1)} KB)`,
+      )
+      counts[file.type] = (counts[file.type] ?? 0) + 1
+      fileCount++
+      byteCount += file.buffer.length
+    }
+  } catch (err) {
+    console.error(`Error generating collection: ${err.message}`)
+    process.exit(1)
+  }
+  console.log(
+    `Dry run: ${fileCount} file(s), ${(byteCount / 1024).toFixed(1)} KB total — nothing written`,
+  )
+  printTypeCounts(counts)
+} else {
+  let manifest
+  try {
+    manifest = await writeCollectionFromSpec(spec, outDir)
+  } catch (err) {
+    console.error(`Error writing collection: ${err.message}`)
+    process.exit(1)
+  }
+
+  const counts = {}
+  for (const entry of manifest) {
+    counts[entry.type] = (counts[entry.type] ?? 0) + 1
+  }
+  console.log(`Wrote ${manifest.length} file(s) to ${outDir}`)
+  printTypeCounts(counts)
 }

package/dist/esm/index.js

@@ -85,6 +85,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(
@@ -97,11 +116,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`);
@@ -119,18 +134,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) {
@@ -138,11 +149,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;
@@ -153,9 +160,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`);
@@ -240,23 +245,104 @@ 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 } : {}
   };
@@ -457,6 +543,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);
 }
@@ -793,6 +880,80 @@ async function fetchPublicCaseToCache(record, cacheRoot = DEFAULT_CACHE_ROOT) {
   writeFileSync2(dest, buf);
   return dest;
 }
+
+// src/schema/parametric.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+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 {
   caseCachePath,
   defaultPublicCasesPath,
@@ -802,7 +963,9 @@ export {
   loadCaseById,
   loadCasesFromJson,
   loadDefaultCases,
+  resolveParametricSpec,
   validateDatasetSpec,
+  validateParametricSpec,
   verifySha256,
   writeCollectionFromSpec
 };

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/index.d.ts

@@ -1,5 +1,6 @@
 export { type CollectionManifest, type GeneratedFile, generateCollectionFromSpec, generateFile, writeCollectionFromSpec, } from './collection/writer.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.5.0",
   "description": "Toolkit for synthetic DICOM fixtures and public fixture fetch/cache.",
   "license": "Apache-2.0",
   "type": "module",