@corewire/airplay 0.0.0 → 1.0.0-beta.1

package/dist/mrp.mjs

@@ -0,0 +1,2112 @@
+import { t as __exportAll } from "./chunk-w6R9maHv.mjs";
+import { $ as NotificationMessageSchema, A as sendPackedVirtualTouchEventMessage, At as ShuffleMode_Enum, B as remoteTextInputMessage, Bt as resolveIdentity, C as SetConnectionStateMessageSchema, Ct as AudioFadeMessageSchema, D as VirtualTouchEventSchema, Dt as DeviceClass_Enum, E as SendVirtualTouchEventMessageSchema, Et as deviceInfoMessage, F as SendButtonEventMessageSchema, Ft as ProtocolMessage_Type, G as playbackSessionMigrateEndMessage, H as registerHIDDeviceMessage, I as sendButtonEventMessage, It as getExtension$1, J as sendCommandResultMessage, K as HandlerReturnStatus_Enum, L as RequestGroupSessionMessageSchema, Lt as setExtension, M as sendHIDEventMessage, Mt as adjustVolumeMessage, N as SendCommandMessageSchema, Nt as ErrorCode_Enum, O as sendVirtualTouchEventMessage, Ot as PlaybackState_Enum, P as sendCommandMessage, Pt as ProtocolMessageSchema, Q as playbackQueueRequestMessage, R as requestGroupSessionMessage, S as setConversationDetectionEnabledMessage, St as clientUpdatesConfigMessage, T as setConnectionStateMessage, Tt as DeviceInfoMessageSchema, U as VirtualTouchDeviceDescriptorSchema, V as RegisterHIDDeviceMessageSchema, W as PlaybackSessionMigrateEndMessageSchema, X as playbackSessionMigrateBeginMessage, Y as PlaybackSessionMigrateBeginMessageSchema, Z as PlaybackQueueRequestMessageSchema, _ as SetListeningModeMessageSchema, _t as ConfigureConnectionMessageSchema, a as parseMessages, at as getVolumeResultMessage, b as setDiscoveryModeMessage, bt as Command, c as wakeDeviceMessage, ct as GetVolumeMessageSchema, d as SetVolumeMutedMessageSchema, dt as GetStateMessageSchema, et as notificationMessage, f as setVolumeMutedMessage, ft as getStateMessage, g as readyStateMessage, gt as ContentItemMetadata_MediaType, h as SetReadyStateMessageSchema, ht as getKeyboardSessionMessage, it as KeyboardState_Enum, j as SendHIDEventMessageSchema, jt as AdjustVolumeMessageSchema, k as SendPackedVirtualTouchEventMessageSchema, kt as RepeatMode_Enum, l as TextInputMessageSchema, lt as getVolumeMessage, m as setVolumeMessage, mt as getRemoteTextInputSessionMessage, n as decodeMessage, nt as ModifyOutputContextRequestType_Enum, o as proto_exports, ot as GetVolumeMutedMessageSchema, p as SetVolumeMessageSchema, pt as GetRemoteTextInputSessionMessageSchema, q as SendError_Enum, qt as uint16ToBE, rt as modifyOutputContextRequestMessage, s as WakeDeviceMessageSchema, st as getVolumeMutedMessage, t as describeProtocolMessage, tt as ModifyOutputContextRequestMessageSchema, u as textInputMessage, ut as VolumeCapabilities_Enum, v as setListeningModeMessage, vt as configureConnectionMessage, w as SetConnectionStateMessage_ConnectionState, wt as audioFadeMessage, x as SetConversationDetectionEnabledMessageSchema, xt as ClientUpdatesConfigMessageSchema, y as SetDiscoveryModeMessageSchema, yt as CommandOptionsSchema, z as RemoteTextInputMessageSchema, zt as create } from "./describe-CAEDGJLu.mjs";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { CommandError, ConnectionClosedError, TimeoutError, waitFor } from "@corewire/core";
+import { NSKeyedArchiver, Plist, RTI } from "@corewire/core/encoding";
+
+//#region src/mrp/artworkUrl.ts
+/** MRAnimatedArtwork serializes its NSURL with NSKeyedArchiver, not UTF-8. */
+function decodeArtworkAssetURL(data) {
+	if (!data?.byteLength) return null;
+	try {
+		const root = NSKeyedArchiver.decode(Plist.parse(Uint8Array.from(data).buffer));
+		const resolve = (value, depth = 0) => {
+			if (!value || typeof value !== "object" || depth > 8) return null;
+			const object = value;
+			if (typeof object["NS.relative"] !== "string") return null;
+			const base = resolve(object["NS.base"], depth + 1);
+			return new URL(object["NS.relative"], base ?? void 0);
+		};
+		const url = resolve(root);
+		return url && (url.protocol === "https:" || url.protocol === "http:") ? url.href : null;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/mrp/artwork.ts
+/**
+* The artwork of what plays now, from the sources MRP offers, in this order: a URL from the item
+* metadata, image bytes inside the queue, the JPEG of the last SET_ARTWORK, and finally a queue
+* request when the metadata promises artwork that has not arrived. A result is cached per
+* artwork identifier.
+*/
+var Artwork = class {
+	#queue;
+	#state;
+	#cached = null;
+	#lastIdentifier = null;
+	constructor(state, queue) {
+		this.#queue = queue;
+		this.#state = state;
+	}
+	/**
+	* Returns the artwork of the current item.
+	*
+	* @param width - In pixels.
+	* @param height - In pixels; -1 keeps the aspect ratio.
+	* @returns Null when there is no artwork.
+	*/
+	async get(width = 600, height = -1) {
+		const player = this.#state.nowPlayingClient?.activePlayer;
+		if (!player) return null;
+		const identifier = player.artworkId;
+		if (identifier && identifier === this.#lastIdentifier && this.#cached) return this.#cached;
+		const available = this.#fromPlayer(player, identifier, width, height);
+		if (available) return this.#cache(identifier, available);
+		const setArtworkData = this.#state.artworkJpegData;
+		if (setArtworkData && setArtworkData.byteLength > 0) return this.#cache(identifier, {
+			url: null,
+			data: setArtworkData,
+			mimeType: "image/jpeg",
+			identifier,
+			width: 0,
+			height: 0
+		});
+		if (identifier) try {
+			await this.#queue.request(1, width, height < 0 ? 400 : height);
+			const fetched = this.#fromPlayer(player, identifier, width, height, true);
+			if (fetched) return this.#cache(identifier, fetched);
+		} catch {}
+		this.clear();
+		return null;
+	}
+	/** Asks for the available animated formats first, then for the asset URLs of those formats. */
+	async getAnimated(width = 600, height = -1) {
+		const item = await this.#queue.requestAssets({ includeAvailableArtworkFormats: true }, width, height);
+		if (!item) return [];
+		const formats = item.availableAnimatedArtworkFormats;
+		const assets = formats.length > 0 ? await this.#queue.requestAssets({ requestedAnimatedArtworkAssetURLFormats: formats }, width, height) : item;
+		if (!assets || assets.identifier !== item.identifier) return [];
+		return assets.animatedArtworks.map((artwork) => ({
+			format: artwork.type ?? "",
+			url: decodeArtworkAssetURL(artwork.assetFileURLData)
+		}));
+	}
+	/** Forgets the cached result, so the next {@link get} looks again. */
+	clear() {
+		this.#lastIdentifier = null;
+		this.#cached = null;
+	}
+	#cache(identifier, result) {
+		this.#lastIdentifier = identifier;
+		this.#cached = result;
+		return result;
+	}
+	/** A URL first and inline bytes second, or bytes first after a queue request delivered them. */
+	#fromPlayer(player, identifier, width, height, dataFirst = false) {
+		const fromUrl = () => {
+			const url = player.artworkUrl(width, height);
+			return url ? {
+				url,
+				data: null,
+				mimeType: guessMimeType(url),
+				identifier,
+				width,
+				height: height < 0 ? 0 : height
+			} : null;
+		};
+		const fromData = () => {
+			const data = player.currentItemArtwork;
+			return data && data.byteLength > 0 ? {
+				url: null,
+				data,
+				mimeType: player.currentItemMetadata?.artworkMIMEType || "image/jpeg",
+				identifier,
+				width: 0,
+				height: 0
+			} : null;
+		};
+		return dataFirst ? fromData() ?? fromUrl() : fromUrl() ?? fromData();
+	}
+};
+function guessMimeType(url) {
+	if (url.includes(".png")) return "image/png";
+	if (url.includes(".webp")) return "image/webp";
+	return "image/jpeg";
+}
+
+//#endregion
+//#region src/mrp/messages.ts
+var messages_exports = /* @__PURE__ */ __exportAll({
+	adjustVolume: () => adjustVolume,
+	audioFade: () => audioFade,
+	clientUpdatesConfig: () => clientUpdatesConfig,
+	configureConnection: () => configureConnection,
+	deviceInfo: () => deviceInfo,
+	getExtension: () => getExtension,
+	getKeyboardSession: () => getKeyboardSession,
+	getRemoteTextInputSession: () => getRemoteTextInputSession,
+	getState: () => getState,
+	getVolume: () => getVolume,
+	getVolumeMuted: () => getVolumeMuted,
+	modifyOutputContext: () => modifyOutputContext,
+	notification: () => notification,
+	playbackQueueRequest: () => playbackQueueRequest,
+	playbackSessionMigrateBegin: () => playbackSessionMigrateBegin,
+	playbackSessionMigrateEnd: () => playbackSessionMigrateEnd,
+	protocol: () => protocol,
+	registerHIDDevice: () => registerHIDDevice,
+	remoteTextInput: () => remoteTextInput,
+	requestGroupSession: () => requestGroupSession,
+	sendButtonEvent: () => sendButtonEvent,
+	sendCommand: () => sendCommand,
+	sendCommandWithPlaybackPosition: () => sendCommandWithPlaybackPosition,
+	sendCommandWithPlaybackRate: () => sendCommandWithPlaybackRate,
+	sendCommandWithRepeatMode: () => sendCommandWithRepeatMode,
+	sendCommandWithShuffleMode: () => sendCommandWithShuffleMode,
+	sendCommandWithSkipInterval: () => sendCommandWithSkipInterval,
+	sendCommandWithSleepTimer: () => sendCommandWithSleepTimer,
+	sendHIDEvent: () => sendHIDEvent,
+	sendPackedVirtualTouchEvent: () => sendPackedVirtualTouchEvent,
+	sendVirtualTouchEvent: () => sendVirtualTouchEvent,
+	setConnectionState: () => setConnectionState,
+	setConversationDetectionEnabled: () => setConversationDetectionEnabled,
+	setDiscoveryMode: () => setDiscoveryMode,
+	setListeningMode: () => setListeningMode,
+	setReadyState: () => setReadyState,
+	setVolume: () => setVolume,
+	setVolumeMuted: () => setVolumeMuted,
+	textInput: () => textInput,
+	wakeDevice: () => wakeDevice
+});
+/** A ProtocolMessage without extension, with a random `identifier` that the data channel matches replies on. */
+function protocol(type, errorCode = 0) {
+	return create(ProtocolMessageSchema, {
+		type,
+		errorCode,
+		identifier: randomUUID().toUpperCase(),
+		uniqueIdentifier: randomUUID().toUpperCase()
+	});
+}
+/** Subscribes to state changes. Send early in the session to receive now-playing, volume and artwork updates. */
+function clientUpdatesConfig(artworkUpdates = true, nowPlayingUpdates = true, volumeUpdates = true, keyboardUpdates = false, outputDeviceUpdates = false, systemEndpointUpdates = true, subscribedPlayerPaths = []) {
+	const protocolMessage = protocol(16);
+	const message = create(ClientUpdatesConfigMessageSchema, {
+		artworkUpdates,
+		nowPlayingUpdates,
+		volumeUpdates,
+		keyboardUpdates,
+		outputDeviceUpdates,
+		systemEndpointUpdates,
+		subscribedPlayerPaths
+	});
+	setExtension(protocolMessage, clientUpdatesConfigMessage, message);
+	return [protocolMessage, clientUpdatesConfigMessage];
+}
+/** CONFIGURE_CONNECTION, which sets the group ID of this connection. */
+function configureConnection(groupId) {
+	const protocolMessage = protocol(120);
+	const message = create(ConfigureConnectionMessageSchema, { groupID: groupId });
+	setExtension(protocolMessage, configureConnectionMessage, message);
+	return [protocolMessage, configureConnectionMessage];
+}
+/**
+* DEVICE_INFO, the first message of a session, which introduces this controller to the receiver.
+*
+* @param pairingId - The pairing identifier from pair-verify.
+*/
+function deviceInfo(pairingId, identity) {
+	const protocolMessage = protocol(15);
+	const message = create(DeviceInfoMessageSchema, {
+		uniqueIdentifier: pairingId.toString(),
+		name: identity.name,
+		localizedModelName: "iPhone",
+		systemBuildVersion: identity.osBuildVersion,
+		applicationBundleIdentifier: identity.applicationBundleIdentifier,
+		applicationBundleVersion: identity.applicationBundleVersion,
+		protocolVersion: 1,
+		lastSupportedMessageType: 139,
+		supportsSystemPairing: true,
+		allowsPairing: true,
+		systemMediaApplication: "com.apple.TVMusic",
+		supportsACL: true,
+		supportsSharedQueue: true,
+		supportsExtendedMotion: true,
+		sharedQueueVersion: 3,
+		deviceClass: 1,
+		logicalDeviceCount: 1,
+		modelID: identity.model,
+		clusterType: 0,
+		isClusterAware: true,
+		isGroupLeader: false,
+		isProxyGroupPlayer: false,
+		groupContainsDiscoverableGroupLeader: 0,
+		supportsOutputContextSync: true,
+		computerName: identity.name
+	});
+	setExtension(protocolMessage, deviceInfoMessage, message);
+	return [protocolMessage, deviceInfoMessage];
+}
+/**
+* MODIFY_OUTPUT_CONTEXT_REQUEST, which changes the devices of a multiroom group.
+*
+* @param settingDevices - Replaces the whole output context.
+*/
+function modifyOutputContext(addingDevices = [], removingDevices = [], settingDevices = []) {
+	const protocolMessage = protocol(48);
+	const message = create(ModifyOutputContextRequestMessageSchema, {
+		outputContextType: 1,
+		addingOutputDeviceUIDs: addingDevices,
+		removingOutputDeviceUIDs: removingDevices,
+		settingOutputDeviceUIDs: settingDevices,
+		clusterAwareAddingOutputDeviceUIDs: addingDevices,
+		clusterAwareRemovingOutputDeviceUIDs: removingDevices,
+		clusterAwareSettingOutputDeviceUIDs: settingDevices
+	});
+	setExtension(protocolMessage, modifyOutputContextRequestMessage, message);
+	return [protocolMessage, modifyOutputContextRequestMessage];
+}
+/** GET_STATE, which asks for the current playback state. */
+function getState() {
+	const protocolMessage = protocol(3);
+	const message = create(GetStateMessageSchema, {});
+	setExtension(protocolMessage, getStateMessage, message);
+	return [protocolMessage, getStateMessage];
+}
+/** GET_VOLUME, which asks for the volume of an output device. */
+function getVolume(outputDeviceUID) {
+	const protocolMessage = protocol(49);
+	const message = create(GetVolumeMessageSchema, { outputDeviceUID });
+	setExtension(protocolMessage, getVolumeMessage, message);
+	return [protocolMessage, getVolumeMessage];
+}
+/** GET_VOLUME_MUTED, which asks whether an output device is muted. */
+function getVolumeMuted(outputDeviceUID) {
+	const protocolMessage = protocol(126);
+	const message = create(GetVolumeMutedMessageSchema, { outputDeviceUID });
+	setExtension(protocolMessage, getVolumeMutedMessage, message);
+	return [protocolMessage, getVolumeMutedMessage];
+}
+/** NOTIFICATION, which sends a named notification to the receiver. */
+function notification(notification) {
+	const protocolMessage = protocol(11);
+	const message = create(NotificationMessageSchema, { notification });
+	setExtension(protocolMessage, notificationMessage, message);
+	return [protocolMessage, notificationMessage];
+}
+/**
+* PLAYBACK_QUEUE_REQUEST, which asks for queue metadata and assets. Animated artwork formats
+* have to be requested explicitly.
+*
+* @param location - Index of the first item.
+* @param artworkWidth - In pixels.
+* @param artworkHeight - In pixels; -1 keeps the aspect ratio.
+*/
+function playbackQueueRequest(location, length, artworkWidth = 600, artworkHeight = -1, options = {}) {
+	const protocolMessage = protocol(32);
+	const message = create(PlaybackQueueRequestMessageSchema, {
+		location,
+		length,
+		artworkWidth,
+		artworkHeight,
+		returnContentItemAssetsInUserCompletion: true,
+		includeMetadata: true,
+		includeLanguageOptions: false,
+		includeInfo: true,
+		includeLyrics: true,
+		includeSections: true,
+		includeAlignments: true,
+		includeParticipants: true,
+		isLegacyNowPlayingInfoRequest: false,
+		...options
+	});
+	setExtension(protocolMessage, playbackQueueRequestMessage, message);
+	return [protocolMessage, playbackQueueRequestMessage];
+}
+/** GET_KEYBOARD_SESSION, which asks whether a text field is active; the answer is a KEYBOARD message. */
+function getKeyboardSession() {
+	const protocolMessage = protocol(24);
+	setExtension(protocolMessage, getKeyboardSessionMessage, "");
+	return [protocolMessage, getKeyboardSessionMessage];
+}
+/** Requests an RTI session; the receiver supplies a RemoteTextInputMessage. */
+function getRemoteTextInputSession() {
+	const message = protocol(68);
+	setExtension(message, getRemoteTextInputSessionMessage, create(GetRemoteTextInputSessionMessageSchema));
+	return [message, getRemoteTextInputSessionMessage];
+}
+/**
+* REMOTE_TEXT_INPUT, which carries one RTI text operation.
+*
+* @param data - The archived RTI operation.
+* @param version - The version of the RTI session it edits.
+*/
+function remoteTextInput(data, version = 1n) {
+	const message = protocol(67);
+	setExtension(message, remoteTextInputMessage, create(RemoteTextInputMessageSchema, {
+		version,
+		data
+	}));
+	return [message, remoteTextInputMessage];
+}
+/**
+* TEXT_INPUT, which sends text to the active keyboard session.
+*
+* @param actionType - For example done, search or send.
+*/
+function textInput(text, actionType) {
+	const protocolMessage = protocol(25);
+	const message = create(TextInputMessageSchema, {
+		timestamp: Date.now() / 1e3,
+		text,
+		actionType
+	});
+	setExtension(protocolMessage, textInputMessage, message);
+	return [protocolMessage, textInputMessage];
+}
+/**
+* SEND_BUTTON_EVENT, a USB HID button press or release.
+*
+* @param usagePage - For example 0x01 for Generic Desktop, 0x0c for Consumer.
+* @param buttonDown - `true` for key down, `false` for key up.
+*/
+function sendButtonEvent(usagePage, usage, buttonDown) {
+	const protocolMessage = protocol(39);
+	const message = create(SendButtonEventMessageSchema, {
+		usagePage,
+		usage,
+		buttonDown
+	});
+	setExtension(protocolMessage, sendButtonEventMessage, message);
+	return [protocolMessage, sendButtonEventMessage];
+}
+/** @param skipInterval - Seconds. */
+function sendCommandWithSkipInterval(command, skipInterval) {
+	return sendCommand(command, create(CommandOptionsSchema, { skipInterval }));
+}
+/** @param playbackPosition - Seconds from the start. */
+function sendCommandWithPlaybackPosition(command, playbackPosition) {
+	return sendCommand(command, create(CommandOptionsSchema, { playbackPosition }));
+}
+/** @param playbackRate - 1 is normal speed, 2 is double speed. */
+function sendCommandWithPlaybackRate(command, playbackRate) {
+	return sendCommand(command, create(CommandOptionsSchema, { playbackRate }));
+}
+function sendCommandWithShuffleMode(command, shuffleMode) {
+	return sendCommand(command, create(CommandOptionsSchema, { shuffleMode }));
+}
+function sendCommandWithRepeatMode(command, repeatMode) {
+	return sendCommand(command, create(CommandOptionsSchema, { repeatMode }));
+}
+/** SEND_COMMAND, a playback command such as play, pause or next track. */
+function sendCommand(command, options) {
+	const protocolMessage = protocol(1);
+	const message = create(SendCommandMessageSchema, {
+		command,
+		options
+	});
+	setExtension(protocolMessage, sendCommandMessage, message);
+	return [protocolMessage, sendCommandMessage];
+}
+/**
+* A Pause command that carries a sleep timer.
+*
+* @param seconds - Timer duration; 0 cancels a running timer.
+* @param stopMode - 0 stops playback, 1 pauses, 2 waits for the end of the track, 3 for the end of the queue.
+*/
+function sendCommandWithSleepTimer(seconds, stopMode = 0) {
+	return sendCommand(2, create(CommandOptionsSchema, {
+		sleepTimerTime: BigInt(seconds),
+		sleepTimerStopMode: stopMode
+	}));
+}
+/**
+* REGISTER_HID_DEVICE, which claims a virtual touch device. The Apple TV answers with a
+* REGISTER_HID_DEVICE_RESULT that holds the device identifier {@link sendVirtualTouchEvent} has
+* to carry; an unclaimed identifier makes it drop the session.
+*
+* @param absolute - Whether coordinates are absolute positions instead of relative movement.
+* @param integratedDisplay - Whether the surface sits on top of a display, as on a phone.
+*/
+function registerHIDDevice(screenWidth = 1e3, screenHeight = 1e3, absolute = true, integratedDisplay = false) {
+	const protocolMessage = protocol(6);
+	const message = create(RegisterHIDDeviceMessageSchema, { deviceDescriptor: create(VirtualTouchDeviceDescriptorSchema, {
+		absolute,
+		integratedDisplay,
+		screenSizeWidth: screenWidth,
+		screenSizeHeight: screenHeight
+	}) });
+	setExtension(protocolMessage, registerHIDDeviceMessage, message);
+	return [protocolMessage, registerHIDDeviceMessage];
+}
+/**
+* SEND_PACKED_VIRTUAL_TOUCH_EVENT, the packed form of a touch event: the five values as 16-bit
+* little endian integers in one byte array, in the order x, y, phase, device identifier, finger.
+*
+* @param phase - 1 began, 2 moved, 3 stationary, 4 ended, 5 cancelled.
+* @param deviceId - The identifier {@link registerHIDDevice} handed out.
+* @param finger - Finger index for multi-touch.
+*/
+function sendPackedVirtualTouchEvent(x, y, phase, deviceId, finger) {
+	const protocolMessage = protocol(43);
+	const data = Buffer.alloc(10);
+	data.writeUInt16LE(x, 0);
+	data.writeUInt16LE(y, 2);
+	data.writeUInt16LE(phase, 4);
+	data.writeUInt16LE(deviceId, 6);
+	data.writeUInt16LE(finger, 8);
+	const message = create(SendPackedVirtualTouchEventMessageSchema, { data });
+	setExtension(protocolMessage, sendPackedVirtualTouchEventMessage, message);
+	return [protocolMessage, sendPackedVirtualTouchEventMessage];
+}
+/**
+* SEND_VIRTUAL_TOUCH_EVENT, a touch on the virtual touchpad of {@link registerHIDDevice}.
+*
+* @param phase - 1 began, 2 moved, 3 stationary, 4 ended, 5 cancelled.
+* @param finger - Finger index for multi-touch.
+* @param deviceId - The identifier {@link registerHIDDevice} handed out.
+*/
+function sendVirtualTouchEvent(x, y, phase, finger, deviceId = 1) {
+	const protocolMessage = protocol(10);
+	const message = create(SendVirtualTouchEventMessageSchema, {
+		virtualDeviceID: BigInt(deviceId),
+		event: create(VirtualTouchEventSchema, {
+			x: BigInt(x),
+			y: BigInt(y),
+			phase,
+			finger
+		})
+	});
+	setExtension(protocolMessage, sendVirtualTouchEventMessage, message);
+	return [protocolMessage, sendVirtualTouchEventMessage];
+}
+/**
+* SEND_HID_EVENT, a raw USB HID event report for a navigation or media key.
+*
+* @param usePage - For example 0x01 for Generic Desktop, 0x0c for Consumer.
+* @param down - `true` for key down, `false` for key up.
+*/
+function sendHIDEvent(usePage, usage, down) {
+	const protocolMessage = protocol(8);
+	const message = create(SendHIDEventMessageSchema, { hidEventData: Buffer.concat([
+		Buffer.from("438922cf08020000", "hex"),
+		Buffer.from("0000000000000000010000000000000002000000200000000300000001000000000000", "hex"),
+		Buffer.concat([
+			uint16ToBE(usePage),
+			uint16ToBE(usage),
+			uint16ToBE(down ? 1 : 0)
+		]),
+		Buffer.from("0000000000000001000000", "hex")
+	]) });
+	setExtension(protocolMessage, sendHIDEventMessage, message);
+	return [protocolMessage, sendHIDEventMessage];
+}
+/** SET_CONNECTION_STATE, which tells the receiver our connection state. */
+function setConnectionState(state = 2) {
+	const protocolMessage = protocol(38);
+	const message = create(SetConnectionStateMessageSchema, { state });
+	setExtension(protocolMessage, setConnectionStateMessage, message);
+	return [protocolMessage, setConnectionStateMessage];
+}
+/** SET_READY_STATE, which tells the receiver this controller is ready. */
+function setReadyState() {
+	const protocolMessage = protocol(36);
+	const message = create(SetReadyStateMessageSchema, {});
+	setExtension(protocolMessage, readyStateMessage, message);
+	return [protocolMessage, readyStateMessage];
+}
+/**
+* SET_VOLUME, which sets the volume of an output device.
+*
+* @param volume - 0 to 1.
+*/
+function setVolume(outputDeviceUID, volume) {
+	const protocolMessage = protocol(51);
+	const message = create(SetVolumeMessageSchema, {
+		outputDeviceUID,
+		volume
+	});
+	setExtension(protocolMessage, setVolumeMessage, message);
+	return [protocolMessage, setVolumeMessage];
+}
+/** SET_VOLUME_MUTED, which mutes or unmutes an output device. */
+function setVolumeMuted(outputDeviceUID, isMuted) {
+	const protocolMessage = protocol(128);
+	const message = create(SetVolumeMutedMessageSchema, {
+		outputDeviceUID,
+		isMuted
+	});
+	setExtension(protocolMessage, setVolumeMutedMessage, message);
+	return [protocolMessage, setVolumeMutedMessage];
+}
+/** SET_CONVERSATION_DETECTION_ENABLED, which turns conversation detection of a HomePod on or off: it ducks the volume while people talk. */
+function setConversationDetectionEnabled(enabled, outputDeviceUID) {
+	const protocolMessage = protocol(130);
+	const message = create(SetConversationDetectionEnabledMessageSchema, {
+		enabled,
+		outputDeviceUID
+	});
+	setExtension(protocolMessage, setConversationDetectionEnabledMessage, message);
+	return [protocolMessage, setConversationDetectionEnabledMessage];
+}
+/**
+* ADJUST_VOLUME (extension field 97), a relative volume step that needs no current volume.
+*
+* @param adjustment - For example IncrementSmall or DecrementSmall.
+*/
+function adjustVolume(adjustment, outputDeviceUID) {
+	const protocolMessage = protocol(125);
+	const message = create(AdjustVolumeMessageSchema, {
+		adjustment,
+		outputDeviceUID
+	});
+	setExtension(protocolMessage, adjustVolumeMessage, message);
+	return [protocolMessage, adjustVolumeMessage];
+}
+/**
+* AUDIO_FADE, which asks the receiver to fade its audio.
+*
+* @param fadeType - 0 fades out, 1 fades in.
+* @param playerPath - Targets one player instead of the active one.
+*/
+function audioFade(fadeType, playerPath) {
+	const protocolMessage = protocol(106);
+	const message = create(AudioFadeMessageSchema, {
+		fadeType,
+		playerPath
+	});
+	setExtension(protocolMessage, audioFadeMessage, message);
+	return [protocolMessage, audioFadeMessage];
+}
+/**
+* SET_LISTENING_MODE, which sets the listening mode of a HomePod.
+*
+* @param listeningMode - For example `Default`, `Vivid` or `LateNight`.
+*/
+function setListeningMode(listeningMode, outputDeviceUID) {
+	const protocolMessage = protocol(110);
+	const message = create(SetListeningModeMessageSchema, {
+		listeningMode,
+		outputDeviceUID
+	});
+	setExtension(protocolMessage, setListeningModeMessage, message);
+	return [protocolMessage, setListeningModeMessage];
+}
+/** SET_DISCOVERY_MODE, which turns device discovery on or off. */
+function setDiscoveryMode(mode) {
+	const protocolMessage = protocol(101);
+	const message = create(SetDiscoveryModeMessageSchema, { mode });
+	setExtension(protocolMessage, setDiscoveryModeMessage, message);
+	return [protocolMessage, setDiscoveryModeMessage];
+}
+/** REQUEST_GROUP_SESSION, which starts a SharePlay group session. */
+function requestGroupSession() {
+	const protocolMessage = protocol(132);
+	const message = create(RequestGroupSessionMessageSchema, {});
+	setExtension(protocolMessage, requestGroupSessionMessage, message);
+	return [protocolMessage, requestGroupSessionMessage];
+}
+/** PLAYBACK_SESSION_MIGRATE_BEGIN, which starts moving playback to another device. */
+function playbackSessionMigrateBegin(playerPath) {
+	const protocolMessage = protocol(75);
+	const message = create(PlaybackSessionMigrateBeginMessageSchema, { playerPath });
+	setExtension(protocolMessage, playbackSessionMigrateBeginMessage, message);
+	return [protocolMessage, playbackSessionMigrateBeginMessage];
+}
+/** PLAYBACK_SESSION_MIGRATE_END, which completes moving playback to another device. */
+function playbackSessionMigrateEnd(playerPath) {
+	const protocolMessage = protocol(76);
+	const message = create(PlaybackSessionMigrateEndMessageSchema, { playerPath });
+	setExtension(protocolMessage, playbackSessionMigrateEndMessage, message);
+	return [protocolMessage, playbackSessionMigrateEndMessage];
+}
+/** WAKE_DEVICE, which wakes a sleeping Apple TV or HomePod. */
+function wakeDevice() {
+	const protocolMessage = protocol(41);
+	const message = create(WakeDeviceMessageSchema, {});
+	setExtension(protocolMessage, wakeDeviceMessage, message);
+	return [protocolMessage, wakeDeviceMessage];
+}
+/** Reads a protobuf extension of a ProtocolMessage, typed by its descriptor. */
+function getExtension(message, extension) {
+	return getExtension$1(message, extension);
+}
+
+//#endregion
+//#region src/mrp/commands.ts
+/**
+* Milliseconds a command waits for its result. The Music app on tvOS answers Play after about
+* 9 s while playback starts within a second, and the receiver handles commands one at a time.
+*/
+const COMMAND_TIMEOUT = 15e3;
+/** The receiver refused a SendCommand. */
+var SendCommandError = class extends CommandError {
+	sendError;
+	handlerReturnStatus;
+	constructor(sendError, handlerReturnStatus) {
+		super(`SendCommand failed: sendError=${SendError_Enum[sendError]}, handlerReturnStatus=${HandlerReturnStatus_Enum[handlerReturnStatus]}`);
+		this.name = "SendCommandError";
+		this.sendError = sendError;
+		this.handlerReturnStatus = handlerReturnStatus;
+	}
+};
+/**
+* Playback commands to the now-playing app, each a SEND_COMMAND exchange. A result with a send
+* error throws {@link SendCommandError}; a reply without a result counts as success.
+*/
+var Commands = class {
+	#channel;
+	constructor(channel) {
+		this.#channel = channel;
+	}
+	/** @throws {SendCommandError} When the receiver reports a send error. */
+	async send(command, options) {
+		return await this.#exchange(sendCommand(command, options));
+	}
+	async play() {
+		await this.send(1);
+	}
+	async pause() {
+		await this.send(2);
+	}
+	async togglePlayPause() {
+		await this.send(3);
+	}
+	async stop() {
+		await this.send(4);
+	}
+	async nextTrack() {
+		await this.send(5);
+	}
+	async previousTrack() {
+		await this.send(6);
+	}
+	/** @param interval - Seconds. */
+	async skipForward(interval = 15) {
+		await this.#exchange(sendCommandWithSkipInterval(18, interval));
+	}
+	/** @param interval - Seconds. */
+	async skipBackward(interval = 15) {
+		await this.#exchange(sendCommandWithSkipInterval(19, interval));
+	}
+	/** @param position - Seconds from the start. */
+	async seekToPosition(position) {
+		await this.#exchange(sendCommandWithPlaybackPosition(45, position));
+	}
+	async setShuffleMode(mode) {
+		await this.#exchange(sendCommandWithShuffleMode(47, mode));
+	}
+	async setRepeatMode(mode) {
+		await this.#exchange(sendCommandWithRepeatMode(46, mode));
+	}
+	/** @param rate - 1 is normal speed. */
+	async changePlaybackRate(rate) {
+		await this.#exchange(sendCommandWithPlaybackRate(20, rate));
+	}
+	async advanceShuffleMode() {
+		await this.send(7);
+	}
+	async advanceRepeatMode() {
+		await this.send(8);
+	}
+	async beginFastForward() {
+		await this.send(9);
+	}
+	async endFastForward() {
+		await this.send(10);
+	}
+	async beginRewind() {
+		await this.send(11);
+	}
+	async endRewind() {
+		await this.send(12);
+	}
+	async nextChapter() {
+		await this.send(25);
+	}
+	async previousChapter() {
+		await this.send(26);
+	}
+	async likeTrack() {
+		await this.send(22);
+	}
+	async dislikeTrack() {
+		await this.send(23);
+	}
+	async bookmarkTrack() {
+		await this.send(24);
+	}
+	async addNowPlayingItemToLibrary() {
+		await this.send(49);
+	}
+	/**
+	* Sets a sleep timer. It goes out as an option on a Pause command.
+	*
+	* @param seconds - Timer duration; 0 cancels a running timer.
+	* @param stopMode - 0 stops playback, 1 pauses, 2 waits for the end of the track, 3 for the end of the queue.
+	*/
+	async setSleepTimer(seconds, stopMode = 0) {
+		await this.#exchange(sendCommandWithSleepTimer(seconds, stopMode));
+	}
+	async #exchange(message) {
+		const response = await this.#channel.exchange(message, COMMAND_TIMEOUT);
+		let result;
+		try {
+			result = getExtension(response, sendCommandResultMessage);
+		} catch {
+			return;
+		}
+		if (!result) return;
+		if (result.sendError !== 0) throw new SendCommandError(result.sendError, result.handlerReturnStatus);
+		return result;
+	}
+};
+
+//#endregion
+//#region src/mrp/hid.ts
+/** USB HID usage page of the navigation keys. */
+const GENERIC_DESKTOP = 1;
+/** USB HID usage page of the media keys. */
+const CONSUMER = 12;
+/**
+* Keys as USB HID events: Generic Desktop (0x01) for navigation, Consumer (0x0c) for media.
+*
+* Every event goes out with `send()`: the receiver never replies to a HID event, so waiting for one
+* would time out on key-down and key-up would never be sent. Touch is not here: tvOS drops the
+* session on a virtual touch event over MRP.
+*/
+var Hid = class {
+	#channel;
+	#state;
+	constructor(channel, state) {
+		this.#channel = channel;
+		this.#state = state;
+	}
+	async up() {
+		await this.press(GENERIC_DESKTOP, 140);
+	}
+	async down() {
+		await this.press(GENERIC_DESKTOP, 141);
+	}
+	async left() {
+		await this.press(GENERIC_DESKTOP, 139);
+	}
+	async right() {
+		await this.press(GENERIC_DESKTOP, 138);
+	}
+	async menu() {
+		await this.press(GENERIC_DESKTOP, 134);
+	}
+	async select() {
+		await this.press(GENERIC_DESKTOP, 137);
+	}
+	async home() {
+		await this.press(CONSUMER, 64);
+	}
+	async suspend() {
+		await this.press(GENERIC_DESKTOP, 130);
+	}
+	async wake() {
+		await this.press(GENERIC_DESKTOP, 131);
+	}
+	async play() {
+		await this.press(CONSUMER, 176);
+	}
+	async pause() {
+		await this.press(CONSUMER, 177);
+	}
+	/** Pause when the now-playing client plays, play otherwise. */
+	async playPause() {
+		if (this.#state.nowPlayingClient?.isPlaying) await this.pause();
+		else await this.play();
+	}
+	async stop() {
+		await this.press(CONSUMER, 183);
+	}
+	async next() {
+		await this.press(CONSUMER, 181);
+	}
+	async previous() {
+		await this.press(CONSUMER, 182);
+	}
+	async volumeUp() {
+		await this.press(CONSUMER, 233);
+	}
+	async volumeDown() {
+		await this.press(CONSUMER, 234);
+	}
+	async mute() {
+		await this.press(CONSUMER, 226);
+	}
+	async topMenu() {
+		await this.press(CONSUMER, 96);
+	}
+	async channelUp() {
+		await this.press(CONSUMER, 156);
+	}
+	async channelDown() {
+		await this.press(CONSUMER, 157);
+	}
+	/** Two presses 150 ms apart. */
+	async doublePress(usePage, usage) {
+		await this.press(usePage, usage);
+		await waitFor(150);
+		await this.press(usePage, usage);
+	}
+	/**
+	* Holds a key down.
+	*
+	* @param duration - Hold time in milliseconds.
+	*/
+	async longPress(usePage, usage, duration = 1e3) {
+		this.#channel.send(sendHIDEvent(usePage, usage, true));
+		await waitFor(duration);
+		this.#channel.send(sendHIDEvent(usePage, usage, false));
+	}
+	/** Key-down, 25 ms, key-up. */
+	async press(usePage, usage) {
+		this.#channel.send(sendHIDEvent(usePage, usage, true));
+		await waitFor(25);
+		this.#channel.send(sendHIDEvent(usePage, usage, false));
+	}
+};
+
+//#endregion
+//#region src/mrp/keyboard.ts
+/** How long the receiver gets to hand out an RTI text session, in milliseconds. */
+const TEXT_SESSION_TIMEOUT = 5e3;
+/**
+* Text input over MRP. Every operation asks the receiver for its current RTI text session first,
+* then sends the edit for that session. Operations run one at a time, in call order.
+*/
+var Keyboard = class {
+	#channel;
+	#queue = Promise.resolve();
+	constructor(channel) {
+		this.#channel = channel;
+	}
+	/** Replaces the text in the focused field. */
+	async set(text) {
+		await this.#enqueue(text, true);
+	}
+	async append(text) {
+		await this.#enqueue(text, false);
+	}
+	async clear() {
+		await this.#enqueue("", true);
+	}
+	/** Asks for the keyboard session; the answer arrives as a KEYBOARD message on the state. */
+	async getSession() {
+		this.#channel.send(getKeyboardSession());
+	}
+	#enqueue(text, clear) {
+		const operation = this.#queue.then(async () => {
+			if (!this.#channel.isConnected) throw new ConnectionClosedError();
+			const { session, version } = await this.#requestSession();
+			if (!this.#channel.isConnected) throw new ConnectionClosedError();
+			if (clear) this.#channel.send(remoteTextInput(new Uint8Array(RTI.encodeOperation(session.uuid, "", true)), version));
+			if (text) this.#channel.send(remoteTextInput(new Uint8Array(RTI.encodeOperation(session.uuid, text, false)), version));
+		});
+		this.#queue = operation.catch(() => {});
+		return operation;
+	}
+	#requestSession() {
+		const channel = this.#channel;
+		return new Promise((resolve, reject) => {
+			const cleanup = () => {
+				clearTimeout(timer);
+				channel.off("remoteTextInput", onSession);
+				channel.off("closed", onClose);
+				channel.off("error", onError);
+			};
+			const onError = (error) => {
+				cleanup();
+				reject(error);
+			};
+			const onClose = () => onError(new ConnectionClosedError());
+			const onSession = (message) => {
+				try {
+					if (!message.data?.byteLength) throw new CommandError("No active AirPlay text input session.");
+					if (message.version !== 1n) throw new CommandError("Unsupported AirPlay text input version.");
+					const session = RTI.decodeSession(message.data);
+					cleanup();
+					resolve({
+						session,
+						version: message.version
+					});
+				} catch (error) {
+					onError(error instanceof Error ? error : new Error(String(error)));
+				}
+			};
+			const timer = setTimeout(() => onError(new TimeoutError("AirPlay did not provide an RTI text session.")), TEXT_SESSION_TIMEOUT);
+			channel.on("remoteTextInput", onSession);
+			channel.on("closed", onClose);
+			channel.on("error", onError);
+			try {
+				channel.send(getRemoteTextInputSession());
+			} catch (error) {
+				onError(error instanceof Error ? error : new Error(String(error)));
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/mrp/outputDevices.ts
+/** The output context of the receiver: which devices play along, and per-device audio settings. */
+var OutputDevices = class {
+	#channel;
+	#state;
+	constructor(channel, state) {
+		this.#channel = channel;
+		this.#state = state;
+	}
+	/** Adds devices to the output context. */
+	async add(deviceUIDs) {
+		await this.#channel.exchange(modifyOutputContext(deviceUIDs));
+	}
+	/** Removes devices from the output context. */
+	async remove(deviceUIDs) {
+		await this.#channel.exchange(modifyOutputContext([], deviceUIDs));
+	}
+	/** Replaces the output context with these devices. */
+	async set(deviceUIDs) {
+		await this.#channel.exchange(modifyOutputContext([], [], deviceUIDs));
+	}
+	/**
+	* Turns conversation detection of the active output device on or off (HomePod).
+	*
+	* @throws {Error} When no output device is active.
+	*/
+	async setConversationDetectionEnabled(enabled) {
+		const outputDeviceUID = this.#state.outputDeviceUID;
+		if (!outputDeviceUID) throw new Error("No output device active.");
+		this.#channel.send(setConversationDetectionEnabled(enabled, outputDeviceUID));
+	}
+	/** Sets the listening mode of the active output device (HomePod), e.g. `Default`, `Vivid`, `LateNight`. Does nothing without one. */
+	async setListeningMode(mode) {
+		const outputDeviceUID = this.#state.outputDeviceUID;
+		if (outputDeviceUID) this.#channel.send(setListeningMode(mode, outputDeviceUID));
+	}
+};
+
+//#endregion
+//#region src/mrp/playbackQueue.ts
+/**
+* Requests for the playback queue. The receiver answers with a SET_STATE carrying the queue, so
+* the result lands in the state; these only wait for the reply.
+*/
+var PlaybackQueue = class {
+	#channel;
+	#state;
+	constructor(channel, state) {
+		this.#channel = channel;
+		this.#state = state;
+	}
+	/** Requests the first `length` items of the queue. */
+	async request(length, artworkWidth, artworkHeight) {
+		await this.#channel.exchange(playbackQueueRequest(0, length, artworkWidth, artworkHeight));
+	}
+	/**
+	* Requests extra assets of the current item, such as artwork formats or lyrics, and returns
+	* the item once they arrived.
+	*
+	* @returns Null without a current item, or when the track changed while waiting.
+	* @throws {Error} When the receiver answers with an error code.
+	*/
+	async requestAssets(options = {}, width = 600, height = -1) {
+		const player = this.#state.nowPlayingClient?.activePlayer;
+		const identifier = player?.currentItem?.identifier;
+		if (!identifier) return null;
+		const response = await this.#channel.exchange(playbackQueueRequest(0, 1, width, height, {
+			...options,
+			playerPath: player.playbackQueue?.resolvedPlayerPath
+		}));
+		if (response.errorCode) throw new Error(`Content item request failed: ${response.errorDescription || response.errorCode}`);
+		if (this.#state.nowPlayingClient?.activePlayer !== player || player.currentItem?.identifier !== identifier) return null;
+		return player.currentItem;
+	}
+};
+
+//#endregion
+//#region src/mrp/additionalMetadata.ts
+const cache = /* @__PURE__ */ new WeakMap();
+/**
+* Reads `TVRAdditionalMetadata` from `ContentItemMetadata.nowPlayingInfoData`. The Apple TV app
+* sends season, episode, genre and rating only there. Results are cached per data buffer; a
+* buffer that does not decode yields null.
+*/
+function decodeAdditionalMetadata(data) {
+	if (!data?.byteLength) return null;
+	if (cache.has(data)) return cache.get(data) ?? null;
+	const metadata = parse(data);
+	cache.set(data, metadata);
+	return metadata;
+}
+function parse(data) {
+	try {
+		const extra = NSKeyedArchiver.decode(Plist.parse(Uint8Array.from(data).buffer))?.["TVRAdditionalMetadata"];
+		if (!extra || typeof extra !== "object" || Array.isArray(extra)) return null;
+		const entries = extra;
+		return {
+			seasonNumber: toNumber(entries["avkt/com.apple.avkit.seasonNumber"]),
+			episodeNumber: toNumber(entries["avkt/com.apple.avkit.episodeNumber"]),
+			episodeTitle: toText(entries["mdta/com.apple.hls.episode-title"]),
+			genre: toText(entries["mdta/com.apple.hls.genre"]),
+			contentRating: toText(entries["mdta/com.apple.hls.rating-display-name"])
+		};
+	} catch {
+		return null;
+	}
+}
+function toNumber(value) {
+	const number = typeof value === "string" ? Number(value) : value;
+	return typeof number === "number" && Number.isInteger(number) && number > 0 ? number : 0;
+}
+function toText(value) {
+	return typeof value === "string" ? value : "";
+}
+
+//#endregion
+//#region src/mrp/player.ts
+/** Seconds between the Cocoa epoch (2001-01-01) and the Unix epoch (1970-01-01). */
+const COCOA_EPOCH_OFFSET = 978307200;
+/** The player the receiver reports when no specific player is active. */
+const DEFAULT_PLAYER_ID = "MediaRemote-DefaultPlayer";
+/** The artwork CDN serves HEIC by default, which most browsers cannot show; a `.jpg` extension makes it return JPEG. */
+function convertArtworkUrl(url) {
+	return url.replace(/\.heic(\b|$)/gi, ".jpg");
+}
+/**
+* Moves an elapsed time from its snapshot to now at the playback rate, never below 0.
+*
+* @param elapsed - Seconds at the moment of the snapshot.
+* @param cocoaTimestamp - Moment of the snapshot, in seconds since the Cocoa epoch.
+*/
+function extrapolateElapsed(elapsed, cocoaTimestamp, rate) {
+	if (!rate) return elapsed;
+	const timestampUnix = cocoaTimestamp + COCOA_EPOCH_OFFSET;
+	const delta = (Date.now() / 1e3 - timestampUnix) * rate;
+	return Math.max(0, elapsed + delta);
+}
+/**
+* One player of a now-playing app; an app can have several, such as picture-in-picture. Tracks
+* the now-playing metadata and playback state, and extrapolates the elapsed time from the Cocoa
+* timestamp and the playback rate.
+*/
+var Player = class {
+	/** The player identifier, such as a player path. */
+	get identifier() {
+		return this.#identifier;
+	}
+	get displayName() {
+		return this.#displayName;
+	}
+	/** Whether this is `MediaRemote-DefaultPlayer`, the player of an app without a specific one. */
+	get isDefaultPlayer() {
+		return this.#identifier === DEFAULT_PLAYER_ID;
+	}
+	get nowPlayingInfo() {
+		return this.#nowPlayingInfo;
+	}
+	get playbackQueue() {
+		return this.#playbackQueue;
+	}
+	get playbackState() {
+		return this.#playbackState;
+	}
+	/** The timestamp of the last playback state update; an older update is ignored. */
+	get playbackStateTimestamp() {
+		return this.#playbackStateTimestamp;
+	}
+	get supportedCommands() {
+		return this.#supportedCommands;
+	}
+	get title() {
+		return this.#nowPlayingInfo?.title || this.currentItemMetadata?.title || "";
+	}
+	get artist() {
+		return this.#nowPlayingInfo?.artist || this.currentItemMetadata?.trackArtistName || "";
+	}
+	get album() {
+		return this.#nowPlayingInfo?.album || this.currentItemMetadata?.albumName || "";
+	}
+	get genre() {
+		return this.currentItemMetadata?.genre || this.#additionalMetadata?.genre || "";
+	}
+	get seriesName() {
+		return this.currentItemMetadata?.seriesName || "";
+	}
+	/** The season number, or 0 when unknown. */
+	get seasonNumber() {
+		return this.currentItemMetadata?.seasonNumber || this.#additionalMetadata?.seasonNumber || 0;
+	}
+	/** The episode number, or 0 when unknown. */
+	get episodeNumber() {
+		return this.currentItemMetadata?.episodeNumber || this.#additionalMetadata?.episodeNumber || 0;
+	}
+	/** The episode title. Only the Apple TV app sends it, in its archived now-playing info. */
+	get episodeTitle() {
+		return this.#additionalMetadata?.episodeTitle || "";
+	}
+	/** The localized content rating, such as `12+`. */
+	get contentRating() {
+		return this.currentItemMetadata?.localizedContentRating || this.#additionalMetadata?.contentRating || "";
+	}
+	get mediaType() {
+		return this.currentItemMetadata?.mediaType ?? 0;
+	}
+	/** The content identifier of the current item, such as a store ID. */
+	get contentIdentifier() {
+		return this.currentItemMetadata?.contentIdentifier || "";
+	}
+	/** The duration of the current item in seconds. */
+	get duration() {
+		return this.#nowPlayingInfo?.duration || this.currentItemMetadata?.duration || 0;
+	}
+	/** The playback rate, where 1 is normal speed, 0 is paused and 2 is double speed. */
+	get playbackRate() {
+		return this.#nowPlayingInfo?.playbackRate ?? this.currentItemMetadata?.playbackRate ?? 0;
+	}
+	get isPlaying() {
+		return this.playbackState === 1;
+	}
+	/** The shuffle mode, read from the info of the ChangeShuffleMode command. */
+	get shuffleMode() {
+		return this.#supportedCommands.find((commandInfo) => commandInfo.command === 47)?.shuffleMode ?? 0;
+	}
+	/** The repeat mode, read from the info of the ChangeRepeatMode command. */
+	get repeatMode() {
+		return this.#supportedCommands.find((commandInfo) => commandInfo.command === 46)?.repeatMode ?? 0;
+	}
+	/**
+	* The elapsed time in seconds, extrapolated from the newer timestamp of the now-playing info
+	* and the content item. Metadata after a track change can report rate 0 during playback, so the
+	* player's rate fills in. A paused player can still report rate 1, so its position stays put.
+	*/
+	get elapsedTime() {
+		const info = this.#nowPlayingInfo;
+		const metadata = this.currentItemMetadata;
+		const infoValid = Number.isFinite(info?.elapsedTime) && Number.isFinite(info?.timestamp) && info.timestamp !== 0;
+		const metadataValid = Number.isFinite(metadata?.elapsedTime) && Number.isFinite(metadata?.elapsedTimeTimestamp) && metadata.elapsedTimeTimestamp !== 0;
+		if (!infoValid && !metadataValid) return info?.elapsedTime || metadata?.elapsedTime || 0;
+		const newest = metadataValid && (!infoValid || metadata.elapsedTimeTimestamp > info.timestamp) ? {
+			elapsed: metadata.elapsedTime,
+			timestamp: metadata.elapsedTimeTimestamp,
+			rate: metadata.playbackRate
+		} : {
+			elapsed: info.elapsedTime,
+			timestamp: info.timestamp,
+			rate: info.playbackRate
+		};
+		if (this.#playbackState !== 1 && this.#playbackState !== 0) return newest.elapsed;
+		return extrapolateElapsed(newest.elapsed, newest.timestamp, newest.rate || this.playbackRate);
+	}
+	/** The item at the queue location, or the first item when the location is out of range. */
+	get currentItem() {
+		if (!this.#playbackQueue || this.#playbackQueue.contentItems.length === 0) return null;
+		return this.#playbackQueue.contentItems[this.#playbackQueue.location] ?? this.#playbackQueue.contentItems[0] ?? null;
+	}
+	get currentItemMetadata() {
+		return this.currentItem?.metadata ?? null;
+	}
+	/** An identifier that changes with the artwork, or null when the metadata shows no sign of artwork. */
+	get artworkId() {
+		const metadata = this.currentItemMetadata;
+		if (!metadata) return null;
+		if (!metadata.artworkAvailable && !metadata.artworkURL && !metadata.artworkIdentifier) return null;
+		if (metadata.artworkIdentifier) return metadata.artworkIdentifier;
+		if (metadata.contentIdentifier) return metadata.contentIdentifier;
+		return this.currentItem?.identifier ?? null;
+	}
+	/**
+	* The artwork URL of the current item, from the metadata `artworkURL`, the remote artworks or
+	* the artwork identifier as a URL template, in that order.
+	*
+	* @param width - In pixels; only a template uses it.
+	* @param height - In pixels; -1 keeps the aspect ratio.
+	*/
+	artworkUrl(width = 600, height = -1) {
+		const metadata = this.currentItemMetadata;
+		if (metadata?.artworkURL) return convertArtworkUrl(metadata.artworkURL);
+		const item = this.currentItem;
+		if (item?.remoteArtworks.length > 0 && item.remoteArtworks[0].artworkURLString) return convertArtworkUrl(item.remoteArtworks[0].artworkURLString);
+		if (!metadata?.artworkIdentifier) return null;
+		const url = metadata.artworkIdentifier.replace("{w}", String(width < 1 ? 999999 : width)).replace("{h}", String(height < 1 ? 999999 : height)).replace("{c}", "bb").replace("{f}", "jpg");
+		if (url.startsWith("http://") || url.startsWith("https://")) return url;
+		return null;
+	}
+	/** The image bytes embedded in the current item, or null. */
+	get currentItemArtwork() {
+		const item = this.currentItem;
+		if (!item) return null;
+		if (item.artworkData?.byteLength > 0) return item.artworkData;
+		if (item.dataArtworks.length > 0 && item.dataArtworks[0].imageData?.byteLength > 0) return item.dataArtworks[0].imageData;
+		return null;
+	}
+	/** The artwork URL at 600 pixels wide, or null. */
+	get currentItemArtworkUrl() {
+		return this.artworkUrl();
+	}
+	get currentItemLyrics() {
+		return this.currentItem?.lyrics ?? null;
+	}
+	get #additionalMetadata() {
+		return decodeAdditionalMetadata(this.currentItemMetadata?.nowPlayingInfoData);
+	}
+	#identifier;
+	#displayName;
+	#nowPlayingInfo = null;
+	#playbackQueue = null;
+	#playbackState;
+	#playbackStateTimestamp = 0;
+	#supportedCommands = [];
+	constructor(identifier, displayName) {
+		this.#identifier = identifier;
+		this.#displayName = displayName;
+		this.#playbackState = 0;
+	}
+	findCommand(command) {
+		return this.#supportedCommands.find((commandInfo) => commandInfo.command === command) ?? null;
+	}
+	/** Whether the command is in the list and not disabled. */
+	isCommandSupported(command) {
+		const info = this.findCommand(command);
+		return info != null && info.enabled !== false;
+	}
+	setNowPlayingInfo(nowPlayingInfo) {
+		this.#nowPlayingInfo = nowPlayingInfo;
+	}
+	setPlaybackQueue(playbackQueue) {
+		this.#playbackQueue = playbackQueue;
+	}
+	/** Ignores an update with a timestamp older than the current one, so stale state never wins. */
+	setPlaybackState(playbackState, playbackStateTimestamp) {
+		if (playbackStateTimestamp < this.#playbackStateTimestamp) return;
+		this.#playbackState = playbackState;
+		this.#playbackStateTimestamp = playbackStateTimestamp;
+	}
+	setSupportedCommands(supportedCommands) {
+		this.#supportedCommands = supportedCommands;
+	}
+	/** Merges the fields an update carries into the queue item with the same identifier. */
+	updateContentItem(item) {
+		if (!this.#playbackQueue) return;
+		const existing = this.#playbackQueue.contentItems.find((contentItem) => contentItem.identifier === item.identifier);
+		if (!existing) return;
+		if (item.metadata != null && existing.metadata != null) {
+			for (const [key, value] of Object.entries(item.metadata)) if (value != null && !key.startsWith("$")) existing.metadata[key] = value;
+		} else if (item.metadata != null) existing.metadata = item.metadata;
+		if (item.artworkData != null) existing.artworkData = item.artworkData;
+		if (item.dataArtworks.length > 0) existing.dataArtworks = item.dataArtworks;
+		if (item.remoteArtworks.length > 0) existing.remoteArtworks = item.remoteArtworks;
+		if (item.animatedArtworks.length > 0) existing.animatedArtworks = item.animatedArtworks;
+		if (item.availableAnimatedArtworkFormats.length > 0) existing.availableAnimatedArtworkFormats = item.availableAnimatedArtworkFormats;
+		if (item.animatedArtworkPreviewFrames.length > 0) existing.animatedArtworkPreviewFrames = item.animatedArtworkPreviewFrames;
+		if (item.lyrics != null) existing.lyrics = item.lyrics;
+		if (item.info != null) existing.info = item.info;
+	}
+};
+
+//#endregion
+//#region src/mrp/client.ts
+/**
+* A now-playing app on the receiver, keyed by bundle identifier, with one or more players. The
+* now-playing getters read from the active player.
+*/
+var Client = class {
+	/** The bundle identifier of the app, such as `com.apple.TVMusic`. */
+	get bundleIdentifier() {
+		return this.#bundleIdentifier;
+	}
+	get displayName() {
+		return this.#displayName;
+	}
+	/** The players of this app, keyed by player identifier. */
+	get players() {
+		return this.#players;
+	}
+	/** The player set active, or the default player when none is set; null when that player does not exist. */
+	get activePlayer() {
+		return this.#players.get(this.#activePlayerId ?? "MediaRemote-DefaultPlayer") ?? null;
+	}
+	get nowPlayingInfo() {
+		return this.activePlayer?.nowPlayingInfo ?? null;
+	}
+	get playbackQueue() {
+		return this.activePlayer?.playbackQueue ?? null;
+	}
+	get playbackState() {
+		return this.activePlayer?.playbackState ?? 0;
+	}
+	/** The timestamp of the last playback state update, or -1 without an active player. */
+	get playbackStateTimestamp() {
+		return this.activePlayer?.playbackStateTimestamp ?? -1;
+	}
+	/** The commands of the active player, followed by the client defaults it does not list. */
+	get supportedCommands() {
+		const playerCommands = this.activePlayer?.supportedCommands ?? [];
+		if (playerCommands.length === 0) return this.#defaultSupportedCommands;
+		if (this.#defaultSupportedCommands.length === 0) return playerCommands;
+		const playerCommandSet = new Set(playerCommands.map((commandInfo) => commandInfo.command));
+		const merged = [...playerCommands];
+		for (const commandInfo of this.#defaultSupportedCommands) if (!playerCommandSet.has(commandInfo.command)) merged.push(commandInfo);
+		return merged;
+	}
+	get title() {
+		return this.activePlayer?.title ?? "";
+	}
+	get artist() {
+		return this.activePlayer?.artist ?? "";
+	}
+	get album() {
+		return this.activePlayer?.album ?? "";
+	}
+	get genre() {
+		return this.activePlayer?.genre ?? "";
+	}
+	get seriesName() {
+		return this.activePlayer?.seriesName ?? "";
+	}
+	get seasonNumber() {
+		return this.activePlayer?.seasonNumber ?? 0;
+	}
+	get episodeNumber() {
+		return this.activePlayer?.episodeNumber ?? 0;
+	}
+	get episodeTitle() {
+		return this.activePlayer?.episodeTitle ?? "";
+	}
+	get contentRating() {
+		return this.activePlayer?.contentRating ?? "";
+	}
+	get mediaType() {
+		return this.activePlayer?.mediaType ?? 0;
+	}
+	get contentIdentifier() {
+		return this.activePlayer?.contentIdentifier ?? "";
+	}
+	/** The duration of the current item in seconds. */
+	get duration() {
+		return this.activePlayer?.duration ?? 0;
+	}
+	/** The playback rate, where 1 is normal speed and 0 is paused. */
+	get playbackRate() {
+		return this.activePlayer?.playbackRate ?? 0;
+	}
+	get isPlaying() {
+		return this.activePlayer?.isPlaying ?? false;
+	}
+	get shuffleMode() {
+		return this.activePlayer?.shuffleMode ?? 0;
+	}
+	get repeatMode() {
+		return this.activePlayer?.repeatMode ?? 0;
+	}
+	/** The elapsed time in seconds, extrapolated to now. */
+	get elapsedTime() {
+		return this.activePlayer?.elapsedTime ?? 0;
+	}
+	/** An identifier that changes with the artwork, or null without artwork. */
+	get artworkId() {
+		return this.activePlayer?.artworkId ?? null;
+	}
+	/**
+	* The artwork URL of the current item; see {@link Player.artworkUrl}.
+	*
+	* @param width - In pixels.
+	* @param height - In pixels; -1 keeps the aspect ratio.
+	*/
+	artworkUrl(width = 600, height = -1) {
+		return this.activePlayer?.artworkUrl(width, height) ?? null;
+	}
+	get currentItem() {
+		return this.activePlayer?.currentItem ?? null;
+	}
+	get currentItemMetadata() {
+		return this.activePlayer?.currentItemMetadata ?? null;
+	}
+	/** The image bytes embedded in the current item, or null. */
+	get currentItemArtwork() {
+		return this.activePlayer?.currentItemArtwork ?? null;
+	}
+	/** The artwork URL at 600 pixels wide, or null. */
+	get currentItemArtworkUrl() {
+		return this.activePlayer?.currentItemArtworkUrl ?? null;
+	}
+	get currentItemLyrics() {
+		return this.activePlayer?.currentItemLyrics ?? null;
+	}
+	#bundleIdentifier;
+	#displayName;
+	#players = /* @__PURE__ */ new Map();
+	#activePlayerId = null;
+	#defaultSupportedCommands = [];
+	constructor(bundleIdentifier, displayName) {
+		this.#bundleIdentifier = bundleIdentifier;
+		this.#displayName = displayName;
+	}
+	/**
+	* Returns the player with this identifier, created when it does not exist yet.
+	*
+	* @param displayName - The name of a new player; the identifier when omitted.
+	*/
+	getOrCreatePlayer(identifier, displayName) {
+		let player = this.#players.get(identifier);
+		if (!player) {
+			player = new Player(identifier, displayName ?? identifier);
+			this.#players.set(identifier, player);
+		}
+		return player;
+	}
+	setActivePlayer(identifier) {
+		this.#activePlayerId = identifier;
+	}
+	/** Removes a player; removing the active one makes the default player active. */
+	removePlayer(identifier) {
+		this.#players.delete(identifier);
+		if (this.#activePlayerId === identifier) this.#activePlayerId = null;
+	}
+	/** Sets the commands that complete the list of the active player. */
+	setDefaultSupportedCommands(supportedCommands) {
+		this.#defaultSupportedCommands = supportedCommands;
+	}
+	/** Finds a command in the list of the active player first, then in the defaults. */
+	findCommand(command) {
+		const playerCommand = this.activePlayer?.findCommand(command) ?? null;
+		if (playerCommand) return playerCommand;
+		return this.#defaultSupportedCommands.find((commandInfo) => commandInfo.command === command) ?? null;
+	}
+	/** Whether {@link findCommand} finds the command and it is not disabled. */
+	isCommandSupported(command) {
+		const info = this.findCommand(command);
+		return info != null && info.enabled !== false;
+	}
+	updateDisplayName(displayName) {
+		this.#displayName = displayName;
+	}
+};
+
+//#endregion
+//#region src/mrp/state.ts
+/**
+* The MRP state of a receiver as a model: clients and their players, what plays now, volume,
+* keyboard, output devices and cluster. It derives everything from the messages it is given with
+* {@link apply} and does no I/O, so recorded traffic feeds it as well as a live data channel.
+*/
+var MediaRemoteState = class extends EventEmitter {
+	/** The now-playing apps, keyed by bundle identifier. */
+	get clients() {
+		return this.#clients;
+	}
+	/** Whether a text input session is open on the receiver. */
+	get isKeyboardActive() {
+		return this.#keyboardState === 2 || this.#keyboardState === 3 || this.#keyboardState === 4;
+	}
+	get keyboardAttributes() {
+		return this.#keyboardAttributes;
+	}
+	get keyboardState() {
+		return this.#keyboardState;
+	}
+	/** The app that plays now, or null when the receiver named none. */
+	get nowPlayingClient() {
+		return this.#nowPlayingClientBundleIdentifier ? this.#clients[this.#nowPlayingClientBundleIdentifier] ?? null : null;
+	}
+	/** The device that volume commands address; the cluster ID for a clustered HomePod pair. */
+	get outputDeviceUID() {
+		return this.#outputDeviceUID;
+	}
+	/** The devices in the current AirPlay group. */
+	get outputDevices() {
+		return this.#outputDevices;
+	}
+	/** The identifier of the multiroom cluster, or null outside one. */
+	get clusterID() {
+		return this.#clusterID;
+	}
+	/** The cluster type code, 0 outside a cluster. */
+	get clusterType() {
+		return this.#clusterType;
+	}
+	get isClusterAware() {
+		return this.#isClusterAware;
+	}
+	get isClusterLeader() {
+		return this.#isClusterLeader;
+	}
+	/** The playback queue participants, such as SharePlay users. */
+	get participants() {
+		return this.#participants;
+	}
+	/** The JPEG bytes of the last SET_ARTWORK, or null before one arrived. */
+	get artworkJpegData() {
+		return this.#artworkJpegData;
+	}
+	/** The volume, from 0 to 1. */
+	get volume() {
+		return this.#volume;
+	}
+	get volumeAvailable() {
+		return this.#volumeAvailable;
+	}
+	get volumeCapabilities() {
+		return this.#volumeCapabilities;
+	}
+	get volumeMuted() {
+		return this.#volumeMuted;
+	}
+	#clients;
+	#keyboardAttributes;
+	#keyboardState;
+	#nowPlayingClientBundleIdentifier;
+	#nowPlayingSnapshot;
+	#outputDeviceUID;
+	#outputDevices = [];
+	#clusterID;
+	#clusterType;
+	#isClusterAware;
+	#isClusterLeader;
+	#participants;
+	#artworkJpegData;
+	#volume;
+	#volumeAvailable;
+	#volumeCapabilities;
+	#volumeMuted;
+	constructor() {
+		super();
+		this.clear();
+	}
+	/**
+	* Applies one decoded message. Messages the state does not track are ignored.
+	*
+	* @example
+	* const decoded = decodeMessage(protocolMessage);
+	* decoded && state.apply(...decoded);
+	*/
+	apply(...[name, message]) {
+		switch (name) {
+			case "keyboard": return this.#onKeyboard(message);
+			case "deviceInfo":
+			case "deviceInfoUpdate": return this.#updateDeviceInfo(message);
+			case "removeClient": return this.#onRemoveClient(message);
+			case "removePlayer": return this.#onRemovePlayer(message);
+			case "sendLyricsEvent": return this.#onSendLyricsEvent(message);
+			case "setArtwork": return this.#onSetArtwork(message);
+			case "setDefaultSupportedCommands": return this.#onSetDefaultSupportedCommands(message);
+			case "setNowPlayingClient": return this.#onSetNowPlayingClient(message);
+			case "setNowPlayingPlayer": return this.#onSetNowPlayingPlayer(message);
+			case "setState": return this.#onSetState(message);
+			case "updateClient": return this.#onUpdateClient(message);
+			case "updateContentItem": return this.#onUpdateContentItem(message);
+			case "updateContentItemArtwork": return this.#onUpdateContentItemArtwork(message);
+			case "updatePlayer": return this.#onUpdatePlayer(message);
+			case "playerClientParticipantsUpdate": return this.#onPlayerClientParticipantsUpdate(message);
+			case "updateOutputDevice": return this.#onUpdateOutputDevice(message);
+			case "volumeControlAvailability": return this.#onVolumeControlAvailability(message);
+			case "volumeControlCapabilitiesDidChange": return this.#onVolumeControlCapabilitiesDidChange(message);
+			case "volumeDidChange": return this.#onVolumeDidChange(message);
+			case "volumeMutedDidChange": return this.#onVolumeMutedDidChange(message);
+		}
+	}
+	/**
+	* Resets every value to its initial one. A state that outlives a session is cleared when the
+	* next one connects, not when the last one ends.
+	*/
+	clear() {
+		this.#clients = {};
+		this.#keyboardAttributes = null;
+		this.#keyboardState = 0;
+		this.#nowPlayingClientBundleIdentifier = null;
+		this.#nowPlayingSnapshot = null;
+		this.#outputDeviceUID = null;
+		this.#outputDevices = [];
+		this.#clusterID = null;
+		this.#clusterType = 0;
+		this.#isClusterAware = false;
+		this.#isClusterLeader = false;
+		this.#participants = [];
+		this.#artworkJpegData = null;
+		this.#volume = 0;
+		this.#volumeAvailable = false;
+		this.#volumeCapabilities = 0;
+		this.#volumeMuted = false;
+	}
+	#onKeyboard(message) {
+		this.#keyboardState = message.state;
+		this.#keyboardAttributes = message.attributes ?? null;
+		this.emit("keyboardChanged", this.#keyboardState, this.#keyboardAttributes);
+	}
+	#onRemoveClient(message) {
+		if (!message.client?.bundleIdentifier) return;
+		if (!(message.client.bundleIdentifier in this.#clients)) return;
+		const wasActive = this.#nowPlayingClientBundleIdentifier === message.client.bundleIdentifier;
+		delete this.#clients[message.client.bundleIdentifier];
+		if (wasActive) this.#nowPlayingClientBundleIdentifier = null;
+		this.emit("clients", this.#clients);
+		if (wasActive) {
+			this.#emitActivePlayerChanged();
+			this.#emitNowPlayingChangedIfNeeded();
+		}
+	}
+	#onSendLyricsEvent(message) {
+		if (message.event) this.emit("lyricsEvent", message.event, message.playerPath);
+	}
+	#onSetArtwork(message) {
+		if (message.jpegData?.byteLength > 0) this.#artworkJpegData = message.jpegData;
+		const client = this.nowPlayingClient;
+		const player = client?.activePlayer;
+		if (client && player) this.emit("artworkChanged", client, player);
+	}
+	#onSetDefaultSupportedCommands(message) {
+		if (!message.playerPath?.client?.bundleIdentifier || !message.supportedCommands) return;
+		this.#client(message.playerPath.client.bundleIdentifier, message.playerPath.client.displayName).setDefaultSupportedCommands(message.supportedCommands.supportedCommands);
+	}
+	#onSetNowPlayingClient(message) {
+		const oldBundleId = this.#nowPlayingClientBundleIdentifier;
+		this.#nowPlayingClientBundleIdentifier = message.client?.bundleIdentifier ?? null;
+		if (message.client?.bundleIdentifier && message.client?.displayName) this.#client(message.client.bundleIdentifier, message.client.displayName);
+		if (oldBundleId !== this.#nowPlayingClientBundleIdentifier) this.#emitActivePlayerChanged();
+		this.#emitNowPlayingChangedIfNeeded();
+	}
+	#onSetNowPlayingPlayer(message) {
+		if (message.playerPath?.client?.bundleIdentifier && message.playerPath?.player?.identifier) {
+			const client = this.#client(message.playerPath.client.bundleIdentifier, message.playerPath.client.displayName);
+			const oldActiveId = client.activePlayer?.identifier;
+			client.getOrCreatePlayer(message.playerPath.player.identifier, message.playerPath.player.displayName);
+			client.setActivePlayer(message.playerPath.player.identifier);
+			if (oldActiveId !== message.playerPath.player.identifier) this.#emitActivePlayerChanged();
+		}
+		this.#emitNowPlayingChangedIfNeeded();
+	}
+	/** One SET_STATE can carry playback state, now-playing info, commands and queue at once; only the active player of the active client emits. */
+	#onSetState(message) {
+		const bundleIdentifier = message.playerPath?.client?.bundleIdentifier;
+		if (!bundleIdentifier) return;
+		const client = this.#client(bundleIdentifier, message.displayName);
+		const playerIdentifier = message.playerPath?.player?.identifier || "MediaRemote-DefaultPlayer";
+		const player = client.getOrCreatePlayer(playerIdentifier, message.playerPath?.player?.displayName);
+		const isActive = bundleIdentifier === this.#nowPlayingClientBundleIdentifier && player === client.activePlayer;
+		if (message.playbackState) {
+			const oldState = player.playbackState;
+			player.setPlaybackState(message.playbackState, message.playbackStateTimestamp);
+			if (isActive && oldState !== player.playbackState) this.emit("playbackStateChanged", client, player, oldState, player.playbackState);
+		}
+		if (message.nowPlayingInfo) player.setNowPlayingInfo(message.nowPlayingInfo);
+		if (message.supportedCommands) {
+			player.setSupportedCommands(message.supportedCommands.supportedCommands);
+			if (isActive) this.emit("supportedCommandsChanged", client, player, player.supportedCommands);
+		}
+		if (message.playbackQueue) {
+			player.setPlaybackQueue(message.playbackQueue);
+			if (isActive) this.emit("playbackQueueChanged", client, player);
+		}
+		if (isActive) this.#emitNowPlayingChangedIfNeeded();
+	}
+	#onUpdateContentItem(message) {
+		const bundleIdentifier = message.playerPath?.client?.bundleIdentifier;
+		if (!bundleIdentifier) return;
+		const client = this.#client(bundleIdentifier, message.playerPath?.client?.displayName ?? "");
+		const playerIdentifier = message.playerPath?.player?.identifier || "MediaRemote-DefaultPlayer";
+		const player = client.getOrCreatePlayer(playerIdentifier, message.playerPath?.player?.displayName);
+		for (const item of message.contentItems) player.updateContentItem(item);
+		if (bundleIdentifier === this.#nowPlayingClientBundleIdentifier) this.#emitNowPlayingChangedIfNeeded();
+	}
+	#onUpdateContentItemArtwork(message) {
+		const bundleIdentifier = message.playerPath?.client?.bundleIdentifier;
+		if (bundleIdentifier) {
+			const client = this.#client(bundleIdentifier, message.playerPath?.client?.displayName ?? "");
+			const playerIdentifier = message.playerPath?.player?.identifier || "MediaRemote-DefaultPlayer";
+			const player = client.getOrCreatePlayer(playerIdentifier, message.playerPath?.player?.displayName);
+			for (const item of message.contentItems) player.updateContentItem(item);
+			if (bundleIdentifier === this.#nowPlayingClientBundleIdentifier) this.#emitNowPlayingChangedIfNeeded();
+		}
+		const client = this.nowPlayingClient;
+		const player = client?.activePlayer;
+		if (client && player) this.emit("artworkChanged", client, player);
+	}
+	#onUpdatePlayer(message) {
+		if (!message.playerPath?.client?.bundleIdentifier || !message.playerPath?.player?.identifier) return;
+		this.#client(message.playerPath.client.bundleIdentifier, message.playerPath.client.displayName).getOrCreatePlayer(message.playerPath.player.identifier, message.playerPath.player.displayName);
+	}
+	#onRemovePlayer(message) {
+		if (message.playerPath?.client?.bundleIdentifier && message.playerPath?.player?.identifier) {
+			const client = this.#clients[message.playerPath.client.bundleIdentifier];
+			if (client) client.removePlayer(message.playerPath.player.identifier);
+		}
+		if (message.playerPath?.client?.bundleIdentifier === this.#nowPlayingClientBundleIdentifier) {
+			this.#emitActivePlayerChanged();
+			this.#emitNowPlayingChangedIfNeeded();
+		}
+	}
+	#onUpdateClient(message) {
+		if (!message.client?.bundleIdentifier) return;
+		this.#client(message.client.bundleIdentifier, message.client.displayName);
+		this.emit("clients", this.#clients);
+	}
+	#onPlayerClientParticipantsUpdate(message) {
+		this.#participants = message.participants ?? [];
+		this.emit("participantsChanged", this.#participants);
+	}
+	/** Prefers the cluster-aware list when the receiver sends one. */
+	#onUpdateOutputDevice(message) {
+		this.#outputDevices = message.clusterAwareOutputDevices?.length > 0 ? message.clusterAwareOutputDevices : message.outputDevices;
+		this.emit("outputDevicesChanged", this.#outputDevices);
+	}
+	#onVolumeControlAvailability(message) {
+		this.#volumeAvailable = message.volumeControlAvailable;
+		this.#volumeCapabilities = message.volumeCapabilities;
+		this.emit("volumeControlChanged", this.#volumeAvailable, this.#volumeCapabilities);
+	}
+	#onVolumeControlCapabilitiesDidChange(message) {
+		if (!message.capabilities) return;
+		this.#volumeAvailable = message.capabilities.volumeControlAvailable;
+		this.#volumeCapabilities = message.capabilities.volumeCapabilities;
+		this.emit("volumeControlChanged", this.#volumeAvailable, this.#volumeCapabilities);
+	}
+	#onVolumeDidChange(message) {
+		this.#volume = message.volume;
+		this.emit("volumeChanged", message.volume);
+	}
+	#onVolumeMutedDidChange(message) {
+		this.#volumeMuted = message.isMuted;
+		this.emit("volumeMutedChanged", this.#volumeMuted);
+	}
+	/** The cluster ID wins over the device UID, so volume commands address a clustered HomePod pair as one device. */
+	#updateDeviceInfo(message) {
+		const previousClusterID = this.#clusterID;
+		const previousIsLeader = this.#isClusterLeader;
+		this.#outputDeviceUID = message.clusterID || message.deviceUID || message.uniqueIdentifier || null;
+		this.#clusterID = message.clusterID || null;
+		this.#clusterType = message.clusterType ?? 0;
+		this.#isClusterAware = message.isClusterAware ?? false;
+		this.#isClusterLeader = message.isClusterLeader ?? false;
+		if (this.#clusterID !== previousClusterID || this.#isClusterLeader !== previousIsLeader) this.emit("clusterChanged", this.#clusterID, this.#isClusterLeader);
+	}
+	/** Gets or creates the client; a non-empty display name replaces the known one. */
+	#client(bundleIdentifier, displayName) {
+		if (bundleIdentifier in this.#clients) {
+			const client = this.#clients[bundleIdentifier];
+			if (displayName) client.updateDisplayName(displayName);
+			return client;
+		}
+		const client = new Client(bundleIdentifier, displayName);
+		this.#clients[bundleIdentifier] = client;
+		this.emit("clients", this.#clients);
+		return client;
+	}
+	#createNowPlayingSnapshot() {
+		const client = this.nowPlayingClient;
+		const player = client?.activePlayer ?? null;
+		const metadata = player?.currentItemMetadata;
+		return {
+			bundleIdentifier: client?.bundleIdentifier ?? null,
+			displayName: client?.displayName ?? null,
+			playerIdentifier: player?.identifier ?? null,
+			playbackState: player?.playbackState ?? 0,
+			title: player?.title ?? "",
+			artist: player?.artist ?? "",
+			trackArtist: metadata?.trackArtistName ?? "",
+			album: player?.album ?? "",
+			genre: player?.genre ?? "",
+			duration: player?.duration ?? 0,
+			playbackRate: player?.playbackRate ?? 0,
+			shuffleMode: player?.shuffleMode ?? 0,
+			repeatMode: player?.repeatMode ?? 0,
+			mediaType: player?.mediaType ?? 0,
+			seriesName: player?.seriesName ?? "",
+			seasonNumber: player?.seasonNumber ?? 0,
+			episodeNumber: player?.episodeNumber ?? 0,
+			episodeTitle: player?.episodeTitle ?? "",
+			contentRating: player?.contentRating ?? "",
+			contentIdentifier: player?.contentIdentifier ?? "",
+			storeAlbumId: String(metadata?.iTunesStoreAlbumIdentifier ?? ""),
+			lyricsId: String(metadata?.lyricsAdamID ?? ""),
+			artworkId: player?.artworkId ?? null,
+			hasArtworkUrl: player?.artworkUrl() != null,
+			hasArtworkData: player?.currentItemArtwork != null,
+			isAlwaysLive: player?.nowPlayingInfo?.isAlwaysLive ?? false,
+			isAdvertisement: player?.nowPlayingInfo?.isAdvertisement ?? false
+		};
+	}
+	#emitActivePlayerChanged() {
+		const client = this.nowPlayingClient;
+		this.emit("activePlayerChanged", client, client?.activePlayer ?? null);
+	}
+	#emitNowPlayingChangedIfNeeded() {
+		const snapshot = this.#createNowPlayingSnapshot();
+		const previous = this.#nowPlayingSnapshot;
+		if (previous && this.#snapshotsEqual(previous, snapshot)) return;
+		this.#nowPlayingSnapshot = snapshot;
+		const client = this.nowPlayingClient;
+		this.emit("nowPlayingChanged", client, client?.activePlayer ?? null);
+	}
+	#snapshotsEqual(a, b) {
+		return a.bundleIdentifier === b.bundleIdentifier && a.displayName === b.displayName && a.playerIdentifier === b.playerIdentifier && a.playbackState === b.playbackState && a.title === b.title && a.artist === b.artist && a.trackArtist === b.trackArtist && a.album === b.album && a.genre === b.genre && a.duration === b.duration && a.playbackRate === b.playbackRate && a.shuffleMode === b.shuffleMode && a.repeatMode === b.repeatMode && a.mediaType === b.mediaType && a.seriesName === b.seriesName && a.seasonNumber === b.seasonNumber && a.episodeNumber === b.episodeNumber && a.episodeTitle === b.episodeTitle && a.contentRating === b.contentRating && a.contentIdentifier === b.contentIdentifier && a.storeAlbumId === b.storeAlbumId && a.lyricsId === b.lyricsId && a.artworkId === b.artworkId && a.hasArtworkUrl === b.hasArtworkUrl && a.hasArtworkData === b.hasArtworkData && a.isAlwaysLive === b.isAlwaysLive && a.isAdvertisement === b.isAdvertisement;
+	}
+};
+
+//#endregion
+//#region src/mrp/volume.ts
+/** One step of {@link Volume.up} and {@link Volume.down} on the 0 to 1 scale. */
+const VOLUME_STEP = .05;
+/** Time between the steps of a fade, in milliseconds. */
+const FADE_STEP_INTERVAL = 50;
+/**
+* Volume of the receiver on a 0 to 1 scale. Absolute volume goes to the output device the state
+* names; a receiver that only supports relative volume gets the HID volume keys instead.
+*/
+var Volume = class {
+	#channel;
+	#context;
+	#hid;
+	#state;
+	constructor(channel, context, state, hid) {
+		this.#channel = channel;
+		this.#context = context;
+		this.#hid = hid;
+		this.#state = state;
+	}
+	/** @throws {CommandError} When the receiver has no volume control. */
+	async down() {
+		switch (this.#state.volumeCapabilities) {
+			case 2:
+			case 3:
+				await this.set(Math.max(0, this.#state.volume - VOLUME_STEP));
+				break;
+			case 1:
+				await this.#hid.volumeDown();
+				break;
+			default: throw new CommandError("Volume control is not available.");
+		}
+	}
+	/** @throws {CommandError} When the receiver has no volume control. */
+	async up() {
+		switch (this.#state.volumeCapabilities) {
+			case 2:
+			case 3:
+				await this.set(Math.min(1, Math.max(0, this.#state.volume + VOLUME_STEP)));
+				break;
+			case 1:
+				await this.#hid.volumeUp();
+				break;
+			default: throw new CommandError("Volume control is not available.");
+		}
+	}
+	/** @throws {CommandError} When no output device is active or the receiver answers otherwise. */
+	async get() {
+		return await this.#getVolume(this.#requireOutputDevice(), "Failed to get volume.");
+	}
+	/**
+	* Sets an absolute volume, clamped to 0 to 1.
+	*
+	* @throws {CommandError} When no output device is active or absolute volume is not available.
+	*/
+	async set(volume) {
+		const outputDeviceUID = this.#requireOutputDevice();
+		this.#requireAbsolute();
+		volume = Math.min(1, Math.max(0, volume));
+		this.#context.logger.info(`Setting volume to ${volume} for device ${outputDeviceUID}`);
+		await this.#channel.exchange(setVolume(outputDeviceUID, volume));
+	}
+	/** @throws {CommandError} When no output device is active. */
+	async mute() {
+		await this.#channel.exchange(setVolumeMuted(this.#requireOutputDevice(), true));
+	}
+	/** @throws {CommandError} When no output device is active. */
+	async unmute() {
+		await this.#channel.exchange(setVolumeMuted(this.#requireOutputDevice(), false));
+	}
+	/** @throws {CommandError} When no output device is active. */
+	async toggleMute() {
+		if (this.#state.volumeMuted) await this.unmute();
+		else await this.mute();
+	}
+	/** Sets the volume of one output device in a group, clamped to 0 to 1. */
+	async setForDevice(outputDeviceUID, volume) {
+		volume = Math.min(1, Math.max(0, volume));
+		this.#context.logger.info(`Setting volume to ${volume} for output device ${outputDeviceUID}`);
+		await this.#channel.exchange(setVolume(outputDeviceUID, volume));
+	}
+	/** @throws {CommandError} When the receiver answers otherwise. */
+	async getForDevice(outputDeviceUID) {
+		return await this.#getVolume(outputDeviceUID, "Failed to get volume for output device.");
+	}
+	async muteDevice(outputDeviceUID) {
+		await this.#channel.exchange(setVolumeMuted(outputDeviceUID, true));
+	}
+	async unmuteDevice(outputDeviceUID) {
+		await this.#channel.exchange(setVolumeMuted(outputDeviceUID, false));
+	}
+	/**
+	* Steps the volume of an output device up or down by a small, medium or large amount.
+	*
+	* @param outputDeviceUID - The active output device when omitted.
+	* @throws {CommandError} When no output device is given or active.
+	*/
+	async adjust(adjustment, outputDeviceUID) {
+		const uid = outputDeviceUID ?? this.#state.outputDeviceUID;
+		if (!uid) throw new CommandError("No output device active.");
+		await this.#channel.exchange(adjustVolume(adjustment, uid));
+	}
+	/** Asks the receiver to fade its audio: 0 fades out, 1 fades in. */
+	async audioFade(fadeType) {
+		this.#channel.send(audioFade(fadeType));
+	}
+	/**
+	* Fades to a volume in steps of {@link FADE_STEP_INTERVAL} ms; the last step sets the target exactly.
+	*
+	* @param durationMs - Duration of the fade in milliseconds.
+	* @throws {CommandError} When no output device is active or absolute volume is not available.
+	*/
+	async fade(targetVolume, durationMs) {
+		this.#requireOutputDevice();
+		this.#requireAbsolute();
+		targetVolume = Math.min(1, Math.max(0, targetVolume));
+		const startVolume = this.#state.volume;
+		const steps = Math.max(1, Math.floor(durationMs / FADE_STEP_INTERVAL));
+		const stepDuration = durationMs / steps;
+		const volumeDelta = (targetVolume - startVolume) / steps;
+		for (let i = 1; i <= steps; i++) {
+			const volume = i === steps ? targetVolume : Math.min(1, Math.max(0, startVolume + volumeDelta * i));
+			await this.set(volume);
+			if (i < steps) await waitFor(stepDuration);
+		}
+	}
+	async #getVolume(outputDeviceUID, failure) {
+		const response = await this.#channel.exchange(getVolume(outputDeviceUID));
+		if (response.type === 50) return getExtension(response, getVolumeResultMessage).volume;
+		throw new CommandError(failure);
+	}
+	#requireAbsolute() {
+		if (![2, 3].includes(this.#state.volumeCapabilities)) throw new CommandError("Absolute volume control is not available.");
+	}
+	#requireOutputDevice() {
+		const outputDeviceUID = this.#state.outputDeviceUID;
+		if (!outputDeviceUID) throw new CommandError("No output device active.");
+		return outputDeviceUID;
+	}
+};
+
+//#endregion
+//#region src/mrp/mediaRemote.ts
+/** The messages the state derives something from. */
+const STATE_MESSAGES = [
+	"keyboard",
+	"deviceInfo",
+	"deviceInfoUpdate",
+	"removeClient",
+	"removePlayer",
+	"sendLyricsEvent",
+	"setArtwork",
+	"setDefaultSupportedCommands",
+	"setNowPlayingClient",
+	"setNowPlayingPlayer",
+	"setState",
+	"updateClient",
+	"updateContentItem",
+	"updateContentItemArtwork",
+	"updatePlayer",
+	"playerClientParticipantsUpdate",
+	"updateOutputDevice",
+	"volumeControlAvailability",
+	"volumeControlCapabilitiesDidChange",
+	"volumeDidChange",
+	"volumeMutedDidChange"
+];
+/**
+* Remote control of a receiver over MRP, on the data channel of an AirPlay session. It owns the
+* state the messages feed and the parts that send: keys, commands, volume, text input, output
+* devices, the playback queue and artwork. It lives as long as its session.
+*/
+var MediaRemote = class MediaRemote {
+	/** The MRP data channel this remote sends on. */
+	get channel() {
+		return this.#channel;
+	}
+	artwork;
+	commands;
+	hid;
+	keyboard;
+	outputDevices;
+	playbackQueue;
+	state;
+	volume;
+	#channel;
+	#session;
+	#lastArtworkId = null;
+	/**
+	* Opens remote control on the session and runs the MRP startup: DEVICE_INFO as an exchange,
+	* then the connection state, the update subscription and GET_STATE, each sent without waiting.
+	* The state listens from before the data channel connects, so it misses nothing the receiver
+	* sends right away. A failed startup ends the session.
+	*
+	* @throws {SetupError} When a SETUP fails.
+	* @throws {TimeoutError} When DEVICE_INFO gets no reply.
+	* @throws {ConnectionClosedError} When the session ends during setup.
+	*/
+	static async open(session, options = {}) {
+		const state = options.state ?? new MediaRemoteState();
+		let remote;
+		const { events } = await session.openRemoteControl({ subscribe: (data) => {
+			remote = new MediaRemote(session, data, state);
+		} });
+		try {
+			await remote.#start();
+			if (session.signal.aborted) throw new ConnectionClosedError("AirPlay setup was interrupted.");
+			if (!session.control.isConnected || !remote.#channel.isConnected || !events.isConnected) throw new ConnectionClosedError("An AirPlay stream closed during setup.");
+		} catch (err) {
+			if (session.signal.aborted) throw err instanceof ConnectionClosedError ? err : new ConnectionClosedError("AirPlay setup was interrupted.");
+			session.context.logger.error("[device]", "Setup failed, cleaning up", err);
+			await session.close();
+			throw err;
+		}
+		session.context.logger.info("Protocol ready.");
+		return remote;
+	}
+	/** Use {@link open}. */
+	constructor(session, channel, state) {
+		this.#channel = channel;
+		this.#session = session;
+		this.state = state;
+		this.hid = new Hid(channel, state);
+		this.commands = new Commands(channel);
+		this.volume = new Volume(channel, session.context, state, this.hid);
+		this.keyboard = new Keyboard(channel);
+		this.outputDevices = new OutputDevices(channel, state);
+		this.playbackQueue = new PlaybackQueue(channel, state);
+		this.artwork = new Artwork(state, this.playbackQueue);
+		this.#feedState();
+	}
+	/** Wakes the receiver from sleep with a WAKE_DEVICE message. */
+	async wake() {
+		this.#channel.send(wakeDevice());
+	}
+	/** Forwards every message the state tracks, until the session ends. */
+	#feedState() {
+		const signal = this.#session.signal;
+		if (signal.aborted) return;
+		const channel = this.#channel;
+		const listeners = STATE_MESSAGES.map((name) => {
+			const listener = (message) => this.state.apply(...[name, message]);
+			channel.on(name, listener);
+			return [name, listener];
+		});
+		signal.addEventListener("abort", () => {
+			for (const [name, listener] of listeners) channel.off(name, listener);
+		}, { once: true });
+	}
+	/** Fetches the playback queue whenever the artwork changes, so its bytes or URL arrive. */
+	#onNowPlayingChanged(player) {
+		const artworkId = player?.artworkId ?? null;
+		if (artworkId === this.#lastArtworkId) return;
+		this.#lastArtworkId = artworkId;
+		this.playbackQueue.request(1).catch(() => {});
+	}
+	async #start() {
+		const channel = this.#channel;
+		await channel.exchange(deviceInfo(this.#session.pairingId, resolveIdentity(this.#session.context)));
+		channel.send(setConnectionState());
+		channel.send(clientUpdatesConfig(true, true, true, true));
+		channel.send(getState());
+		const listener = (_client, player) => this.#onNowPlayingChanged(player);
+		this.state.on("nowPlayingChanged", listener);
+		this.#session.signal.addEventListener("abort", () => this.state.off("nowPlayingChanged", listener), { once: true });
+	}
+};
+
+//#endregion
+export { Artwork, Client, Commands, DEFAULT_PLAYER_ID, Hid, Keyboard, MediaRemote, MediaRemoteState, messages_exports as Messages, OutputDevices, PlaybackQueue, Player, proto_exports as Proto, SendCommandError, Volume, decodeMessage, describeProtocolMessage, parseMessages };