@ubercode/dcmtk 0.13.2 → 0.15.0

package/dist/{index-Bve4fMIh.d.cts → index-CtqMUrjP.d.cts}

@@ -1777,6 +1777,8 @@ declare class DicomReceiver extends EventEmitter<DicomReceiverEventMap> {
     private startTcpProxy;
     /** Closes the TCP proxy server. */
     private closeTcpProxy;
+    /** Drains in-flight file and instance work on all non-idle workers, with a 5s safety timeout. */
+    private drainAllWorkers;
     /** Routes an incoming connection to an idle worker. */
     private handleConnection;
     /** Finds an idle worker, retrying up to connectionTimeoutMs. */

package/dist/{index-CZiFWENk.d.ts → index-D7nnTY1R.d.ts}

@@ -1777,6 +1777,8 @@ declare class DicomReceiver extends EventEmitter<DicomReceiverEventMap> {
     private startTcpProxy;
     /** Closes the TCP proxy server. */
     private closeTcpProxy;
+    /** Drains in-flight file and instance work on all non-idle workers, with a 5s safety timeout. */
+    private drainAllWorkers;
     /** Routes an incoming connection to an idle worker. */
     private handleConnection;
     /** Finds an idle worker, retrying up to connectionTimeoutMs. */

package/dist/index.cjs

@@ -713,6 +713,51 @@ var LineParser = class extends events.EventEmitter {
   }
 };
 
+// src/tools/_toolError.ts
+var MAX_ARGS_LENGTH = 200;
+var MAX_STDERR_LENGTH = 500;
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.substring(0, maxLength)}...`;
+}
+var ToolExecutionError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    __publicField(this, "stdout");
+    __publicField(this, "stderr");
+    __publicField(this, "exitCode");
+    this.name = "ToolExecutionError";
+    this.stdout = details.stdout;
+    this.stderr = details.stderr;
+    this.exitCode = details.exitCode;
+  }
+};
+function createToolError(toolName, args, exitCode, stderr8, stdout = "") {
+  const argsStr = truncate(args.join(" "), MAX_ARGS_LENGTH);
+  const stderrStr = truncate(stderr8.trim(), MAX_STDERR_LENGTH);
+  const parts = [`${toolName} failed (exit code ${String(exitCode)})`];
+  if (argsStr.length > 0) {
+    parts.push(`args: ${argsStr}`);
+  }
+  if (stderrStr.length > 0) {
+    parts.push(`stderr: ${stderrStr}`);
+  }
+  return new ToolExecutionError(parts.join(" | "), { stdout, stderr: stderr8, exitCode });
+}
+function createValidationError(toolName, zodError) {
+  const parts = [];
+  for (let i = 0; i < zodError.issues.length; i++) {
+    const issue = zodError.issues[i];
+    if (issue === void 0) continue;
+    const path2 = issue.path.length > 0 ? issue.path.map(String).join(".") : "(root)";
+    parts.push(`${path2}: ${issue.message}`);
+  }
+  const detail = parts.length > 0 ? parts.join("; ") : "unknown validation error";
+  return new Error(`${toolName}: invalid options \u2014 ${detail}`);
+}
+
 // src/dicom/vr.ts
 var VR = {
   /** Application Entity — 16 bytes max, leading/trailing spaces significant */
@@ -31136,39 +31181,6 @@ function resolveBinary(toolName) {
   return ok(path.join(pathResult.value, binaryName2));
 }
 
-// src/tools/_toolError.ts
-var MAX_ARGS_LENGTH = 200;
-var MAX_STDERR_LENGTH = 500;
-function truncate(value, maxLength) {
-  if (value.length <= maxLength) {
-    return value;
-  }
-  return `${value.substring(0, maxLength)}...`;
-}
-function createToolError(toolName, args, exitCode, stderr8) {
-  const argsStr = truncate(args.join(" "), MAX_ARGS_LENGTH);
-  const stderrStr = truncate(stderr8.trim(), MAX_STDERR_LENGTH);
-  const parts = [`${toolName} failed (exit code ${String(exitCode)})`];
-  if (argsStr.length > 0) {
-    parts.push(`args: ${argsStr}`);
-  }
-  if (stderrStr.length > 0) {
-    parts.push(`stderr: ${stderrStr}`);
-  }
-  return new Error(parts.join(" | "));
-}
-function createValidationError(toolName, zodError) {
-  const parts = [];
-  for (let i = 0; i < zodError.issues.length; i++) {
-    const issue = zodError.issues[i];
-    if (issue === void 0) continue;
-    const path2 = issue.path.length > 0 ? issue.path.map(String).join(".") : "(root)";
-    parts.push(`${path2}: ${issue.message}`);
-  }
-  const detail = parts.length > 0 ? parts.join("; ") : "unknown validation error";
-  return new Error(`${toolName}: invalid options \u2014 ${detail}`);
-}
-
 // src/tools/dcm2xml.ts
 var Dcm2xmlCharset = {
   /** Use UTF-8 encoding (default). */
@@ -31552,15 +31564,17 @@ async function dcm2json(inputPath, options) {
   }
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const signal = options?.signal;
+  const startTime = Date.now();
+  const remaining = () => Math.max(1e3, timeoutMs - (Date.now() - startTime));
   const verbosity = options?.verbosity;
   if (options?.directOnly === true) {
-    return tryDirectPath(inputPath, timeoutMs, signal, verbosity);
+    return tryDirectPath(inputPath, remaining(), signal, verbosity);
   }
-  const xmlResult = await tryXmlPath(inputPath, timeoutMs, signal, buildXmlOpts(options));
+  const xmlResult = await tryXmlPath(inputPath, remaining(), signal, buildXmlOpts(options));
   if (xmlResult.ok) {
     return xmlResult;
   }
-  return tryDirectPath(inputPath, timeoutMs, signal, verbosity);
+  return tryDirectPath(inputPath, remaining(), signal, verbosity);
 }
 var DcmdumpFormat = {
   /** Print standard DCMTK format. */
@@ -33288,7 +33302,7 @@ async function dcmsend(options) {
     return err(result.error);
   }
   if (result.value.exitCode !== 0) {
-    return err(createToolError("dcmsend", args, result.value.exitCode, result.value.stderr));
+    return err(createToolError("dcmsend", args, result.value.exitCode, result.value.stderr, result.value.stdout));
   }
   return ok({ success: true, stdout: result.value.stdout, stderr: result.value.stderr });
 }
@@ -33443,10 +33457,10 @@ async function storescu(options) {
     return err(result.error);
   }
   if (result.value.exitCode !== 0) {
-    return err(createToolError("storescu", args, result.value.exitCode, result.value.stderr));
+    return err(createToolError("storescu", args, result.value.exitCode, result.value.stderr, result.value.stdout));
   }
   if (DIMSE_ERROR_PATTERN.test(result.value.stderr)) {
-    return err(createToolError("storescu", args, 0, result.value.stderr));
+    return err(createToolError("storescu", args, 0, result.value.stderr, result.value.stdout));
   }
   return ok({ success: true, stdout: result.value.stdout, stderr: result.value.stderr });
 }
@@ -36517,7 +36531,7 @@ var Worker = class {
     this.port = port;
     this.tempDir = tempDir;
   }
-  /** Current worker state. */
+  /** Current worker state: idle (ready), busy (handling association), finalizing (draining). */
   get state() {
     return this._state;
   }
@@ -36549,6 +36563,10 @@ var Worker = class {
     this._instancesReceived = 0;
     this._instanceErrors = 0;
   }
+  /** Marks the worker as finalizing — still has valid context but cannot accept new connections. */
+  markFinalizing() {
+    this._state = "finalizing";
+  }
   /**
    * Returns the worker to idle. Context is intentionally preserved so that
    * late FILE_RECEIVED events (arriving in a subsequent pipe chunk after
@@ -36731,6 +36749,7 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
       this.options.signal.removeEventListener("abort", this.abortHandler);
     }
     await this.closeTcpProxy();
+    await this.drainAllWorkers();
     const stopPromises = [];
     for (const worker of this.workers.values()) {
       stopPromises.push(this.stopWorker(worker));
@@ -36899,6 +36918,18 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
       this.tcpServer.close(() => resolve());
     });
   }
+  /** Drains in-flight file and instance work on all non-idle workers, with a 5s safety timeout. */
+  async drainAllWorkers() {
+    const drainPromises = [];
+    for (const worker of this.workers.values()) {
+      if (worker.state !== "idle") {
+        drainPromises.push(worker.drainPendingFiles());
+        drainPromises.push(worker.drainInstancePending());
+      }
+    }
+    if (drainPromises.length === 0) return;
+    await Promise.race([Promise.all(drainPromises), promises.setTimeout(5e3)]);
+  }
   // -----------------------------------------------------------------------
   // Connection routing
   // -----------------------------------------------------------------------
@@ -36927,7 +36958,9 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     };
     worker.beginAssociation(ctx);
     this.pipeConnection(worker, remoteSocket);
-    void this.replenishPool();
+    void this.replenishPool().catch((e) => {
+      this.emit("error", { error: e instanceof Error ? e : new Error(String(e)) });
+    });
   }
   /** Finds an idle worker, retrying up to connectionTimeoutMs. */
   async findIdleWorker() {
@@ -37166,6 +37199,7 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
   /** Returns worker to idle pool on association complete, emits summary. */
   wireAssociationComplete(worker) {
     worker.dcmrecv.onAssociationComplete((data) => {
+      worker.markFinalizing();
       setImmediate(() => {
         void this.finalizeAssociation(worker, data);
       });
@@ -37319,8 +37353,14 @@ var SenderEngine = class {
     // Bucket state (bucket mode only)
     __publicField(this, "currentBucket", []);
     __publicField(this, "bucketTimer");
+    // Abort wiring: stopController fires on stop(); combinedSignal also fires
+    // when the externally provided config.signal aborts. Passed into the
+    // executor and into delayInterruptible so stop() unblocks promptly.
+    __publicField(this, "stopController", new AbortController());
+    __publicField(this, "combinedSignal");
     this.config = config;
     this.effectiveMaxAssociations = config.configuredMaxAssociations;
+    this.combinedSignal = combineSignals(this.stopController.signal, config.signal);
   }
   // -----------------------------------------------------------------------
   // Public API
@@ -37346,6 +37386,7 @@ var SenderEngine = class {
   async stop() {
     if (this.isStopped) return;
     this.isStopped = true;
+    this.stopController.abort();
     this.clearBucketTimer();
     this.rejectBucket(`${this.config.senderName}: sender stopped`);
     this.rejectQueue(`${this.config.senderName}: sender stopped`);
@@ -37462,18 +37503,48 @@ var SenderEngine = class {
       }
     };
   }
-  /** Flushes the current bucket: combines all files, dispatches as one send. */
+  /**
+   * Flushes the current bucket. Entries with the same bucketParamsKey merge
+   * into one underlying call; differing keys split into separate calls,
+   * preserving first-occurrence order. Each group emits its own
+   * BUCKET_FLUSHED. If the number of groups exceeds available capacity,
+   * the surplus is queued and drains as capacity frees.
+   */
   flushBucketInternal(reason) {
     if (this.currentBucket.length === 0) return;
     const entries = [...this.currentBucket];
     this.currentBucket = [];
-    const bucketEntry = this.mergeBucketEntries(entries);
-    this.config.emitters.emitBucketFlushed({ fileCount: bucketEntry.files.length, reason });
-    if (this.activeAssociations < this.effectiveMaxAssociations) {
-      void this.executeEntry(bucketEntry);
-    } else {
-      this.queue.push(bucketEntry);
+    const groups = this.groupBucketByParams(entries);
+    for (const group of groups) {
+      const bucketEntry = this.mergeBucketEntries(group);
+      this.config.emitters.emitBucketFlushed({ fileCount: bucketEntry.files.length, reason });
+      if (this.activeAssociations < this.effectiveMaxAssociations) {
+        void this.executeEntry(bucketEntry);
+      } else {
+        this.queue.push(bucketEntry);
+      }
+    }
+  }
+  /**
+   * Groups bucket entries by bucketParamsKey while preserving first-occurrence
+   * order. Without a key function, returns a single group containing every
+   * entry (current behavior for callers that don't vary binaryParams).
+   */
+  groupBucketByParams(entries) {
+    const keyFn = this.config.bucketParamsKey;
+    if (keyFn === void 0) return [entries.slice()];
+    const groups = /* @__PURE__ */ new Map();
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      const key = keyFn(entry.binaryParams);
+      let group = groups.get(key);
+      if (group === void 0) {
+        group = [];
+        groups.set(key, group);
+      }
+      group.push(entry);
     }
+    return Array.from(groups.values());
   }
   /** Resets the bucket flush timer. */
   resetBucketTimer() {
@@ -37515,25 +37586,33 @@ var SenderEngine = class {
   /** Attempts the binary call up to maxAttempts times. Returns undefined on success. */
   async attemptSend(entry, maxAttempts, startMs) {
     let lastError;
-    const lastOutput = { stdout: "", stderr: "" };
+    let lastOutput = { stdout: "", stderr: "" };
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       if (this.isStopped) {
-        this.activeAssociations--;
-        entry.resolve(err(new Error(`${this.config.senderName}: sender stopped`)));
-        return void 0;
+        return this.resolveStopped(entry);
       }
-      const result = await this.config.executor(entry.files, entry.timeoutMs, entry.binaryParams, this.config.signal);
-      if (result.ok) {
-        this.handleSendSuccess(entry, startMs, result.value);
+      const outcome = await this.config.executor(entry.files, entry.timeoutMs, entry.binaryParams, this.combinedSignal);
+      lastOutput = { stdout: outcome.stdout, stderr: outcome.stderr };
+      if (outcome.error === void 0) {
+        this.handleSendSuccess(entry, startMs, lastOutput);
         return void 0;
       }
-      lastError = result.error;
+      if (this.isStopped) {
+        return this.resolveStopped(entry);
+      }
+      lastError = outcome.error;
       if (attempt < maxAttempts - 1) {
-        await delay2(this.config.retryDelayMs * (attempt + 1));
+        await delayInterruptible(this.config.retryDelayMs * (attempt + 1), this.combinedSignal);
       }
     }
     return { error: lastError ?? new Error(`${this.config.senderName}: send failed`), output: lastOutput };
   }
+  /** Resolves the entry as stopped and decrements activeAssociations. Used from attemptSend. */
+  resolveStopped(entry) {
+    this.activeAssociations--;
+    entry.resolve(err(new Error(`${this.config.senderName}: sender stopped`)));
+    return void 0;
+  }
   /** Handles a successful send: updates state, emits event, resolves promise. */
   handleSendSuccess(entry, startMs, output) {
     this.activeAssociations--;
@@ -37639,11 +37718,41 @@ var SenderEngine = class {
     });
   }
 };
-function delay2(ms) {
+function delayInterruptible(ms, signal) {
+  if (signal.aborted) return Promise.resolve();
   return new Promise((resolve) => {
-    setTimeout(resolve, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal.addEventListener("abort", onAbort, { once: true });
   });
 }
+function combineSignals(primary, external) {
+  if (external === void 0) return primary;
+  if (primary.aborted) return primary;
+  if (external.aborted) {
+    const c = new AbortController();
+    c.abort(external.reason);
+    return c.signal;
+  }
+  const merged = new AbortController();
+  const onPrimary = () => {
+    merged.abort(primary.reason);
+    external.removeEventListener("abort", onExternal);
+  };
+  const onExternal = () => {
+    merged.abort(external.reason);
+    primary.removeEventListener("abort", onPrimary);
+  };
+  primary.addEventListener("abort", onPrimary, { once: true });
+  external.addEventListener("abort", onExternal, { once: true });
+  return merged.signal;
+}
 
 // src/senders/DicomSender.ts
 var DEFAULT_MAX_ASSOCIATIONS = 4;
@@ -37678,6 +37787,9 @@ var DicomSenderOptionsSchema = zod.z.object({
   required: zod.z.boolean().optional(),
   signal: zod.z.instanceof(AbortSignal).optional()
 }).strict();
+function storescuBucketKey(p) {
+  return JSON.stringify(p);
+}
 function createStorescuExecutor(options) {
   return async (files, timeoutMs, params, signal) => {
     const result = await storescu({
@@ -37699,8 +37811,13 @@ function createStorescuExecutor(options) {
       timeoutMs,
       signal
     });
-    if (!result.ok) return err(result.error);
-    return ok({ stdout: result.value.stdout, stderr: result.value.stderr });
+    if (!result.ok) {
+      const e = result.error;
+      const stdout = e instanceof ToolExecutionError ? e.stdout : "";
+      const stderr8 = e instanceof ToolExecutionError ? e.stderr : "";
+      return { stdout, stderr: stderr8, error: e };
+    }
+    return { stdout: result.value.stdout, stderr: result.value.stderr };
   };
 }
 function resolveConfig2(options) {
@@ -37757,6 +37874,7 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
       executor: createStorescuExecutor(options),
       signal: options.signal,
       senderName: "DicomSender",
+      bucketParamsKey: storescuBucketKey,
       emitters: {
         emitSendComplete: (data) => {
           senderRef.current.emit("SEND_COMPLETE", data);
@@ -37925,6 +38043,9 @@ var DicomSendOptionsSchema = zod.z.object({
   noUidChecks: zod.z.boolean().optional(),
   signal: zod.z.instanceof(AbortSignal).optional()
 }).strict();
+function dcmsendBucketKey(p) {
+  return JSON.stringify(p);
+}
 function createDcmsendExecutor(options) {
   return async (files, timeoutMs, params, signal) => {
     const result = await dcmsend({
@@ -37948,8 +38069,13 @@ function createDcmsendExecutor(options) {
       timeoutMs,
       signal
     });
-    if (!result.ok) return err(result.error);
-    return ok({ stdout: result.value.stdout, stderr: result.value.stderr });
+    if (!result.ok) {
+      const e = result.error;
+      const stdout = e instanceof ToolExecutionError ? e.stdout : "";
+      const stderr8 = e instanceof ToolExecutionError ? e.stderr : "";
+      return { stdout, stderr: stderr8, error: e };
+    }
+    return { stdout: result.value.stdout, stderr: result.value.stderr };
   };
 }
 function resolveConfig3(options) {
@@ -38006,6 +38132,7 @@ var DicomSend = class _DicomSend extends events.EventEmitter {
       executor: createDcmsendExecutor(options),
       signal: options.signal,
       senderName: "DicomSend",
+      bucketParamsKey: dcmsendBucketKey,
       emitters: {
         emitSendComplete: (data) => {
           senderRef.current.emit("SEND_COMPLETE", data);
@@ -38693,7 +38820,7 @@ function computeThroughput(succeeded, totalBytes, durationMs) {
     bytesPerSec: durationSec > 0 ? totalBytes / durationSec : 0
   };
 }
-function delay3(ms) {
+function delay2(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -38840,7 +38967,7 @@ var DicomHammer = class _DicomHammer extends events.EventEmitter {
   /** Sends a single file, with optional delay. */
   async sendOneFile(file) {
     if (this.opts.delayMs > 0) {
-      await delay3(this.opts.delayMs);
+      await delay2(this.opts.delayMs);
     }
     const result = await dcmsend({
       host: this.opts.host,
@@ -39007,6 +39134,7 @@ exports.StoreSCP = StoreSCP;
 exports.StoreSCPPreset = StoreSCPPreset;
 exports.StorescpEvent = StorescpEvent;
 exports.SubdirectoryMode = SubdirectoryMode;
+exports.ToolExecutionError = ToolExecutionError;
 exports.TransferSyntax = TransferSyntax;
 exports.UIDSchema = UIDSchema;
 exports.UNIX_SEARCH_PATHS = UNIX_SEARCH_PATHS;