@ubercode/dcmtk 0.7.3 → 0.8.1

package/dist/index.cjs

@@ -31184,6 +31184,7 @@ var Dcm2xmlOptionsSchema = zod.z.object({
   charset: zod.z.enum(["utf8", "latin1", "ascii"]).optional(),
   writeBinaryData: zod.z.boolean().optional(),
   encodeBinaryBase64: zod.z.boolean().optional(),
+  charsetAssume: zod.z.string().min(1).optional(),
   verbosity: zod.z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
 function pushEncodingArgs(args, options) {
@@ -31207,6 +31208,9 @@ function buildArgs(inputPath, options) {
   if (options?.namespace === true) {
     args.push("+Xn");
   }
+  if (options?.charsetAssume !== void 0) {
+    args.push("+Ca", options.charsetAssume);
+  }
   pushEncodingArgs(args, options);
   args.push(inputPath);
   return args;
@@ -31456,6 +31460,7 @@ var Dcm2jsonOptionsSchema = zod.z.object({
   timeoutMs: zod.z.number().int().positive().optional(),
   signal: zod.z.instanceof(AbortSignal).optional(),
   directOnly: zod.z.boolean().optional(),
+  charsetAssume: zod.z.string().min(1).optional(),
   verbosity: zod.z.enum(["verbose", "debug"]).optional()
 }).strict().optional();
 var VERBOSITY_FLAGS2 = { verbose: "-v", debug: "-d" };
@@ -31465,12 +31470,19 @@ function buildVerbosityArgs(verbosity) {
   }
   return [];
 }
-async function tryXmlPath(inputPath, timeoutMs, signal, verbosity) {
+function buildXmlOpts(options) {
+  const result = {};
+  if (options?.verbosity !== void 0) result["verbosity"] = options.verbosity;
+  if (options?.charsetAssume !== void 0) result["charsetAssume"] = options.charsetAssume;
+  return result;
+}
+async function tryXmlPath(inputPath, timeoutMs, signal, opts) {
   const xmlBinary = resolveBinary("dcm2xml");
   if (!xmlBinary.ok) {
     return err(xmlBinary.error);
   }
-  const xmlArgs = [...buildVerbosityArgs(verbosity), "-nat", inputPath];
+  const charsetArgs = opts?.charsetAssume !== void 0 ? ["+Ca", opts.charsetAssume] : [];
+  const xmlArgs = [...buildVerbosityArgs(opts?.verbosity), ...charsetArgs, "-nat", inputPath];
   const xmlResult = await execCommand(xmlBinary.value, xmlArgs, { timeoutMs, signal });
   if (!xmlResult.ok) {
     return err(xmlResult.error);
@@ -31516,7 +31528,7 @@ async function dcm2json(inputPath, options) {
   if (options?.directOnly === true) {
     return tryDirectPath(inputPath, timeoutMs, signal, verbosity);
   }
-  const xmlResult = await tryXmlPath(inputPath, timeoutMs, signal, verbosity);
+  const xmlResult = await tryXmlPath(inputPath, timeoutMs, signal, buildXmlOpts(options));
   if (xmlResult.ok) {
     return xmlResult;
   }
@@ -33131,6 +33143,30 @@ async function echoscu(options) {
   return ok({ success: true, stderr: result.value.stderr });
 }
 var VERBOSITY_FLAGS19 = { verbose: "-v", debug: "-d" };
+var DECOMPRESS_FLAGS = {
+  never: "--decompress-never",
+  lossless: "--decompress-lossless",
+  lossy: "--decompress-lossy"
+};
+function pushSendModeArgs(args, options) {
+  if (options.noHalt === true) {
+    args.push("--no-halt");
+  }
+  if (options.noIllegalProposal === true) {
+    args.push("--no-illegal-proposal");
+  }
+  if (options.decompress !== void 0) {
+    args.push(DECOMPRESS_FLAGS[options.decompress]);
+  }
+  if (options.multiAssociations === true) {
+    args.push("+ma");
+  } else if (options.multiAssociations === false) {
+    args.push("-ma");
+  }
+  if (options.createReportFile !== void 0) {
+    args.push("--create-report-file", options.createReportFile);
+  }
+}
 var DcmsendOptionsSchema = zod.z.object({
   timeoutMs: zod.z.number().int().positive().optional(),
   signal: zod.z.instanceof(AbortSignal).optional(),
@@ -33140,8 +33176,15 @@ var DcmsendOptionsSchema = zod.z.object({
   callingAETitle: zod.z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
   calledAETitle: zod.z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
   scanDirectory: zod.z.boolean().optional(),
+  recurse: zod.z.boolean().optional(),
+  scanPattern: zod.z.string().min(1).optional(),
   verbosity: zod.z.enum(["verbose", "debug"]).optional(),
   noUidChecks: zod.z.boolean().optional(),
+  noHalt: zod.z.boolean().optional(),
+  noIllegalProposal: zod.z.boolean().optional(),
+  decompress: zod.z.enum(["never", "lossless", "lossy"]).optional(),
+  multiAssociations: zod.z.boolean().optional(),
+  createReportFile: zod.z.string().min(1).optional(),
   maxPduReceive: zod.z.number().int().min(4096).max(131072).optional(),
   maxPduSend: zod.z.number().int().min(4096).max(131072).optional(),
   noHostnameLookup: zod.z.boolean().optional(),
@@ -33187,6 +33230,13 @@ function buildArgs33(options) {
   if (options.scanDirectory === true) {
     args.push("--scan-directories");
   }
+  if (options.recurse === true) {
+    args.push("+r");
+  }
+  if (options.scanPattern !== void 0) {
+    args.push("--scan-pattern", options.scanPattern);
+  }
+  pushSendModeArgs(args, options);
   args.push(options.host, String(options.port));
   args.push(...options.files);
   return args;
@@ -34313,7 +34363,7 @@ var DicomInstance = class _DicomInstance {
    * Opens a DICOM file and creates a DicomInstance.
    *
    * @param path - Filesystem path to the DICOM file
-   * @param options - Timeout and abort options
+   * @param options - Timeout, abort, and charset options
    * @returns A Result containing the DicomInstance or an error
    */
   static async open(path2, options) {
@@ -34321,7 +34371,8 @@ var DicomInstance = class _DicomInstance {
     if (!filePathResult.ok) return err(filePathResult.error);
     const jsonResult = await dcm2json(path2, {
       timeoutMs: options?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-      signal: options?.signal
+      signal: options?.signal,
+      charsetAssume: options?.charsetAssume
     });
     if (!jsonResult.ok) return err(jsonResult.error);
     const datasetResult = DicomDataset.fromJson(jsonResult.value.data);
@@ -36877,68 +36928,13 @@ var SenderHealth = {
   DOWN: "down"
 };
 
-// src/senders/DicomSender.ts
-var DEFAULT_MAX_ASSOCIATIONS = 4;
-var DEFAULT_MAX_QUEUE_LENGTH = 1e3;
-var DEFAULT_MAX_RETRIES = 3;
-var DEFAULT_RETRY_DELAY_MS = 1e3;
-var DEFAULT_BUCKET_FLUSH_MS = 5e3;
-var DEFAULT_MAX_BUCKET_SIZE = 50;
-var MAX_ASSOCIATIONS_LIMIT = 64;
+// src/senders/SenderEngine.ts
 var DEGRADE_THRESHOLD = 3;
 var DOWN_THRESHOLD = 10;
 var RECOVERY_THRESHOLD = 3;
-var DicomSenderOptionsSchema = zod.z.object({
-  host: zod.z.string().min(1),
-  port: zod.z.number().int().min(1).max(65535),
-  calledAETitle: zod.z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
-  callingAETitle: zod.z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
-  mode: zod.z.enum(["single", "multiple", "bucket"]).optional(),
-  maxAssociations: zod.z.number().int().min(1).max(MAX_ASSOCIATIONS_LIMIT).optional(),
-  proposedTransferSyntax: zod.z.union([zod.z.enum(PROPOSED_TS_VALUES), zod.z.array(zod.z.enum(PROPOSED_TS_VALUES)).min(1)]).optional(),
-  combineProposedTransferSyntaxes: zod.z.boolean().optional(),
-  maxQueueLength: zod.z.number().int().min(1).optional(),
-  timeoutMs: zod.z.number().int().positive().optional(),
-  maxRetries: zod.z.number().int().min(0).optional(),
-  retryDelayMs: zod.z.number().int().min(0).optional(),
-  bucketFlushMs: zod.z.number().int().positive().optional(),
-  maxBucketSize: zod.z.number().int().min(1).optional(),
-  maxPduReceive: zod.z.number().int().min(4096).max(131072).optional(),
-  maxPduSend: zod.z.number().int().min(4096).max(131072).optional(),
-  associationTimeout: zod.z.number().int().positive().optional(),
-  acseTimeout: zod.z.number().int().positive().optional(),
-  dimseTimeout: zod.z.number().int().positive().optional(),
-  noHostnameLookup: zod.z.boolean().optional(),
-  verbosity: zod.z.enum(["verbose", "debug"]).optional(),
-  required: zod.z.boolean().optional(),
-  signal: zod.z.instanceof(AbortSignal).optional()
-}).strict();
-function resolveConfig(options) {
-  const mode = options.mode ?? "multiple";
-  const rawMax = options.maxAssociations ?? DEFAULT_MAX_ASSOCIATIONS;
-  return {
-    mode,
-    configuredMaxAssociations: mode === "single" ? 1 : rawMax,
-    maxQueueLength: options.maxQueueLength ?? DEFAULT_MAX_QUEUE_LENGTH,
-    defaultTimeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-    defaultMaxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
-    retryDelayMs: options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,
-    bucketFlushMs: options.bucketFlushMs ?? DEFAULT_BUCKET_FLUSH_MS,
-    maxBucketSize: options.maxBucketSize ?? DEFAULT_MAX_BUCKET_SIZE
-  };
-}
-var DicomSender = class _DicomSender extends events.EventEmitter {
-  constructor(options) {
-    super();
-    __publicField(this, "options");
-    __publicField(this, "mode");
-    __publicField(this, "configuredMaxAssociations");
-    __publicField(this, "maxQueueLength");
-    __publicField(this, "defaultTimeoutMs");
-    __publicField(this, "defaultMaxRetries");
-    __publicField(this, "retryDelayMs");
-    __publicField(this, "bucketFlushMs");
-    __publicField(this, "maxBucketSize");
+var SenderEngine = class {
+  constructor(config) {
+    __publicField(this, "config");
     // Queue and concurrency state
     __publicField(this, "queue", []);
     __publicField(this, "activeAssociations", 0);
@@ -36951,113 +36947,36 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
     // Bucket state (bucket mode only)
     __publicField(this, "currentBucket", []);
     __publicField(this, "bucketTimer");
-    // AbortSignal
-    __publicField(this, "abortHandler");
-    this.setMaxListeners(20);
-    this.on("error", () => {
-    });
-    this.options = options;
-    const cfg = resolveConfig(options);
-    this.mode = cfg.mode;
-    this.configuredMaxAssociations = cfg.configuredMaxAssociations;
-    this.effectiveMaxAssociations = cfg.configuredMaxAssociations;
-    this.maxQueueLength = cfg.maxQueueLength;
-    this.defaultTimeoutMs = cfg.defaultTimeoutMs;
-    this.defaultMaxRetries = cfg.defaultMaxRetries;
-    this.retryDelayMs = cfg.retryDelayMs;
-    this.bucketFlushMs = cfg.bucketFlushMs;
-    this.maxBucketSize = cfg.maxBucketSize;
-    if (options.signal !== void 0) {
-      this.wireAbortSignal(options.signal);
-    }
+    this.config = config;
+    this.effectiveMaxAssociations = config.configuredMaxAssociations;
   }
   // -----------------------------------------------------------------------
   // Public API
   // -----------------------------------------------------------------------
-  /**
-   * Creates a new DicomSender instance.
-   *
-   * @param options - Configuration options
-   * @returns A Result containing the instance or a validation error
-   */
-  static create(options) {
-    const validation = DicomSenderOptionsSchema.safeParse(options);
-    if (!validation.success) {
-      return err(createValidationError("DicomSender", validation.error));
-    }
-    return ok(new _DicomSender(options));
-  }
-  /**
-   * Sends one or more DICOM files to the remote endpoint.
-   *
-   * In single/multiple mode, files are sent as one storescu call.
-   * In bucket mode, files are accumulated into a bucket and flushed
-   * when the bucket reaches maxBucketSize or the flush timer fires.
-   *
-   * The returned promise resolves when the files are actually sent
-   * (not just queued). Callers can await for confirmation or
-   * fire-and-forget with `void sender.send(files)`.
-   *
-   * @param files - One or more DICOM file paths
-   * @param options - Per-send overrides
-   * @returns A Result containing the send result or an error
-   */
-  send(files, options) {
+  /** Sends files through the engine's queue/bucket system. */
+  send(files, timeoutMs, maxRetries, binaryParams) {
     if (this.isStopped) {
-      return Promise.resolve(err(new Error("DicomSender: sender is stopped")));
+      return Promise.resolve(err(new Error(`${this.config.senderName}: sender is stopped`)));
     }
     if (files.length === 0) {
-      return Promise.resolve(err(new Error("DicomSender: no files provided")));
-    }
-    return this.dispatchSend(files, this.buildSendParams(options));
-  }
-  /** Builds SendParams from per-send options, applying instance defaults. */
-  buildSendParams(options) {
-    return {
-      timeoutMs: options?.timeoutMs ?? this.defaultTimeoutMs,
-      maxRetries: options?.maxRetries ?? this.defaultMaxRetries,
-      calledAETitle: options?.calledAETitle,
-      callingAETitle: options?.callingAETitle,
-      required: options?.required,
-      proposedTransferSyntax: options?.proposedTransferSyntax,
-      combineProposedTransferSyntaxes: options?.combineProposedTransferSyntaxes
-    };
-  }
-  /** Dispatches a send to the appropriate mode handler. */
-  dispatchSend(files, params) {
-    switch (this.mode) {
-      case "single":
-      case "multiple":
-        return this.enqueueSend(files, params);
-      case "bucket":
-        return this.enqueueBucket(files, params);
-      default:
-        assertUnreachable(this.mode);
+      return Promise.resolve(err(new Error(`${this.config.senderName}: no files provided`)));
     }
+    return this.dispatchSend(files, timeoutMs, maxRetries, binaryParams);
   }
-  /**
-   * Flushes the current bucket immediately (bucket mode only).
-   * In single/multiple mode this is a no-op.
-   */
+  /** Flushes the current bucket immediately (bucket mode only). */
   flush() {
-    if (this.mode !== "bucket") return;
+    if (this.config.mode !== "bucket") return;
     if (this.currentBucket.length === 0) return;
     this.clearBucketTimer();
     this.flushBucketInternal("timer");
   }
-  /**
-   * Gracefully stops the sender. Rejects all queued items and
-   * waits for active associations to complete.
-   */
+  /** Gracefully stops the engine. Rejects all queued items and waits for active associations. */
   async stop() {
     if (this.isStopped) return;
     this.isStopped = true;
-    if (this.options.signal !== void 0 && this.abortHandler !== void 0) {
-      this.options.signal.removeEventListener("abort", this.abortHandler);
-    }
     this.clearBucketTimer();
-    this.rejectBucket("DicomSender: sender stopped");
-    this.rejectQueue("DicomSender: sender stopped");
+    this.rejectBucket(`${this.config.senderName}: sender stopped`);
+    this.rejectQueue(`${this.config.senderName}: sender stopped`);
     await this.waitForActive();
   }
   /** Current sender status. */
@@ -37072,77 +36991,37 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
       stopped: this.isStopped
     };
   }
+  /** Whether the engine has been stopped. */
+  get stopped() {
+    return this.isStopped;
+  }
   // -----------------------------------------------------------------------
-  // Typed event listener convenience methods
+  // Dispatch
   // -----------------------------------------------------------------------
-  /**
-   * Registers a typed listener for a DicomSender-specific event.
-   *
-   * @param event - The event name from DicomSenderEventMap
-   * @param listener - Callback receiving typed event data
-   * @returns this for chaining
-   */
-  onEvent(event, listener) {
-    return this.on(event, listener);
-  }
-  /**
-   * Registers a listener for successful sends.
-   *
-   * @param listener - Callback receiving send complete data
-   * @returns this for chaining
-   */
-  onSendComplete(listener) {
-    return this.on("SEND_COMPLETE", listener);
-  }
-  /**
-   * Registers a listener for failed sends.
-   *
-   * @param listener - Callback receiving send failed data
-   * @returns this for chaining
-   */
-  onSendFailed(listener) {
-    return this.on("SEND_FAILED", listener);
-  }
-  /**
-   * Registers a listener for health state changes.
-   *
-   * @param listener - Callback receiving health change data
-   * @returns this for chaining
-   */
-  onHealthChanged(listener) {
-    return this.on("HEALTH_CHANGED", listener);
-  }
-  /**
-   * Registers a listener for bucket flushes (bucket mode only).
-   *
-   * @param listener - Callback receiving bucket flush data
-   * @returns this for chaining
-   */
-  onBucketFlushed(listener) {
-    return this.on("BUCKET_FLUSHED", listener);
+  /** Dispatches a send to the appropriate mode handler. */
+  dispatchSend(files, timeoutMs, maxRetries, binaryParams) {
+    switch (this.config.mode) {
+      case "single":
+      case "multiple":
+        return this.enqueueSend(files, timeoutMs, maxRetries, binaryParams);
+      case "bucket":
+        return this.enqueueBucket(files, timeoutMs, maxRetries, binaryParams);
+      default:
+        assertUnreachable(this.config.mode);
+    }
   }
   // -----------------------------------------------------------------------
   // Single/Multiple mode: queue-based dispatch
   // -----------------------------------------------------------------------
   /** Enqueues a send and dispatches immediately if capacity allows. */
-  enqueueSend(files, params) {
+  enqueueSend(files, timeoutMs, maxRetries, binaryParams) {
     return new Promise((resolve) => {
       const totalQueued = this.queue.length + this.currentBucket.length;
-      if (totalQueued >= this.maxQueueLength) {
-        resolve(err(new Error("DicomSender: queue full")));
+      if (totalQueued >= this.config.maxQueueLength) {
+        resolve(err(new Error(`${this.config.senderName}: queue full`)));
         return;
       }
-      const entry = {
-        files,
-        timeoutMs: params.timeoutMs,
-        maxRetries: params.maxRetries,
-        calledAETitle: params.calledAETitle,
-        callingAETitle: params.callingAETitle,
-        required: params.required,
-        proposedTransferSyntax: params.proposedTransferSyntax,
-        combineProposedTransferSyntaxes: params.combineProposedTransferSyntaxes,
-        resolve
-      };
+      const entry = { files, timeoutMs, maxRetries, binaryParams, resolve };
       if (this.activeAssociations < this.effectiveMaxAssociations) {
         void this.executeEntry(entry);
       } else {
@@ -37162,27 +37041,16 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
   // Bucket mode: accumulate-then-flush
   // -----------------------------------------------------------------------
   /** Adds files to the current bucket and triggers flush if full. */
-  enqueueBucket(files, params) {
+  enqueueBucket(files, timeoutMs, maxRetries, binaryParams) {
     return new Promise((resolve) => {
       const totalQueued = this.queue.length + this.currentBucket.length;
-      if (totalQueued >= this.maxQueueLength) {
-        resolve(err(new Error("DicomSender: queue full")));
+      if (totalQueued >= this.config.maxQueueLength) {
+        resolve(err(new Error(`${this.config.senderName}: queue full`)));
         return;
       }
-      const { timeoutMs, maxRetries, calledAETitle, callingAETitle, required, proposedTransferSyntax, combineProposedTransferSyntaxes } = params;
-      this.currentBucket.push({
-        files,
-        resolve,
-        timeoutMs,
-        maxRetries,
-        calledAETitle,
-        callingAETitle,
-        required,
-        proposedTransferSyntax,
-        combineProposedTransferSyntaxes
-      });
+      this.currentBucket.push({ files, resolve, timeoutMs, maxRetries, binaryParams });
       const totalFiles = this.countBucketFiles();
-      if (totalFiles >= this.maxBucketSize) {
+      if (totalFiles >= this.config.maxBucketSize) {
         this.clearBucketTimer();
         void this.flushBucketInternal("maxSize");
       } else {
@@ -37214,11 +37082,7 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
       files: allFiles,
       timeoutMs,
       maxRetries,
-      calledAETitle: entries[0]?.calledAETitle,
-      callingAETitle: entries[0]?.callingAETitle,
-      required: entries[0]?.required,
-      proposedTransferSyntax: entries[0]?.proposedTransferSyntax,
-      combineProposedTransferSyntaxes: entries[0]?.combineProposedTransferSyntaxes,
+      binaryParams: entries[0].binaryParams,
       resolve: (result) => {
         for (let i = 0; i < entries.length; i++) {
           entries[i].resolve(result);
@@ -37232,7 +37096,7 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
     const entries = [...this.currentBucket];
     this.currentBucket = [];
     const bucketEntry = this.mergeBucketEntries(entries);
-    this.emit("BUCKET_FLUSHED", { fileCount: bucketEntry.files.length, reason });
+    this.config.emitters.emitBucketFlushed({ fileCount: bucketEntry.files.length, reason });
     if (this.activeAssociations < this.effectiveMaxAssociations) {
       void this.executeEntry(bucketEntry);
     } else {
@@ -37245,7 +37109,7 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
     this.bucketTimer = setTimeout(() => {
       this.bucketTimer = void 0;
       void this.flushBucketInternal("timer");
-    }, this.bucketFlushMs);
+    }, this.config.bucketFlushMs);
   }
   /** Clears the bucket flush timer. */
   clearBucketTimer() {
@@ -37257,7 +37121,7 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
   // -----------------------------------------------------------------------
   // Core send execution with retry
   // -----------------------------------------------------------------------
-  /** Executes a single queue entry: calls storescu with retry. */
+  /** Executes a single queue entry: calls the binary with retry. */
   async executeEntry(entry) {
     this.activeAssociations++;
     const startMs = Date.now();
@@ -37266,7 +37130,7 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
     if (failure === void 0) return;
     this.activeAssociations--;
     this.recordFailure();
-    this.emit("SEND_FAILED", {
+    this.config.emitters.emitSendFailed({
       files: entry.files,
       error: failure.error,
       attempts: maxAttempts,
@@ -37276,49 +37140,27 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
     entry.resolve(err(failure.error));
     this.drainQueue();
   }
-  /** Attempts storescu up to maxAttempts times. Returns undefined on success, or failure info. */
+  /** Attempts the binary call up to maxAttempts times. Returns undefined on success. */
   async attemptSend(entry, maxAttempts, startMs) {
     let lastError;
     const lastOutput = { stdout: "", stderr: "" };
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       if (this.isStopped) {
         this.activeAssociations--;
-        entry.resolve(err(new Error("DicomSender: sender stopped")));
+        entry.resolve(err(new Error(`${this.config.senderName}: sender stopped`)));
         return void 0;
       }
-      const result = await this.callStorescu(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);
         return void 0;
       }
       lastError = result.error;
       if (attempt < maxAttempts - 1) {
-        await delay2(this.retryDelayMs * (attempt + 1));
+        await delay2(this.config.retryDelayMs * (attempt + 1));
       }
     }
-    return { error: lastError ?? new Error("DicomSender: send failed"), output: lastOutput };
-  }
-  /** Calls storescu with the configured options. */
-  callStorescu(entry) {
-    return storescu({
-      host: this.options.host,
-      port: this.options.port,
-      files: [...entry.files],
-      calledAETitle: entry.calledAETitle ?? this.options.calledAETitle,
-      callingAETitle: entry.callingAETitle ?? this.options.callingAETitle,
-      proposedTransferSyntax: entry.proposedTransferSyntax ?? this.options.proposedTransferSyntax,
-      combineProposedTransferSyntaxes: entry.combineProposedTransferSyntaxes ?? this.options.combineProposedTransferSyntaxes,
-      maxPduReceive: this.options.maxPduReceive,
-      maxPduSend: this.options.maxPduSend,
-      associationTimeout: this.options.associationTimeout,
-      acseTimeout: this.options.acseTimeout,
-      dimseTimeout: this.options.dimseTimeout,
-      noHostnameLookup: this.options.noHostnameLookup,
-      verbosity: this.options.verbosity,
-      required: entry.required ?? this.options.required,
-      timeoutMs: entry.timeoutMs,
-      signal: this.options.signal
-    });
+    return { error: lastError ?? new Error(`${this.config.senderName}: send failed`), output: lastOutput };
   }
   /** Handles a successful send: updates state, emits event, resolves promise. */
   handleSendSuccess(entry, startMs, output) {
@@ -37326,7 +37168,7 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
     const durationMs = Date.now() - startMs;
     this.recordSuccess();
     const data = { files: entry.files, fileCount: entry.files.length, durationMs, stdout: output.stdout, stderr: output.stderr };
-    this.emit("SEND_COMPLETE", data);
+    this.config.emitters.emitSendComplete(data);
     entry.resolve(ok(data));
     this.drainQueue();
   }
@@ -37344,8 +37186,8 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
       if (this.health === SenderHealth.DOWN) {
         this.health = SenderHealth.DEGRADED;
       } else {
-        this.effectiveMaxAssociations = Math.min(this.effectiveMaxAssociations * 2, this.configuredMaxAssociations);
-        if (this.effectiveMaxAssociations >= this.configuredMaxAssociations) {
+        this.effectiveMaxAssociations = Math.min(this.effectiveMaxAssociations * 2, this.config.configuredMaxAssociations);
+        if (this.effectiveMaxAssociations >= this.config.configuredMaxAssociations) {
           this.health = SenderHealth.HEALTHY;
         }
       }
@@ -37365,22 +37207,26 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
         this.emitHealthChanged(previousHealth);
       }
     } else if (this.consecutiveFailures >= DEGRADE_THRESHOLD && this.consecutiveFailures % DEGRADE_THRESHOLD === 0) {
-      if (this.health === SenderHealth.HEALTHY) {
-        this.health = SenderHealth.DEGRADED;
-        this.effectiveMaxAssociations = Math.max(1, Math.floor(this.configuredMaxAssociations / 2));
+      this.degradeHealth(previousHealth);
+    }
+  }
+  /** Handles HEALTHY→DEGRADED or DEGRADED→DEGRADED transitions. */
+  degradeHealth(previousHealth) {
+    if (this.health === SenderHealth.HEALTHY) {
+      this.health = SenderHealth.DEGRADED;
+      this.effectiveMaxAssociations = Math.max(1, Math.floor(this.config.configuredMaxAssociations / 2));
+      this.emitHealthChanged(previousHealth);
+    } else if (this.health === SenderHealth.DEGRADED) {
+      const newMax = Math.max(1, Math.floor(this.effectiveMaxAssociations / 2));
+      if (newMax !== this.effectiveMaxAssociations) {
+        this.effectiveMaxAssociations = newMax;
         this.emitHealthChanged(previousHealth);
-      } else if (this.health === SenderHealth.DEGRADED) {
-        const newMax = Math.max(1, Math.floor(this.effectiveMaxAssociations / 2));
-        if (newMax !== this.effectiveMaxAssociations) {
-          this.effectiveMaxAssociations = newMax;
-          this.emitHealthChanged(previousHealth);
-        }
       }
     }
   }
-  /** Emits a HEALTH_CHANGED event. */
+  /** Emits a HEALTH_CHANGED event via the wrapper's emitter. */
   emitHealthChanged(previousHealth) {
-    this.emit("HEALTH_CHANGED", {
+    this.config.emitters.emitHealthChanged({
       previousHealth,
       newHealth: this.health,
       effectiveMaxAssociations: this.effectiveMaxAssociations,
@@ -37420,20 +37266,6 @@ var DicomSender = class _DicomSender extends events.EventEmitter {
       check();
     });
   }
-  // -----------------------------------------------------------------------
-  // Abort signal
-  // -----------------------------------------------------------------------
-  /** Wires an AbortSignal to stop the sender. */
-  wireAbortSignal(signal) {
-    if (signal.aborted) {
-      void this.stop();
-      return;
-    }
-    this.abortHandler = () => {
-      void this.stop();
-    };
-    signal.addEventListener("abort", this.abortHandler, { once: true });
-  }
 };
 function delay2(ms) {
   return new Promise((resolve) => {
@@ -37441,6 +37273,492 @@ function delay2(ms) {
   });
 }
 
+// src/senders/DicomSender.ts
+var DEFAULT_MAX_ASSOCIATIONS = 4;
+var DEFAULT_MAX_QUEUE_LENGTH = 1e3;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY_MS = 1e3;
+var DEFAULT_BUCKET_FLUSH_MS = 5e3;
+var DEFAULT_MAX_BUCKET_SIZE = 50;
+var MAX_ASSOCIATIONS_LIMIT = 64;
+var DicomSenderOptionsSchema = zod.z.object({
+  host: zod.z.string().min(1),
+  port: zod.z.number().int().min(1).max(65535),
+  calledAETitle: zod.z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  callingAETitle: zod.z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  mode: zod.z.enum(["single", "multiple", "bucket"]).optional(),
+  maxAssociations: zod.z.number().int().min(1).max(MAX_ASSOCIATIONS_LIMIT).optional(),
+  proposedTransferSyntax: zod.z.union([zod.z.enum(PROPOSED_TS_VALUES), zod.z.array(zod.z.enum(PROPOSED_TS_VALUES)).min(1)]).optional(),
+  combineProposedTransferSyntaxes: zod.z.boolean().optional(),
+  maxQueueLength: zod.z.number().int().min(1).optional(),
+  timeoutMs: zod.z.number().int().positive().optional(),
+  maxRetries: zod.z.number().int().min(0).optional(),
+  retryDelayMs: zod.z.number().int().min(0).optional(),
+  bucketFlushMs: zod.z.number().int().positive().optional(),
+  maxBucketSize: zod.z.number().int().min(1).optional(),
+  maxPduReceive: zod.z.number().int().min(4096).max(131072).optional(),
+  maxPduSend: zod.z.number().int().min(4096).max(131072).optional(),
+  associationTimeout: zod.z.number().int().positive().optional(),
+  acseTimeout: zod.z.number().int().positive().optional(),
+  dimseTimeout: zod.z.number().int().positive().optional(),
+  noHostnameLookup: zod.z.boolean().optional(),
+  verbosity: zod.z.enum(["verbose", "debug"]).optional(),
+  required: zod.z.boolean().optional(),
+  signal: zod.z.instanceof(AbortSignal).optional()
+}).strict();
+function createStorescuExecutor(options) {
+  return async (files, timeoutMs, params, signal) => {
+    const result = await storescu({
+      host: options.host,
+      port: options.port,
+      files: [...files],
+      calledAETitle: params.calledAETitle ?? options.calledAETitle,
+      callingAETitle: params.callingAETitle ?? options.callingAETitle,
+      proposedTransferSyntax: params.proposedTransferSyntax ?? options.proposedTransferSyntax,
+      combineProposedTransferSyntaxes: params.combineProposedTransferSyntaxes ?? options.combineProposedTransferSyntaxes,
+      maxPduReceive: options.maxPduReceive,
+      maxPduSend: options.maxPduSend,
+      associationTimeout: options.associationTimeout,
+      acseTimeout: options.acseTimeout,
+      dimseTimeout: options.dimseTimeout,
+      noHostnameLookup: options.noHostnameLookup,
+      verbosity: options.verbosity,
+      required: params.required ?? options.required,
+      timeoutMs,
+      signal
+    });
+    if (!result.ok) return err(result.error);
+    return ok({ stdout: result.value.stdout, stderr: result.value.stderr });
+  };
+}
+function resolveConfig(options) {
+  const mode = options.mode ?? "multiple";
+  const rawMax = options.maxAssociations ?? DEFAULT_MAX_ASSOCIATIONS;
+  return {
+    mode,
+    configuredMaxAssociations: mode === "single" ? 1 : rawMax,
+    maxQueueLength: options.maxQueueLength ?? DEFAULT_MAX_QUEUE_LENGTH,
+    defaultTimeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    defaultMaxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES,
+    retryDelayMs: options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS,
+    bucketFlushMs: options.bucketFlushMs ?? DEFAULT_BUCKET_FLUSH_MS,
+    maxBucketSize: options.maxBucketSize ?? DEFAULT_MAX_BUCKET_SIZE
+  };
+}
+var DicomSender = class _DicomSender extends events.EventEmitter {
+  constructor(engine, cfg, signal) {
+    super();
+    __publicField(this, "engine");
+    __publicField(this, "defaultTimeoutMs");
+    __publicField(this, "defaultMaxRetries");
+    __publicField(this, "signal");
+    __publicField(this, "abortHandler");
+    this.setMaxListeners(20);
+    this.on("error", () => {
+    });
+    this.engine = engine;
+    this.defaultTimeoutMs = cfg.defaultTimeoutMs;
+    this.defaultMaxRetries = cfg.defaultMaxRetries;
+    this.signal = signal;
+    if (signal !== void 0) {
+      this.wireAbortSignal(signal);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /**
+   * Creates a new DicomSender instance.
+   *
+   * @param options - Configuration options
+   * @returns A Result containing the instance or a validation error
+   */
+  static create(options) {
+    const validation = DicomSenderOptionsSchema.safeParse(options);
+    if (!validation.success) {
+      return err(createValidationError("DicomSender", validation.error));
+    }
+    const cfg = resolveConfig(options);
+    const senderRef = { current: void 0 };
+    const engine = new SenderEngine({
+      ...cfg,
+      executor: createStorescuExecutor(options),
+      signal: options.signal,
+      senderName: "DicomSender",
+      emitters: {
+        emitSendComplete: (data) => {
+          senderRef.current.emit("SEND_COMPLETE", data);
+        },
+        emitSendFailed: (data) => {
+          senderRef.current.emit("SEND_FAILED", data);
+        },
+        emitHealthChanged: (data) => {
+          senderRef.current.emit("HEALTH_CHANGED", data);
+        },
+        emitBucketFlushed: (data) => {
+          senderRef.current.emit("BUCKET_FLUSHED", data);
+        }
+      }
+    });
+    const sender = new _DicomSender(engine, cfg, options.signal);
+    senderRef.current = sender;
+    return ok(sender);
+  }
+  /**
+   * Sends one or more DICOM files to the remote endpoint.
+   *
+   * In single/multiple mode, files are sent as one storescu call.
+   * In bucket mode, files are accumulated into a bucket and flushed
+   * when the bucket reaches maxBucketSize or the flush timer fires.
+   *
+   * The returned promise resolves when the files are actually sent
+   * (not just queued). Callers can await for confirmation or
+   * fire-and-forget with `void sender.send(files)`.
+   *
+   * @param files - One or more DICOM file paths
+   * @param options - Per-send overrides
+   * @returns A Result containing the send result or an error
+   */
+  send(files, options) {
+    const params = buildStorescuParams(options);
+    const timeoutMs = options?.timeoutMs ?? this.defaultTimeoutMs;
+    const maxRetries = options?.maxRetries ?? this.defaultMaxRetries;
+    return this.engine.send(files, timeoutMs, maxRetries, params);
+  }
+  /**
+   * Flushes the current bucket immediately (bucket mode only).
+   * In single/multiple mode this is a no-op.
+   */
+  flush() {
+    this.engine.flush();
+  }
+  /**
+   * Gracefully stops the sender. Rejects all queued items and
+   * waits for active associations to complete.
+   */
+  async stop() {
+    if (this.signal !== void 0 && this.abortHandler !== void 0) {
+      this.signal.removeEventListener("abort", this.abortHandler);
+    }
+    await this.engine.stop();
+  }
+  /** Current sender status. */
+  get status() {
+    return this.engine.status;
+  }
+  // -----------------------------------------------------------------------
+  // Typed event listener convenience methods
+  // -----------------------------------------------------------------------
+  /**
+   * Registers a typed listener for a DicomSender-specific event.
+   *
+   * @param event - The event name from DicomSenderEventMap
+   * @param listener - Callback receiving typed event data
+   * @returns this for chaining
+   */
+  onEvent(event, listener) {
+    return this.on(event, listener);
+  }
+  /**
+   * Registers a listener for successful sends.
+   *
+   * @param listener - Callback receiving send complete data
+   * @returns this for chaining
+   */
+  onSendComplete(listener) {
+    return this.on("SEND_COMPLETE", listener);
+  }
+  /**
+   * Registers a listener for failed sends.
+   *
+   * @param listener - Callback receiving send failed data
+   * @returns this for chaining
+   */
+  onSendFailed(listener) {
+    return this.on("SEND_FAILED", listener);
+  }
+  /**
+   * Registers a listener for health state changes.
+   *
+   * @param listener - Callback receiving health change data
+   * @returns this for chaining
+   */
+  onHealthChanged(listener) {
+    return this.on("HEALTH_CHANGED", listener);
+  }
+  /**
+   * Registers a listener for bucket flushes (bucket mode only).
+   *
+   * @param listener - Callback receiving bucket flush data
+   * @returns this for chaining
+   */
+  onBucketFlushed(listener) {
+    return this.on("BUCKET_FLUSHED", listener);
+  }
+  // -----------------------------------------------------------------------
+  // Abort signal
+  // -----------------------------------------------------------------------
+  /** Wires an AbortSignal to stop the sender. */
+  wireAbortSignal(signal) {
+    if (signal.aborted) {
+      void this.stop();
+      return;
+    }
+    this.abortHandler = () => {
+      void this.stop();
+    };
+    signal.addEventListener("abort", this.abortHandler, { once: true });
+  }
+};
+function buildStorescuParams(options) {
+  return {
+    calledAETitle: options?.calledAETitle,
+    callingAETitle: options?.callingAETitle,
+    required: options?.required,
+    proposedTransferSyntax: options?.proposedTransferSyntax,
+    combineProposedTransferSyntaxes: options?.combineProposedTransferSyntaxes
+  };
+}
+var DEFAULT_MAX_ASSOCIATIONS2 = 4;
+var DEFAULT_MAX_QUEUE_LENGTH2 = 1e3;
+var DEFAULT_MAX_RETRIES2 = 3;
+var DEFAULT_RETRY_DELAY_MS2 = 1e3;
+var DEFAULT_BUCKET_FLUSH_MS2 = 5e3;
+var DEFAULT_MAX_BUCKET_SIZE2 = 50;
+var MAX_ASSOCIATIONS_LIMIT2 = 64;
+var DicomSendOptionsSchema = zod.z.object({
+  host: zod.z.string().min(1),
+  port: zod.z.number().int().min(1).max(65535),
+  calledAETitle: zod.z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  callingAETitle: zod.z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  mode: zod.z.enum(["single", "multiple", "bucket"]).optional(),
+  maxAssociations: zod.z.number().int().min(1).max(MAX_ASSOCIATIONS_LIMIT2).optional(),
+  maxQueueLength: zod.z.number().int().min(1).optional(),
+  timeoutMs: zod.z.number().int().positive().optional(),
+  maxRetries: zod.z.number().int().min(0).optional(),
+  retryDelayMs: zod.z.number().int().min(0).optional(),
+  bucketFlushMs: zod.z.number().int().positive().optional(),
+  maxBucketSize: zod.z.number().int().min(1).optional(),
+  maxPduReceive: zod.z.number().int().min(4096).max(131072).optional(),
+  maxPduSend: zod.z.number().int().min(4096).max(131072).optional(),
+  associationTimeout: zod.z.number().int().positive().optional(),
+  acseTimeout: zod.z.number().int().positive().optional(),
+  dimseTimeout: zod.z.number().int().positive().optional(),
+  noHostnameLookup: zod.z.boolean().optional(),
+  verbosity: zod.z.enum(["verbose", "debug"]).optional(),
+  noHalt: zod.z.boolean().optional(),
+  noIllegalProposal: zod.z.boolean().optional(),
+  decompress: zod.z.enum(["never", "lossless", "lossy"]).optional(),
+  multiAssociations: zod.z.boolean().optional(),
+  noUidChecks: zod.z.boolean().optional(),
+  signal: zod.z.instanceof(AbortSignal).optional()
+}).strict();
+function createDcmsendExecutor(options) {
+  return async (files, timeoutMs, params, signal) => {
+    const result = await dcmsend({
+      host: options.host,
+      port: options.port,
+      files: [...files],
+      calledAETitle: params.calledAETitle ?? options.calledAETitle,
+      callingAETitle: params.callingAETitle ?? options.callingAETitle,
+      maxPduReceive: options.maxPduReceive,
+      maxPduSend: options.maxPduSend,
+      associationTimeout: options.associationTimeout,
+      acseTimeout: options.acseTimeout,
+      dimseTimeout: options.dimseTimeout,
+      noHostnameLookup: options.noHostnameLookup,
+      verbosity: options.verbosity,
+      noHalt: options.noHalt,
+      noIllegalProposal: options.noIllegalProposal,
+      decompress: options.decompress,
+      multiAssociations: options.multiAssociations,
+      noUidChecks: options.noUidChecks,
+      timeoutMs,
+      signal
+    });
+    if (!result.ok) return err(result.error);
+    return ok({ stdout: result.value.stdout, stderr: result.value.stderr });
+  };
+}
+function resolveConfig2(options) {
+  const mode = options.mode ?? "multiple";
+  const rawMax = options.maxAssociations ?? DEFAULT_MAX_ASSOCIATIONS2;
+  return {
+    mode,
+    configuredMaxAssociations: mode === "single" ? 1 : rawMax,
+    maxQueueLength: options.maxQueueLength ?? DEFAULT_MAX_QUEUE_LENGTH2,
+    defaultTimeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    defaultMaxRetries: options.maxRetries ?? DEFAULT_MAX_RETRIES2,
+    retryDelayMs: options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS2,
+    bucketFlushMs: options.bucketFlushMs ?? DEFAULT_BUCKET_FLUSH_MS2,
+    maxBucketSize: options.maxBucketSize ?? DEFAULT_MAX_BUCKET_SIZE2
+  };
+}
+var DicomSend = class _DicomSend extends events.EventEmitter {
+  constructor(engine, cfg, signal) {
+    super();
+    __publicField(this, "engine");
+    __publicField(this, "defaultTimeoutMs");
+    __publicField(this, "defaultMaxRetries");
+    __publicField(this, "signal");
+    __publicField(this, "abortHandler");
+    this.setMaxListeners(20);
+    this.on("error", () => {
+    });
+    this.engine = engine;
+    this.defaultTimeoutMs = cfg.defaultTimeoutMs;
+    this.defaultMaxRetries = cfg.defaultMaxRetries;
+    this.signal = signal;
+    if (signal !== void 0) {
+      this.wireAbortSignal(signal);
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /**
+   * Creates a new DicomSend instance.
+   *
+   * @param options - Configuration options
+   * @returns A Result containing the instance or a validation error
+   */
+  static create(options) {
+    const validation = DicomSendOptionsSchema.safeParse(options);
+    if (!validation.success) {
+      return err(createValidationError("DicomSend", validation.error));
+    }
+    const cfg = resolveConfig2(options);
+    const senderRef = { current: void 0 };
+    const engine = new SenderEngine({
+      ...cfg,
+      executor: createDcmsendExecutor(options),
+      signal: options.signal,
+      senderName: "DicomSend",
+      emitters: {
+        emitSendComplete: (data) => {
+          senderRef.current.emit("SEND_COMPLETE", data);
+        },
+        emitSendFailed: (data) => {
+          senderRef.current.emit("SEND_FAILED", data);
+        },
+        emitHealthChanged: (data) => {
+          senderRef.current.emit("HEALTH_CHANGED", data);
+        },
+        emitBucketFlushed: (data) => {
+          senderRef.current.emit("BUCKET_FLUSHED", data);
+        }
+      }
+    });
+    const sender = new _DicomSend(engine, cfg, options.signal);
+    senderRef.current = sender;
+    return ok(sender);
+  }
+  /**
+   * Sends one or more DICOM files to the remote endpoint.
+   *
+   * In single/multiple mode, files are sent as one dcmsend call.
+   * In bucket mode, files are accumulated into a bucket and flushed
+   * when the bucket reaches maxBucketSize or the flush timer fires.
+   *
+   * @param files - One or more DICOM file paths
+   * @param options - Per-send overrides
+   * @returns A Result containing the send result or an error
+   */
+  send(files, options) {
+    const params = {
+      calledAETitle: options?.calledAETitle,
+      callingAETitle: options?.callingAETitle
+    };
+    const timeoutMs = options?.timeoutMs ?? this.defaultTimeoutMs;
+    const maxRetries = options?.maxRetries ?? this.defaultMaxRetries;
+    return this.engine.send(files, timeoutMs, maxRetries, params);
+  }
+  /**
+   * Flushes the current bucket immediately (bucket mode only).
+   * In single/multiple mode this is a no-op.
+   */
+  flush() {
+    this.engine.flush();
+  }
+  /**
+   * Gracefully stops the sender. Rejects all queued items and
+   * waits for active associations to complete.
+   */
+  async stop() {
+    if (this.signal !== void 0 && this.abortHandler !== void 0) {
+      this.signal.removeEventListener("abort", this.abortHandler);
+    }
+    await this.engine.stop();
+  }
+  /** Current sender status. */
+  get status() {
+    return this.engine.status;
+  }
+  // -----------------------------------------------------------------------
+  // Typed event listener convenience methods
+  // -----------------------------------------------------------------------
+  /**
+   * Registers a typed listener for a DicomSend-specific event.
+   *
+   * @param event - The event name from DicomSendEventMap
+   * @param listener - Callback receiving typed event data
+   * @returns this for chaining
+   */
+  onEvent(event, listener) {
+    return this.on(event, listener);
+  }
+  /**
+   * Registers a listener for successful sends.
+   *
+   * @param listener - Callback receiving send complete data
+   * @returns this for chaining
+   */
+  onSendComplete(listener) {
+    return this.on("SEND_COMPLETE", listener);
+  }
+  /**
+   * Registers a listener for failed sends.
+   *
+   * @param listener - Callback receiving send failed data
+   * @returns this for chaining
+   */
+  onSendFailed(listener) {
+    return this.on("SEND_FAILED", listener);
+  }
+  /**
+   * Registers a listener for health state changes.
+   *
+   * @param listener - Callback receiving health change data
+   * @returns this for chaining
+   */
+  onHealthChanged(listener) {
+    return this.on("HEALTH_CHANGED", listener);
+  }
+  /**
+   * Registers a listener for bucket flushes (bucket mode only).
+   *
+   * @param listener - Callback receiving bucket flush data
+   * @returns this for chaining
+   */
+  onBucketFlushed(listener) {
+    return this.on("BUCKET_FLUSHED", listener);
+  }
+  // -----------------------------------------------------------------------
+  // Abort signal
+  // -----------------------------------------------------------------------
+  /** Wires an AbortSignal to stop the sender. */
+  wireAbortSignal(signal) {
+    if (signal.aborted) {
+      void this.stop();
+      return;
+    }
+    this.abortHandler = () => {
+      void this.stop();
+    };
+    signal.addEventListener("abort", this.abortHandler, { once: true });
+  }
+};
+
 // src/pacs/types.ts
 var QueryLevel = {
   STUDY: "STUDY",
@@ -37990,7 +38308,7 @@ var DEFAULT_CONFIG = {
   signal: void 0,
   onRetry: void 0
 };
-function resolveConfig2(opts) {
+function resolveConfig3(opts) {
   if (!opts) return DEFAULT_CONFIG;
   return {
     ...DEFAULT_CONFIG,
@@ -38035,7 +38353,7 @@ function shouldBreakAfterFailure(attempt, lastError, config) {
   return false;
 }
 async function retry(operation, options) {
-  const config = resolveConfig2(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();
@@ -38083,6 +38401,7 @@ exports.DcmtkProcess = DcmtkProcess;
 exports.DicomDataset = DicomDataset;
 exports.DicomInstance = DicomInstance;
 exports.DicomReceiver = DicomReceiver;
+exports.DicomSend = DicomSend;
 exports.DicomSender = DicomSender;
 exports.DicomTagPathSchema = DicomTagPathSchema;
 exports.DicomTagSchema = DicomTagSchema;