@ecobridge.xyz/devicemanager 3.0.2 → 3.1.1

package/ts/discovery/discovery.classes.ssdp.ts

@@ -1,5 +1,15 @@
 import * as plugins from '../plugins.js';
 
+const SSDP_ADDRESS = '239.255.255.250';
+const SSDP_PORT = 1900;
+const SSDP_MULTICAST_TTL = 4;
+const SEARCH_INTERVAL_MS = 30000;
+const DESCRIPTION_TIMEOUT_MS = 5000;
+const SOAP_TIMEOUT_MS = 10000;
+
+type TSsdpLifecycleState = 'stopped' | 'starting' | 'running' | 'stopping';
+type TSsdpTimer = ReturnType<typeof setInterval>;
+
 /**
  * SSDP service types for device discovery
  */
@@ -19,6 +29,13 @@ export const SSDP_SERVICE_TYPES = {
   INTERNET_GATEWAY: 'urn:schemas-upnp-org:device:InternetGatewayDevice:1',
 };
 
+const DEFAULT_SERVICE_TYPES = [
+  SSDP_SERVICE_TYPES.ROOT,
+  SSDP_SERVICE_TYPES.MEDIA_RENDERER,
+  SSDP_SERVICE_TYPES.MEDIA_SERVER,
+  SSDP_SERVICE_TYPES.SONOS_ZONE_PLAYER,
+];
+
 /**
  * SSDP discovered device information
  */
@@ -74,187 +91,462 @@ export interface ISsdpIcon {
 }
 
 /**
- * SSDP Discovery service using node-ssdp
+ * Optional runtime dependencies. These are primarily useful for deterministic
+ * tests and do not change the default native Node.js behavior.
  */
