@corewire/airplay 0.0.0 → 1.0.0-next.1

package/dist/index.mjs

@@ -0,0 +1,3637 @@
+import { i as AudioSourceSession, n as generateDacpId, r as generateSessionId, t as generateActiveRemoteId } from "./identifiers-CsXXbYkW.mjs";
+import { a as AUDIO_BYTES_PER_CHANNEL, c as DEFAULT_PORT, l as FEEDBACK_INTERVAL, n as buildResponse, o as AUDIO_CHANNELS, r as parseRequest, s as AUDIO_SAMPLE_RATE, t as RtspClient, u as HTTP_TIMEOUT } from "./rtsp-BWFaYW5H.mjs";
+import { Bt as resolveIdentity, Ft as ProtocolMessage_Type, Gt as randomInt32, Ht as buildReply, It as getExtension, Kt as randomInt64, Pt as ProtocolMessageSchema, Rt as toBinary, Ut as getMacAddress, Vt as buildHeader$1, Wt as parseHeaderSeqno, a as parseMessages, i as messageKind, r as encodeVarint, t as describeProtocolMessage, w as SetConnectionStateMessage_ConnectionState } from "./describe-CAEDGJLu.mjs";
+import { randomBytes, randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { ConnectionClosedError, EncryptionError, Logger, PairingError, PlaybackError, SetupError, TimeoutError, reporter, waitFor } from "@corewire/core";
+import { NTP, Plist } from "@corewire/core/encoding";
+import { Context, EncryptionAwareConnection, EncryptionState, buildNonce } from "@corewire/core/transport";
+import { createSocket } from "node:dgram";
+import { ChaCha20, HKDF } from "@corewire/core/crypto";
+import { PairSetup, PairVerify, deriveControlKeys } from "@corewire/core/pairing";
+import { Discovery } from "@corewire/core/discovery";
+
+//#region src/features.ts
+/**
+* Parses the `features` TXT value of an mDNS record: one hex value, or two comma-separated 32-bit
+* hex values (low,high) that form a 64-bit mask.
+*
+* @throws If the value has neither form.
+*/
+function parseFeatures(features) {
+	const parts = features.split(",").map((part) => part.trim());
+	if (parts.length === 1) return BigInt(parts[0]);
+	if (parts.length === 2) {
+		const low = BigInt(parts[0]);
+		return BigInt(parts[1]) << 32n | low;
+	}
+	throw new Error(`Invalid features format: ${features}`);
+}
+/** Decodes Apple's full, little-endian feature vector from /info. */
+function parseReceiverFeatures(info) {
+	if (typeof info.featuresEx === "string") {
+		const value = info.featuresEx;
+		if (!/^[A-Za-z0-9+/]*={0,2}$/.test(value) || value.length % 4 === 1) throw new TypeError("Invalid base64 featuresEx");
+		const bytes = Buffer.from(value, "base64");
+		if (bytes.toString("base64").replace(/=+$/, "") !== value.replace(/=+$/, "")) throw new TypeError("Invalid base64 featuresEx");
+		let features = 0n;
+		for (let i = bytes.length - 1; i >= 0; i--) features = features << 8n | BigInt(bytes[i]);
+		return features;
+	}
+	const legacy = parseLegacyFeatures(info.features ?? 0n);
+	return info.featuresEx == null ? legacy : legacy | parseLegacyFeatures(info.featuresEx) << 32n;
+}
+/** Encodes the legacy mask and Apple's base64 extended representation for SETUP. */
+function encodeFeatures(features) {
+	if (features < 0n) throw new RangeError("Features must be non-negative");
+	const bytes = [];
+	for (let remaining = features; remaining > 0n; remaining >>= 8n) bytes.push(Number(remaining & 255n));
+	return {
+		features: features & 18446744073709551615n,
+		featuresEx: Buffer.from(bytes).toString("base64")
+	};
+}
+function parseLegacyFeatures(value) {
+	if (typeof value === "bigint" && value >= 0n) return value;
+	if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return BigInt(value);
+	if (typeof value === "string") {
+		if (/^(?:0x[0-9a-f]+|[0-9]+)$/i.test(value)) return BigInt(value);
+		if (/^[0-9a-f]+$/i.test(value)) return BigInt(`0x${value}`);
+	}
+	throw new TypeError("Invalid or imprecise legacy features");
+}
+
+//#endregion
+//#region src/airplayFeatures.ts
+/**
+* AirPlay feature flags as bigint bits of the `features` field in the mDNS TXT
+* record. Each flag is a capability the device advertises.
+*/
+const AirPlayFeatureFlags = {
+	SupportsAirPlayVideoV1: 1n << 0n,
+	SupportsAirPlayPhoto: 1n << 1n,
+	SupportsAirPlayVideoFairPlay: 1n << 2n,
+	SupportsAirPlayVideoVolumeControl: 1n << 3n,
+	SupportsAirPlayVideoHTTPLiveStreams: 1n << 4n,
+	SupportsAirPlaySlideShow: 1n << 5n,
+	SupportsAirPlayScreen: 1n << 7n,
+	SupportsAirPlayAudio: 1n << 9n,
+	AudioRedundant: 1n << 11n,
+	Authentication4: 1n << 14n,
+	MetadataFeatures0: 1n << 15n,
+	MetadataFeatures1: 1n << 16n,
+	MetadataFeatures2: 1n << 17n,
+	AudioFormats0: 1n << 18n,
+	AudioFormats1: 1n << 19n,
+	AudioFormats2: 1n << 20n,
+	AudioFormats3: 1n << 21n,
+	Authentication1: 1n << 23n,
+	Authentication8: 1n << 26n,
+	SupportsLegacyPairing: 1n << 27n,
+	HasUnifiedAdvertiserInfo: 1n << 30n,
+	SupportsVolume: 1n << 32n,
+	SupportsAirPlayVideoPlayQueue: 1n << 33n,
+	SupportsAirPlayFromCloud: 1n << 34n,
+	SupportsTLSPSK: 1n << 35n,
+	SupportsUnifiedMediaControl: 1n << 38n,
+	SupportsBufferedAudio: 1n << 40n,
+	SupportsPTP: 1n << 41n,
+	SupportsScreenMultiCodec: 1n << 42n,
+	SupportsSystemPairing: 1n << 43n,
+	IsAPValeriaScreenSender: 1n << 44n,
+	SupportsHKPairingAndAccessControl: 1n << 46n,
+	SupportsCoreUtilsPairingAndEncryption: 1n << 48n,
+	SupportsAirPlayVideoV2: 1n << 49n,
+	MetadataFeatures3: 1n << 50n,
+	SupportsUnifiedPairSetupAndMFi: 1n << 51n,
+	SupportsSetPeersExtendedMessage: 1n << 52n,
+	SupportsAPSync: 1n << 54n,
+	SupportsWoL: 1n << 55n,
+	SupportsWoL2: 1n << 56n,
+	SupportsHangdogRemoteControl: 1n << 58n,
+	SupportsAudioStreamConnectionSetup: 1n << 59n,
+	SupportsAudioMetadataControl: 1n << 60n,
+	SupportsRFC2198Redundancy: 1n << 61n
+};
+/** Password protection bit of the `sf` (status flags) TXT field. */
+const PASSWORD_BIT = 128n;
+/** Legacy pairing bit of the `sf` TXT field; it requires a PIN. */
+const LEGACY_PAIRING_BIT = 512n;
+/** PIN required bit of the `sf` TXT field. */
+const PIN_REQUIRED_BIT = 8n;
+function hasFeatureFlag(features, flag) {
+	return (features & flag) === flag;
+}
+/** Names of the flags set in the bitmask, for debugging and diagnostics. */
+function describeFlags(features) {
+	const result = [];
+	for (const [name, flag] of Object.entries(AirPlayFeatureFlags)) if (hasFeatureFlag(features, flag)) result.push(name);
+	return result;
+}
+/**
+* Reads the AirPlay version from the mDNS TXT record. The flag
+* SupportsUnifiedMediaControl or SupportsCoreUtilsPairingAndEncryption means
+* AirPlay 2.
+*/
+function getProtocolVersion(txt) {
+	const featuresStr = txt.features ?? txt.ft;
+	if (!featuresStr) return 1;
+	const features = parseFeatures(featuresStr);
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsUnifiedMediaControl)) return 2;
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsCoreUtilsPairingAndEncryption)) return 2;
+	return 1;
+}
+/**
+* Reads the pairing requirement from the feature and status flags of the
+* mDNS TXT record. The order of precedence is HomeKit, PIN required,
+* transient (system) pairing, legacy PIN, none.
+*/
+function getPairingRequirement(txt) {
+	const featuresStr = txt.features ?? txt.ft;
+	if (!featuresStr) return "none";
+	const features = parseFeatures(featuresStr);
+	const sf = parseStatusFlags(txt);
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsHKPairingAndAccessControl)) return "homekit";
+	if ((sf & PIN_REQUIRED_BIT) !== 0n) return "pin";
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsSystemPairing)) return "transient";
+	if ((sf & LEGACY_PAIRING_BIT) !== 0n) return "pin";
+	return "none";
+}
+/** True when the `pw` TXT field or the password bit of the `sf` status flags is set. */
+function isPasswordRequired(txt) {
+	if (txt.pw === "true") return true;
+	return (parseStatusFlags(txt) & PASSWORD_BIT) !== 0n;
+}
+/**
+* True when the device has the SupportsHangdogRemoteControl flag, which it
+* needs to receive HID events. In practice only an Apple TV has it.
+*/
+function isRemoteControlSupported(txt) {
+	const featuresStr = txt.features ?? txt.ft;
+	if (!featuresStr) return false;
+	return hasFeatureFlag(parseFeatures(featuresStr), AirPlayFeatureFlags.SupportsHangdogRemoteControl);
+}
+/** Feature bitmask we advertise for a remote control session. */
+const SENDER_FEATURES_REMOTE_CONTROL = AirPlayFeatureFlags.SupportsAirPlayAudio | AirPlayFeatureFlags.AudioRedundant | AirPlayFeatureFlags.MetadataFeatures0 | AirPlayFeatureFlags.MetadataFeatures1 | AirPlayFeatureFlags.MetadataFeatures2 | AirPlayFeatureFlags.MetadataFeatures3 | AirPlayFeatureFlags.Authentication4 | AirPlayFeatureFlags.Authentication1 | AirPlayFeatureFlags.HasUnifiedAdvertiserInfo | AirPlayFeatureFlags.SupportsUnifiedMediaControl | AirPlayFeatureFlags.SupportsSystemPairing | AirPlayFeatureFlags.SupportsCoreUtilsPairingAndEncryption | AirPlayFeatureFlags.SupportsHKPairingAndAccessControl | AirPlayFeatureFlags.SupportsHangdogRemoteControl | AirPlayFeatureFlags.SupportsAPSync | AirPlayFeatureFlags.SupportsSetPeersExtendedMessage | AirPlayFeatureFlags.SupportsVolume;
+/** Feature bitmask we advertise for an audio streaming session: the remote control features plus the audio ones. */
+const SENDER_FEATURES_AUDIO = SENDER_FEATURES_REMOTE_CONTROL | AirPlayFeatureFlags.SupportsBufferedAudio | AirPlayFeatureFlags.SupportsAudioStreamConnectionSetup | AirPlayFeatureFlags.SupportsAudioMetadataControl | AirPlayFeatureFlags.AudioFormats0 | AirPlayFeatureFlags.AudioFormats1 | AirPlayFeatureFlags.AudioFormats2 | AirPlayFeatureFlags.AudioFormats3 | AirPlayFeatureFlags.SupportsPTP;
+function parseStatusFlags(txt) {
+	const value = (txt.sf || txt.flags || "0").trim().replace(/^0x/i, "");
+	if (!/^[0-9a-f]+$/i.test(value)) return 0n;
+	return BigInt(`0x${value}`);
+}
+
+//#endregion
+//#region src/audio/playback.ts
+/**
+* A running audio stream on a connection of its own. Owns that connection and the source: both
+* end when the source runs out, on {@link stop}, or when the session it came from ends.
+*/
+var AudioPlayback = class {
+	/**
+	* Settles when streaming is over: resolves once the source ran out and TEARDOWN went out,
+	* rejects when the stream failed or was stopped halfway.
+	*/
+	get ended() {
+		return this.#ended;
+	}
+	/** Aborts when the stream's connection closes. */
+	get signal() {
+		return this.#session.signal;
+	}
+	get stats() {
+		return this.#stream.stats;
+	}
+	#ended;
+	#session;
+	#source;
+	#stream;
+	constructor(session, stream, source) {
+		this.#session = session;
+		this.#source = source;
+		this.#stream = stream;
+		this.#ended = this.#run();
+		this.#ended.catch(() => void 0);
+	}
+	/** Stops the source and closes the connection, without TEARDOWN. */
+	stop() {
+		this.#source.stop().catch((error) => this.#session.context.logger.error("Audio source cleanup failed", error));
+		this.#session.close();
+	}
+	async #run() {
+		try {
+			await this.#stream.stream(this.#source, this.#session.target.address);
+		} finally {
+			this.#stream.close();
+			this.#session.close();
+			await this.#source.stop();
+		}
+	}
+};
+
+//#endregion
+//#region src/audio/latency.ts
+/** Latency tiers in ascending order, in seconds (fractions of the sample rate). */
+const LATENCY_TIERS = [
+	.25,
+	.5,
+	1,
+	2
+];
+/** Number of consecutive successful packets needed to drop one latency tier. */
+const STABILITY_THRESHOLD = 500;
+/** Number of glitches within the glitch window that trigger a tier increase. */
+const GLITCH_THRESHOLD = 3;
+/** Time window in milliseconds for counting glitches. */
+const GLITCH_WINDOW_MS = 5e3;
+/**
+* Picks the latency tier of an audio stream. Glitches (packet loss, NACK,
+* late arrival) reported through {@link reportGlitch} raise the tier; a run
+* of {@link reportSuccess} calls lowers it.
+*/
+var LatencyManager = class {
+	#sampleRate;
+	#tierIndex = 0;
+	#consecutiveSuccesses = 0;
+	#glitchTimestamps = [];
+	/**
+	* @param sampleRate - Sample rate in Hz.
+	* @param initialTierIndex - Starting tier, where 0 is the lowest latency.
+	*/
+	constructor(sampleRate, initialTierIndex = 0) {
+		this.#sampleRate = sampleRate;
+		this.#tierIndex = Math.min(Math.max(0, initialTierIndex), LATENCY_TIERS.length - 1);
+	}
+	/** Index of the current latency tier, from 0 (lowest latency) to 3 (highest). */
+	get tierIndex() {
+		return this.#tierIndex;
+	}
+	/** Current latency in samples. */
+	get latency() {
+		return Math.round(this.#sampleRate * LATENCY_TIERS[this.#tierIndex]);
+	}
+	/** Current latency in milliseconds. */
+	get latencyMs() {
+		return Math.round(LATENCY_TIERS[this.#tierIndex] * 1e3);
+	}
+	get isMaxTier() {
+		return this.#tierIndex >= LATENCY_TIERS.length - 1;
+	}
+	get isMinTier() {
+		return this.#tierIndex <= 0;
+	}
+	/** Current latency in samples, same as {@link latency}. */
+	getLatency() {
+		return this.latency;
+	}
+	/**
+	* Reports a packet that was sent and acknowledged. Enough consecutive
+	* successes lower the tier.
+	*/
+	reportSuccess() {
+		this.#consecutiveSuccesses++;
+		if (this.#consecutiveSuccesses >= STABILITY_THRESHOLD && !this.isMinTier) {
+			this.#tierIndex--;
+			this.#consecutiveSuccesses = 0;
+		}
+	}
+	/**
+	* Reports a glitch: packet loss, a retransmission request or a late
+	* arrival. Enough glitches within the window raise the tier.
+	*/
+	reportGlitch() {
+		this.#consecutiveSuccesses = 0;
+		const now = performance.now();
+		this.#glitchTimestamps.push(now);
+		const windowStart = now - GLITCH_WINDOW_MS;
+		this.#glitchTimestamps = this.#glitchTimestamps.filter((timestamp) => timestamp >= windowStart);
+		if (this.#glitchTimestamps.length >= GLITCH_THRESHOLD && !this.isMaxTier) {
+			this.#tierIndex++;
+			this.#glitchTimestamps = [];
+		}
+	}
+	/** RFC 2198 redundancy level for the current tier; a higher tier gets more. */
+	get recommendedRedundancy() {
+		if (this.#tierIndex >= 2) return 3;
+		if (this.#tierIndex >= 1) return 2;
+		return 1;
+	}
+	/** Returns to the lowest tier. */
+	reset() {
+		this.#tierIndex = 0;
+		this.#consecutiveSuccesses = 0;
+		this.#glitchTimestamps = [];
+	}
+};
+
+//#endregion
+//#region src/audio/pacing.ts
+/** Maximum number of extra packets per cycle when catching up. */
+const MAX_PACKETS_COMPENSATE = 3;
+/** Number of consecutive slow packets before logging a warning. */
+const SLOW_WARNING_THRESHOLD = 5;
+/**
+* Paces audio packets against wall-clock time, sending up to {@link MAX_PACKETS_COMPENSATE} extra packets per cycle when behind.
+*
+* @param sendPacket - Returns frames sent, or 0 when done.
+* @returns Total packets sent.
+*/
+async function streamWithTiming(sendPacket, options) {
+	const { sampleRate, logger, logPrefix } = options;
+	let firstPacket = true;
+	let packetCount = 0;
+	let slowCount = 0;
+	let totalFrames = 0;
+	const startTime = performance.now();
+	while (true) {
+		const framesSent = await sendPacket(firstPacket);
+		if (framesSent === 0) {
+			logger.debug(logPrefix, `End of stream after ${packetCount} packets`);
+			break;
+		}
+		totalFrames += framesSent;
+		packetCount++;
+		firstPacket = false;
+		if (packetCount % 100 === 0) logger.debug(logPrefix, `Sent ${packetCount} packets, ${totalFrames} frames`);
+		const sleepTime = totalFrames / sampleRate * 1e3 - (performance.now() - startTime);
+		if (sleepTime > 0) {
+			slowCount = 0;
+			await waitFor(sleepTime);
+		} else {
+			const framesBehind = Math.floor(-sleepTime / 1e3 * sampleRate);
+			if (framesBehind >= 352) {
+				const extraPackets = Math.min(Math.floor(framesBehind / 352), MAX_PACKETS_COMPENSATE);
+				for (let idx = 0; idx < extraPackets; idx++) {
+					const extra = await sendPacket(false);
+					if (extra === 0) break;
+					totalFrames += extra;
+					packetCount++;
+				}
+			}
+			slowCount++;
+			if (slowCount >= SLOW_WARNING_THRESHOLD) {
+				logger.warn(logPrefix, `Stream behind schedule (${slowCount} consecutive, ${Math.abs(sleepTime).toFixed(1)}ms behind)`);
+				slowCount = 0;
+			}
+		}
+	}
+	return packetCount;
+}
+
+//#endregion
+//#region src/audio/stream.ts
+/** Maximum number of packets to keep in the retransmission backlog. */
+const PACKET_BACKLOG_SIZE = 1e3;
+/** Interval in milliseconds between RTCP sync packets. */
+const SYNC_INTERVAL = 1e3;
+/** Default number of previous frames sent as RFC 2198 redundancy; 0 disables it. */
+const DEFAULT_REDUNDANCY_COUNT = 0;
+/** Compression types for SETUP `ct`. */
+const CompressionType = {
+	PCM: 1,
+	ALAC: 2,
+	AAC_LC: 4,
+	AAC_ELD: 8,
+	Opus: 32
+};
+/** SETUP `audioFormat` bits, named `{codec}_{sampleRate}_{bitDepth}_{channels}`. */
+const AudioFormat = {
+	PCM_8000_16_1: 4,
+	PCM_8000_16_2: 8,
+	PCM_16000_16_1: 16,
+	PCM_16000_16_2: 32,
+	PCM_24000_16_1: 64,
+	PCM_24000_16_2: 128,
+	PCM_32000_16_1: 256,
+	PCM_32000_16_2: 512,
+	PCM_44100_16_1: 1024,
+	PCM_44100_16_2: 2048,
+	PCM_44100_24_1: 4096,
+	PCM_44100_24_2: 8192,
+	PCM_48000_16_1: 16384,
+	PCM_48000_16_2: 32768,
+	PCM_48000_24_1: 65536,
+	PCM_48000_24_2: 131072,
+	ALAC_44100_16_2: 262144,
+	ALAC_44100_24_2: 524288,
+	ALAC_48000_16_2: 1048576,
+	ALAC_48000_24_2: 2097152,
+	AAC_LC_44100_2: 4194304,
+	AAC_LC_48000_2: 8388608,
+	AAC_ELD_44100_2: 16777216,
+	AAC_ELD_48000_2: 33554432,
+	AAC_ELD_16000_1: 67108864,
+	AAC_ELD_24000_1: 134217728,
+	AAC_ELD_48000_1: 4294967296
+};
+/** Converts an RTP timestamp to NTP against the wall-clock anchor taken at stream start, for multiroom sync. */
+function rtpToNtp(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)));
+}
+/**
+* Encrypted RTP audio over UDP with RTCP synchronization, NACK retransmission and optional RFC 2198 redundancy.
+* Call {@link setup}, then {@link prepare}, send frames and call {@link finish}, or use {@link stream} after setup.
+*/
+var AudioStream = class {
+	#address;
+	#context;
+	#control;
+	#supportedFormats;
+	/** RFC 2198 redundancy count; 0 disables it. */
+	#redundancyCount;
+	#controlPort = 0;
+	#source;
+	#closed = false;
+	/** UDP socket for RTCP control messages (sync, retransmit requests). */
+	#controlSocket;
+	/** 32-byte shared key for ChaCha20 audio encryption. */
+	#sharedKey;
+	/** Remote data port from the SETUP response. */
+	#dataPort = 0;
+	#dataSocket;
+	#negotiatedBytesPerChannel = 2;
+	#negotiatedSampleRate = AUDIO_SAMPLE_RATE;
+	/** RTP timestamp of the NTP anchor. */
+	#anchorRtp = 0;
+	/** NTP timestamp of the anchor, for RTP to NTP conversion. */
+	#anchorNtp = 0n;
+	/** Previous frames kept for RFC 2198 redundancy. */
+	#previousFrames = [];
+	/** Remote RTCP control port from the SETUP response. */
+	#remoteControlPort = 0;
+	/** Sent packets kept for retransmission on NACK, keyed by RTP sequence number. */
+	#packetBacklog = /* @__PURE__ */ new Map();
+	/** Random RTP synchronization source identifier. */
+	#ssrc = 0;
+	#syncInterval;
+	#streamContext;
+	#latencyManager;
+	/** ChaCha20 nonce counter, independent of the RTP sequence number. */
+	#encryptionCounter = 0;
+	#packetsSent = 0;
+	#retransmitRequests = 0;
+	#retransmitsFulfilled = 0;
+	#retransmitsFailed = 0;
+	#totalBytesSent = 0;
+	get stats() {
+		return {
+			packetsSent: this.#packetsSent,
+			retransmitRequests: this.#retransmitRequests,
+			retransmitsFulfilled: this.#retransmitsFulfilled,
+			retransmitsFailed: this.#retransmitsFailed,
+			packetLossRate: this.#packetsSent > 0 ? this.#retransmitRequests / this.#packetsSent : 0,
+			totalBytesSent: this.#totalBytesSent
+		};
+	}
+	constructor(target, options) {
+		this.#address = target.address;
+		this.#context = target.context;
+		this.#control = target.control;
+		this.#supportedFormats = target.supportedAudioFormats;
+		this.#redundancyCount = options?.redundancyCount ?? DEFAULT_REDUNDANCY_COUNT;
+	}
+	/**
+	* Negotiates PCM 44100/16/stereo and UDP ports via SETUP, then sends RECORD.
+	*
+	* @returns The assigned data and control ports.
+	* @throws SetupError if SETUP fails or returns no stream info.
+	*/
+	async setup() {
+		if (this.#closed) throw new SetupError("Audio setup cancelled.");
+		this.#sharedKey = Buffer.from(randomBytes(32));
+		this.#ssrc = randomInt32() >>> 0;
+		const socket = this.#controlSocket = createSocket("udp4");
+		this.#controlSocket.on("message", (data, rinfo) => this.#onControlMessage(data, rinfo));
+		await new Promise((resolve, reject) => {
+			const cleanup = () => {
+				socket.off("error", fail);
+				socket.off("close", closed);
+			};
+			const fail = (error) => {
+				cleanup();
+				reject(error);
+			};
+			const closed = () => fail(new SetupError("Audio setup cancelled."));
+			socket.once("error", fail);
+			socket.once("close", closed);
+			socket.bind(0, () => {
+				cleanup();
+				if (this.#closed) {
+					reject(new SetupError("Audio setup cancelled."));
+					return;
+				}
+				this.#controlPort = socket.address().port;
+				resolve();
+			});
+		});
+		const shkArrayBuffer = this.#sharedKey.buffer.slice(this.#sharedKey.byteOffset, this.#sharedKey.byteOffset + this.#sharedKey.byteLength);
+		const streamConnectionID = randomInt64();
+		const supportedFormats = this.#supportedFormats;
+		const ct = CompressionType.PCM;
+		const audioFormat = AudioFormat.PCM_44100_16_2;
+		const sampleRate = AUDIO_SAMPLE_RATE;
+		if (supportedFormats) this.#context.logger.info("[audio]", `Receiver supported formats: 0x${supportedFormats.toString(16)}`);
+		const bytesPerChannel = 2;
+		const setupBody = Plist.serialize({ streams: [{
+			audioFormat,
+			audioMode: "default",
+			controlPort: this.#controlPort,
+			ct,
+			isMedia: true,
+			latencyMax: sampleRate * 2,
+			latencyMin: Math.round(sampleRate * .25),
+			shk: shkArrayBuffer,
+			spf: 352,
+			sr: sampleRate,
+			streamConnectionID,
+			supportsDynamicStreamID: false,
+			redundantAudio: this.#redundancyCount > 0,
+			supportsRTPPacketRedundancy: this.#redundancyCount > 0,
+			type: 96
+		}] });
+		this.#context.logger.debug("[audio]", "Sending audio stream SETUP...");
+		this.#context.logger.debug("[audio]", "shk length:", this.#sharedKey.length);
+		const response = await this.#control.setup(`/${this.#control.sessionId}`, Buffer.from(setupBody), { "Content-Type": "application/x-apple-binary-plist" });
+		if (this.#closed) throw new SetupError("Audio setup cancelled.");
+		if (response.status !== 200) {
+			const text = await response.text();
+			throw new SetupError(`Failed to setup audio stream: ${response.status} - ${text}`);
+		}
+		const plist = Plist.parse(await response.arrayBuffer());
+		this.#context.logger.debug("[audio]", "Setup stream response:", plist);
+		if (!(plist.streams && plist.streams.length > 0)) throw new SetupError("No stream info in SETUP response.");
+		const streamInfo = plist.streams[0];
+		this.#dataPort = streamInfo.dataPort & 65535;
+		this.#remoteControlPort = streamInfo.controlPort & 65535;
+		this.#negotiatedSampleRate = sampleRate;
+		this.#negotiatedBytesPerChannel = bytesPerChannel;
+		this.#context.logger.info("[audio]", `Audio stream setup: dataPort=${this.#dataPort}, controlPort=${this.#remoteControlPort}, format=0x${audioFormat.toString(16)}, sr=${sampleRate}, bpc=${bytesPerChannel}`);
+		this.#context.logger.debug("[audio]", "Sending RECORD...");
+		await this.#control.record(`/${this.#control.sessionId}`);
+		if (this.#closed) throw new SetupError("Audio setup cancelled.");
+		this.#context.logger.debug("[audio]", "RECORD complete");
+		return {
+			dataPort: this.#dataPort,
+			controlPort: this.#remoteControlPort
+		};
+	}
+	/**
+	* Connects the UDP data socket, creates the stream context, sends FLUSH
+	* and starts RTCP sync.
+	*/
+	async prepare(remoteAddress) {
+		if (!this.#controlSocket || !this.#sharedKey || !this.#dataPort) throw new SetupError("Audio stream not setup.");
+		if (this.#closed) throw new SetupError("Audio preparation cancelled.");
+		const socket = this.#dataSocket = createSocket("udp4");
+		await new Promise((resolve, reject) => {
+			const cleanup = () => {
+				socket.off("error", fail);
+				socket.off("close", closed);
+			};
+			const fail = (error) => {
+				cleanup();
+				reject(error);
+			};
+			const closed = () => fail(new SetupError("Audio preparation cancelled."));
+			socket.once("error", fail);
+			socket.once("close", closed);
+			socket.connect(this.#dataPort, remoteAddress, () => {
+				cleanup();
+				this.#closed ? reject(new SetupError("Audio preparation cancelled.")) : resolve();
+			});
+		});
+		const frameSize = 2 * this.#negotiatedBytesPerChannel;
+		const packetSize = 352 * frameSize;
+		this.#latencyManager = new LatencyManager(this.#negotiatedSampleRate);
+		const latency = this.#latencyManager.getLatency();
+		const initialRtpTime = 0;
+		this.#anchorRtp = initialRtpTime;
+		this.#anchorNtp = NTP.now();
+		const ctx = {
+			sampleRate: this.#negotiatedSampleRate,
+			channels: 2,
+			bytesPerChannel: this.#negotiatedBytesPerChannel,
+			frameSize,
+			packetSize,
+			rtpSeq: randomInt32() & 65535,
+			rtpTime: initialRtpTime,
+			headTs: initialRtpTime,
+			latency,
+			paddingSent: 0,
+			totalFrames: 0
+		};
+		this.#streamContext = ctx;
+		this.#context.logger.debug("[audio]", "Sending FLUSH...");
+		await this.#control.flush(`/${this.#control.sessionId}`, {
+			"Range": "npt=0-",
+			"RTP-Info": `seq=${ctx.rtpSeq};rtptime=${ctx.rtpTime}`
+		});
+		if (this.#closed) throw new SetupError("Audio preparation cancelled.");
+		this.#context.logger.debug("[audio]", "FLUSH complete");
+		this.#context.logger.debug("[audio]", `RTP start: seq=${ctx.rtpSeq}, time=${ctx.rtpTime}, ssrc=${this.#ssrc}`);
+		this.#packetBacklog.clear();
+		this.#startSync();
+		return ctx;
+	}
+	/**
+	* Sends frames that were already read as one RTP packet. {@link AudioMultiplexer}
+	* reads each packet once and sends it to every stream.
+	*
+	* @param frames - Raw PCM frame data.
+	* @param firstPacket - Sets the RTP marker bit.
+	* @returns Number of frames sent.
+	* @throws SetupError if the stream has not been prepared.
+	*/
+	async sendFrameData(frames, firstPacket) {
+		if (!this.#streamContext) throw new SetupError("Audio stream not prepared.");
+		return this.#sendFrameBuffer(frames, firstPacket, this.#streamContext);
+	}
+	/** Pads with silence for the negotiated latency before TEARDOWN so the receiver can finish buffered audio. */
+	async finish() {
+		if (!this.#streamContext) return;
+		const ctx = this.#streamContext;
+		const startFrames = ctx.totalFrames;
+		const startTime = performance.now();
+		while (ctx.paddingSent < ctx.latency) {
+			const silence = Buffer.alloc(ctx.packetSize, 0);
+			const sent = await this.#sendFrameBuffer(silence, false, ctx);
+			if (sent === 0) break;
+			ctx.paddingSent += sent;
+			const sleepTime = (ctx.totalFrames - startFrames) / ctx.sampleRate * 1e3 - (performance.now() - startTime);
+			if (sleepTime > 0) await this.#sleep(sleepTime);
+		}
+		this.#stopSync();
+		this.#context.logger.debug("[audio]", "Sending TEARDOWN...");
+		await this.#control.teardown(`/${this.#control.sessionId}`);
+		this.#context.logger.debug("[audio]", "TEARDOWN complete");
+	}
+	/**
+	* Prepares, paces and finishes the stream, then closes it. Sends extra packets when behind schedule.
+	*
+	* @param remoteAddress - Receiver address for the UDP connection.
+	*/
+	async stream(source, remoteAddress) {
+		const session = new AudioSourceSession(source);
+		this.#source = session;
+		try {
+			if (this.#closed) return;
+			const ctx = await this.prepare(remoteAddress);
+			if (this.#closed) return;
+			await session.start();
+			this.#context.logger.info("[audio]", "Starting audio stream...");
+			const packetCount = await streamWithTiming((firstPacket) => this.#sendPacket(session, firstPacket, ctx), {
+				sampleRate: ctx.sampleRate,
+				logger: this.#context.logger,
+				logPrefix: "[audio]"
+			});
+			this.#context.logger.info("[audio]", `Audio stream finished, sent ${packetCount} packets`);
+			this.#stopSync();
+			this.#context.logger.debug("[audio]", "Sending TEARDOWN...");
+			await this.#control.teardown(`/${this.#control.sessionId}`);
+			this.#context.logger.debug("[audio]", "TEARDOWN complete");
+		} finally {
+			this.close();
+			if (this.#source === session) this.#source = void 0;
+		}
+	}
+	/**
+	* Reads frames from the source and sends them as one RTP packet. Once the
+	* source is exhausted, it sends silence until the latency is padded.
+	*
+	* @param firstPacket - Sets the RTP marker bit.
+	* @param ctx - Stream context with the RTP state, updated in place.
+	* @returns Number of frames sent, or 0 when all padding has been sent.
+	*/
+	async #sendPacket(source, firstPacket, ctx) {
+		if (this.#closed || ctx.paddingSent >= ctx.latency) return 0;
+		let frames = await source.readFrames(352);
+		if (this.#closed) return 0;
+		if (!frames || frames.length === 0) {
+			frames = Buffer.alloc(ctx.packetSize, 0);
+			ctx.paddingSent += Math.floor(frames.length / ctx.frameSize);
+		} else if (frames.length < ctx.packetSize) {
+			const padded = Buffer.alloc(ctx.packetSize, 0);
+			frames.copy(padded);
+			frames = padded;
+		}
+		return this.#sendFrameBuffer(frames, firstPacket, ctx);
+	}
+	/**
+	* Builds encrypted RTP packets with optional RFC 2198 redundancy and retains them for retransmission.
+	*
+	* @param frames - PCM data, `packetSize` bytes.
+	* @param firstPacket - Sets the RTP marker bit.
+	* @returns Number of frames sent.
+	*/
+	#sendFrameBuffer(frames, firstPacket, ctx) {
+		const hasRedundancy = this.#redundancyCount > 0 && this.#previousFrames.length > 0;
+		const pt = hasRedundancy ? 97 : 96;
+		const rtpHeader = Buffer.allocUnsafe(12);
+		rtpHeader.writeUInt8(128, 0);
+		rtpHeader.writeUInt8(firstPacket ? pt | 128 : pt, 1);
+		rtpHeader.writeUInt16BE(ctx.rtpSeq, 2);
+		rtpHeader.writeUInt32BE(ctx.headTs >>> 0, 4);
+		rtpHeader.writeUInt32BE(this.#ssrc, 8);
+		let audioPayload;
+		if (hasRedundancy) {
+			const redundantFrames = this.#previousFrames.slice(-this.#redundancyCount);
+			const headers = [];
+			for (let i = 0; i < redundantFrames.length; i++) {
+				const tsOffset = (redundantFrames.length - i) * 352;
+				const blockLen = redundantFrames[i].length;
+				const header = Buffer.allocUnsafe(4);
+				header[0] = 224;
+				header[1] = tsOffset >> 6 & 255;
+				header[2] = (tsOffset & 63) << 2 | blockLen >> 8 & 3;
+				header[3] = blockLen & 255;
+				headers.push(header);
+			}
+			headers.push(Buffer.from([96]));
+			audioPayload = Buffer.concat([
+				...headers,
+				...redundantFrames,
+				frames
+			]);
+		} else audioPayload = frames;
+		this.#previousFrames.push(Buffer.from(frames));
+		if (this.#previousFrames.length > this.#redundancyCount) this.#previousFrames.shift();
+		const aad = rtpHeader.subarray(4, 12);
+		const payload = this.#encryptAudio(audioPayload, aad, this.#encryptionCounter++);
+		const packet = Buffer.concat([rtpHeader, payload]);
+		this.#storePacket(ctx.rtpSeq, packet);
+		const framesSent = Math.floor(frames.length / ctx.frameSize);
+		ctx.rtpSeq = ctx.rtpSeq + 1 & 65535;
+		ctx.headTs = ctx.headTs + framesSent >>> 0;
+		ctx.totalFrames += framesSent;
+		return this.#send(packet).then(() => {
+			this.#packetsSent++;
+			this.#totalBytesSent += packet.length;
+			this.#latencyManager?.reportSuccess();
+			if (this.#redundancyCount > 0 && this.#latencyManager && this.#packetsSent % 50 === 0) {
+				const recommended = this.#latencyManager.recommendedRedundancy;
+				if (recommended !== this.#redundancyCount) {
+					this.#context.logger.debug("[audio]", `Adjusting redundancy: ${this.#redundancyCount} → ${recommended}`);
+					this.#redundancyCount = recommended;
+				}
+			}
+			return framesSent;
+		});
+	}
+	/** Keeps a sent packet for retransmission and drops the oldest past {@link PACKET_BACKLOG_SIZE}. */
+	#storePacket(seqno, packet) {
+		this.#packetBacklog.set(seqno, packet);
+		if (this.#packetBacklog.size > PACKET_BACKLOG_SIZE) {
+			const oldestKey = this.#packetBacklog.keys().next().value;
+			if (oldestKey !== void 0) this.#packetBacklog.delete(oldestKey);
+		}
+	}
+	/**
+	* Returns a sent packet from the retransmission backlog.
+	*
+	* @returns The RTP packet with its header, or undefined once it left the backlog.
+	*/
+	getPacket(seqno) {
+		return this.#packetBacklog.get(seqno);
+	}
+	/**
+	* Encrypts an audio payload with ChaCha20-Poly1305 and the shared key. The
+	* 12-byte nonce holds the counter little-endian at offset 4.
+	*
+	* @param aad - RTP header bytes 4 to 12: timestamp and SSRC.
+	* @param seqNumber - Nonce counter.
+	* @returns Ciphertext, auth tag and the 8-byte nonce trailer.
+	* @throws EncryptionError if encryption has not been set up.
+	*/
+	#encryptAudio(data, aad, seqNumber) {
+		if (!this.#sharedKey) throw new EncryptionError("Encryption not setup.");
+		const nonceBytes = Buffer.alloc(12, 0);
+		nonceBytes.writeUInt32LE(seqNumber, 4);
+		const result = ChaCha20.encrypt(this.#sharedKey, nonceBytes, aad, data);
+		const nonceTrailer = nonceBytes.subarray(4, 12);
+		return Buffer.concat([
+			result.ciphertext,
+			result.authTag,
+			nonceTrailer
+		]);
+	}
+	#send(data) {
+		return new Promise((resolve, reject) => {
+			this.#dataSocket.send(data, (err) => err ? reject(err) : resolve());
+		});
+	}
+	#sleep(ms) {
+		return new Promise((resolve) => setTimeout(resolve, ms));
+	}
+	/**
+	* Starts the periodic RTCP sync packets (type 0xD4). Each one tells the
+	* receiver our current RTP timestamp and its NTP wall-clock time; the
+	* first has the marker bit set.
+	*/
+	#startSync() {
+		if (this.#syncInterval) return;
+		let firstPacket = true;
+		const sendSync = () => {
+			if (!this.#controlSocket || !this.#streamContext || !this.#remoteControlPort) return;
+			const ctx = this.#streamContext;
+			const currentTime = rtpToNtp(ctx.headTs, ctx.sampleRate, this.#anchorRtp, this.#anchorNtp);
+			const [currentSec, currentFrac] = NTP.parts(currentTime);
+			const packet = Buffer.allocUnsafe(20);
+			packet.writeUInt8(firstPacket ? 144 : 128, 0);
+			packet.writeUInt8(212, 1);
+			packet.writeUInt16BE(7, 2);
+			packet.writeUInt32BE(ctx.headTs - ctx.latency >>> 0, 4);
+			packet.writeUInt32BE(currentSec, 8);
+			packet.writeUInt32BE(currentFrac, 12);
+			packet.writeUInt32BE(ctx.headTs >>> 0, 16);
+			firstPacket = false;
+			this.#controlSocket.send(packet, this.#remoteControlPort, this.#address, (err) => {
+				if (err) this.#context.logger.warn("[audio]", "Sync packet send failed", err);
+			});
+		};
+		sendSync();
+		this.#syncInterval = setInterval(sendSync, SYNC_INTERVAL);
+	}
+	/** Stops the RTCP sync packets and clears the stream context. */
+	#stopSync() {
+		if (this.#syncInterval) {
+			clearInterval(this.#syncInterval);
+			this.#syncInterval = void 0;
+		}
+		this.#streamContext = void 0;
+	}
+	/**
+	* Handles an RTCP control message from the receiver. Only type 0x55, a
+	* retransmit request (NACK), is handled.
+	*/
+	#onControlMessage(data, rinfo) {
+		if (data.length < 8 || data[0] >> 6 !== 2 || rinfo.address !== this.#address || rinfo.port !== this.#remoteControlPort) return;
+		if ((data[1] & 127) === 85) this.#retransmitPackets(data, rinfo);
+	}
+	/**
+	* Answers a NACK by resending each requested packet from the backlog in a
+	* retransmit response (type 0xD6). A packet that left the backlog gets an
+	* empty response, so the receiver stops waiting for it.
+	*
+	* @param data - NACK packet with the first sequence number and the count.
+	*/
+	#retransmitPackets(data, addr) {
+		const lostSeqno = data.readUInt16BE(4);
+		const lostPackets = Math.min(data.readUInt16BE(6), 512);
+		this.#latencyManager?.reportGlitch();
+		this.#retransmitRequests += lostPackets;
+		for (let i = 0; i < lostPackets; i++) {
+			const seqno = lostSeqno + i & 65535;
+			const packet = this.#packetBacklog.get(seqno);
+			if (packet) {
+				const originalSeqno = packet.subarray(2, 4);
+				const resp = Buffer.concat([
+					Buffer.from([128, 214]),
+					originalSeqno,
+					packet
+				]);
+				this.#controlSocket?.send(resp, addr.port, addr.address);
+				this.#retransmitsFulfilled++;
+			} else {
+				const seqBuf = Buffer.alloc(2);
+				seqBuf.writeUInt16BE(seqno);
+				const resp = Buffer.concat([
+					Buffer.from([128, 214]),
+					seqBuf,
+					Buffer.alloc(4)
+				]);
+				this.#controlSocket?.send(resp, addr.port, addr.address);
+				this.#retransmitsFailed++;
+			}
+		}
+	}
+	/**
+	* Stops the sync packets, closes both UDP sockets and clears the
+	* retransmission backlog. Safe to call more than once.
+	*/
+	close() {
+		this.#closed = true;
+		this.#source?.stop().catch((error) => this.#context.logger.error("[audio]", "Source cleanup failed", error));
+		this.#stopSync();
+		try {
+			this.#controlSocket?.removeAllListeners();
+			this.#controlSocket?.close();
+		} catch {}
+		this.#controlSocket = void 0;
+		try {
+			this.#dataSocket?.close();
+		} catch {}
+		this.#dataSocket = void 0;
+		this.#packetBacklog.clear();
+	}
+};
+
+//#endregion
+//#region src/channels/encryption.ts
+/** Frames we send carry at most this much plaintext. */
+const FRAME_LENGTH = 1024;
+function nonce(counter) {
+	return buildNonce(counter, "counter-at-4");
+}
+/**
+* Decrypts the complete frames at the start of `data`: `[2-byte LE length] [ciphertext] [16-byte
+* auth tag]`, where the length is the AAD. Callers keep the unconsumed ciphertext tail for the
+* next read.
+*
+* @throws If a frame has length zero, or a frame fails authentication.
+*/
+function chacha20DecryptFrames(state, data) {
+	const output = [];
+	let offset = 0;
+	while (offset + 2 <= data.length) {
+		const length = data.readUInt16LE(offset);
+		if (length === 0) throw new Error("Invalid encrypted frame length");
+		const end = offset + length + 18;
+		if (end > data.length) break;
+		const plaintext = ChaCha20.decrypt(state.readKey, nonce(state.readCount), data.subarray(offset, offset + 2), data.subarray(offset + 2, end - 16), data.subarray(end - 16, end));
+		state.readCount++;
+		output.push(plaintext);
+		offset = end;
+	}
+	return {
+		data: Buffer.concat(output),
+		consumed: offset
+	};
+}
+/** Encrypts `data` in frames of at most 1024 bytes, each with its 2-byte LE length as AAD. */
+function chacha20Encrypt(state, data) {
+	const result = [];
+	for (let offset = 0; offset < data.length;) {
+		const frame = data.subarray(offset, offset + FRAME_LENGTH);
+		offset += frame.length;
+		const leLength = Buffer.allocUnsafe(2);
+		leLength.writeUInt16LE(frame.length, 0);
+		const encrypted = ChaCha20.encrypt(state.writeKey, nonce(state.writeCount++), leLength, frame);
+		result.push(leLength, encrypted.ciphertext, encrypted.authTag);
+	}
+	return Buffer.concat(result);
+}
+
+//#endregion
+//#region src/channels/control.ts
+/** Request line protocol of play queue commands: they go as HTTP/1.1 on the RTSP connection. */
+const COMMAND_PROTOCOL = "HTTP/1.1";
+/** Slightly less than the two-second feedback interval, so requests never overlap. */
+const FEEDBACK_TIMEOUT = 1900;
+/**
+* The RTSP control connection of an AirPlay session. Every request carries the session headers
+* (Active-Remote, DACP-ID, X-Apple-Session-ID); after pair-verify the connection switches to
+* ChaCha20-Poly1305 frames. Requests resolve with any status, the caller checks it.
+*/
+var ControlChannel = class extends RtspClient {
+	/** DACP remote identifier, a random unsigned 32-bit integer in decimal. */
+	get activeRemoteId() {
+		return this.#activeRemoteId;
+	}
+	/** DACP identifier, 16 uppercase hex characters. */
+	get dacpId() {
+		return this.#dacpId;
+	}
+	/** Identifies the session in RTSP URIs (`/<sessionId>`) and the `X-Apple-Session-ID` header. */
+	get sessionId() {
+		return this.#sessionId;
+	}
+	get isEncrypted() {
+		return !!this.#encryptionState;
+	}
+	/** Settles once the TEARDOWN in flight is answered, times out or loses its connection; undefined when none is. */
+	get pendingTeardown() {
+		return this.#pendingTeardown;
+	}
+	#activeRemoteId;
+	#dacpId;
+	#sessionId;
+	#closeReason;
+	#encryptionState;
+	#pendingTeardown;
+	constructor(context, address, port) {
+		super(context, address, port);
+		this.#activeRemoteId = generateActiveRemoteId();
+		this.#dacpId = generateDacpId();
+		this.#sessionId = generateSessionId();
+		this.on("closed", (reason) => this.#closeReason = reason);
+	}
+	/** Switches to encrypted frames with the control keys from pair-verify or a transient pairing. */
+	enableEncryption(readKey, writeKey) {
+		this.#encryptionState = new EncryptionState(readKey, writeKey);
+	}
+	getDefaultHeaders() {
+		return {
+			"Active-Remote": this.#activeRemoteId,
+			"DACP-ID": this.#dacpId,
+			"User-Agent": `AirPlay/${resolveIdentity(this.context).sourceVersion}`,
+			"X-Apple-ProtocolVersion": 1,
+			"X-Apple-Session-ID": this.#sessionId
+		};
+	}
+	transformIncoming(data) {
+		if (!this.#encryptionState) return data;
+		return chacha20DecryptFrames(this.#encryptionState, data);
+	}
+	transformOutgoing(data) {
+		if (!this.#encryptionState) return data;
+		return chacha20Encrypt(this.#encryptionState, data);
+	}
+	/**
+	* Sends a play queue command as `POST /command`, the command as a binary plist in `params.data`.
+	*
+	* @param streamId - Stream ID from the SETUP of the remote control stream.
+	* @param sessionUUID - Session UUID from the first SETUP, sent as `X-Apple-Session-ID`.
+	*/
+	async command(streamId, payload, sessionUUID) {
+		const data = payload instanceof ArrayBuffer ? payload : Plist.serialize(payload);
+		return await this.exchange("POST", "/command", {
+			headers: {
+				"X-Apple-Session-ID": sessionUUID,
+				"X-Apple-StreamID": String(streamId)
+			},
+			body: { params: { data } },
+			protocol: COMMAND_PROTOCOL,
+			allowError: true
+		});
+	}
+	/** The keepalive a receiver expects every two seconds, optionally with stats in the body. */
+	async feedback(stats) {
+		return await this.post("/feedback", stats, void 0, FEEDBACK_TIMEOUT);
+	}
+	async flush(uri, headers) {
+		return await this.exchange("FLUSH", uri, {
+			headers,
+			allowError: true
+		});
+	}
+	/** Flushes buffered audio, optionally limited by flushFromSeq/TS and flushUntilSeq/TS headers. */
+	async flushBuffered(uri, headers = {}) {
+		return await this.exchange("FLUSHBUFFERED", uri, {
+			headers,
+			allowError: true
+		});
+	}
+	async get(path, headers = {}, timeout = HTTP_TIMEOUT) {
+		return await this.exchange("GET", path, {
+			headers,
+			timeout,
+			allowError: true
+		});
+	}
+	/**
+	* Reads a receiver property, such as `Volume`, `VolumeDB`, `IsMuted`, `ReceiverDeviceIsPlaying`,
+	* `AudioLatencyMs`, `ClusterUUID`, `UsePTPClock` or `dmcp.device-volume`. The body holds the value,
+	* usually as a plist.
+	*/
+	async getProperty(property) {
+		return await this.get(`/getProperty?${property}`);
+	}
+	async post(path, body, headers = {}, timeout = HTTP_TIMEOUT) {
+		return await this.exchange("POST", path, {
+			headers,
+			body,
+			timeout,
+			allowError: true
+		});
+	}
+	async put(path, body, headers = {}, timeout = HTTP_TIMEOUT) {
+		return await this.exchange("PUT", path, {
+			headers,
+			body,
+			timeout,
+			allowError: true
+		});
+	}
+	async record(path, headers = {}, timeout = HTTP_TIMEOUT) {
+		return await this.exchange("RECORD", path, {
+			headers,
+			timeout,
+			allowError: true
+		});
+	}
+	/** Seeks URL playback to a position in seconds. */
+	async scrub(position) {
+		return await this.exchange("POST", `/scrub?position=${position.toFixed(6)}`, { allowError: true });
+	}
+	/** Sets the audio routing mode, such as `default`, `moviePlayback` or `spoken`. */
+	async setAudioMode(mode) {
+		const body = Plist.serialize({ audioMode: mode });
+		return await this.exchange("POST", "/audioMode", {
+			body: Buffer.from(body),
+			headers: { "Content-Type": "application/x-apple-binary-plist" },
+			allowError: true
+		});
+	}
+	/** Sends `SET_PARAMETER` on the session with a `text/parameters` body; stream volume is set this way, in dB. */
+	async setParameter(parameter, value) {
+		return await this.exchange("SET_PARAMETER", `/${this.sessionId}`, {
+			contentType: "text/parameters",
+			body: `${parameter}: ${value}\r\n`,
+			allowError: true
+		});
+	}
+	/** Writes a receiver property; see {@link getProperty} for the known keys. */
+	async setProperty(property, body) {
+		return await this.put(`/setProperty?${property}`, body);
+	}
+	async setup(path, body, headers = {}, timeout = HTTP_TIMEOUT) {
+		return await this.exchange("SETUP", path, {
+			headers,
+			body,
+			timeout,
+			allowError: true
+		});
+	}
+	async setVolume(volume) {
+		return await this.exchange("POST", `/volume?volume=${volume.toFixed(6)}`, { allowError: true });
+	}
+	/** Stops URL playback. */
+	async stop() {
+		return await this.exchange("POST", "/stop", { allowError: true });
+	}
+	/**
+	* Ends the session on the receiver. A receiver that closes this connection before it answers
+	* has ended the session itself, so that counts as done and resolves with undefined.
+	*/
+	async teardown(path, headers = {}, timeout = HTTP_TIMEOUT) {
+		const exchange = this.exchange("TEARDOWN", path, {
+			headers,
+			timeout,
+			allowError: true
+		});
+		const settled = exchange.then(() => void 0, () => void 0);
+		this.#pendingTeardown = settled;
+		settled.then(() => {
+			if (this.#pendingTeardown === settled) this.#pendingTeardown = void 0;
+		});
+		try {
+			return await exchange;
+		} catch (err) {
+			if (this.#closeReason !== "remote") throw err;
+			this.context.logger.debug("[rtsp]", "The receiver closed the control connection before answering TEARDOWN, the session has ended.");
+			return;
+		}
+	}
+};
+
+//#endregion
+//#region src/channels/encrypted.ts
+/** Upper bound for both receive buffers; a peer that sends more is broken or hostile. */
+const MAX_BUFFER_SIZE = 4 * 1024 * 1024;
+/**
+* A TCP channel next to the control channel that is encrypted from its first byte, in AirPlay's
+* frame format (2-byte LE length as AAD, nonce with the counter at offset 4).
+*
+* Ciphertext and plaintext have separate buffers: a partial TCP delivery leaves ciphertext waiting
+* until its frame is complete, so it can never end up in the plaintext a subclass parses. A frame
+* that does not decrypt or parse ends the channel with reason `error`.
+*/
+var EncryptedChannel = class extends EncryptionAwareConnection {
+	#buffer = Buffer.alloc(0);
+	#encryptedBuffer = Buffer.alloc(0);
+	constructor(context, address, port, keys) {
+		super(context, address, port);
+		this.enableEncryption(keys.readKey, keys.writeKey);
+		const connection = this;
+		connection.on("data", (data) => this.#onData(data));
+		connection.on("closed", () => this.#reset());
+	}
+	/** Encrypts and writes a plaintext frame. */
+	writeEncrypted(data) {
+		this.write(chacha20Encrypt(this.encryption, data));
+	}
+	#onData(data) {
+		try {
+			if (this.#encryptedBuffer.length + data.length > MAX_BUFFER_SIZE) throw new Error("Encrypted stream buffer limit exceeded.");
+			this.#encryptedBuffer = Buffer.concat([this.#encryptedBuffer, data]);
+			const decrypted = chacha20DecryptFrames(this.encryption, this.#encryptedBuffer);
+			this.#encryptedBuffer = Buffer.from(this.#encryptedBuffer.subarray(decrypted.consumed));
+			this.#buffer = Buffer.concat([this.#buffer, decrypted.data]);
+			if (this.#buffer.length > MAX_BUFFER_SIZE) throw new Error("Plaintext stream buffer limit exceeded.");
+			const consumed = this.receive(this.#buffer, data.byteLength);
+			this.#buffer = this.#buffer.subarray(consumed);
+		} catch (err) {
+			this.#reset();
+			this.context.logger.error(`[${this.constructor.name}]`, "Failed to read from the channel.", err);
+			this.destroy(err instanceof Error ? err : new Error(String(err)));
+		}
+	}
+	#reset() {
+		this.#buffer = Buffer.alloc(0);
+		this.#encryptedBuffer = Buffer.alloc(0);
+	}
+};
+
+//#endregion
+//#region src/channels/data.ts
+/** Size of the frame header in bytes. */
+const DATA_HEADER_LENGTH = 32;
+/** Largest frame we accept; anything bigger is a broken length field. */
+const MAX_FRAME_LENGTH = 16 * 1024 * 1024;
+/** MRP exchange timeout in milliseconds. */
+const EXCHANGE_TIMEOUT = 5e3;
+/**
+* The MRP channel: protobuf messages over the dedicated data socket. A 32-byte header wraps a
+* plist whose `params.data` holds varint-prefixed ProtocolMessages. {@link exchange} waits for the
+* reply with the same identifier, {@link send} expects none; every incoming message becomes an
+* event. Keys come from the pair-verify secret and the seed of the SETUP that announced the port.
+*/
+var DataChannel = class extends EncryptedChannel {
+	#outstanding = /* @__PURE__ */ new Map();
+	#seqno;
+	constructor(context, address, port, sharedSecret, seed) {
+		super(context, address, port, HKDF.deriveEncryptionKeys(sharedSecret, `DataStream-Salt${seed}`, "DataStream-Input-Encryption-Key", "DataStream-Output-Encryption-Key"));
+		this.#seqno = 4294967296n + BigInt(randomInt32());
+		this.on("closed", () => this.#rejectAll(new ConnectionClosedError()));
+		this.on("error", (error) => {
+			this.context.logger.error("[data]", "Data channel error.", error);
+			this.#rejectAll(error);
+		});
+	}
+	/**
+	* Sends a message and resolves with the reply that carries the same `identifier`, or the
+	* first message of the same type when the message has no identifier.
+	*
+	* @throws {TimeoutError} When no reply arrives in time.
+	* @throws {ConnectionClosedError} When the channel ends first.
+	*/
+	exchange(message, timeout = EXCHANGE_TIMEOUT) {
+		const protocolMessage = Array.isArray(message) ? message[0] : message;
+		const identifier = protocolMessage.identifier || `type_${protocolMessage.type}`;
+		if (this.signal.aborted) return Promise.reject(new ConnectionClosedError());
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.#outstanding.delete(identifier);
+				reject(new TimeoutError(`Exchange timed out for ${identifier}`));
+			}, timeout);
+			this.#outstanding.set(identifier, {
+				resolve,
+				reject,
+				timer
+			});
+			try {
+				this.send(message);
+			} catch (err) {
+				this.#outstanding.delete(identifier);
+				clearTimeout(timer);
+				reject(err);
+			}
+		});
+	}
+	/**
+	* Sends a message without waiting for a reply.
+	*
+	* @throws {ConnectionClosedError} When the channel has ended.
+	*/
+	send(message) {
+		if (this.signal.aborted) throw new ConnectionClosedError();
+		if (Array.isArray(message)) message = message[0];
+		const bytes = toBinary(ProtocolMessageSchema, message, { writeUnknownFields: true });
+		const payload = Buffer.concat([Buffer.from(encodeVarint(bytes.byteLength)), bytes]);
+		const plistPayload = Buffer.from(Plist.serialize({ params: { data: payload.buffer.slice(payload.byteOffset, payload.byteOffset + payload.byteLength) } }));
+		const header = buildHeader$1(DATA_HEADER_LENGTH + plistPayload.byteLength, this.#seqno++);
+		if (reporter.tapsTraffic || reporter.accepts("raw")) {
+			const decoded = describeProtocolMessage(message);
+			this.context.logger.raw("[data]", `Sending message. ${decoded.typeName}`, decoded);
+			this.#tap("out", decoded, bytes);
+		}
+		this.writeEncrypted(Buffer.concat([header, plistPayload]));
+	}
+	/** Frames are a 32-byte header and a plist payload. `sync` frames get a `rply`; `rply` frames only acknowledge transport. */
+	receive(plaintext, received) {
+		let offset = 0;
+		while (plaintext.byteLength - offset >= DATA_HEADER_LENGTH) {
+			const header = plaintext.subarray(offset, offset + DATA_HEADER_LENGTH);
+			const totalLength = header.readUint32BE();
+			if (totalLength < DATA_HEADER_LENGTH || totalLength > MAX_FRAME_LENGTH) throw new Error(`Invalid DataStream frame length: ${totalLength}`);
+			if (plaintext.byteLength - offset < totalLength) {
+				this.context.logger.debug("[data]", `Data packet is too short needed=${totalLength} available=${plaintext.byteLength - offset} receivedLength=${received}`);
+				break;
+			}
+			const frame = plaintext.subarray(offset + DATA_HEADER_LENGTH, offset + totalLength);
+			const plist = frame.length > 0 ? Plist.parse(frame.buffer.slice(frame.byteOffset, frame.byteOffset + frame.byteLength)) : null;
+			const command = header.toString("ascii", 4, 8);
+			offset += totalLength;
+			if (plist?.params?.data) for (const message of parseMessages(Buffer.from(plist.params.data))) {
+				if (reporter.tapsTraffic || reporter.accepts("raw")) {
+					const decoded = describeProtocolMessage(message);
+					this.context.logger.raw("[data]", `Received message. ${decoded.typeName}`, decoded);
+					this.#tap("in", decoded);
+				}
+				this.#handleMessage(message);
+			}
+			if (command === "sync") this.#reply(parseHeaderSeqno(header));
+		}
+		return offset;
+	}
+	#reply(seqno) {
+		this.context.logger.raw("[data]", `Sending reply packet seqno=${seqno}`);
+		this.writeEncrypted(buildReply(seqno));
+	}
+	/** Emits `rawMessage`, settles a matching exchange, then emits the typed event. */
+	#handleMessage(message) {
+		this.emit("rawMessage", message);
+		const identifier = message.identifier || `type_${message.type}`;
+		const outstanding = this.#outstanding.get(identifier);
+		if (outstanding) {
+			this.#outstanding.delete(identifier);
+			clearTimeout(outstanding.timer);
+			outstanding.resolve(message);
+		}
+		const kind = messageKind(message.type);
+		if (!kind) {
+			if (message.type !== 0) this.context.logger.warn("[data]", `Unknown message type ${message.type}.`);
+			return;
+		}
+		const { extension, name: event, level } = kind;
+		let decoded;
+		try {
+			decoded = getExtension(message, extension);
+		} catch (err) {
+			this.context.logger.error("[data]", `Failed to parse extension for message type ${message.type}:`, err);
+			return;
+		}
+		this.context.logger[level]("[data]", event, decoded);
+		try {
+			this.emit(event, decoded);
+		} catch (err) {
+			this.context.logger.error("[data]", `A listener for ${event} failed:`, err);
+		}
+	}
+	#rejectAll(error) {
+		for (const { reject, timer } of this.#outstanding.values()) {
+			clearTimeout(timer);
+			reject(error);
+		}
+		this.#outstanding.clear();
+	}
+	#tap(direction, decoded, bytes) {
+		if (!reporter.tapsTraffic) return;
+		this.context.logger.traffic("dataStream", direction, String(decoded.typeName), decoded, bytes);
+	}
+};
+
+//#endregion
+//#region src/playback/playQueue.ts
+/** Client type of the remote control stream (RCS) that carries play queue commands. */
+const RCS_CLIENT_TYPE_UUID = "A6B27562-B43A-4F2D-B75F-82391E250194";
+/** Channel suffixes tried in order for the RCS SETUP; macOS sends RCS-2. */
+const RCS_CHANNEL_SUFFIXES = ["RCS-1", "RCS-2"];
+/** Milliseconds to wait for the first `playing` state after `setRate`. */
+const START_TIMEOUT = 3e4;
+/** CMTime that marks a time as invalid, used for the pause times of a streaming item. */
+const INVALID_TIME = {
+	flags: 0,
+	value: 0,
+	epoch: 0,
+	timescale: 0
+};
+const FCUP_MAX_RESPONSE_SIZE = 8 * 1024 * 1024;
+const FCUP_MAX_SESSION_SIZE = 32 * 1024 * 1024;
+const FCUP_FETCH_TIMEOUT = 2e4;
+const FCUP_MAX_IN_FLIGHT = 4;
+const FCUP_SKIPPED_REQUEST_HEADERS = ["accept-encoding", "host"];
+const FCUP_SKIPPED_RESPONSE_HEADERS = [
+	"connection",
+	"content-encoding",
+	"content-length",
+	"keep-alive",
+	"transfer-encoding"
+];
+/**
+* URL playback through the receiver's play queue: a remote control stream on the control
+* connection carries the commands, the event stream reports the playback state back.
+* Also answers `unhandledURL` (FCUP) requests by fetching the URL on behalf of the receiver.
+*/
+var PlayQueueSession = class {
+	/** Stream ID the receiver assigned to the remote control stream, once set up. */
+	get streamId() {
+		return this.#streamId;
+	}
+	/** The last playback state the receiver reported. */
+	get state() {
+		return this.#state;
+	}
+	/** Playback info built from the last `playing` event, with the position extrapolated to now. */
+	get lastInfo() {
+		const playing = this.#playing;
+		if (!playing) return this.#state ? { state: this.#state } : {};
+		const isPlaying = this.#state === "playing";
+		let position = playing.position;
+		if (position !== void 0 && isPlaying) {
+			position += playing.rate * (performance.now() - playing.receivedAt) / 1e3;
+			if (playing.duration !== void 0) position = Math.min(position, playing.duration);
+		}
+		return {
+			duration: playing.duration,
+			position,
+			rate: isPlaying ? playing.rate : 0,
+			readyToPlay: true,
+			state: this.#state
+		};
+	}
+	#context;
+	#controlStream;
+	#sessionUUID;
+	#senderMac;
+	#fetchAbort = new AbortController();
+	#fetchWaiters = [];
+	#end;
+	#resolveEnd;
+	#rejectEnd;
+	#settled = false;
+	#started = false;
+	#fetchesInFlight = 0;
+	#fetchedBytes = 0;
+	#itemUUID;
+	#playing;
+	#startTimer;
+	#state;
+	#streamId;
+	/**
+	* @param controlStream - Encrypted control channel the commands go out on.
+	* @param eventStream - Event channel the receiver reports on.
+	* @param sessionUUID - Session UUID from the first SETUP, sent as `X-Apple-Session-ID`.
+	* @param senderMac - The `macAddress` sent in the first SETUP; prefix of the RCS channel ID.
+	*/
+	constructor(context, controlStream, eventStream, sessionUUID, senderMac) {
+		this.#context = context;
+		this.#controlStream = controlStream;
+		this.#sessionUUID = sessionUUID;
+		this.#senderMac = senderMac;
+		this.#end = new Promise((resolve, reject) => {
+			this.#resolveEnd = resolve;
+			this.#rejectEnd = reject;
+		});
+		this.#end.catch(() => void 0);
+		eventStream.on("playQueue", (command) => this.handleEvent(command));
+		eventStream.on("closed", () => this.#onStreamClose());
+		controlStream.on("closed", () => this.#onStreamClose());
+	}
+	/**
+	* Sets up the remote control stream (SETUP type 130), trying each channel suffix once.
+	*
+	* @returns `false` when the receiver refused every attempt, so the caller can fall back to `/play`.
+	*/
+	async setup() {
+		for (const suffix of RCS_CHANNEL_SUFFIXES) {
+			const streamId = await this.#setupStream(`${this.#senderMac}-${suffix}`);
+			if (streamId !== void 0) {
+				this.#streamId = streamId;
+				this.#context.logger.info("[play-queue]", `Remote control stream ${streamId} set up on channel ${suffix}.`);
+				return true;
+			}
+		}
+		return false;
+	}
+	/**
+	* Queues the URL and starts playback.
+	*
+	* @param url - Media URL the receiver loads.
+	* @param position - Start position in seconds.
+	* @returns `false` when the receiver answered `insertPlayQueueItem` with 4xx or 5xx, so the caller can fall back to `/play`.
+	* @throws {PlaybackError} When a later command fails or reports an `errorCode`.
+	*/
+	async start(url, position) {
+		const itemUUID = randomUUID().toUpperCase();
+		this.#itemUUID = itemUUID;
+		const insert = await this.#send({
+			type: "insertPlayQueueItem",
+			item: buildItem(itemUUID, url, position)
+		});
+		if (insert.status >= 400) {
+			this.#context.logger.warn("[play-queue]", `insertPlayQueueItem failed: ${insert.status}`);
+			return false;
+		}
+		await this.#check("insertPlayQueueItem", insert);
+		const commands = [
+			{
+				type: "setProperty",
+				property: "isInterestedInDateRange",
+				value: true,
+				item: { uuid: itemUUID }
+			},
+			{
+				type: "setProperty",
+				property: "actionAtItemEnd",
+				value: 1
+			},
+			{
+				type: "setRate",
+				rate: 1
+			}
+		];
+		for (const command of commands) await this.#check(String(command.type), await this.#send(command));
+		if (!this.#started && !this.#settled) this.#startTimer = setTimeout(() => this.#fail(new PlaybackError("Playback did not start within 30 seconds.")), START_TIMEOUT);
+		return true;
+	}
+	/**
+	* Handles a play queue command from the receiver. Bound to the event stream's `playQueue` event.
+	*
+	* @param command - The decoded `params.data` of the request.
+	*/
+	handleEvent(command) {
+		if (this.#settled) return;
+		if (command.kind === "request" && command.type === "unhandledURL") {
+			this.#answerUnhandledURL(command);
+			return;
+		}
+		if (command.type === "playbackState") this.#onPlaybackState(command);
+		else if (command.type === "notification") this.#onNotification(command);
+	}
+	/**
+	* Resolves when playback ends and rejects with a {@link PlaybackError} when it fails.
+	*
+	* @param signal - Stops waiting early, without an error, when aborted.
+	*/
+	async waitForEnd(signal) {
+		if (!signal) return await this.#end;
+		if (signal.aborted) return;
+		await new Promise((resolve, reject) => {
+			const onAbort = () => resolve();
+			signal.addEventListener("abort", onAbort, { once: true });
+			this.#end.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+		});
+	}
+	/** Ends the session: stops listening, aborts open fetches and resolves {@link waitForEnd}. */
+	close() {
+		this.#settle();
+	}
+	async #setupStream(channelID) {
+		const response = await this.#controlStream.setup(`/${this.#controlStream.sessionId}`, { streams: [{
+			type: 130,
+			controlType: 1,
+			channelID,
+			clientUUID: randomUUID().toUpperCase(),
+			clientTypeUUID: RCS_CLIENT_TYPE_UUID
+		}] });
+		if (response.status !== 200) {
+			this.#context.logger.warn("[play-queue]", `SETUP of remote control stream ${channelID} failed: ${response.status}`);
+			return;
+		}
+		const streamId = (parsePlist(await response.arrayBuffer())?.streams)?.[0]?.streamID;
+		if (typeof streamId !== "number" && typeof streamId !== "bigint") {
+			this.#context.logger.warn("[play-queue]", `SETUP of remote control stream ${channelID} returned no streamID.`);
+			return;
+		}
+		return Number(streamId);
+	}
+	async #send(command) {
+		if (this.#streamId === void 0) throw new PlaybackError("The remote control stream is not set up.");
+		return await this.#controlStream.command(this.#streamId, serializeCommand(command), this.#sessionUUID);
+	}
+	async #check(name, response) {
+		if (!response.ok) throw new PlaybackError(`Play queue command ${name} failed: ${response.status}`);
+		const body = parsePlist(await response.arrayBuffer());
+		const errorCode = (body ? decodeNestedCommand(body) ?? body : void 0)?.errorCode;
+		if (errorCode !== void 0 && errorCode !== 0) throw new PlaybackError(`Play queue command ${name} failed with errorCode ${String(errorCode)}.`);
+	}
+	#onPlaybackState(command) {
+		const params = isRecord(command.params) ? command.params : {};
+		const rawState = params.playbackState ?? command.name;
+		if (typeof rawState !== "string") return;
+		const state = rawState.toLowerCase();
+		const reason = params.reason ?? command.reason;
+		const position = this.lastInfo.position;
+		this.#state = state;
+		this.#context.logger.info("[play-queue]", `Playback state: ${state}${reason !== void 0 ? ` (${String(reason)})` : ""}`);
+		if (state === "playing") {
+			this.#started = true;
+			clearTimeout(this.#startTimer);
+			this.#playing = {
+				position: toSeconds(params.position),
+				duration: toSeconds(params.duration),
+				rate: toSeconds(params.rate) ?? 1,
+				receivedAt: performance.now()
+			};
+			return;
+		}
+		if (state === "paused" && this.#playing) {
+			this.#playing = {
+				...this.#playing,
+				position,
+				receivedAt: performance.now()
+			};
+			return;
+		}
+		if (state === "stopped" && this.#started) this.#settle();
+	}
+	#onNotification(command) {
+		const name = command.name;
+		this.#context.logger.debug("[play-queue]", `Notification: ${String(name)}`, command.params);
+		if (name === "itemPlayedToEnd") this.#settle();
+		else if (name === "itemFailedToPlayToEnd") this.#fail(new PlaybackError(`The receiver failed to play the item: ${describe(command.params)}`));
+	}
+	#onStreamClose() {
+		if (this.#settled) return;
+		if (this.#started) {
+			this.#context.logger.info("[play-queue]", "Stream closed, assuming playback ended.");
+			this.#settle();
+			return;
+		}
+		this.#fail(new PlaybackError("The connection closed before playback started."));
+	}
+	async #answerUnhandledURL(command) {
+		const request = isRecord(command.request) ? command.request : void 0;
+		const url = request?.FCUP_Response_URL;
+		const messageId = command.messageID;
+		if (!request || typeof url !== "string" || messageId === void 0) {
+			this.#context.logger.warn("[play-queue]", "Ignoring malformed unhandledURL request.", command);
+			return;
+		}
+		const reply = async (status, headers, data) => {
+			const response = await this.#send({
+				kind: "response",
+				messageID: messageId,
+				type: "unhandledURL",
+				response: {
+					FCUP_Response_URL: url,
+					FCUP_Response_RequestID: request.FCUP_Response_RequestID ?? 0,
+					FCUP_Response_StatusCode: status,
+					FCUP_Response_Headers: headers,
+					FCUP_Response_Data: data
+				}
+			});
+			if (!response.ok) this.#context.logger.warn("[play-queue]", `Receiver rejected the unhandledURL response: ${response.status}`);
+		};
+		try {
+			this.#context.logger.info("[play-queue]", `Receiver asks us to fetch ${url}`);
+			if (request.FCUP_Response_IsContentKeyRequest === true) {
+				await reply(501, {}, /* @__PURE__ */ new ArrayBuffer(0));
+				this.#fail(new PlaybackError(`The receiver asked for a FairPlay content key (${url}); protected content is not supported.`));
+				return;
+			}
+			if (!isHttpUrl(url)) {
+				await reply(403, {}, /* @__PURE__ */ new ArrayBuffer(0));
+				this.#fail(new PlaybackError(`The receiver asked to fetch ${url}; only http and https URLs are fetched.`));
+				return;
+			}
+			let result;
+			try {
+				result = await this.#fetch(url, requestHeaders(request.FCUP_Response_Headers));
+			} catch (err) {
+				if (this.#settled) return;
+				this.#context.logger.warn("[play-queue]", `Failed to fetch ${url} for the receiver.`, err);
+				await reply(502, {}, /* @__PURE__ */ new ArrayBuffer(0));
+				this.#fail(new PlaybackError(`Could not fetch ${url} for the receiver: ${err.message}`));
+				return;
+			}
+			if (this.#settled) return;
+			this.#context.logger.info("[play-queue]", `Fetched ${url} for the receiver: ${result.status} (${result.data.byteLength} bytes)`);
+			if (result.status >= 200 && result.status < 300 && !isPlaylist(result.data)) this.#context.logger.warn("[play-queue]", `${url} is not an HLS playlist; the receiver will probably not play it.`);
+			await reply(result.status, result.headers, result.data);
+		} catch (err) {
+			this.#context.logger.error("[play-queue]", `Failed to answer the unhandledURL request for ${url}.`, err);
+		}
+	}
+	async #fetch(url, headers) {
+		await this.#acquireFetchSlot();
+		try {
+			const signal = AbortSignal.any([this.#fetchAbort.signal, AbortSignal.timeout(FCUP_FETCH_TIMEOUT)]);
+			signal.throwIfAborted();
+			const response = await fetch(url, {
+				headers,
+				redirect: "follow",
+				signal
+			});
+			const data = await this.#readBody(response);
+			const replyHeaders = {};
+			response.headers.forEach((value, key) => {
+				if (!FCUP_SKIPPED_RESPONSE_HEADERS.includes(key.toLowerCase())) replyHeaders[key] = value;
+			});
+			replyHeaders["Content-Length"] = String(data.byteLength);
+			return {
+				status: response.status,
+				headers: replyHeaders,
+				data
+			};
+		} finally {
+			this.#releaseFetchSlot();
+		}
+	}
+	async #readBody(response) {
+		const declaredLength = Number(response.headers.get("content-length") ?? 0);
+		if (declaredLength > FCUP_MAX_RESPONSE_SIZE) {
+			await response.body?.cancel();
+			throw new PlaybackError(`Response too large (${declaredLength} bytes).`);
+		}
+		const reader = response.body?.getReader();
+		if (!reader) return /* @__PURE__ */ new ArrayBuffer(0);
+		const chunks = [];
+		let length = 0;
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			length += value.byteLength;
+			this.#fetchedBytes += value.byteLength;
+			if (length > FCUP_MAX_RESPONSE_SIZE || this.#fetchedBytes > FCUP_MAX_SESSION_SIZE) {
+				await reader.cancel();
+				throw new PlaybackError(length > FCUP_MAX_RESPONSE_SIZE ? `Response larger than ${FCUP_MAX_RESPONSE_SIZE} bytes.` : `Fetched more than ${FCUP_MAX_SESSION_SIZE} bytes in this session.`);
+			}
+			chunks.push(value);
+		}
+		const data = new Uint8Array(length);
+		let offset = 0;
+		for (const chunk of chunks) {
+			data.set(chunk, offset);
+			offset += chunk.byteLength;
+		}
+		return data.buffer;
+	}
+	async #acquireFetchSlot() {
+		if (this.#fetchesInFlight < FCUP_MAX_IN_FLIGHT) {
+			this.#fetchesInFlight++;
+			return;
+		}
+		await new Promise((resolve) => this.#fetchWaiters.push(resolve));
+	}
+	#releaseFetchSlot() {
+		const next = this.#fetchWaiters.shift();
+		if (next) next();
+		else this.#fetchesInFlight--;
+	}
+	#fail(error) {
+		if (this.#settled) return;
+		this.#context.logger.error("[play-queue]", error.message);
+		this.#rejectEnd(error);
+		this.#settle();
+	}
+	#settle() {
+		if (this.#settled) return;
+		this.#settled = true;
+		clearTimeout(this.#startTimer);
+		this.#resolveEnd();
+		this.#fetchAbort.abort();
+		for (const waiter of this.#fetchWaiters.splice(0)) {
+			this.#fetchesInFlight++;
+			waiter();
+		}
+		this.#context.logger.debug("[play-queue]", `Session for item ${this.#itemUUID ?? "?"} ended.`);
+	}
+};
+/**
+* Decodes the binary plist in `params.data` of a `POST /command` body.
+*
+* @returns The inner command, or undefined when the body carries none.
+*/
+function decodeNestedCommand(body) {
+	if (!isRecord(body) || !isRecord(body.params) || !isBinaryPlist(body.params.data)) return;
+	return parsePlist(body.params.data) ?? void 0;
+}
+/**
+* Picks the item's `mediaType`, `streaming` for an HLS playlist. macOS sends `streaming` for HLS,
+* and third party receivers keep a live playlist in `loading` as `file`. Apple TV is not verified
+* with `streaming`.
+*/
+function mediaTypeFor(url) {
+	try {
+		return new URL(url).pathname.toLowerCase().endsWith(".m3u8") ? "streaming" : "file";
+	} catch {
+		return "file";
+	}
+}
+function buildItem(itemUUID, url, position) {
+	const mediaType = mediaTypeFor(url);
+	const item = {
+		uuid: itemUUID,
+		"Content-Location": url,
+		mediaType,
+		"Start-Position": {
+			flags: 1,
+			value: Math.round(position * 1e3),
+			epoch: 0,
+			timescale: 1e3
+		}
+	};
+	if (mediaType === "streaming") {
+		item.timeToPausePlayback = INVALID_TIME;
+		item.timeToPauseBuffering = INVALID_TIME;
+	}
+	return item;
+}
+/**
+* Serializes a command to the binary plist that goes in `params.data`. With {@link RATE_AS_REAL}, a
+* whole `setRate` rate is written with a placeholder real whose bytes are then overwritten.
+*/
+function serializeCommand(command) {
+	const rate = command.rate;
+	if (command.type !== "setRate" || typeof rate !== "number" || !Number.isInteger(rate)) return Plist.serialize(command);
+	const placeholder = .25;
+	const data = Plist.serialize({
+		...command,
+		rate: placeholder
+	});
+	const view = new DataView(data);
+	for (let offset = 0; offset + 9 <= data.byteLength; offset++) if (view.getUint8(offset) === 35 && view.getFloat64(offset + 1) === placeholder) {
+		view.setFloat64(offset + 1, rate);
+		return data;
+	}
+	throw new PlaybackError("Could not encode the playback rate.");
+}
+function requestHeaders(headers) {
+	const result = {};
+	if (!isRecord(headers)) return result;
+	for (const [key, value] of Object.entries(headers)) if (!FCUP_SKIPPED_REQUEST_HEADERS.includes(key.toLowerCase())) result[key] = String(value);
+	return result;
+}
+/** Reads a number or a CMTime dictionary (`value` / `timescale`) as seconds. */
+function toSeconds(value) {
+	if (typeof value === "number") return value;
+	if (isRecord(value) && typeof value.value === "number" && typeof value.timescale === "number" && value.timescale > 0) return value.value / value.timescale;
+}
+function isHttpUrl(url) {
+	try {
+		const protocol = new URL(url).protocol;
+		return protocol === "http:" || protocol === "https:";
+	} catch {
+		return false;
+	}
+}
+function isPlaylist(data) {
+	return Buffer.from(data, 0, Math.min(data.byteLength, 64)).toString("utf8").trimStart().startsWith("#EXTM3U");
+}
+function isBinaryPlist(data) {
+	return data instanceof ArrayBuffer && data.byteLength >= 8 && Buffer.from(data, 0, 8).toString("latin1") === "bplist00";
+}
+function parsePlist(data) {
+	if (data.byteLength === 0) return;
+	try {
+		const value = Plist.parse(data);
+		return isRecord(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof ArrayBuffer);
+}
+function describe(value) {
+	try {
+		return JSON.stringify(value) ?? "unknown error";
+	} catch {
+		return String(value);
+	}
+}
+
+//#endregion
+//#region src/channels/event.ts
+/**
+* The reverse RTSP channel: the receiver is the client here and we answer its requests. Every
+* request gets `200 OK`; `POST /command` bodies become events.
+*/
+var EventChannel = class extends EncryptedChannel {
+	constructor(context, address, port, sharedSecret) {
+		super(context, address, port, eventKeys(sharedSecret));
+	}
+	/** Sends a response to a request of the receiver. */
+	respond(status, statusText, headers, body) {
+		const data = buildResponse({
+			status,
+			statusText,
+			headers,
+			body
+		});
+		this.context.logger.traffic("eventStream", "out", `${status} ${statusText}`, { headers }, data);
+		this.writeEncrypted(data);
+	}
+	receive(plaintext) {
+		let offset = 0;
+		while (plaintext.byteLength > offset) {
+			const result = parseRequest(plaintext.subarray(offset));
+			if (result === null) break;
+			if (reporter.tapsTraffic) this.context.logger.traffic("eventStream", "in", `${result.method} ${result.path}`, {
+				headers: result.headers,
+				body: withNestedCommand(decodePlist(result.body))
+			}, Buffer.from(plaintext.subarray(offset, offset + result.requestLength)));
+			offset += result.requestLength;
+			this.#handle(result.method, result.path, result.headers, result.body);
+		}
+		return offset;
+	}
+	#handle(method, path, headers, body) {
+		const key = `${method} ${path}`;
+		if (key !== "POST /command") {
+			this.context.logger.warn("[event]", "No handler for url", key);
+			this.respond(200, "OK", { "CSeq": headers["CSeq"] ?? 0 });
+			return;
+		}
+		const data = Plist.parse(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
+		const commandType = data.type;
+		this.context.logger.info("[event]", "Received command:", commandType ?? "unknown", data);
+		this.emit("command", data);
+		if (commandType === "cycleUsePickedRoute" || commandType === "duckAudio") this.emit("duckAudio", data);
+		else if (commandType === "unduckAudio") this.emit("unduckAudio", data);
+		else if (commandType === "died") this.emit("sessionDied");
+		this.respond(200, "OK", {
+			"Audio-Latency": 0,
+			"CSeq": headers["CSeq"] ?? 0
+		});
+		const playQueueCommand = decodeNestedCommand(data);
+		if (playQueueCommand) {
+			this.context.logger.info("[event]", "Received play queue command:", playQueueCommand.type ?? "unknown", playQueueCommand);
+			this.emit("playQueue", playQueueCommand);
+		}
+	}
+};
+/**
+* The HKDF infos are named from the receiver's side, because the receiver originates this
+* connection. The keys are swapped on purpose: `Events-Write-Encryption-Key` is what the
+* receiver writes, which we read.
+*/
+function eventKeys(sharedSecret) {
+	const { readKey, writeKey } = HKDF.deriveEncryptionKeys(sharedSecret, "Events-Salt", "Events-Read-Encryption-Key", "Events-Write-Encryption-Key");
+	return {
+		readKey: writeKey,
+		writeKey: readKey
+	};
+}
+function decodePlist(body) {
+	if (body.byteLength === 0) return;
+	try {
+		return Plist.parse(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
+	} catch {
+		return;
+	}
+}
+/** Replaces the binary plist in `params.data` by its decoded command, for the traffic sink. */
+function withNestedCommand(body) {
+	const command = decodeNestedCommand(body);
+	if (!command) return body;
+	const outer = body;
+	return {
+		...outer,
+		params: {
+			...outer.params,
+			data: command
+		}
+	};
+}
+
+//#endregion
+//#region src/info.ts
+/**
+* Fetches `/info`. A status other than 200 is not an error: what an earlier `/info` said stays, and
+* without one the receiver has no features and SETUP bodies carry our own source version. Fields
+* the answer lacks keep their earlier value too.
+*/
+async function fetchInfo(control, context, previous) {
+	const ourVersion = String(resolveIdentity(context).sourceVersion);
+	const response = await control.get("/info");
+	if (response.status !== 200) {
+		context.logger.warn("[protocol]", `GET /info failed: ${response.status}`);
+		return previous ?? {
+			info: {},
+			features: 0n,
+			sourceVersion: ourVersion
+		};
+	}
+	const info = Plist.parse(await response.arrayBuffer());
+	const receiverVersion = info.sourceVersion;
+	const features = info.features != null || info.featuresEx != null ? parseReceiverFeatures(info) : previous?.features ?? 0n;
+	context.logger.info("[protocol]", `Receiver: ${info.name ?? "unknown"}, model=${info.model ?? "?"}, sourceVersion=${receiverVersion ?? "?"}`);
+	context.logger.info("[protocol]", `Receiver features: ${describeFlags(features).join(", ")}`);
+	if (info.initialVolume != null) context.logger.info("[protocol]", `Receiver initial volume: ${info.initialVolume}`);
+	if (receiverVersion && compareVersions(ourVersion, receiverVersion) > 0) {
+		context.logger.info("[protocol]", `Capping sourceVersion from ${ourVersion} to ${receiverVersion}`);
+		return {
+			info,
+			features,
+			sourceVersion: receiverVersion
+		};
+	}
+	return {
+		info,
+		features,
+		sourceVersion: previous?.sourceVersion ?? ourVersion
+	};
+}
+function compareVersions(a, b) {
+	const pa = a.split(".").map(Number);
+	const pb = b.split(".").map(Number);
+	for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+		const na = pa[i] ?? 0;
+		const nb = pb[i] ?? 0;
+		if (na !== nb) return na - nb;
+	}
+	return 0;
+}
+
+//#endregion
+//#region src/pairing.ts
+/** Posts each pairing message as an octet-stream body; the HTTP status is not checked, the TLV carries errors. */
+function rtspTransport(control, path, hkp) {
+	return async (payload) => {
+		const response = await control.post(path, payload, {
+			"Content-Type": "application/octet-stream",
+			"X-Apple-HKP": hkp.toString()
+		});
+		return Buffer.from(await response.arrayBuffer());
+	};
+}
+/** `/pair-pin-start` goes first for both a PIN and a transient pairing. */
+async function pinStart(control, hkp) {
+	const response = await control.post("/pair-pin-start", null, {
+		"Content-Type": "application/octet-stream",
+		"X-Apple-HKP": hkp.toString()
+	});
+	if (response.status !== 200) throw new PairingError(`Cannot start pairing session. ${response.status} ${response.statusText} ${await response.text()}`);
+}
+/** Pair-verify over `/pair-verify`, followed by the control keys. */
+async function verifyPairing(control, context, credentials) {
+	const keys = await new PairVerify(context, rtspTransport(control, "/pair-verify", 3)).start(credentials);
+	return {
+		...deriveControlKeys(keys.sharedSecret),
+		pairingId: keys.pairingId,
+		sharedSecret: keys.sharedSecret
+	};
+}
+/** Pair-setup M1 to M4 with the transient flag, for receivers that need no PIN (HomePod). */
+async function transientPairing(control, context) {
+	const setup = new PairSetup(context, rtspTransport(control, "/pair-setup", 4));
+	await setup.start();
+	await pinStart(control, 4);
+	return await setup.transient();
+}
+/**
+* Starts a PIN pairing: connects, fetches `/info` and asks the receiver to show its PIN. Finish
+* with {@link PinPairing.pin}, which runs pair-setup M1 to M6 and returns the long-term credentials.
+*
+* @throws {PairingError} When the receiver refuses to start pairing.
+*/
+async function pair(target, options = {}) {
+	const context = options.context ?? new Context(target.id ?? target.address, options.identity);
+	const control = new ControlChannel(context, target.address, target.port ?? 7e3);
+	const interrupt = () => control.destroy();
+	options.signal?.addEventListener("abort", interrupt, {
+		once: true,
+		signal: control.signal
+	});
+	try {
+		await control.connect();
+		await fetchInfo(control, context);
+		const setup = new PairSetup(context, rtspTransport(control, "/pair-setup", 3));
+		await setup.start();
+		await pinStart(control, 3);
+		return new PinPairing(control, setup);
+	} catch (err) {
+		control.destroy();
+		throw options.signal?.aborted ? new ConnectionClosedError("Pairing was interrupted.") : err;
+	}
+}
+/** A PIN pairing whose PIN the receiver shows now. One connection, used once. */
+var PinPairing = class {
+	/** Aborts when the pairing connection closes. */
+	get signal() {
+		return this.#control.signal;
+	}
+	#control;
+	#setup;
+	constructor(control, setup) {
+		this.#control = control;
+		this.#setup = setup;
+	}
+	/**
+	* Runs pair-setup M1 to M6 with the PIN from the screen. A wrong PIN leaves the connection
+	* open; call {@link close} when giving up.
+	*
+	* @throws {PairingError} When a step fails or the PIN is wrong.
+	*/
+	async pin(code) {
+		const m1 = await this.#setup.m1();
+		const m2 = await this.#setup.m2(m1, code);
+		const m3 = await this.#setup.m3(m2);
+		const m4 = await this.#setup.m4(m3);
+		const m5 = await this.#setup.m5(m4);
+		const credentials = await this.#setup.m6(m4, m5);
+		if (!credentials) throw new PairingError("Pairing failed: could not obtain credentials.");
+		return credentials;
+	}
+	/** Closes the pairing connection. */
+	close() {
+		this.#control.destroy();
+	}
+};
+
+//#endregion
+//#region src/playback/playback.ts
+/** Maximum number of attempts of `POST /play` while it answers 500. */
+const PLAY_RETRIES = 3;
+/** Interval in milliseconds between `/playback-info` polls. */
+const PLAYBACK_POLL_INTERVAL = 1e3;
+/** Number of consecutive polls without a duration before playback counts as ended. */
+const PLAYBACK_IDLE_THRESHOLD = 5;
+/** CMTime with all fields zero, which the receiver reads as "no end time". */
+const NO_END_TIME = {
+	flags: 0,
+	value: 0,
+	epoch: 0,
+	timescale: 0
+};
+/**
+* A URL the receiver fetches and plays itself, on a connection of its own so remote control stays
+* untouched. Through the play queue when the receiver has one, otherwise `/play`.
+* Owns its session: {@link stop} and the end of playback close it.
+*/
+var UrlPlayback = class UrlPlayback {
+	/**
+	* Resolves when playback ends, then closes the connection; rejects with a {@link PlaybackError}
+	* when the receiver reports a playback error. A play queue session follows its events.
+	* Otherwise the first read starts polling `/playback-info`: playback starts with the first
+	* answer that has a duration and ends after {@link PLAYBACK_IDLE_THRESHOLD} answers in a row
+	* without one, or when the receiver stops answering. A consumer that never reads this sends
+	* no polls.
+	*/
+	get ended() {
+		this.#ended ??= this.#waitForEnd();
+		return this.#ended;
+	}
+	/** Aborts when the playback's connection closes. */
+	get signal() {
+		return this.#session.signal;
+	}
+	#channels;
+	#session;
+	#playQueue;
+	#ended;
+	constructor(channels, playQueue) {
+		this.#channels = channels;
+		this.#session = channels.session;
+		this.#playQueue = playQueue;
+		this.#session.signal.addEventListener("abort", () => {
+			if (this.#session.closeReason === "local") this.#playQueue?.close();
+		}, { once: true });
+	}
+	/**
+	* Starts playback after RECORD: through the play queue when the receiver supports it, else
+	* with `POST /play`, retrying 500 responses.
+	*
+	* @throws {PlaybackError} When playback fails, or the play queue fails on a receiver without `/play`.
+	*/
+	static async start(channels, url, position) {
+		const playQueue = await startPlayQueue(channels, url, position);
+		if (playQueue) return new UrlPlayback(channels, playQueue);
+		await playLegacy(channels, url, position);
+		return new UrlPlayback(channels);
+	}
+	/**
+	* The current playback info. A play queue session answers from its last `playing` event,
+	* because `GET /playback-info` fails there (500 on tvOS 26, 403 on tvOS 27).
+	*
+	* @returns Empty when nothing plays, null when the receiver did not answer.
+	*/
+	async getPlaybackInfo() {
+		if (this.#playQueue) return this.#playQueue.lastInfo;
+		try {
+			const response = await this.#channels.control.get("/playback-info");
+			if (!response.ok) return null;
+			const body = await response.arrayBuffer();
+			if (body.byteLength === 0) return {};
+			return Plist.parse(body);
+		} catch {
+			return null;
+		}
+	}
+	async #waitForEnd() {
+		try {
+			if (this.#playQueue) await this.#playQueue.waitForEnd();
+			else await this.#poll();
+		} finally {
+			this.#session.close();
+		}
+	}
+	/** Stops playback and closes the connection, without TEARDOWN. */
+	stop() {
+		this.#playQueue?.close();
+		this.#session.close();
+	}
+	async #poll() {
+		const logger = this.#channels.context.logger;
+		let playbackStarted = false;
+		let idleCount = 0;
+		while (true) {
+			const info = await this.getPlaybackInfo();
+			if (!info) {
+				logger.debug("[protocol]", "Connection lost, assuming playback stopped.");
+				return;
+			}
+			if (info.error) throw new PlaybackError(`Playback error: ${info.error.code} (${info.error.domain})`);
+			if (info.duration !== void 0) {
+				playbackStarted = true;
+				idleCount = 0;
+			} else if (playbackStarted) {
+				idleCount++;
+				if (idleCount >= PLAYBACK_IDLE_THRESHOLD) {
+					logger.debug("[protocol]", "Playback ended.");
+					return;
+				}
+			}
+			await waitFor(PLAYBACK_POLL_INTERVAL);
+		}
+	}
+};
+/**
+* Queues the URL through the play queue when the receiver advertises one.
+*
+* @returns The running play queue, or undefined when `/play` should be used instead.
+* @throws {PlaybackError} When the play queue fails on a receiver that has no `/play`.
+*/
+async function startPlayQueue(channels, url, position) {
+	const { context, features } = channels;
+	const playQueue = hasFeatureFlag(features, AirPlayFeatureFlags.SupportsAirPlayVideoPlayQueue);
+	const videoV2 = hasFeatureFlag(features, AirPlayFeatureFlags.SupportsAirPlayVideoV2);
+	const videoV1 = hasFeatureFlag(features, AirPlayFeatureFlags.SupportsAirPlayVideoV1);
+	const bits = `VideoPlayQueue=${playQueue}, VideoV2=${videoV2}, VideoV1=${videoV1}`;
+	if (!playQueue && !videoV2) {
+		context.logger.info("[protocol]", `playUrl via /play (${bits})`);
+		return;
+	}
+	context.logger.info("[protocol]", `playUrl via play queue (${bits})`);
+	const session = new PlayQueueSession(context, channels.control, channels.events, channels.sessionUUID, channels.senderMac);
+	try {
+		if (await session.setup() && await session.start(url, position)) return session;
+	} catch (err) {
+		session.close();
+		throw err;
+	}
+	session.close();
+	if (videoV2 && !videoV1) throw new PlaybackError("The play queue failed and this receiver does not support /play.");
+	context.logger.warn("[protocol]", `Play queue failed, falling back to /play (${bits})`);
+}
+/** `POST /play`, retrying 500 responses because the receiver may need time to prepare, then the playback properties. */
+async function playLegacy(channels, url, position) {
+	const { context, control } = channels;
+	const identity = resolveIdentity(context);
+	let lastStatus = 0;
+	for (let retry = 0; retry < PLAY_RETRIES; retry++) {
+		lastStatus = (await control.post("/play", {
+			"Content-Location": url,
+			"Start-Position-Seconds": position,
+			uuid: channels.sessionUUID.toUpperCase(),
+			streamType: 1,
+			mediaType: "file",
+			volume: 1,
+			rate: 1,
+			clientBundleID: "com.basmilius.apple-protocols",
+			clientProcName: identity.name,
+			osBuildVersion: identity.osBuildVersion,
+			model: identity.model,
+			SenderMACAddress: getMacAddress().toUpperCase()
+		})).status;
+		context.logger.info("[protocol]", `play_url response: ${lastStatus} (attempt ${retry + 1}/${PLAY_RETRIES})`);
+		if (lastStatus === 200) break;
+		if (lastStatus === 500) {
+			context.logger.warn("[protocol]", "play_url returned 500, retrying...");
+			await waitFor(1e3);
+			continue;
+		}
+		if (lastStatus >= 400) throw new PlaybackError(`Failed to play URL: ${lastStatus}`);
+	}
+	if (lastStatus !== 200) throw new PlaybackError(`Failed to play URL after ${PLAY_RETRIES} retries: ${lastStatus}`);
+	await control.put("/setProperty?isInterestedInDateRange", { value: true });
+	await control.put("/setProperty?actionAtItemEnd", { value: 0 });
+	await control.post("/rate?value=1.000000");
+	await control.put("/setProperty?forwardEndTime", { value: NO_END_TIME });
+	await control.put("/setProperty?reverseEndTime", { value: NO_END_TIME });
+}
+
+//#endregion
+//#region src/timing/ntp.ts
+/**
+* NTP timing server for AirPlay audio synchronization.
+*
+* During audio streaming, Apple devices send NTP timing requests to sync their
+* clock with the controller. The server answers with the current wall-clock
+* time, from which the device derives the playback offset for multiroom audio.
+* It uses `Date.now()`, not the monotonic `process.hrtime`, because NTP
+* timestamps are anchored to the Unix epoch.
+*/
+var TimingServer = class {
+	/** The UDP port the timing server is listening on, or 0 if not yet bound. */
+	get port() {
+		return this.#port;
+	}
+	#logger;
+	#socket;
+	#port = 0;
+	/** @param options.logger - Receives the errors of the server; a `timing-server` logger when omitted. */
+	constructor(options = {}) {
+		this.#logger = options.logger ?? new Logger("timing-server");
+		this.#socket = createSocket("udp4");
+		this.onError = this.onError.bind(this);
+		this.onMessage = this.onMessage.bind(this);
+		this.#socket.on("error", this.onError);
+		this.#socket.on("message", this.onMessage);
+	}
+	/** Closes the UDP socket and resets the port. */
+	close() {
+		try {
+			this.#socket.close();
+		} catch {}
+		this.#port = 0;
+	}
+	/**
+	* Binds the UDP socket to a random free port and starts answering NTP
+	* timing requests. Rejects when the socket fails to bind.
+	*/
+	listen() {
+		return new Promise((resolve, reject) => {
+			const onError = (err) => {
+				this.#socket.removeListener("listening", onListening);
+				reject(err);
+			};
+			const onListening = () => {
+				this.#socket.removeListener("error", onError);
+				this.#onListening();
+				resolve();
+			};
+			this.#socket.once("error", onError);
+			this.#socket.once("listening", onListening);
+			this.#socket.bind(0);
+		});
+	}
+	onError(err) {
+		this.#logger.error("Timing server error", err);
+	}
+	#onListening() {
+		const { port } = this.#socket.address();
+		this.#port = port;
+	}
+	/**
+	* Answers an NTP timing request. The reference timestamp echoes the send
+	* time of the request; receive and send time are both now.
+	*/
+	onMessage(data, info) {
+		try {
+			const request = NTP.decode(data);
+			const ntp = NTP.now();
+			const [receivedSeconds, receivedFraction] = NTP.parts(ntp);
+			this.#logger.info(`Timing server ntp=${ntp} receivedSeconds=${receivedSeconds} receivedFraction=${receivedFraction}`);
+			const response = NTP.encode({
+				proto: request.proto,
+				type: 211,
+				seqno: request.seqno,
+				padding: 0,
+				reftime_sec: request.sendtime_sec,
+				reftime_frac: request.sendtime_frac,
+				recvtime_sec: receivedSeconds,
+				recvtime_frac: receivedFraction,
+				sendtime_sec: receivedSeconds,
+				sendtime_frac: receivedFraction
+			});
+			this.#socket.send(response, info.port, info.address, (err) => {
+				if (!err) return;
+				this.#logger.warn(`Timing server failed to send response to ${info.address}:${info.port}`, err);
+			});
+		} catch (err) {
+			this.#logger.warn(`Timing server received malformed packet (${data.length} bytes) from ${info.address}:${info.port}`, err);
+		}
+	}
+};
+
+//#endregion
+//#region src/timing/ptp/clockIdentity.ts
+/**
+* Generates an 8-byte EUI-64 clock identity from this machine's MAC-48 address,
+* for PTPv2 `sourcePortIdentity.clockIdentity`. The bytes `0xFF 0xFE` go
+* between the OUI (first three octets) and the NIC-specific part.
+*/
+function generateClockIdentity() {
+	const mac = Buffer.from(getMacAddress().replace(/:/g, ""), "hex");
+	const id = Buffer.alloc(8);
+	mac.copy(id, 0, 0, 3);
+	id[3] = 255;
+	id[4] = 254;
+	mac.copy(id, 5, 3, 6);
+	return id;
+}
+
+//#endregion
+//#region src/timing/ptp/header.ts
+/** Byte length of a PTPv2 common message header. */
+const PTP_HEADER_LENGTH = 34;
+/** PTPv2 protocol version written into every header. */
+const PTP_VERSION = 2;
+/**
+* Encodes the fields of a PTPv2 common header into a 34-byte buffer.
+* Reserved bytes stay zero, as macOS and iOS senders write them.
+*/
+function encodeHeader(fields) {
+	const buf = Buffer.alloc(34);
+	buf[0] = fields.messageType & 15 | (fields.transportSpecific & 15) << 4;
+	buf[1] = 2;
+	buf.writeUInt16BE(fields.messageLength, 2);
+	buf[4] = fields.domainNumber;
+	buf.writeUInt16BE(fields.flags, 6);
+	buf.writeBigInt64BE(fields.correctionField, 8);
+	fields.sourcePortIdentity.copy(buf, 20, 0, 10);
+	buf.writeUInt16BE(fields.sequenceId, 30);
+	buf[32] = fields.controlField;
+	buf.writeInt8(fields.logMessageInterval, 33);
+	return buf;
+}
+/**
+* Decodes a PTPv2 common header from the first 34 bytes of the buffer.
+*/
+function decodeHeader(buf) {
+	return {
+		messageType: buf[0] & 15,
+		transportSpecific: buf[0] >> 4 & 15,
+		messageLength: buf.readUInt16BE(2),
+		domainNumber: buf[4],
+		flags: buf.readUInt16BE(6),
+		correctionField: buf.readBigInt64BE(8),
+		sourcePortIdentity: Buffer.from(buf.subarray(20, 30)),
+		sequenceId: buf.readUInt16BE(30),
+		controlField: buf[32],
+		logMessageInterval: buf.readInt8(33)
+	};
+}
+
+//#endregion
+//#region src/timing/ptp/timestamp.ts
+/**
+* Captures the current wall-clock time as a {@link PtpTimestamp}.
+*
+* Uses {@link Date.now}, not the monotonic {@link process.hrtime.bigint},
+* because PTP timestamps are anchored to the Unix epoch, as with {@link NTP.now}.
+*/
+function ptpNow() {
+	const nowMs = BigInt(Date.now());
+	const seconds = nowMs / 1000n;
+	return {
+		seconds,
+		nanoseconds: Number((nowMs - seconds * 1000n) * 1000000n)
+	};
+}
+/**
+* Encodes a {@link PtpTimestamp} into the 10-byte PTP wire format:
+* 48-bit seconds (big-endian) followed by 32-bit nanoseconds (big-endian).
+*/
+function encodeTimestamp(ts) {
+	const buf = Buffer.alloc(10);
+	const high = Number(ts.seconds >> 32n & 65535n);
+	const low = Number(ts.seconds & 4294967295n);
+	buf.writeUInt16BE(high, 0);
+	buf.writeUInt32BE(low, 2);
+	buf.writeUInt32BE(ts.nanoseconds, 6);
+	return buf;
+}
+/**
+* Decodes a 10-byte PTP timestamp from the buffer at the given offset.
+*/
+function decodeTimestamp(buf, offset) {
+	const high = BigInt(buf.readUInt16BE(offset));
+	const low = BigInt(buf.readUInt32BE(offset + 2));
+	const nanoseconds = buf.readUInt32BE(offset + 6);
+	return {
+		seconds: high << 32n | low,
+		nanoseconds
+	};
+}
+
+//#endregion
+//#region src/timing/ptp/tlv.ts
+/** IEEE 1588-2008 standard TLV types used on the wire. */
+const TlvType = {
+	Management: 1,
+	OrganizationExtension: 3,
+	RequestUnicastTransmission: 4,
+	GrantUnicastTransmission: 5,
+	CancelUnicastTransmission: 6,
+	AcknowledgeCancelUnicastTransmission: 7
+};
+/** IEEE 802.1AS Apple-gPTP Organization ID (00:80:C2 = IEEE 802). */
+const IEEE_802_1_ORGANIZATION_ID = Buffer.from([
+	0,
+	128,
+	194
+]);
+/** Organization sub-type identifier for the 802.1AS FollowUpInformation TLV. */
+const FOLLOW_UP_INFORMATION_SUBTYPE = 1;
+/** Organization sub-type identifier for the 802.1AS MessageIntervalRequest TLV. */
+const MESSAGE_INTERVAL_REQUEST_SUBTYPE = 2;
+/**
+* Encodes an IEEE 802.1AS FollowUpInformation TLV (subtype 1), including the
+* 4-byte TLV header. It trails every FollowUp body. A sender-only role sends
+* zeros, as macOS senders do.
+*
+* @param cumulativeScaledRateOffset - Written as u32 BE.
+* @param gmTimeBaseIndicator - Written as u16 BE.
+* @param lastGmPhaseChange - 12 bytes of scaled nanoseconds in fixed point.
+* @param scaledLastGmFreqChange - Written as u32 BE.
+*/
+function encodeFollowUpInfoTlv(cumulativeScaledRateOffset = 0, gmTimeBaseIndicator = 0, lastGmPhaseChange = Buffer.alloc(12), scaledLastGmFreqChange = 0) {
+	if (lastGmPhaseChange.length !== 12) throw new Error("lastGmPhaseChange must be exactly 12 bytes.");
+	const payload = Buffer.alloc(26);
+	IEEE_802_1_ORGANIZATION_ID.copy(payload, 0);
+	payload[3] = FOLLOW_UP_INFORMATION_SUBTYPE;
+	payload.writeUInt32BE(cumulativeScaledRateOffset, 4);
+	payload.writeUInt16BE(gmTimeBaseIndicator, 8);
+	lastGmPhaseChange.copy(payload, 10);
+	payload.writeUInt32BE(scaledLastGmFreqChange, 22);
+	const tlv = Buffer.alloc(4 + payload.length);
+	tlv.writeUInt16BE(TlvType.OrganizationExtension, 0);
+	tlv.writeUInt16BE(payload.length, 2);
+	payload.copy(tlv, 4);
+	return tlv;
+}
+/**
+* Encodes an IEEE 802.1AS MessageIntervalRequest TLV (subtype 2), including
+* the 4-byte TLV header. A Signaling message carries it to ask the peer to
+* adjust or stop its Sync, Announce or Pdelay messages. When we yield the
+* master role, all three fields are `0x7E` for a full stop.
+*
+* @param logLinkDelayInterval - Pdelay interval as signed log2 of seconds; 0x7E stops.
+* @param logTimeSyncInterval - Sync interval as signed log2 of seconds; 0x7E stops.
+* @param logAnnounceInterval - Announce interval as signed log2 of seconds; 0x7E stops.
+*/
+function encodeMessageIntervalRequestTlv(logLinkDelayInterval, logTimeSyncInterval, logAnnounceInterval) {
+	const payload = Buffer.alloc(10);
+	IEEE_802_1_ORGANIZATION_ID.copy(payload, 0);
+	payload[3] = MESSAGE_INTERVAL_REQUEST_SUBTYPE;
+	payload.writeInt8(logLinkDelayInterval, 4);
+	payload.writeInt8(logTimeSyncInterval, 5);
+	payload.writeInt8(logAnnounceInterval, 6);
+	payload[7] = 0;
+	const tlv = Buffer.alloc(4 + payload.length);
+	tlv.writeUInt16BE(TlvType.OrganizationExtension, 0);
+	tlv.writeUInt16BE(payload.length, 2);
+	payload.copy(tlv, 4);
+	return tlv;
+}
+
+//#endregion
+//#region src/timing/ptp/messages.ts
+/**
+* PTPv2 control field per message type. PTPv1 receivers need it; PTPv2-only
+* stacks ignore it.
+*/
+const ControlField = {
+	Sync: 0,
+	DelayReq: 1,
+	FollowUp: 2,
+	DelayResp: 3,
+	Management: 4,
+	AllOthers: 5
+};
+/** macOS sends transportSpecific = 1 in its PTP messages. */
+const TRANSPORT_SPECIFIC = 1;
+/** Default priority1 advertised by our grandmaster. */
+const DEFAULT_PRIORITY_1 = 248;
+/** Default priority2 advertised by our grandmaster. */
+const DEFAULT_PRIORITY_2 = 128;
+/** clockClass of every PTP sender that is not a primary reference. */
+const DEFAULT_CLOCK_CLASS = 248;
+/** clockAccuracy "unknown", as macOS sends it. */
+const DEFAULT_CLOCK_ACCURACY = 254;
+/** offsetScaledLogVariance "unknown", as macOS sends it. */
+const DEFAULT_OFFSET_SCALED_LOG_VARIANCE = 65535;
+/** UTC to TAI offset in leap seconds, as macOS sends it. */
+const DEFAULT_CURRENT_UTC_OFFSET = 37;
+/** Time source "internalOscillator", which Apple claims as grandmaster. */
+const DEFAULT_TIME_SOURCE = 160;
+/** log2 of the interval in seconds, written in the header of each message type. */
+const LogInterval = {
+	Sync: -3,
+	Announce: 0,
+	FollowUp: 0,
+	DelayReq: 127,
+	DelayResp: 127,
+	Signaling: 127
+};
+function buildHeader(messageType, clockIdentity, sequenceId, messageLength, controlField, logMessageInterval, flags = 0) {
+	const sourcePortIdentity = Buffer.alloc(10);
+	clockIdentity.copy(sourcePortIdentity, 0, 0, 8);
+	sourcePortIdentity.writeUInt16BE(1, 8);
+	return encodeHeader({
+		messageType,
+		transportSpecific: TRANSPORT_SPECIFIC,
+		messageLength,
+		domainNumber: 0,
+		flags,
+		correctionField: 0n,
+		sourcePortIdentity,
+		sequenceId,
+		controlField,
+		logMessageInterval
+	});
+}
+/**
+* Encodes a two-step Sync message of 44 bytes (34 header, 10 timestamp). The
+* precise origin timestamp follows in a FollowUp.
+*
+* @param clockIdentity - Our 8-byte EUI-64 clock identity.
+*/
+function encodeSync(sequenceId, clockIdentity) {
+	const header = buildHeader(0, clockIdentity, sequenceId, 34 + 10, ControlField.Sync, LogInterval.Sync, 520);
+	const zeroTs = encodeTimestamp({
+		seconds: 0n,
+		nanoseconds: 0
+	});
+	return Buffer.concat([header, zeroTs]);
+}
+/**
+* Encodes a FollowUp message carrying the precise origin timestamp for the
+* preceding Sync: 44 bytes plus a 30-byte FollowUpInformation TLV.
+*
+* @param sequenceId - Must match the preceding Sync.
+* @param clockIdentity - Our 8-byte EUI-64 clock identity.
+* @param preciseOriginTimestamp - When the Sync was sent.
+*/
+function encodeFollowUp(sequenceId, clockIdentity, preciseOriginTimestamp) {
+	const timestamp = encodeTimestamp(preciseOriginTimestamp);
+	const tlv = encodeFollowUpInfoTlv();
+	const header = buildHeader(8, clockIdentity, sequenceId, 34 + timestamp.length + tlv.length, ControlField.FollowUp, LogInterval.FollowUp, 8);
+	return Buffer.concat([
+		header,
+		timestamp,
+		tlv
+	]);
+}
+/**
+* Encodes a 64-byte Announce message advertising our grandmaster role.
+*
+* @param clockIdentity - Our 8-byte EUI-64 clock identity, also the grandmasterIdentity.
+* @param priority1 - Grandmaster priority1; the default 248 is above "slave-only" and below the 246 of an Apple TV.
+*/
+function encodeAnnounce(sequenceId, clockIdentity, priority1 = 248, priority2 = 128) {
+	const header = buildHeader(11, clockIdentity, sequenceId, 34 + 10 + 20, ControlField.AllOthers, LogInterval.Announce, 8);
+	const zeroTs = encodeTimestamp({
+		seconds: 0n,
+		nanoseconds: 0
+	});
+	const body = Buffer.alloc(20);
+	body.writeInt16BE(DEFAULT_CURRENT_UTC_OFFSET, 0);
+	body[3] = priority1;
+	body[4] = DEFAULT_CLOCK_CLASS;
+	body[5] = DEFAULT_CLOCK_ACCURACY;
+	body.writeUInt16BE(DEFAULT_OFFSET_SCALED_LOG_VARIANCE, 6);
+	body[8] = priority2;
+	clockIdentity.copy(body, 9, 0, 8);
+	body.writeUInt16BE(0, 17);
+	body[19] = DEFAULT_TIME_SOURCE;
+	return Buffer.concat([
+		header,
+		zeroTs,
+		body
+	]);
+}
+/**
+* Encodes a 54-byte DelayResp message that answers a DelayReq: 34 header,
+* 10 receiveTimestamp and 10 requestingPortIdentity.
+*
+* @param sequenceId - Copied from the DelayReq.
+* @param clockIdentity - Our 8-byte EUI-64 clock identity.
+* @param receiveTimestamp - When we received the DelayReq.
+* @param requestingPortIdentity - The 10-byte source port identity of the DelayReq.
+*/
+function encodeDelayResp(sequenceId, clockIdentity, receiveTimestamp, requestingPortIdentity) {
+	const timestamp = encodeTimestamp(receiveTimestamp);
+	const header = buildHeader(9, clockIdentity, sequenceId, 34 + timestamp.length + 10, ControlField.DelayResp, LogInterval.DelayResp, 8);
+	const requester = Buffer.alloc(10);
+	requestingPortIdentity.copy(requester, 0, 0, 10);
+	return Buffer.concat([
+		header,
+		timestamp,
+		requester
+	]);
+}
+/**
+* Encodes a Signaling message that asks the peer to stop its Sync, Announce
+* and Pdelay messages, with 0x7E in all three fields of a MessageIntervalRequest
+* TLV. We send it when we yield the master role to a peer with a higher priority.
+*
+* @param clockIdentity - Our 8-byte EUI-64 clock identity.
+* @param targetPortIdentity - The 10-byte port identity of the peer.
+*/
+function encodeSignalingStop(sequenceId, clockIdentity, targetPortIdentity) {
+	const tlv = encodeMessageIntervalRequestTlv(126, 126, 126);
+	const target = Buffer.alloc(10);
+	targetPortIdentity.copy(target, 0, 0, 10);
+	const header = buildHeader(12, clockIdentity, sequenceId, 34 + target.length + tlv.length, ControlField.AllOthers, LogInterval.Signaling, 8);
+	return Buffer.concat([
+		header,
+		target,
+		tlv
+	]);
+}
+/**
+* Decodes a PTP message from a raw UDP packet. Only the types in
+* {@link PtpMessageType} decode.
+*
+* @returns The decoded message, or null for a short buffer or an unknown type.
+*/
+function decodeMessage(buf) {
+	if (buf.length < 34) return null;
+	const header = decodeHeader(buf);
+	const offset = 34;
+	switch (header.messageType) {
+		case 0:
+			if (buf.length < offset + 10) return null;
+			return {
+				type: 0,
+				header,
+				body: { originTimestamp: decodeTimestamp(buf, offset) }
+			};
+		case 1:
+			if (buf.length < offset + 10) return null;
+			return {
+				type: 1,
+				header,
+				body: { originTimestamp: decodeTimestamp(buf, offset) }
+			};
+		case 8:
+			if (buf.length < offset + 10) return null;
+			return {
+				type: 8,
+				header,
+				body: { preciseOriginTimestamp: decodeTimestamp(buf, offset) }
+			};
+		case 9:
+			if (buf.length < offset + 10 + 10) return null;
+			return {
+				type: 9,
+				header,
+				body: {
+					receiveTimestamp: decodeTimestamp(buf, offset),
+					requestingPortIdentity: Buffer.from(buf.subarray(offset + 10, offset + 20))
+				}
+			};
+		case 11: {
+			if (buf.length < offset + 10 + 20) return null;
+			const originTimestamp = decodeTimestamp(buf, offset);
+			const bodyOffset = offset + 10;
+			const currentUtcOffset = buf.readInt16BE(bodyOffset);
+			const grandmasterPriority1 = buf[bodyOffset + 3];
+			const clockClass = buf[bodyOffset + 4];
+			const clockAccuracy = buf[bodyOffset + 5];
+			const offsetScaledLogVariance = buf.readUInt16BE(bodyOffset + 6);
+			const grandmasterPriority2 = buf[bodyOffset + 8];
+			const grandmasterIdentity = Buffer.from(buf.subarray(bodyOffset + 9, bodyOffset + 17));
+			const stepsRemoved = buf.readUInt16BE(bodyOffset + 17);
+			const timeSource = buf[bodyOffset + 19];
+			return {
+				type: 11,
+				header,
+				body: {
+					originTimestamp,
+					currentUtcOffset,
+					grandmasterPriority1,
+					grandmasterClockQuality: {
+						clockClass,
+						clockAccuracy,
+						offsetScaledLogVariance
+					},
+					grandmasterPriority2,
+					grandmasterIdentity,
+					stepsRemoved,
+					timeSource
+				}
+			};
+		}
+		case 12:
+			if (buf.length < offset + 10) return null;
+			return {
+				type: 12,
+				header,
+				body: {
+					targetPortIdentity: Buffer.from(buf.subarray(offset, offset + 10)),
+					tlv: Buffer.from(buf.subarray(offset + 10))
+				}
+			};
+		default: return null;
+	}
+}
+
+//#endregion
+//#region src/timing/ptp/index.ts
+/** Interval between Sync and FollowUp pairs, logInterval -3. */
+const SYNC_INTERVAL_MS = 125;
+/** Interval between Announce messages, the macOS cadence. */
+const ANNOUNCE_INTERVAL_MS = 250;
+/** IANA event port for PTP (Sync, DelayReq). */
+const EVENT_PORT = 319;
+/** IANA general port for PTP (FollowUp, DelayResp, Announce, Signaling). */
+const GENERAL_PORT = 320;
+/**
+* IEEE 1588 (PTPv2) grandmaster for AirPlay 2 HomePods.
+*
+* A HomePod with `SupportsPTP` (feature bit 41) expects the sender to be the
+* PTP grandmaster. The master binds the two PTP UDP ports, sends Sync and
+* Announce at the macOS rates and answers DelayReq with DelayResp. When a peer
+* with a higher priority announces itself, it sends a Signaling message with
+* `logMessageInterval = 0x7E` and stops.
+*
+* After that yield, audio timestamps keep using the local wall clock; there
+* is no PTP slave. HomePods accept this as long as the Sync messages stop.
+*/
+var PtpMaster = class {
+	/** UDP port for PTP event messages: 319, or an ephemeral port as fallback. */
+	get eventPort() {
+		return this.#eventPort;
+	}
+	/** UDP port for PTP general messages: 320, or an ephemeral port as fallback. */
+	get generalPort() {
+		return this.#generalPort;
+	}
+	get state() {
+		return this.#state;
+	}
+	/** Our 8-byte EUI-64 clock identity, as advertised to peers. */
+	get clockIdentity() {
+		return this.#clockIdentity;
+	}
+	/** Number of Sync messages sent to the peer. */
+	get syncsSent() {
+		return this.#syncsSent;
+	}
+	/** Number of Announce messages sent to the peer. */
+	get announcesSent() {
+		return this.#announcesSent;
+	}
+	/** Number of DelayReq messages received from any peer. */
+	get delayReqsReceived() {
+		return this.#delayReqsReceived;
+	}
+	/** Number of DelayResp messages sent in reply. */
+	get delayRespsSent() {
+		return this.#delayRespsSent;
+	}
+	/** Number of Announce messages received from peers. */
+	get announcesReceived() {
+		return this.#announcesReceived;
+	}
+	#logger;
+	#clockIdentity;
+	#peerAddress;
+	#eventSocket;
+	#generalSocket;
+	#eventPort = 0;
+	#generalPort = 0;
+	#syncSequenceId = 0;
+	#announceSequenceId = 0;
+	#signalingSequenceId = 0;
+	#state = "idle";
+	#syncTimer;
+	#announceTimer;
+	#syncsSent = 0;
+	#announcesSent = 0;
+	#delayReqsReceived = 0;
+	#delayRespsSent = 0;
+	#announcesReceived = 0;
+	/**
+	* @param peerAddress - IPv4 address of the receiver, the destination of Sync, FollowUp and Announce.
+	*/
+	constructor(peerAddress) {
+		this.#logger = new Logger("ptp-master");
+		this.#clockIdentity = generateClockIdentity();
+		this.#peerAddress = peerAddress;
+		this.onEventPacket = this.onEventPacket.bind(this);
+		this.onGeneralPacket = this.onGeneralPacket.bind(this);
+		this.onEventError = this.onEventError.bind(this);
+		this.onGeneralError = this.onGeneralError.bind(this);
+	}
+	/**
+	* Binds both PTP sockets and starts acting as the grandmaster. It prefers
+	* the privileged ports 319 and 320 and falls back to ephemeral ports on
+	* `EACCES`, so it runs on Linux without root. Some HomePods reject PTP on
+	* non-standard ports.
+	*
+	* @returns The bound event and general ports.
+	*/
+	async start() {
+		if (this.#state !== "idle") return {
+			eventPort: this.#eventPort,
+			generalPort: this.#generalPort
+		};
+		this.#eventSocket = await this.#bindSocket(EVENT_PORT, "event");
+		this.#generalSocket = await this.#bindSocket(GENERAL_PORT, "general");
+		this.#eventPort = this.#eventSocket.address().port;
+		this.#generalPort = this.#generalSocket.address().port;
+		this.#eventSocket.on("message", this.onEventPacket);
+		this.#eventSocket.on("error", this.onEventError);
+		this.#generalSocket.on("message", this.onGeneralPacket);
+		this.#generalSocket.on("error", this.onGeneralError);
+		this.#state = "master";
+		this.#startMasterTimers();
+		this.#logger.info(`Started on event=${this.#eventPort} general=${this.#generalPort} peer=${this.#peerAddress}`);
+		return {
+			eventPort: this.#eventPort,
+			generalPort: this.#generalPort
+		};
+	}
+	/**
+	* Stops the cadence timers and closes both sockets. Safe to call more than once.
+	*/
+	stop() {
+		if (this.#syncTimer) {
+			clearInterval(this.#syncTimer);
+			this.#syncTimer = void 0;
+		}
+		if (this.#announceTimer) {
+			clearInterval(this.#announceTimer);
+			this.#announceTimer = void 0;
+		}
+		try {
+			this.#eventSocket?.close();
+		} catch {}
+		try {
+			this.#generalSocket?.close();
+		} catch {}
+		this.#eventSocket = void 0;
+		this.#generalSocket = void 0;
+		this.#state = "stopped";
+	}
+	/**
+	* Answers a DelayReq on the event port with a DelayResp that carries our
+	* receive timestamp. A master ignores the other event messages.
+	*/
+	onEventPacket(buf, info) {
+		const decoded = decodeMessage(buf);
+		if (!decoded || decoded.type !== 1) return;
+		this.#delayReqsReceived++;
+		const receiveTimestamp = ptpNow();
+		const response = encodeDelayResp(decoded.header.sequenceId, this.#clockIdentity, receiveTimestamp, decoded.header.sourcePortIdentity);
+		this.#generalSocket?.send(response, GENERAL_PORT, info.address, (err) => {
+			if (err) {
+				this.#logger.warn(`DelayResp send failed to ${info.address}:${GENERAL_PORT}`, err);
+				return;
+			}
+			this.#delayRespsSent++;
+		});
+	}
+	/**
+	* Handles an Announce on the general port. When the peer has a strictly
+	* better priority1 than ours, the master yields and stops.
+	*/
+	onGeneralPacket(buf, info) {
+		const decoded = decodeMessage(buf);
+		if (!decoded) return;
+		if (decoded.type !== 11) return;
+		this.#announcesReceived++;
+		const peerPriority1 = decoded.body.grandmasterPriority1;
+		if (peerPriority1 >= 248) return;
+		this.#logger.info(`Peer ${info.address} priority1=${peerPriority1} < ours=${248}, yielding master role`);
+		this.#sendSignalingStop(decoded.header.sourcePortIdentity, info.address);
+		this.stop();
+	}
+	/** Logs the error only; {@link stop} owns the socket lifecycle. */
+	onEventError(err) {
+		this.#logger.warn("Event socket error", err);
+	}
+	/** Logs the error only; {@link stop} owns the socket lifecycle. */
+	onGeneralError(err) {
+		this.#logger.warn("General socket error", err);
+	}
+	/**
+	* Binds `preferredPort` (319 or 320) and falls back to an ephemeral port on `EACCES`.
+	*
+	* @param label - Names the socket in log messages.
+	*/
+	#bindSocket(preferredPort, label) {
+		return new Promise((resolve, reject) => {
+			const socket = createSocket("udp4");
+			const cleanup = () => {
+				socket.removeListener("error", onError);
+				socket.removeListener("listening", onListening);
+			};
+			const onError = (err) => {
+				cleanup();
+				if (err.code === "EACCES") {
+					this.#logger.warn(`Privileged ${label} port ${preferredPort} not available, falling back to ephemeral port. Some HomePods may reject PTP on non-standard ports.`);
+					this.#bindEphemeral(label).then(resolve, reject);
+					return;
+				}
+				reject(err);
+			};
+			const onListening = () => {
+				cleanup();
+				resolve(socket);
+			};
+			socket.once("error", onError);
+			socket.once("listening", onListening);
+			socket.bind(preferredPort);
+		});
+	}
+	/**
+	* Binds a new UDP socket to an ephemeral port.
+	*
+	* @param label - Names the socket in log messages.
+	*/
+	#bindEphemeral(label) {
+		return new Promise((resolve, reject) => {
+			const socket = createSocket("udp4");
+			const cleanup = () => {
+				socket.removeListener("error", onError);
+				socket.removeListener("listening", onListening);
+			};
+			const onError = (err) => {
+				cleanup();
+				reject(err);
+			};
+			const onListening = () => {
+				cleanup();
+				this.#logger.warn(`Bound ${label} socket to ephemeral port ${socket.address().port}`);
+				resolve(socket);
+			};
+			socket.once("error", onError);
+			socket.once("listening", onListening);
+			socket.bind(0);
+		});
+	}
+	#startMasterTimers() {
+		this.#syncTimer = setInterval(() => this.#sendSyncAndFollowUp(), SYNC_INTERVAL_MS);
+		this.#announceTimer = setInterval(() => this.#sendAnnounce(), ANNOUNCE_INTERVAL_MS);
+	}
+	/**
+	* Sends a Sync on the event port and the matching FollowUp on the general
+	* port. In two-step PTP, the FollowUp carries the time the Sync went out.
+	*/
+	#sendSyncAndFollowUp() {
+		if (!this.#eventSocket || !this.#generalSocket) return;
+		const sequenceId = this.#syncSequenceId = this.#syncSequenceId + 1 & 65535;
+		const sync = encodeSync(sequenceId, this.#clockIdentity);
+		this.#eventSocket.send(sync, EVENT_PORT, this.#peerAddress, (err) => {
+			if (err) {
+				this.#logger.warn(`Sync send failed`, err);
+				return;
+			}
+			this.#syncsSent++;
+			const t1 = ptpNow();
+			const followUp = encodeFollowUp(sequenceId, this.#clockIdentity, t1);
+			this.#generalSocket?.send(followUp, GENERAL_PORT, this.#peerAddress, (followUpErr) => {
+				if (!followUpErr) return;
+				this.#logger.warn(`FollowUp send failed`, followUpErr);
+			});
+		});
+	}
+	#sendAnnounce() {
+		if (!this.#generalSocket) return;
+		const announce = encodeAnnounce(this.#announceSequenceId = this.#announceSequenceId + 1 & 65535, this.#clockIdentity);
+		this.#generalSocket.send(announce, GENERAL_PORT, this.#peerAddress, (err) => {
+			if (err) {
+				this.#logger.warn(`Announce send failed`, err);
+				return;
+			}
+			this.#announcesSent++;
+		});
+	}
+	/**
+	* Sends one Signaling message that asks the peer to stop its Sync,
+	* Announce and Pdelay messages, when we yield.
+	*
+	* @param targetPortIdentity - The 10-byte port identity of the peer.
+	* @param address - IPv4 destination address.
+	*/
+	#sendSignalingStop(targetPortIdentity, address) {
+		if (!this.#generalSocket) return;
+		const signaling = encodeSignalingStop(this.#signalingSequenceId = this.#signalingSequenceId + 1 & 65535, this.#clockIdentity, targetPortIdentity);
+		this.#generalSocket.send(signaling, GENERAL_PORT, address, (err) => {
+			if (!err) return;
+			this.#logger.warn(`Signaling stop send failed to ${address}`, err);
+		});
+	}
+};
+
+//#endregion
+//#region src/timing/selector.ts
+/**
+* Picks the preferred timing strategy from a receiver's feature flags. The
+* caller decides at SETUP which strategy it can provide, for example only
+* `NTP` without a {@link PtpMaster}.
+*
+* @param receiverFeatures - The feature bitmask from GET /info.
+*/
+function selectTimingStrategy(receiverFeatures) {
+	if (hasFeatureFlag(receiverFeatures, AirPlayFeatureFlags.SupportsPTP)) return "PTP";
+	return "NTP";
+}
+
+//#endregion
+//#region src/session.ts
+/**
+* How long the keepalive may go without a successful `/feedback` before the receiver counts as gone.
+* A receiver only flags an inactive client after tens of seconds, and a busy hub can miss a few ticks.
+*/
+const KEEPALIVE_DEADLINE = 3e4;
+/** A fresh audio session starts silent, so it gets an audible volume. */
+const DEFAULT_VOLUME_DB = -20;
+/** Client type of the MRP data stream in its SETUP. */
+const DATA_CLIENT_TYPE_UUID = "1910A70F-DBC0-4242-AF95-115DB30604E1";
+/** Package-internal: how the multiplexer reaches into a session without a public method for it. */
+const audioLinks = /* @__PURE__ */ new WeakMap();
+/**
+* Connects to an AirPlay receiver and returns a ready session: TCP, `GET /info`, pair-verify with
+* the credentials or a transient pairing without, then encryption of the control channel.
+*
+* @throws {ConnectionClosedError} When the signal aborts during the handshake.
+* @throws {PairingError} When pairing fails.
+*/
+async function connect(target, options = {}) {
+	return await establish(target, options);
+}
+async function establish(target, options, ptpMaster) {
+	const signal = options.signal;
+	if (signal?.aborted) throw new ConnectionClosedError("AirPlay setup was interrupted.");
+	const context = options.context ?? new Context(target.id ?? target.address, options.identity);
+	const control = new ControlChannel(context, target.address, target.port ?? 7e3);
+	const interrupt = () => control.destroy();
+	signal?.addEventListener("abort", interrupt, { once: true });
+	try {
+		await control.connect();
+		const info = await fetchInfo(control, context);
+		const keys = options.credentials ? await verifyPairing(control, context, options.credentials) : await transientPairing(control, context);
+		if (signal?.aborted || !control.isConnected) throw new ConnectionClosedError("AirPlay setup was interrupted.");
+		control.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
+		return new AirPlaySession({
+			target,
+			options,
+			context,
+			control,
+			keys,
+			info,
+			ptpMaster
+		});
+	} catch (err) {
+		control.destroy();
+		throw signal?.aborted ? new ConnectionClosedError("AirPlay setup was interrupted.") : err;
+	} finally {
+		signal?.removeEventListener("abort", interrupt);
+	}
+}
+/**
+* One authenticated AirPlay connection. It lives once: it ends exactly once, with a reason, and
+* then its {@link signal} aborts and every channel, timer and pending request on it goes too.
+* Remote control runs on the session itself; URL playback and audio streams each get a dedicated
+* connection, because the receiver wants them apart, and end with the session.
+*/
+var AirPlaySession = class extends EventEmitter {
+	/** Why the session ended, or undefined while it is open. */
+	get closeReason() {
+		return this.#closeReason;
+	}
+	get context() {
+		return this.#context;
+	}
+	/** The RTSP control channel, encrypted. */
+	get control() {
+		return this.#control;
+	}
+	/** The feature mask of the receiver from `/info`. */
+	get features() {
+		return this.#info.features;
+	}
+	/** The `/info` plist; empty when the receiver answered with another status than 200. */
+	get info() {
+		return this.#info.info;
+	}
+	get isOpen() {
+		return !this.signal.aborted;
+	}
+	/** Our pairing identifier, from the credentials or the transient pairing. */
+	get pairingId() {
+		return this.#keys.pairingId;
+	}
+	/** The remote control channels once {@link openRemoteControl} succeeded. */
+	get remoteControl() {
+		return this.#remote;
+	}
+	/** Identifies the session in SETUP bodies; uppercase. */
+	get sessionUUID() {
+		return this.#sessionUUID;
+	}
+	/** Aborts with a {@link ConnectionClosedError} when the session ends. */
+	get signal() {
+		return this.#controller.signal;
+	}
+	/** Whether the receiver fetches and plays a URL itself. A HomePod advertises no video feature and needs an audio stream. */
+	get supportsUrlPlayback() {
+		return this.hasFeature(AirPlayFeatureFlags.SupportsAirPlayVideoV1) || this.hasFeature(AirPlayFeatureFlags.SupportsAirPlayVideoV2) || this.hasFeature(AirPlayFeatureFlags.SupportsAirPlayVideoPlayQueue);
+	}
+	get target() {
+		return this.#target;
+	}
+	#context;
+	#control;
+	#controller = new AbortController();
+	#keys;
+	#options;
+	#ptpMaster;
+	#sessionUUID = randomUUID().toUpperCase();
+	#target;
+	#closeReason;
+	#info;
+	#keepalive;
+	#remote;
+	#remoteOpening = false;
+	/** Use {@link connect}; a session starts from a finished handshake. */
+	constructor(parts) {
+		super();
+		this.#context = parts.context;
+		this.#control = parts.control;
+		this.#info = parts.info;
+		this.#keys = parts.keys;
+		this.#options = parts.options;
+		this.#ptpMaster = parts.ptpMaster;
+		this.#target = parts.target;
+		this.#control.on("closed", (reason, error) => this.#channelClosed("control", reason, error));
+		this.#control.on("error", (error) => this.#context.logger.error("AirPlay error", error));
+		parts.options.signal?.addEventListener("abort", () => this.#end("local"), {
+			once: true,
+			signal: this.signal
+		});
+		audioLinks.set(this, (options) => this.#openAudioLink(options));
+	}
+	hasFeature(feature) {
+		return hasFeatureFlag(this.#info.features, feature);
+	}
+	/** Ends the session and every connection that hangs off it, without TEARDOWN. */
+	async close() {
+		this.#end("local");
+	}
+	/**
+	* Opens remote control: the SETUP with the remote control features, the event channel and
+	* RECORD, the SETUP of the MRP data channel and its connection, then the keepalive. The MRP
+	* startup on the data channel is up to the caller, usually `MediaRemote.open()`. A failed step
+	* ends the session with reason `local`.
+	*
+	* @throws {SetupError} When a SETUP fails.
+	* @throws {ConnectionClosedError} When the session ends during setup.
+	*/
+	async openRemoteControl(options = {}) {
+		this.#assertOpen();
+		if (this.#remote || this.#remoteOpening) throw new Error("Remote control is already open on this session.");
+		this.#remoteOpening = true;
+		try {
+			const body = {
+				...this.#setupBody(SENDER_FEATURES_REMOTE_CONTROL),
+				isRemoteControlOnly: true
+			};
+			await this.#applyTiming(body);
+			const events = await this.#connectEvents(await this.#performSetup(body, () => "SETUP request failed."));
+			await this.#control.record(this.#path);
+			this.#checkpoint();
+			this.#observe("event", events);
+			const data = await this.#connectData(options.subscribe);
+			this.#checkpoint();
+			this.#observe("data", data);
+			data.on("setConnectionState", (message) => this.#onConnectionState(message));
+			this.#startKeepalive();
+			this.#remote = {
+				data,
+				events
+			};
+			return this.#remote;
+		} catch (err) {
+			this.#remoteOpening = false;
+			if (this.signal.aborted) throw err instanceof ConnectionClosedError ? err : new ConnectionClosedError("AirPlay setup was interrupted.");
+			this.#context.logger.error("[device]", "Setup failed, cleaning up", err);
+			this.#end("local");
+			throw err;
+		}
+	}
+	/**
+	* Has the receiver fetch and play a URL, on a connection of its own. Resolves once playback
+	* was started; the returned playback ends with the session.
+	*
+	* @throws {PlaybackError} When the receiver cannot play URLs or refuses this one.
+	* @throws {SetupError} When the SETUP fails.
+	*/
+	async playUrl(url, options = {}) {
+		const dedicated = await this.#spawn(options.signal);
+		try {
+			return await dedicated.#startUrlPlayback(url, options.position ?? 0);
+		} catch (err) {
+			dedicated.#end("local");
+			throw dedicated.#interrupted(err, "URL playback cancelled.");
+		}
+	}
+	/**
+	* Streams PCM audio on a connection of its own. Resolves once the audio stream is set up;
+	* {@link AudioPlayback.ended} settles when the source ran out and the stream is torn down.
+	* The source is stopped in every case.
+	*
+	* @throws {SetupError} When a SETUP fails.
+	*/
+	async streamAudio(source, options = {}) {
+		const sourceSession = new AudioSourceSession(source);
+		try {
+			const { session, stream } = await this.#openAudioLink(options);
+			try {
+				await stream.setup();
+				session.#checkpoint();
+			} catch (err) {
+				session.#end("local");
+				throw session.#interrupted(err, "Audio stream cancelled.");
+			}
+			return new AudioPlayback(session, stream, sourceSession);
+		} catch (err) {
+			await sourceSession.stop();
+			throw options.signal?.aborted ? new ConnectionClosedError("Audio stream cancelled.") : err;
+		}
+	}
+	async #openAudioLink(options) {
+		const dedicated = await this.#spawn(options.signal, options.ptpMaster);
+		try {
+			return await dedicated.#openAudio(options.volumeDb ?? DEFAULT_VOLUME_DB, options);
+		} catch (err) {
+			dedicated.#end("local");
+			throw dedicated.#interrupted(err, "Audio stream cancelled.");
+		}
+	}
+	async #openAudio(volumeDb, options) {
+		const body = {
+			...this.#setupBody(SENDER_FEATURES_AUDIO),
+			groupContainsGroupLeader: false,
+			groupUUID: randomUUID().toUpperCase(),
+			isMultiSelectAirPlay: true,
+			senderSupportsRelay: false,
+			statsCollectionEnabled: false,
+			supportsGroupCohesion: true,
+			updateSessionRequest: false
+		};
+		await this.#applyTiming(body);
+		const events = await this.#connectEvents(await this.#performSetup(body, () => "SETUP request failed."));
+		await this.#control.record(this.#path);
+		this.#checkpoint();
+		this.#observe("event", events);
+		await this.#control.setParameter("volume", String(volumeDb));
+		this.#checkpoint();
+		this.#startKeepalive();
+		const stream = new AudioStream({
+			context: this.#context,
+			control: this.#control,
+			address: this.#target.address,
+			supportedAudioFormats: this.#info.info.supportedAudioFormats
+		}, options);
+		this.signal.addEventListener("abort", () => stream.close(), { once: true });
+		return {
+			session: this,
+			stream
+		};
+	}
+	async #startUrlPlayback(url, position) {
+		if (!this.supportsUrlPlayback) throw new PlaybackError("This receiver does not support URL playback. Stream the URL as audio instead.");
+		const body = {
+			...this.#setupBody(SENDER_FEATURES_AUDIO),
+			groupContainsGroupLeader: false,
+			groupUUID: randomUUID(),
+			isMultiSelectAirPlay: true,
+			senderSupportsRelay: false,
+			statsCollectionEnabled: false,
+			supportsGroupCohesion: true,
+			updateSessionRequest: false
+		};
+		await this.#applyTiming(body);
+		const events = await this.#connectEvents(await this.#performSetup(body, (status) => `Failed to setup for playback: ${status}`));
+		this.#startKeepalive();
+		try {
+			this.#info = await fetchInfo(this.#control, this.#context, this.#info);
+		} catch (err) {
+			this.#context.logger.warn("[protocol]", "Second GET /info failed", err);
+		}
+		await this.#control.record(this.#path);
+		this.#checkpoint();
+		this.#observe("event", events);
+		try {
+			return await UrlPlayback.start({
+				session: this,
+				context: this.#context,
+				control: this.#control,
+				events,
+				features: this.#info.features,
+				sessionUUID: this.#sessionUUID,
+				senderMac: body.macAddress
+			}, url, position);
+		} catch (err) {
+			this.#stopKeepalive();
+			try {
+				await this.#control.teardown(this.#path);
+			} catch (teardownErr) {
+				this.#context.logger.warn("[protocol]", "TEARDOWN after playUrl failure also failed", teardownErr);
+			}
+			throw err;
+		}
+	}
+	get #path() {
+		return `/${this.#control.sessionId}`;
+	}
+	/**
+	* Fills `timingProtocol` and `timingPort`: PTP when the receiver supports it and a PTP master
+	* was given, NTP when a timing server was given, otherwise `None`.
+	*/
+	async #applyTiming(body) {
+		const master = this.#ptpMaster;
+		if (master && selectTimingStrategy(this.#info.features) === "PTP") {
+			body.timingPort = master.state === "idle" ? (await master.start()).eventPort : master.eventPort;
+			body.timingProtocol = "PTP";
+			return;
+		}
+		if (this.#options.timing) {
+			body.timingPort = this.#options.timing.port;
+			body.timingProtocol = "NTP";
+			return;
+		}
+		body.timingProtocol = "None";
+	}
+	#assertOpen() {
+		if (this.signal.aborted) throw new ConnectionClosedError("This AirPlay session has closed.");
+	}
+	/** Throws when the session ended while a setup step was waiting. */
+	#checkpoint() {
+		if (this.signal.aborted) throw new ConnectionClosedError("AirPlay setup was interrupted.");
+	}
+	/**
+	* A channel the session did not close itself counts as broken, also when someone destroyed it locally.
+	* Once TEARDOWN went out, a receiver may drop the event or data channel before it answers on the
+	* control channel, so the session then waits for that answer or its timeout.
+	*/
+	#channelClosed(name, reason, error) {
+		const teardown = this.#control.pendingTeardown;
+		if (name !== "control" && reason === "remote" && teardown) {
+			this.#context.logger.debug("[session]", `The ${name} channel closed during TEARDOWN, ending the session once it is answered.`);
+			teardown.then(() => this.#end("local"));
+			return;
+		}
+		if (reason === "local") {
+			this.#end("error", error ?? new ConnectionClosedError(`The ${name} channel was closed.`));
+			return;
+		}
+		this.#end(reason, error);
+	}
+	async #connectData(subscribe) {
+		const seed = randomInt64();
+		const response = await this.#control.setup(this.#path, { streams: [{
+			controlType: 2,
+			channelID: randomUUID().toUpperCase(),
+			seed,
+			clientUUID: randomUUID().toUpperCase(),
+			type: 130,
+			wantsDedicatedSocket: true,
+			clientTypeUUID: DATA_CLIENT_TYPE_UUID
+		}] });
+		if (response.status !== 200) {
+			this.#context.logger.error("[protocol]", "Failed to setup data stream.", response.status, response.statusText, await response.text());
+			throw new SetupError("Failed to setup data stream.");
+		}
+		const dataPort = Plist.parse(await response.arrayBuffer()).streams[0].dataPort & 65535;
+		this.#checkpoint();
+		this.#context.logger.net("[protocol]", `Connecting to data stream on port ${dataPort}...`);
+		const data = new DataChannel(this.#context, this.#target.address, dataPort, this.#keys.sharedSecret, seed);
+		this.signal.addEventListener("abort", () => data.destroy(), { once: true });
+		subscribe?.(data);
+		await data.connect();
+		return data;
+	}
+	async #connectEvents(setup) {
+		const eventPort = setup.eventPort & 65535;
+		this.#checkpoint();
+		this.#context.logger.net("[protocol]", `Connecting to event stream on port ${eventPort}...`);
+		const events = new EventChannel(this.#context, this.#target.address, eventPort, this.#keys.sharedSecret);
+		this.signal.addEventListener("abort", () => events.destroy(), { once: true });
+		await events.connect();
+		return events;
+	}
+	/** The single exit: aborts the signal (children clean up there), closes the control channel and emits `closed`. */
+	#end(reason, error) {
+		if (this.#closeReason) return;
+		this.#closeReason = reason;
+		this.#context.logger.net("[session]", `AirPlay session closed (${reason}${error ? `: ${error.message}` : ""}).`);
+		this.#stopKeepalive();
+		this.#controller.abort(new ConnectionClosedError(`AirPlay session closed (${reason}).`));
+		this.#control.destroy();
+		try {
+			this.#ptpMaster?.stop();
+		} catch (err) {
+			this.#context.logger.warn("[protocol]", "Error stopping PTP master", err);
+		}
+		this.emit("closed", reason, error);
+	}
+	/** Turns the error of a setup that the caller or the parent session interrupted into a {@link ConnectionClosedError}. */
+	#interrupted(err, message) {
+		return this.#options.signal?.aborted ? new ConnectionClosedError(message) : err;
+	}
+	/** A channel counts once it is connected; a close or error after that ends the session. */
+	#observe(name, channel) {
+		if (!channel.isConnected) throw new ConnectionClosedError("An AirPlay stream closed during setup.");
+		channel.on("closed", (reason, error) => this.#channelClosed(name, reason, error));
+		channel.on("error", (error) => {
+			this.#context.logger.error("AirPlay stream error", error);
+			this.#end("error", error);
+		});
+	}
+	/**
+	* The receiver answers a message it rejects with Disconnected and then ignores the session, so
+	* the session has to go down with it instead of staying up in name only.
+	*/
+	#onConnectionState(message) {
+		if (message.state !== 3) return;
+		this.#context.logger.error("AirPlay session dropped by the device");
+		this.#end("remote", new ConnectionClosedError("The receiver dropped the session."));
+	}
+	async #performSetup(body, failure) {
+		const response = await this.#control.setup(this.#path, body);
+		if (response.status !== 200) {
+			this.#context.logger.error("[protocol]", "Failed SETUP request.", response.status, response.statusText);
+			throw new SetupError(failure(response.status));
+		}
+		const plist = Plist.parse(await response.arrayBuffer());
+		if (plist.enabledFeatures != null) this.#context.logger.info("[protocol]", `Receiver enabled features: 0x${BigInt(plist.enabledFeatures).toString(16)}`);
+		if (plist.keepAlivePort != null) this.#context.logger.info("[protocol]", `Receiver keep-alive port: ${plist.keepAlivePort}`);
+		return plist;
+	}
+	/** The common SETUP body: identity, features, our MAC and the session UUID. */
+	#setupBody(features) {
+		const identity = resolveIdentity(this.#context);
+		return {
+			deviceID: this.#keys.pairingId.toString(),
+			...encodeFeatures(features),
+			macAddress: getMacAddress().toUpperCase(),
+			model: identity.model,
+			name: identity.name,
+			osBuildVersion: identity.osBuildVersion,
+			osName: identity.osName,
+			osVersion: identity.osVersion,
+			sourceVersion: this.#info.sourceVersion,
+			sessionUUID: this.#sessionUUID,
+			sessionCorrelationUUID: this.#sessionUUID.toUpperCase()
+		};
+	}
+	/** A new connection to the same receiver with the same credentials and timing, ending with this session. */
+	async #spawn(signal, ptpMaster) {
+		this.#assertOpen();
+		return await establish(this.#target, {
+			...this.#options,
+			context: this.#context,
+			signal: signal ? AbortSignal.any([this.signal, signal]) : this.signal
+		}, ptpMaster);
+	}
+	/**
+	* `POST /feedback` every two seconds. A tick that finds no success within {@link KEEPALIVE_DEADLINE}
+	* ends the session with `timeout`.
+	*/
+	#startKeepalive() {
+		if (this.#keepalive || this.signal.aborted) return;
+		let lastSuccess = performance.now();
+		let lastError;
+		this.#keepalive = setInterval(async () => {
+			if (performance.now() - lastSuccess >= KEEPALIVE_DEADLINE) {
+				this.#end("timeout", lastError ?? new TimeoutError(`No successful feedback for ${KEEPALIVE_DEADLINE} ms.`));
+				return;
+			}
+			try {
+				await this.#control.feedback();
+				lastSuccess = performance.now();
+				lastError = void 0;
+			} catch (err) {
+				if (this.signal.aborted) return;
+				lastError = err instanceof Error ? err : new Error(String(err));
+				this.#context.logger.warn("[protocol]", `Feedback failed (${Math.round((performance.now() - lastSuccess) / 1e3)} s since the last success).`, err);
+			}
+		}, FEEDBACK_INTERVAL);
+	}
+	#stopKeepalive() {
+		clearInterval(this.#keepalive);
+		this.#keepalive = void 0;
+	}
+};
+
+//#endregion
+//#region src/discovery.ts
+const AIRPLAY_SERVICE = "_airplay._tcp.local";
+/** Finds the AirPlay receivers on the local network. */
+async function discover(options = {}) {
+	return (await new Discovery(AIRPLAY_SERVICE).find(options.useCache ?? true)).map(withFeatures);
+}
+/** The connect target for a discovered receiver. */
+function toTarget(result) {
+	const { features } = withFeatures(result);
+	return {
+		address: result.address,
+		port: result.service.port,
+		id: result.id,
+		txt: result.txt,
+		features
+	};
+}
+/** Adds the parsed feature mask of the `features` (or `ft`) TXT value. */
+function withFeatures(result) {
+	const features = result.txt.features ?? result.txt.ft;
+	if (!features) return result;
+	try {
+		return {
+			...result,
+			features: parseFeatures(features)
+		};
+	} catch {
+		return result;
+	}
+}
+
+//#endregion
+export { AIRPLAY_SERVICE, AUDIO_BYTES_PER_CHANNEL, AUDIO_CHANNELS, AUDIO_SAMPLE_RATE, AirPlayFeatureFlags, AirPlaySession, AudioPlayback, DataChannel, EventChannel, PinPairing, PtpMaster, TimingServer, UrlPlayback, connect, describeFlags, discover, generateActiveRemoteId, generateDacpId, generateSessionId, getPairingRequirement, getProtocolVersion, hasFeatureFlag, isPasswordRequired, isRemoteControlSupported, pair, parseFeatures, toTarget, withFeatures };