dicom-synth 0.1.0 → 1.0.0

package/dist/esm/index.js

@@ -1,3 +1,43 @@
+// src/negativeCases/index.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+function writeFakeDicomSignatureFile(filePath) {
+  const buf = Buffer.alloc(200, 0);
+  buf.write("XXXX", 128, 4, "ascii");
+  mkdirSync(resolve(filePath, ".."), { recursive: true });
+  writeFileSync(filePath, buf);
+}
+function writeNonDicomFile(filePath, content = "not dicom") {
+  mkdirSync(resolve(filePath, ".."), { recursive: true });
+  writeFileSync(filePath, content);
+}
+
+// src/nonStandardDicom/dicomdir.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { resolve as resolve2 } 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);
+}
+function writeDicomdirFile(filePath) {
+  mkdirSync2(resolve2(filePath, ".."), { recursive: true });
+  writeFileSync2(filePath, buildDicomdirBuffer());
+}
+
 // src/public-fixtures/catalog.ts
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -31,7 +71,7 @@ function loadCaseById(casesJsonPath, id) {
 
 // src/public-fixtures/fetch.ts
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
 import { homedir } from "node:os";
 import { join as join2 } from "node:path";
 var DEFAULT_CACHE_ROOT = join2(homedir(), ".cache", "dicom-synth-testcases");
@@ -58,7 +98,7 @@ async function fetchPublicCaseToCache(record, cacheRoot = DEFAULT_CACHE_ROOT) {
     verifySha256(buf2, record.sha256);
     return dest;
   }
-  mkdirSync(join2(cacheRoot, record.sha256), { recursive: true });
+  mkdirSync3(join2(cacheRoot, record.sha256), { recursive: true });
   const res = await fetch(record.source.url);
   if (!res.ok) {
     throw new Error(
@@ -67,13 +107,13 @@ async function fetchPublicCaseToCache(record, cacheRoot = DEFAULT_CACHE_ROOT) {
   }
   const buf = Buffer.from(await res.arrayBuffer());
   verifySha256(buf, record.sha256);
-  writeFileSync(dest, buf);
+  writeFileSync3(dest, buf);
   return dest;
 }
 
 // src/syntheticFixtures/generator.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { resolve } from "node:path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { resolve as resolve3 } from "node:path";
 
 // src/loadDcmjs.ts
 import dcmjsDefaultImport, * as dcmjsNamespace from "dcmjs";
@@ -183,13 +223,38 @@ var SYNTHETIC_FIXTURES = [
     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
+  };
+  const dicomDict = new dcmjs.data.DicomDict({});
+  dicomDict.dict = dcmjs.data.DicomMetaDictionary.denaturalizeDataset(dataset);
+  const buffer = Buffer.from(dicomDict.write({ allowInvalidVRLength: true }));
+  mkdirSync4(resolve3(filePath, ".."), { recursive: true });
+  writeFileSync4(filePath, buffer);
+}
 function writeSyntheticFixturesToDir(outDir) {
-  const root = resolve(outDir);
-  mkdirSync2(root, { recursive: true });
+  const root = resolve3(outDir);
+  mkdirSync4(root, { recursive: true });
   const written = [];
   for (const { filename, variant } of SYNTHETIC_FIXTURES) {
-    const path = resolve(root, filename);
-    writeFileSync2(path, buildSyntheticCtBuffer(variant));
+    const path = resolve3(root, filename);
+    writeFileSync4(path, buildSyntheticCtBuffer(variant));
     written.push(path);
   }
   return written;
@@ -197,6 +262,7 @@ function writeSyntheticFixturesToDir(outDir) {
 export {
   SYNTHETIC_FIXTURES,
   buildDicomDict,
+  buildDicomdirBuffer,
   buildSyntheticCtBuffer,
   caseCachePath,
   defaultPublicCasesPath,
@@ -205,5 +271,9 @@ export {
   loadCasesFromJson,
   loadDefaultCases,
   verifySha256,
+  writeDicomdirFile,
+  writeFakeDicomSignatureFile,
+  writeMinimalDicomFile,
+  writeNonDicomFile,
   writeSyntheticFixturesToDir
 };

package/dist/esm/negativeCases/index.js

@@ -0,0 +1,17 @@
+// src/negativeCases/index.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+function writeFakeDicomSignatureFile(filePath) {
+  const buf = Buffer.alloc(200, 0);
+  buf.write("XXXX", 128, 4, "ascii");
+  mkdirSync(resolve(filePath, ".."), { recursive: true });
+  writeFileSync(filePath, buf);
+}
+function writeNonDicomFile(filePath, content = "not dicom") {
+  mkdirSync(resolve(filePath, ".."), { recursive: true });
+  writeFileSync(filePath, content);
+}
+export {
+  writeFakeDicomSignatureFile,
+  writeNonDicomFile
+};

package/dist/esm/nonStandardDicom/dicomdir.js

@@ -0,0 +1,30 @@
+// 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);
+}
+function writeDicomdirFile(filePath) {
+  mkdirSync(resolve(filePath, ".."), { recursive: true });
+  writeFileSync(filePath, buildDicomdirBuffer());
+}
+export {
+  DICOMDIR_SOP_CLASS_UID,
+  buildDicomdirBuffer,
+  writeDicomdirFile
+};

package/dist/esm/syntheticFixtures/generator.js

@@ -110,6 +110,31 @@ var SYNTHETIC_FIXTURES = [
     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
+  };
+  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);
+}
 function writeSyntheticFixturesToDir(outDir) {
   const root = resolve(outDir);
   mkdirSync(root, { recursive: true });
@@ -125,5 +150,6 @@ export {
   SYNTHETIC_FIXTURES,
   buildDicomDict,
   buildSyntheticCtBuffer,
+  writeMinimalDicomFile,
   writeSyntheticFixturesToDir
 };

package/dist/types/index.d.ts

@@ -1,3 +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, SYNTHETIC_FIXTURES, type SyntheticCtVariant, writeSyntheticFixturesToDir, } from './syntheticFixtures/generator';
+export { buildDicomDict, buildSyntheticCtBuffer, type MinimalDicomTags, SYNTHETIC_FIXTURES, type SyntheticCtVariant, writeMinimalDicomFile, writeSyntheticFixturesToDir, } from './syntheticFixtures/generator';

