@ubercode/dcmtk 0.9.3 → 0.10.0

package/dist/index.cjs

@@ -2,15 +2,16 @@
 
 var path = require('path');
 var zod = require('zod');
-var fs$1 = require('fs');
+var fs = require('fs');
 var child_process = require('child_process');
 var kill = require('tree-kill');
 var events = require('events');
 var stderrLib = require('stderr-lib');
-var fs = require('fs/promises');
+var promises$1 = require('fs/promises');
 var os = require('os');
 var fastXmlParser = require('fast-xml-parser');
 var net = require('net');
+var promises = require('timers/promises');
 var crypto = require('crypto');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -35,7 +36,6 @@ function _interopNamespace(e) {
 
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 var kill__default = /*#__PURE__*/_interopDefault(kill);
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var net__namespace = /*#__PURE__*/_interopNamespace(net);
 
@@ -224,7 +224,7 @@ function binaryName(name) {
 }
 function hasRequiredBinaries(dir) {
   for (const bin of REQUIRED_BINARIES) {
-    if (!fs$1.existsSync(path.join(dir, binaryName(bin)))) {
+    if (!fs.existsSync(path.join(dir, binaryName(bin)))) {
       return false;
     }
   }
@@ -31508,12 +31508,12 @@ async function tryDirectPath(inputPath, timeoutMs, signal, verbosity) {
     const execOpts = signal !== void 0 ? { timeoutMs, signal } : { timeoutMs };
     return await execAndParse(jsonBinary.value, directArgs, inputPath, execOpts);
   } finally {
-    fs.rm(bulkDir, { recursive: true, force: true }).catch(() => {
+    promises$1.rm(bulkDir, { recursive: true, force: true }).catch(() => {
     });
   }
 }
 async function createBulkTempDir() {
-  return fs.mkdtemp(path.join(os.tmpdir(), "dcm2json-bulk-"));
+  return promises$1.mkdtemp(path.join(os.tmpdir(), "dcm2json-bulk-"));
 }
 async function execAndParse(binary, args, inputPath, execOpts) {
   const result = await execCommand(binary, args, execOpts);
@@ -34341,19 +34341,19 @@ async function applyModifications(filePath, changeset, options) {
 }
 async function copyFileSafe(source, dest) {
   return stderrLib.tryCatch(
-    () => fs.copyFile(source, dest),
+    () => promises$1.copyFile(source, dest),
     (e) => new Error(`Failed to copy file: ${e.message}`)
   );
 }
 async function statFileSize(path2) {
   return stderrLib.tryCatch(
-    async () => (await fs.stat(path2)).size,
+    async () => (await promises$1.stat(path2)).size,
     (e) => new Error(`Failed to stat file: ${e.message}`)
   );
 }
 async function unlinkFile(path2) {
   return stderrLib.tryCatch(
-    () => fs.unlink(path2),
+    () => promises$1.unlink(path2),
     (e) => new Error(`Failed to delete file: ${e.message}`)
   );
 }
@@ -36272,6 +36272,184 @@ var Wlmscpfs = class _Wlmscpfs extends DcmtkProcess {
     signal.addEventListener("abort", this.abortHandler, { once: true });
   }
 };
+var MIN_CONCURRENCY = 1;
+var MAX_CONCURRENCY = 64;
+var DEFAULT_CONCURRENCY = 4;
+function clampConcurrency(value) {
+  if (value === void 0) return DEFAULT_CONCURRENCY;
+  return Math.max(MIN_CONCURRENCY, Math.min(MAX_CONCURRENCY, Math.floor(value)));
+}
+function createBatchState(total) {
+  const results = [];
+  for (let i = 0; i < total; i += 1) {
+    results.push(void 0);
+  }
+  return { results, succeeded: 0, failed: 0, completed: 0 };
+}
+async function processItem(item, index, operation, state) {
+  let result;
+  try {
+    result = await operation(item);
+  } catch (thrown) {
+    result = err(stderrLib.stderr(thrown));
+  }
+  state.results[index] = result;
+  state.completed += 1;
+  if (result.ok) {
+    state.succeeded += 1;
+  } else {
+    state.failed += 1;
+  }
+}
+async function batch(items, operation, options) {
+  const concurrency = clampConcurrency(options?.concurrency);
+  const signal = options?.signal;
+  const onProgress = options?.onProgress;
+  const total = items.length;
+  if (total === 0) {
+    return { results: [], succeeded: 0, failed: 0 };
+  }
+  const state = createBatchState(total);
+  const inFlight = /* @__PURE__ */ new Set();
+  let nextIndex = 0;
+  while (nextIndex < total) {
+    if (signal?.aborted) break;
+    const itemIndex = nextIndex;
+    nextIndex += 1;
+    const promise = processItem(items[itemIndex], itemIndex, operation, state).then(() => {
+      if (onProgress) {
+        const result = state.results[itemIndex];
+        onProgress(state.completed, total, result);
+      }
+    });
+    inFlight.add(promise);
+    promise.then(
+      () => inFlight.delete(promise),
+      () => inFlight.delete(promise)
+    );
+    if (inFlight.size >= concurrency) {
+      await Promise.race(inFlight);
+    }
+  }
+  if (inFlight.size > 0) {
+    await Promise.all(inFlight);
+  }
+  return { results: state.results, succeeded: state.succeeded, failed: state.failed };
+}
+
+// src/utils/retry.ts
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_INITIAL_DELAY_MS = 1e3;
+var DEFAULT_MAX_DELAY_MS = 3e4;
+var DEFAULT_BACKOFF_MULTIPLIER = 2;
+var JITTER_FRACTION = 0.1;
+var DEFAULT_CONFIG = {
+  maxAttempts: DEFAULT_MAX_ATTEMPTS,
+  initialDelayMs: DEFAULT_INITIAL_DELAY_MS,
+  maxDelayMs: DEFAULT_MAX_DELAY_MS,
+  backoffMultiplier: DEFAULT_BACKOFF_MULTIPLIER,
+  shouldRetry: void 0,
+  signal: void 0,
+  onRetry: void 0
+};
+function resolveConfig(opts) {
+  if (!opts) return DEFAULT_CONFIG;
+  return {
+    ...DEFAULT_CONFIG,
+    ...Object.fromEntries(Object.entries(opts).filter(([, v]) => v !== void 0)),
+    maxAttempts: Math.max(1, Math.floor(opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS)),
+    initialDelayMs: Math.max(0, opts.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS),
+    maxDelayMs: Math.max(0, opts.maxDelayMs ?? DEFAULT_MAX_DELAY_MS),
+    backoffMultiplier: Math.max(1, opts.backoffMultiplier ?? DEFAULT_BACKOFF_MULTIPLIER)
+  };
+}
+function computeDelay(attempt, config) {
+  const baseDelay = Math.min(config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt), config.maxDelayMs);
+  const jitter = baseDelay * JITTER_FRACTION * (2 * Math.random() - 1);
+  return Math.max(0, Math.round(baseDelay + jitter));
+}
+async function waitWithAbort(delayMs, signal) {
+  if (signal?.aborted) {
+    return false;
+  }
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve(true);
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timer);
+      cleanup();
+      resolve(false);
+    };
+    const cleanup = () => {
+      signal?.removeEventListener("abort", onAbort);
+    };
+    if (signal) {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function shouldBreakAfterFailure(attempt, lastError, config) {
+  if (attempt === config.maxAttempts - 1) return true;
+  if (config.shouldRetry && !config.shouldRetry(lastError, attempt + 1)) return true;
+  if (config.signal?.aborted) return true;
+  return false;
+}
+async function retry(operation, options) {
+  const config = resolveConfig(options);
+  let lastResult = err(new Error("No attempts executed"));
+  for (let attempt = 0; attempt < config.maxAttempts; attempt += 1) {
+    lastResult = await operation();
+    if (lastResult.ok) return lastResult;
+    if (shouldBreakAfterFailure(attempt, lastResult.error, config)) break;
+    const delayMs = computeDelay(attempt, config);
+    if (config.onRetry) config.onRetry(lastResult.error, attempt + 1, delayMs);
+    const waitCompleted = await waitWithAbort(delayMs, config.signal);
+    if (!waitCompleted) break;
+  }
+  return lastResult;
+}
+async function ensureDirectory(dirPath) {
+  try {
+    await promises$1.mkdir(dirPath, { recursive: true });
+    return ok(void 0);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return err(new Error(`Failed to create directory ${dirPath}: ${msg}`));
+  }
+}
+async function moveFile(src, dest) {
+  try {
+    await promises$1.rename(src, dest);
+    return ok(void 0);
+  } catch {
+    try {
+      await promises$1.copyFile(src, dest);
+      await promises$1.unlink(src);
+      return ok(void 0);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return err(new Error(`Failed to move file ${src} \u2192 ${dest}: ${msg}`));
+    }
+  }
+}
+async function statFileSafe(filePath) {
+  try {
+    const s = await promises$1.stat(filePath);
+    return s.size;
+  } catch {
+    return 0;
+  }
+}
+async function removeDirSafe(dirPath) {
+  try {
+    await promises$1.rm(dirPath, { recursive: true, force: true });
+  } catch {
+  }
+}
+
+// src/servers/DicomReceiver.ts
 var DEFAULT_MIN_POOL_SIZE = 2;
 var DEFAULT_MAX_POOL_SIZE = 10;
 var DEFAULT_CONNECTION_TIMEOUT_MS = 1e4;
@@ -36297,6 +36475,102 @@ var DicomReceiverOptionsSchema = zod.z.object({
 }).strict().refine((data) => (data.minPoolSize ?? DEFAULT_MIN_POOL_SIZE) <= (data.maxPoolSize ?? DEFAULT_MAX_POOL_SIZE), {
   message: "minPoolSize must be <= maxPoolSize"
 });
+var Worker = class {
+  constructor(dcmrecv, port, tempDir) {
+    __publicField(this, "dcmrecv");
+    __publicField(this, "port");
+    __publicField(this, "tempDir");
+    __publicField(this, "_state", "idle");
+    __publicField(this, "_context");
+    __publicField(this, "_pending", /* @__PURE__ */ new Set());
+    __publicField(this, "_files", []);
+    __publicField(this, "_fileSizes", []);
+    __publicField(this, "_outputLines", []);
+    __publicField(this, "_remoteSocket");
+    __publicField(this, "_workerSocket");
+    this.dcmrecv = dcmrecv;
+    this.port = port;
+    this.tempDir = tempDir;
+  }
+  /** Current worker state. */
+  get state() {
+    return this._state;
+  }
+  /** Active association context, or undefined when idle. */
+  get context() {
+    return this._context;
+  }
+  /** Files moved to the association directory during the current association. */
+  get files() {
+    return this._files;
+  }
+  /** Byte sizes parallel to files[], for transfer stats. */
+  get fileSizes() {
+    return this._fileSizes;
+  }
+  /** Captured output lines during the current association. */
+  get outputLines() {
+    return this._outputLines;
+  }
+  /** Marks the worker busy with a new association context. */
+  beginAssociation(ctx) {
+    this._state = "busy";
+    this._context = ctx;
+    this._files.length = 0;
+    this._fileSizes.length = 0;
+    this._outputLines.length = 0;
+    this._pending.clear();
+  }
+  /** Returns the worker to idle and clears all association state. */
+  endAssociation() {
+    this._state = "idle";
+    this._context = void 0;
+    this._files.length = 0;
+    this._fileSizes.length = 0;
+    this._outputLines.length = 0;
+    this._pending.clear();
+    this._remoteSocket = void 0;
+    this._workerSocket = void 0;
+  }
+  /** Tracks an in-flight file handling promise; auto-removes on completion. */
+  trackFile(promise) {
+    this._pending.add(promise);
+    void promise.finally(() => {
+      this._pending.delete(promise);
+    });
+  }
+  /** Records a successfully received file path and its size. */
+  recordFile(filePath, size) {
+    this._files.push(filePath);
+    this._fileSizes.push(size);
+  }
+  /** Awaits all in-flight file handling promises. */
+  async drainPendingFiles() {
+    if (this._pending.size > 0) {
+      await Promise.all(this._pending);
+    }
+  }
+  /** Appends a line to the output buffer, respecting the cap. */
+  captureOutput(text) {
+    if (this._outputLines.length < MAX_OUTPUT_LINES_PER_ASSOCIATION) {
+      this._outputLines.push(text);
+    }
+  }
+  /** Stores the remote and worker sockets for later cleanup. */
+  setSockets(remote, worker) {
+    this._remoteSocket = remote;
+    this._workerSocket = worker;
+  }
+  /** Destroys both sockets if they exist and are not already destroyed. */
+  destroySockets() {
+    if (this._remoteSocket !== void 0 && !this._remoteSocket.destroyed) {
+      this._remoteSocket.destroy();
+    }
+    if (this._workerSocket !== void 0 && !this._workerSocket.destroyed) {
+      this._workerSocket.destroy();
+    }
+  }
+};
 function allocatePort() {
   return new Promise((resolve) => {
     const server = net__namespace.createServer();
@@ -36314,6 +36588,13 @@ function allocatePort() {
     });
   });
 }
+function sumArray(arr) {
+  let total = 0;
+  for (let i = 0; i < arr.length; i++) {
+    total += arr[i] ?? 0;
+  }
+  return total;
+}
 var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
   constructor(options) {
     super();
@@ -36328,8 +36609,6 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     __publicField(this, "stopping", false);
     __publicField(this, "abortHandler");
     this.setMaxListeners(20);
-    this.on("error", () => {
-    });
     this.options = options;
     this.minPoolSize = options.minPoolSize ?? DEFAULT_MIN_POOL_SIZE;
     this.maxPoolSize = options.maxPoolSize ?? DEFAULT_MAX_POOL_SIZE;
@@ -36537,14 +36816,12 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
       this.emit("error", { error: mkdirResult.error });
       return;
     }
-    worker.state = "busy";
-    worker.associationId = associationId;
-    worker.associationDir = associationDir;
-    worker.files = [];
-    worker.fileSizes = [];
-    worker.outputLines = [];
-    worker.pendingFiles = [];
-    worker.startAt = Date.now();
+    const ctx = {
+      associationId,
+      associationDir,
+      startAt: Date.now()
+    };
+    worker.beginAssociation(ctx);
     this.pipeConnection(worker, remoteSocket);
     void this.replenishPool();
   }
@@ -36554,7 +36831,7 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     if (idle !== void 0) return idle;
     const maxRetries = Math.min(Math.ceil(this.connectionTimeoutMs / CONNECTION_RETRY_INTERVAL_MS), MAX_CONNECTION_RETRIES);
     for (let i = 0; i < maxRetries; i++) {
-      await delay(CONNECTION_RETRY_INTERVAL_MS);
+      await promises.setTimeout(CONNECTION_RETRY_INTERVAL_MS);
       const found = this.getIdleWorker();
       if (found !== void 0) return found;
       if (this.stopping) return void 0;
@@ -36571,8 +36848,7 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
   /** Pipes remote socket bidirectionally to the worker's port. */
   pipeConnection(worker, remoteSocket) {
     const workerSocket = net__namespace.createConnection({ port: worker.port, host: "127.0.0.1" });
-    worker.remoteSocket = remoteSocket;
-    worker.workerSocket = workerSocket;
+    worker.setSockets(remoteSocket, workerSocket);
     const cleanup = () => {
       remoteSocket.unpipe(workerSocket);
       workerSocket.unpipe(remoteSocket);
@@ -36631,21 +36907,7 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     const createResult = this.createDcmrecv(port, tempDir);
     if (!createResult.ok) return createResult;
     const dcmrecv = createResult.value;
-    const worker = {
-      dcmrecv,
-      port,
-      tempDir,
-      state: "idle",
-      associationId: void 0,
-      associationDir: void 0,
-      files: [],
-      fileSizes: [],
-      outputLines: [],
-      pendingFiles: [],
-      startAt: void 0,
-      remoteSocket: void 0,
-      workerSocket: void 0
-    };
+    const worker = new Worker(dcmrecv, port, tempDir);
     this.wireWorkerEvents(worker);
     const startResult = await dcmrecv.start();
     if (!startResult.ok) {
@@ -36654,14 +36916,9 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     this.workers.set(port, worker);
     return ok(worker);
   }
-  /** Stops a single worker: stop process, clean temp dir, remove from pool. */
+  /** Stops a single worker: destroy sockets, stop process, clean temp dir, remove from pool. */
   async stopWorker(worker) {
-    if (worker.remoteSocket !== void 0 && !worker.remoteSocket.destroyed) {
-      worker.remoteSocket.destroy();
-    }
-    if (worker.workerSocket !== void 0 && !worker.workerSocket.destroyed) {
-      worker.workerSocket.destroy();
-    }
+    worker.destroySockets();
     await worker.dcmrecv.stop();
     worker.dcmrecv[Symbol.dispose]();
     await removeDirSafe(worker.tempDir);
@@ -36713,12 +36970,11 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     this.wireRefusingAssociation(worker);
     this.wireOutputCapture(worker);
   }
-  /** Wires FILE_RECEIVED from dcmrecv worker to handleFileReceived. */
+  /** Wires FILE_RECEIVED from dcmrecv worker — captures context synchronously. */
   wireFileReceived(worker) {
     worker.dcmrecv.onFileReceived((data) => {
-      const assocId = worker.associationId;
-      const assocDir = worker.associationDir;
-      if (assocDir === void 0 || assocId === void 0) {
+      const ctx = worker.context;
+      if (ctx === void 0) {
         this.emit("error", {
           error: new Error(`DicomReceiver: FILE_RECEIVED with no active association (worker state: ${worker.state})`),
           filePath: data.filePath,
@@ -36728,22 +36984,21 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
         });
         return;
       }
-      const promise = this.handleFileReceived(worker, data, assocId, assocDir);
-      worker.pendingFiles.push(promise);
-      void promise.finally(() => removePending(worker.pendingFiles, promise));
+      const promise = this.handleFileReceived(worker, data, ctx);
+      worker.trackFile(promise);
     });
   }
   /** Moves a received file, opens it as DicomInstance, and emits FILE_RECEIVED. */
-  async handleFileReceived(worker, data, assocId, assocDir) {
+  async handleFileReceived(worker, data, ctx) {
     try {
-      await this.moveAndEmitFile(worker, data, assocId, assocDir);
+      await this.moveAndEmitFile(worker, data, ctx);
     } catch (thrown) {
       const error = thrown instanceof Error ? thrown : new Error(String(thrown));
       this.emit("error", {
         error,
         filePath: data.filePath,
-        associationId: assocId,
-        associationDir: assocDir,
+        associationId: ctx.associationId,
+        associationDir: ctx.associationDir,
         callingAE: data.callingAE,
         calledAE: data.calledAE,
         source: data.source
@@ -36751,21 +37006,20 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     }
   }
   /** Inner handler: move file, parse DICOM, emit FILE_RECEIVED or error. */
-  async moveAndEmitFile(worker, data, assocId, assocDir) {
+  async moveAndEmitFile(worker, data, ctx) {
     const srcPath = data.filePath;
-    const destPath = path__namespace.join(assocDir, path__namespace.basename(srcPath));
+    const destPath = path__namespace.join(ctx.associationDir, path__namespace.basename(srcPath));
     const moveResult = await moveFile(srcPath, destPath);
     const finalPath = moveResult.ok ? destPath : srcPath;
     const fileSize = await statFileSafe(finalPath);
-    worker.files.push(finalPath);
-    worker.fileSizes.push(fileSize);
+    worker.recordFile(finalPath, fileSize);
     const openResult = await DicomInstance.open(finalPath);
     if (!openResult.ok) {
       this.emit("error", {
         error: openResult.error,
         filePath: finalPath,
-        associationId: assocId,
-        associationDir: assocDir,
+        associationId: ctx.associationId,
+        associationDir: ctx.associationDir,
         callingAE: data.callingAE,
         calledAE: data.calledAE,
         source: data.source
@@ -36775,8 +37029,8 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     this.emit("FILE_RECEIVED", {
       filePath: finalPath,
       fileSize,
-      associationId: assocId,
-      associationDir: assocDir,
+      associationId: ctx.associationId,
+      associationDir: ctx.associationDir,
       callingAE: data.callingAE,
       calledAE: data.calledAE,
       source: data.source,
@@ -36791,21 +37045,20 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
   }
   /** Awaits ALL pending file operations, emits ASSOCIATION_COMPLETE, resets worker state. */
   async finalizeAssociation(worker, data) {
-    while (worker.pendingFiles.length > 0) {
-      await Promise.all(worker.pendingFiles);
-    }
+    await worker.drainPendingFiles();
     this.emitAssociationComplete(worker, data);
-    this.resetWorker(worker);
+    worker.endAssociation();
     void this.scaleDown();
   }
   /** Emits the ASSOCIATION_COMPLETE event with transfer stats. */
   emitAssociationComplete(worker, data) {
-    const assocId = worker.associationId ?? data.associationId;
-    const assocDir = worker.associationDir ?? "";
+    const ctx = worker.context;
+    const assocId = ctx?.associationId ?? data.associationId;
+    const assocDir = ctx?.associationDir ?? "";
+    const startAt = ctx?.startAt ?? Date.now();
     const files = [...worker.files];
     const output = [...worker.outputLines];
     const endAt = Date.now();
-    const startAt = worker.startAt ?? endAt;
     const totalBytes = sumArray(worker.fileSizes);
     const elapsedMs = endAt - startAt;
     const bytesPerSecond = elapsedMs > 0 ? Math.round(totalBytes / elapsedMs * 1e3) : 0;
@@ -36825,24 +37078,11 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
       output
     });
   }
-  /** Resets worker state to idle after an association completes. */
-  resetWorker(worker) {
-    worker.state = "idle";
-    worker.associationId = void 0;
-    worker.associationDir = void 0;
-    worker.files = [];
-    worker.fileSizes = [];
-    worker.outputLines = [];
-    worker.pendingFiles = [];
-    worker.startAt = void 0;
-    worker.remoteSocket = void 0;
-    worker.workerSocket = void 0;
-  }
   /** Bubbles ASSOCIATION_RECEIVED from dcmrecv worker. */
   wireAssociationReceived(worker) {
     worker.dcmrecv.onEvent("ASSOCIATION_RECEIVED", (data) => {
       this.emit("ASSOCIATION_RECEIVED", {
-        associationId: worker.associationId ?? "",
+        associationId: worker.context?.associationId ?? "",
         callingAE: data.callingAE,
         calledAE: data.calledAE,
         source: data.source
@@ -36853,7 +37093,7 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
   wireCStoreRequest(worker) {
     worker.dcmrecv.onEvent("C_STORE_REQUEST", (data) => {
       this.emit("C_STORE_REQUEST", {
-        associationId: worker.associationId ?? "",
+        associationId: worker.context?.associationId ?? "",
         raw: data.raw
       });
     });
@@ -36862,7 +37102,7 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
   wireEchoRequest(worker) {
     worker.dcmrecv.onEvent("ECHO_REQUEST", () => {
       this.emit("ECHO_REQUEST", {
-        associationId: worker.associationId ?? ""
+        associationId: worker.context?.associationId ?? ""
       });
     });
   }
@@ -36877,8 +37117,8 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
   /** Captures worker output lines during busy associations. */
   wireOutputCapture(worker) {
     worker.dcmrecv.on("line", ({ text }) => {
-      if (worker.state === "busy" && worker.outputLines.length < MAX_OUTPUT_LINES_PER_ASSOCIATION) {
-        worker.outputLines.push(text);
+      if (worker.state === "busy") {
+        worker.captureOutput(text);
       }
     });
   }
@@ -36897,60 +37137,6 @@ var DicomReceiver = class _DicomReceiver extends events.EventEmitter {
     signal.addEventListener("abort", this.abortHandler, { once: true });
   }
 };
-async function ensureDirectory(dirPath) {
-  try {
-    await fs__namespace.mkdir(dirPath, { recursive: true });
-    return ok(void 0);
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e);
-    return err(new Error(`Failed to create directory ${dirPath}: ${msg}`));
-  }
-}
-async function moveFile(src, dest) {
-  try {
-    await fs__namespace.rename(src, dest);
-    return ok(void 0);
-  } catch {
-    try {
-      await fs__namespace.copyFile(src, dest);
-      await fs__namespace.unlink(src);
-      return ok(void 0);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      return err(new Error(`Failed to move file ${src} \u2192 ${dest}: ${msg}`));
-    }
-  }
-}
-async function statFileSafe(filePath) {
-  try {
-    const stat4 = await fs__namespace.stat(filePath);
-    return stat4.size;
-  } catch {
-    return 0;
-  }
-}
-function sumArray(arr) {
-  let total = 0;
-  for (let i = 0; i < arr.length; i++) {
-    total += arr[i] ?? 0;
-  }
-  return total;
-}
-async function removeDirSafe(dirPath) {
-  try {
-    await fs__namespace.rm(dirPath, { recursive: true, force: true });
-  } catch {
-  }
-}
-function removePending(arr, promise) {
-  const idx = arr.indexOf(promise);
-  if (idx !== -1) void arr.splice(idx, 1);
-}
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
 
 // src/senders/types.ts
 var SenderMode = {
@@ -37373,7 +37559,7 @@ function createStorescuExecutor(options) {
     return ok({ stdout: result.value.stdout, stderr: result.value.stderr });
   };
 }
-function resolveConfig(options) {
+function resolveConfig2(options) {
   const mode = options.mode ?? "multiple";
   const rawMax = options.maxAssociations ?? DEFAULT_MAX_ASSOCIATIONS;
   return {
@@ -37420,7 +37606,7 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
     if (!validation.success) {
       return err(createValidationError("DicomSender", validation.error));
     }
-    const cfg = resolveConfig(options);
+    const cfg = resolveConfig2(options);
     const senderRef = { current: void 0 };
     const engine = new SenderEngine({
       ...cfg,
@@ -37622,7 +37808,7 @@ function createDcmsendExecutor(options) {
     return ok({ stdout: result.value.stdout, stderr: result.value.stderr });
   };
 }
-function resolveConfig2(options) {
+function resolveConfig3(options) {
   const mode = options.mode ?? "multiple";
   const rawMax = options.maxAssociations ?? DEFAULT_MAX_ASSOCIATIONS2;
   return {
@@ -37669,7 +37855,7 @@ var DicomSend = class _DicomSend extends events.EventEmitter {
     if (!validation.success) {
       return err(createValidationError("DicomSend", validation.error));
     }
-    const cfg = resolveConfig2(options);
+    const cfg = resolveConfig3(options);
     const senderRef = { current: void 0 };
     const engine = new SenderEngine({
       ...cfg,
@@ -37927,13 +38113,13 @@ function buildWorklistKeys(filter) {
 var MAX_RESPONSE_FILES = 1e4;
 async function createTempDir() {
   return stderrLib.tryCatch(
-    () => fs.mkdtemp(path.join(os.tmpdir(), "dcmtk-pacs-")),
+    () => promises$1.mkdtemp(path.join(os.tmpdir(), "dcmtk-pacs-")),
     (e) => new Error(`Failed to create temp directory: ${e.message}`)
   );
 }
 async function listDcmFiles(directory) {
   try {
-    const entries = await fs.readdir(directory);
+    const entries = await promises$1.readdir(directory);
     const dcmFiles = [];
     for (let i = 0; i < entries.length; i += 1) {
       const entry = entries[i];
@@ -37951,7 +38137,7 @@ async function listDcmFiles(directory) {
 }
 async function cleanupTempDir(directory) {
   try {
-    await fs.rm(directory, { recursive: true, force: true });
+    await promises$1.rm(directory, { recursive: true, force: true });
   } catch {
   }
 }
@@ -38270,70 +38456,6 @@ var PacsClient = class _PacsClient {
     return ok({ success: true, outputDirectory: options.outputDirectory });
   }
 };
-var MIN_CONCURRENCY = 1;
-var MAX_CONCURRENCY = 64;
-var DEFAULT_CONCURRENCY = 4;
-function clampConcurrency(value) {
-  if (value === void 0) return DEFAULT_CONCURRENCY;
-  return Math.max(MIN_CONCURRENCY, Math.min(MAX_CONCURRENCY, Math.floor(value)));
-}
-function createBatchState(total) {
-  const results = [];
-  for (let i = 0; i < total; i += 1) {
-    results.push(void 0);
-  }
-  return { results, succeeded: 0, failed: 0, completed: 0 };
-}
-async function processItem(item, index, operation, state) {
-  let result;
-  try {
-    result = await operation(item);
-  } catch (thrown) {
-    result = err(stderrLib.stderr(thrown));
-  }
-  state.results[index] = result;
-  state.completed += 1;
-  if (result.ok) {
-    state.succeeded += 1;
-  } else {
-    state.failed += 1;
-  }
-}
-async function batch(items, operation, options) {
-  const concurrency = clampConcurrency(options?.concurrency);
-  const signal = options?.signal;
-  const onProgress = options?.onProgress;
-  const total = items.length;
-  if (total === 0) {
-    return { results: [], succeeded: 0, failed: 0 };
-  }
-  const state = createBatchState(total);
-  const inFlight = /* @__PURE__ */ new Set();
-  let nextIndex = 0;
-  while (nextIndex < total) {
-    if (signal?.aborted) break;
-    const itemIndex = nextIndex;
-    nextIndex += 1;
-    const promise = processItem(items[itemIndex], itemIndex, operation, state).then(() => {
-      if (onProgress) {
-        const result = state.results[itemIndex];
-        onProgress(state.completed, total, result);
-      }
-    });
-    inFlight.add(promise);
-    promise.then(
-      () => inFlight.delete(promise),
-      () => inFlight.delete(promise)
-    );
-    if (inFlight.size >= concurrency) {
-      await Promise.race(inFlight);
-    }
-  }
-  if (inFlight.size > 0) {
-    await Promise.all(inFlight);
-  }
-  return { results: state.results, succeeded: state.succeeded, failed: state.failed };
-}
 
 // src/testing/types.ts
 var HammerPhase = {
@@ -38470,7 +38592,7 @@ var DicomHammer = class _DicomHammer extends events.EventEmitter {
     const start = Date.now();
     const dir = path.join(this.opts.outputDir, `dcmtk-hammer-${Date.now()}`);
     try {
-      await fs.mkdir(dir, { recursive: true });
+      await promises$1.mkdir(dir, { recursive: true });
     } catch {
       return err(new Error(`Failed to create output directory: ${dir}`));
     }
@@ -38592,7 +38714,7 @@ var DicomHammer = class _DicomHammer extends events.EventEmitter {
   /** Gets the file size in bytes, returning 0 on error. */
   async getFileSize(filePath) {
     try {
-      const s = await fs.stat(filePath);
+      const s = await promises$1.stat(filePath);
       return s.size;
     } catch {
       return 0;
@@ -38633,7 +38755,7 @@ var DicomHammer = class _DicomHammer extends events.EventEmitter {
   async cleanup() {
     if (this.generatedDir === void 0) return ok(void 0);
     try {
-      await fs.rm(this.generatedDir, { recursive: true, force: true });
+      await promises$1.rm(this.generatedDir, { recursive: true, force: true });
       this.generatedDir = void 0;
       this.generatedFiles = [];
       return ok(void 0);
@@ -38670,80 +38792,6 @@ var DicomHammer = class _DicomHammer extends events.EventEmitter {
   }
 };
 
-// src/utils/retry.ts
-var DEFAULT_MAX_ATTEMPTS = 3;
-var DEFAULT_INITIAL_DELAY_MS = 1e3;
-var DEFAULT_MAX_DELAY_MS = 3e4;
-var DEFAULT_BACKOFF_MULTIPLIER = 2;
-var JITTER_FRACTION = 0.1;
-var DEFAULT_CONFIG = {
-  maxAttempts: DEFAULT_MAX_ATTEMPTS,
-  initialDelayMs: DEFAULT_INITIAL_DELAY_MS,
-  maxDelayMs: DEFAULT_MAX_DELAY_MS,
-  backoffMultiplier: DEFAULT_BACKOFF_MULTIPLIER,
-  shouldRetry: void 0,
-  signal: void 0,
-  onRetry: void 0
-};
-function resolveConfig3(opts) {
-  if (!opts) return DEFAULT_CONFIG;
-  return {
-    ...DEFAULT_CONFIG,
-    ...Object.fromEntries(Object.entries(opts).filter(([, v]) => v !== void 0)),
-    maxAttempts: Math.max(1, Math.floor(opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS)),
-    initialDelayMs: Math.max(0, opts.initialDelayMs ?? DEFAULT_INITIAL_DELAY_MS),
-    maxDelayMs: Math.max(0, opts.maxDelayMs ?? DEFAULT_MAX_DELAY_MS),
-    backoffMultiplier: Math.max(1, opts.backoffMultiplier ?? DEFAULT_BACKOFF_MULTIPLIER)
-  };
-}
-function computeDelay(attempt, config) {
-  const baseDelay = Math.min(config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt), config.maxDelayMs);
-  const jitter = baseDelay * JITTER_FRACTION * (2 * Math.random() - 1);
-  return Math.max(0, Math.round(baseDelay + jitter));
-}
-async function waitWithAbort(delayMs, signal) {
-  if (signal?.aborted) {
-    return false;
-  }
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      cleanup();
-      resolve(true);
-    }, delayMs);
-    const onAbort = () => {
-      clearTimeout(timer);
-      cleanup();
-      resolve(false);
-    };
-    const cleanup = () => {
-      signal?.removeEventListener("abort", onAbort);
-    };
-    if (signal) {
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-  });
-}
-function shouldBreakAfterFailure(attempt, lastError, config) {
-  if (attempt === config.maxAttempts - 1) return true;
-  if (config.shouldRetry && !config.shouldRetry(lastError, attempt + 1)) return true;
-  if (config.signal?.aborted) return true;
-  return false;
-}
-async function retry(operation, options) {
-  const config = resolveConfig3(options);
-  let lastResult = err(new Error("No attempts executed"));
-  for (let attempt = 0; attempt < config.maxAttempts; attempt += 1) {
-    lastResult = await operation();
-    if (lastResult.ok) return lastResult;
-    if (shouldBreakAfterFailure(attempt, lastResult.error, config)) break;
-    const delayMs = computeDelay(attempt, config);
-    if (config.onRetry) config.onRetry(lastResult.error, attempt + 1, delayMs);
-    const waitCompleted = await waitWithAbort(delayMs, config.signal);
-    if (!waitCompleted) break;
-  }
-  return lastResult;
-}
-
 exports.AETitleSchema = AETitleSchema;
 exports.AssociationTracker = AssociationTracker;
 exports.ChangeSet = ChangeSet;