@ubercode/dcmtk 0.3.0 → 0.4.0

package/dist/tools.js

@@ -243,19 +243,17 @@ var Dcm2xmlCharset = {
   /** Use ASCII encoding. */
   ASCII: "ascii"
 };
+var VERBOSITY_FLAGS = { verbose: "-v", debug: "-d" };
 var Dcm2xmlOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
   namespace: z.boolean().optional(),
   charset: z.enum(["utf8", "latin1", "ascii"]).optional(),
   writeBinaryData: z.boolean().optional(),
-  encodeBinaryBase64: z.boolean().optional()
+  encodeBinaryBase64: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs(inputPath, options) {
-  const args = [];
-  if (options?.namespace === true) {
-    args.push("+Xn");
-  }
+function pushEncodingArgs(args, options) {
   if (options?.charset === "latin1") {
     args.push("+Cl");
   } else if (options?.charset === "ascii") {
@@ -267,6 +265,16 @@ function buildArgs(inputPath, options) {
       args.push("+Eb");
     }
   }
+}
+function buildArgs(inputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS[options.verbosity]);
+  }
+  if (options?.namespace === true) {
+    args.push("+Xn");
+  }
+  pushEncodingArgs(args, options);
   args.push(inputPath);
   return args;
 }
@@ -497,19 +505,28 @@ function repairJson(raw) {
 var Dcm2jsonOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  directOnly: z.boolean().optional()
+  directOnly: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-async function tryXmlPath(inputPath, timeoutMs, signal) {
+var VERBOSITY_FLAGS2 = { verbose: "-v", debug: "-d" };
+function buildVerbosityArgs(verbosity) {
+  if (verbosity !== void 0) {
+    return [VERBOSITY_FLAGS2[verbosity]];
+  }
+  return [];
+}
+async function tryXmlPath(inputPath, timeoutMs, signal, verbosity) {
   const xmlBinary = resolveBinary("dcm2xml");
   if (!xmlBinary.ok) {
     return err(xmlBinary.error);
   }
-  const xmlResult = await execCommand(xmlBinary.value, ["-nat", inputPath], { timeoutMs, signal });
+  const xmlArgs = [...buildVerbosityArgs(verbosity), "-nat", inputPath];
+  const xmlResult = await execCommand(xmlBinary.value, xmlArgs, { timeoutMs, signal });
   if (!xmlResult.ok) {
     return err(xmlResult.error);
   }
   if (xmlResult.value.exitCode !== 0) {
-    return err(createToolError("dcm2xml", ["-nat", inputPath], xmlResult.value.exitCode, xmlResult.value.stderr));
+    return err(createToolError("dcm2xml", xmlArgs, xmlResult.value.exitCode, xmlResult.value.stderr));
   }
   const jsonResult = xmlToJson(xmlResult.value.stdout);
   if (!jsonResult.ok) {
@@ -517,17 +534,18 @@ async function tryXmlPath(inputPath, timeoutMs, signal) {
   }
   return ok({ data: jsonResult.value, source: "xml" });
 }
-async function tryDirectPath(inputPath, timeoutMs, signal) {
+async function tryDirectPath(inputPath, timeoutMs, signal, verbosity) {
   const jsonBinary = resolveBinary("dcm2json");
   if (!jsonBinary.ok) {
     return err(jsonBinary.error);
   }
-  const result = await execCommand(jsonBinary.value, [inputPath], { timeoutMs, signal });
+  const directArgs = [...buildVerbosityArgs(verbosity), inputPath];
+  const result = await execCommand(jsonBinary.value, directArgs, { timeoutMs, signal });
   if (!result.ok) {
     return err(result.error);
   }
   if (result.value.exitCode !== 0) {
-    return err(createToolError("dcm2json", [inputPath], result.value.exitCode, result.value.stderr));
+    return err(createToolError("dcm2json", directArgs, result.value.exitCode, result.value.stderr));
   }
   try {
     const repaired = repairJson(result.value.stdout);
@@ -544,14 +562,15 @@ async function dcm2json(inputPath, options) {
   }
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const signal = options?.signal;
+  const verbosity = options?.verbosity;
   if (options?.directOnly === true) {
-    return tryDirectPath(inputPath, timeoutMs, signal);
+    return tryDirectPath(inputPath, timeoutMs, signal, verbosity);
   }
-  const xmlResult = await tryXmlPath(inputPath, timeoutMs, signal);
+  const xmlResult = await tryXmlPath(inputPath, timeoutMs, signal, verbosity);
   if (xmlResult.ok) {
     return xmlResult;
   }
-  return tryDirectPath(inputPath, timeoutMs, signal);
+  return tryDirectPath(inputPath, timeoutMs, signal, verbosity);
 }
 var DcmdumpFormat = {
   /** Print standard DCMTK format. */
@@ -559,16 +578,17 @@ var DcmdumpFormat = {
   /** Print tag and value only. */
   SHORT: "short"
 };
+var VERBOSITY_FLAGS3 = { verbose: "-v", debug: "-d" };
 var DcmdumpOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
   format: z.enum(["standard", "short"]).optional(),
   allTags: z.boolean().optional(),
   searchTag: z.string().regex(/^\([0-9A-Fa-f]{4},[0-9A-Fa-f]{4}\)$/).optional(),
-  printValues: z.boolean().optional()
+  printValues: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs2(inputPath, options) {
-  const args = [];
+function pushDisplayArgs(args, options) {
   if (options?.format === "short") {
     args.push("+L");
   }
@@ -582,6 +602,13 @@ function buildArgs2(inputPath, options) {
   if (options?.printValues === true) {
     args.push("+Vr");
   }
+}
+function buildArgs2(inputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS3[options.verbosity]);
+  }
+  pushDisplayArgs(args, options);
   args.push(inputPath);
   return args;
 }
@@ -628,7 +655,8 @@ var VALID_TRANSFER_SYNTAXES = ["+ti", "+te", "+tb", "+tl", "+t2", "+tr", "+td"];
 var DcmconvOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  transferSyntax: z.enum(VALID_TRANSFER_SYNTAXES)
+  transferSyntax: z.enum(VALID_TRANSFER_SYNTAXES),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict();
 async function dcmconv(inputPath, outputPath, options) {
   const validation = DcmconvOptionsSchema.safeParse(options);
@@ -639,7 +667,13 @@ async function dcmconv(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [options.transferSyntax, inputPath, outputPath];
+  const args = [];
+  if (options.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options.verbosity === "debug") {
+    args.push("-d");
+  }
+  args.push(options.transferSyntax, inputPath, outputPath);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -658,6 +692,7 @@ var TagModificationSchema = z.object({
   tag: z.string().regex(TAG_OR_PATH_PATTERN),
   value: z.string()
 });
+var VERBOSITY_FLAGS4 = { verbose: "-v", debug: "-d" };
 var DcmodifyOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
@@ -666,12 +701,16 @@ var DcmodifyOptionsSchema = z.object({
   erasePrivateTags: z.boolean().optional(),
   noBackup: z.boolean().optional(),
   insertIfMissing: z.boolean().optional(),
-  ignoreMissingTags: z.boolean().optional()
+  ignoreMissingTags: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().refine((data) => data.modifications.length > 0 || data.erasures !== void 0 && data.erasures.length > 0 || data.erasePrivateTags === true, {
   message: "At least one of modifications, erasures, or erasePrivateTags is required"
 });
 function buildArgs3(inputPath, options) {
   const args = [];
+  if (options.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS4[options.verbosity]);
+  }
   if (options.noBackup !== false) {
     args.push("-nb");
   }
@@ -719,8 +758,18 @@ async function dcmodify(inputPath, options) {
 }
 var DcmftestOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+var VERBOSITY_FLAGS5 = { verbose: "-v", debug: "-d" };
+function buildArgs4(inputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS5[options.verbosity]);
+  }
+  args.push(inputPath);
+  return args;
+}
 async function dcmftest(inputPath, options) {
   const validation = DcmftestOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -730,7 +779,7 @@ async function dcmftest(inputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath];
+  const args = buildArgs4(inputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -754,10 +803,16 @@ var DcmgpdirOptionsSchema = z.object({
   filesetId: z.string().min(1).optional(),
   inputDirectory: z.string().min(1).optional(),
   mapFilenames: z.boolean().optional(),
-  inventAttributes: z.boolean().optional()
+  inventAttributes: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict();
-function buildArgs4(options) {
+function buildArgs5(options) {
   const args = [];
+  if (options.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options.outputFile !== void 0) {
     args.push("+D", options.outputFile);
   }
@@ -785,7 +840,7 @@ async function dcmgpdir(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs4(options);
+  const args = buildArgs5(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -810,10 +865,16 @@ var DcmmkdirOptionsSchema = z.object({
   append: z.boolean().optional(),
   inputDirectory: z.string().min(1).optional(),
   mapFilenames: z.boolean().optional(),
-  inventAttributes: z.boolean().optional()
+  inventAttributes: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict();
-function buildArgs5(options) {
+function buildArgs6(options) {
   const args = [];
+  if (options.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options.outputFile !== void 0) {
     args.push("+D", options.outputFile);
   }
@@ -844,7 +905,7 @@ async function dcmmkdir(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs5(options);
+  const args = buildArgs6(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -865,12 +926,18 @@ var DcmqridxOptionsSchema = z.object({
   indexDirectory: z.string().min(1),
   inputFiles: z.array(z.string().min(1)).min(1).optional(),
   print: z.boolean().optional(),
-  notNew: z.boolean().optional()
+  notNew: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().refine((data) => data.inputFiles !== void 0 && data.inputFiles.length > 0 || data.print === true, {
   message: "Either inputFiles (non-empty) or print must be specified"
 });
-function buildArgs6(options) {
+function buildArgs7(options) {
   const args = [];
+  if (options.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options.print === true) {
     args.push("-p");
   }
@@ -892,7 +959,7 @@ async function dcmqridx(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs6(options);
+  const args = buildArgs7(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -912,11 +979,17 @@ async function dcmqridx(options) {
 var Xml2dcmOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional(),
   generateNewUIDs: z.boolean().optional(),
   validateDocument: z.boolean().optional()
 }).strict().optional();
-function buildArgs7(inputPath, outputPath, options) {
+function buildArgs8(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.generateNewUIDs === true) {
     args.push("+Ug");
   }
@@ -935,7 +1008,7 @@ async function xml2dcm(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs7(inputPath, outputPath, options);
+  const args = buildArgs8(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -951,8 +1024,18 @@ async function xml2dcm(inputPath, outputPath, options) {
 }
 var Json2dcmOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+var VERBOSITY_FLAGS6 = { verbose: "-v", debug: "-d" };
+function buildArgs9(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS6[options.verbosity]);
+  }
+  args.push(inputPath, outputPath);
+  return args;
+}
 async function json2dcm(inputPath, outputPath, options) {
   const validation = Json2dcmOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -962,7 +1045,7 @@ async function json2dcm(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath, outputPath];
+  const args = buildArgs9(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -979,11 +1062,17 @@ async function json2dcm(inputPath, outputPath, options) {
 var Dump2dcmOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional(),
   generateNewUIDs: z.boolean().optional(),
   writeFileFormat: z.boolean().optional()
 }).strict().optional();
-function buildArgs8(inputPath, outputPath, options) {
+function buildArgs10(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.generateNewUIDs === true) {
     args.push("+Ug");
   }
@@ -1002,7 +1091,7 @@ async function dump2dcm(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs8(inputPath, outputPath, options);
+  const args = buildArgs10(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1025,6 +1114,7 @@ var Img2dcmInputFormat = {
 var Img2dcmOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional(),
   inputFormat: z.enum(["jpeg", "bmp"]).optional(),
   datasetFrom: z.string().min(1).optional()
 }).strict().optional();
@@ -1032,8 +1122,13 @@ var FORMAT_FLAG_MAP = {
   jpeg: "JPEG",
   bmp: "BMP"
 };
-function buildArgs9(inputPath, outputPath, options) {
+function buildArgs11(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.inputFormat !== void 0) {
     args.push("-i", FORMAT_FLAG_MAP[options.inputFormat]);
   }
@@ -1052,7 +1147,7 @@ async function img2dcm(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs9(inputPath, outputPath, options);
+  const args = buildArgs11(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1068,8 +1163,18 @@ async function img2dcm(inputPath, outputPath, options) {
 }
 var Pdf2dcmOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+var VERBOSITY_FLAGS7 = { verbose: "-v", debug: "-d" };
+function buildArgs12(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS7[options.verbosity]);
+  }
+  args.push(inputPath, outputPath);
+  return args;
+}
 async function pdf2dcm(inputPath, outputPath, options) {
   const validation = Pdf2dcmOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -1079,7 +1184,7 @@ async function pdf2dcm(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath, outputPath];
+  const args = buildArgs12(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1095,8 +1200,18 @@ async function pdf2dcm(inputPath, outputPath, options) {
 }
 var Dcm2pdfOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+var VERBOSITY_FLAGS8 = { verbose: "-v", debug: "-d" };
+function buildArgs13(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS8[options.verbosity]);
+  }
+  args.push(inputPath, outputPath);
+  return args;
+}
 async function dcm2pdf(inputPath, outputPath, options) {
   const validation = Dcm2pdfOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -1106,7 +1221,7 @@ async function dcm2pdf(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath, outputPath];
+  const args = buildArgs13(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1122,8 +1237,18 @@ async function dcm2pdf(inputPath, outputPath, options) {
 }
 var Cda2dcmOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+var VERBOSITY_FLAGS9 = { verbose: "-v", debug: "-d" };
+function buildArgs14(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS9[options.verbosity]);
+  }
+  args.push(inputPath, outputPath);
+  return args;
+}
 async function cda2dcm(inputPath, outputPath, options) {
   const validation = Cda2dcmOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -1133,7 +1258,7 @@ async function cda2dcm(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath, outputPath];
+  const args = buildArgs14(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1149,8 +1274,18 @@ async function cda2dcm(inputPath, outputPath, options) {
 }
 var Dcm2cdaOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+var VERBOSITY_FLAGS10 = { verbose: "-v", debug: "-d" };
+function buildArgs15(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS10[options.verbosity]);
+  }
+  args.push(inputPath, outputPath);
+  return args;
+}
 async function dcm2cda(inputPath, outputPath, options) {
   const validation = Dcm2cdaOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -1160,7 +1295,7 @@ async function dcm2cda(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath, outputPath];
+  const args = buildArgs15(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1176,8 +1311,18 @@ async function dcm2cda(inputPath, outputPath, options) {
 }
 var Stl2dcmOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+var VERBOSITY_FLAGS11 = { verbose: "-v", debug: "-d" };
+function buildArgs16(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS11[options.verbosity]);
+  }
+  args.push(inputPath, outputPath);
+  return args;
+}
 async function stl2dcm(inputPath, outputPath, options) {
   const validation = Stl2dcmOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -1187,7 +1332,7 @@ async function stl2dcm(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath, outputPath];
+  const args = buildArgs16(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1204,10 +1349,16 @@ async function stl2dcm(inputPath, outputPath, options) {
 var DcmcrleOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  uidAlways: z.boolean().optional()
+  uidAlways: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs10(inputPath, outputPath, options) {
+function buildArgs17(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.uidAlways === true) {
     args.push("+ua");
   }
@@ -1223,7 +1374,7 @@ async function dcmcrle(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs10(inputPath, outputPath, options);
+  const args = buildArgs17(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1240,10 +1391,16 @@ async function dcmcrle(inputPath, outputPath, options) {
 var DcmdrleOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  uidAlways: z.boolean().optional()
+  uidAlways: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs11(inputPath, outputPath, options) {
+function buildArgs18(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.uidAlways === true) {
     args.push("+ua");
   }
@@ -1259,7 +1416,7 @@ async function dcmdrle(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs11(inputPath, outputPath, options);
+  const args = buildArgs18(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1276,10 +1433,16 @@ async function dcmdrle(inputPath, outputPath, options) {
 var DcmencapOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  documentTitle: z.string().optional()
+  documentTitle: z.string().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs12(inputPath, outputPath, options) {
+function buildArgs19(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.documentTitle !== void 0) {
     args.push("--title", options.documentTitle);
   }
@@ -1295,7 +1458,7 @@ async function dcmencap(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs12(inputPath, outputPath, options);
+  const args = buildArgs19(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1311,8 +1474,19 @@ async function dcmencap(inputPath, outputPath, options) {
 }
 var DcmdecapOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+function buildArgs20(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
+  args.push(inputPath, outputPath);
+  return args;
+}
 async function dcmdecap(inputPath, outputPath, options) {
   const validation = DcmdecapOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -1322,7 +1496,7 @@ async function dcmdecap(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath, outputPath];
+  const args = buildArgs20(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1340,10 +1514,19 @@ var DcmcjpegOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
   quality: z.number().int().min(1).max(100).optional(),
-  lossless: z.boolean().optional()
+  lossless: z.boolean().optional(),
+  progressive: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs13(inputPath, outputPath, options) {
+var VERBOSITY_FLAGS12 = { verbose: "-v", debug: "-d" };
+function buildArgs21(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS12[options.verbosity]);
+  }
+  if (options?.progressive === true) {
+    args.push("+p");
+  }
   if (options?.lossless === true) {
     args.push("+e1");
   }
@@ -1362,7 +1545,7 @@ async function dcmcjpeg(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs13(inputPath, outputPath, options);
+  const args = buildArgs21(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1392,10 +1575,16 @@ var COLOR_CONVERSION_FLAGS = {
 var DcmdjpegOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  colorConversion: z.enum(["photometric", "always", "never"]).optional()
+  colorConversion: z.enum(["photometric", "always", "never"]).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs14(inputPath, outputPath, options) {
+function buildArgs22(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.colorConversion !== void 0) {
     args.push(COLOR_CONVERSION_FLAGS[options.colorConversion]);
   }
@@ -1411,7 +1600,7 @@ async function dcmdjpeg(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs14(inputPath, outputPath, options);
+  const args = buildArgs22(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1429,10 +1618,15 @@ var DcmcjplsOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
   lossless: z.boolean().optional(),
-  maxDeviation: z.number().int().min(0).optional()
+  maxDeviation: z.number().int().min(0).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs15(inputPath, outputPath, options) {
+var VERBOSITY_FLAGS13 = { verbose: "-v", debug: "-d" };
+function buildArgs23(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS13[options.verbosity]);
+  }
   if (options?.lossless === false) {
     args.push("+en");
   } else if (options?.lossless === true) {
@@ -1453,7 +1647,7 @@ async function dcmcjpls(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs15(inputPath, outputPath, options);
+  const args = buildArgs23(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1483,10 +1677,16 @@ var JPLS_COLOR_CONVERSION_FLAGS = {
 var DcmdjplsOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  colorConversion: z.enum(["photometric", "always", "never"]).optional()
+  colorConversion: z.enum(["photometric", "always", "never"]).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs16(inputPath, outputPath, options) {
+function buildArgs24(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.colorConversion !== void 0) {
     args.push(JPLS_COLOR_CONVERSION_FLAGS[options.colorConversion]);
   }
@@ -1502,7 +1702,7 @@ async function dcmdjpls(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs16(inputPath, outputPath, options);
+  const args = buildArgs24(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1521,6 +1721,8 @@ var Dcmj2pnmOutputFormat = {
   PNM: "pnm",
   /** PNG format. */
   PNG: "png",
+  /** 16-bit PNG format. */
+  PNG_16BIT: "png16",
   /** BMP format. */
   BMP: "bmp",
   /** TIFF format. */
@@ -1531,6 +1733,7 @@ var Dcmj2pnmOutputFormat = {
 var OUTPUT_FORMAT_FLAGS = {
   pnm: "+op",
   png: "+on",
+  png16: "+on2",
   bmp: "+ob",
   tiff: "+ot",
   jpeg: "+oj"
@@ -1538,17 +1741,32 @@ var OUTPUT_FORMAT_FLAGS = {
 var Dcmj2pnmOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  outputFormat: z.enum(["pnm", "png", "bmp", "tiff", "jpeg"]).optional(),
-  frame: z.number().int().min(0).max(65535).optional()
-}).strict().optional();
-function buildArgs17(inputPath, outputPath, options) {
+  outputFormat: z.enum(["pnm", "png", "png16", "bmp", "tiff", "jpeg"]).optional(),
+  frame: z.number().int().min(0).max(65535).optional(),
+  windowCenter: z.number().optional(),
+  windowWidth: z.number().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
+}).strict().refine((data) => data?.windowCenter === void 0 === (data?.windowWidth === void 0), {
+  message: "windowCenter and windowWidth must be provided together"
+}).optional();
+var VERBOSITY_FLAGS14 = { verbose: "-v", debug: "-d" };
+function pushWindowArgs(args, options) {
+  if (options?.windowCenter !== void 0 && options?.windowWidth !== void 0) {
+    args.push("+Wl", String(options.windowCenter), String(options.windowWidth));
+  }
+}
+function buildArgs25(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS14[options.verbosity]);
+  }
   if (options?.outputFormat !== void 0) {
     args.push(OUTPUT_FORMAT_FLAGS[options.outputFormat]);
   }
   if (options?.frame !== void 0) {
     args.push("+F", String(options.frame));
   }
+  pushWindowArgs(args, options);
   args.push(inputPath, outputPath);
   return args;
 }
@@ -1557,11 +1775,12 @@ async function dcmj2pnm(inputPath, outputPath, options) {
   if (!validation.success) {
     return err(createValidationError("dcmj2pnm", validation.error));
   }
-  const binaryResult = resolveBinary("dcmj2pnm");
+  const dcm2imgResult = resolveBinary("dcm2img");
+  const binaryResult = dcm2imgResult.ok ? dcm2imgResult : resolveBinary("dcmj2pnm");
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs17(inputPath, outputPath, options);
+  const args = buildArgs25(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1580,6 +1799,8 @@ var Dcm2pnmOutputFormat = {
   PNM: "pnm",
   /** PNG format. */
   PNG: "png",
+  /** 16-bit PNG format. */
+  PNG_16BIT: "png16",
   /** BMP format. */
   BMP: "bmp",
   /** TIFF format. */
@@ -1588,23 +1809,39 @@ var Dcm2pnmOutputFormat = {
 var DCM2PNM_FORMAT_FLAGS = {
   pnm: "+op",
   png: "+on",
+  png16: "+on2",
   bmp: "+ob",
   tiff: "+ot"
 };
 var Dcm2pnmOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  outputFormat: z.enum(["pnm", "png", "bmp", "tiff"]).optional(),
-  frame: z.number().int().min(0).max(65535).optional()
-}).strict().optional();
-function buildArgs18(inputPath, outputPath, options) {
+  outputFormat: z.enum(["pnm", "png", "png16", "bmp", "tiff"]).optional(),
+  frame: z.number().int().min(0).max(65535).optional(),
+  windowCenter: z.number().optional(),
+  windowWidth: z.number().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
+}).strict().refine((data) => data?.windowCenter === void 0 === (data?.windowWidth === void 0), {
+  message: "windowCenter and windowWidth must be provided together"
+}).optional();
+var VERBOSITY_FLAGS15 = { verbose: "-v", debug: "-d" };
+function pushWindowArgs2(args, options) {
+  if (options?.windowCenter !== void 0 && options?.windowWidth !== void 0) {
+    args.push("+Wl", String(options.windowCenter), String(options.windowWidth));
+  }
+}
+function buildArgs26(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS15[options.verbosity]);
+  }
   if (options?.outputFormat !== void 0) {
     args.push(DCM2PNM_FORMAT_FLAGS[options.outputFormat]);
   }
   if (options?.frame !== void 0) {
     args.push("+F", String(options.frame));
   }
+  pushWindowArgs2(args, options);
   args.push(inputPath, outputPath);
   return args;
 }
@@ -1613,11 +1850,12 @@ async function dcm2pnm(inputPath, outputPath, options) {
   if (!validation.success) {
     return err(createValidationError("dcm2pnm", validation.error));
   }
-  const binaryResult = resolveBinary("dcm2pnm");
+  const dcm2imgResult = resolveBinary("dcm2img");
+  const binaryResult = dcm2imgResult.ok ? dcm2imgResult : resolveBinary("dcm2pnm");
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs18(inputPath, outputPath, options);
+  const args = buildArgs26(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1637,10 +1875,11 @@ var DcmscaleOptionsSchema = z.object({
   xFactor: z.number().positive().max(100).optional(),
   yFactor: z.number().positive().max(100).optional(),
   xSize: z.number().int().positive().optional(),
-  ySize: z.number().int().positive().optional()
+  ySize: z.number().int().positive().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs19(inputPath, outputPath, options) {
-  const args = [];
+var VERBOSITY_FLAGS16 = { verbose: "-v", debug: "-d" };
+function pushScalingArgs(args, options) {
   if (options?.xFactor !== void 0) {
     args.push("+Sxf", String(options.xFactor));
   }
@@ -1653,6 +1892,13 @@ function buildArgs19(inputPath, outputPath, options) {
   if (options?.ySize !== void 0) {
     args.push("+Syv", String(options.ySize));
   }
+}
+function buildArgs27(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS16[options.verbosity]);
+  }
+  pushScalingArgs(args, options);
   args.push(inputPath, outputPath);
   return args;
 }
@@ -1665,7 +1911,7 @@ async function dcmscale(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs19(inputPath, outputPath, options);
+  const args = buildArgs27(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1683,10 +1929,16 @@ var DcmquantOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
   colors: z.number().int().min(2).max(65536).optional(),
-  frame: z.number().int().min(0).max(65535).optional()
+  frame: z.number().int().min(0).max(65535).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs20(inputPath, outputPath, options) {
+function buildArgs28(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.colors !== void 0) {
     args.push("+pc", String(options.colors));
   }
@@ -1705,7 +1957,7 @@ async function dcmquant(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs20(inputPath, outputPath, options);
+  const args = buildArgs28(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1725,10 +1977,11 @@ var DcmdspfnOptionsSchema = z.object({
   monitorFile: z.string().min(1).optional(),
   cameraFile: z.string().min(1).optional(),
   printerFile: z.string().min(1).optional(),
-  ambientLight: z.number().positive().optional()
+  ambientLight: z.number().positive().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs21(options) {
-  const args = [];
+var VERBOSITY_FLAGS17 = { verbose: "-v", debug: "-d" };
+function pushDeviceArgs(args, options) {
   if (options?.monitorFile !== void 0) {
     args.push("+Im", options.monitorFile);
   }
@@ -1741,6 +1994,13 @@ function buildArgs21(options) {
   if (options?.ambientLight !== void 0) {
     args.push("+Ca", String(options.ambientLight));
   }
+}
+function buildArgs29(options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS17[options.verbosity]);
+  }
+  pushDeviceArgs(args, options);
   return args;
 }
 async function dcmdspfn(options) {
@@ -1752,7 +2012,7 @@ async function dcmdspfn(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs21(options);
+  const args = buildArgs29(options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1768,8 +2028,19 @@ async function dcmdspfn(options) {
 }
 var Dcod2lumOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+function buildArgs30(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
+  args.push(inputPath, outputPath);
+  return args;
+}
 async function dcod2lum(inputPath, outputPath, options) {
   const validation = Dcod2lumOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -1779,7 +2050,7 @@ async function dcod2lum(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath, outputPath];
+  const args = buildArgs30(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1796,10 +2067,16 @@ async function dcod2lum(inputPath, outputPath, options) {
 var DconvlumOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  ambientLight: z.number().positive().optional()
+  ambientLight: z.number().positive().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs22(inputPath, outputPath, options) {
+function buildArgs31(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.ambientLight !== void 0) {
     args.push("+Ca", String(options.ambientLight));
   }
@@ -1815,7 +2092,7 @@ async function dconvlum(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs22(inputPath, outputPath, options);
+  const args = buildArgs31(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1835,10 +2112,42 @@ var EchoscuOptionsSchema = z.object({
   host: z.string().min(1),
   port: z.number().int().min(1).max(65535),
   callingAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
-  calledAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional()
+  calledAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional(),
+  maxPduReceive: z.number().int().min(4096).max(131072).optional(),
+  maxPduSend: z.number().int().min(4096).max(131072).optional(),
+  associationTimeout: z.number().int().positive().optional(),
+  acseTimeout: z.number().int().positive().optional(),
+  dimseTimeout: z.number().int().positive().optional(),
+  noHostnameLookup: z.boolean().optional()
 }).strict();
-function buildArgs23(options) {
+var VERBOSITY_FLAGS18 = { verbose: "-v", debug: "-d" };
+function pushNetworkArgs(args, options) {
+  if (options.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS18[options.verbosity]);
+  }
+  if (options.maxPduReceive !== void 0) {
+    args.push("--max-pdu", String(options.maxPduReceive));
+  }
+  if (options.maxPduSend !== void 0) {
+    args.push("--max-send-pdu", String(options.maxPduSend));
+  }
+  if (options.associationTimeout !== void 0) {
+    args.push("-to", String(options.associationTimeout));
+  }
+  if (options.acseTimeout !== void 0) {
+    args.push("-ta", String(options.acseTimeout));
+  }
+  if (options.dimseTimeout !== void 0) {
+    args.push("-td", String(options.dimseTimeout));
+  }
+  if (options.noHostnameLookup === true) {
+    args.push("-nh");
+  }
+}
+function buildArgs32(options) {
   const args = [];
+  pushNetworkArgs(args, options);
   if (options.callingAETitle !== void 0) {
     args.push("-aet", options.callingAETitle);
   }
@@ -1857,7 +2166,7 @@ async function echoscu(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs23(options);
+  const args = buildArgs32(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1871,6 +2180,7 @@ async function echoscu(options) {
   }
   return ok({ success: true, stderr: result.value.stderr });
 }
+var VERBOSITY_FLAGS19 = { verbose: "-v", debug: "-d" };
 var DcmsendOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
@@ -1879,16 +2189,51 @@ var DcmsendOptionsSchema = z.object({
   files: z.array(z.string().min(1).refine(isSafePath, { message: "path traversal detected in file path" })).min(1),
   callingAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
   calledAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
-  scanDirectory: z.boolean().optional()
+  scanDirectory: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional(),
+  noUidChecks: z.boolean().optional(),
+  maxPduReceive: z.number().int().min(4096).max(131072).optional(),
+  maxPduSend: z.number().int().min(4096).max(131072).optional(),
+  noHostnameLookup: z.boolean().optional(),
+  associationTimeout: z.number().int().positive().optional(),
+  acseTimeout: z.number().int().positive().optional(),
+  dimseTimeout: z.number().int().positive().optional()
 }).strict();
-function buildArgs24(options) {
-  const args = [];
+function pushNetworkArgs2(args, options) {
   if (options.callingAETitle !== void 0) {
     args.push("-aet", options.callingAETitle);
   }
   if (options.calledAETitle !== void 0) {
     args.push("-aec", options.calledAETitle);
   }
+  if (options.noUidChecks === true) {
+    args.push("--no-uid-checks");
+  }
+  if (options.maxPduReceive !== void 0) {
+    args.push("--max-pdu", String(options.maxPduReceive));
+  }
+  if (options.maxPduSend !== void 0) {
+    args.push("--max-send-pdu", String(options.maxPduSend));
+  }
+  if (options.noHostnameLookup === true) {
+    args.push("-nh");
+  }
+  if (options.associationTimeout !== void 0) {
+    args.push("-to", String(options.associationTimeout));
+  }
+  if (options.acseTimeout !== void 0) {
+    args.push("-ta", String(options.acseTimeout));
+  }
+  if (options.dimseTimeout !== void 0) {
+    args.push("-td", String(options.dimseTimeout));
+  }
+}
+function buildArgs33(options) {
+  const args = [];
+  if (options.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS19[options.verbosity]);
+  }
+  pushNetworkArgs2(args, options);
   if (options.scanDirectory === true) {
     args.push("--scan-directories");
   }
@@ -1905,7 +2250,7 @@ async function dcmsend(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs24(options);
+  const args = buildArgs33(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -1917,7 +2262,7 @@ async function dcmsend(options) {
   if (result.value.exitCode !== 0) {
     return err(createToolError("dcmsend", args, result.value.exitCode, result.value.stderr));
   }
-  return ok({ success: true, stderr: result.value.stderr });
+  return ok({ success: true, stdout: result.value.stdout, stderr: result.value.stderr });
 }
 var ProposedTransferSyntax = {
   UNCOMPRESSED: "uncompressed",
@@ -1955,6 +2300,14 @@ var StorescuOptionsSchema = z.object({
   calledAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
   scanDirectories: z.boolean().optional(),
   recurse: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional(),
+  maxPduReceive: z.number().int().min(4096).max(131072).optional(),
+  maxPduSend: z.number().int().min(4096).max(131072).optional(),
+  associationTimeout: z.number().int().positive().optional(),
+  acseTimeout: z.number().int().positive().optional(),
+  dimseTimeout: z.number().int().positive().optional(),
+  noHostnameLookup: z.boolean().optional(),
+  noUidChecks: z.boolean().optional(),
   proposedTransferSyntax: z.enum([
     "uncompressed",
     "littleEndian",
@@ -1969,8 +2322,36 @@ var StorescuOptionsSchema = z.object({
     "jlsLossy"
   ]).optional()
 }).strict();
-function buildArgs25(options) {
+var VERBOSITY_FLAGS20 = { verbose: "-v", debug: "-d" };
+function pushNetworkArgs3(args, options) {
+  if (options.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS20[options.verbosity]);
+  }
+  if (options.maxPduReceive !== void 0) {
+    args.push("--max-pdu", String(options.maxPduReceive));
+  }
+  if (options.maxPduSend !== void 0) {
+    args.push("--max-send-pdu", String(options.maxPduSend));
+  }
+  if (options.associationTimeout !== void 0) {
+    args.push("-to", String(options.associationTimeout));
+  }
+  if (options.acseTimeout !== void 0) {
+    args.push("-ta", String(options.acseTimeout));
+  }
+  if (options.dimseTimeout !== void 0) {
+    args.push("-td", String(options.dimseTimeout));
+  }
+  if (options.noHostnameLookup === true) {
+    args.push("-nh");
+  }
+}
+function buildArgs34(options) {
   const args = [];
+  pushNetworkArgs3(args, options);
+  if (options.noUidChecks === true) {
+    args.push("--no-uid-checks");
+  }
   if (options.callingAETitle !== void 0) {
     args.push("-aet", options.callingAETitle);
   }
@@ -1999,7 +2380,7 @@ async function storescu(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs25(options);
+  const args = buildArgs34(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2033,12 +2414,44 @@ var FindscuOptionsSchema = z.object({
   queryModel: z.enum(["worklist", "patient", "study"]).optional(),
   keys: z.array(z.string().min(1).refine(isValidDicomKey, { message: "invalid DICOM query key format (expected XXXX,XXXX[=value])" })).optional(),
   extract: z.boolean().optional(),
-  outputDirectory: z.string().min(1).refine(isSafePath, { message: "path traversal detected in outputDirectory" }).optional()
+  outputDirectory: z.string().min(1).refine(isSafePath, { message: "path traversal detected in outputDirectory" }).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional(),
+  maxPduReceive: z.number().int().min(4096).max(131072).optional(),
+  maxPduSend: z.number().int().min(4096).max(131072).optional(),
+  associationTimeout: z.number().int().positive().optional(),
+  acseTimeout: z.number().int().positive().optional(),
+  dimseTimeout: z.number().int().positive().optional(),
+  noHostnameLookup: z.boolean().optional()
 }).strict().refine((data) => data.extract !== true || data.outputDirectory !== void 0, {
   message: "outputDirectory is required when extract is true"
 });
-function buildArgs26(options) {
+var VERBOSITY_FLAGS21 = { verbose: "-v", debug: "-d" };
+function pushNetworkArgs4(args, options) {
+  if (options.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS21[options.verbosity]);
+  }
+  if (options.maxPduReceive !== void 0) {
+    args.push("--max-pdu", String(options.maxPduReceive));
+  }
+  if (options.maxPduSend !== void 0) {
+    args.push("--max-send-pdu", String(options.maxPduSend));
+  }
+  if (options.associationTimeout !== void 0) {
+    args.push("-to", String(options.associationTimeout));
+  }
+  if (options.acseTimeout !== void 0) {
+    args.push("-ta", String(options.acseTimeout));
+  }
+  if (options.dimseTimeout !== void 0) {
+    args.push("-td", String(options.dimseTimeout));
+  }
+  if (options.noHostnameLookup === true) {
+    args.push("-nh");
+  }
+}
+function buildArgs35(options) {
   const args = [];
+  pushNetworkArgs4(args, options);
   if (options.callingAETitle !== void 0) {
     args.push("-aet", options.callingAETitle);
   }
@@ -2071,7 +2484,7 @@ async function findscu(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs26(options);
+  const args = buildArgs35(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2103,10 +2516,42 @@ var MovescuOptionsSchema = z.object({
   queryModel: z.enum(["patient", "study"]).optional(),
   keys: z.array(z.string().min(1).refine(isValidDicomKey, { message: "invalid DICOM query key format (expected XXXX,XXXX[=value])" })).optional(),
   moveDestination: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
-  outputDirectory: z.string().min(1).refine(isSafePath, { message: "path traversal detected in outputDirectory" }).optional()
+  outputDirectory: z.string().min(1).refine(isSafePath, { message: "path traversal detected in outputDirectory" }).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional(),
+  maxPduReceive: z.number().int().min(4096).max(131072).optional(),
+  maxPduSend: z.number().int().min(4096).max(131072).optional(),
+  associationTimeout: z.number().int().positive().optional(),
+  acseTimeout: z.number().int().positive().optional(),
+  dimseTimeout: z.number().int().positive().optional(),
+  noHostnameLookup: z.boolean().optional()
 }).strict();
-function buildArgs27(options) {
+var VERBOSITY_FLAGS22 = { verbose: "-v", debug: "-d" };
+function pushNetworkArgs5(args, options) {
+  if (options.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS22[options.verbosity]);
+  }
+  if (options.maxPduReceive !== void 0) {
+    args.push("--max-pdu", String(options.maxPduReceive));
+  }
+  if (options.maxPduSend !== void 0) {
+    args.push("--max-send-pdu", String(options.maxPduSend));
+  }
+  if (options.associationTimeout !== void 0) {
+    args.push("-to", String(options.associationTimeout));
+  }
+  if (options.acseTimeout !== void 0) {
+    args.push("-ta", String(options.acseTimeout));
+  }
+  if (options.dimseTimeout !== void 0) {
+    args.push("-td", String(options.dimseTimeout));
+  }
+  if (options.noHostnameLookup === true) {
+    args.push("-nh");
+  }
+}
+function buildArgs36(options) {
   const args = [];
+  pushNetworkArgs5(args, options);
   if (options.callingAETitle !== void 0) {
     args.push("-aet", options.callingAETitle);
   }
@@ -2139,7 +2584,7 @@ async function movescu(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs27(options);
+  const args = buildArgs36(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2170,10 +2615,42 @@ var GetscuOptionsSchema = z.object({
   calledAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
   queryModel: z.enum(["patient", "study"]).optional(),
   keys: z.array(z.string().min(1).refine(isValidDicomKey, { message: "invalid DICOM query key format (expected XXXX,XXXX[=value])" })).optional(),
-  outputDirectory: z.string().min(1).refine(isSafePath, { message: "path traversal detected in outputDirectory" }).optional()
+  outputDirectory: z.string().min(1).refine(isSafePath, { message: "path traversal detected in outputDirectory" }).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional(),
+  maxPduReceive: z.number().int().min(4096).max(131072).optional(),
+  maxPduSend: z.number().int().min(4096).max(131072).optional(),
+  associationTimeout: z.number().int().positive().optional(),
+  acseTimeout: z.number().int().positive().optional(),
+  dimseTimeout: z.number().int().positive().optional(),
+  noHostnameLookup: z.boolean().optional()
 }).strict();
-function buildArgs28(options) {
+var VERBOSITY_FLAGS23 = { verbose: "-v", debug: "-d" };
+function pushNetworkArgs6(args, options) {
+  if (options.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS23[options.verbosity]);
+  }
+  if (options.maxPduReceive !== void 0) {
+    args.push("--max-pdu", String(options.maxPduReceive));
+  }
+  if (options.maxPduSend !== void 0) {
+    args.push("--max-send-pdu", String(options.maxPduSend));
+  }
+  if (options.associationTimeout !== void 0) {
+    args.push("-to", String(options.associationTimeout));
+  }
+  if (options.acseTimeout !== void 0) {
+    args.push("-ta", String(options.acseTimeout));
+  }
+  if (options.dimseTimeout !== void 0) {
+    args.push("-td", String(options.dimseTimeout));
+  }
+  if (options.noHostnameLookup === true) {
+    args.push("-nh");
+  }
+}
+function buildArgs37(options) {
   const args = [];
+  pushNetworkArgs6(args, options);
   if (options.callingAETitle !== void 0) {
     args.push("-aet", options.callingAETitle);
   }
@@ -2203,7 +2680,7 @@ async function getscu(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs28(options);
+  const args = buildArgs37(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2223,10 +2700,42 @@ var TermscuOptionsSchema = z.object({
   host: z.string().min(1),
   port: z.number().int().min(1).max(65535),
   callingAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
-  calledAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional()
+  calledAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional(),
+  maxPduReceive: z.number().int().min(4096).max(131072).optional(),
+  maxPduSend: z.number().int().min(4096).max(131072).optional(),
+  associationTimeout: z.number().int().positive().optional(),
+  acseTimeout: z.number().int().positive().optional(),
+  dimseTimeout: z.number().int().positive().optional(),
+  noHostnameLookup: z.boolean().optional()
 }).strict();
-function buildArgs29(options) {
+var VERBOSITY_FLAGS24 = { verbose: "-v", debug: "-d" };
+function pushNetworkArgs7(args, options) {
+  if (options.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS24[options.verbosity]);
+  }
+  if (options.maxPduReceive !== void 0) {
+    args.push("--max-pdu", String(options.maxPduReceive));
+  }
+  if (options.maxPduSend !== void 0) {
+    args.push("--max-send-pdu", String(options.maxPduSend));
+  }
+  if (options.associationTimeout !== void 0) {
+    args.push("-to", String(options.associationTimeout));
+  }
+  if (options.acseTimeout !== void 0) {
+    args.push("-ta", String(options.acseTimeout));
+  }
+  if (options.dimseTimeout !== void 0) {
+    args.push("-td", String(options.dimseTimeout));
+  }
+  if (options.noHostnameLookup === true) {
+    args.push("-nh");
+  }
+}
+function buildArgs38(options) {
   const args = [];
+  pushNetworkArgs7(args, options);
   if (options.callingAETitle !== void 0) {
     args.push("-aet", options.callingAETitle);
   }
@@ -2245,7 +2754,7 @@ async function termscu(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs29(options);
+  const args = buildArgs38(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2259,15 +2768,17 @@ async function termscu(options) {
   }
   return ok({ success: true, stderr: result.value.stderr });
 }
+var VERBOSITY_FLAGS25 = { verbose: "-v", debug: "-d" };
 var DsrdumpOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
   printFilename: z.boolean().optional(),
   printLong: z.boolean().optional(),
-  printCodes: z.boolean().optional()
+  printCodes: z.boolean().optional(),
+  charsetAssume: z.string().min(1).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs30(inputPath, options) {
-  const args = [];
+function pushDisplayArgs2(args, options) {
   if (options?.printFilename === true) {
     args.push("+Pf");
   }
@@ -2277,6 +2788,16 @@ function buildArgs30(inputPath, options) {
   if (options?.printCodes === true) {
     args.push("+Pc");
   }
+  if (options?.charsetAssume !== void 0) {
+    args.push("+Ca", options.charsetAssume);
+  }
+}
+function buildArgs39(inputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS25[options.verbosity]);
+  }
+  pushDisplayArgs2(args, options);
   args.push(inputPath);
   return args;
 }
@@ -2289,7 +2810,7 @@ async function dsrdump(inputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs30(inputPath, options);
+  const args = buildArgs39(inputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2303,20 +2824,29 @@ async function dsrdump(inputPath, options) {
   }
   return ok({ text: result.value.stdout });
 }
+var VERBOSITY_FLAGS26 = { verbose: "-v", debug: "-d" };
 var Dsr2xmlOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
   useNamespace: z.boolean().optional(),
-  addSchemaRef: z.boolean().optional()
+  addSchemaRef: z.boolean().optional(),
+  charsetAssume: z.string().min(1).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs31(inputPath, options) {
+function buildArgs40(inputPath, options) {
   const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS26[options.verbosity]);
+  }
   if (options?.useNamespace === true) {
     args.push("+Xn");
   }
   if (options?.addSchemaRef === true) {
     args.push("+Xs");
   }
+  if (options?.charsetAssume !== void 0) {
+    args.push("+Ca", options.charsetAssume);
+  }
   args.push(inputPath);
   return args;
 }
@@ -2329,7 +2859,7 @@ async function dsr2xml(inputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs31(inputPath, options);
+  const args = buildArgs40(inputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2347,10 +2877,16 @@ var Xml2dsrOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
   generateNewUIDs: z.boolean().optional(),
-  validateDocument: z.boolean().optional()
+  validateDocument: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs32(inputPath, outputPath, options) {
+function buildArgs41(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.generateNewUIDs === true) {
     args.push("+Ug");
   }
@@ -2369,7 +2905,7 @@ async function xml2dsr(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs32(inputPath, outputPath, options);
+  const args = buildArgs41(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2386,10 +2922,16 @@ async function xml2dsr(inputPath, outputPath, options) {
 var DrtdumpOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  printFilename: z.boolean().optional()
+  printFilename: z.boolean().optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs33(inputPath, options) {
+function buildArgs42(inputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.printFilename === true) {
     args.push("+Pf");
   }
@@ -2405,7 +2947,7 @@ async function drtdump(inputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs33(inputPath, options);
+  const args = buildArgs42(inputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2421,8 +2963,18 @@ async function drtdump(inputPath, options) {
 }
 var DcmpsmkOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+var VERBOSITY_FLAGS27 = { verbose: "-v", debug: "-d" };
+function buildArgs43(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS27[options.verbosity]);
+  }
+  args.push(inputPath, outputPath);
+  return args;
+}
 async function dcmpsmk(inputPath, outputPath, options) {
   const validation = DcmpsmkOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -2432,7 +2984,7 @@ async function dcmpsmk(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath, outputPath];
+  const args = buildArgs43(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2448,8 +3000,18 @@ async function dcmpsmk(inputPath, outputPath, options) {
 }
 var DcmpschkOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+var VERBOSITY_FLAGS28 = { verbose: "-v", debug: "-d" };
+function buildArgs44(inputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS28[options.verbosity]);
+  }
+  args.push(inputPath);
+  return args;
+}
 async function dcmpschk(inputPath, options) {
   const validation = DcmpschkOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -2459,7 +3021,7 @@ async function dcmpschk(inputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath];
+  const args = buildArgs44(inputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2480,10 +3042,16 @@ var DcmprscuOptionsSchema = z.object({
   port: z.number().int().min(1).max(65535),
   callingAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
   calledAETitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
-  configFile: z.string().min(1).optional()
+  configFile: z.string().min(1).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict();
-function buildArgs34(options) {
+function buildArgs45(options) {
   const args = [];
+  if (options.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options.callingAETitle !== void 0) {
     args.push("-aet", options.callingAETitle);
   }
@@ -2505,7 +3073,7 @@ async function dcmprscu(options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs34(options);
+  const args = buildArgs45(options);
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2522,10 +3090,16 @@ async function dcmprscu(options) {
 var DcmpsprtOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
-  configFile: z.string().min(1).optional()
+  configFile: z.string().min(1).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs35(inputPath, options) {
+function buildArgs46(inputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.configFile !== void 0) {
     args.push("-c", options.configFile);
   }
@@ -2541,7 +3115,7 @@ async function dcmpsprt(inputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs35(inputPath, options);
+  const args = buildArgs46(inputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2559,10 +3133,16 @@ var Dcmp2pgmOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
   presentationState: z.string().min(1).optional(),
-  frame: z.number().int().min(0).max(65535).optional()
+  frame: z.number().int().min(0).max(65535).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs36(inputPath, outputPath, options) {
+function buildArgs47(inputPath, outputPath, options) {
   const args = [];
+  if (options?.verbosity === "verbose") {
+    args.push("-v");
+  } else if (options?.verbosity === "debug") {
+    args.push("-d");
+  }
   if (options?.presentationState !== void 0) {
     args.push("-p", options.presentationState);
   }
@@ -2581,7 +3161,7 @@ async function dcmp2pgm(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs36(inputPath, outputPath, options);
+  const args = buildArgs47(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2597,8 +3177,18 @@ async function dcmp2pgm(inputPath, outputPath, options) {
 }
 var DcmmkcrvOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
-  signal: z.instanceof(AbortSignal).optional()
+  signal: z.instanceof(AbortSignal).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
+var VERBOSITY_FLAGS29 = { verbose: "-v", debug: "-d" };
+function buildArgs48(inputPath, outputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS29[options.verbosity]);
+  }
+  args.push(inputPath, outputPath);
+  return args;
+}
 async function dcmmkcrv(inputPath, outputPath, options) {
   const validation = DcmmkcrvOptionsSchema.safeParse(options);
   if (!validation.success) {
@@ -2608,7 +3198,7 @@ async function dcmmkcrv(inputPath, outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = [inputPath, outputPath];
+  const args = buildArgs48(inputPath, outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,
@@ -2635,16 +3225,17 @@ var LUT_TYPE_FLAGS = {
   presentation: "+Tp",
   voi: "+Tv"
 };
+var VERBOSITY_FLAGS30 = { verbose: "-v", debug: "-d" };
 var DcmmklutOptionsSchema = z.object({
   timeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional(),
   lutType: z.enum(["modality", "presentation", "voi"]).optional(),
   gamma: z.number().positive().optional(),
   entries: z.number().int().positive().optional(),
-  bits: z.number().int().min(8).max(16).optional()
+  bits: z.number().int().min(8).max(16).optional(),
+  verbosity: z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
-function buildArgs37(outputPath, options) {
-  const args = [];
+function pushLutArgs(args, options) {
   if (options?.lutType !== void 0) {
     args.push(LUT_TYPE_FLAGS[options.lutType]);
   }
@@ -2657,6 +3248,13 @@ function buildArgs37(outputPath, options) {
   if (options?.bits !== void 0) {
     args.push("-b", String(options.bits));
   }
+}
+function buildArgs49(outputPath, options) {
+  const args = [];
+  if (options?.verbosity !== void 0) {
+    args.push(VERBOSITY_FLAGS30[options.verbosity]);
+  }
+  pushLutArgs(args, options);
   args.push(outputPath);
   return args;
 }
@@ -2669,7 +3267,7 @@ async function dcmmklut(outputPath, options) {
   if (!binaryResult.ok) {
     return err(binaryResult.error);
   }
-  const args = buildArgs37(outputPath, options);
+  const args = buildArgs49(outputPath, options);
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const result = await execCommand(binaryResult.value, args, {
     timeoutMs,