@corewire/airplay 0.0.0 → 1.0.0-beta.1

package/dist/raop.mjs

@@ -0,0 +1,1248 @@
+import { i as AudioSourceSession, n as generateDacpId, r as generateSessionId, t as generateActiveRemoteId } from "./identifiers-CsXXbYkW.mjs";
+import { a as AUDIO_BYTES_PER_CHANNEL, o as AUDIO_CHANNELS, s as AUDIO_SAMPLE_RATE, t as RtspClient } from "./rtsp-BWFaYW5H.mjs";
+import { createHash } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { ConnectionClosedError, PlaybackError, waitFor } from "@corewire/core";
+import { DAAP, NTP, Plist } from "@corewire/core/encoding";
+import { Context } from "@corewire/core/transport";
+import { createSocket } from "node:dgram";
+import { Discovery } from "@corewire/core/discovery";
+
+//#region src/raop/types.ts
+/** Encryption types a RAOP receiver supports, from the `et` TXT field. */
+let EncryptionType = /* @__PURE__ */ function(EncryptionType) {
+	/** The TXT record has no encryption field. */
+	EncryptionType[EncryptionType["Unknown"] = 0] = "Unknown";
+	EncryptionType[EncryptionType["Unencrypted"] = 1] = "Unencrypted";
+	/** The receiver supports MFi-SAP encryption, as the AirPort Express does. */
+	EncryptionType[EncryptionType["MFiSAP"] = 2] = "MFiSAP";
+	return EncryptionType;
+}({});
+/** Metadata types a RAOP receiver supports, from the `md` TXT field. */
+let MetadataType = /* @__PURE__ */ function(MetadataType) {
+	MetadataType[MetadataType["NotSupported"] = 0] = "NotSupported";
+	/** The receiver shows title, artist and album. */
+	MetadataType[MetadataType["Text"] = 1] = "Text";
+	MetadataType[MetadataType["Artwork"] = 2] = "Artwork";
+	/** The receiver shows progress and duration. */
+	MetadataType[MetadataType["Progress"] = 4] = "Progress";
+	return MetadataType;
+}({});
+
+//#endregion
+//#region src/raop/const.ts
+/** Number of sent packets kept for retransmission. */
+const PACKET_BACKLOG_SIZE = 1e3;
+/** Metadata for a stream without metadata from the caller. */
+const MISSING_METADATA = {
+	title: "Streaming with CoreWire",
+	artist: "CoreWire",
+	album: "AirPlay",
+	duration: 0
+};
+/** Metadata of a stream before any metadata is set. */
+const EMPTY_METADATA = {
+	title: "",
+	artist: "",
+	album: "",
+	duration: 0
+};
+/** Encryption types this client supports: unencrypted and MFi-SAP (AirPort Express). */
+const SUPPORTED_ENCRYPTIONS = 1 | 2;
+
+//#endregion
+//#region src/raop/rtspClient.ts
+const USER_AGENT = "AirPlay/550.10";
+/** Flag byte for unencrypted auth-setup mode. */
+const AUTH_SETUP_UNENCRYPTED = Buffer.from([1]);
+/** Static Curve25519 public key for the MFi-SAP `/auth-setup` of an AirPort Express. */
+const CURVE25519_PUB_KEY = Buffer.from([
+	89,
+	2,
+	237,
+	233,
+	13,
+	78,
+	242,
+	189,
+	76,
+	182,
+	138,
+	99,
+	48,
+	3,
+	130,
+	7,
+	169,
+	77,
+	189,
+	80,
+	216,
+	170,
+	70,
+	91,
+	93,
+	140,
+	1,
+	42,
+	12,
+	126,
+	29,
+	78
+]);
+/**
+* Computes an MD5 HTTP Digest authorization header value.
+*
+* @param method - RTSP method; empty for the default headers.
+*/
+function getDigestPayload(method, uri, info) {
+	const ha1 = createHash("md5").update(`${info.username}:${info.realm}:${info.password}`).digest("hex");
+	const ha2 = createHash("md5").update(`${method}:${uri}`).digest("hex");
+	const response = createHash("md5").update(`${ha1}:${info.nonce}:${ha2}`).digest("hex");
+	return `Digest username="${info.username}", realm="${info.realm}", nonce="${info.nonce}", uri="${uri}", response="${response}"`;
+}
+/** Builds the SDP body of the RTSP ANNOUNCE request, with CRLF line endings. */
+function buildAnnouncePayload(options) {
+	return [
+		"v=0",
+		`o=iTunes ${options.sessionId} 0 IN IP4 ${options.localIp}`,
+		"s=iTunes",
+		`c=IN IP4 ${options.remoteIp}`,
+		"t=0 0",
+		"m=audio 0 RTP/AVP 96",
+		`a=rtpmap:96 L16/${options.sampleRate}/${options.channels}`,
+		`a=fmtp:96 ${352} 0 ${options.bitsPerChannel} 40 10 14 ${options.channels} 255 0 0 ${options.sampleRate}`
+	].join("\r\n") + "\r\n";
+}
+/**
+* RTSP client for the RAOP commands: ANNOUNCE, SETUP, RECORD, SET_PARAMETER,
+* FLUSH and TEARDOWN, plus auth-setup, digest authentication, metadata and
+* artwork.
+*/
+var RaopRtspClient = class extends RtspClient {
+	/** Active-Remote identifier for DACP remote control. */
+	get activeRemoteId() {
+		return this.#activeRemoteId;
+	}
+	/** DACP identifier for remote control discovery. */
+	get dacpId() {
+		return this.#dacpId;
+	}
+	/** RTSP session identifier for session-scoped requests. */
+	get rtspSessionId() {
+		return this.#rtspSessionId;
+	}
+	/** Numeric session identifier in the RTSP URI path. */
+	get sessionId() {
+		return this.#sessionId;
+	}
+	/** RTSP URI of this session, in the form `rtsp://<localIp>/<sessionId>`. */
+	get uri() {
+		return `rtsp://${this.connection.localIp}/${this.#sessionId}`;
+	}
+	get connection() {
+		return {
+			localIp: this.localAddress,
+			remoteIp: this.address
+		};
+	}
+	#activeRemoteId;
+	#dacpId;
+	#rtspSessionId;
+	#sessionId;
+	/** Digest credentials, set after a 401 challenge. */
+	#digestInfo;
+	constructor(context, address, port) {
+		super(context, address, port);
+		this.#activeRemoteId = generateActiveRemoteId();
+		this.#dacpId = generateDacpId();
+		this.#rtspSessionId = generateSessionId();
+		this.#sessionId = Math.floor(Math.random() * 4294967295);
+	}
+	/** Headers on every request: the DACP identifiers, User-Agent and, after a challenge, digest authorization. */
+	getDefaultHeaders() {
+		const headers = {
+			"DACP-ID": this.#dacpId,
+			"Active-Remote": this.#activeRemoteId,
+			"Client-Instance": this.#dacpId,
+			"User-Agent": USER_AGENT
+		};
+		if (this.#digestInfo) headers["Authorization"] = getDigestPayload("", this.uri, this.#digestInfo);
+		return headers;
+	}
+	/**
+	* Fetches the device info plist from `/info`.
+	*
+	* @returns The info dictionary, or an empty object on failure.
+	*/
+	async info() {
+		try {
+			const response = await this.exchange("GET", "/info", { allowError: true });
+			if (!response.ok) return {};
+			const buffer = Buffer.from(await response.arrayBuffer());
+			if (buffer.length === 0) return {};
+			try {
+				return Plist.parse(buffer.buffer);
+			} catch (err) {
+				this.context.logger.warn("[raop-rtsp]", "Failed to parse info plist", err);
+				return {};
+			}
+		} catch (err) {
+			this.context.logger.warn("[raop-rtsp]", "Failed to get device info", err);
+			return {};
+		}
+	}
+	/**
+	* Sends the Curve25519 public key to `/auth-setup`, which an AirPort
+	* Express with MFi-SAP encryption requires.
+	*/
+	async authSetup() {
+		const body = Buffer.concat([AUTH_SETUP_UNENCRYPTED, CURVE25519_PUB_KEY]);
+		await this.exchange("POST", "/auth-setup", {
+			contentType: "application/octet-stream",
+			body,
+			protocol: "HTTP/1.1"
+		});
+	}
+	/**
+	* Sends ANNOUNCE with an SDP body for the audio format. On a 401
+	* challenge with a password given, it retries with HTTP Digest
+	* authentication.
+	*
+	* @param bytesPerChannel - Bytes per sample per channel, 2 for 16-bit.
+	* @param sampleRate - Sample rate in Hz.
+	*/
+	async announce(bytesPerChannel, channels, sampleRate, password) {
+		const body = buildAnnouncePayload({
+			sessionId: this.#sessionId,
+			localIp: this.connection.localIp,
+			remoteIp: this.connection.remoteIp,
+			bitsPerChannel: 8 * bytesPerChannel,
+			channels,
+			sampleRate
+		});
+		let response = await this.exchange("ANNOUNCE", this.uri, {
+			contentType: "application/sdp",
+			body,
+			allowError: !!password
+		});
+		if (response.status === 401 && password) {
+			const wwwAuthenticate = response.headers.get("www-authenticate");
+			if (wwwAuthenticate) {
+				const parts = wwwAuthenticate.split("\"");
+				if (parts.length >= 5) {
+					this.#digestInfo = {
+						username: "apple-protocols",
+						realm: parts[1],
+						password,
+						nonce: parts[3]
+					};
+					response = await this.exchange("ANNOUNCE", this.uri, {
+						contentType: "application/sdp",
+						body
+					});
+				}
+			}
+		}
+		return response;
+	}
+	/**
+	* Sends SETUP to negotiate the transport (ports, protocol).
+	*
+	* @param headers - Extra headers, for example Transport.
+	* @returns The response, with the receiver's ports in its Transport header.
+	*/
+	async setup(headers, body) {
+		return await this.exchange("SETUP", this.uri, {
+			headers,
+			body
+		});
+	}
+	/**
+	* Sends RECORD to start playback on the receiver.
+	*
+	* @param headers - Usually Range, Session and RTP-Info.
+	*/
+	async record(headers) {
+		await this.exchange("RECORD", this.uri, { headers });
+	}
+	/**
+	* Sends FLUSH to clear the receiver's audio buffer and move playback to
+	* the RTP position in the headers.
+	*
+	* @param options - Headers with Session and RTP-Info.
+	*/
+	async flush(options) {
+		await this.exchange("FLUSH", this.uri, { headers: options.headers });
+	}
+	/**
+	* Sends a `text/parameters` SET_PARAMETER, for volume, progress and other
+	* scalar values.
+	*
+	* @param name - For example `volume` or `progress`.
+	*/
+	async setParameter(name, value) {
+		await this.exchange("SET_PARAMETER", this.uri, {
+			contentType: "text/parameters",
+			body: `${name}: ${value}`
+		});
+	}
+	/**
+	* Sends title, artist, album and duration as DAAP-tagged SET_PARAMETER.
+	*
+	* @param rtpseq - RTP sequence number for the RTP-Info header.
+	* @param rtptime - RTP timestamp for the RTP-Info header.
+	*/
+	async setMetadata(session, rtpseq, rtptime, metadata) {
+		const daapData = DAAP.encodeTrackMetadata({
+			title: metadata.title,
+			artist: metadata.artist,
+			album: metadata.album,
+			duration: metadata.duration
+		});
+		await this.exchange("SET_PARAMETER", this.uri, {
+			contentType: "application/x-dmap-tagged",
+			headers: {
+				"Session": session,
+				"RTP-Info": `seq=${rtpseq};rtptime=${rtptime}`
+			},
+			body: daapData
+		});
+	}
+	/**
+	* Sends album artwork as SET_PARAMETER. The magic bytes tell PNG apart;
+	* anything else goes as JPEG.
+	*
+	* @param rtpseq - RTP sequence number for the RTP-Info header.
+	* @param rtptime - RTP timestamp for the RTP-Info header.
+	*/
+	async setArtwork(session, rtpseq, rtptime, artwork) {
+		let contentType = "image/jpeg";
+		if (artwork[0] === 137 && artwork[1] === 80) contentType = "image/png";
+		await this.exchange("SET_PARAMETER", this.uri, {
+			contentType,
+			headers: {
+				"Session": session,
+				"RTP-Info": `seq=${rtpseq};rtptime=${rtptime}`
+			},
+			body: artwork
+		});
+	}
+	/**
+	* Posts to `/feedback`, which keeps the session alive during streaming.
+	*
+	* @param allowError - Resolves on an HTTP error status instead of throwing.
+	*/
+	async feedback(allowError = false) {
+		return await this.exchange("POST", "/feedback", { allowError });
+	}
+	/** Sends TEARDOWN to end the streaming session. */
+	async teardown(session) {
+		await this.exchange("TEARDOWN", this.uri, { headers: { "Session": session } });
+	}
+};
+
+//#endregion
+//#region src/raop/packets.ts
+/**
+* Fixed-size FIFO of recently sent RTP audio packets, for the receiver's
+* retransmit requests.
+*/
+var PacketFifo = class {
+	#maxSize;
+	#packets = /* @__PURE__ */ new Map();
+	/** Sequence numbers in insertion order, for eviction. */
+	#order = [];
+	constructor(maxSize) {
+		this.#maxSize = maxSize;
+	}
+	get(seqno) {
+		return this.#packets.get(seqno);
+	}
+	/**
+	* Stores a packet unless its sequence number is already present, and
+	* evicts the oldest packets past the maximum size.
+	*
+	* @param packet - Full RTP packet including the header.
+	*/
+	set(seqno, packet) {
+		if (this.#packets.has(seqno)) return;
+		this.#packets.set(seqno, packet);
+		this.#order.push(seqno);
+		while (this.#order.length > this.#maxSize) {
+			const oldest = this.#order.shift();
+			if (oldest !== void 0) this.#packets.delete(oldest);
+		}
+	}
+	has(seqno) {
+		return this.#packets.has(seqno);
+	}
+	clear() {
+		this.#packets.clear();
+		this.#order.length = 0;
+	}
+};
+/** Encoder for the 12-byte RTP fixed header of RAOP audio packets. */
+const AudioPacketHeader = { 
+/**
+* @param header - First byte with version, padding and extension flags, usually 0x80.
+* @param payloadType - RTP payload type: 0xE0 for the first packet, 0x60 after that.
+* @param timestamp - 32-bit RTP timestamp in audio frames.
+* @param ssrc - Synchronization source identifier, the session ID.
+*/
+encode(header, payloadType, seqno, timestamp, ssrc) {
+	const packet = Buffer.allocUnsafe(12);
+	packet.writeUInt8(header, 0);
+	packet.writeUInt8(payloadType, 1);
+	packet.writeUInt16BE(seqno, 2);
+	packet.writeUInt32BE(timestamp, 4);
+	packet.writeUInt32BE(ssrc, 8);
+	return packet;
+} };
+/**
+* Encoder for the 20-byte RAOP sync packet. The control channel sends it
+* periodically to sync the receiver's playback clock with our RTP timestamps.
+*/
+const SyncPacket = { 
+/**
+* @param header - First byte: 0x90 for the first sync, 0x80 after that.
+* @param payloadType - Payload type, 0xD4 for sync.
+* @param seqno - Sequence number, usually 0x0007.
+* @param rtpTimestamp - RTP timestamp of the next packet to play, minus the latency.
+* @param ntpSec - NTP seconds of the current wall-clock time.
+* @param ntpFrac - NTP fraction of the current wall-clock time.
+* @param rtpTimestampNow - RTP timestamp of the current head position.
+*/
+encode(header, payloadType, seqno, rtpTimestamp, ntpSec, ntpFrac, rtpTimestampNow) {
+	const packet = Buffer.allocUnsafe(20);
+	packet.writeUInt8(header, 0);
+	packet.writeUInt8(payloadType, 1);
+	packet.writeUInt16BE(seqno, 2);
+	packet.writeUInt32BE(rtpTimestamp, 4);
+	packet.writeUInt32BE(ntpSec, 8);
+	packet.writeUInt32BE(ntpFrac, 12);
+	packet.writeUInt32BE(rtpTimestampNow, 16);
+	return packet;
+} };
+/**
+* Decodes a retransmit request from the control channel.
+*
+* @throws Error when the packet is not an RTP retransmit request.
+*/
+function decodeRetransmitRequest(data) {
+	if (data.length < 8 || data[0] >> 6 !== 2 || (data[1] & 127) !== 85) throw new Error("Invalid RTP retransmit request");
+	return {
+		lostSeqno: data.readUInt16BE(4),
+		lostPackets: data.readUInt16BE(6)
+	};
+}
+
+//#endregion
+//#region src/raop/controlClient.ts
+/**
+* Converts an RTP timestamp to a 64-bit wall-clock NTP timestamp against the
+* anchor taken at stream start, across the 32-bit wrap.
+*/
+function ntpFromTs(rtpTimestamp, sampleRate, anchorRtp, anchorNtp) {
+	let elapsedSamples;
+	if (rtpTimestamp >= anchorRtp) elapsedSamples = rtpTimestamp - anchorRtp;
+	else elapsedSamples = 4294967296 - anchorRtp + rtpTimestamp;
+	const elapsedSeconds = Math.floor(elapsedSamples / sampleRate);
+	const elapsedFraction = elapsedSamples % sampleRate * 4294967295 / sampleRate;
+	return anchorNtp + (BigInt(elapsedSeconds) << 32n | BigInt(Math.floor(elapsedFraction)));
+}
+/**
+* UDP control channel of a RAOP stream. It sends periodic sync packets so the
+* receiver aligns its playback clock with our RTP timestamps, and answers
+* retransmit requests from the packet backlog.
+*/
+var ControlClient = class extends EventEmitter {
+	#appContext;
+	#transport;
+	#context;
+	#packetBacklog;
+	#syncTask;
+	#localPort;
+	/** RTP timestamp of the NTP anchor. */
+	#anchorRtp = 0;
+	/** NTP wall-clock timestamp of the anchor. */
+	#anchorNtp = 0n;
+	#remoteAddress;
+	constructor(appContext, context, packetBacklog) {
+		super();
+		this.#appContext = appContext;
+		this.#context = context;
+		this.#packetBacklog = packetBacklog;
+	}
+	/** Local UDP port of the control channel, or 0 before binding. */
+	get port() {
+		return this.#localPort ?? 0;
+	}
+	/**
+	* Binds the UDP socket and resolves once it listens. Rejects on a bind error.
+	*
+	* @param port - Local port to bind; 0 picks a free one.
+	*/
+	async bind(localIp, port) {
+		return new Promise((resolve, reject) => {
+			this.#transport = createSocket("udp4");
+			this.#transport.on("error", (err) => {
+				this.#appContext.logger.error("[raop-control]", "Control connection error:", err);
+				reject(err);
+			});
+			this.#transport.on("message", (data, rinfo) => {
+				this.#onMessage(data, rinfo);
+			});
+			this.#transport.on("listening", () => {
+				const address = this.#transport.address();
+				this.#localPort = address.port;
+				resolve();
+			});
+			this.#transport.bind(port, localIp);
+		});
+	}
+	/** Stops the sync task and closes the UDP socket. */
+	close() {
+		this.stop();
+		if (this.#transport) {
+			this.#transport.close();
+			this.#transport = void 0;
+		}
+	}
+	/**
+	* Sends a sync packet to the receiver now and then every second.
+	*
+	* @param remoteAddr - IP address of the RAOP receiver.
+	* @throws When the sync task is already running.
+	*/
+	start(remoteAddr) {
+		this.#remoteAddress = remoteAddr;
+		if (this.#syncTask) throw new Error("Already running");
+		this.#anchorRtp = this.#context.headTs;
+		this.#anchorNtp = NTP.now();
+		this.#startSyncTask(remoteAddr, this.#context.controlPort);
+	}
+	/** Stops the sync task and keeps the UDP socket open. */
+	stop() {
+		if (this.#syncTask) {
+			clearInterval(this.#syncTask);
+			this.#syncTask = void 0;
+		}
+	}
+	/**
+	* Starts the sync loop. The first packet has header byte 0x90 (marker bit
+	* set), the rest 0x80.
+	*
+	* @param port - Remote control port.
+	*/
+	#startSyncTask(addr, port) {
+		let firstPacket = true;
+		const sendSync = () => {
+			if (!this.#transport) return;
+			const currentTime = ntpFromTs(this.#context.headTs, this.#context.sampleRate, this.#anchorRtp, this.#anchorNtp);
+			const [currentSec, currentFrac] = NTP.parts(currentTime);
+			const packet = SyncPacket.encode(firstPacket ? 144 : 128, 212, 7, this.#context.headTs - this.#context.latency, currentSec, currentFrac, this.#context.headTs);
+			firstPacket = false;
+			this.#transport.send(packet, port, addr);
+		};
+		sendSync();
+		this.#syncTask = setInterval(sendSync, 1e3);
+	}
+	/** Answers retransmit requests (type 0x55) and logs the other message types. */
+	#onMessage(data, rinfo) {
+		if (data.length < 8 || data[0] >> 6 !== 2 || rinfo.address !== this.#remoteAddress || rinfo.port !== this.#context.controlPort) return;
+		if ((data[1] & 127) === 85) this.#retransmitLostPackets(decodeRetransmitRequest(data), rinfo);
+		else this.#appContext.logger.debug("[raop-control]", "Received unhandled control data from", rinfo, data);
+	}
+	/**
+	* Resends each requested packet in a retransmit response (type 0xD6). A
+	* packet that left the backlog gets an empty response, so the receiver
+	* stops waiting for it.
+	*/
+	#retransmitLostPackets(request, addr) {
+		for (let i = 0; i < Math.min(request.lostPackets, 512); i++) {
+			const seqno = request.lostSeqno + i & 65535;
+			if (this.#packetBacklog.has(seqno)) {
+				const packet = this.#packetBacklog.get(seqno);
+				if (packet.byteLength < 4) continue;
+				const originalSeqno = packet.subarray(2, 4);
+				const resp = Buffer.concat([
+					Buffer.from([128, 214]),
+					originalSeqno,
+					packet
+				]);
+				if (this.#transport) this.#transport.send(resp, addr.port, addr.address);
+			} else {
+				const seqBuf = Buffer.alloc(2);
+				seqBuf.writeUInt16BE(seqno);
+				const resp = Buffer.concat([
+					Buffer.from([128, 214]),
+					seqBuf,
+					Buffer.alloc(4)
+				]);
+				if (this.#transport) this.#transport.send(resp, addr.port, addr.address);
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/raop/statistics.ts
+/**
+* Compares the frames sent against the frames due by the monotonic clock,
+* to detect when sending falls behind real time.
+*/
+var Statistics = class {
+	/** Sample rate in Hz. */
+	sampleRate;
+	/** Monotonic start time in nanoseconds. */
+	startTimeNs;
+	/** Start of the current reporting interval, in milliseconds. */
+	intervalTime;
+	/** Frames sent since streaming began. */
+	totalFrames = 0;
+	/** Frames sent in the current reporting interval. */
+	intervalFrames = 0;
+	/** @param sampleRate - Sample rate in Hz. */
+	constructor(sampleRate) {
+		this.sampleRate = sampleRate;
+		this.startTimeNs = process.hrtime.bigint();
+		this.intervalTime = performance.now();
+	}
+	/** Number of frames due by now since streaming started. */
+	get expectedFrameCount() {
+		const elapsedNs = Number(process.hrtime.bigint() - this.startTimeNs);
+		return Math.floor(elapsedNs / (1e9 / this.sampleRate));
+	}
+	/** Number of frames the sender lags behind real time; positive means send faster. */
+	get framesBehind() {
+		return this.expectedFrameCount - this.totalFrames;
+	}
+	/** True once the interval holds a second of frames, time to log and reset. */
+	get intervalCompleted() {
+		return this.intervalFrames >= this.sampleRate;
+	}
+	tick(sentFrames) {
+		this.totalFrames += sentFrames;
+		this.intervalFrames += sentFrames;
+	}
+	/**
+	* Ends the current reporting interval and resets its frame counter.
+	*
+	* @returns Elapsed seconds and frames sent in the interval that ended.
+	*/
+	newInterval() {
+		const endTime = performance.now();
+		const diff = (endTime - this.intervalTime) / 1e3;
+		this.intervalTime = endTime;
+		const frames = this.intervalFrames;
+		this.intervalFrames = 0;
+		return [diff, frames];
+	}
+};
+
+//#endregion
+//#region src/raop/utils.ts
+/**
+* Converts a volume percentage to dBFS for the RAOP `volume` SET_PARAMETER.
+*
+* @param volume - Volume percentage, from 0 (silent) to 100 (full).
+* @returns Volume in dBFS, from -144 (mute) to 0 (full).
+*/
+function pctToDbfs(volume) {
+	if (volume <= 0) return -144;
+	if (volume >= 100) return 0;
+	return 20 * Math.log10(volume / 100);
+}
+/**
+* Reads the encryption types from the `et` field of the mDNS TXT record.
+*/
+function getEncryptionTypes(properties) {
+	const field = properties.get("et");
+	if (!field) return 0;
+	let types = 0;
+	for (const entry of field.split(",")) {
+		const type = parseInt(entry.trim(), 10);
+		if (type === 0) types |= 1;
+		if (type === 1) types |= 2;
+	}
+	return types;
+}
+/**
+* Reads the metadata types from the `md` field of the mDNS TXT record.
+*/
+function getMetadataTypes(properties) {
+	const field = properties.get("md");
+	if (!field) return 0;
+	let types = 0;
+	for (const entry of field.split(",")) {
+		const type = parseInt(entry.trim(), 10);
+		if (type === 0) types |= 1;
+		if (type === 1) types |= 2;
+		if (type === 2) types |= 4;
+	}
+	return types;
+}
+/**
+* Reads the audio format from the mDNS TXT record, with CD quality
+* (44100 Hz, 2 channels, 16-bit) for missing fields.
+*
+* @returns `[sampleRate, channels, bytesPerChannel]`.
+*/
+function getAudioProperties(properties) {
+	return [
+		parseInt(properties.get("sr") ?? "44100", 10),
+		parseInt(properties.get("ch") ?? "2", 10),
+		parseInt(properties.get("ss") ?? "16", 10) / 8
+	];
+}
+
+//#endregion
+//#region src/raop/streamClient.ts
+/**
+* Streams RAOP audio: negotiates encryption and metadata, sets up the control
+* channel, sends PCM packets in real time, publishes metadata and artwork and
+* tears down. When sending falls behind, it bursts extra packets to catch up.
+*/
+var StreamClient = class extends EventEmitter {
+	/** The `/info` dictionary fetched during initialization. */
+	get info() {
+		return this.#info;
+	}
+	/** The playback info, with the fallback metadata when the caller gave none. */
+	get playbackInfo() {
+		return {
+			metadata: this.#isMetadataEmpty(this.#metadata) ? this.#missingMetadata : this.#metadata,
+			position: this.#streamContext.position
+		};
+	}
+	/** Only an AirPort with MFi-SAP encryption needs auth-setup. */
+	get #requiresAuthSetup() {
+		const modelName = this.#properties.get("am") ?? "";
+		return (this.#encryptionTypes & 2) !== 0 && modelName.startsWith("AirPort");
+	}
+	#context;
+	#rtsp;
+	#streamContext;
+	#settings;
+	#protocol;
+	#packetBacklog;
+	#timingServer;
+	/** Shown on the receiver when a stream comes without metadata. */
+	#missingMetadata;
+	#controlClient;
+	#encryptionTypes = 0;
+	#metadataTypes = 0;
+	#metadata = EMPTY_METADATA;
+	#info = {};
+	/** The receiver's mDNS TXT record. */
+	#properties = /* @__PURE__ */ new Map();
+	/** The streaming loop runs while this is true. */
+	#isPlaying = false;
+	/**
+	* @param missingMetadata - Shown on the receiver when a stream comes without metadata.
+	*/
+	constructor(context, rtsp, streamContext, protocol, settings, timingServer, missingMetadata) {
+		super();
+		this.#context = context;
+		this.#rtsp = rtsp;
+		this.#streamContext = streamContext;
+		this.#protocol = protocol;
+		this.#settings = settings;
+		this.#packetBacklog = new PacketFifo(PACKET_BACKLOG_SIZE);
+		this.#timingServer = timingServer;
+		this.#missingMetadata = missingMetadata;
+	}
+	/** Closes the control channel and its UDP socket. */
+	close() {
+		this.#controlClient?.close();
+		this.#controlClient = void 0;
+	}
+	/**
+	* Reads the receiver's capabilities, binds the control channel, fetches
+	* `/info`, sends auth-setup when needed and runs the protocol SETUP.
+	*
+	* @param properties - The receiver's mDNS TXT record.
+	*/
+	async initialize(properties) {
+		this.#properties = properties;
+		this.#encryptionTypes = getEncryptionTypes(properties);
+		this.#metadataTypes = getMetadataTypes(properties);
+		this.#context.logger.info(`Initializing RTSP with encryption=${this.#encryptionTypes}, metadata=${this.#metadataTypes}`);
+		const intersection = this.#encryptionTypes & SUPPORTED_ENCRYPTIONS;
+		if (!intersection || intersection === 0) this.#context.logger.debug("No supported encryption type, continuing anyway");
+		this.#updateOutputProperties(properties);
+		this.#controlClient = new ControlClient(this.#context, this.#streamContext, this.#packetBacklog);
+		await this.#controlClient.bind(this.#rtsp.connection.localIp, this.#settings.protocols.raop.controlPort);
+		this.#context.logger.debug(`Local ports: control=${this.#controlClient.port}, timing=${this.#timingServer.port}`);
+		const info = await this.#rtsp.info();
+		Object.assign(this.#info, info);
+		this.#context.logger.debug("Updated info parameters to:", this.#info);
+		if (this.#requiresAuthSetup) await this.#rtsp.authSetup();
+		await this.#protocol.setup(this.#timingServer.port, this.#controlClient.port);
+	}
+	/**
+	* Stops the streaming loop after the current packet. {@link sendAudio}
+	* returns once the teardown is done.
+	*/
+	stop() {
+		this.#context.logger.debug("Stopping audio playback");
+		this.#isPlaying = false;
+	}
+	/**
+	* Sets the receiver volume with SET_PARAMETER.
+	*
+	* @param volume - Volume in dBFS.
+	*/
+	async setVolume(volume) {
+		await this.#rtsp.setParameter("volume", String(volume));
+		this.#streamContext.volume = volume;
+	}
+	/**
+	* Streams PCM after setting up metadata, volume and RTSP RECORD.
+	* On completion or error, clears the backlog, tears down RTSP, closes UDP and emits `stopped`.
+	*
+	* @param volumeDb - Initial volume in dBFS, -144 to 0; the receiver keeps its own when omitted.
+	* @param onStreaming - Runs once the setup is done and the audio starts to flow.
+	*/
+	async sendAudio(source, metadata = EMPTY_METADATA, volumeDb, onStreaming) {
+		if (!this.#controlClient) throw new Error("Not initialized");
+		this.#streamContext.reset();
+		let transport;
+		try {
+			transport = createSocket("udp4");
+			await new Promise((resolve, reject) => {
+				transport.once("error", reject);
+				transport.connect(this.#streamContext.serverPort, this.#rtsp.connection.remoteIp, () => {
+					transport.removeListener("error", reject);
+					resolve();
+				});
+			});
+			this.#controlClient.start(this.#rtsp.connection.remoteIp);
+			if ((this.#metadataTypes & 4) !== 0) {
+				const start = this.#streamContext.rtptime;
+				const now = this.#streamContext.rtptime;
+				const end = start + source.duration * this.#streamContext.sampleRate;
+				await this.#rtsp.setParameter("progress", `${start}/${now}/${end}`);
+			}
+			this.#metadata = metadata;
+			if ((this.#metadataTypes & 1) !== 0) {
+				this.#context.logger.debug("Playing with metadata:", this.playbackInfo.metadata);
+				await this.#rtsp.setMetadata(this.#streamContext.rtspSession, this.#streamContext.rtpseq, this.#streamContext.rtptime, this.playbackInfo.metadata);
+			}
+			if ((this.#metadataTypes & 2) !== 0 && metadata.artwork) {
+				this.#context.logger.debug(`Sending ${metadata.artwork.length} bytes artwork`);
+				await this.#rtsp.setArtwork(this.#streamContext.rtspSession, this.#streamContext.rtpseq, this.#streamContext.rtptime, metadata.artwork);
+			}
+			await this.#protocol.startFeedback();
+			this.emit("playing", this.playbackInfo);
+			await this.#rtsp.record({
+				"Range": "npt=0-",
+				"Session": this.#streamContext.rtspSession,
+				"RTP-Info": `seq=${this.#streamContext.rtpseq};rtptime=${this.#streamContext.rtptime}`
+			});
+			await this.#rtsp.flush({ headers: {
+				"Range": "npt=0-",
+				"Session": this.#streamContext.rtspSession,
+				"RTP-Info": `seq=${this.#streamContext.rtpseq};rtptime=${this.#streamContext.rtptime}`
+			} });
+			if (volumeDb !== void 0) await this.setVolume(volumeDb);
+			onStreaming?.();
+			await this.#streamData(source, transport);
+		} catch (err) {
+			this.#context.logger.error("An error occurred during streaming.", err);
+			throw new Error("An error occurred during streaming.", { cause: err });
+		} finally {
+			this.#packetBacklog.clear();
+			if (transport) {
+				await this.#rtsp.teardown(this.#streamContext.rtspSession).catch((err) => this.#context.logger.warn("TEARDOWN failed.", err));
+				transport.close();
+			}
+			this.#protocol.teardown();
+			this.close();
+			this.emit("stopped");
+		}
+	}
+	/**
+	* Sends the source as RTP packets, paced against the clock. When behind,
+	* it bursts up to {@link MAX_PACKETS_COMPENSATE} extra packets.
+	*
+	* @param transport - UDP socket connected to the receiver's audio port.
+	*/
+	async #streamData(source, transport) {
+		const stats = new Statistics(this.#streamContext.sampleRate);
+		const initialTime = performance.now();
+		let prevSlowSeqno = null;
+		let numberSlowSeqno = 0;
+		this.#isPlaying = true;
+		while (this.#isPlaying) {
+			const currentSeqno = this.#streamContext.rtpseq - 1;
+			const numSent = await this.#sendPacket(source, stats.totalFrames === 0, transport);
+			if (numSent === 0) break;
+			stats.tick(numSent);
+			const framesBehind = stats.framesBehind;
+			if (framesBehind >= 352) {
+				const maxPackets = Math.min(Math.floor(framesBehind / 352), 3);
+				this.#context.logger.debug(`Compensating with ${maxPackets} packets (${framesBehind} frames behind)`);
+				const [sentFrames, hasMorePackets] = await this.#sendNumberOfPackets(source, transport, maxPackets);
+				stats.tick(sentFrames);
+				if (!hasMorePackets) break;
+			}
+			if (stats.intervalCompleted) {
+				const [intervalTime, intervalFrames] = stats.newInterval();
+				this.#context.logger.debug(`Sent ${intervalFrames} frames in ${intervalTime.toFixed(3)}s (current frames: ${stats.totalFrames}, expected: ${stats.expectedFrameCount})`);
+			}
+			const absTimeStream = stats.totalFrames / this.#streamContext.sampleRate;
+			const relToStart = (performance.now() - initialTime) / 1e3;
+			const diff = absTimeStream - relToStart;
+			if (diff > 0) {
+				numberSlowSeqno = 0;
+				await waitFor(diff * 1e3);
+			} else {
+				if (prevSlowSeqno === currentSeqno - 1) numberSlowSeqno++;
+				if (numberSlowSeqno >= 5) this.#context.logger.warn(`Too slow to keep up for seqno ${currentSeqno} (${absTimeStream.toFixed(3)} vs ${relToStart.toFixed(3)} => ${diff.toFixed(3)})`);
+				else this.#context.logger.debug(`Too slow to keep up for seqno ${currentSeqno} (${absTimeStream.toFixed(3)} vs ${relToStart.toFixed(3)} => ${diff.toFixed(3)})`);
+				prevSlowSeqno = currentSeqno;
+			}
+		}
+		const elapsedNs = Number(process.hrtime.bigint() - stats.startTimeNs);
+		this.#context.logger.debug(`Audio finished sending in ${(elapsedNs / 1e9).toFixed(3)}s`);
+	}
+	/**
+	* Reads one packet of frames and sends it as an RTP packet, zero-padded to
+	* the packet size. Once the source is exhausted, it sends silence until
+	* the latency is padded.
+	*
+	* @param firstPacket - Sends payload type 0xE0 with the marker bit.
+	* @param transport - UDP socket connected to the receiver's audio port.
+	* @returns Number of frames sent, or 0 when all padding has been sent.
+	*/
+	async #sendPacket(source, firstPacket, transport) {
+		if (this.#streamContext.paddingSent >= this.#streamContext.latency) return 0;
+		let frames = await source.readFrames(352);
+		if (!frames) {
+			frames = Buffer.alloc(this.#streamContext.packetSize);
+			this.#streamContext.paddingSent += Math.floor(frames.length / this.#streamContext.frameSize);
+		} else if (frames.length !== this.#streamContext.packetSize) {
+			const padded = Buffer.alloc(this.#streamContext.packetSize);
+			frames.copy(padded);
+			frames = padded;
+		}
+		const header = AudioPacketHeader.encode(128, firstPacket ? 224 : 96, this.#streamContext.rtpseq, this.#streamContext.headTs, this.#rtsp.sessionId);
+		const [rtpseq, packet] = await this.#protocol.sendAudioPacket(transport, header, frames);
+		this.#packetBacklog.set(rtpseq, packet);
+		this.#streamContext.rtpseq = (this.#streamContext.rtpseq + 1) % 2 ** 16;
+		this.#streamContext.headTs = this.#streamContext.headTs + Math.floor(frames.length / this.#streamContext.frameSize) >>> 0;
+		return Math.floor(frames.length / this.#streamContext.frameSize);
+	}
+	/**
+	* Sends a burst of packets to catch up, and stops early when the source
+	* is exhausted.
+	*
+	* @returns The frames sent, and whether more packets are available.
+	*/
+	async #sendNumberOfPackets(source, transport, count) {
+		let totalFrames = 0;
+		for (let i = 0; i < count; i++) {
+			const sent = await this.#sendPacket(source, false, transport);
+			totalFrames += sent;
+			if (sent === 0) return [totalFrames, false];
+		}
+		return [totalFrames, true];
+	}
+	/** True when the caller gave no metadata: all fields empty or zero. */
+	#isMetadataEmpty(metadata) {
+		return metadata.title === "" && metadata.artist === "" && metadata.album === "" && metadata.duration === 0;
+	}
+	/** Takes the audio format of the stream context from the mDNS TXT record. */
+	#updateOutputProperties(properties) {
+		const [sampleRate, channels, bytesPerChannel] = getAudioProperties(properties);
+		this.#streamContext.sampleRate = sampleRate;
+		this.#streamContext.channels = channels;
+		this.#streamContext.bytesPerChannel = bytesPerChannel;
+		this.#context.logger.debug(`Update play settings to ${sampleRate}/${channels}/${bytesPerChannel * 8}bit`);
+	}
+};
+
+//#endregion
+//#region src/raop/session.ts
+/** Where the RAOP service listens when the target does not say. */
+const DEFAULT_PORT = 7e3;
+/** Interval in milliseconds of the `/feedback` keepalive during a stream. */
+const FEEDBACK_INTERVAL = 2e3;
+/**
+* Connects to a RAOP (AirPlay 1 audio) receiver and returns a ready session: the RTSP connection,
+* the control channel, `GET /info`, `/auth-setup` for an AirPort, then ANNOUNCE and SETUP.
+*
+* @throws {ConnectionClosedError} When the signal aborts during the handshake.
+*/
+async function connect(target, options) {
+	const signal = options.signal;
+	if (signal?.aborted) throw new ConnectionClosedError("RAOP setup was interrupted.");
+	const context = options.context ?? new Context(target.id ?? target.address);
+	const rtsp = new RaopRtspClient(context, target.address, target.port ?? DEFAULT_PORT);
+	const interrupt = () => rtsp.destroy();
+	let streamClient;
+	signal?.addEventListener("abort", interrupt, { once: true });
+	try {
+		await rtsp.connect();
+		const streamContext = createStreamContext();
+		streamContext.rtspSession = rtsp.rtspSessionId;
+		const settings = { protocols: { raop: {
+			controlPort: 0,
+			timingPort: 0
+		} } };
+		const missingMetadata = {
+			...MISSING_METADATA,
+			...options.metadata
+		};
+		streamClient = new StreamClient(context, rtsp, streamContext, new RaopStreamProtocol(rtsp, streamContext, options.password), settings, options.timing, missingMetadata);
+		await streamClient.initialize(new Map(Object.entries(target.txt ?? {})));
+		if (signal?.aborted || !rtsp.isConnected) throw new ConnectionClosedError("RAOP setup was interrupted.");
+		return new RaopSession(target, context, rtsp, streamClient, streamContext, signal);
+	} catch (err) {
+		streamClient?.close();
+		rtsp.destroy();
+		throw signal?.aborted ? new ConnectionClosedError("RAOP setup was interrupted.") : err;
+	} finally {
+		signal?.removeEventListener("abort", interrupt);
+	}
+}
+/**
+* One RAOP connection to a receiver. It lives once: it ends exactly once, with a reason, and then
+* its {@link signal} aborts and a running stream stops. One stream runs at a time.
+*/
+var RaopSession = class extends EventEmitter {
+	/** Why the session ended, or undefined while it is open. */
+	get closeReason() {
+		return this.#closeReason;
+	}
+	get context() {
+		return this.#context;
+	}
+	/** The `/info` plist of the receiver; empty when it did not answer. */
+	get info() {
+		return this.#streamClient.info;
+	}
+	get isOpen() {
+		return !this.signal.aborted;
+	}
+	/** Aborts with a {@link ConnectionClosedError} when the session ends. */
+	get signal() {
+		return this.#controller.signal;
+	}
+	get target() {
+		return this.#target;
+	}
+	/** The volume last sent to the receiver, in dBFS. */
+	get volumeDb() {
+		return this.#streamContext.volume;
+	}
+	#context;
+	#controller = new AbortController();
+	#rtsp;
+	#streamClient;
+	#streamContext;
+	#target;
+	#closeReason;
+	#playback;
+	/** Use {@link connect}; a session starts from a finished handshake. */
+	constructor(target, context, rtsp, streamClient, streamContext, signal) {
+		super();
+		this.#context = context;
+		this.#rtsp = rtsp;
+		this.#streamClient = streamClient;
+		this.#streamContext = streamContext;
+		this.#target = target;
+		this.#rtsp.on("closed", (reason, error) => this.#end(reason, error));
+		this.#streamClient.on("playing", (info) => this.emit("playing", info));
+		this.#streamClient.on("stopped", () => this.emit("stopped"));
+		signal?.addEventListener("abort", () => void this.close(), {
+			once: true,
+			signal: this.signal
+		});
+	}
+	/** Stops a running stream and closes the connection, without TEARDOWN of an idle session. */
+	async close() {
+		if (this.signal.aborted) return;
+		this.#playback?.stop();
+		this.#streamClient.close();
+		await this.#rtsp.disconnect();
+		this.#end("local");
+	}
+	/** Sends a volume in dBFS, -144 (silent) to 0, with SET_PARAMETER. */
+	async setVolumeDb(volumeDb) {
+		this.#assertOpen();
+		await this.#streamClient.setVolume(volumeDb);
+	}
+	/**
+	* Streams PCM audio: metadata, RECORD, FLUSH and the volume, then the audio over RTP. Resolves
+	* once the audio flows; {@link RaopPlayback.ended} settles when the source ran out and TEARDOWN
+	* went out. The source is stopped in every case.
+	*
+	* @throws {PlaybackError} When a stream is already running.
+	*/
+	async stream(source, options = {}) {
+		this.#assertOpen();
+		if (this.#playback) throw new PlaybackError("A RAOP stream is already active.");
+		const sourceSession = new AudioSourceSession(source);
+		const streamClient = this.#streamClient;
+		let onStreaming;
+		const streaming = new Promise((resolve) => onStreaming = resolve);
+		const stop = () => {
+			streamClient.stop();
+			sourceSession.stop().catch((error) => this.#context.logger.error("[raop]", "Source cleanup failed", error));
+		};
+		const run = async () => {
+			try {
+				await sourceSession.start();
+				await streamClient.sendAudio(sourceSession, options.metadata, options.volumeDb, onStreaming);
+			} finally {
+				await sourceSession.stop();
+				if (this.#playback?.stop === stop) this.#playback = void 0;
+			}
+		};
+		const playback = {
+			ended: run(),
+			stop
+		};
+		playback.ended.catch(() => void 0);
+		this.#playback = playback;
+		await Promise.race([streaming, playback.ended]);
+		return playback;
+	}
+	#assertOpen() {
+		if (this.signal.aborted) throw new ConnectionClosedError("This RAOP session has closed.");
+	}
+	/** The single exit: aborts the signal, stops a running stream and emits `closed`. */
+	#end(reason, error) {
+		if (this.#closeReason) return;
+		this.#closeReason = reason;
+		this.#context.logger.net("[raop]", `RAOP session closed (${reason}${error ? `: ${error.message}` : ""}).`);
+		this.#playback?.stop();
+		this.#streamClient.close();
+		this.#controller.abort(new ConnectionClosedError(`RAOP session closed (${reason}).`));
+		this.#rtsp.destroy();
+		this.emit("closed", reason, error);
+	}
+};
+/**
+* The RAOP {@link StreamProtocol}: ANNOUNCE and SETUP for the transport,
+* feedback keepalives and raw UDP audio packets.
+*/
+var RaopStreamProtocol = class {
+	#password;
+	#rtsp;
+	#streamContext;
+	#feedbackInterval;
+	/** @param password - Answers a digest challenge on ANNOUNCE; without one a 401 fails the setup. */
+	constructor(rtsp, streamContext, password) {
+		this.#password = password;
+		this.#rtsp = rtsp;
+		this.#streamContext = streamContext;
+	}
+	/**
+	* Sends ANNOUNCE and SETUP and reads the receiver's server and control
+	* ports from the Transport header of the response.
+	*
+	* @param timingPort - Local NTP timing server port.
+	* @param controlPort - Local control channel port.
+	*/
+	async setup(timingPort, controlPort) {
+		await this.#rtsp.announce(this.#streamContext.bytesPerChannel, this.#streamContext.channels, this.#streamContext.sampleRate, this.#password);
+		const transport = [
+			"RTP/AVP/UDP",
+			"unicast",
+			"interleaved=0-1",
+			"mode=record",
+			`control_port=${controlPort}`,
+			`timing_port=${timingPort}`
+		].join(";");
+		const transportHeader = (await this.#rtsp.setup({ "Transport": transport })).headers.get("Transport");
+		if (!transportHeader) return;
+		const serverPortMatch = transportHeader.match(/server_port=(\d+)/);
+		if (serverPortMatch) this.#streamContext.serverPort = parseInt(serverPortMatch[1], 10);
+		const controlPortMatch = transportHeader.match(/control_port=(\d+)/);
+		if (controlPortMatch) this.#streamContext.controlPort = parseInt(controlPortMatch[1], 10);
+	}
+	/** Sends `POST /feedback` every two seconds to keep the RAOP session alive during streaming. */
+	async startFeedback() {
+		this.#feedbackInterval = setInterval(async () => {
+			try {
+				await this.#rtsp.feedback(true);
+			} catch (err) {
+				this.#rtsp.context.logger.warn("[raop]", "Feedback failed", err);
+			}
+		}, FEEDBACK_INTERVAL);
+	}
+	/**
+	* Sends the RTP header and audio payload as one UDP packet.
+	*
+	* @returns The sequence number and the full packet, for the backlog.
+	*/
+	async sendAudioPacket(transport, header, audio) {
+		const packet = Buffer.concat([header, audio]);
+		const seqno = header.readUInt16BE(2);
+		await new Promise((resolve, reject) => {
+			transport.send(packet, (err) => err ? reject(err) : resolve());
+		});
+		return [seqno, packet];
+	}
+	/** Stops the feedback keepalive. */
+	teardown() {
+		if (!this.#feedbackInterval) return;
+		clearInterval(this.#feedbackInterval);
+		this.#feedbackInterval = void 0;
+	}
+};
+/**
+* Creates a stream context with CD quality (44100 Hz, stereo, 16-bit) and a
+* random RTP sequence number and timestamp.
+*/
+function createStreamContext() {
+	const rtptime = Math.floor(Math.random() * 4294967295);
+	return {
+		sampleRate: AUDIO_SAMPLE_RATE,
+		channels: 2,
+		bytesPerChannel: 2,
+		rtpseq: Math.floor(Math.random() * 65536),
+		rtptime,
+		headTs: rtptime,
+		latency: Math.floor(AUDIO_SAMPLE_RATE * 2),
+		serverPort: 0,
+		controlPort: 0,
+		rtspSession: "",
+		volume: -20,
+		position: 0,
+		packetSize: 352 * 2 * 2,
+		frameSize: 2 * 2,
+		paddingSent: 0,
+		reset() {
+			this.rtpseq = Math.floor(Math.random() * 65536);
+			this.rtptime = Math.floor(Math.random() * 4294967295);
+			this.headTs = this.rtptime;
+			this.paddingSent = 0;
+			this.position = 0;
+		}
+	};
+}
+
+//#endregion
+//#region src/raop/discovery.ts
+const RAOP_SERVICE = "_raop._tcp.local";
+/** Finds the RAOP (AirPlay 1 audio) receivers on the local network. */
+async function discover(options = {}) {
+	return await new Discovery(RAOP_SERVICE).find(options.useCache ?? true);
+}
+/** The connect target for a discovered receiver. */
+function toTarget(result) {
+	return {
+		address: result.address,
+		port: result.service.port,
+		id: result.id,
+		txt: result.txt
+	};
+}
+
+//#endregion
+export { EncryptionType, MetadataType, RAOP_SERVICE, RaopSession, connect, discover, getAudioProperties, getEncryptionTypes, getMetadataTypes, pctToDbfs, toTarget };