@ubercode/dcmtk 0.1.4 → 0.3.0

package/dist/servers.js

@@ -1,10 +1,16 @@
 import { z } from 'zod';
 import { EventEmitter } from 'events';
 import { spawn, execSync } from 'child_process';
-import { stderr } from 'stderr-lib';
+import { stderr, tryCatch } from 'stderr-lib';
 import kill from 'tree-kill';
-import { join } from 'path';
+import * as path from 'path';
+import { join, normalize } from 'path';
 import { existsSync } from 'fs';
+import * as net from 'net';
+import * as fs from 'fs/promises';
+import { copyFile, unlink, stat } from 'fs/promises';
+import * as os from 'os';
+import { XMLParser } from 'fast-xml-parser';
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -19,6 +25,7 @@ function err(error) {
 }
 
 // src/constants.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_START_TIMEOUT_MS = 1e4;
 var DEFAULT_DRAIN_TIMEOUT_MS = 5e3;
 var DEFAULT_BLOCK_TIMEOUT_MS = 1e3;
@@ -27,6 +34,8 @@ var UNIX_SEARCH_PATHS = ["/usr/local/bin", "/usr/bin", "/opt/local/bin", "/opt/h
 var REQUIRED_BINARIES = ["dcm2json", "dcm2xml", "dcmodify", "dcmdump", "dcmrecv", "dcmsend", "echoscu"];
 var MAX_BLOCK_LINES = 1e3;
 var MAX_EVENT_PATTERNS = 200;
+var MAX_TRAVERSAL_DEPTH = 50;
+var MAX_CHANGESET_OPERATIONS = 1e4;
 var MAX_OUTPUT_BYTES = 100 * 1024 * 1024;
 
 // src/DcmtkProcess.ts
@@ -374,7 +383,10 @@ var LineParser = class extends EventEmitter {
 };
 
 // src/patterns.ts
-var AE_TITLE_PATTERN = /^[A-Za-z0-9 -]+$/;
+var DICOM_TAG_PATTERN = /^\([0-9A-Fa-f]{4},[0-9A-Fa-f]{4}\)$/;
+var AE_TITLE_PATTERN = /^[\x20-\x5b\x5d-\x7e]+$/;
+var UID_PATTERN = /^[0-9]+(\.[0-9]+)*$/;
+var UID_MAX_LENGTH = 64;
 var PATH_TRAVERSAL_PATTERN = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
 function isValidAETitle(value) {
   return AE_TITLE_PATTERN.test(value);
@@ -480,6 +492,39 @@ function resolveBinary(toolName) {
   return ok(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, stderr6) {
+  const argsStr = truncate(args.join(" "), MAX_ARGS_LENGTH);
+  const stderrStr = truncate(stderr6.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/events/dcmrecv.ts
 var DcmrecvEvent = {
   LISTENING: "LISTENING",
@@ -491,7 +536,11 @@ var DcmrecvEvent = {
   ASSOCIATION_ABORTED: "ASSOCIATION_ABORTED",
   ECHO_REQUEST: "ECHO_REQUEST",
   CANNOT_START_LISTENER: "CANNOT_START_LISTENER",
-  REFUSING_ASSOCIATION: "REFUSING_ASSOCIATION"
+  REFUSING_ASSOCIATION: "REFUSING_ASSOCIATION",
+  /** Synthetic: STORED_FILE enriched with association context. */
+  FILE_RECEIVED: "FILE_RECEIVED",
+  /** Synthetic: emitted on association release/abort with summary. */
+  ASSOCIATION_COMPLETE: "ASSOCIATION_COMPLETE"
 };
 var DCMRECV_PATTERNS = [
   {
@@ -501,9 +550,9 @@ var DCMRECV_PATTERNS = [
   },
   {
     event: DcmrecvEvent.ASSOCIATION_RECEIVED,
-    pattern: /Association Received\s{1,100}([^:]+):\s*"([^"]+)"\s*->\s*"([^"]+)"/,
+    pattern: /Association Received\s{1,100}(\S+):\s+(\S+)\s+->\s+(\S+)/,
     processor: (match) => ({
-      address: match[1] ?? "",
+      source: match[1] ?? "",
       callingAE: match[2] ?? "",
       calledAE: match[3] ?? ""
     })
@@ -531,7 +580,7 @@ var DCMRECV_PATTERNS = [
   },
   {
     event: DcmrecvEvent.ASSOCIATION_RELEASE,
-    pattern: /Received Association Release/i,
+    pattern: /Association Release/i,
     processor: () => void 0
   },
   {
@@ -561,6 +610,95 @@ var DCMRECV_PATTERNS = [
 ];
 var DCMRECV_FATAL_EVENTS = /* @__PURE__ */ new Set([DcmrecvEvent.CANNOT_START_LISTENER]);
 
+// src/servers/AssociationTracker.ts
+var AssociationTracker = class {
+  constructor() {
+    __publicField(this, "association");
+    __publicField(this, "counter", 0);
+  }
+  /**
+   * Begins a new association, transitioning from IDLE to ACTIVE.
+   *
+   * If an association is already active, it is silently ended (abort)
+   * and the new one begins.
+   *
+   * @param data - Association metadata
+   * @returns The unique association ID
+   */
+  beginAssociation(data) {
+    this.counter++;
+    const associationId = `assoc-${String(this.counter)}`;
+    this.association = {
+      associationId,
+      callingAE: data.callingAE,
+      calledAE: data.calledAE,
+      source: data.source,
+      startTime: Date.now(),
+      files: []
+    };
+    return associationId;
+  }
+  /**
+   * Tracks a file received during the current association.
+   *
+   * If no association is active, returns a TrackedFile with empty context.
+   *
+   * @param filePath - Path to the received file
+   * @returns A TrackedFile enriched with association context
+   */
+  trackFile(filePath) {
+    if (this.association === void 0) {
+      return {
+        filePath,
+        associationId: "",
+        callingAE: "",
+        calledAE: "",
+        source: ""
+      };
+    }
+    this.association.files.push(filePath);
+    return {
+      filePath,
+      associationId: this.association.associationId,
+      callingAE: this.association.callingAE,
+      calledAE: this.association.calledAE,
+      source: this.association.source
+    };
+  }
+  /**
+   * Ends the current association, transitioning from ACTIVE to IDLE.
+   *
+   * @param reason - Why the association ended
+   * @returns An AssociationSummary, or undefined if no association was active
+   */
+  endAssociation(reason) {
+    if (this.association === void 0) return void 0;
+    const summary = {
+      associationId: this.association.associationId,
+      callingAE: this.association.callingAE,
+      calledAE: this.association.calledAE,
+      source: this.association.source,
+      files: [...this.association.files],
+      durationMs: Date.now() - this.association.startTime,
+      endReason: reason
+    };
+    this.association = void 0;
+    return summary;
+  }
+  /** The currently active association context, or undefined. */
+  get current() {
+    return this.association;
+  }
+  /** Whether an association is currently active. */
+  get isActive() {
+    return this.association !== void 0;
+  }
+  /** Resets the tracker to IDLE, discarding any active association. */
+  reset() {
+    this.association = void 0;
+  }
+};
+
 // src/servers/Dcmrecv.ts
 var SubdirectoryMode = {
   NONE: "none",
@@ -645,13 +783,16 @@ function addNetworkArgs(args, options) {
   }
 }
 var Dcmrecv = class _Dcmrecv extends DcmtkProcess {
-  constructor(config, parser, signal) {
+  constructor(config, parser2, signal) {
     super(config);
     __publicField(this, "parser");
+    __publicField(this, "tracker");
     __publicField(this, "abortSignal");
     __publicField(this, "abortHandler");
-    this.parser = parser;
+    this.parser = parser2;
+    this.tracker = new AssociationTracker();
     this.wireParser();
+    this.wireTracker();
     if (signal !== void 0) {
       this.wireAbortSignal(signal);
     }
@@ -692,6 +833,24 @@ var Dcmrecv = class _Dcmrecv extends DcmtkProcess {
   onStoredFile(listener) {
     return this.onEvent("STORED_FILE", listener);
   }
+  /**
+   * Registers a listener for received files enriched with association context.
+   *
+   * @param listener - Callback receiving tracked file data
+   * @returns this for chaining
+   */
+  onFileReceived(listener) {
+    return this.onEvent("FILE_RECEIVED", listener);
+  }
+  /**
+   * Registers a listener for completed associations.
+   *
+   * @param listener - Callback receiving association summary
+   * @returns this for chaining
+   */
+  onAssociationComplete(listener) {
+    return this.onEvent("ASSOCIATION_COMPLETE", listener);
+  }
   /**
    * Creates a new Dcmrecv server instance.
    *
@@ -701,16 +860,16 @@ var Dcmrecv = class _Dcmrecv extends DcmtkProcess {
   static create(options) {
     const validation = DcmrecvOptionsSchema.safeParse(options);
     if (!validation.success) {
-      return err(new Error(`dcmrecv: invalid options: ${validation.error.message}`));
+      return err(createValidationError("dcmrecv", validation.error));
     }
     const binaryResult = resolveBinary("dcmrecv");
     if (!binaryResult.ok) {
       return err(binaryResult.error);
     }
     const args = buildArgs(options);
-    const parser = new LineParser();
+    const parser2 = new LineParser();
     for (const pattern of DCMRECV_PATTERNS) {
-      const addResult = parser.addPattern(pattern);
+      const addResult = parser2.addPattern(pattern);
       if (!addResult.ok) {
         return err(addResult.error);
       }
@@ -722,7 +881,7 @@ var Dcmrecv = class _Dcmrecv extends DcmtkProcess {
       drainTimeoutMs: options.drainTimeoutMs,
       isStartedPredicate: (line) => /listening/i.test(line)
     };
-    return ok(new _Dcmrecv(config, parser, options.signal));
+    return ok(new _Dcmrecv(config, parser2, options.signal));
   }
   /** Wires the line parser to the process output. */
   wireParser() {
@@ -734,7 +893,29 @@ var Dcmrecv = class _Dcmrecv extends DcmtkProcess {
         this.emit("error", { error: new Error(`Fatal: ${event}`), fatal: true });
         void this.stop();
       }
-      this.emit(event, ...[data]);
+      this.emit(event, data);
+    });
+  }
+  /** Wires the AssociationTracker to server events. */
+  wireTracker() {
+    this.onEvent("ASSOCIATION_RECEIVED", (data) => {
+      this.tracker.beginAssociation(data);
+    });
+    this.onEvent("STORED_FILE", (data) => {
+      const tracked = this.tracker.trackFile(data.filePath);
+      this.emit(DcmrecvEvent.FILE_RECEIVED, tracked);
+    });
+    this.onEvent("ASSOCIATION_RELEASE", () => {
+      const summary = this.tracker.endAssociation("release");
+      if (summary !== void 0) {
+        this.emit(DcmrecvEvent.ASSOCIATION_COMPLETE, summary);
+      }
+    });
+    this.onEvent("ASSOCIATION_ABORTED", () => {
+      const summary = this.tracker.endAssociation("abort");
+      if (summary !== void 0) {
+        this.emit(DcmrecvEvent.ASSOCIATION_COMPLETE, summary);
+      }
     });
   }
   /** Wires an AbortSignal to stop the server. */
@@ -757,6 +938,11 @@ var StorescpEvent = {
   STORING_FILE: "STORING_FILE",
   SUBDIRECTORY_CREATED: "SUBDIRECTORY_CREATED"
 };
+var STORESCP_ASSOCIATION_RECEIVED = {
+  event: StorescpEvent.ASSOCIATION_RECEIVED,
+  pattern: /Association Received/i,
+  processor: () => ({ source: "", callingAE: "", calledAE: "" })
+};
 var STORESCP_ADDITIONAL_PATTERNS = [
   {
     event: StorescpEvent.STORING_FILE,
@@ -773,7 +959,11 @@ var STORESCP_ADDITIONAL_PATTERNS = [
     })
   }
 ];
-var STORESCP_PATTERNS = [...DCMRECV_PATTERNS, ...STORESCP_ADDITIONAL_PATTERNS];
+var STORESCP_PATTERNS = [
+  ...DCMRECV_PATTERNS.filter((p) => p.event !== DcmrecvEvent.ASSOCIATION_RECEIVED),
+  STORESCP_ASSOCIATION_RECEIVED,
+  ...STORESCP_ADDITIONAL_PATTERNS
+];
 var STORESCP_FATAL_EVENTS = /* @__PURE__ */ new Set([...DCMRECV_FATAL_EVENTS]);
 
 // src/servers/StoreSCP.ts
@@ -783,6 +973,23 @@ var PreferredTransferSyntax = {
   IMPLICIT: "implicit",
   ACCEPT_ALL: "accept-all"
 };
+var StoreSCPPreset = {
+  /** Basic storage: unique filenames to avoid collisions. */
+  BASIC_STORAGE: {
+    uniqueFilenames: true
+  },
+  /** Testing: unique filenames, preserving raw transfer syntax. */
+  TESTING: {
+    uniqueFilenames: true,
+    bitPreserving: true
+  },
+  /** Production: unique filenames with reasonable timeouts. */
+  PRODUCTION: {
+    uniqueFilenames: true,
+    acseTimeout: 30,
+    dimseTimeout: 60
+  }
+};
 var StoreSCPOptionsSchema = z.object({
   port: z.number().int().min(1).max(65535),
   aeTitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
@@ -864,136 +1071,2089 @@ function buildNetworkArgs(args, options) {
   if (options.socketTimeout !== void 0) {
     args.push("--socket-timeout", String(options.socketTimeout));
   }
-  if (options.acseTimeout !== void 0) {
-    args.push("--acse-timeout", String(options.acseTimeout));
+  if (options.acseTimeout !== void 0) {
+    args.push("--acse-timeout", String(options.acseTimeout));
+  }
+  if (options.dimseTimeout !== void 0) {
+    args.push("--dimse-timeout", String(options.dimseTimeout));
+  }
+  if (options.maxPdu !== void 0) {
+    args.push("--max-pdu", String(options.maxPdu));
+  }
+}
+function buildExecArgs(args, options) {
+  if (options.execOnReception !== void 0) {
+    args.push("--exec-on-reception", options.execOnReception);
+  }
+  if (options.execOnEndOfStudy !== void 0) {
+    args.push("--exec-on-eostudy", options.execOnEndOfStudy);
+  }
+  if (options.endOfStudyTimeout !== void 0) {
+    args.push("--eostudy-timeout", String(options.endOfStudyTimeout));
+  }
+  if (options.renameOnEndOfStudy === true) {
+    args.push("--rename-on-eostudy");
+  }
+}
+var StoreSCP = class _StoreSCP extends DcmtkProcess {
+  constructor(config, parser2, signal) {
+    super(config);
+    __publicField(this, "parser");
+    __publicField(this, "tracker");
+    __publicField(this, "abortSignal");
+    __publicField(this, "abortHandler");
+    this.parser = parser2;
+    this.tracker = new AssociationTracker();
+    this.wireParser();
+    this.wireTracker();
+    if (signal !== void 0) {
+      this.wireAbortSignal(signal);
+    }
+  }
+  /** Disposes the server and its parser, preventing listener leaks. */
+  [Symbol.dispose]() {
+    if (this.abortSignal !== void 0 && this.abortHandler !== void 0) {
+      this.abortSignal.removeEventListener("abort", this.abortHandler);
+    }
+    this.parser[Symbol.dispose]();
+    super[Symbol.dispose]();
+  }
+  /**
+   * Registers a typed listener for a storescp-specific event.
+   *
+   * @param event - The event name from StoreSCPEventMap
+   * @param listener - Callback receiving typed event data
+   * @returns this for chaining
+   */
+  onEvent(event, listener) {
+    return this.on(event, listener);
+  }
+  /**
+   * Registers a listener for incoming associations.
+   *
+   * @param listener - Callback receiving association data
+   * @returns this for chaining
+   */
+  onAssociationReceived(listener) {
+    return this.onEvent("ASSOCIATION_RECEIVED", listener);
+  }
+  /**
+   * Registers a listener for files being stored to disk.
+   *
+   * @param listener - Callback receiving storing file data
+   * @returns this for chaining
+   */
+  onStoringFile(listener) {
+    return this.onEvent("STORING_FILE", listener);
+  }
+  /**
+   * Registers a listener for received files enriched with association context.
+   *
+   * @param listener - Callback receiving tracked file data
+   * @returns this for chaining
+   */
+  onFileReceived(listener) {
+    return this.onEvent("FILE_RECEIVED", listener);
+  }
+  /**
+   * Registers a listener for completed associations.
+   *
+   * @param listener - Callback receiving association summary
+   * @returns this for chaining
+   */
+  onAssociationComplete(listener) {
+    return this.onEvent("ASSOCIATION_COMPLETE", listener);
+  }
+  /**
+   * Creates a new StoreSCP server instance.
+   *
+   * @param options - Configuration options for the storescp server
+   * @returns A Result containing the server instance or a validation/resolution error
+   */
+  static create(options) {
+    const validation = StoreSCPOptionsSchema.safeParse(options);
+    if (!validation.success) {
+      return err(createValidationError("storescp", validation.error));
+    }
+    const binaryResult = resolveBinary("storescp");
+    if (!binaryResult.ok) {
+      return err(binaryResult.error);
+    }
+    const args = buildArgs2(options);
+    const parser2 = new LineParser();
+    for (const pattern of STORESCP_PATTERNS) {
+      const addResult = parser2.addPattern(pattern);
+      if (!addResult.ok) {
+        return err(addResult.error);
+      }
+    }
+    const config = {
+      binary: binaryResult.value,
+      args,
+      startTimeoutMs: options.startTimeoutMs,
+      drainTimeoutMs: options.drainTimeoutMs
+      // storescp doesn't print "listening" — resolve on spawn
+    };
+    return ok(new _StoreSCP(config, parser2, options.signal));
+  }
+  /** Wires the line parser to the process output. */
+  wireParser() {
+    this.on("line", ({ text }) => {
+      this.parser.feed(text);
+    });
+    this.parser.on("match", ({ event, data }) => {
+      if (STORESCP_FATAL_EVENTS.has(event)) {
+        this.emit("error", { error: new Error(`Fatal: ${event}`), fatal: true });
+        void this.stop();
+      }
+      this.emit(event, data);
+    });
+  }
+  /** Wires the AssociationTracker to server events. */
+  wireTracker() {
+    this.onEvent("ASSOCIATION_RECEIVED", (data) => {
+      this.tracker.beginAssociation(data);
+    });
+    this.onEvent("STORING_FILE", (data) => {
+      const tracked = this.tracker.trackFile(data.filePath);
+      this.emit(DcmrecvEvent.FILE_RECEIVED, tracked);
+    });
+    this.onEvent("STORED_FILE", (data) => {
+      const tracked = this.tracker.trackFile(data.filePath);
+      this.emit(DcmrecvEvent.FILE_RECEIVED, tracked);
+    });
+    this.onEvent("ASSOCIATION_RELEASE", () => {
+      const summary = this.tracker.endAssociation("release");
+      if (summary !== void 0) {
+        this.emit(DcmrecvEvent.ASSOCIATION_COMPLETE, summary);
+      }
+    });
+    this.onEvent("ASSOCIATION_ABORTED", () => {
+      const summary = this.tracker.endAssociation("abort");
+      if (summary !== void 0) {
+        this.emit(DcmrecvEvent.ASSOCIATION_COMPLETE, summary);
+      }
+    });
+  }
+  /** Wires an AbortSignal to stop the server. */
+  wireAbortSignal(signal) {
+    if (signal.aborted) {
+      void this.stop();
+      return;
+    }
+    this.abortSignal = signal;
+    this.abortHandler = () => {
+      void this.stop();
+    };
+    signal.addEventListener("abort", this.abortHandler, { once: true });
+  }
+};
+function createDicomTag(input) {
+  if (!DICOM_TAG_PATTERN.test(input)) {
+    return err(new Error(`Invalid DICOM tag: "${input}". Expected format (XXXX,XXXX) where X is a hex digit`));
+  }
+  return ok(input);
+}
+function createSOPClassUID(input) {
+  if (input.length === 0 || input.length > UID_MAX_LENGTH) {
+    return err(new Error(`Invalid SOP Class UID: "${input}". Must be 1-${UID_MAX_LENGTH} characters`));
+  }
+  if (!UID_PATTERN.test(input)) {
+    return err(new Error(`Invalid SOP Class UID: "${input}". Must be a dotted numeric OID`));
+  }
+  return ok(input);
+}
+function createDicomFilePath(input) {
+  if (input.length === 0) {
+    return err(new Error("Invalid DICOM file path: empty string"));
+  }
+  if (PATH_TRAVERSAL_PATTERN.test(input)) {
+    return err(new Error(`Invalid DICOM file path: path traversal detected in "${input}"`));
+  }
+  const normalized = normalize(input);
+  return ok(normalized);
+}
+
+// src/dicom/tagPath.ts
+var SEGMENT_PATTERN = /^\(([0-9A-Fa-f]{4}),([0-9A-Fa-f]{4})\)(?:\[(\d+|\*)\])?/;
+function matchToSegment(match) {
+  const group = match[1];
+  const element = match[2];
+  const indexStr = match[3];
+  if (group === void 0 || element === void 0) {
+    throw new Error("Failed to parse tag group/element");
+  }
+  const tagResult = createDicomTag(`(${group},${element})`);
+  if (!tagResult.ok) throw new Error(`Invalid tag in path: (${group},${element})`);
+  if (indexStr === "*") return { tag: tagResult.value, isWildcard: true };
+  if (indexStr !== void 0) return { tag: tagResult.value, index: Number(indexStr) };
+  return { tag: tagResult.value };
+}
+function advancePastMatch(remaining, matchLength) {
+  const after = remaining.slice(matchLength);
+  if (!after.startsWith(".")) return after;
+  if (after.length === 1) throw new Error("Tag path cannot end with a dot separator");
+  return after.slice(1);
+}
+function tagPathToSegments(path2) {
+  const segments = [];
+  let remaining = path2;
+  for (let i = 0; i < MAX_TRAVERSAL_DEPTH && remaining.length > 0; i++) {
+    const match = SEGMENT_PATTERN.exec(remaining);
+    if (match === null) {
+      throw new Error(`Invalid tag path segment at position ${path2.length - remaining.length}: "${remaining}"`);
+    }
+    segments.push(matchToSegment(match));
+    remaining = advancePastMatch(remaining, match[0].length);
+  }
+  if (remaining.length > 0) throw new Error(`Tag path exceeds maximum depth of ${MAX_TRAVERSAL_DEPTH}`);
+  if (segments.length === 0) throw new Error("Tag path is empty");
+  return segments;
+}
+
+// src/dicom/ChangeSet.ts
+var ERASE_PRIVATE_SENTINEL = "__ERASE_PRIVATE__";
+function isControlChar(code) {
+  if (code <= 9) return true;
+  if (code === 11 || code === 12) return true;
+  if (code >= 14 && code <= 31) return true;
+  return code === 127;
+}
+function sanitizeValue(value) {
+  let result = "";
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (!isControlChar(code)) {
+      result += value[i];
+    }
+  }
+  return result;
+}
+function buildMergedModifications(base, other, erasures) {
+  const merged = new Map(base);
+  for (const [key, value] of other) {
+    merged.set(key, value);
+  }
+  for (const key of erasures) {
+    merged.delete(key);
+  }
+  return merged;
+}
+function applyBatchEntries(initial, entries) {
+  const keys = Object.keys(entries);
+  let cs = initial;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key === void 0) continue;
+    const value = entries[key];
+    if (value === void 0) continue;
+    cs = cs.setTag(key, value);
+  }
+  return cs;
+}
+var ChangeSet = class _ChangeSet {
+  constructor(mods, erasures) {
+    __publicField(this, "mods");
+    __publicField(this, "erased");
+    this.mods = mods;
+    this.erased = erasures;
+  }
+  /** Creates an empty ChangeSet with no modifications or erasures. */
+  static empty() {
+    return new _ChangeSet(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
+  }
+  /**
+   * Sets a tag value, returning a new ChangeSet.
+   *
+   * Control characters (except LF/CR) are stripped from the value.
+   * If the tag was previously erased, it is removed from the erasure set.
+   *
+   * @param path - The DICOM tag path to set (e.g. `'(0010,0010)'`)
+   * @param value - The new value for the tag
+   * @returns A new ChangeSet with the modification applied
+   * @throws Error if operation count would exceed MAX_CHANGESET_OPERATIONS
+   */
+  setTag(path2, value) {
+    const totalOps = this.mods.size + this.erased.size;
+    if (totalOps >= MAX_CHANGESET_OPERATIONS) {
+      throw new Error(`ChangeSet operation limit (${MAX_CHANGESET_OPERATIONS}) exceeded`);
+    }
+    tagPathToSegments(path2);
+    const sanitized = sanitizeValue(value);
+    const newMods = new Map(this.mods);
+    newMods.set(path2, sanitized);
+    const newErasures = new Set(this.erased);
+    newErasures.delete(path2);
+    return new _ChangeSet(newMods, newErasures);
+  }
+  /**
+   * Marks a tag for erasure, returning a new ChangeSet.
+   *
+   * If the tag was previously set, the modification is removed.
+   *
+   * @param path - The DICOM tag path to erase (e.g. `'(0010,0010)'`)
+   * @returns A new ChangeSet with the erasure applied
+   * @throws Error if operation count would exceed MAX_CHANGESET_OPERATIONS
+   */
+  eraseTag(path2) {
+    const totalOps = this.mods.size + this.erased.size;
+    if (totalOps >= MAX_CHANGESET_OPERATIONS) {
+      throw new Error(`ChangeSet operation limit (${MAX_CHANGESET_OPERATIONS}) exceeded`);
+    }
+    tagPathToSegments(path2);
+    const newMods = new Map(this.mods);
+    newMods.delete(path2);
+    const newErasures = new Set(this.erased);
+    newErasures.add(path2);
+    return new _ChangeSet(newMods, newErasures);
+  }
+  /**
+   * Marks all private tags for erasure, returning a new ChangeSet.
+   *
+   * @returns A new ChangeSet with the erase-private flag set
+   * @throws Error if operation count would exceed MAX_CHANGESET_OPERATIONS
+   */
+  erasePrivateTags() {
+    const totalOps = this.mods.size + this.erased.size;
+    if (totalOps >= MAX_CHANGESET_OPERATIONS) {
+      throw new Error(`ChangeSet operation limit (${MAX_CHANGESET_OPERATIONS}) exceeded`);
+    }
+    const newErasures = new Set(this.erased);
+    newErasures.add(ERASE_PRIVATE_SENTINEL);
+    return new _ChangeSet(new Map(this.mods), newErasures);
+  }
+  // -----------------------------------------------------------------------
+  // Convenience setters for common DICOM tags
+  // -----------------------------------------------------------------------
+  /** Sets Patient's Name (0010,0010). */
+  setPatientName(value) {
+    return this.setTag("(0010,0010)", value);
+  }
+  /** Sets Patient ID (0010,0020). */
+  setPatientID(value) {
+    return this.setTag("(0010,0020)", value);
+  }
+  /** Sets Study Date (0008,0020). */
+  setStudyDate(value) {
+    return this.setTag("(0008,0020)", value);
+  }
+  /** Sets Modality (0008,0060). */
+  setModality(value) {
+    return this.setTag("(0008,0060)", value);
+  }
+  /** Sets Accession Number (0008,0050). */
+  setAccessionNumber(value) {
+    return this.setTag("(0008,0050)", value);
+  }
+  /** Sets Study Description (0008,1030). */
+  setStudyDescription(value) {
+    return this.setTag("(0008,1030)", value);
+  }
+  /** Sets Series Description (0008,103E). */
+  setSeriesDescription(value) {
+    return this.setTag("(0008,103E)", value);
+  }
+  /** Sets Institution Name (0008,0080). */
+  setInstitutionName(value) {
+    return this.setTag("(0008,0080)", value);
+  }
+  /**
+   * Sets multiple tags at once, returning a new ChangeSet.
+   *
+   * @param entries - A record of tag path → value pairs
+   * @returns A new ChangeSet with all modifications applied
+   */
+  setBatch(entries) {
+    return applyBatchEntries(this, entries);
+  }
+  /** All pending tag modifications as a readonly map of path → value. */
+  get modifications() {
+    return this.mods;
+  }
+  /** All pending tag erasures as a readonly set of paths. */
+  get erasures() {
+    return this.erased;
+  }
+  /** Total number of operations (modifications + erasures) in this ChangeSet. */
+  get operationCount() {
+    return this.mods.size + this.erased.size;
+  }
+  /** Whether the ChangeSet has no modifications and no erasures. */
+  get isEmpty() {
+    return this.mods.size === 0 && this.erased.size === 0;
+  }
+  /** Whether the erase-all-private-tags flag is set. */
+  get erasePrivate() {
+    return this.erased.has(ERASE_PRIVATE_SENTINEL);
+  }
+  /**
+   * Merges another ChangeSet into this one, returning a new ChangeSet.
+   *
+   * The `other` ChangeSet wins on conflicts: if the same tag is modified in both,
+   * `other`'s value is used. Erasures from both sets are unioned. An erasure in
+   * `other` removes a modification from `base`.
+   *
+   * @param other - The ChangeSet to merge in
+   * @returns A new ChangeSet with merged modifications and erasures
+   */
+  merge(other) {
+    const mergedErasures = /* @__PURE__ */ new Set([...this.erased, ...other.erased]);
+    const mergedMods = buildMergedModifications(this.mods, other.mods, mergedErasures);
+    return new _ChangeSet(mergedMods, mergedErasures);
+  }
+  /**
+   * Converts modifications to dcmodify-compatible TagModification array.
+   *
+   * @returns A readonly array of TagModification objects
+   */
+  toModifications() {
+    const result = [];
+    for (const [tag, value] of this.mods) {
+      result.push({ tag, value });
+    }
+    return result;
+  }
+  /**
+   * Converts erasures to dcmodify-compatible argument strings.
+   *
+   * The erase-private sentinel is excluded — use {@link erasePrivate} to check
+   * whether `-ep` should be passed.
+   *
+   * @returns A readonly array of tag path strings for `-e` arguments
+   */
+  toErasureArgs() {
+    const result = [];
+    for (const path2 of this.erased) {
+      if (path2 !== ERASE_PRIVATE_SENTINEL) {
+        result.push(path2);
+      }
+    }
+    return result;
+  }
+};
+var HEX_TAG_KEY = /^[0-9A-Fa-f]{8}$/;
+function isDicomJsonElement(value) {
+  return typeof value === "object" && value !== null && "vr" in value && typeof value["vr"] === "string";
+}
+function isValidDicomJsonModel(obj) {
+  const keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (key === void 0) continue;
+    if (!HEX_TAG_KEY.test(key)) return false;
+    if (!isDicomJsonElement(obj[key])) return false;
+  }
+  return true;
+}
+var TAG_WITH_PARENS = /^\(([0-9A-Fa-f]{4}),([0-9A-Fa-f]{4})\)$/;
+var TAG_HEX_ONLY = /^[0-9A-Fa-f]{8}$/;
+function normalizeTag(tag) {
+  const parenMatch = TAG_WITH_PARENS.exec(tag);
+  if (parenMatch !== null) {
+    const group = parenMatch[1];
+    const element = parenMatch[2];
+    if (group === void 0 || element === void 0) return err(new Error(`Invalid tag: "${tag}"`));
+    return ok(`${group}${element}`.toUpperCase());
+  }
+  if (TAG_HEX_ONLY.test(tag)) {
+    return ok(tag.toUpperCase());
+  }
+  return err(new Error(`Invalid tag format: "${tag}". Expected (XXXX,XXXX) or XXXXXXXX`));
+}
+function resolveElement(data, tagKey) {
+  return data[tagKey];
+}
+function extractPNAlphabetic(first) {
+  if (typeof first !== "object" || first === null) return "";
+  const pn = first;
+  const alphabetic = pn["Alphabetic"];
+  return typeof alphabetic === "string" ? alphabetic : "";
+}
+function primitiveToString(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "";
+}
+function extractString(element) {
+  const values = element.Value;
+  if (values === void 0 || values.length === 0) return "";
+  const first = values[0];
+  if (first === void 0 || first === null) return "";
+  if (element.vr === "PN") return extractPNAlphabetic(first);
+  return primitiveToString(first);
+}
+function extractNumber(element) {
+  const values = element.Value;
+  if (values === void 0 || values.length === 0) {
+    return err(new Error("Element has no Value array"));
+  }
+  const first = values[0];
+  if (typeof first === "number") return ok(first);
+  if (typeof first === "string") {
+    const parsed = Number(first);
+    if (Number.isNaN(parsed)) {
+      return err(new Error(`Cannot convert "${first}" to number`));
+    }
+    return ok(parsed);
+  }
+  return err(new Error(`Value is not numeric: ${typeof first}`));
+}
+function extractStrings(element) {
+  const values = element.Value;
+  if (values === void 0) return [];
+  const result = [];
+  for (const v of values) {
+    if (typeof v === "string") {
+      result.push(v);
+    } else if (typeof v === "number" || typeof v === "boolean") {
+      result.push(String(v));
+    } else {
+      result.push("");
+    }
+  }
+  return result;
+}
+function getSequenceItems(element) {
+  if (element.vr !== "SQ" || element.Value === void 0) return void 0;
+  return element.Value;
+}
+function isPlausibleModel(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function descendIntoSequence(element, seg) {
+  const items = getSequenceItems(element);
+  if (items === void 0) {
+    return err(new Error(`Tag ${seg.tag} is not a sequence`));
+  }
+  const idx = seg.index ?? 0;
+  const item = items[idx];
+  if (!isPlausibleModel(item)) {
+    return err(new Error(`Sequence ${seg.tag} has no valid item at index ${idx}`));
+  }
+  return ok(item);
+}
+function traversePath(data, segments) {
+  let current = data;
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg === void 0) return err(new Error("Unexpected undefined segment"));
+    const tagResult = normalizeTag(seg.tag);
+    if (!tagResult.ok) return err(tagResult.error);
+    const element = resolveElement(current, tagResult.value);
+    if (element === void 0) return err(new Error(`Tag ${seg.tag} not found`));
+    if (i === segments.length - 1) return ok(element);
+    const descent = descendIntoSequence(element, seg);
+    if (!descent.ok) return err(descent.error);
+    current = descent.value;
+  }
+  return err(new Error("Empty path segments"));
+}
+function collectWildcard(data, segments) {
+  const results = [];
+  const queue = [{ data, segmentIndex: 0 }];
+  const maxIterations = MAX_TRAVERSAL_DEPTH * 100;
+  let iteration = 0;
+  for (; iteration < maxIterations && queue.length > 0; iteration++) {
+    const entry = queue.shift();
+    if (entry === void 0) break;
+    processQueueEntry(entry, segments, results, queue);
+  }
+  return { values: results, truncated: iteration >= maxIterations && queue.length > 0 };
+}
+function processQueueEntry(entry, segments, results, queue) {
+  const seg = segments[entry.segmentIndex];
+  if (seg === void 0) return;
+  const tagResult = normalizeTag(seg.tag);
+  if (!tagResult.ok) return;
+  const element = resolveElement(entry.data, tagResult.value);
+  if (element === void 0) return;
+  const isLast = entry.segmentIndex === segments.length - 1;
+  if (isLast) {
+    collectLeafValues(element, results);
+    return;
+  }
+  enqueueSequenceItems(element, seg, entry.segmentIndex, queue);
+}
+function collectLeafValues(element, results) {
+  if (element.Value !== void 0) {
+    for (const v of element.Value) {
+      results.push(v);
+    }
+  }
+}
+function enqueueSequenceItems(element, seg, segmentIndex, queue) {
+  const items = getSequenceItems(element);
+  if (items === void 0) return;
+  if (seg.isWildcard === true) {
+    for (const item of items) {
+      if (isPlausibleModel(item)) {
+        queue.push({ data: item, segmentIndex: segmentIndex + 1 });
+      }
+    }
+  } else {
+    const idx = seg.index ?? 0;
+    const item = items[idx];
+    if (isPlausibleModel(item)) {
+      queue.push({ data: item, segmentIndex: segmentIndex + 1 });
+    }
+  }
+}
+var TAGS = {
+  AccessionNumber: "00080050",
+  PatientName: "00100010",
+  PatientID: "00100020",
+  StudyDate: "00080020",
+  Modality: "00080060",
+  SOPClassUID: "00080016",
+  StudyInstanceUID: "0020000D",
+  SeriesInstanceUID: "0020000E",
+  SOPInstanceUID: "00080018",
+  TransferSyntaxUID: "00020010"
+};
+var DicomDataset = class _DicomDataset {
+  constructor(data) {
+    __publicField(this, "data");
+    this.data = data;
+  }
+  /**
+   * Creates a DicomDataset from a DICOM JSON Model object.
+   *
+   * Performs structural validation only — verifies the input is a non-null object.
+   *
+   * @param json - A DICOM JSON Model object (typically from dcm2json)
+   * @returns A Result containing the DicomDataset or an error
+   */
+  static fromJson(json) {
+    if (json === null || json === void 0 || typeof json !== "object" || Array.isArray(json)) {
+      return err(new Error("Invalid DICOM JSON: expected a non-null, non-array object"));
+    }
+    const obj = json;
+    if (!isValidDicomJsonModel(obj)) {
+      return err(new Error('Invalid DICOM JSON: every key must be an 8-char hex tag and every value must have a "vr" string property'));
+    }
+    return ok(new _DicomDataset(json));
+  }
+  /**
+   * Gets the full DICOM JSON element for a tag.
+   *
+   * @param tag - A DicomTag `(0010,0010)` or hex string `00100010`
+   * @returns Result containing the element or an error if not found
+   */
+  getElement(tag) {
+    const norm = normalizeTag(tag);
+    if (!norm.ok) return err(norm.error);
+    const element = resolveElement(this.data, norm.value);
+    if (element === void 0) return err(new Error(`Tag ${tag} not found`));
+    return ok(element);
+  }
+  /**
+   * Gets the Value array for a tag.
+   *
+   * @param tag - A DicomTag `(0010,0010)` or hex string `00100010`
+   * @returns Result containing the readonly Value array or an error
+   */
+  getValue(tag) {
+    const elemResult = this.getElement(tag);
+    if (!elemResult.ok) return err(elemResult.error);
+    const values = elemResult.value.Value;
+    if (values === void 0) return err(new Error(`Tag ${tag} has no Value`));
+    return ok(values);
+  }
+  /**
+   * Gets the first element of the Value array for a tag.
+   *
+   * @param tag - A DicomTag `(0010,0010)` or hex string `00100010`
+   * @returns Result containing the first value or an error
+   */
+  getFirstValue(tag) {
+    const valResult = this.getValue(tag);
+    if (!valResult.ok) return err(valResult.error);
+    const first = valResult.value[0];
+    if (first === void 0) return err(new Error(`Tag ${tag} Value array is empty`));
+    return ok(first);
+  }
+  /**
+   * Gets a tag value as a string with optional fallback.
+   *
+   * Returns the fallback (default empty string) if the tag is missing or has no value.
+   * Handles PN (PersonName) values by extracting the Alphabetic component.
+   *
+   * @param tag - A DicomTag `(0010,0010)` or hex string `00100010`
+   * @param fallback - Value to return if tag is missing (default: `''`)
+   * @returns The string value or the fallback
+   */
+  getString(tag, fallback = "") {
+    const elemResult = this.getElement(tag);
+    if (!elemResult.ok) return fallback;
+    const str = extractString(elemResult.value);
+    return str.length > 0 ? str : fallback;
+  }
+  /**
+   * Gets a tag value as a validated number.
+   *
+   * @param tag - A DicomTag `(0010,0010)` or hex string `00100010`
+   * @returns Result containing the number or an error
+   */
+  getNumber(tag) {
+    const elemResult = this.getElement(tag);
+    if (!elemResult.ok) return err(elemResult.error);
+    return extractNumber(elemResult.value);
+  }
+  /**
+   * Gets all values of a tag as strings.
+   *
+   * Useful for multi-valued tags like CS (Code String).
+   *
+   * @param tag - A DicomTag `(0010,0010)` or hex string `00100010`
+   * @returns Result containing the readonly string array or an error
+   */
+  getStrings(tag) {
+    const elemResult = this.getElement(tag);
+    if (!elemResult.ok) return err(elemResult.error);
+    return ok(extractStrings(elemResult.value));
+  }
+  /**
+   * Checks whether a tag exists in the dataset.
+   *
+   * @param tag - A DicomTag `(0010,0010)` or hex string `00100010`
+   * @returns `true` if the tag is present
+   */
+  hasTag(tag) {
+    const norm = normalizeTag(tag);
+    if (!norm.ok) return false;
+    return resolveElement(this.data, norm.value) !== void 0;
+  }
+  /**
+   * Gets an element by traversing a dotted tag path through sequences.
+   *
+   * @param path - A branded DicomTagPath, e.g. `(0040,A730)[0].(0040,A160)`
+   * @returns Result containing the element at the path or an error
+   */
+  getElementAtPath(path2) {
+    let segments;
+    try {
+      segments = tagPathToSegments(path2);
+    } catch (e) {
+      return err(stderr(e));
+    }
+    return traversePath(this.data, segments);
+  }
+  /**
+   * Finds all values matching a path with wildcard `[*]` indices.
+   *
+   * Traverses all items in wildcard sequence positions using an iterative BFS queue.
+   * The traversal is bounded to {@link MAX_TRAVERSAL_DEPTH} * 100 iterations (5 000).
+   * For extremely large datasets this may truncate results silently; callers
+   * needing completeness guarantees should verify dataset size independently.
+   *
+   * @param path - A branded DicomTagPath, e.g. `(0040,A730)[*].(0040,A160)`
+   * @returns A readonly array of all matching values (may be empty)
+   */
+  findValues(path2) {
+    let segments;
+    try {
+      segments = tagPathToSegments(path2);
+    } catch {
+      return [];
+    }
+    const result = collectWildcard(this.data, segments);
+    return result.values;
+  }
+  // -----------------------------------------------------------------------
+  // Convenience readonly getters
+  // -----------------------------------------------------------------------
+  /** Accession Number (0008,0050). */
+  get accession() {
+    return this.getString(TAGS.AccessionNumber);
+  }
+  /** Patient's Name (0010,0010). */
+  get patientName() {
+    return this.getString(TAGS.PatientName);
+  }
+  /** Patient ID (0010,0020). */
+  get patientID() {
+    return this.getString(TAGS.PatientID);
+  }
+  /** Study Date (0008,0020). */
+  get studyDate() {
+    return this.getString(TAGS.StudyDate);
+  }
+  /** Modality (0008,0060). */
+  get modality() {
+    return this.getString(TAGS.Modality);
+  }
+  /** SOP Class UID (0008,0016) as a branded SOPClassUID, or undefined if missing/invalid. */
+  get sopClassUID() {
+    const uid = this.getString(TAGS.SOPClassUID);
+    if (uid.length === 0) return void 0;
+    const result = createSOPClassUID(uid);
+    return result.ok ? result.value : void 0;
+  }
+  /** Study Instance UID (0020,000D). */
+  get studyInstanceUID() {
+    return this.getString(TAGS.StudyInstanceUID);
+  }
+  /** Series Instance UID (0020,000E). */
+  get seriesInstanceUID() {
+    return this.getString(TAGS.SeriesInstanceUID);
+  }
+  /** SOP Instance UID (0008,0018). */
+  get sopInstanceUID() {
+    return this.getString(TAGS.SOPInstanceUID);
+  }
+  /** Transfer Syntax UID (0002,0010). */
+  get transferSyntaxUID() {
+    return this.getString(TAGS.TransferSyntaxUID);
+  }
+};
+function killTree(pid) {
+  try {
+    kill(pid);
+  } catch {
+  }
+}
+async function execCommand(binary, args, options) {
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    const child = spawn(binary, [...args], {
+      cwd: options?.cwd,
+      windowsHide: true,
+      signal: options?.signal
+    });
+    wireSpawnListeners(child, timeoutMs, resolve);
+  });
+}
+function wireSpawnListeners(child, timeoutMs, resolve) {
+  let stdout = "";
+  let stderr6 = "";
+  let settled = false;
+  const settle = (result) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timer);
+    resolve(result);
+  };
+  const timer = setTimeout(() => {
+    if (child.pid !== void 0 && child.pid !== null) killTree(child.pid);
+    settle(err(new Error(`Process timed out after ${timeoutMs}ms`)));
+  }, timeoutMs);
+  child.stdout?.on("data", (chunk) => {
+    stdout += String(chunk);
+    if (stdout.length + stderr6.length > MAX_OUTPUT_BYTES) {
+      if (child.pid !== void 0 && child.pid !== null) killTree(child.pid);
+      settle(err(new Error(`Process output exceeded ${MAX_OUTPUT_BYTES} bytes`)));
+    }
+  });
+  child.stderr?.on("data", (chunk) => {
+    stderr6 += String(chunk);
+    if (stdout.length + stderr6.length > MAX_OUTPUT_BYTES) {
+      if (child.pid !== void 0 && child.pid !== null) killTree(child.pid);
+      settle(err(new Error(`Process output exceeded ${MAX_OUTPUT_BYTES} bytes`)));
+    }
+  });
+  child.on("error", (error) => {
+    if (child.pid !== void 0 && child.pid !== null) killTree(child.pid);
+    settle(err(new Error(`Process error: ${error.message}`)));
+  });
+  child.on("close", (code) => {
+    settle(ok({ stdout, stderr: stderr6, exitCode: code ?? 1 }));
+  });
+}
+async function spawnCommand(binary, args, options) {
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    const child = spawn(binary, [...args], {
+      cwd: options?.cwd,
+      env: options?.env ? { ...process.env, ...options.env } : void 0,
+      windowsHide: true,
+      signal: options?.signal
+    });
+    wireSpawnListeners(child, timeoutMs, resolve);
+  });
+}
+var PN_REPS = ["Alphabetic", "Ideographic", "Phonetic"];
+var ARRAY_TAG_NAMES = /* @__PURE__ */ new Set(["DicomAttribute", "Value", "PersonName", "Item"]);
+var KNOWN_VR_CODES = /* @__PURE__ */ new Set([
+  "AE",
+  "AS",
+  "AT",
+  "CS",
+  "DA",
+  "DS",
+  "DT",
+  "FD",
+  "FL",
+  "IS",
+  "LO",
+  "LT",
+  "OB",
+  "OD",
+  "OF",
+  "OL",
+  "OV",
+  "OW",
+  "PN",
+  "SH",
+  "SL",
+  "SQ",
+  "SS",
+  "ST",
+  "SV",
+  "TM",
+  "UC",
+  "UI",
+  "UL",
+  "UN",
+  "UR",
+  "US",
+  "UT",
+  "UV"
+]);
+function buildPnString(comp) {
+  const parts = [comp.FamilyName ?? "", comp.GivenName ?? "", comp.MiddleName ?? "", comp.NamePrefix ?? "", comp.NameSuffix ?? ""];
+  let last = parts.length - 1;
+  for (; last >= 0; last--) {
+    if (parts[last] !== "") break;
+  }
+  return parts.slice(0, last + 1).join("^");
+}
+function toArray(val) {
+  if (Array.isArray(val)) return val;
+  if (val === void 0 || val === null) return [];
+  return [val];
+}
+function convertPersonName(pnNode) {
+  const result = {};
+  if (typeof pnNode !== "object" || pnNode === null) return result;
+  const pn = pnNode;
+  for (const rep of PN_REPS) {
+    const repNode = pn[rep];
+    if (repNode !== void 0 && typeof repNode === "object" && repNode !== null) {
+      const str = buildPnString(repNode);
+      if (str.length > 0) {
+        result[rep] = str;
+      }
+    }
+  }
+  return result;
+}
+function safeString(val) {
+  if (typeof val === "string") return val;
+  if (typeof val === "number" || typeof val === "boolean") return String(val);
+  return "";
+}
+function convertInlineBinary(attr, element) {
+  element.InlineBinary = safeString(attr.InlineBinary);
+}
+function convertBulkDataURI(attr, element) {
+  const bulkArray = toArray(attr.BulkDataURI);
+  const firstBulk = bulkArray[0];
+  if (typeof firstBulk === "object" && firstBulk !== null && "@_uri" in firstBulk) {
+    element.BulkDataURI = safeString(firstBulk["@_uri"]);
+  } else {
+    element.BulkDataURI = safeString(firstBulk);
+  }
+}
+function convertPNValue(attr, element) {
+  const pnArray = toArray(attr.PersonName);
+  const values = [];
+  for (const pn of pnArray) {
+    values.push(convertPersonName(pn));
+  }
+  if (values.length > 0) element.Value = values;
+}
+function convertSequence(attr, element) {
+  const items = toArray(attr.Item);
+  const values = [];
+  for (const item of items) {
+    if (typeof item !== "object" || item === null) continue;
+    values.push(convertAttributes(item));
+  }
+  if (values.length > 0) element.Value = values;
+}
+function convertRegularValue(attr, element) {
+  const valArray = toArray(attr.Value);
+  const values = [];
+  for (const v of valArray) {
+    if (typeof v === "object" && v !== null && "#text" in v) {
+      values.push(v["#text"]);
+    } else {
+      values.push(v);
+    }
+  }
+  if (values.length > 0) element.Value = values;
+}
+function convertElement(attr) {
+  const rawVr = attr["@_vr"];
+  const vr = KNOWN_VR_CODES.has(rawVr) ? rawVr : "UN";
+  const element = { vr };
+  if (attr.InlineBinary !== void 0) {
+    convertInlineBinary(attr, element);
+  } else if (attr.BulkDataURI !== void 0) {
+    convertBulkDataURI(attr, element);
+  } else if (element.vr === "PN" && attr.PersonName !== void 0) {
+    convertPNValue(attr, element);
+  } else if (element.vr === "SQ" && attr.Item !== void 0) {
+    convertSequence(attr, element);
+  } else if (attr.Value !== void 0) {
+    convertRegularValue(attr, element);
+  }
+  return Object.freeze(element);
+}
+function convertAttributes(obj) {
+  const result = {};
+  const attrs = toArray(obj["DicomAttribute"]);
+  for (const attr of attrs) {
+    if (typeof attr !== "object" || attr === null) continue;
+    const xmlAttr = attr;
+    const tag = xmlAttr["@_tag"];
+    if (tag === void 0) continue;
+    result[tag] = convertElement(xmlAttr);
+  }
+  return result;
+}
+var parser = new XMLParser({
+  ignoreAttributes: false,
+  attributeNamePrefix: "@_",
+  parseTagValue: false,
+  isArray: (name) => ARRAY_TAG_NAMES.has(name)
+});
+function xmlToJson(xml) {
+  try {
+    const parsed = parser.parse(xml);
+    const root = parsed["NativeDicomModel"];
+    if (root === void 0) {
+      return err(new Error("Invalid dcm2xml output: missing NativeDicomModel root element"));
+    }
+    if (typeof root !== "object" || root === null) {
+      return ok({});
+    }
+    return ok(convertAttributes(root));
+  } catch (error) {
+    return err(new Error(`Failed to parse dcm2xml XML: ${stderr(error).message}`));
+  }
+}
+
+// src/tools/_repairJson.ts
+var VALUE_ARRAY_PATTERN = /("Value"\s*:\s*\[)([\s\S]*?)(\])/g;
+var BARE_NUMBER = /^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+function quoteIfBareNumber(token) {
+  const trimmed = token.trim();
+  if (BARE_NUMBER.test(trimmed)) {
+    return `"${trimmed}"`;
+  }
+  return trimmed;
+}
+function repairInner(inner) {
+  const trimmed = inner.trim();
+  if (trimmed.length === 0) return inner;
+  const tokens = [];
+  let current = "";
+  let inString = false;
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (ch === '"' && (i === 0 || trimmed[i - 1] !== "\\")) {
+      inString = !inString;
+      current += ch;
+    } else if (ch === "," && !inString) {
+      tokens.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  tokens.push(current);
+  return tokens.map(quoteIfBareNumber).join(", ");
+}
+function repairJson(raw) {
+  return raw.replace(VALUE_ARRAY_PATTERN, (_match, prefix, inner, suffix) => {
+    return `${prefix}${repairInner(inner)}${suffix}`;
+  });
+}
+
+// src/tools/dcm2json.ts
+var Dcm2jsonOptionsSchema = z.object({
+  timeoutMs: z.number().int().positive().optional(),
+  signal: z.instanceof(AbortSignal).optional(),
+  directOnly: z.boolean().optional()
+}).strict().optional();
+async function tryXmlPath(inputPath, timeoutMs, signal) {
+  const xmlBinary = resolveBinary("dcm2xml");
+  if (!xmlBinary.ok) {
+    return err(xmlBinary.error);
+  }
+  const xmlResult = await execCommand(xmlBinary.value, ["-nat", inputPath], { timeoutMs, signal });
+  if (!xmlResult.ok) {
+    return err(xmlResult.error);
+  }
+  if (xmlResult.value.exitCode !== 0) {
+    return err(createToolError("dcm2xml", ["-nat", inputPath], xmlResult.value.exitCode, xmlResult.value.stderr));
+  }
+  const jsonResult = xmlToJson(xmlResult.value.stdout);
+  if (!jsonResult.ok) {
+    return err(jsonResult.error);
+  }
+  return ok({ data: jsonResult.value, source: "xml" });
+}
+async function tryDirectPath(inputPath, timeoutMs, signal) {
+  const jsonBinary = resolveBinary("dcm2json");
+  if (!jsonBinary.ok) {
+    return err(jsonBinary.error);
+  }
+  const result = await execCommand(jsonBinary.value, [inputPath], { timeoutMs, signal });
+  if (!result.ok) {
+    return err(result.error);
+  }
+  if (result.value.exitCode !== 0) {
+    return err(createToolError("dcm2json", [inputPath], result.value.exitCode, result.value.stderr));
+  }
+  try {
+    const repaired = repairJson(result.value.stdout);
+    const data = JSON.parse(repaired);
+    return ok({ data, source: "direct" });
+  } catch (parseError) {
+    return err(createToolError("dcm2json", [inputPath], 1, `Parse error: ${stderr(parseError).message}`));
+  }
+}
+async function dcm2json(inputPath, options) {
+  const validation = Dcm2jsonOptionsSchema.safeParse(options);
+  if (!validation.success) {
+    return err(createValidationError("dcm2json", validation.error));
+  }
+  const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const signal = options?.signal;
+  if (options?.directOnly === true) {
+    return tryDirectPath(inputPath, timeoutMs, signal);
+  }
+  const xmlResult = await tryXmlPath(inputPath, timeoutMs, signal);
+  if (xmlResult.ok) {
+    return xmlResult;
+  }
+  return tryDirectPath(inputPath, timeoutMs, signal);
+}
+var TAG_OR_PATH_PATTERN = /^\([0-9A-Fa-f]{4},[0-9A-Fa-f]{4}\)(\[\d+\](\.\([0-9A-Fa-f]{4},[0-9A-Fa-f]{4}\)(\[\d+\])?)*)?$/;
+var TagModificationSchema = z.object({
+  tag: z.string().regex(TAG_OR_PATH_PATTERN),
+  value: z.string()
+});
+var DcmodifyOptionsSchema = z.object({
+  timeoutMs: z.number().int().positive().optional(),
+  signal: z.instanceof(AbortSignal).optional(),
+  modifications: z.array(TagModificationSchema).optional().default([]),
+  erasures: z.array(z.string()).optional(),
+  erasePrivateTags: z.boolean().optional(),
+  noBackup: z.boolean().optional(),
+  insertIfMissing: z.boolean().optional(),
+  ignoreMissingTags: z.boolean().optional()
+}).strict().refine((data) => data.modifications.length > 0 || data.erasures !== void 0 && data.erasures.length > 0 || data.erasePrivateTags === true, {
+  message: "At least one of modifications, erasures, or erasePrivateTags is required"
+});
+function buildArgs3(inputPath, options) {
+  const args = [];
+  if (options.noBackup !== false) {
+    args.push("-nb");
+  }
+  if (options.ignoreMissingTags === true) {
+    args.push("-imt");
+  }
+  const flag = options.insertIfMissing === true ? "-i" : "-m";
+  const modifications = options.modifications ?? [];
+  for (const mod of modifications) {
+    args.push(flag, `${mod.tag}=${mod.value}`);
+  }
+  if (options.erasures !== void 0) {
+    for (const erasure of options.erasures) {
+      args.push("-e", erasure);
+    }
+  }
+  if (options.erasePrivateTags === true) {
+    args.push("-ep");
+  }
+  args.push(inputPath);
+  return args;
+}
+async function dcmodify(inputPath, options) {
+  const validation = DcmodifyOptionsSchema.safeParse(options);
+  if (!validation.success) {
+    return err(createValidationError("dcmodify", validation.error));
+  }
+  const binaryResult = resolveBinary("dcmodify");
+  if (!binaryResult.ok) {
+    return err(binaryResult.error);
+  }
+  const args = buildArgs3(inputPath, options);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const result = await spawnCommand(binaryResult.value, args, {
+    timeoutMs,
+    signal: options.signal
+  });
+  if (!result.ok) {
+    return err(result.error);
+  }
+  if (result.value.exitCode !== 0) {
+    return err(createToolError("dcmodify", args, result.value.exitCode, result.value.stderr));
+  }
+  return ok({ filePath: inputPath });
+}
+async function applyModifications(filePath, changeset, options) {
+  const modifications = changeset.toModifications();
+  const erasures = changeset.toErasureArgs();
+  const hasErasures = erasures.length > 0 || changeset.erasePrivate;
+  const result = await dcmodify(filePath, {
+    modifications: modifications.length > 0 ? modifications : void 0,
+    erasures: erasures.length > 0 ? erasures : void 0,
+    erasePrivateTags: changeset.erasePrivate || void 0,
+    insertIfMissing: true,
+    ignoreMissingTags: hasErasures || void 0,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    signal: options.signal
+  });
+  if (!result.ok) return err(result.error);
+  return ok(void 0);
+}
+async function copyFileSafe(source, dest) {
+  return tryCatch(
+    () => copyFile(source, dest),
+    (e) => new Error(`Failed to copy file: ${e.message}`)
+  );
+}
+async function statFileSize(path2) {
+  return tryCatch(
+    async () => (await stat(path2)).size,
+    (e) => new Error(`Failed to stat file: ${e.message}`)
+  );
+}
+async function unlinkFile(path2) {
+  return tryCatch(
+    () => unlink(path2),
+    (e) => new Error(`Failed to delete file: ${e.message}`)
+  );
+}
+
+// src/dicom/DicomInstance.ts
+var DicomInstance = class _DicomInstance {
+  constructor(dataset, changes, filePath, metadata) {
+    __publicField(this, "dicomDataset");
+    __publicField(this, "changeSet");
+    __publicField(this, "filepath");
+    __publicField(this, "meta");
+    this.dicomDataset = dataset;
+    this.changeSet = changes;
+    this.filepath = filePath;
+    this.meta = metadata;
+  }
+  // -----------------------------------------------------------------------
+  // Factories
+  // -----------------------------------------------------------------------
+  /**
+   * Opens a DICOM file and creates a DicomInstance.
+   *
+   * @param path - Filesystem path to the DICOM file
+   * @param options - Timeout and abort options
+   * @returns A Result containing the DicomInstance or an error
+   */
+  static async open(path2, options) {
+    const filePathResult = createDicomFilePath(path2);
+    if (!filePathResult.ok) return err(filePathResult.error);
+    const jsonResult = await dcm2json(path2, {
+      timeoutMs: options?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      signal: options?.signal
+    });
+    if (!jsonResult.ok) return err(jsonResult.error);
+    const datasetResult = DicomDataset.fromJson(jsonResult.value.data);
+    if (!datasetResult.ok) return err(datasetResult.error);
+    return ok(new _DicomInstance(datasetResult.value, ChangeSet.empty(), filePathResult.value, /* @__PURE__ */ new Map()));
+  }
+  /**
+   * Creates a DicomInstance from an existing DicomDataset.
+   *
+   * @param dataset - The DicomDataset to wrap
+   * @param filePath - Optional file path (e.g. if the dataset came from a file)
+   * @returns A Result containing the DicomInstance
+   */
+  static fromDataset(dataset, filePath) {
+    let fp;
+    if (filePath !== void 0) {
+      const fpResult = createDicomFilePath(filePath);
+      if (!fpResult.ok) return err(fpResult.error);
+      fp = fpResult.value;
+    }
+    return ok(new _DicomInstance(dataset, ChangeSet.empty(), fp, /* @__PURE__ */ new Map()));
+  }
+  // -----------------------------------------------------------------------
+  // Read accessors (delegate to DicomDataset)
+  // -----------------------------------------------------------------------
+  /** The underlying immutable DICOM dataset. */
+  get dataset() {
+    return this.dicomDataset;
+  }
+  /** The pending change set. */
+  get changes() {
+    return this.changeSet;
+  }
+  /** Whether there are unsaved changes. */
+  get hasUnsavedChanges() {
+    return !this.changeSet.isEmpty;
+  }
+  /** The file path, or undefined if this instance has no associated file. */
+  get filePath() {
+    return this.filepath;
+  }
+  /** Patient's Name (0010,0010). */
+  get patientName() {
+    return this.dicomDataset.patientName;
+  }
+  /** Patient ID (0010,0020). */
+  get patientID() {
+    return this.dicomDataset.patientID;
+  }
+  /** Study Date (0008,0020). */
+  get studyDate() {
+    return this.dicomDataset.studyDate;
+  }
+  /** Modality (0008,0060). */
+  get modality() {
+    return this.dicomDataset.modality;
+  }
+  /** Accession Number (0008,0050). */
+  get accession() {
+    return this.dicomDataset.accession;
+  }
+  /** SOP Class UID (0008,0016). */
+  get sopClassUID() {
+    return this.dicomDataset.sopClassUID;
+  }
+  /** Study Instance UID (0020,000D). */
+  get studyInstanceUID() {
+    return this.dicomDataset.studyInstanceUID;
+  }
+  /** Series Instance UID (0020,000E). */
+  get seriesInstanceUID() {
+    return this.dicomDataset.seriesInstanceUID;
+  }
+  /** SOP Instance UID (0008,0018). */
+  get sopInstanceUID() {
+    return this.dicomDataset.sopInstanceUID;
+  }
+  /** Transfer Syntax UID (0002,0010). */
+  get transferSyntaxUID() {
+    return this.dicomDataset.transferSyntaxUID;
+  }
+  /**
+   * Gets a tag value as a string with optional fallback.
+   *
+   * @param tag - A DICOM tag, e.g. `'(0010,0010)'` or `'00100010'`
+   * @param fallback - Value to return if tag is missing (default: `''`)
+   */
+  getString(tag, fallback = "") {
+    return this.dicomDataset.getString(tag, fallback);
+  }
+  /**
+   * Gets a tag value as a number.
+   *
+   * @param tag - A DICOM tag, e.g. `'(0020,0013)'`
+   */
+  getNumber(tag) {
+    return this.dicomDataset.getNumber(tag);
+  }
+  /** Checks whether a tag exists in the dataset. */
+  hasTag(tag) {
+    return this.dicomDataset.hasTag(tag);
+  }
+  /**
+   * Finds all values matching a wildcard path.
+   *
+   * @param path - A DicomTagPath with optional wildcard indices
+   */
+  findValues(path2) {
+    return this.dicomDataset.findValues(path2);
+  }
+  // -----------------------------------------------------------------------
+  // Write methods (return new instance)
+  // -----------------------------------------------------------------------
+  /**
+   * Sets a tag value, returning a new DicomInstance.
+   *
+   * @param path - The DICOM tag path (e.g. `'(0010,0010)'`)
+   * @param value - The new value
+   */
+  setTag(path2, value) {
+    return new _DicomInstance(this.dicomDataset, this.changeSet.setTag(path2, value), this.filepath, this.meta);
+  }
+  /**
+   * Erases a tag, returning a new DicomInstance.
+   *
+   * @param path - The DICOM tag path to erase
+   */
+  eraseTag(path2) {
+    return new _DicomInstance(this.dicomDataset, this.changeSet.eraseTag(path2), this.filepath, this.meta);
+  }
+  /** Erases all private tags, returning a new DicomInstance. */
+  erasePrivateTags() {
+    return new _DicomInstance(this.dicomDataset, this.changeSet.erasePrivateTags(), this.filepath, this.meta);
+  }
+  /** Sets Patient's Name (0010,0010). */
+  setPatientName(value) {
+    return this.setTag("(0010,0010)", value);
+  }
+  /** Sets Patient ID (0010,0020). */
+  setPatientID(value) {
+    return this.setTag("(0010,0020)", value);
+  }
+  /** Sets Study Date (0008,0020). */
+  setStudyDate(value) {
+    return this.setTag("(0008,0020)", value);
+  }
+  /** Sets Modality (0008,0060). */
+  setModality(value) {
+    return this.setTag("(0008,0060)", value);
+  }
+  /** Sets Accession Number (0008,0050). */
+  setAccessionNumber(value) {
+    return this.setTag("(0008,0050)", value);
+  }
+  /** Sets Study Description (0008,1030). */
+  setStudyDescription(value) {
+    return this.setTag("(0008,1030)", value);
+  }
+  /** Sets Series Description (0008,103E). */
+  setSeriesDescription(value) {
+    return this.setTag("(0008,103E)", value);
+  }
+  /** Sets Institution Name (0008,0080). */
+  setInstitutionName(value) {
+    return this.setTag("(0008,0080)", value);
+  }
+  /**
+   * Transforms a tag value using a function.
+   *
+   * The function receives the current string value (or undefined if tag is missing)
+   * and returns the new value. Returns a new DicomInstance with the modification.
+   *
+   * @param path - The DICOM tag path
+   * @param fn - Transform function receiving the current value
+   */
+  transformTag(path2, fn) {
+    const current = this.dicomDataset.getString(path2);
+    const newValue = fn(current.length > 0 ? current : void 0);
+    return this.setTag(path2, newValue);
+  }
+  /**
+   * Sets multiple tags at once, returning a new DicomInstance.
+   *
+   * @param entries - A record of tag path → value pairs
+   */
+  setBatch(entries) {
+    return new _DicomInstance(this.dicomDataset, this.changeSet.setBatch(entries), this.filepath, this.meta);
+  }
+  /**
+   * Returns a new DicomInstance with the given changes merged into pending changes.
+   *
+   * @param changes - A ChangeSet to merge with existing pending changes
+   * @returns A new DicomInstance with accumulated changes
+   */
+  withChanges(changes) {
+    return new _DicomInstance(this.dicomDataset, this.changeSet.merge(changes), this.filepath, this.meta);
+  }
+  /**
+   * Returns a new DicomInstance pointing to a different file path.
+   *
+   * Preserves the dataset, pending changes, and metadata.
+   *
+   * @param newPath - The new filesystem path (validated via createDicomFilePath)
+   * @returns A new DicomInstance with the updated path
+   * @throws If the path is invalid
+   */
+  withFilePath(newPath) {
+    const result = createDicomFilePath(newPath);
+    if (!result.ok) throw result.error;
+    return new _DicomInstance(this.dicomDataset, this.changeSet, result.value, this.meta);
   }
-  if (options.dimseTimeout !== void 0) {
-    args.push("--dimse-timeout", String(options.dimseTimeout));
+  // -----------------------------------------------------------------------
+  // File I/O
+  // -----------------------------------------------------------------------
+  /**
+   * Applies pending changes to the file in-place.
+   *
+   * Requires that the instance has an associated file path.
+   *
+   * @param options - Timeout and abort options
+   */
+  async applyChanges(options) {
+    if (this.filepath === void 0) return err(new Error("No file path associated with this instance"));
+    if (this.changeSet.isEmpty) return ok(void 0);
+    return applyModifications(this.filepath, this.changeSet, options ?? {});
   }
-  if (options.maxPdu !== void 0) {
-    args.push("--max-pdu", String(options.maxPdu));
+  /**
+   * Copies the file to a new path and applies pending changes to the copy.
+   *
+   * Returns a new DicomInstance pointing to the output path.
+   *
+   * @param outputPath - Destination filesystem path
+   * @param options - Timeout and abort options
+   */
+  async writeAs(outputPath, options) {
+    if (this.filepath === void 0) return err(new Error("No file path associated with this instance"));
+    const outPathResult = createDicomFilePath(outputPath);
+    if (!outPathResult.ok) return err(outPathResult.error);
+    const copyResult = await copyFileSafe(this.filepath, outputPath);
+    if (!copyResult.ok) return err(copyResult.error);
+    if (!this.changeSet.isEmpty) {
+      const applyResult = await applyModifications(outPathResult.value, this.changeSet, options ?? {});
+      if (!applyResult.ok) {
+        await unlinkFile(outputPath);
+        return err(applyResult.error);
+      }
+    }
+    return ok(new _DicomInstance(this.dicomDataset, ChangeSet.empty(), outPathResult.value, this.meta));
   }
-}
-function buildExecArgs(args, options) {
-  if (options.execOnReception !== void 0) {
-    args.push("--exec-on-reception", options.execOnReception);
+  /**
+   * Gets the file size in bytes.
+   *
+   * @returns A Result containing the size or an error
+   */
+  async fileSize() {
+    if (this.filepath === void 0) return err(new Error("No file path associated with this instance"));
+    return statFileSize(this.filepath);
   }
-  if (options.execOnEndOfStudy !== void 0) {
-    args.push("--exec-on-eostudy", options.execOnEndOfStudy);
+  /**
+   * Deletes the associated file from the filesystem.
+   *
+   * @returns A Result indicating success or failure
+   */
+  async unlink() {
+    if (this.filepath === void 0) return err(new Error("No file path associated with this instance"));
+    return unlinkFile(this.filepath);
   }
-  if (options.endOfStudyTimeout !== void 0) {
-    args.push("--eostudy-timeout", String(options.endOfStudyTimeout));
+  // -----------------------------------------------------------------------
+  // Metadata (non-DICOM app context)
+  // -----------------------------------------------------------------------
+  /**
+   * Returns a new DicomInstance with application metadata attached.
+   *
+   * Metadata is not stored in the DICOM file — it's for application context
+   * (e.g. tracking source association, processing status, etc.).
+   *
+   * @param key - Metadata key
+   * @param value - Metadata value
+   */
+  withMetadata(key, value) {
+    const newMeta = new Map(this.meta);
+    newMeta.set(key, value);
+    return new _DicomInstance(this.dicomDataset, this.changeSet, this.filepath, newMeta);
   }
-  if (options.renameOnEndOfStudy === true) {
-    args.push("--rename-on-eostudy");
+  /**
+   * Gets application metadata by key.
+   *
+   * @param key - Metadata key
+   * @returns The metadata value or undefined
+   */
+  getMetadata(key) {
+    return this.meta.get(key);
   }
+};
+
+// src/servers/DicomReceiver.ts
+var DEFAULT_MIN_POOL_SIZE = 2;
+var DEFAULT_MAX_POOL_SIZE = 10;
+var DEFAULT_CONNECTION_TIMEOUT_MS = 1e4;
+var CONNECTION_RETRY_INTERVAL_MS = 500;
+var MAX_CONNECTION_RETRIES = 200;
+var DicomReceiverOptionsSchema = z.object({
+  port: z.number().int().min(1).max(65535),
+  storageDir: z.string().min(1).refine(isSafePath, { message: "path traversal detected in storageDir" }),
+  aeTitle: z.string().min(1).max(16).refine(isValidAETitle, { message: "AE Title contains invalid characters" }).optional(),
+  minPoolSize: z.number().int().min(1).max(100).optional(),
+  maxPoolSize: z.number().int().min(1).max(100).optional(),
+  connectionTimeoutMs: z.number().int().positive().optional(),
+  configFile: z.string().min(1).refine(isSafePath, { message: "path traversal detected in configFile" }).optional(),
+  configProfile: z.string().min(1).optional(),
+  signal: z.instanceof(AbortSignal).optional()
+}).strict().refine((data) => (data.minPoolSize ?? DEFAULT_MIN_POOL_SIZE) <= (data.maxPoolSize ?? DEFAULT_MAX_POOL_SIZE), {
+  message: "minPoolSize must be <= maxPoolSize"
+});
+function allocatePort() {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (addr === null || typeof addr === "string") {
+        server.close(() => resolve(err(new Error("Failed to allocate port"))));
+        return;
+      }
+      const port = addr.port;
+      server.close(() => resolve(ok(port)));
+    });
+    server.on("error", (e) => {
+      resolve(err(new Error(`Port allocation failed: ${e.message}`)));
+    });
+  });
 }
-var StoreSCP = class _StoreSCP extends DcmtkProcess {
-  constructor(config, parser, signal) {
-    super(config);
-    __publicField(this, "parser");
-    __publicField(this, "abortSignal");
+var DicomReceiver = class _DicomReceiver extends EventEmitter {
+  constructor(options) {
+    super();
+    __publicField(this, "options");
+    __publicField(this, "minPoolSize");
+    __publicField(this, "maxPoolSize");
+    __publicField(this, "connectionTimeoutMs");
+    __publicField(this, "workers", /* @__PURE__ */ new Map());
+    __publicField(this, "tcpServer");
+    __publicField(this, "associationCounter", 0);
+    __publicField(this, "started", false);
+    __publicField(this, "stopping", false);
     __publicField(this, "abortHandler");
-    this.parser = parser;
-    this.wireParser();
-    if (signal !== void 0) {
-      this.wireAbortSignal(signal);
+    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;
+    this.connectionTimeoutMs = options.connectionTimeoutMs ?? DEFAULT_CONNECTION_TIMEOUT_MS;
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /**
+   * Creates a new DicomReceiver instance.
+   *
+   * @param options - Configuration options
+   * @returns A Result containing the instance or a validation error
+   */
+  static create(options) {
+    const validation = DicomReceiverOptionsSchema.safeParse(options);
+    if (!validation.success) {
+      return err(createValidationError("DicomReceiver", validation.error));
     }
+    return ok(new _DicomReceiver(options));
   }
   /**
-   * Registers a typed listener for a storescp-specific event.
+   * Starts the TCP proxy and spawns the initial worker pool.
    *
-   * @param event - The event name from StoreSCPEventMap
-   * @param listener - Callback receiving typed event data
-   * @returns this for chaining
+   * @returns A Result indicating success or failure
    */
-  /** Disposes the server and its parser, preventing listener leaks. */
-  [Symbol.dispose]() {
-    if (this.abortSignal !== void 0 && this.abortHandler !== void 0) {
-      this.abortSignal.removeEventListener("abort", this.abortHandler);
+  async start() {
+    if (this.started) {
+      return err(new Error("DicomReceiver: already started"));
     }
-    this.parser[Symbol.dispose]();
-    super[Symbol.dispose]();
+    this.started = true;
+    const storageDirResult = await ensureDirectory(this.options.storageDir);
+    if (!storageDirResult.ok) return storageDirResult;
+    const spawnResults = await this.spawnWorkers(this.minPoolSize);
+    if (!spawnResults.ok) return spawnResults;
+    const listenResult = await this.startTcpProxy();
+    if (!listenResult.ok) return listenResult;
+    if (this.options.signal !== void 0) {
+      this.wireAbortSignal(this.options.signal);
+    }
+    return ok(void 0);
   }
-  onEvent(event, listener) {
-    return this.on(event, listener);
+  /**
+   * Stops the TCP proxy and all workers.
+   */
+  async stop() {
+    if (!this.started || this.stopping) {
+      return;
+    }
+    this.stopping = true;
+    if (this.options.signal !== void 0 && this.abortHandler !== void 0) {
+      this.options.signal.removeEventListener("abort", this.abortHandler);
+    }
+    await this.closeTcpProxy();
+    const stopPromises = [];
+    for (const worker of this.workers.values()) {
+      stopPromises.push(this.stopWorker(worker));
+    }
+    await Promise.all(stopPromises);
+    this.workers.clear();
+    this.started = false;
+    this.stopping = false;
   }
   /**
-   * Registers a listener for incoming associations.
+   * Registers a typed listener for a DicomReceiver-specific event.
    *
-   * @param listener - Callback receiving association data
+   * @param event - The event name from DicomReceiverEventMap
+   * @param listener - Callback receiving typed event data
    * @returns this for chaining
    */
-  onAssociationReceived(listener) {
-    return this.onEvent("ASSOCIATION_RECEIVED", listener);
+  onEvent(event, listener) {
+    return this.on(event, listener);
   }
   /**
-   * Registers a listener for files being stored to disk.
+   * Registers a listener for received files.
    *
-   * @param listener - Callback receiving storing file data
+   * @param listener - Callback receiving file data
    * @returns this for chaining
    */
-  onStoringFile(listener) {
-    return this.onEvent("STORING_FILE", listener);
+  onFileReceived(listener) {
+    return this.on("FILE_RECEIVED", listener);
   }
   /**
-   * Creates a new StoreSCP server instance.
+   * Registers a listener for completed associations.
    *
-   * @param options - Configuration options for the storescp server
-   * @returns A Result containing the server instance or a validation/resolution error
+   * @param listener - Callback receiving association data
+   * @returns this for chaining
    */
-  static create(options) {
-    const validation = StoreSCPOptionsSchema.safeParse(options);
-    if (!validation.success) {
-      return err(new Error(`storescp: invalid options: ${validation.error.message}`));
-    }
-    const binaryResult = resolveBinary("storescp");
-    if (!binaryResult.ok) {
-      return err(binaryResult.error);
+  onAssociationComplete(listener) {
+    return this.on("ASSOCIATION_COMPLETE", listener);
+  }
+  /** Current pool status. */
+  get poolStatus() {
+    let idle = 0;
+    let busy = 0;
+    for (const w of this.workers.values()) {
+      if (w.state === "idle") idle++;
+      else busy++;
     }
-    const args = buildArgs2(options);
-    const parser = new LineParser();
-    for (const pattern of STORESCP_PATTERNS) {
-      const addResult = parser.addPattern(pattern);
-      if (!addResult.ok) {
-        return err(addResult.error);
+    return { idle, busy, total: this.workers.size };
+  }
+  // -----------------------------------------------------------------------
+  // TCP proxy
+  // -----------------------------------------------------------------------
+  /** Starts the TCP proxy on the configured port. */
+  startTcpProxy() {
+    return new Promise((resolve) => {
+      this.tcpServer = net.createServer((socket) => {
+        void this.handleConnection(socket);
+      });
+      this.tcpServer.on("error", (e) => {
+        if (!this.started) {
+          resolve(err(new Error(`DicomReceiver: TCP proxy failed: ${e.message}`)));
+        } else {
+          this.emit("error", { error: e instanceof Error ? e : new Error(String(e)) });
+        }
+      });
+      this.tcpServer.listen(this.options.port, () => {
+        resolve(ok(void 0));
+      });
+    });
+  }
+  /** Closes the TCP proxy server. */
+  closeTcpProxy() {
+    return new Promise((resolve) => {
+      if (this.tcpServer === void 0) {
+        resolve();
+        return;
       }
+      this.tcpServer.close(() => resolve());
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Connection routing
+  // -----------------------------------------------------------------------
+  /** Routes an incoming connection to an idle worker. */
+  async handleConnection(remoteSocket) {
+    remoteSocket.pause();
+    const worker = await this.findIdleWorker();
+    if (worker === void 0) {
+      remoteSocket.destroy(new Error("DicomReceiver: no idle worker available"));
+      this.emit("error", { error: new Error("DicomReceiver: connection rejected \u2014 pool exhausted") });
+      return;
     }
-    const config = {
-      binary: binaryResult.value,
-      args,
-      startTimeoutMs: options.startTimeoutMs,
-      drainTimeoutMs: options.drainTimeoutMs
-      // storescp doesn't print "listening" — resolve on spawn
+    this.associationCounter++;
+    const associationId = `assoc-${String(this.associationCounter)}`;
+    const associationDir = path.join(this.options.storageDir, associationId);
+    const mkdirResult = await ensureDirectory(associationDir);
+    if (!mkdirResult.ok) {
+      remoteSocket.destroy();
+      this.emit("error", { error: mkdirResult.error });
+      return;
+    }
+    worker.state = "busy";
+    worker.associationId = associationId;
+    worker.associationDir = associationDir;
+    worker.files = [];
+    worker.fileSizes = [];
+    worker.startAt = Date.now();
+    this.pipeConnection(worker, remoteSocket);
+    void this.replenishPool();
+  }
+  /** Finds an idle worker, retrying up to connectionTimeoutMs. */
+  async findIdleWorker() {
+    const idle = this.getIdleWorker();
+    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);
+      const found = this.getIdleWorker();
+      if (found !== void 0) return found;
+      if (this.stopping) return void 0;
+    }
+    return void 0;
+  }
+  /** Returns the first idle worker, or undefined. */
+  getIdleWorker() {
+    for (const w of this.workers.values()) {
+      if (w.state === "idle") return w;
+    }
+    return void 0;
+  }
+  /** Pipes remote socket bidirectionally to the worker's port. */
+  pipeConnection(worker, remoteSocket) {
+    const workerSocket = net.createConnection({ port: worker.port, host: "127.0.0.1" });
+    worker.remoteSocket = remoteSocket;
+    worker.workerSocket = workerSocket;
+    remoteSocket.pipe(workerSocket);
+    workerSocket.pipe(remoteSocket);
+    remoteSocket.resume();
+    const cleanup = () => {
+      remoteSocket.unpipe(workerSocket);
+      workerSocket.unpipe(remoteSocket);
+      if (!remoteSocket.destroyed) remoteSocket.destroy();
+      if (!workerSocket.destroyed) workerSocket.destroy();
     };
-    return ok(new _StoreSCP(config, parser, options.signal));
+    remoteSocket.on("error", cleanup);
+    workerSocket.on("error", cleanup);
+    remoteSocket.on("close", cleanup);
+    workerSocket.on("close", cleanup);
   }
-  /** Wires the line parser to the process output. */
-  wireParser() {
-    this.on("line", ({ text }) => {
-      this.parser.feed(text);
+  // -----------------------------------------------------------------------
+  // Worker pool management
+  // -----------------------------------------------------------------------
+  /** Spawns `count` new workers and adds them to the pool. */
+  async spawnWorkers(count) {
+    const promises = [];
+    for (let i = 0; i < count; i++) {
+      promises.push(this.spawnWorker());
+    }
+    const results = await Promise.all(promises);
+    for (const result of results) {
+      if (!result.ok) return err(result.error);
+    }
+    return ok(void 0);
+  }
+  /** Spawns a single Dcmrecv worker with an ephemeral port. */
+  async spawnWorker() {
+    const portResult = await allocatePort();
+    if (!portResult.ok) return portResult;
+    const port = portResult.value;
+    const tempDir = path.join(os.tmpdir(), `dcmrecv-pool-${String(port)}-${String(Date.now())}`);
+    const mkdirResult = await ensureDirectory(tempDir);
+    if (!mkdirResult.ok) return mkdirResult;
+    const createResult = Dcmrecv.create({
+      port,
+      aeTitle: this.options.aeTitle ?? "DCMRECV",
+      outputDirectory: tempDir,
+      configFile: this.options.configFile,
+      configProfile: this.options.configProfile
     });
-    this.parser.on("match", ({ event, data }) => {
-      if (STORESCP_FATAL_EVENTS.has(event)) {
-        this.emit("error", { error: new Error(`Fatal: ${event}`), fatal: true });
-        void this.stop();
+    if (!createResult.ok) return createResult;
+    const dcmrecv = createResult.value;
+    const worker = {
+      dcmrecv,
+      port,
+      tempDir,
+      state: "idle",
+      associationId: void 0,
+      associationDir: void 0,
+      files: [],
+      fileSizes: [],
+      startAt: void 0,
+      remoteSocket: void 0,
+      workerSocket: void 0
+    };
+    this.wireWorkerEvents(worker);
+    const startResult = await dcmrecv.start();
+    if (!startResult.ok) {
+      return err(new Error(`DicomReceiver: worker start failed on port ${String(port)}: ${startResult.error.message}`));
+    }
+    this.workers.set(port, worker);
+    return ok(worker);
+  }
+  /** Stops a single worker: 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();
+    }
+    await worker.dcmrecv.stop();
+    worker.dcmrecv[Symbol.dispose]();
+    await removeDirSafe(worker.tempDir);
+    this.workers.delete(worker.port);
+  }
+  /** Pre-emptively spawns workers to keep idle count >= minPoolSize. */
+  async replenishPool() {
+    const status = this.poolStatus;
+    const needed = this.minPoolSize - status.idle;
+    const capacity = this.maxPoolSize - status.total;
+    const toSpawn = Math.min(needed, capacity);
+    if (toSpawn <= 0) return;
+    const promises = [];
+    for (let i = 0; i < toSpawn; i++) {
+      promises.push(this.spawnWorker());
+    }
+    const results = await Promise.all(promises);
+    for (const result of results) {
+      if (!result.ok) {
+        this.emit("error", { error: result.error });
       }
-      this.emit(event, ...[data]);
+    }
+  }
+  /** Stops excess idle workers when idle count > minPoolSize + 2. */
+  async scaleDown() {
+    const idleWorkers = [];
+    for (const w of this.workers.values()) {
+      if (w.state === "idle") idleWorkers.push(w);
+    }
+    const excess = idleWorkers.length - (this.minPoolSize + 2);
+    if (excess <= 0) return;
+    const toStop = idleWorkers.slice(0, excess);
+    const promises = [];
+    for (const w of toStop) {
+      promises.push(this.stopWorker(w));
+    }
+    await Promise.all(promises);
+  }
+  // -----------------------------------------------------------------------
+  // Worker event wiring
+  // -----------------------------------------------------------------------
+  /** Wires FILE_RECEIVED and ASSOCIATION_COMPLETE events on a worker. */
+  wireWorkerEvents(worker) {
+    this.wireFileReceived(worker);
+    this.wireAssociationComplete(worker);
+  }
+  /** Wires FILE_RECEIVED from dcmrecv worker to handleFileReceived. */
+  wireFileReceived(worker) {
+    worker.dcmrecv.onFileReceived((data) => {
+      void this.handleFileReceived(worker, data);
     });
   }
-  /** Wires an AbortSignal to stop the server. */
+  /** Moves a received file, opens it as DicomInstance, and emits FILE_RECEIVED. */
+  async handleFileReceived(worker, data) {
+    if (worker.associationDir === void 0 || worker.associationId === void 0) return;
+    const srcPath = data.filePath;
+    const destPath = path.join(worker.associationDir, path.basename(srcPath));
+    const assocId = worker.associationId;
+    const assocDir = worker.associationDir;
+    const moveResult = await moveFile(srcPath, destPath);
+    const finalPath = moveResult.ok ? destPath : srcPath;
+    worker.files.push(finalPath);
+    worker.fileSizes.push(await statFileSafe(finalPath));
+    const openResult = await DicomInstance.open(finalPath);
+    if (!openResult.ok) {
+      this.emit("error", {
+        error: openResult.error,
+        filePath: finalPath,
+        associationId: assocId,
+        associationDir: assocDir,
+        callingAE: data.callingAE,
+        calledAE: data.calledAE,
+        source: data.source
+      });
+      return;
+    }
+    this.emit("FILE_RECEIVED", {
+      filePath: finalPath,
+      associationId: assocId,
+      associationDir: assocDir,
+      callingAE: data.callingAE,
+      calledAE: data.calledAE,
+      source: data.source,
+      instance: openResult.value
+    });
+  }
+  /** Returns worker to idle pool on association complete, emits summary. */
+  wireAssociationComplete(worker) {
+    worker.dcmrecv.onAssociationComplete((data) => {
+      const assocId = worker.associationId ?? data.associationId;
+      const assocDir = worker.associationDir ?? "";
+      const files = [...worker.files];
+      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;
+      this.emit("ASSOCIATION_COMPLETE", {
+        associationId: assocId,
+        associationDir: assocDir,
+        callingAE: data.callingAE,
+        calledAE: data.calledAE,
+        source: data.source,
+        files,
+        durationMs: data.durationMs,
+        endReason: data.endReason,
+        totalBytes,
+        bytesPerSecond,
+        startAt,
+        endAt
+      });
+      worker.state = "idle";
+      worker.associationId = void 0;
+      worker.associationDir = void 0;
+      worker.files = [];
+      worker.fileSizes = [];
+      worker.startAt = void 0;
+      worker.remoteSocket = void 0;
+      worker.workerSocket = void 0;
+      void this.scaleDown();
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Abort signal
+  // -----------------------------------------------------------------------
+  /** Wires an AbortSignal to stop the receiver. */
   wireAbortSignal(signal) {
     if (signal.aborted) {
       void this.stop();
       return;
     }
-    this.abortSignal = signal;
     this.abortHandler = () => {
       void this.stop();
     };
     signal.addEventListener("abort", this.abortHandler, { once: true });
   }
 };
+async function ensureDirectory(dirPath) {
+  try {
+    await fs.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.rename(src, dest);
+    return ok(void 0);
+  } catch {
+    try {
+      await fs.copyFile(src, dest);
+      await fs.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 stat3 = await fs.stat(filePath);
+    return stat3.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.rm(dirPath, { recursive: true, force: true });
+  } catch {
+  }
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
 
 // src/events/dcmprscp.ts
 var DcmprscpEvent = {
@@ -1065,7 +3225,7 @@ var DcmprsCPOptionsSchema = z.object({
   drainTimeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional()
 }).strict();
-function buildArgs3(options) {
+function buildArgs4(options) {
   const args = ["--verbose", "--config", options.configFile];
   if (options.printer !== void 0) {
     args.push("--printer", options.printer);
@@ -1082,12 +3242,12 @@ function buildArgs3(options) {
   return args;
 }
 var DcmprsCP = class _DcmprsCP extends DcmtkProcess {
-  constructor(config, parser, signal) {
+  constructor(config, parser2, signal) {
     super(config);
     __publicField(this, "parser");
     __publicField(this, "abortSignal");
     __publicField(this, "abortHandler");
-    this.parser = parser;
+    this.parser = parser2;
     this.wireParser();
     if (signal !== void 0) {
       this.wireAbortSignal(signal);
@@ -1138,16 +3298,16 @@ var DcmprsCP = class _DcmprsCP extends DcmtkProcess {
   static create(options) {
     const validation = DcmprsCPOptionsSchema.safeParse(options);
     if (!validation.success) {
-      return err(new Error(`dcmprscp: invalid options: ${validation.error.message}`));
+      return err(createValidationError("dcmprscp", validation.error));
     }
     const binaryResult = resolveBinary("dcmprscp");
     if (!binaryResult.ok) {
       return err(binaryResult.error);
     }
-    const args = buildArgs3(options);
-    const parser = new LineParser();
+    const args = buildArgs4(options);
+    const parser2 = new LineParser();
     for (const pattern of DCMPRSCP_PATTERNS) {
-      const addResult = parser.addPattern(pattern);
+      const addResult = parser2.addPattern(pattern);
       if (!addResult.ok) {
         return err(addResult.error);
       }
@@ -1159,7 +3319,7 @@ var DcmprsCP = class _DcmprsCP extends DcmtkProcess {
       drainTimeoutMs: options.drainTimeoutMs,
       isStartedPredicate: (line) => /Using database in directory/i.test(line)
     };
-    return ok(new _DcmprsCP(config, parser, options.signal));
+    return ok(new _DcmprsCP(config, parser2, options.signal));
   }
   /** Wires the line parser to the process output. */
   wireParser() {
@@ -1171,7 +3331,7 @@ var DcmprsCP = class _DcmprsCP extends DcmtkProcess {
         this.emit("error", { error: new Error(`Fatal: ${event}`), fatal: true });
         void this.stop();
       }
-      this.emit(event, ...[data]);
+      this.emit(event, data);
     });
   }
   /** Wires an AbortSignal to stop the server. */
@@ -1296,7 +3456,7 @@ var DcmpsrcvOptionsSchema = z.object({
   drainTimeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional()
 }).strict();
-function buildArgs4(options) {
+function buildArgs5(options) {
   const args = ["--verbose"];
   if (options.logLevel !== void 0) {
     args.push("--log-level", options.logLevel);
@@ -1311,12 +3471,12 @@ function buildArgs4(options) {
   return args;
 }
 var Dcmpsrcv = class _Dcmpsrcv extends DcmtkProcess {
-  constructor(config, parser, signal) {
+  constructor(config, parser2, signal) {
     super(config);
     __publicField(this, "parser");
     __publicField(this, "abortSignal");
     __publicField(this, "abortHandler");
-    this.parser = parser;
+    this.parser = parser2;
     this.wireParser();
     if (signal !== void 0) {
       this.wireAbortSignal(signal);
@@ -1367,16 +3527,16 @@ var Dcmpsrcv = class _Dcmpsrcv extends DcmtkProcess {
   static create(options) {
     const validation = DcmpsrcvOptionsSchema.safeParse(options);
     if (!validation.success) {
-      return err(new Error(`dcmpsrcv: invalid options: ${validation.error.message}`));
+      return err(createValidationError("dcmpsrcv", validation.error));
     }
     const binaryResult = resolveBinary("dcmpsrcv");
     if (!binaryResult.ok) {
       return err(binaryResult.error);
     }
-    const args = buildArgs4(options);
-    const parser = new LineParser();
+    const args = buildArgs5(options);
+    const parser2 = new LineParser();
     for (const pattern of DCMPSRCV_PATTERNS) {
-      const addResult = parser.addPattern(pattern);
+      const addResult = parser2.addPattern(pattern);
       if (!addResult.ok) {
         return err(addResult.error);
       }
@@ -1388,7 +3548,7 @@ var Dcmpsrcv = class _Dcmpsrcv extends DcmtkProcess {
       drainTimeoutMs: options.drainTimeoutMs,
       isStartedPredicate: (line) => /Receiver\s+\S+\s+on port/i.test(line)
     };
-    return ok(new _Dcmpsrcv(config, parser, options.signal));
+    return ok(new _Dcmpsrcv(config, parser2, options.signal));
   }
   /** Wires the line parser to the process output. */
   wireParser() {
@@ -1400,7 +3560,7 @@ var Dcmpsrcv = class _Dcmpsrcv extends DcmtkProcess {
         this.emit("error", { error: new Error(`Fatal: ${event}`), fatal: true });
         void this.stop();
       }
-      this.emit(event, ...[data]);
+      this.emit(event, data);
     });
   }
   /** Wires an AbortSignal to stop the server. */
@@ -1516,7 +3676,7 @@ var DcmQRSCPOptionsSchema = z.object({
   drainTimeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional()
 }).strict();
-function buildArgs5(options) {
+function buildArgs6(options) {
   const args = [];
   if (options.verbose !== false) {
     args.push("--verbose");
@@ -1552,24 +3712,17 @@ function buildNetworkArgs2(args, options) {
   }
 }
 var DcmQRSCP = class _DcmQRSCP extends DcmtkProcess {
-  constructor(config, parser, signal) {
+  constructor(config, parser2, signal) {
     super(config);
     __publicField(this, "parser");
     __publicField(this, "abortSignal");
     __publicField(this, "abortHandler");
-    this.parser = parser;
+    this.parser = parser2;
     this.wireParser();
     if (signal !== void 0) {
       this.wireAbortSignal(signal);
     }
   }
-  /**
-   * Registers a typed listener for a dcmqrscp-specific event.
-   *
-   * @param event - The event name from DcmQRSCPEventMap
-   * @param listener - Callback receiving typed event data
-   * @returns this for chaining
-   */
   /** Disposes the server and its parser, preventing listener leaks. */
   [Symbol.dispose]() {
     if (this.abortSignal !== void 0 && this.abortHandler !== void 0) {
@@ -1578,6 +3731,13 @@ var DcmQRSCP = class _DcmQRSCP extends DcmtkProcess {
     this.parser[Symbol.dispose]();
     super[Symbol.dispose]();
   }
+  /**
+   * Registers a typed listener for a dcmqrscp-specific event.
+   *
+   * @param event - The event name from DcmQRSCPEventMap
+   * @param listener - Callback receiving typed event data
+   * @returns this for chaining
+   */
   onEvent(event, listener) {
     return this.on(event, listener);
   }
@@ -1608,16 +3768,16 @@ var DcmQRSCP = class _DcmQRSCP extends DcmtkProcess {
   static create(options) {
     const validation = DcmQRSCPOptionsSchema.safeParse(options);
     if (!validation.success) {
-      return err(new Error(`dcmqrscp: invalid options: ${validation.error.message}`));
+      return err(createValidationError("dcmqrscp", validation.error));
     }
     const binaryResult = resolveBinary("dcmqrscp");
     if (!binaryResult.ok) {
       return err(binaryResult.error);
     }
-    const args = buildArgs5(options);
-    const parser = new LineParser();
+    const args = buildArgs6(options);
+    const parser2 = new LineParser();
     for (const pattern of DCMQRSCP_PATTERNS) {
-      const addResult = parser.addPattern(pattern);
+      const addResult = parser2.addPattern(pattern);
       if (!addResult.ok) {
         return err(addResult.error);
       }
@@ -1628,7 +3788,7 @@ var DcmQRSCP = class _DcmQRSCP extends DcmtkProcess {
       startTimeoutMs: options.startTimeoutMs,
       drainTimeoutMs: options.drainTimeoutMs
     };
-    return ok(new _DcmQRSCP(config, parser, options.signal));
+    return ok(new _DcmQRSCP(config, parser2, options.signal));
   }
   /** Wires the line parser to the process output. */
   wireParser() {
@@ -1640,7 +3800,7 @@ var DcmQRSCP = class _DcmQRSCP extends DcmtkProcess {
         this.emit("error", { error: new Error(`Fatal: ${event}`), fatal: true });
         void this.stop();
       }
-      this.emit(event, ...[data]);
+      this.emit(event, data);
     });
   }
   /** Wires an AbortSignal to stop the server. */
@@ -1736,7 +3896,7 @@ var WlmscpfsOptionsSchema = z.object({
   drainTimeoutMs: z.number().int().positive().optional(),
   signal: z.instanceof(AbortSignal).optional()
 }).strict();
-function buildArgs6(options) {
+function buildArgs7(options) {
   const args = [];
   if (options.verbose !== false) {
     args.push("--verbose");
@@ -1766,24 +3926,17 @@ function buildNetworkArgs3(args, options) {
   }
 }
 var Wlmscpfs = class _Wlmscpfs extends DcmtkProcess {
-  constructor(config, parser, signal) {
+  constructor(config, parser2, signal) {
     super(config);
     __publicField(this, "parser");
     __publicField(this, "abortSignal");
     __publicField(this, "abortHandler");
-    this.parser = parser;
+    this.parser = parser2;
     this.wireParser();
     if (signal !== void 0) {
       this.wireAbortSignal(signal);
     }
   }
-  /**
-   * Registers a typed listener for a wlmscpfs-specific event.
-   *
-   * @param event - The event name from WlmscpfsEventMap
-   * @param listener - Callback receiving typed event data
-   * @returns this for chaining
-   */
   /** Disposes the server and its parser, preventing listener leaks. */
   [Symbol.dispose]() {
     if (this.abortSignal !== void 0 && this.abortHandler !== void 0) {
@@ -1792,6 +3945,13 @@ var Wlmscpfs = class _Wlmscpfs extends DcmtkProcess {
     this.parser[Symbol.dispose]();
     super[Symbol.dispose]();
   }
+  /**
+   * Registers a typed listener for a wlmscpfs-specific event.
+   *
+   * @param event - The event name from WlmscpfsEventMap
+   * @param listener - Callback receiving typed event data
+   * @returns this for chaining
+   */
   onEvent(event, listener) {
     return this.on(event, listener);
   }
@@ -1822,16 +3982,16 @@ var Wlmscpfs = class _Wlmscpfs extends DcmtkProcess {
   static create(options) {
     const validation = WlmscpfsOptionsSchema.safeParse(options);
     if (!validation.success) {
-      return err(new Error(`wlmscpfs: invalid options: ${validation.error.message}`));
+      return err(createValidationError("wlmscpfs", validation.error));
     }
     const binaryResult = resolveBinary("wlmscpfs");
     if (!binaryResult.ok) {
       return err(binaryResult.error);
     }
-    const args = buildArgs6(options);
-    const parser = new LineParser();
+    const args = buildArgs7(options);
+    const parser2 = new LineParser();
     for (const pattern of WLMSCPFS_PATTERNS) {
-      const addResult = parser.addPattern(pattern);
+      const addResult = parser2.addPattern(pattern);
       if (!addResult.ok) {
         return err(addResult.error);
       }
@@ -1843,7 +4003,7 @@ var Wlmscpfs = class _Wlmscpfs extends DcmtkProcess {
       drainTimeoutMs: options.drainTimeoutMs
       // wlmscpfs doesn't reliably print "listening" — resolve on spawn
     };
-    return ok(new _Wlmscpfs(config, parser, options.signal));
+    return ok(new _Wlmscpfs(config, parser2, options.signal));
   }
   /** Wires the line parser to the process output. */
   wireParser() {
@@ -1855,7 +4015,7 @@ var Wlmscpfs = class _Wlmscpfs extends DcmtkProcess {
         this.emit("error", { error: new Error(`Fatal: ${event}`), fatal: true });
         void this.stop();
       }
-      this.emit(event, ...[data]);
+      this.emit(event, data);
     });
   }
   /** Wires an AbortSignal to stop the server. */
@@ -1872,6 +4032,6 @@ var Wlmscpfs = class _Wlmscpfs extends DcmtkProcess {
   }
 };
 
-export { DCMPRSCP_FATAL_EVENTS, DCMPRSCP_PATTERNS, DCMPSRCV_FATAL_EVENTS, DCMPSRCV_PATTERNS, DCMQRSCP_FATAL_EVENTS, DCMQRSCP_PATTERNS, DCMRECV_FATAL_EVENTS, DCMRECV_PATTERNS, DcmQRSCP, DcmprsCP, DcmprscpEvent, Dcmpsrcv, DcmpsrcvEvent, DcmqrscpEvent, Dcmrecv, DcmrecvEvent, DcmtkProcess, FilenameMode, LineParser, PreferredTransferSyntax, ProcessState, STORESCP_FATAL_EVENTS, STORESCP_PATTERNS, StorageMode, StoreSCP, StorescpEvent, SubdirectoryMode, WLMSCPFS_FATAL_EVENTS, WLMSCPFS_PATTERNS, Wlmscpfs, WlmscpfsEvent };
+export { AssociationTracker, DCMPRSCP_FATAL_EVENTS, DCMPRSCP_PATTERNS, DCMPSRCV_FATAL_EVENTS, DCMPSRCV_PATTERNS, DCMQRSCP_FATAL_EVENTS, DCMQRSCP_PATTERNS, DCMRECV_FATAL_EVENTS, DCMRECV_PATTERNS, DcmQRSCP, DcmprsCP, DcmprscpEvent, Dcmpsrcv, DcmpsrcvEvent, DcmqrscpEvent, Dcmrecv, DcmrecvEvent, DcmtkProcess, DicomReceiver, FilenameMode, LineParser, PreferredTransferSyntax, ProcessState, STORESCP_FATAL_EVENTS, STORESCP_PATTERNS, StorageMode, StoreSCP, StoreSCPPreset, StorescpEvent, SubdirectoryMode, WLMSCPFS_FATAL_EVENTS, WLMSCPFS_PATTERNS, Wlmscpfs, WlmscpfsEvent };
 //# sourceMappingURL=servers.js.map
 //# sourceMappingURL=servers.js.map