package/dist/types/negativeCases/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Write a file large enough to pass size checks but with `XXXX` at
+ * offset 128 instead of the `DICM` magic bytes.
+ * The parent directory is created if it does not exist.
+ */
+export declare function writeFakeDicomSignatureFile(filePath: string): void;
+/**
+ * Write arbitrary non-DICOM content to `filePath`.
+ * The parent directory is created if it does not exist.
+ */
+export declare function writeNonDicomFile(filePath: string, content?: string): void;

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

@@ -0,0 +1,15 @@
+export declare const DICOMDIR_SOP_CLASS_UID = "1.2.840.10008.1.3.10";
+/**
+ * Build a minimal DICOM Part 10 buffer whose MediaStorageSOPClassUID
+ * identifies it as a DICOMDIR (1.2.840.10008.1.3.10).
+ *
+ * The file has a valid DICM signature and a single meta tag (0002,0002)
+ * 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;

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

@@ -7,5 +7,21 @@ export declare const SYNTHETIC_FIXTURES: {
     variant: SyntheticCtVariant;
     description: string;
 }[];
+export type MinimalDicomTags = {
+    patientId?: string;
+    patientName?: string;
+    sopInstanceUid?: string;
+};
+/**
+ * Write a minimal CT DICOM file to `filePath`.
+ *
+ * The output is intentionally bare: it contains no Part 10 group-0002
+ * file-meta header (no MediaStorageSOPClassUID, TransferSyntaxUID, etc.).
+ * Use `buildDicomDict` / `buildSyntheticCtBuffer` when a conformant
+ * Part 10 file with a complete meta header is required.
+ *
+ * The parent directory is created if it does not exist.
+ */
+export declare function writeMinimalDicomFile(filePath: string, tags?: MinimalDicomTags): void;
 /** Write all catalogue fixtures to a directory (created if missing). */
 export declare function writeSyntheticFixturesToDir(outDir: string): string[];

package/package.json

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

package/dist/esm/publicCorpus.js

@@ -1,72 +0,0 @@
-// src/publicCorpus.ts
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-var DEFAULT_CACHE_ROOT = join(homedir(), ".cache", "dicom-synth-testcases");
-var bundledCatalogPath = join(
-  dirname(fileURLToPath(import.meta.url)),
-  "../data/public-cases.json"
-);
-function defaultPublicCasesPath() {
-  return bundledCatalogPath;
-}
-function loadDefaultCases() {
-  return loadCasesFromJson(defaultPublicCasesPath());
-}
-function loadCasesFromJson(casesJsonPath) {
-  const j = JSON.parse(readFileSync(casesJsonPath, "utf8"));
-  return j.cases;
-}
-function loadCaseById(casesJsonPath, id) {
-  const found = loadCasesFromJson(casesJsonPath).find((r) => r.id === id);
-  if (!found) {
-    throw new Error(`Unknown case id "${id}" in ${casesJsonPath}`);
-  }
-  return found;
-}
-function caseCachePath(sha256, root = DEFAULT_CACHE_ROOT) {
-  return join(root, sha256, "file.dcm");
-}
-function verifySha256(buffer, expected) {
-  const h = createHash("sha256").update(buffer).digest("hex");
-  if (h !== expected) {
-    throw new Error(
-      `SHA256 mismatch: expected ${expected}, got ${h}. Upstream may have changed; bump metadata after review.`
-    );
-  }
-}
-async function fetchPublicCaseToCache(record, cacheRoot = DEFAULT_CACHE_ROOT) {
-  if (record.source.kind !== "url") {
-    throw new Error(
-      `Case ${record.id}: only url sources are supported (s3 requires credentials).`
-    );
-  }
-  const dest = caseCachePath(record.sha256, cacheRoot);
-  if (existsSync(dest)) {
-    const buf2 = readFileSync(dest);
-    verifySha256(buf2, record.sha256);
-    return dest;
-  }
-  mkdirSync(join(cacheRoot, record.sha256), { recursive: true });
-  const res = await fetch(record.source.url);
-  if (!res.ok) {
-    throw new Error(
-      `Fetch failed ${res.status} ${res.statusText} for ${record.source.url}`
-    );
-  }
-  const buf = Buffer.from(await res.arrayBuffer());
-  verifySha256(buf, record.sha256);
-  writeFileSync(dest, buf);
-  return dest;
-}
-export {
-  caseCachePath,
-  defaultPublicCasesPath,
-  fetchPublicCaseToCache,
-  loadCaseById,
-  loadCasesFromJson,
-  loadDefaultCases,
-  verifySha256
-};

