@ecobridge.xyz/devicemanager 3.1.0 → 3.1.1

package/test/test.ssdp.node.ts

@@ -0,0 +1,978 @@
+import { EventEmitter } from 'node:events';
+import type { BindOptions, RemoteInfo, Socket } from 'node:dgram';
+import { createServer } from 'node:http';
+import type { NetworkInterfaceInfo } from 'node:os';
+
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as devicemanager from '../ts/index.js';
+import type {
+  ISsdpDevice,
+  ISsdpDiscoveryDependencies,
+} from '../ts/index.js';
+
+const DEVICE_DESCRIPTION = `<?xml version="1.0"?>
+<root>
+  <device>
+    <deviceType>urn:schemas-upnp-org:device:MediaRenderer:1</deviceType>
+    <friendlyName>Living Room</friendlyName>
+    <manufacturer>Example Corp</manufacturer>
+    <modelName>Example Renderer</modelName>
+    <UDN>uuid:device-1</UDN>
+    <serviceList>
+      <service>
+        <serviceType>urn:schemas-upnp-org:service:AVTransport:1</serviceType>
+        <serviceId>urn:upnp-org:serviceId:AVTransport</serviceId>
+        <SCPDURL>/avtransport.xml</SCPDURL>
+        <controlURL>/control</controlURL>
+        <eventSubURL>/events</eventSubURL>
+      </service>
+    </serviceList>
+    <iconList>
+      <icon>
+        <mimetype>image/png</mimetype>
+        <width>64</width>
+        <height>64</height>
+        <depth>24</depth>
+        <url>/icon.png</url>
+      </icon>
+    </iconList>
+  </device>
+</root>`;
+
+const SONOS_DEVICE_DESCRIPTION = `<?xml version="1.0"?>
+<root>
+  <device>
+    <deviceType>urn:schemas-upnp-org:device:ZonePlayer:1</deviceType>
+    <friendlyName>Kitchen</friendlyName>
+    <manufacturer>Sonos, Inc.</manufacturer>
+    <modelName>Sonos One</modelName>
+    <UDN>uuid:RINCON_00000000000101400</UDN>
+  </device>
+</root>`;
+
+interface IFakeSocketOptions {
+  bindError?: Error;
+  configurationError?: Error;
+  sendErrors?: Array<Error | null>;
+}
+
+interface ISentPacket {
+  message: string;
+  port: number;
+  address: string;
+  wasBound: boolean;
+}
+
+class FakeSocket extends EventEmitter {
+  public readonly bindCalls: BindOptions[] = [];
+  public readonly sentPackets: ISentPacket[] = [];
+  public multicastInterface: string | null = null;
+  public multicastTtl: number | null = null;
+  public bound = false;
+  public closed = false;
+  public unrefCalled = false;
+  private readonly options: IFakeSocketOptions;
+
+  constructor(options: IFakeSocketOptions = {}) {
+    super();
+    this.options = options;
+  }
+
+  public bind(options: BindOptions): this {
+    this.bindCalls.push(options);
+    queueMicrotask(() => {
+      if (this.options.bindError) {
+        this.emit('error', this.options.bindError);
+      } else {
+        this.bound = true;
+        this.emit('listening');
+      }
+    });
+    return this;
+  }
+
+  public setMulticastInterface(address: string): void {
+    if (this.options.configurationError) {
+      throw this.options.configurationError;
+    }
+    this.multicastInterface = address;
+  }
+
+  public setMulticastTTL(ttl: number): void {
+    this.multicastTtl = ttl;
+  }
+
+  public unref(): this {
+    this.unrefCalled = true;
+    return this;
+  }
+
+  public send(
+    message: Buffer,
+    port: number,
+    address: string,
+    callback: (error: Error | null, bytes: number) => void
+  ): void {
+    this.sentPackets.push({
+      message: message.toString('ascii'),
+      port,
+      address,
+      wasBound: this.bound,
+    });
+    const error = this.options.sendErrors?.shift() ?? null;
+    queueMicrotask(() => callback(error, error ? 0 : message.length));
+  }
+
+  public close(callback?: () => void): this {
+    this.closed = true;
+    queueMicrotask(() => {
+      this.emit('close');
+      callback?.();
+    });
+    return this;
+  }
+
+  public emitMessage(message: string, address = '192.168.1.50', port = 1900): void {
+    const rinfo: RemoteInfo = {
+      address,
+      family: 'IPv4',
+      port,
+      size: Buffer.byteLength(message),
+    };
+    this.emit('message', Buffer.from(message), rinfo);
+  }
+}
+
+type TFakeTimerKind = 'interval' | 'timeout';
+
+class FakeTimer {
+  public active = true;
+  public unrefCalled = false;
+
+  constructor(
+    public readonly kind: TFakeTimerKind,
+    public readonly callback: () => void,
+    public readonly delay: number
+  ) {}
+
+  public unref(): void {
+    this.unrefCalled = true;
+  }
+}
+
+class FakeClock {
+  public readonly timers: FakeTimer[] = [];
+
+  public readonly setInterval = (callback: () => void, delay: number): ReturnType<typeof setInterval> => {
+    return this.createTimer('interval', callback, delay);
+  };
+
+  public readonly clearInterval = (timer: ReturnType<typeof setInterval>): void => {
+    this.toFakeTimer(timer).active = false;
+  };
+
+  public readonly setTimeout = (callback: () => void, delay: number): ReturnType<typeof setTimeout> => {
+    return this.createTimer('timeout', callback, delay);
+  };
+
+  public readonly clearTimeout = (timer: ReturnType<typeof setTimeout>): void => {
+    this.toFakeTimer(timer).active = false;
+  };
+
+  public fireIntervals(): void {
+    for (const timer of this.timers) {
+      if (timer.active && timer.kind === 'interval') {
+        timer.callback();
+      }
+    }
+  }
+
+  public get activeCount(): number {
+    return this.timers.filter((timer) => timer.active).length;
+  }
+
+  private createTimer(
+    kind: TFakeTimerKind,
+    callback: () => void,
+    delay: number
+  ): ReturnType<typeof setTimeout> {
+    const timer = new FakeTimer(kind, callback, delay);
+    this.timers.push(timer);
+    return timer as unknown as ReturnType<typeof setTimeout>;
+  }
+
+  private toFakeTimer(timer: ReturnType<typeof setTimeout>): FakeTimer {
+    return timer as unknown as FakeTimer;
+  }
+}
+
+interface ITestHarnessOptions {
+  addresses?: string[];
+  socketOptions?: IFakeSocketOptions[];
+  fetch?: typeof globalThis.fetch;
+}
+
+interface ITestHarness {
+  discovery: devicemanager.SsdpDiscovery;
+  sockets: FakeSocket[];
+  clock: FakeClock;
+  fetchCalls: Array<{ input: string; init?: RequestInit }>;
+}
+
+function createHarness(options: ITestHarnessOptions = {}): ITestHarness {
+  const addresses = options.addresses ?? ['192.168.1.10'];
+  const sockets: FakeSocket[] = [];
+  const clock = new FakeClock();
+  const fetchCalls: Array<{ input: string; init?: RequestInit }> = [];
+  let socketIndex = 0;
+
+  const fetchImplementation: typeof globalThis.fetch = async (input, init) => {
+    fetchCalls.push({ input: String(input), init });
+    if (options.fetch) {
+      return options.fetch(input, init);
+    }
+    return new Response(DEVICE_DESCRIPTION, { status: 200 });
+  };
+
+  const interfaceInfos: NodeJS.Dict<NetworkInterfaceInfo[]> = {
+    lo: [{
+      address: '127.0.0.1',
+      netmask: '255.0.0.0',
+      family: 'IPv4',
+      mac: '00:00:00:00:00:00',
+      internal: true,
+      cidr: '127.0.0.1/8',
+    }],
+    ipv6: [{
+      address: 'fe80::1',
+      netmask: 'ffff:ffff:ffff:ffff::',
+      family: 'IPv6',
+      mac: '00:00:00:00:00:01',
+      internal: false,
+      cidr: 'fe80::1/64',
+      scopeid: 1,
+    }],
+  };
+
+  addresses.forEach((address, index) => {
+    interfaceInfos[`eth${index}`] = [{
+      address,
+      netmask: '255.255.255.0',
+      family: 'IPv4',
+      mac: `00:00:00:00:00:${String(index + 2).padStart(2, '0')}`,
+      internal: false,
+      cidr: `${address}/24`,
+    }];
+  });
+  if (addresses.length > 0) {
+    interfaceInfos.duplicate = [interfaceInfos.eth0![0]];
+  }
+
+  const dependencies: ISsdpDiscoveryDependencies = {
+    createSocket: () => {
+      const socket = new FakeSocket(options.socketOptions?.[socketIndex]);
+      socketIndex++;
+      sockets.push(socket);
+      return socket as unknown as Socket;
+    },
+    networkInterfaces: () => interfaceInfos,
+    fetch: fetchImplementation,
+    setInterval: clock.setInterval,
+    clearInterval: clock.clearInterval,
+    setTimeout: clock.setTimeout,
+    clearTimeout: clock.clearTimeout,
+  };
+
+  return {
+    discovery: new devicemanager.SsdpDiscovery(dependencies),
+    sockets,
+    clock,
+    fetchCalls,
+  };
+}
+
+function createSsdpResponse(
+  usn = 'uuid:device-1::upnp:rootdevice',
+  location = 'http://192.168.1.50:1400/description.xml',
+  serviceType = devicemanager.SSDP_SERVICE_TYPES.MEDIA_RENDERER,
+  lineEnding = '\r\n'
+): string {
+  return [
+    'HTTP/1.1 200 OK',
+    `usn: ${usn}`,
+    `LoCaTiOn: ${location}`,
+    `sT: ${serviceType}`,
+    'cache-control: max-age=1800',
+    '',
+    '',
+  ].join(lineEnding);
+}
+
+async function flushAsyncWork(): Promise<void> {
+  await new Promise<void>((resolve) => setImmediate(resolve));
+}
+
+async function captureError(operation: Promise<unknown>): Promise<Error | null> {
+  try {
+    await operation;
+    return null;
+  } catch (error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+}
+
+tap.test('SSDP frames and parses packets across every non-internal IPv4 interface', async () => {
+  const harness = createHarness({
+    addresses: ['192.168.1.10', '10.0.0.20', '192.168.1.10'],
+  });
+  const foundDevices: ISsdpDevice[] = [];
+  let started = 0;
+  let stopped = 0;
+  harness.discovery.on('started', () => started++);
+  harness.discovery.on('stopped', () => stopped++);
+  harness.discovery.on('device:found', (device: ISsdpDevice) => foundDevices.push(device));
+
+  await harness.discovery.start();
+
+  expect(harness.discovery.isRunning).toEqual(true);
+  expect(started).toEqual(1);
+  expect(harness.sockets.length).toEqual(2);
+  expect(harness.sockets.map((socket) => socket.bindCalls[0].address)).toEqual([
+    '10.0.0.20',
+    '192.168.1.10',
+  ]);
+  expect(harness.sockets.map((socket) => socket.multicastInterface)).toEqual([
+    '10.0.0.20',
+    '192.168.1.10',
+  ]);
+  expect(harness.sockets.every((socket) => socket.multicastTtl === 4)).toEqual(true);
+  expect(harness.sockets.every((socket) => socket.unrefCalled)).toEqual(true);
+  expect(harness.sockets.every((socket) => socket.sentPackets.length === 4)).toEqual(true);
+  expect(harness.sockets.every((socket) => socket.sentPackets.every((packet) => packet.wasBound))).toEqual(true);
+  expect(harness.sockets[0].sentPackets[0]).toEqual({
+    message: 'M-SEARCH * HTTP/1.1\r\nHOST: 239.255.255.250:1900\r\nMAN: "ssdp:discover"\r\nMX: 3\r\nST: upnp:rootdevice\r\n\r\n',
+    port: 1900,
+    address: '239.255.255.250',
+    wasBound: true,
+  });
+  expect(harness.clock.timers[0].unrefCalled).toEqual(true);
+
+  harness.sockets[0].emitMessage('HTTP/1.1 404 Not Found\r\nUSN: ignored\r\n\r\n');
+  harness.sockets[0].emitMessage(createSsdpResponse(undefined, undefined, undefined, '\n'));
+  await flushAsyncWork();
+
+  expect(foundDevices.length).toEqual(1);
+  expect(harness.discovery.getDevices().length).toEqual(1);
+  expect(harness.discovery.getDevicesByType(devicemanager.SSDP_SERVICE_TYPES.MEDIA_RENDERER).length).toEqual(1);
+  expect(foundDevices[0].headers).toEqual({
+    USN: 'uuid:device-1::upnp:rootdevice',
+    LOCATION: 'http://192.168.1.50:1400/description.xml',
+    ST: devicemanager.SSDP_SERVICE_TYPES.MEDIA_RENDERER,
+    'CACHE-CONTROL': 'max-age=1800',
+  });
+  expect(foundDevices[0].address).toEqual('192.168.1.50');
+  expect(foundDevices[0].port).toEqual(1400);
+  expect(foundDevices[0].description?.friendlyName).toEqual('Living Room');
+  expect(foundDevices[0].description?.services[0].controlURL).toEqual('/control');
+  expect(foundDevices[0].description?.icons?.[0].width).toEqual(64);
+
+  await harness.discovery.stop();
+  expect(harness.discovery.isRunning).toEqual(false);
+  expect(stopped).toEqual(1);
+  expect(harness.clock.activeCount).toEqual(0);
+  expect(harness.sockets.every((socket) => socket.closed)).toEqual(true);
+  expect(harness.sockets.every((socket) => socket.listenerCount('message') === 0)).toEqual(true);
+  expect(harness.sockets.every((socket) => socket.listenerCount('error') === 0)).toEqual(true);
+});
+
+tap.test('SSDP deduplicates USNs and preserves event ordering across custom, periodic, and restart searches', async () => {
+  let resolveDescription!: (response: Response) => void;
+  const harness = createHarness({
+    fetch: async () => new Promise<Response>((resolve) => {
+      resolveDescription = resolve;
+    }),
+  });
+  const eventNames: string[] = [];
+  const foundDevices: ISsdpDevice[] = [];
+  const updatedDevices: ISsdpDevice[] = [];
+  harness.discovery.on('started', () => eventNames.push('started'));
+  harness.discovery.on('stopped', () => eventNames.push('stopped'));
+  harness.discovery.on('device:found', (device: ISsdpDevice) => {
+    eventNames.push('found');
+    foundDevices.push(device);
+  });
+  harness.discovery.on('device:updated', (device: ISsdpDevice) => {
+    eventNames.push('updated');
+    updatedDevices.push(device);
+  });
+
+  await harness.discovery.start([devicemanager.SSDP_SERVICE_TYPES.ROOT]);
+  harness.sockets[0].emitMessage(createSsdpResponse());
+  harness.sockets[0].emitMessage(createSsdpResponse(
+    undefined,
+    'https://192.168.1.50:1443/description.xml'
+  ));
+  expect(foundDevices.length).toEqual(0);
+  expect(updatedDevices.length).toEqual(0);
+  expect(harness.discovery.getDevices().length).toEqual(1);
+
+  resolveDescription(new Response(DEVICE_DESCRIPTION, { status: 200 }));
+  await flushAsyncWork();
+  const canonicalDevice = foundDevices[0];
+  expect(canonicalDevice.port).toEqual(1443);
+
+  harness.sockets[0].emitMessage(createSsdpResponse());
+  expect(updatedDevices.length).toEqual(1);
+  expect(updatedDevices[0] === canonicalDevice).toEqual(true);
+  expect(updatedDevices[0].description?.friendlyName).toEqual('Living Room');
+  expect(updatedDevices[0].port).toEqual(1400);
+  expect(harness.fetchCalls.length).toEqual(1);
+
+  harness.discovery.search(devicemanager.SSDP_SERVICE_TYPES.BASIC_DEVICE);
+  await flushAsyncWork();
+  expect(harness.sockets[0].sentPackets.length).toEqual(2);
+  expect(harness.sockets[0].sentPackets[1].message).toInclude(
+    `ST: ${devicemanager.SSDP_SERVICE_TYPES.BASIC_DEVICE}\r\n`
+  );
+
+  harness.clock.fireIntervals();
+  await flushAsyncWork();
+  expect(harness.sockets[0].sentPackets.length).toEqual(3);
+  expect(harness.sockets[0].sentPackets[2].message).toInclude(
+    `ST: ${devicemanager.SSDP_SERVICE_TYPES.ROOT}\r\n`
+  );
+
+  await harness.discovery.start([devicemanager.SSDP_SERVICE_TYPES.MEDIA_SERVER]);
+  expect(harness.sockets.length).toEqual(1);
+  await harness.discovery.stop();
+  await harness.discovery.stop();
+
+  await harness.discovery.start([devicemanager.SSDP_SERVICE_TYPES.ROOT]);
+  expect(harness.sockets.length).toEqual(2);
+  harness.sockets[1].emitMessage(createSsdpResponse());
+  expect(updatedDevices.length).toEqual(2);
+  expect(updatedDevices[1] === canonicalDevice).toEqual(true);
+  expect(harness.fetchCalls.length).toEqual(1);
+  await harness.discovery.stop();
+
+  expect(eventNames).toEqual([
+    'started',
+    'found',
+    'updated',
+    'stopped',
+    'started',
+    'updated',
+    'stopped',
+  ]);
+  expect(harness.clock.activeCount).toEqual(0);
+});
+
+tap.test('SSDP rolls back zero-interface, partial bind, configuration, and initial send failures', async () => {
+  const zeroInterfaceHarness = createHarness({ addresses: [] });
+  const zeroInterfaceError = await captureError(zeroInterfaceHarness.discovery.start());
+  expect(zeroInterfaceError?.message).toContain('No non-internal IPv4 interfaces');
+  expect(zeroInterfaceHarness.discovery.isRunning).toEqual(false);
+  expect(zeroInterfaceHarness.sockets.length).toEqual(0);
+
+  const bindHarness = createHarness({
+    addresses: ['10.0.0.1', '10.0.0.2'],
+    socketOptions: [{}, { bindError: new Error('bind failed') }],
+  });
+  const bindError = await captureError(bindHarness.discovery.start([
+    devicemanager.SSDP_SERVICE_TYPES.ROOT,
+  ]));
+  expect(bindError?.message).toEqual('bind failed');
+  expect(bindHarness.discovery.isRunning).toEqual(false);
+  expect(bindHarness.sockets.every((socket) => socket.closed)).toEqual(true);
+  expect(bindHarness.sockets.every((socket) => socket.listenerCount('message') === 0)).toEqual(true);
+  expect(bindHarness.sockets.every((socket) => socket.listenerCount('error') === 0)).toEqual(true);
+  expect(bindHarness.clock.activeCount).toEqual(0);
+
+  const configurationHarness = createHarness({
+    socketOptions: [{ configurationError: new Error('configuration failed') }],
+  });
+  const configurationError = await captureError(configurationHarness.discovery.start());
+  expect(configurationError?.message).toEqual('configuration failed');
+  expect(configurationHarness.sockets[0].closed).toEqual(true);
+
+  const sendHarness = createHarness({
+    socketOptions: [{ sendErrors: [new Error('send failed')] }],
+  });
+  const sendError = await captureError(sendHarness.discovery.start([
+    devicemanager.SSDP_SERVICE_TYPES.ROOT,
+  ]));
+  expect(sendError?.message).toEqual('send failed');
+  expect(sendHarness.discovery.isRunning).toEqual(false);
+  expect(sendHarness.sockets[0].closed).toEqual(true);
+  expect(sendHarness.clock.activeCount).toEqual(0);
+});
+
+tap.test('SSDP stop aborts pending descriptions and suppresses post-stop events', async () => {
+  let abortObserved = false;
+  const pendingFetch: typeof globalThis.fetch = async (_input, init) => {
+    return new Promise<Response>((_resolve, reject) => {
+      init?.signal?.addEventListener('abort', () => {
+        abortObserved = true;
+        reject(new Error('aborted'));
+      }, { once: true });
+    });
+  };
+  const harness = createHarness({ fetch: pendingFetch });
+  let found = 0;
+  let updated = 0;
+  harness.discovery.on('device:found', () => found++);
+  harness.discovery.on('device:updated', () => updated++);
+
+  await harness.discovery.start([devicemanager.SSDP_SERVICE_TYPES.ROOT]);
+  harness.sockets[0].emitMessage(createSsdpResponse());
+  await flushAsyncWork();
+  expect(harness.discovery.getDevices().length).toEqual(1);
+
+  await harness.discovery.stop();
+  expect(abortObserved).toEqual(true);
+  expect(found).toEqual(0);
+  expect(updated).toEqual(0);
+  expect(harness.discovery.getDevices().length).toEqual(0);
+  expect(harness.clock.activeCount).toEqual(0);
+
+  harness.sockets[0].emitMessage(createSsdpResponse());
+  await flushAsyncWork();
+  expect(found).toEqual(0);
+  expect(updated).toEqual(0);
+});
+
+tap.test('SSDP runtime transport errors stop and clean every fake handle', async () => {
+  const socketErrorHarness = createHarness();
+  const reportedErrors: Error[] = [];
+  let stopped = 0;
+  socketErrorHarness.discovery.on('error', (error: Error) => reportedErrors.push(error));
+  socketErrorHarness.discovery.on('stopped', () => stopped++);
+  await socketErrorHarness.discovery.start([devicemanager.SSDP_SERVICE_TYPES.ROOT]);
+  socketErrorHarness.sockets[0].emit('error', new Error('runtime socket failure'));
+  await socketErrorHarness.discovery.stop();
+
+  expect(reportedErrors.map((error) => error.message)).toEqual(['runtime socket failure']);
+  expect(stopped).toEqual(1);
+  expect(socketErrorHarness.discovery.isRunning).toEqual(false);
+  expect(socketErrorHarness.sockets[0].closed).toEqual(true);
+  expect(socketErrorHarness.clock.activeCount).toEqual(0);
+
+  const sendErrorHarness = createHarness({
+    socketOptions: [{ sendErrors: [null, new Error('custom send failure')] }],
+  });
+  await sendErrorHarness.discovery.start([devicemanager.SSDP_SERVICE_TYPES.ROOT]);
+  sendErrorHarness.discovery.search(devicemanager.SSDP_SERVICE_TYPES.MEDIA_SERVER);
+  await flushAsyncWork();
+  await sendErrorHarness.discovery.stop();
+  expect(sendErrorHarness.discovery.isRunning).toEqual(false);
+  expect(sendErrorHarness.sockets[0].closed).toEqual(true);
+  expect(sendErrorHarness.clock.activeCount).toEqual(0);
+});
+
+tap.test('mDNS stop attempts every cleanup and clears retained handles on failure', async () => {
+  const discovery = new devicemanager.MdnsDiscovery();
+  const internals = discovery as unknown as {
+    browsers: Array<{ stop: () => void }>;
+    bonjour: { destroy: (callback?: (error?: Error) => void) => void } | null;
+    isRunning: boolean;
+  };
+  const cleanupCalls: string[] = [];
+  let stopped = 0;
+  discovery.on('stopped', () => stopped++);
+
+  internals.browsers = [
+    {
+      stop: () => {
+        cleanupCalls.push('browser-1');
+        throw new Error('browser 1 stop failed');
+      },
+    },
+    {
+      stop: () => {
+        cleanupCalls.push('browser-2');
+      },
+    },
+    {
+      stop: () => {
+        cleanupCalls.push('browser-3');
+        throw new Error('browser 3 stop failed');
+      },
+    },
+  ];
+  internals.bonjour = {
+    destroy: () => {
+      cleanupCalls.push('bonjour');
+      throw new Error('bonjour destroy failed');
+    },
+  };
+  internals.isRunning = true;
+
+  const error = await captureError(discovery.stop());
+  expect(error).toBeInstanceOf(AggregateError);
+  expect((error as AggregateError).errors.map((item: unknown) =>
+    item instanceof Error ? item.message : String(item)
+  )).toEqual([
+    'browser 1 stop failed',
+    'browser 3 stop failed',
+    'bonjour destroy failed',
+  ]);
+  expect(cleanupCalls).toEqual(['browser-1', 'browser-2', 'browser-3', 'bonjour']);
+  expect(discovery.running).toEqual(false);
+  expect(internals.browsers).toEqual([]);
+  expect(internals.bonjour).toEqual(null);
+  expect(stopped).toEqual(1);
+
+  await discovery.stop();
+  expect(cleanupCalls).toEqual(['browser-1', 'browser-2', 'browser-3', 'bonjour']);
+});
+
+tap.test('DeviceManager rolls back both discovery transports when either startup fails', async () => {
+  const manager = new devicemanager.DeviceManager({ autoDiscovery: false });
+  const internals = manager as unknown as {
+    mdnsDiscovery: {
+      start: () => Promise<void>;
+      stop: () => Promise<void>;
+    };
+    ssdpDiscovery: {
+      start: () => Promise<void>;
+      stop: () => Promise<void>;
+    };
+  };
+  let mdnsStarts = 0;
+  let mdnsStops = 0;
+  let ssdpStarts = 0;
+  let ssdpStops = 0;
+
+  internals.mdnsDiscovery.start = async () => {
+    mdnsStarts++;
+  };
+  internals.mdnsDiscovery.stop = async () => {
+    mdnsStops++;
+  };
+  internals.ssdpDiscovery.start = async () => {
+    ssdpStarts++;
+    throw new Error('SSDP startup failed');
+  };
+  internals.ssdpDiscovery.stop = async () => {
+    ssdpStops++;
+  };
+
+  const error = await captureError(manager.startDiscovery());
+  expect(error?.message).toEqual('SSDP startup failed');
+  expect({ mdnsStarts, mdnsStops, ssdpStarts, ssdpStops }).toEqual({
+    mdnsStarts: 1,
+    mdnsStops: 1,
+    ssdpStarts: 1,
+    ssdpStops: 1,
+  });
+});
+
+tap.test('DeviceManager reports incomplete rollback without retaining transport handles', async () => {
+  const manager = new devicemanager.DeviceManager({ autoDiscovery: false });
+  const internals = manager as unknown as {
+    mdnsDiscovery: {
+      start: () => Promise<void>;
+      stop: () => Promise<void>;
+    };
+    ssdpDiscovery: {
+      start: () => Promise<void>;
+      stop: () => Promise<void>;
+    };
+  };
+  const startupError = new Error('SSDP startup failed after allocation');
+  const cleanupError = new Error('mDNS cleanup failed');
+  let mdnsHandleActive = false;
+  let ssdpHandleActive = false;
+  let mdnsStops = 0;
+  let ssdpStops = 0;
+
+  internals.mdnsDiscovery.start = async () => {
+    mdnsHandleActive = true;
+  };
+  internals.mdnsDiscovery.stop = () => {
+    mdnsStops++;
+    mdnsHandleActive = false;
+    throw cleanupError;
+  };
+  internals.ssdpDiscovery.start = async () => {
+    ssdpHandleActive = true;
+    throw startupError;
+  };
+  internals.ssdpDiscovery.stop = async () => {
+    ssdpStops++;
+    ssdpHandleActive = false;
+  };
+
+  const error = await captureError(manager.startDiscovery());
+  expect(error).toBeInstanceOf(AggregateError);
+  const aggregateError = error as AggregateError;
+  expect(aggregateError.message).toContain('rollback cleanup was incomplete');
+  expect(aggregateError.cause === startupError).toEqual(true);
+  expect(aggregateError.errors[0] === startupError).toEqual(true);
+  expect(aggregateError.errors[1] === cleanupError).toEqual(true);
+  expect({ mdnsStops, ssdpStops }).toEqual({ mdnsStops: 1, ssdpStops: 1 });
+  expect({ mdnsHandleActive, ssdpHandleActive }).toEqual({
+    mdnsHandleActive: false,
+    ssdpHandleActive: false,
+  });
+});
+
+tap.test('DeviceManager awaits both stop paths when one rejects', async () => {
+  const manager = new devicemanager.DeviceManager({ autoDiscovery: false });
+  const activeResources = new Set(['mdns', 'ssdp']);
+  const mdnsError = new Error('mDNS stop failed');
+  let ssdpStopStarted = false;
+  let releaseSsdpStop!: () => void;
+  const internals = manager as unknown as {
+    mdnsDiscovery: {
+      readonly running: boolean;
+      stop: () => Promise<void>;
+    };
+    ssdpDiscovery: {
+      readonly isRunning: boolean;
+      stop: () => Promise<void>;
+    };
+  };
+
+  internals.mdnsDiscovery = {
+    get running(): boolean {
+      return activeResources.has('mdns');
+    },
+    stop: async () => {
+      activeResources.delete('mdns');
+      throw mdnsError;
+    },
+  };
+  internals.ssdpDiscovery = {
+    get isRunning(): boolean {
+      return activeResources.has('ssdp');
+    },
+    stop: async () => {
+      ssdpStopStarted = true;
+      await new Promise<void>((resolve) => {
+        releaseSsdpStop = resolve;
+      });
+      activeResources.delete('ssdp');
+    },
+  };
+
+  let stopSettled = false;
+  const errorPromise = captureError(manager.stopDiscovery());
+  void errorPromise.then(() => {
+    stopSettled = true;
+  });
+  await flushAsyncWork();
+
+  expect(ssdpStopStarted).toEqual(true);
+  expect(stopSettled).toEqual(false);
+  expect(manager.isDiscovering).toEqual(true);
+  expect(Array.from(activeResources)).toEqual(['ssdp']);
+
+  releaseSsdpStop();
+  const error = await errorPromise;
+  expect(error).toBeInstanceOf(AggregateError);
+  expect((error as AggregateError).errors).toEqual([mdnsError]);
+  expect((error as AggregateError).cause === mdnsError).toEqual(true);
+  expect(stopSettled).toEqual(true);
+  expect(manager.isDiscovering).toEqual(false);
+  expect(Array.from(activeResources)).toEqual([]);
+});
+
+tap.test('DeviceManager aggregates both stop failures after releasing all resources', async () => {
+  const manager = new devicemanager.DeviceManager({ autoDiscovery: false });
+  const activeResources = new Set(['mdns', 'ssdp']);
+  const mdnsError = new Error('mDNS stop failed');
+  const ssdpError = new Error('SSDP stop failed');
+  const stopCalls: string[] = [];
+  const internals = manager as unknown as {
+    mdnsDiscovery: {
+      readonly running: boolean;
+      stop: () => Promise<void>;
+    };
+    ssdpDiscovery: {
+      readonly isRunning: boolean;
+      stop: () => Promise<void>;
+    };
+  };
+
+  internals.mdnsDiscovery = {
+    get running(): boolean {
+      return activeResources.has('mdns');
+    },
+    stop: async () => {
+      stopCalls.push('mdns');
+      activeResources.delete('mdns');
+      throw mdnsError;
+    },
+  };
+  internals.ssdpDiscovery = {
+    get isRunning(): boolean {
+      return activeResources.has('ssdp');
+    },
+    stop: async () => {
+      stopCalls.push('ssdp');
+      activeResources.delete('ssdp');
+      throw ssdpError;
+    },
+  };
+
+  const error = await captureError(manager.stopDiscovery());
+  expect(error).toBeInstanceOf(AggregateError);
+  expect((error as AggregateError).errors).toEqual([mdnsError, ssdpError]);
+  expect(stopCalls).toEqual(['mdns', 'ssdp']);
+  expect(manager.isDiscovering).toEqual(false);
+  expect(Array.from(activeResources)).toEqual([]);
+});
+
+tap.test('SSDP cancels non-success description and SOAP response bodies', async () => {
+  let cancelledBodies = 0;
+  const harness = createHarness({
+    fetch: async () => new Response(new ReadableStream({
+      cancel: () => {
+        cancelledBodies++;
+      },
+    }), { status: 500 }),
+  });
+  let found = 0;
+  harness.discovery.on('device:found', () => found++);
+
+  await harness.discovery.start([devicemanager.SSDP_SERVICE_TYPES.ROOT]);
+  harness.sockets[0].emitMessage(createSsdpResponse());
+  await flushAsyncWork();
+  expect(found).toEqual(1);
+  expect(cancelledBodies).toEqual(1);
+
+  const soapError = await captureError(harness.discovery.soapRequest(
+    'http://192.168.1.50/control',
+    'urn:schemas-upnp-org:service:AVTransport:1',
+    'Play'
+  ));
+  expect(soapError?.message).toEqual('SOAP request failed: 500');
+  expect(cancelledBodies).toEqual(2);
+  expect(harness.clock.activeCount).toEqual(1);
+  await harness.discovery.stop();
+  expect(harness.clock.activeCount).toEqual(0);
+});
+
+tap.test('SSDP SOAP and Chromecast public APIs remain available without removed dependencies', async () => {
+  let resolveSoapBody!: (body: string) => void;
+  const harness = createHarness({
+    fetch: async () => ({
+      ok: true,
+      status: 200,
+      text: async () => new Promise<string>((resolve) => {
+        resolveSoapBody = resolve;
+      }),
+    }) as Response,
+  });
+  const resultPromise = harness.discovery.soapRequest(
+    'http://192.168.1.50/control',
+    'urn:schemas-upnp-org:service:AVTransport:1',
+    'Play',
+    { InstanceID: 0, Speed: 1 }
+  );
+  await flushAsyncWork();
+  expect(harness.clock.activeCount).toEqual(1);
+  resolveSoapBody('<result>ok</result>');
+  const result = await resultPromise;
+  expect(result).toEqual('<result>ok</result>');
+  expect(harness.fetchCalls[0].init?.method).toEqual('POST');
+  expect(String(harness.fetchCalls[0].init?.body)).toInclude('<InstanceID>0</InstanceID>');
+  expect(harness.clock.activeCount).toEqual(0);
+
+  const chromecastProtocol: devicemanager.TPlaybackProtocol = 'chromecast';
+  const chromecast = devicemanager.createSpeaker({
+    id: 'speaker:chromecast',
+    name: 'Chromecast',
+    address: '192.168.1.60',
+    port: 8009,
+    protocol: chromecastProtocol,
+  });
+  expect(devicemanager.SERVICE_TYPES.GOOGLECAST).toEqual('_googlecast._tcp');
+  expect(chromecast.selectFeature<devicemanager.PlaybackFeature>('playback').protocol).toEqual('chromecast');
+  expect(chromecast.hasFeature('volume')).toEqual(true);
+  expect(typeof devicemanager.DeviceManager.prototype.addSpeaker).toEqual('function');
+  expect(typeof devicemanager.NetworkScanner.prototype.scan).toEqual('function');
+});
+
+tap.test('Sonos SSDP and network responses classify as Sonos speakers', async () => {
+  const harness = createHarness({
+    fetch: async () => new Response(SONOS_DEVICE_DESCRIPTION, { status: 200 }),
+  });
+  const foundDevices: ISsdpDevice[] = [];
+  harness.discovery.on('device:found', (device: ISsdpDevice) => foundDevices.push(device));
+
+  await harness.discovery.start([devicemanager.SSDP_SERVICE_TYPES.SONOS_ZONE_PLAYER]);
+  harness.sockets[0].emitMessage(createSsdpResponse(
+    'uuid:RINCON_00000000000101400::urn:schemas-upnp-org:device:ZonePlayer:1',
+    'http://192.168.1.70:1400/xml/device_description.xml',
+    devicemanager.SSDP_SERVICE_TYPES.SONOS_ZONE_PLAYER
+  ));
+  await flushAsyncWork();
+
+  expect(foundDevices.length).toEqual(1);
+  expect(foundDevices[0].serviceType).toEqual(devicemanager.SSDP_SERVICE_TYPES.SONOS_ZONE_PLAYER);
+  expect(foundDevices[0].description?.friendlyName).toEqual('Kitchen');
+
+  const manager = new devicemanager.DeviceManager({ autoDiscovery: false });
+  const managerInternals = manager as unknown as {
+    handleSsdpDeviceFound: (device: ISsdpDevice) => void;
+  };
+  managerInternals.handleSsdpDeviceFound(foundDevices[0]);
+
+  const discoveredSpeaker = manager.selectDevice({ address: '192.168.1.70' });
+  expect(discoveredSpeaker.name).toEqual('Kitchen');
+  expect(
+    discoveredSpeaker.selectFeature<devicemanager.PlaybackFeature>('playback').protocol
+  ).toEqual('sonos');
+  expect(
+    discoveredSpeaker.selectFeature<devicemanager.VolumeFeature>('volume').protocol
+  ).toEqual('sonos');
+
+  const server = createServer((request, response) => {
+    if (request.url !== '/xml/device_description.xml') {
+      response.writeHead(404).end();
+      return;
+    }
+    response.writeHead(200, { 'content-type': 'application/xml' });
+    response.end(SONOS_DEVICE_DESCRIPTION);
+  });
+  await new Promise<void>((resolve, reject) => {
+    const onError = (error: Error): void => reject(error);
+    server.once('error', onError);
+    server.listen(0, '127.0.0.1', () => {
+      server.off('error', onError);
+      resolve();
+    });
+  });
+
+  try {
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+      throw new Error('Expected the Sonos test server to use a TCP address.');
+    }
+    const scanner = new devicemanager.NetworkScanner() as unknown as {
+      probeSonos: (
+        ip: string,
+        port: number,
+        timeout: number
+      ) => Promise<{ type: string; protocol: string; port: number; name: string; model?: string } | null>;
+    };
+    const networkDevice = await scanner.probeSonos('127.0.0.1', address.port, 1000);
+
+    expect(networkDevice).toEqual({
+      type: 'speaker',
+      protocol: 'sonos',
+      port: address.port,
+      name: 'Kitchen',
+      model: 'Sonos One',
+    });
+  } finally {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => error ? reject(error) : resolve());
+    });
+    await harness.discovery.stop();
+  }
+});
+
+export default tap.start();