dicom-synth 1.0.0 → 1.1.0

package/dist/esm/schema/validate.js

@@ -0,0 +1,140 @@
+// src/schema/validate.ts
+var TYPE_CAPABILITIES = {
+  "valid-ct": { tags: true, violations: true, transferSyntax: true },
+  "invalid-uid-ct": { tags: true, violations: true, transferSyntax: true },
+  "vendor-warnings-ct": { tags: true, violations: true, transferSyntax: true },
+  "large-ct": { tags: true, violations: true, transferSyntax: true },
+  "fake-signature": { tags: false, violations: false, transferSyntax: false },
+  "non-dicom": { tags: false, violations: false, transferSyntax: false },
+  dicomdir: { tags: false, violations: false, transferSyntax: false }
+};
+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 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;
+  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)}`
+    );
+  }
+  const type = e.type;
+  const caps = TYPE_CAPABILITIES[type];
+  if ("count" in e) {
+    if (typeof e.count !== "number" || !Number.isInteger(e.count) || e.count < 1) {
+      throw new Error(
+        `${path}.count: must be a positive integer; got ${JSON.stringify(e.count)}`
+      );
+    }
+  }
+  if ("transferSyntax" in e) {
+    if (!caps.transferSyntax) {
+      throw new Error(
+        `${path}.transferSyntax: not supported for type "${type}"`
+      );
+    }
+    if (!Object.hasOwn(VALID_TRANSFER_SYNTAXES, e.transferSyntax)) {
+      throw new Error(
+        `${path}.transferSyntax: must be one of ${Object.keys(VALID_TRANSFER_SYNTAXES).join(", ")}`
+      );
+    }
+  }
+  if (!caps.tags && "tags" in e)
+    throw new Error(`${path}.tags: not supported for type "${type}"`);
+  if (!caps.violations && "violations" in e)
+    throw new Error(`${path}.violations: not supported for type "${type}"`);
+  if ("tags" in e) {
+    if (typeof e.tags !== "object" || e.tags === null || Array.isArray(e.tags)) {
+      throw new Error(`${path}.tags: must be an object`);
+    }
+    for (const key of Object.keys(e.tags)) {
+      validateTagKey(key, `${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()) {
+      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)}`
+        );
+      }
+    }
+  }
+  if (type === "large-ct") {
+    if (typeof e.rows !== "number" || !Number.isInteger(e.rows) || e.rows < 1) {
+      throw new Error(`${path}.rows: must be a positive integer`);
+    }
+    if (typeof e.columns !== "number" || !Number.isInteger(e.columns) || e.columns < 1) {
+      throw new Error(`${path}.columns: must be a positive integer`);
+    }
+    if ("frames" in e) {
+      if (typeof e.frames !== "number" || !Number.isInteger(e.frames) || e.frames < 1) {
+        throw new Error(`${path}.frames: must be a positive integer`);
+      }
+    }
+    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 validateDatasetSpec(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error("DatasetSpec: must be a JSON object");
+  }
+  const r = raw;
+  if (!Array.isArray(r.entries)) {
+    throw new Error("DatasetSpec.entries: must be an array");
+  }
+  if (r.entries.length === 0) {
+    throw new Error("DatasetSpec.entries: must not be empty");
+  }
+  const entries = r.entries.map(
+    (entry, i) => validateEntry(entry, `entries[${i}]`)
+  );
+  if ("seed" in r) {
+    if (typeof r.seed !== "number" || !Number.isFinite(r.seed)) {
+      throw new Error(
+        `DatasetSpec.seed: must be a finite number; got ${JSON.stringify(r.seed)}`
+      );
+    }
+  }
+  return {
+    entries,
+    ...r.seed !== void 0 ? { seed: r.seed } : {}
+  };
+}
+export {
+  HEX_TAG_RE,
+  validateDatasetSpec
+};

package/dist/esm/syntheticFixtures/generator.js

@@ -1,7 +1,3 @@
-// src/syntheticFixtures/generator.ts
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-
 // src/loadDcmjs.ts
 import dcmjsDefaultImport, * as dcmjsNamespace from "dcmjs";
 function loadDcmjs() {
@@ -21,38 +17,85 @@ function loadDcmjs() {
 }
 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/schema/validate.ts
+var MAX_PIXEL_BYTES = 512 * 1024 * 1024;
+var HEX_TAG_RE = /^[0-9a-fA-F]{8}$/;
+
 // src/syntheticFixtures/generator.ts
 var CT_SOP_CLASS = "1.2.840.10008.5.1.4.1.1.2";
-var VARIANT_INDEX = {
-  "minimal-invalid-uid": 0,
-  "valid-uid": 1,
-  "vendor-warnings": 2
+var TRANSFER_SYNTAX_UID = {
+  "explicit-vr-little-endian": "1.2.840.10008.1.2.1",
+  "implicit-vr-little-endian": "1.2.840.10008.1.2"
 };
-function uidFor(variant, role) {
-  const i = VARIANT_INDEX[variant];
-  if (variant === "minimal-invalid-uid") {
-    return `2.25.100000000000000000000000000000.${role}.${i}`;
+function buildTagToKeyword() {
+  const map = /* @__PURE__ */ new Map();
+  const nm = dcmjs.data?.DicomMetaDictionary?.nameMap;
+  if (!nm) return map;
+  for (const [keyword, info] of Object.entries(nm)) {
+    if (info?.tag) {
+      const hex = info.tag.replace(/[(,)]/g, "").toUpperCase();
+      if (hex.length === 8) map.set(hex, keyword);
+    }
   }
-  const uidRoots = [
-    "1000000000000000000000000000000000001",
-    "1000000000000000000000000000000000002",
-    "1000000000000000000000000000000000003"
-  ];
-  const roleSuffix = role === "study" ? 1 : role === "series" ? 2 : 3;
-  return `2.25.${uidRoots[i]}.${roleSuffix}`;
+  return map;
 }
-function naturalDataset(variant) {
-  const studyUID = uidFor(variant, "study");
-  const seriesUID = uidFor(variant, "series");
-  const sopUID = uidFor(variant, "sop");
-  const dataset = {
+var tagToKeyword = buildTagToKeyword();
+function applyTagOverrides(dataset, tags) {
+  if (!tags) return;
+  for (const [key, value] of Object.entries(tags)) {
+    if (HEX_TAG_RE.test(key)) {
+      const keyword = tagToKeyword.get(key.toUpperCase());
+      if (keyword) {
+        dataset[keyword] = value;
+      } else {
+        console.warn(`dicom-synth: unknown hex tag "${key}" \u2014 skipping`);
+      }
+    } else {
+      dataset[key] = value;
+    }
+  }
+}
+function buildMeta(uid, transferSyntax = "explicit-vr-little-endian") {
+  return {
+    FileMetaInformationVersion: new Uint8Array([0, 1]).buffer,
+    MediaStorageSOPClassUID: CT_SOP_CLASS,
+    MediaStorageSOPInstanceUID: uid.sop,
+    TransferSyntaxUID: TRANSFER_SYNTAX_UID[transferSyntax],
+    ImplementationClassUID: "1.2.3.4",
+    ImplementationVersionName: "SYNTH"
+  };
+}
+function buildBaseCtDataset(uid) {
+  return {
     PatientName: "SYNTH^SUBJECT",
     PatientID: "SYNTH_PID",
     Modality: "CT",
     SOPClassUID: CT_SOP_CLASS,
-    SOPInstanceUID: sopUID,
-    SeriesInstanceUID: seriesUID,
-    StudyInstanceUID: studyUID,
+    SOPInstanceUID: uid.sop,
+    SeriesInstanceUID: uid.series,
+    StudyInstanceUID: uid.study,
     StudyDescription: "Synthetic study",
     SeriesDescription: "Synthetic series",
     Rows: 1,
@@ -63,93 +106,87 @@ function naturalDataset(variant) {
     SamplesPerPixel: 1,
     PhotometricInterpretation: "MONOCHROME2",
     PixelRepresentation: 0,
-    PixelData: new Uint8Array([0, 0]).buffer
+    PixelData: new Uint8Array([0, 0]).buffer,
+    // Declares PixelData's VR explicitly — without it dcmjs logs
+    // "No value representation given for PixelData" and falls back to OW anyway.
+    _vrMap: { PixelData: "OW" }
   };
-  if (variant === "vendor-warnings") {
-    dataset.Laterality = "";
-    dataset.PatientWeight = "0";
-  }
-  return dataset;
 }
-function buildDicomDict(variant) {
-  const meta = {
-    FileMetaInformationVersion: new Uint8Array([0, 1]).buffer,
-    MediaStorageSOPClassUID: CT_SOP_CLASS,
-    MediaStorageSOPInstanceUID: uidFor(variant, "sop"),
-    TransferSyntaxUID: "1.2.840.10008.1.2.1",
-    ImplementationClassUID: "1.2.3.4",
-    ImplementationVersionName: "SYNTH"
-  };
+function serializeDict(meta, dataset) {
   const dicomDict = new dcmjs.data.DicomDict(
-    dcmjs.data.DicomMetaDictionary.denaturalizeDataset(meta)
+    dcmjs.data.DicomMetaDictionary.denaturalizeDataset(
+      meta
+    )
   );
   dicomDict.dict = dcmjs.data.DicomMetaDictionary.denaturalizeDataset(
-    naturalDataset(variant)
+    dataset
   );
-  return dicomDict;
+  return Buffer.from(dicomDict.write({ allowInvalidVRLength: true }));
 }
-function buildSyntheticCtBuffer(variant) {
-  return Buffer.from(
-    buildDicomDict(variant).write({ allowInvalidVRLength: true })
-  );
+function buildValidCtBuffer(uid, tags, transferSyntax) {
+  const dataset = buildBaseCtDataset(uid);
+  applyTagOverrides(dataset, tags);
+  return serializeDict(buildMeta(uid, transferSyntax), dataset);
 }
-var SYNTHETIC_FIXTURES = [
-  {
-    filename: "minimal-ct-0.dcm",
-    variant: "minimal-invalid-uid",
-    description: "Minimal CT with text in UIDs (many dciodvfy errors)"
-  },
-  {
-    filename: "valid-uid-ct-0.dcm",
-    variant: "valid-uid",
-    description: "Minimal CT with numeric UIDs only (missing-module noise)"
-  },
-  {
-    filename: "vendor-warnings-ct-0.dcm",
-    variant: "vendor-warnings",
-    description: "Valid UIDs plus empty Laterality and zero PatientWeight"
-  }
-];
-function writeMinimalDicomFile(filePath, tags) {
-  const patientId = tags?.patientId ?? "TEST-PATIENT-001";
-  const patientName = tags?.patientName ?? "TEST^PATIENT";
-  const sopUID = tags?.sopInstanceUid ?? "1.2.3.4.5.6.7.8.9.0.1";
-  const dataset = {
-    PatientName: patientName,
-    PatientID: patientId,
-    Modality: "CT",
-    SOPClassUID: CT_SOP_CLASS,
-    SOPInstanceUID: sopUID,
-    SeriesInstanceUID: "1.2.3.4.5.6.7.8",
-    StudyInstanceUID: "1.2.3.4.5.6.7",
-    SeriesNumber: "1",
-    Rows: 1,
-    Columns: 1,
-    BitsAllocated: 16,
-    PixelRepresentation: 0,
-    PixelData: new Uint8Array([0, 0]).buffer
+function buildInvalidUidCtBuffer(uid, tags, transferSyntax) {
+  const invalidUid = {
+    study: `2.25.invalid.study.${uid.study.slice(-6)}`,
+    series: `2.25.invalid.series.${uid.series.slice(-6)}`,
+    sop: `2.25.invalid.sop.${uid.sop.slice(-6)}`
   };
-  const dicomDict = new dcmjs.data.DicomDict({});
-  dicomDict.dict = dcmjs.data.DicomMetaDictionary.denaturalizeDataset(dataset);
-  const buffer = Buffer.from(dicomDict.write({ allowInvalidVRLength: true }));
-  mkdirSync(resolve(filePath, ".."), { recursive: true });
-  writeFileSync(filePath, buffer);
+  const dataset = buildBaseCtDataset(invalidUid);
+  applyTagOverrides(dataset, tags);
+  return serializeDict(buildMeta(invalidUid, transferSyntax), dataset);
+}
+function buildVendorCtBuffer(uid, tags, transferSyntax) {
+  const dataset = buildBaseCtDataset(uid);
+  dataset.Laterality = "";
+  dataset.PatientWeight = "0";
+  applyTagOverrides(dataset, tags);
+  return serializeDict(buildMeta(uid, transferSyntax), dataset);
+}
+function buildLargeCtBuffer(uid, rows, columns, frames, tags, transferSyntax) {
+  const dataset = buildBaseCtDataset(uid);
+  dataset.Rows = rows;
+  dataset.Columns = columns;
+  dataset.NumberOfFrames = frames;
+  dataset.PixelData = new Uint8Array(rows * columns * frames * 2).buffer;
+  applyTagOverrides(dataset, tags);
+  return serializeDict(buildMeta(uid, transferSyntax), dataset);
+}
+function buildFakeSignatureBuffer() {
+  const buf = Buffer.alloc(200, 0);
+  buf.write("XXXX", 128, 4, "ascii");
+  return buf;
+}
+function buildNonDicomBuffer(content = "not dicom") {
+  return Buffer.from(content, "utf8");
 }
-function writeSyntheticFixturesToDir(outDir) {
-  const root = resolve(outDir);
-  mkdirSync(root, { recursive: true });
-  const written = [];
-  for (const { filename, variant } of SYNTHETIC_FIXTURES) {
-    const path = resolve(root, filename);
-    writeFileSync(path, buildSyntheticCtBuffer(variant));
-    written.push(path);
+function buildBufferForSpec(spec, uid) {
+  switch (spec.type) {
+    case "valid-ct":
+      return buildValidCtBuffer(uid, spec.tags, spec.transferSyntax);
+    case "invalid-uid-ct":
+      return buildInvalidUidCtBuffer(uid, spec.tags, spec.transferSyntax);
+    case "vendor-warnings-ct":
+      return buildVendorCtBuffer(uid, spec.tags, spec.transferSyntax);
+    case "large-ct":
+      return buildLargeCtBuffer(
+        uid,
+        spec.rows,
+        spec.columns,
+        spec.frames ?? 1,
+        spec.tags,
+        spec.transferSyntax
+      );
+    case "fake-signature":
+      return buildFakeSignatureBuffer();
+    case "non-dicom":
+      return buildNonDicomBuffer(spec.content);
+    case "dicomdir":
+      return buildDicomdirBuffer();
   }
-  return written;
 }
 export {
-  SYNTHETIC_FIXTURES,
-  buildDicomDict,
-  buildSyntheticCtBuffer,
-  writeMinimalDicomFile,
-  writeSyntheticFixturesToDir
+  buildBufferForSpec
 };

package/dist/esm/syntheticFixtures/uid.js

@@ -0,0 +1,40 @@
+// src/syntheticFixtures/uid.ts
+import { randomBytes } from "node:crypto";
+var ROLE_CODE = { study: 1, series: 2, sop: 3 };
+function lcg(seed) {
+  let s = seed >>> 0;
+  return () => {
+    s = Math.imul(1664525, s) + 1013904223 >>> 0;
+    return s;
+  };
+}
+function formatUid(a, b, role) {
+  return `2.25.${a}.${b}.${ROLE_CODE[role]}`;
+}
+function randomUid(role) {
+  const buf = randomBytes(8);
+  return formatUid(buf.readUInt32BE(0), buf.readUInt32BE(4), role);
+}
+function seededUid(next, role) {
+  return formatUid(next(), next(), role);
+}
+function makeUidGenerator(seed) {
+  if (seed === void 0) {
+    return () => ({
+      study: randomUid("study"),
+      series: randomUid("series"),
+      sop: randomUid("sop")
+    });
+  }
+  return (fileIndex) => {
+    const next = lcg(seed * 999983 + fileIndex * 1000003 >>> 0);
+    return {
+      study: seededUid(next, "study"),
+      series: seededUid(next, "series"),
+      sop: seededUid(next, "sop")
+    };
+  };
+}
+export {
+  makeUidGenerator
+};

package/dist/esm/syntheticFixtures/violations.js

@@ -0,0 +1,115 @@
+// 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/syntheticFixtures/violations.ts
+var dcmjsAny = dcmjs;
+function parseBuffer(buffer) {
+  const ab = buffer.buffer.slice(
+    buffer.byteOffset,
+    buffer.byteOffset + buffer.byteLength
+  );
+  return dcmjsAny.data.DicomMessage.readFile(ab);
+}
+function reserialize(parsed) {
+  return Buffer.from(parsed.write({ allowInvalidVRLength: true }));
+}
+var OVERLONG_UID = `2.25.${"0".repeat(60)}`;
+var VIOLATION_LEVEL = {
+  "uid-too-long": "tag",
+  "non-conformant-uid": "tag",
+  "vr-max-length-exceeded": "tag",
+  "missing-type1-tag": "tag",
+  "missing-meta-header": "byte",
+  "malformed-sq-delimiter": "byte"
+};
+function applyTagLevel(buffer, violations) {
+  if (violations.length === 0) return buffer;
+  let parsed;
+  try {
+    parsed = parseBuffer(buffer);
+  } catch {
+    console.warn(
+      "dicom-synth: could not parse buffer for tag-level violations \u2014 skipping"
+    );
+    return buffer;
+  }
+  const natural = dcmjsAny.data.DicomMetaDictionary.naturalizeDataset(
+    parsed.dict
+  );
+  for (const v of violations) {
+    switch (v) {
+      case "uid-too-long":
+        break;
+      case "non-conformant-uid":
+        natural.SOPInstanceUID = "2.25.01.234.567";
+        break;
+      case "vr-max-length-exceeded":
+        natural.StudyDescription = "X".repeat(65);
+        break;
+      case "missing-type1-tag":
+        delete natural.SOPClassUID;
+        break;
+      default:
+        throw new Error(
+          `dicom-synth: unhandled tag-level violation "${v}"`
+        );
+    }
+  }
+  parsed.dict = dcmjsAny.data.DicomMetaDictionary.denaturalizeDataset(natural);
+  if (violations.includes("uid-too-long")) {
+    ;
+    parsed.dict["00080018"] = {
+      vr: "UI",
+      Value: [OVERLONG_UID]
+    };
+  }
+  return reserialize(parsed);
+}
+function applyByteLevel(buffer, violations) {
+  let result = buffer;
+  for (const v of violations) {
+    switch (v) {
+      case "missing-meta-header":
+        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]);
+        break;
+      }
+      default:
+        throw new Error(
+          `dicom-synth: unhandled byte-level violation "${v}"`
+        );
+    }
+  }
+  return result;
+}
+function applyViolations(buffer, violations) {
+  if (violations.length === 0) return buffer;
+  const tagViolations = violations.filter((v) => VIOLATION_LEVEL[v] === "tag");
+  const byteViolations = violations.filter((v) => VIOLATION_LEVEL[v] === "byte");
+  return applyByteLevel(applyTagLevel(buffer, tagViolations), byteViolations);
+}
+export {
+  applyViolations
+};

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

@@ -0,0 +1,19 @@
+import type { DatasetSpec, FileSpec } from '../schema/types.js';
+export type GeneratedFile = {
+    filename: 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;
+    padWidth?: number;
+}): Promise<GeneratedFile>;
+export declare function generateCollectionFromSpec(spec: DatasetSpec): AsyncGenerator<GeneratedFile>;
+export declare function writeCollectionFromSpec(spec: DatasetSpec, outDir: string): Promise<CollectionManifest>;

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
-export { writeFakeDicomSignatureFile, writeNonDicomFile, } from './negativeCases/index';
-export { buildDicomdirBuffer, writeDicomdirFile, } from './nonStandardDicom/dicomdir';
-export { defaultPublicCasesPath, loadCaseById, loadCasesFromJson, loadDefaultCases, type PublicCaseRecord, type PublicCaseSource, } from './public-fixtures/catalog';
-export { caseCachePath, fetchPublicCaseToCache, verifySha256, } from './public-fixtures/fetch';
-export { buildDicomDict, buildSyntheticCtBuffer, type MinimalDicomTags, SYNTHETIC_FIXTURES, type SyntheticCtVariant, writeMinimalDicomFile, writeSyntheticFixturesToDir, } from './syntheticFixtures/generator';
+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 { DatasetSpec, DicomdirSpec, DicomTagOverrides, FakeSignatureSpec, FileSpec, InvalidUidCtSpec, LargeCtSpec, NonDicomSpec, TransferSyntax, ValidCtSpec, VendorCtSpec, ViolationClass, } from './schema/types.js';
+export { validateDatasetSpec } from './schema/validate.js';

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

@@ -0,0 +1,48 @@
+export type TransferSyntax = 'explicit-vr-little-endian' | 'implicit-vr-little-endian';
+export type DicomTagOverrides = {
+    PatientID?: string;
+    PatientName?: string;
+    StudyDescription?: string;
+    SeriesDescription?: string;
+    [tag: string]: unknown;
+};
+export type ViolationClass = 'uid-too-long' | 'non-conformant-uid' | 'missing-meta-header' | 'malformed-sq-delimiter' | 'vr-max-length-exceeded' | 'missing-type1-tag';
+type BaseCtSpec = {
+    tags?: DicomTagOverrides;
+    transferSyntax?: TransferSyntax;
+    violations?: ViolationClass[];
+};
+export type ValidCtSpec = BaseCtSpec & {
+    type: 'valid-ct';
+};
+export type InvalidUidCtSpec = BaseCtSpec & {
+    type: 'invalid-uid-ct';
+};
+export type VendorCtSpec = BaseCtSpec & {
+    type: 'vendor-warnings-ct';
+};
+export type LargeCtSpec = BaseCtSpec & {
+    type: 'large-ct';
+    rows: number;
+    columns: number;
+    frames?: number;
+};
+export type FakeSignatureSpec = {
+    type: 'fake-signature';
+};
+export type NonDicomSpec = {
+    type: 'non-dicom';
+    content?: string;
+};
+export type DicomdirSpec = {
+    type: 'dicomdir';
+};
+export type FileSpec = ValidCtSpec | InvalidUidCtSpec | VendorCtSpec | LargeCtSpec | FakeSignatureSpec | NonDicomSpec | DicomdirSpec;
+export type EntrySpec = FileSpec & {
+    count?: number;
+};
+export type DatasetSpec = {
+    entries: EntrySpec[];
+    seed?: number;
+};
+export {};

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

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