package/dist/esm/synthetic.js

@@ -1,109 +0,0 @@
-// src/synthetic.ts
-import { mkdirSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
-import * as dcmjs from "dcmjs";
-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
-};
-function uidFor(variant, role) {
-  const i = VARIANT_INDEX[variant];
-  if (variant === "minimal-invalid-uid") {
-    return `2.25.100000000000000000000000000000.${role}.${i}`;
-  }
-  const uidRoots = [
-    "1000000000000000000000000000000000001",
-    "1000000000000000000000000000000000002",
-    "1000000000000000000000000000000000003"
-  ];
-  const roleSuffix = role === "study" ? 1 : role === "series" ? 2 : 3;
-  return `2.25.${uidRoots[i]}.${roleSuffix}`;
-}
-function naturalDataset(variant) {
-  const studyUID = uidFor(variant, "study");
-  const seriesUID = uidFor(variant, "series");
-  const sopUID = uidFor(variant, "sop");
-  const dataset = {
-    PatientName: "SYNTH^SUBJECT",
-    PatientID: "SYNTH_PID",
-    Modality: "CT",
-    SOPClassUID: CT_SOP_CLASS,
-    SOPInstanceUID: sopUID,
-    SeriesInstanceUID: seriesUID,
-    StudyInstanceUID: studyUID,
-    StudyDescription: "Synthetic study",
-    SeriesDescription: "Synthetic series",
-    Rows: 1,
-    Columns: 1,
-    BitsAllocated: 16,
-    BitsStored: 16,
-    HighBit: 15,
-    SamplesPerPixel: 1,
-    PhotometricInterpretation: "MONOCHROME2",
-    PixelRepresentation: 0,
-    PixelData: new Uint8Array([0, 0]).buffer
-  };
-  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"
-  };
-  const dicomDict = new dcmjs.data.DicomDict(
-    dcmjs.data.DicomMetaDictionary.denaturalizeDataset(meta)
-  );
-  dicomDict.dict = dcmjs.data.DicomMetaDictionary.denaturalizeDataset(
-    naturalDataset(variant)
-  );
-  return dicomDict;
-}
-function buildSyntheticCtBuffer(variant) {
-  return Buffer.from(
-    buildDicomDict(variant).write({ allowInvalidVRLength: true })
-  );
-}
-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 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);
-  }
-  return written;
-}
-export {
-  SYNTHETIC_FIXTURES,
-  buildDicomDict,
-  buildSyntheticCtBuffer,
-  writeSyntheticFixturesToDir
-};

package/dist/types/publicCorpus.d.ts

@@ -1,25 +0,0 @@
-export type PublicCaseSource = {
-    kind: 'url';
-    url: string;
-} | {
-    kind: 's3';
-    bucket: string;
-    key: string;
-    version_id?: string;
-};
-export type PublicCaseRecord = {
-    id: string;
-    violation_class: string;
-    source: PublicCaseSource;
-    sha256: string;
-    notes?: string;
-    dciodvfy_skip?: boolean;
-};
-/** Path to bundled `public-cases.json` (works from `src/` and `dist/esm/`). */
-export declare function defaultPublicCasesPath(): string;
-export declare function loadDefaultCases(): PublicCaseRecord[];
-export declare function loadCasesFromJson(casesJsonPath: string): PublicCaseRecord[];
-export declare function loadCaseById(casesJsonPath: string, id: string): PublicCaseRecord;
-export declare function caseCachePath(sha256: string, root?: string): string;
-export declare function verifySha256(buffer: Buffer, expected: string): void;
-export declare function fetchPublicCaseToCache(record: PublicCaseRecord, cacheRoot?: string): Promise<string>;

package/dist/types/synthetic.d.ts

@@ -1,11 +0,0 @@
-import * as dcmjs from 'dcmjs';
-export type SyntheticCtVariant = 'minimal-invalid-uid' | 'valid-uid' | 'vendor-warnings';
-export declare function buildDicomDict(variant: SyntheticCtVariant): dcmjs.data.DicomDict;
-export declare function buildSyntheticCtBuffer(variant: SyntheticCtVariant): Buffer;
-export declare const SYNTHETIC_FIXTURES: {
-    filename: string;
-    variant: SyntheticCtVariant;
-    description: string;
-}[];
-/** Write all catalogue fixtures to a directory (created if missing). */
-export declare function writeSyntheticFixturesToDir(outDir: string): string[];