-export class SsdpDiscovery extends plugins.events.EventEmitter {
-  private client: InstanceType<typeof plugins.nodeSsdp.Client> | null = null;
-  private devices: Map<string, ISsdpDevice> = new Map();
-  private running = false;
-  private searchInterval: NodeJS.Timeout | null = null;
+export interface ISsdpDiscoveryDependencies {
+  createSocket?: () => plugins.dgram.Socket;
+  networkInterfaces?: typeof plugins.os.networkInterfaces;
+  fetch?: typeof globalThis.fetch;
+  setInterval?: (callback: () => void, delay: number) => TSsdpTimer;
+  clearInterval?: (timer: TSsdpTimer) => void;
+  setTimeout?: (callback: () => void, delay: number) => TSsdpTimer;
+  clearTimeout?: (timer: TSsdpTimer) => void;
+}
+
+interface ISsdpSocketResource {
+  address: string;
+  socket: plugins.dgram.Socket;
+  onMessage: (message: Buffer, rinfo: plugins.dgram.RemoteInfo) => void;
+  onError: (error: Error) => void;
+}
+
+interface IPendingDescription {
+  device: ISsdpDevice;
+  abortController: AbortController;
+  timeout: TSsdpTimer;
+  promise: Promise<void>;
+}
 
-  constructor() {
+interface IParsedSsdpResponse {
+  statusCode: number;
+  headers: Record<string, string>;
+}
+
+/**
+ * Focused SSDP discovery client backed by native Node.js UDP sockets.
+ */
+export class SsdpDiscovery extends plugins.events.EventEmitter {
+  private readonly dependencies: Required<ISsdpDiscoveryDependencies>;
+  private readonly devices = new Map<string, ISsdpDevice>();
+  private readonly foundUsns = new Set<string>();
+  private readonly pendingDescriptions = new Map<string, IPendingDescription>();
+  private sockets: ISsdpSocketResource[] = [];
+  private lifecycleState: TSsdpLifecycleState = 'stopped';
+  private lifecycleTail: Promise<void> = Promise.resolve();
+  private generation = 0;
+  private startupError: Error | null = null;
+  private searchInterval: TSsdpTimer | null = null;
+  private serviceTypes: string[] = [...DEFAULT_SERVICE_TYPES];
+
+  constructor(dependencies: ISsdpDiscoveryDependencies = {}) {
     super();
+    this.dependencies = {
+      createSocket: dependencies.createSocket ?? (() => plugins.dgram.createSocket({
+        type: 'udp4',
+        reuseAddr: true,
+      })),
+      networkInterfaces: dependencies.networkInterfaces ?? plugins.os.networkInterfaces,
+      fetch: dependencies.fetch ?? globalThis.fetch,
+      setInterval: dependencies.setInterval ?? globalThis.setInterval,
+      clearInterval: dependencies.clearInterval ?? globalThis.clearInterval,
+      setTimeout: dependencies.setTimeout ?? globalThis.setTimeout,
+      clearTimeout: dependencies.clearTimeout ?? globalThis.clearTimeout,
+    };
   }
 
   /**
-   * Start SSDP discovery
+   * Start SSDP discovery.
    */
   public async start(serviceTypes?: string[]): Promise<void> {
-    if (this.running) {
-      return;
-    }
-
-    this.running = true;
-    this.client = new plugins.nodeSsdp.Client();
-
-    // Handle SSDP responses
-    this.client.on('response', (headers: Record<string, string>, statusCode: number, rinfo: { address: string; port: number }) => {
-      this.handleSsdpResponse(headers, rinfo);
-    });
-
-    // Search for devices
-    const typesToSearch = serviceTypes ?? [
-      SSDP_SERVICE_TYPES.ROOT,
-      SSDP_SERVICE_TYPES.MEDIA_RENDERER,
-      SSDP_SERVICE_TYPES.MEDIA_SERVER,
-      SSDP_SERVICE_TYPES.SONOS_ZONE_PLAYER,
-    ];
-
-    // Initial search
-    for (const st of typesToSearch) {
-      this.client.search(st);
+    const typesToSearch = [...(serviceTypes ?? DEFAULT_SERVICE_TYPES)];
+    for (const serviceType of typesToSearch) {
+      this.validateServiceType(serviceType);
     }
 
-    // Periodic re-search (every 30 seconds)
-    this.searchInterval = setInterval(() => {
-      if (this.client) {
-        for (const st of typesToSearch) {
-          this.client.search(st);
-        }
+    return this.queueLifecycle(async () => {
+      if (this.lifecycleState === 'running') {
+        return;
       }
-    }, 30000);
-
-    this.emit('started');
+      await this.startInternal(typesToSearch);
+    });
   }
 
   /**
-   * Stop SSDP discovery
+   * Stop SSDP discovery.
    */
   public async stop(): Promise<void> {
-    if (!this.running) {
-      return;
-    }
-
-    this.running = false;
-
-    if (this.searchInterval) {
-      clearInterval(this.searchInterval);
-      this.searchInterval = null;
-    }
-
-    if (this.client) {
-      this.client.stop();
-      this.client = null;
-    }
+    return this.queueLifecycle(async () => {
+      if (this.lifecycleState === 'stopped') {
+        return;
+      }
 
-    this.emit('stopped');
+      const shouldEmitStopped = this.lifecycleState === 'running';
+      await this.cleanupResources();
+      if (shouldEmitStopped) {
+        this.emit('stopped');
+      }
+    });
   }
 
   /**
-   * Check if discovery is running
+   * Check if discovery is running.
    */
   public get isRunning(): boolean {
-    return this.running;
+    return this.lifecycleState === 'running';
   }
 
   /**
-   * Get all discovered devices
+   * Get all discovered devices.
    */
   public getDevices(): ISsdpDevice[] {
     return Array.from(this.devices.values());
   }
 
   /**
-   * Get devices by service type
+   * Get devices by service type.
    */
   public getDevicesByType(serviceType: string): ISsdpDevice[] {
-    return this.getDevices().filter((d) => d.serviceType === serviceType);
+    return this.getDevices().filter((device) => device.serviceType === serviceType);
   }
 
   /**
-   * Search for a specific service type
+   * Search for a specific service type.
    */
   public search(serviceType: string): void {
-    if (this.client && this.running) {
-      this.client.search(serviceType);
+    this.validateServiceType(serviceType);
+    if (this.lifecycleState !== 'running') {
+      return;
     }
+
+    const activeGeneration = this.generation;
+    void this.sendSearches([serviceType], activeGeneration).catch((error: unknown) => {
+      this.handleRuntimeError(this.toError(error), activeGeneration);
+    });
+  }
+
+  private queueLifecycle(operation: () => Promise<void>): Promise<void> {
+    const result = this.lifecycleTail.then(operation);
+    this.lifecycleTail = result.catch(() => {});
+    return result;
+  }
+
+  private async startInternal(typesToSearch: string[]): Promise<void> {
+    this.lifecycleState = 'starting';
+    this.startupError = null;
+    const activeGeneration = ++this.generation;
+
+    try {
+      const addresses = this.getInterfaceAddresses();
+      if (addresses.length === 0) {
+        throw new Error('No non-internal IPv4 interfaces available for SSDP discovery.');
+      }
+
+      for (const address of addresses) {
+        const resource = this.createSocketResource(address, activeGeneration);
+        this.sockets.push(resource);
+        await this.bindSocket(resource);
+      }
+
+      await this.sendSearches(typesToSearch, activeGeneration);
+      if (this.startupError) {
+        throw this.startupError;
+      }
+
+      this.serviceTypes = typesToSearch;
+      this.lifecycleState = 'running';
+      this.searchInterval = this.dependencies.setInterval(() => {
+        const intervalGeneration = this.generation;
+        void this.sendSearches(this.serviceTypes, intervalGeneration).catch((error: unknown) => {
+          this.handleRuntimeError(this.toError(error), intervalGeneration);
+        });
+      }, SEARCH_INTERVAL_MS);
+      this.unrefTimer(this.searchInterval);
+      this.emit('started');
+    } catch (error) {
+      await this.cleanupResources();
+      throw error;
+    }
+  }
+
+  private getInterfaceAddresses(): string[] {
+    const addresses = new Set<string>();
+    const interfaces = this.dependencies.networkInterfaces();
+
+    for (const [, interfaceInfos] of Object.entries(interfaces).sort(([a], [b]) => a.localeCompare(b))) {
+      for (const interfaceInfo of interfaceInfos ?? []) {
+        if (!interfaceInfo.internal && interfaceInfo.family === 'IPv4') {
+          addresses.add(interfaceInfo.address);
+        }
+      }
+    }
+
+    return Array.from(addresses).sort((a, b) => a.localeCompare(b));
+  }
+
+  private createSocketResource(address: string, activeGeneration: number): ISsdpSocketResource {
+    const socket = this.dependencies.createSocket();
+    const onMessage = (message: Buffer, rinfo: plugins.dgram.RemoteInfo): void => {
+      if (this.lifecycleState === 'running' && this.generation === activeGeneration) {
+        this.handleSsdpMessage(message, rinfo, activeGeneration);
+      }
+    };
+    const onError = (error: Error): void => {
+      if (this.lifecycleState === 'starting' && this.generation === activeGeneration) {
+        this.startupError ??= error;
+        return;
+      }
+      this.handleRuntimeError(error, activeGeneration);
+    };
+
+    socket.on('message', onMessage);
+    socket.on('error', onError);
+    return { address, socket, onMessage, onError };
+  }
+
+  private async bindSocket(resource: ISsdpSocketResource): Promise<void> {
+    const { address, socket } = resource;
+
+    await new Promise<void>((resolve, reject) => {
+      const cleanupBindListeners = (): void => {
+        socket.off('listening', onListening);
+        socket.off('error', onBindError);
+      };
+      const onListening = (): void => {
+        cleanupBindListeners();
+        resolve();
+      };
+      const onBindError = (error: Error): void => {
+        cleanupBindListeners();
+        reject(error);
+      };
+
+      socket.once('listening', onListening);
+      socket.once('error', onBindError);
+      try {
+        socket.bind({ port: 0, address, exclusive: true });
+      } catch (error) {
+        cleanupBindListeners();
+        reject(error);
+      }
+    });
+
+    if (this.startupError) {
+      throw this.startupError;
+    }
+
+    socket.setMulticastInterface(address);
+    socket.setMulticastTTL(SSDP_MULTICAST_TTL);
+    // M-SEARCH responses are unicast to this bound socket, so membership is not needed.
+    socket.unref();
+  }
+
+  private async sendSearches(serviceTypes: string[], activeGeneration: number): Promise<void> {
+    if (
+      this.generation !== activeGeneration ||
+      (this.lifecycleState !== 'starting' && this.lifecycleState !== 'running')
+    ) {
+      return;
+    }
+
+    const sends: Promise<void>[] = [];
+    for (const serviceType of serviceTypes) {
+      const packet = this.createSearchPacket(serviceType);
+      for (const resource of this.sockets) {
+        sends.push(this.sendPacket(resource.socket, packet));
+      }
+    }
+
+    const results = await Promise.allSettled(sends);
+    const failure = results.find((result): result is PromiseRejectedResult => result.status === 'rejected');
+    if (failure) {
+      throw failure.reason;
+    }
+  }
+
+  private createSearchPacket(serviceType: string): Buffer {
+    return Buffer.from([
+      'M-SEARCH * HTTP/1.1',
+      `HOST: ${SSDP_ADDRESS}:${SSDP_PORT}`,
+      'MAN: "ssdp:discover"',
+      'MX: 3',
+      `ST: ${serviceType}`,
+      '',
+      '',
+    ].join('\r\n'), 'ascii');
+  }
+
+  private async sendPacket(socket: plugins.dgram.Socket, packet: Buffer): Promise<void> {
+    await new Promise<void>((resolve, reject) => {
+      try {
+        socket.send(packet, SSDP_PORT, SSDP_ADDRESS, (error) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve();
+          }
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+
+  private handleRuntimeError(error: Error, activeGeneration: number): void {
+    if (this.lifecycleState !== 'running' || this.generation !== activeGeneration) {
+      return;
+    }
+
+    void this.stop();
+    if (this.listenerCount('error') > 0) {
+      this.emit('error', error);
+    }
+  }
+
+  private handleSsdpMessage(
+    message: Buffer,
+    rinfo: plugins.dgram.RemoteInfo,
+    activeGeneration: number
+  ): void {
+    const response = this.parseSsdpResponse(message);
+    if (!response || response.statusCode !== 200) {
+      return;
+    }
+    this.handleSsdpResponse(response.headers, rinfo, activeGeneration);
+  }
+
+  private parseSsdpResponse(message: Buffer): IParsedSsdpResponse | null {
+    const lines = message.toString('utf8').split(/\r?\n/);
+    const statusLine = lines.shift()?.trim() ?? '';
+    const statusMatch = statusLine.match(/^HTTP\/\d\.\d\s+(\d{3})(?:\s|$)/i);
+    if (!statusMatch) {
+      return null;
+    }
+
+    const headers: Record<string, string> = {};
+    for (const line of lines) {
+      if (line.trim() === '') {
+        break;
+      }
+      const separatorIndex = line.indexOf(':');
+      if (separatorIndex <= 0) {
+        continue;
+      }
+      const name = line.slice(0, separatorIndex).trim().toUpperCase();
+      if (name) {
+        headers[name] = line.slice(separatorIndex + 1).trim();
+      }
+    }
+
+    return {
+      statusCode: Number.parseInt(statusMatch[1], 10),
+      headers,
+    };
   }
 
-  /**
-   * Handle SSDP response
-   */
   private handleSsdpResponse(
     headers: Record<string, string>,
-    rinfo: { address: string; port: number }
+    rinfo: plugins.dgram.RemoteInfo,
+    activeGeneration: number
   ): void {
-    const usn = headers['USN'] || headers['usn'];
-    const location = headers['LOCATION'] || headers['location'];
-    const st = headers['ST'] || headers['st'];
-
+    const usn = headers.USN;
+    const location = headers.LOCATION;
     if (!usn || !location) {
       return;
     }
 
-    // Parse location URL
-    let address = rinfo.address;
-    let port = 80;
-
-    try {
-      const url = new URL(location);
-      address = url.hostname;
-      port = parseInt(url.port) || (url.protocol === 'https:' ? 443 : 80);
-    } catch {
-      // Keep rinfo address
+    const locationInfo = this.parseLocation(location, rinfo.address);
+    const existing = this.devices.get(usn);
+    if (existing) {
+      existing.serviceType = headers.ST || 'unknown';
+      existing.location = location;
+      existing.address = locationInfo.address;
+      existing.port = locationInfo.port;
+      existing.headers = { ...headers };
+
+      if (this.foundUsns.has(usn)) {
+        this.emit('device:updated', existing);
+      }
+      return;
     }
 
     const device: ISsdpDevice = {
       usn,
-      serviceType: st || 'unknown',
+      serviceType: headers.ST || 'unknown',
       location,
-      address,
-      port,
+      address: locationInfo.address,
+      port: locationInfo.port,
       headers: { ...headers },
     };
 
-    const isNew = !this.devices.has(usn);
     this.devices.set(usn, device);
+    this.startDescriptionFetch(device, activeGeneration);
+  }
 
-    if (isNew) {
-      // Fetch device description
-      this.fetchDeviceDescription(device).then(() => {
-        this.emit('device:found', device);
-      }).catch(() => {
-        // Still emit even without description
-        this.emit('device:found', device);
-      });
-    } else {
-      this.emit('device:updated', device);
+  private parseLocation(location: string, fallbackAddress: string): { address: string; port: number } {
+    try {
+      const url = new URL(location);
+      return {
+        address: url.hostname,
+        port: Number.parseInt(url.port, 10) || (url.protocol === 'https:' ? 443 : 80),
+      };
+    } catch {
+      return { address: fallbackAddress, port: 80 };
     }
   }
 
-  /**
-   * Fetch and parse device description XML
-   */
-  private async fetchDeviceDescription(device: ISsdpDevice): Promise<void> {
-    try {
-      const response = await fetch(device.location, {
-        signal: AbortSignal.timeout(5000),
-      });
+  private startDescriptionFetch(device: ISsdpDevice, activeGeneration: number): void {
+    const abortController = new AbortController();
+    const timeout = this.dependencies.setTimeout(() => {
+      abortController.abort();
+    }, DESCRIPTION_TIMEOUT_MS);
+    this.unrefTimer(timeout);
+
+    const pending: IPendingDescription = {
+      device,
+      abortController,
+      timeout,
+      promise: Promise.resolve(),
+    };
+
+    pending.promise = (async () => {
+      await this.fetchDeviceDescription(device, abortController.signal);
+      if (
+        this.lifecycleState === 'running' &&
+        this.generation === activeGeneration &&
+        this.devices.get(device.usn) === device &&
+        !this.foundUsns.has(device.usn)
+      ) {
+        this.foundUsns.add(device.usn);
+        this.emit('device:found', device);
+      }
+    })().finally(() => {
+      this.dependencies.clearTimeout(timeout);
+      if (this.pendingDescriptions.get(device.usn) === pending) {
+        this.pendingDescriptions.delete(device.usn);
+      }
+    });
 
+    this.pendingDescriptions.set(device.usn, pending);
+  }
+
+  private async fetchDeviceDescription(device: ISsdpDevice, signal: AbortSignal): Promise<void> {
+    try {
+      const response = await this.dependencies.fetch(device.location, { signal });
       if (!response.ok) {
+        await this.cancelResponseBody(response);
         return;
       }
 
       const xml = await response.text();
-      device.description = this.parseDeviceDescription(xml);
+      if (!signal.aborted) {
+        device.description = this.parseDeviceDescription(xml);
+      }
     } catch {
-      // Ignore fetch errors
+      // Devices without a reachable description are still valid SSDP results.
     }
   }
 
-  /**
-   * Parse UPnP device description XML
-   */
   private parseDeviceDescription(xml: string): ISsdpDeviceDescription {
     const getTagContent = (tag: string, source: string = xml): string => {
       const regex = new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`, 'i');
@@ -268,7 +560,6 @@ export class SsdpDiscovery extends plugins.events.EventEmitter {
       return match?.[1] ?? '';
     };
 
-    // Parse services
     const services: ISsdpService[] = [];
     const serviceListBlock = getTagBlock('serviceList');
     const serviceMatches = serviceListBlock.match(/<service>[\s\S]*?<\/service>/gi) || [];
@@ -283,7 +574,6 @@ export class SsdpDiscovery extends plugins.events.EventEmitter {
       });
     }
 
-    // Parse icons
     const icons: ISsdpIcon[] = [];
     const iconListBlock = getTagBlock('iconList');
     const iconMatches = iconListBlock.match(/<icon>[\s\S]*?<\/icon>/gi) || [];
@@ -291,9 +581,9 @@ export class SsdpDiscovery extends plugins.events.EventEmitter {
     for (const iconXml of iconMatches) {
       icons.push({
         mimetype: getTagContent('mimetype', iconXml),
-        width: parseInt(getTagContent('width', iconXml)) || 0,
-        height: parseInt(getTagContent('height', iconXml)) || 0,
-        depth: parseInt(getTagContent('depth', iconXml)) || 0,
+        width: Number.parseInt(getTagContent('width', iconXml), 10) || 0,
+        height: Number.parseInt(getTagContent('height', iconXml), 10) || 0,
+        depth: Number.parseInt(getTagContent('depth', iconXml), 10) || 0,
         url: getTagContent('url', iconXml),
       });
     }
@@ -314,8 +604,71 @@ export class SsdpDiscovery extends plugins.events.EventEmitter {
     };
   }
 
+  private async cleanupResources(): Promise<void> {
+    this.lifecycleState = 'stopping';
+    ++this.generation;
+
+    if (this.searchInterval) {
+      this.dependencies.clearInterval(this.searchInterval);
+      this.searchInterval = null;
+    }
+
+    const pendingDescriptions = Array.from(this.pendingDescriptions.values());
+    for (const pending of pendingDescriptions) {
+      this.dependencies.clearTimeout(pending.timeout);
+      pending.abortController.abort();
+    }
+    await Promise.allSettled(pendingDescriptions.map((pending) => pending.promise));
+    for (const pending of pendingDescriptions) {
+      if (!this.foundUsns.has(pending.device.usn) && this.devices.get(pending.device.usn) === pending.device) {
+        this.devices.delete(pending.device.usn);
+      }
+    }
+    this.pendingDescriptions.clear();
+
+    const sockets = this.sockets;
+    this.sockets = [];
+    await Promise.all(sockets.map(async (resource) => {
+      resource.socket.off('message', resource.onMessage);
+      resource.socket.off('error', resource.onError);
+      await new Promise<void>((resolve) => {
+        try {
+          resource.socket.close(resolve);
+        } catch {
+          resolve();
+        }
+      });
+    }));
+
+    this.startupError = null;
+    this.lifecycleState = 'stopped';
+  }
+
+  private validateServiceType(serviceType: string): void {
+    if (!serviceType || /[\r\n]/.test(serviceType)) {
+      throw new Error('SSDP service type must be non-empty and cannot contain line breaks.');
+    }
+  }
+
+  private unrefTimer(timer: TSsdpTimer): void {
+    const unref = (timer as TSsdpTimer & { unref?: () => void }).unref;
+    unref?.call(timer);
+  }
+
+  private toError(error: unknown): Error {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+
+  private async cancelResponseBody(response: Response): Promise<void> {
+    try {
+      await response.body?.cancel();
+    } catch {
+      // The fetch timeout/abort remains the final cleanup path for a failed body.
+    }
+  }
+
   /**
-   * Make a UPnP SOAP request
+   * Make a UPnP SOAP request.
    */
   public async soapRequest(
     controlUrl: string,
@@ -323,7 +676,6 @@ export class SsdpDiscovery extends plugins.events.EventEmitter {
     action: string,
     args: Record<string, string | number> = {}
   ): Promise<string> {
-    // Build SOAP body
     let argsXml = '';
     for (const [key, value] of Object.entries(args)) {
       argsXml += `<${key}>${value}</${key}>`;
@@ -338,20 +690,31 @@ export class SsdpDiscovery extends plugins.events.EventEmitter {
   </s:Body>
 </s:Envelope>`;
 
-    const response = await fetch(controlUrl, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'text/xml; charset=utf-8',
-        'SOAPACTION': `"${serviceType}#${action}"`,
-      },
-      body: soapBody,
-      signal: AbortSignal.timeout(10000),
-    });
+    const abortController = new AbortController();
+    const timeout = this.dependencies.setTimeout(() => {
+      abortController.abort();
+    }, SOAP_TIMEOUT_MS);
+    this.unrefTimer(timeout);
 
-    if (!response.ok) {
-      throw new Error(`SOAP request failed: ${response.status}`);
-    }
+    try {
+      const response = await this.dependencies.fetch(controlUrl, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'text/xml; charset=utf-8',
+          'SOAPACTION': `"${serviceType}#${action}"`,
+        },
+        body: soapBody,
+        signal: abortController.signal,
+      });
 
-    return response.text();
+      if (!response.ok) {
+        await this.cancelResponseBody(response);
+        throw new Error(`SOAP request failed: ${response.status}`);
+      }
+
+      return await response.text();
+    } finally {
+      this.dependencies.clearTimeout(timeout);
+    }
   }
 }