@radicalimaging/static-wado-creator 1.3.2 → 1.6.10

package/lib/DeleteStudy.js

@@ -7,8 +7,15 @@ module.exports = (options) =>
     console.log("Delete Study", studyInstanceUid);
     const studyData = await this.scanStudy("studies", studyInstanceUid);
     studyData.delete();
-    const allStudies = await JSONReader(options.directoryName, "studies/index.json.gz", []);
-    const studiesWithoutDeleted = allStudies.filter((study) => studyInstanceUid != Tags.getValue(study, Tags.StudyInstanceUID));
+    const allStudies = await JSONReader(
+      options.directoryName,
+      "studies/index.json.gz",
+      [],
+    );
+    const studiesWithoutDeleted = allStudies.filter(
+      (study) =>
+        studyInstanceUid != Tags.getValue(study, Tags.StudyInstanceUID),
+    );
     await JSONWriter(options.directoryName, "studies", studiesWithoutDeleted);
     delete this.studyData;
   };

package/lib/RejectInstance.js

@@ -1,4 +1,5 @@
-const dataExtractor = /^(.*studies)?[\\/]?([0-9.a-zA-Z]+)[\\/](series[\\/])?([0-9.a-zA-Z]+)([\\/]instances[\\/]([0-9.a-zA-Z]*))?$/;
+const dataExtractor =
+  /^(.*studies)?[\\/]?([0-9.a-zA-Z]+)[\\/](series[\\/])?([0-9.a-zA-Z]+)([\\/]instances[\\/]([0-9.a-zA-Z]*))?$/;
 
 module.exports = () =>
   async function rejectInstanceWithOptions(args) {
@@ -11,9 +12,20 @@ module.exports = () =>
       studyInstanceUid = extracted[2];
       seriesInstanceUid = extracted[4];
       sopInstanceUid = extracted[6];
-      console.log("Extracted", studyInstanceUid, seriesInstanceUid, sopInstanceUid, reason);
+      console.log(
+        "Extracted",
+        studyInstanceUid,
+        seriesInstanceUid,
+        sopInstanceUid,
+        reason,
+      );
     } else {
-      console.log("Not extracting from URL", studyInstanceUid, seriesInstanceUid, reason);
+      console.log(
+        "Not extracting from URL",
+        studyInstanceUid,
+        seriesInstanceUid,
+        reason,
+      );
       seriesInstanceUid = args[1];
     }
     const studyData = await this.scanStudy(studyInstanceUid);

package/lib/StaticWado.js

@@ -1,6 +1,14 @@
 const dicomCodec = require("@cornerstonejs/dicom-codec");
-const staticCS = require("@radicalimaging/static-cs-lite");
-const { Stats, handleHomeRelative, dirScanner, JSONReader, JSONWriter, asyncIterableToBuffer, Tags } = require("@radicalimaging/static-wado-util");
+const staticCS = require("@radicalimaging/cs3d");
+const {
+  Stats,
+  handleHomeRelative,
+  dirScanner,
+  JSONReader,
+  JSONWriter,
+  asyncIterableToBuffer,
+  Tags,
+} = require("@radicalimaging/static-wado-util");
 const dicomParser = require("dicom-parser");
 const fs = require("fs");
 const path = require("path");
@@ -15,7 +23,12 @@ const IdCreator = require("./util/IdCreator");
 const ScanStudy = require("./operation/ScanStudy");
 const HashDataWriter = require("./writer/HashDataWriter");
 const VideoWriter = require("./writer/VideoWriter");
-const { transcodeImageFrame, generateLossyImage, transcodeId, transcodeMetadata } = require("./operation/adapter/transcodeImage");
+const {
+  transcodeImageFrame,
+  generateLossyImage,
+  transcodeId,
+  transcodeMetadata,
+} = require("./operation/adapter/transcodeImage");
 const ThumbnailWriter = require("./writer/ThumbnailWriter");
 const decodeImage = require("./operation/adapter/decodeImage");
 const ThumbnailService = require("./operation/ThumbnailService");
@@ -23,33 +36,87 @@ const DeleteStudy = require("./DeleteStudy");
 const RejectInstance = require("./RejectInstance");
 const RawDicomWriter = require("./writer/RawDicomWriter");
 const { isVideo } = require("./writer/VideoWriter");
+const validateMetadata = require("./operation/validateMetadata.js");
+const {
+  Success,
+  Failure,
+  clearResults,
+  WriteResults,
+} = require("./util/resultsReport");
 
 function setStudyData(studyData) {
   this.studyData = studyData;
 }
 
-function internalGenerateImage(originalImageFrame, dataset, metadata, transferSyntaxUid, doneCallback) {
-  decodeImage(originalImageFrame, dataset, transferSyntaxUid)
-    .then((decodeResult = {}) => {
-      if (isVideo(transferSyntaxUid)) {
-        console.log("Video data - no thumbnail generator yet");
-      } else {
-        const { imageFrame, imageInfo } = decodeResult;
-        const pixelData = dicomCodec.getPixelData(imageFrame, imageInfo, transferSyntaxUid);
-        staticCS.getRenderedBuffer(transferSyntaxUid, pixelData, metadata, doneCallback);
-      }
-    })
-    .catch((error) => {
-      console.log(`Error while generating thumbnail:: ${error}`);
-    });
+async function cs3dThumbnail(
+  originalImageFrame,
+  dataset,
+  metadata,
+  transferSyntaxUid,
+  doneCallback,
+) {
+  if (!originalImageFrame) {
+    throw new Error(`No originalImageFrame data available`);
+  }
+  if (!dataset && !metadata) {
+    throw new Error(
+      `Neither dataset ${!!dataset} nor metadata ${!!metadata} available.`,
+    );
+  }
+  if (isVideo(transferSyntaxUid)) {
+    console.log("Video data - no thumbnail generator yet");
+    return;
+  }
+
+  let decodeResult;
+  try {
+    decodeResult = await decodeImage(
+      originalImageFrame,
+      dataset,
+      metadata,
+      transferSyntaxUid,
+    );
+  } catch (error) {
+    console.log("Error while decoding image:", error);
+    return;
+  }
+
+  if (!decodeResult) {
+    console.warn("No decode result, can't create thumbnail");
+    return;
+  }
+
+  const { imageFrame, imageInfo } = decodeResult;
+  const pixelData = dicomCodec.getPixelData(
+    imageFrame,
+    imageInfo,
+    transferSyntaxUid,
+  );
+  return staticCS.getRenderedBuffer(
+    transferSyntaxUid,
+    pixelData,
+    metadata,
+    doneCallback,
+  );
 }
 
 class StaticWado {
   constructor(configuration) {
-    const { rootDir = "~/dicomweb", pathDeduplicated = "deduplicated", pathInstances = "instances", verbose } = configuration;
+    const {
+      rootDir = "~/dicomweb",
+      pathDeduplicated = "deduplicated",
+      pathInstances = "instances",
+      verbose,
+      quiet = false,
+      multipart = false,
+      showProgress = !quiet && !multipart && !verbose,
+    } = configuration;
 
     dicomCodec.setConfig({ verbose });
     const directoryName = handleHomeRelative(rootDir);
+    this.showProgress = showProgress;
+    this.processedFiles = 0;
+    this.totalFiles = 0;
 
     this.options = {
       ...configuration,
@@ -66,15 +133,22 @@ class StaticWado {
       videoWriter: VideoWriter(this.options),
       thumbWriter: ThumbnailWriter(this.options),
       completeStudy: CompleteStudyWriter(this.options),
+      validateMetadata: validateMetadata(this.options),
       metadata: InstanceDeduplicate(this.options),
       deduplicated: DeduplicateWriter(this.options),
       scanStudy: ScanStudy(this.options),
       reject: RejectInstance(this.options),
       delete: DeleteStudy(this.options),
+      success: Success(this.options),
+      failure: Failure(this.options),
+      writeResults: WriteResults(this.options),
+      clearResults,
       setStudyData,
       rawDicomWriter: RawDicomWriter(this.options),
-      notificationService: new NotificationService(this.options.notificationDir),
-      internalGenerateImage,
+      notificationService: new NotificationService(
+        this.options.notificationDir,
+      ),
+      internalGenerateImage: cs3dThumbnail,
     };
   }
 
@@ -106,20 +180,87 @@ class StaticWado {
    * @param {*} callback
    * @param {*} params
    */
+  updateProgress() {
+    if (!this.showProgress) return;
+    this.processedFiles++;
+    const percentage = Math.round(
+      (this.processedFiles / this.totalFiles) * 100,
+    );
+    const progressBar =
+      "=".repeat(Math.floor(percentage / 4)) +
+      "-".repeat(25 - Math.floor(percentage / 4));
+    process.stdout.write(
+      `\r[${progressBar}] ${percentage}% | ${this.processedFiles}/${this.totalFiles} files`,
+    );
+  }
+
   async processFiles(files, params) {
-    return dirScanner(files, {
+    if (this.showProgress) {
+      // Count total files first
+      for (const file of files) {
+        try {
+          if (fs.statSync(file).isDirectory()) {
+            const dirFiles = fs.readdirSync(file, { recursive: true });
+            this.totalFiles += dirFiles.filter(
+              (f) => !fs.statSync(path.join(file, f)).isDirectory(),
+            ).length;
+          } else {
+            this.totalFiles++;
+          }
+        } catch (e) {
+          this.callback.failure(
+            "File not DICOM",
+            {
+              FailedSOPSequence: [
+                { FailureReason: 0xd000, TextValue: "File not DICOM" },
+              ],
+            },
+            file,
+          );
+        }
+      }
+      console.noQuiet(`\nProcessing ${this.totalFiles} DICOM files...\n`);
+    }
+
+    let filesProcessed = 0;
+    const result = await dirScanner(files, {
       ...params,
       callback: async (file) => {
         try {
           const dicomp10stream = fs.createReadStream(file);
           await this.importBinaryDicom(dicomp10stream, { ...params, file });
+          filesProcessed++;
           Stats.StudyStats.add("DICOM P10", "Parse DICOM P10 file");
+          this.updateProgress();
         } catch (e) {
-          console.error("Couldn't process", file);
-          console.verbose("Error", e);
+          this.updateProgress();
+          const message = {
+            FailedSOPSequence: [
+              {
+                FailureReason: 0xd000,
+                TextValue: "File not DICOM",
+                StorageURL: file,
+              },
+            ],
+          };
+          this.callback.failure("Not DICOM", message, file, e);
         }
       },
     });
+
+    if (!filesProcessed) {
+      const message = {
+        action: "metadata",
+        count: 0,
+        status: -1,
+      };
+      this.callback.failure("No files processed", message);
+    }
+
+    if (this.showProgress) {
+      console.log("\n"); // Move to next line after progress bar
+    }
+    return result;
   }
 
   /**
@@ -144,7 +285,7 @@ class StaticWado {
     const studyInstanceUid = dataSet.string("x0020000d");
 
     if (!studyInstanceUid) {
-      console.log("No study UID, can't import file", params.file, dataSet.elements);
+      console.log("No study UID, can't import file", params.file);
       return undefined;
     }
 
@@ -156,10 +297,14 @@ class StaticWado {
         sopInstanceUid: dataSet.string("x00080018"),
         transferSyntaxUid: dataSet.string("x00020010"),
       },
-      params.file
+      params.file,
     );
 
-    const targetId = transcodeId(id, this.options, dataSet.uint16(Tags.RawSamplesPerPixel));
+    const targetId = transcodeId(
+      id,
+      this.options,
+      dataSet.uint16(Tags.RawSamplesPerPixel),
+    );
 
     let bulkDataIndex = 0;
     let imageFrameIndex = 0;
@@ -172,17 +317,36 @@ class StaticWado {
         // TODO - handle other types here too as single part rendered
         if (options?.mimeType === "application/pdf") {
           console.log("Writing rendered mimeType", options.mimeType);
-          const writeStream = WriteStream(id.sopInstanceRootPath, "rendered.pdf", {
-            gzip: false,
-            mkdir: true,
-          });
+          const writeStream = WriteStream(
+            id.sopInstanceRootPath,
+            "rendered.pdf",
+            {
+              gzip: false,
+              mkdir: true,
+            },
+          );
           await writeStream.write(bulkData);
           await writeStream.close();
         }
-        return this.callback.bulkdata(targetId, _bulkDataIndex, bulkData, options);
+        return this.callback.bulkdata(
+          targetId,
+          _bulkDataIndex,
+          bulkData,
+          options,
+        );
       },
       imageFrame: async (originalImageFrame) => {
-        const { imageFrame: transcodedImageFrame, decoded, id: transcodedId } = await transcodeImageFrame(id, targetId, originalImageFrame, dataSet, this.options);
+        const {
+          imageFrame: transcodedImageFrame,
+          decoded,
+          id: transcodedId,
+        } = await transcodeImageFrame(
+          id,
+          targetId,
+          originalImageFrame,
+          dataSet,
+          this.options,
+        );
 
         const lossyImage = await generateLossyImage(id, decoded, this.options);
 
@@ -190,7 +354,11 @@ class StaticWado {
         imageFrameIndex += 1;
 
         if (lossyImage) {
-          await this.callback.imageFrame(lossyImage.id, currentImageFrameIndex, lossyImage.imageFrame);
+          await this.callback.imageFrame(
+            lossyImage.id,
+            currentImageFrameIndex,
+            lossyImage.imageFrame,
+          );
         }
 
         thumbnailService.queueThumbnail(
@@ -201,10 +369,14 @@ class StaticWado {
             id,
             frameIndex: currentImageFrameIndex,
           },
-          this.options
+          this.options,
         );
 
-        return this.callback.imageFrame(transcodedId, currentImageFrameIndex, transcodedImageFrame);
+        return this.callback.imageFrame(
+          transcodedId,
+          currentImageFrameIndex,
+          transcodedImageFrame,
+        );
       },
       videoWriter: async (_dataSet) => this.callback.videoWriter(id, _dataSet),
     };
@@ -212,11 +384,25 @@ class StaticWado {
     // convert to DICOMweb MetaData and BulkData
     const result = await getDataSet(dataSet, generator, this.options);
 
+    await this.callback.validateMetadata?.(id, result, buffer);
+
     await this.callback.rawDicomWriter?.(id, result, buffer);
 
     const transcodedMeta = transcodeMetadata(result.metadata, id, this.options);
-    await thumbnailService.generateThumbnails(id, dataSet, transcodedMeta, this.callback, this.options);
-    await thumbnailService.generateRendered(id, dataSet, transcodedMeta, this.callback, this.options);
+    await thumbnailService.generateThumbnails(
+      id,
+      dataSet,
+      transcodedMeta,
+      this.callback,
+      this.options,
+    );
+    await thumbnailService.generateRendered(
+      id,
+      dataSet,
+      transcodedMeta,
+      this.callback,
+      this.options,
+    );
     await this.callback.metadata(targetId, transcodedMeta);
 
     // resolve promise with statistics
@@ -227,8 +413,20 @@ class StaticWado {
     return getDataSet(dataSet, generator, params);
   }
 
-  static internalGenerateImage(originalImageFrame, dataSet, metadata, transferSyntaxUid, doneCallback) {
-    return internalGenerateImage(originalImageFrame, dataSet, metadata, transferSyntaxUid, doneCallback);
+  static internalGenerateImage(
+    originalImageFrame,
+    dataSet,
+    metadata,
+    transferSyntaxUid,
+    doneCallback,
+  ) {
+    return cs3dThumbnail(
+      originalImageFrame,
+      dataSet,
+      metadata,
+      transferSyntaxUid,
+      doneCallback,
+    );
   }
 
   /**
@@ -237,15 +435,17 @@ class StaticWado {
    * data in memory by default on a study level, which avoids needing to run the load process.
    */
   async executeCommand(input) {
+    this.callback.clearResults();
     if (this.options.scanStudies) {
       console.log("Scanning study dir", input);
       // Scan one of the study directories - in this case, files is a set of study directories
       await this.processStudyDir(input, this.options);
     } else {
-      console.log("Scanning files", input);
+      console.noQuiet("Scanning files", input);
       await this.processFiles(input, this.options);
     }
     await this.close();
+    this.callback.writeResults();
   }
 
   async close() {
@@ -261,7 +461,11 @@ class StaticWado {
     const dirs = await fs.promises.readdir(studiesDir);
     const studies = [];
     for (const dir of dirs) {
-      const study = await JSONReader(`${studiesDir}/${dir}`, "index.json.gz", null);
+      const study = await JSONReader(
+        `${studiesDir}/${dir}`,
+        "index.json.gz",
+        null,
+      );
       if (study === null) {
         console.log("No study found in", dir);
         continue;

package/lib/createPart10.js

@@ -1,4 +1,3 @@
-/* eslint-disable no-param-reassign */
 const { Tags, readBulkData } = require("@radicalimaging/static-wado-util");
 const dcmjs = require("dcmjs");
 
@@ -14,8 +13,13 @@ fileMetaInformationVersionArray[1] = 1;
 
 const createFmi = (instance) => {
   // Assume the TSUID is in the value 0
-  const TransferSyntaxUID = Tags.getValue(instance, Tags.AvailableTransferSyntaxUID) || UncompressedLEIExplicit;
-  const MediaStorageSOPClassUID = Tags.getValue(instance, Tags.MediaStorageSOPClassUID);
+  const TransferSyntaxUID =
+    Tags.getValue(instance, Tags.AvailableTransferSyntaxUID) ||
+    UncompressedLEIExplicit;
+  const MediaStorageSOPClassUID = Tags.getValue(
+    instance,
+    Tags.MediaStorageSOPClassUID,
+  );
   const SOPInstanceUID = Tags.getValue(instance, Tags.SOPInstanceUID);
   const naturalFmi = {
     MediaStorageSOPClassUID,
@@ -103,7 +107,7 @@ module.exports = async function createMain(options, program) {
     const instance = await study.recombine(sop);
     const fmi = createFmi(instance);
 
-    console.log("Processing sop", sop);
+    console.noQuiet("Processing sop", sop);
     const dicomDict = new DicomDict(fmi);
     await readBinaryData(dir, instance);
     dicomDict.dict = instance;

package/lib/createThumbnail.js

@@ -0,0 +1,181 @@
+const {
+  Tags,
+  readBulkData,
+  handleHomeRelative,
+} = require("@radicalimaging/static-wado-util");
+const dcmjs = require("dcmjs");
+
+const StaticWado = require("./StaticWado");
+const adaptProgramOpts = require("./util/adaptProgramOpts");
+const WriteStream = require("./writer/WriteStream");
+
+const UncompressedLEIExplicit = "1.2.840.10008.1.2.1";
+const { DicomDict, DicomMetaDictionary } = dcmjs.data;
+
+const fileMetaInformationVersionArray = new Uint8Array(2);
+fileMetaInformationVersionArray[1] = 1;
+
+const readBulkDataValue = async (studyDir, instance, value, options) => {
+  const { BulkDataURI } = value;
+  value.vr = "OB";
+  const seriesUid = Tags.getValue(instance, Tags.SeriesInstanceUID);
+  const numberOfFrames = Tags.getValue(instance, Tags.NumberOfFrames) || 1;
+  if (BulkDataURI.indexOf("/frames") !== -1) {
+    const seriesDir = `${studyDir}/series/${seriesUid}`;
+    if (options?.frame === false) {
+      return;
+    }
+    // Really only support a limited number of frames based on memory size
+    value.Value = [];
+    if (typeof options?.frame === "number") {
+      console.noQuiet("Reading frame", options.frame);
+      const bulk = await readBulkData(seriesDir, BulkDataURI, options.frame);
+      if (!bulk) {
+        return;
+      }
+      value.Value[options.frame - 1] = bulk.binaryData;
+      value.transferSyntaxUid = bulk.transferSyntaxUid;
+      value.contentType = bulk.contentType;
+      return;
+    }
+    console.noQuiet("Reading frames", 1, "...", numberOfFrames);
+    for (let frame = 1; frame <= numberOfFrames; frame++) {
+      const bulk = await readBulkData(seriesDir, BulkDataURI, frame);
+      if (!bulk) break;
+      value.Value.push(bulk.binaryData);
+      value.transferSyntaxUid = bulk.transferSyntaxUid;
+      value.contentType = bulk.contentType;
+    }
+  } else {
+    const bulk = await readBulkData(studyDir, BulkDataURI);
+    value.Value = [new ArrayBuffer(bulk.binaryData)];
+    value.contentType = bulk.contentType;
+  }
+};
+
+const readBinaryData = async (dir, instance, options = { frame: true }) => {
+  for (const tag of Object.keys(instance)) {
+    const v = instance[tag];
+    if (v.BulkDataURI) {
+      await readBulkDataValue(dir, instance, v, options);
+      continue;
+    }
+    if (!v.vr) {
+      const value0 = v.Value?.[0];
+      if (typeof value0 === "string") {
+        v.vr = "LT";
+      } else {
+        console.log("Deleting", tag, v.Value, v);
+        delete instance[tag];
+      }
+      continue;
+    }
+    if (v.vr === "SQ" && v.Values?.length) {
+      await Promise.all(v.Values.map(readBinaryData));
+      continue;
+    }
+  }
+};
+
+module.exports = async function createThumbnail(options, program) {
+  const finalOptions = adaptProgramOpts(options, {
+    ...this,
+    // Instance metadata is the instances/<sopUID>/metadata.gz files
+    isInstance: false,
+    // Deduplicated data is single instance deduplicated data
+    isDeduplicate: false,
+    // Group data is the group file directories
+    isGroup: false,
+    isStudyData: false,
+    isDeleteInstances: false,
+  });
+  const importer = new StaticWado(finalOptions);
+  const studyInstanceUid = program.args[0];
+  const dir = `${importer.options.rootDir}/studies/${studyInstanceUid}`;
+  console.noQuiet("Creating thumbnail for", studyInstanceUid, dir);
+  const study = await importer.callback.scanStudy(studyInstanceUid);
+  const outputPath = `./studies/${studyInstanceUid}`;
+  const { sopInstanceUid, seriesInstanceUid, seriesThumbnail, studyThumbnail } =
+    options;
+  const sops = sopInstanceUid ? new Set() : null;
+  if (sopInstanceUid) {
+    for (const sop of sopInstanceUid.split(",").map((s) => s.trim())) {
+      sops.add(sop);
+    }
+  }
+  const promises = [];
+
+  const writeThumbnail = async (id, buffer) => {
+    console.verbose("Write thumbnail", id, buffer);
+    await importer.callback.thumbWriter(
+      id.sopInstanceRootPath,
+      "thumbnail",
+      buffer,
+    );
+    if (seriesThumbnail) {
+      await importer.callback.thumbWriter(
+        id.seriesRootPath,
+        "thumbnail",
+        buffer,
+      );
+    }
+    if (studyThumbnail) {
+      await importer.callback.thumbWriter(id.studyPath, "thumbnail", buffer);
+    }
+  };
+
+  // TODO - choose middle frame of multiframe and choose middle image of
+  // series for series thumbnail, and first series for study thumbnail
+  const codecOptions = { frame: 1 };
+
+  for (const sop of study.getSopUids()) {
+    if (sops && !sops.has(sop)) {
+      continue;
+    }
+    const instance = await study.recombine(sop);
+
+    if (
+      seriesInstanceUid &&
+      Tags.getValue(instance, Tags.SeriesInstanceUID) !== seriesInstanceUid
+    ) {
+      continue;
+    }
+
+    await readBinaryData(dir, instance, codecOptions);
+
+    const availableTransferSyntaxUID = Tags.getValue(
+      instance,
+      Tags.AvailableTransferSyntaxUID,
+    );
+    const pixelData = Tags.getValue(instance, Tags.PixelData);
+    if (!pixelData) {
+      console.warn("No pixel data found in instance");
+      continue;
+    }
+    const transferSyntaxUid =
+      instance[Tags.PixelData].transferSyntaxUid || availableTransferSyntaxUID;
+    const frame = Array.isArray(pixelData.Value)
+      ? pixelData.Value[0]
+      : pixelData;
+    console.verbose("Use transfer syntax uid:", transferSyntaxUid);
+    const id = importer.callback.uids({
+      studyInstanceUid,
+      seriesInstanceUid: Tags.getValue(instance, Tags.SeriesInstanceUID),
+      sopInstanceUid: sop,
+      transferSyntaxUid,
+    });
+
+    const promise = importer.callback.internalGenerateImage(
+      frame,
+      null,
+      instance,
+      id.transferSyntaxUid,
+      writeThumbnail.bind(null, id),
+    );
+    promises.push(promise);
+    if (seriesThumbnail) {
+      break;
+    }
+  }
+  await Promise.all(promises);
+};

package/lib/index.js

@@ -1,9 +1,11 @@
 const mkdicomwebConfig = require("./mkdicomwebConfig");
 const StaticWado = require("./StaticWado");
+const { configureProgram } = require("./program/index.js");
 
 StaticWado.mkdicomwebConfig = mkdicomwebConfig;
 StaticWado.createMain = require("./createMain");
 StaticWado.deleteMain = require("./deleteMain");
 StaticWado.adaptProgramOpts = require("./util/adaptProgramOpts");
+StaticWado.configureProgram = configureProgram;
 
 module.exports = StaticWado;