@basmilius/apple-sdk 0.11.0

package/dist/index.mjs

@@ -0,0 +1,4590 @@
+import { EventEmitter } from "node:events";
+import { AirPlayFeatureFlags, CommandError, CredentialsError, Discovery, TimingServer, reporter, waitFor } from "@basmilius/apple-common";
+import { DataStreamMessage, Proto, Proto as Proto$1, Protocol } from "@basmilius/apple-airplay";
+import { MediaControlFlag, Protocol as Protocol$1, convertAttentionState } from "@basmilius/apple-companion-link";
+import { NSKeyedArchiver, Plist } from "@basmilius/apple-encoding";
+
+//#region src/configure.ts
+let globalStorage;
+let globalTimingServer;
+/**
+* Configures global settings for the Apple SDK.
+* Should be called once before creating any device instances.
+*/
+function configure(config) {
+	if (config.storage) globalStorage = config.storage;
+	if (config.timingServer) globalTimingServer = config.timingServer;
+	if (config.logging) {
+		reporter.none();
+		for (const group of config.logging) reporter.enable(group);
+	}
+}
+/**
+* @internal Returns the globally configured timing server, if any.
+*/
+function getGlobalTimingServer() {
+	return globalTimingServer;
+}
+
+//#endregion
+//#region src/controller/accounts.ts
+/**
+* User account controller for Apple TV devices.
+* Provides user account listing and switching.
+*/
+var AccountsController = class {
+	#companionLink;
+	constructor(companionLink) {
+		this.#companionLink = companionLink;
+	}
+	/**
+	* Returns the list of user accounts configured on the device.
+	*/
+	async list() {
+		return await this.#companionLink.getUserAccounts();
+	}
+	/**
+	* Switches to a different user account.
+	*
+	* @param accountId - The account ID to switch to.
+	*/
+	async switch(accountId) {
+		await this.#companionLink.switchUserAccount(accountId);
+	}
+};
+
+//#endregion
+//#region src/controller/apps.ts
+/**
+* App management controller for Apple TV devices.
+* Provides app launching and URL opening.
+*/
+var AppsController = class {
+	#companionLink;
+	constructor(companionLink) {
+		this.#companionLink = companionLink;
+	}
+	/**
+	* Returns the list of apps that can be launched on the device.
+	*/
+	async list() {
+		return await this.#companionLink.getLaunchableApps();
+	}
+	/**
+	* Launches an app by its bundle identifier.
+	*
+	* @param bundleId - The bundle identifier (e.g. 'com.netflix.Netflix').
+	*/
+	async launch(bundleId) {
+		await this.#companionLink.launchApp(bundleId);
+	}
+	/**
+	* Opens a URL on the device (universal link or app-specific URL scheme).
+	*
+	* @param url - The URL to open.
+	*/
+	async openUrl(url) {
+		await this.#companionLink.launchUrl(url);
+	}
+};
+
+//#endregion
+//#region src/controller/artwork.ts
+/**
+* Artwork controller for Apple devices.
+* Resolves artwork from all available sources with a 4-tier fallback.
+*/
+var ArtworkController = class {
+	#airplay;
+	constructor(airplay) {
+		this.#airplay = airplay;
+	}
+	/**
+	* Gets the current artwork for the active now-playing item.
+	*
+	* @param width - Desired width in pixels (default: 600).
+	* @param height - Desired height in pixels (-1 for proportional).
+	* @returns Artwork result with url, data, or both.
+	*/
+	async get(width = 600, height = -1) {
+		return await this.#airplay.artwork.get(width, height);
+	}
+};
+
+//#endregion
+//#region src/controller/keyboard.ts
+/**
+* Text input controller for Apple TV devices.
+* Provides keyboard control when a text field is active on the device.
+*/
+var KeyboardController = class {
+	#airplay;
+	constructor(airplay) {
+		this.#airplay = airplay;
+	}
+	/**
+	* Sets the text input field to the given text, replacing any existing content.
+	*/
+	async type(text) {
+		await this.#airplay.remote.textSet(text);
+	}
+	/**
+	* Appends text to the current text input field content.
+	*/
+	async append(text) {
+		await this.#airplay.remote.textAppend(text);
+	}
+	/**
+	* Clears the text input field.
+	*/
+	async clear() {
+		await this.#airplay.remote.textClear();
+	}
+	/**
+	* Fetches the current keyboard session state.
+	*/
+	async getSession() {
+		return await this.#airplay.remote.getKeyboardSession();
+	}
+};
+
+//#endregion
+//#region src/controller/media.ts
+/**
+* Media source controller for Apple devices.
+* Provides URL playback (device fetches and plays) and audio streaming (client sends PCM via RTP).
+*/
+var MediaController = class {
+	#airplay;
+	constructor(airplay) {
+		this.#airplay = airplay;
+	}
+	/**
+	* Plays a URL on the device. The device fetches and plays the content.
+	* Creates a separate protocol session to avoid conflicting with remote control.
+	*
+	* @param url - The media URL to play.
+	* @param position - Start position in seconds (default: 0).
+	*/
+	async playUrl(url, position = 0) {
+		await this.#airplay.playUrl(url, position);
+	}
+	/**
+	* Stops the current URL playback.
+	*/
+	stopPlayUrl() {
+		this.#airplay.stopPlayUrl();
+	}
+	/**
+	* Waits for the current URL playback to end naturally.
+	*/
+	async waitForPlaybackEnd() {
+		await this.#airplay.waitForPlaybackEnd();
+	}
+	/**
+	* Streams audio from a source to the device via RAOP/RTP.
+	* Creates a separate protocol session to avoid conflicting with remote control.
+	*
+	* @param source - The audio source to stream (MP3, OGG, WAV, PCM, FFmpeg, URL, live).
+	*/
+	async streamAudio(source) {
+		await this.#airplay.streamAudio(source);
+	}
+	/**
+	* Stops the current audio stream.
+	*/
+	stopStreamAudio() {
+		this.#airplay.stopStreamAudio();
+	}
+	/**
+	* Requests lyrics for the current playback.
+	*
+	* @param length - Maximum number of lyrics items to retrieve.
+	*/
+	async requestLyrics(length = 10) {
+		await this.#airplay.requestPlaybackQueue(length);
+	}
+};
+
+//#endregion
+//#region src/controller/multiroom.ts
+/**
+* Multi-room / cluster controller for Apple devices.
+* Manages output device groups for multi-room audio.
+*/
+var MultiroomController = class {
+	#airplay;
+	constructor(airplay) {
+		this.#airplay = airplay;
+	}
+	/**
+	* The cluster ID if the device is part of a multi-room group, or null.
+	*/
+	get clusterId() {
+		return this.#airplay.state.clusterID;
+	}
+	/**
+	* Whether this device is the leader of its multi-room cluster.
+	*/
+	get isLeader() {
+		return this.#airplay.state.isClusterLeader;
+	}
+	/**
+	* Whether this device is aware of cluster functionality.
+	*/
+	get isClusterAware() {
+		return this.#airplay.state.isClusterAware;
+	}
+	/**
+	* Adds devices to the current multi-room output context.
+	*
+	* @param deviceUIDs - UIDs of devices to add.
+	*/
+	async addDevice(...deviceUIDs) {
+		await this.#airplay.addOutputDevices(deviceUIDs);
+	}
+	/**
+	* Removes devices from the current multi-room output context.
+	*
+	* @param deviceUIDs - UIDs of devices to remove.
+	*/
+	async removeDevice(...deviceUIDs) {
+		await this.#airplay.removeOutputDevices(deviceUIDs);
+	}
+	/**
+	* Replaces the entire multi-room output context.
+	*
+	* @param deviceUIDs - UIDs of devices to set as the output context.
+	*/
+	async setDevices(...deviceUIDs) {
+		await this.#airplay.setOutputDevices(deviceUIDs);
+	}
+};
+
+//#endregion
+//#region src/controller/playback.ts
+/**
+* Media playback controller for Apple devices.
+* Provides play/pause/next/seek and other media commands via SendCommand (MRP protocol).
+*/
+var PlaybackController = class {
+	#airplay;
+	constructor(airplay) {
+		this.#airplay = airplay;
+	}
+	async play() {
+		await this.#airplay.remote.commandPlay();
+	}
+	async pause() {
+		await this.#airplay.remote.commandPause();
+	}
+	async playPause() {
+		await this.#airplay.remote.commandTogglePlayPause();
+	}
+	async stop() {
+		await this.#airplay.remote.commandStop();
+	}
+	async next() {
+		await this.#airplay.remote.commandNextTrack();
+	}
+	async previous() {
+		await this.#airplay.remote.commandPreviousTrack();
+	}
+	async skipForward(seconds = 15) {
+		await this.#airplay.remote.commandSkipForward(seconds);
+	}
+	async skipBackward(seconds = 15) {
+		await this.#airplay.remote.commandSkipBackward(seconds);
+	}
+	async seekTo(position) {
+		await this.#airplay.remote.commandSeekToPosition(position);
+	}
+	async setShuffleMode(mode) {
+		await this.#airplay.remote.commandSetShuffleMode(mode);
+	}
+	async setRepeatMode(mode) {
+		await this.#airplay.remote.commandSetRepeatMode(mode);
+	}
+	async advanceShuffleMode() {
+		await this.#airplay.remote.commandAdvanceShuffleMode();
+	}
+	async advanceRepeatMode() {
+		await this.#airplay.remote.commandAdvanceRepeatMode();
+	}
+	async setPlaybackRate(rate) {
+		await this.#airplay.remote.commandChangePlaybackRate(rate);
+	}
+	async setSleepTimer(seconds, stopMode = 0) {
+		await this.#airplay.remote.commandSetSleepTimer(seconds, stopMode);
+	}
+	async beginFastForward() {
+		await this.#airplay.remote.commandBeginFastForward();
+	}
+	async endFastForward() {
+		await this.#airplay.remote.commandEndFastForward();
+	}
+	async beginRewind() {
+		await this.#airplay.remote.commandBeginRewind();
+	}
+	async endRewind() {
+		await this.#airplay.remote.commandEndRewind();
+	}
+	async nextChapter() {
+		await this.#airplay.remote.commandNextChapter();
+	}
+	async previousChapter() {
+		await this.#airplay.remote.commandPreviousChapter();
+	}
+	async likeTrack() {
+		await this.#airplay.remote.commandLikeTrack();
+	}
+	async dislikeTrack() {
+		await this.#airplay.remote.commandDislikeTrack();
+	}
+	async bookmarkTrack() {
+		await this.#airplay.remote.commandBookmarkTrack();
+	}
+	async addToLibrary() {
+		await this.#airplay.remote.commandAddNowPlayingItemToLibrary();
+	}
+	/**
+	* Requests the playback queue from the device (includes artwork and metadata).
+	*
+	* @param length - Maximum number of queue items to retrieve (default: 1).
+	*/
+	async requestPlaybackQueue(length = 1) {
+		await this.#airplay.requestPlaybackQueue(length);
+	}
+	/**
+	* Checks whether a playback command is currently supported by the active media app.
+	*/
+	isCommandSupported(command) {
+		return this.#airplay.state.nowPlayingClient?.isCommandSupported(command) ?? false;
+	}
+};
+
+//#endregion
+//#region src/controller/power.ts
+/**
+* Power management controller for Apple TV devices.
+* Provides power on/off and attention state queries.
+*/
+var PowerController = class {
+	#airplay;
+	#companionLink;
+	constructor(airplay, companionLink) {
+		this.#airplay = airplay;
+		this.#companionLink = companionLink;
+	}
+	/**
+	* Turns on the device (sends wake HID key).
+	*/
+	async on() {
+		await this.#airplay.remote.wake();
+	}
+	/**
+	* Turns off the device (sends suspend HID key).
+	*/
+	async off() {
+		await this.#airplay.remote.suspend();
+	}
+	/**
+	* Gets the current attention state of the device.
+	*
+	* @returns The attention state ('active', 'idle', 'screensaver', etc.).
+	*/
+	async getState() {
+		return await this.#companionLink.getAttentionState();
+	}
+};
+
+//#endregion
+//#region src/controller/remote.ts
+/**
+* Remote controller for Apple devices.
+* Provides all HID-based keys (navigation, media, volume, power),
+* touch/swipe gestures, and low-level HID primitives.
+*/
+var RemoteController = class {
+	#airplay;
+	constructor(airplay) {
+		this.#airplay = airplay;
+	}
+	async up() {
+		await this.#airplay.remote.up();
+	}
+	async down() {
+		await this.#airplay.remote.down();
+	}
+	async left() {
+		await this.#airplay.remote.left();
+	}
+	async right() {
+		await this.#airplay.remote.right();
+	}
+	async select() {
+		await this.#airplay.remote.select();
+	}
+	async menu() {
+		await this.#airplay.remote.menu();
+	}
+	async home() {
+		await this.#airplay.remote.home();
+	}
+	async topMenu() {
+		await this.#airplay.remote.topMenu();
+	}
+	async play() {
+		await this.#airplay.remote.play();
+	}
+	async pause() {
+		await this.#airplay.remote.pause();
+	}
+	async playPause() {
+		await this.#airplay.remote.playPause();
+	}
+	async stop() {
+		await this.#airplay.remote.stop();
+	}
+	async next() {
+		await this.#airplay.remote.next();
+	}
+	async previous() {
+		await this.#airplay.remote.previous();
+	}
+	async channelUp() {
+		await this.#airplay.remote.channelUp();
+	}
+	async channelDown() {
+		await this.#airplay.remote.channelDown();
+	}
+	async volumeUp() {
+		await this.#airplay.remote.volumeUp();
+	}
+	async volumeDown() {
+		await this.#airplay.remote.volumeDown();
+	}
+	async mute() {
+		await this.#airplay.remote.mute();
+	}
+	async wake() {
+		await this.#airplay.remote.wake();
+	}
+	async suspend() {
+		await this.#airplay.remote.suspend();
+	}
+	async tap(x, y, finger = 1) {
+		await this.#airplay.remote.tap(x, y, finger);
+	}
+	async swipe(direction, duration = 200) {
+		switch (direction) {
+			case "up":
+				await this.#airplay.remote.swipeUp(duration);
+				break;
+			case "down":
+				await this.#airplay.remote.swipeDown(duration);
+				break;
+			case "left":
+				await this.#airplay.remote.swipeLeft(duration);
+				break;
+			case "right":
+				await this.#airplay.remote.swipeRight(duration);
+				break;
+		}
+	}
+	async pressAndRelease(usePage, usage) {
+		await this.#airplay.remote.pressAndRelease(usePage, usage);
+	}
+	async longPress(usePage, usage, duration = 1e3) {
+		await this.#airplay.remote.longPress(usePage, usage, duration);
+	}
+	async doublePress(usePage, usage) {
+		await this.#airplay.remote.doublePress(usePage, usage);
+	}
+};
+
+//#endregion
+//#region src/controller/state.ts
+/**
+* Now-playing state controller.
+* Provides read-only getters for the current playback state and emits
+* typed events when state changes occur.
+*/
+var StateController = class extends EventEmitter {
+	#airplay;
+	constructor(airplay) {
+		super();
+		this.#airplay = airplay;
+	}
+	get #state() {
+		return this.#airplay.state;
+	}
+	get title() {
+		return this.#state.nowPlayingClient?.title ?? "";
+	}
+	get artist() {
+		return this.#state.nowPlayingClient?.artist ?? "";
+	}
+	get album() {
+		return this.#state.nowPlayingClient?.album ?? "";
+	}
+	get genre() {
+		return this.#state.nowPlayingClient?.genre ?? "";
+	}
+	get duration() {
+		return this.#state.nowPlayingClient?.duration ?? 0;
+	}
+	get elapsedTime() {
+		return this.#state.nowPlayingClient?.elapsedTime ?? 0;
+	}
+	get playbackRate() {
+		return this.#state.nowPlayingClient?.playbackRate ?? 0;
+	}
+	get isPlaying() {
+		return this.#state.nowPlayingClient?.isPlaying ?? false;
+	}
+	get playbackState() {
+		return this.#state.nowPlayingClient?.playbackState;
+	}
+	get mediaType() {
+		return this.#state.nowPlayingClient?.mediaType;
+	}
+	get shuffleMode() {
+		return this.#state.nowPlayingClient?.shuffleMode;
+	}
+	get repeatMode() {
+		return this.#state.nowPlayingClient?.repeatMode;
+	}
+	get activeApp() {
+		const client = this.#state.nowPlayingClient;
+		if (!client) return null;
+		return {
+			bundleIdentifier: client.bundleIdentifier,
+			displayName: client.displayName
+		};
+	}
+	get volume() {
+		return this.#state.volume;
+	}
+	get isMuted() {
+		return this.#state.volumeMuted;
+	}
+	get volumeAvailable() {
+		return this.#state.volumeAvailable;
+	}
+	get isKeyboardActive() {
+		return this.#state.keyboardState !== void 0;
+	}
+	get clusterId() {
+		return this.#state.clusterID;
+	}
+	get isClusterLeader() {
+		return this.#state.isClusterLeader;
+	}
+	get outputDevices() {
+		return this.#state.outputDevices;
+	}
+	get clients() {
+		return this.#state.clients;
+	}
+	get activeClient() {
+		return this.#state.nowPlayingClient;
+	}
+	get activePlayer() {
+		return this.#state.nowPlayingClient?.activePlayer ?? null;
+	}
+	isCommandSupported(command) {
+		return this.#state.nowPlayingClient?.isCommandSupported(command) ?? false;
+	}
+	getCommandInfo(command) {
+		return this.#state.nowPlayingClient?.findCommand(command) ?? null;
+	}
+	/**
+	* Subscribes to the underlying AirPlayState events and re-emits them.
+	* Called internally by the device after connection is established.
+	* @internal
+	*/
+	subscribe() {
+		const state = this.#state;
+		state.on("nowPlayingChanged", (client, player) => {
+			this.emit("nowPlayingChanged", client, player);
+			const app = client ? {
+				bundleIdentifier: client.bundleIdentifier,
+				displayName: client.displayName
+			} : null;
+			this.emit("activeAppChanged", app?.bundleIdentifier ?? null, app?.displayName ?? null);
+		});
+		state.on("playbackStateChanged", (client, player, oldState, newState) => {
+			this.emit("playbackStateChanged", client, player, oldState, newState);
+		});
+		state.on("volumeDidChange", (volume) => {
+			this.emit("volumeChanged", volume);
+		});
+		state.on("volumeMutedDidChange", (muted) => {
+			this.emit("volumeMutedChanged", muted);
+		});
+		state.on("artworkChanged", (client, player) => {
+			this.emit("artworkChanged", client, player);
+		});
+		state.on("supportedCommandsChanged", (client, player, commands) => {
+			this.emit("supportedCommandsChanged", client, player, commands);
+		});
+		state.on("clusterChanged", (clusterId, isLeader) => {
+			this.emit("clusterChanged", clusterId, isLeader);
+		});
+	}
+	/**
+	* Removes all event listeners from this controller.
+	* @internal
+	*/
+	unsubscribe() {
+		this.removeAllListeners();
+	}
+};
+
+//#endregion
+//#region src/controller/system.ts
+/**
+* System controller for Apple TV devices.
+* Provides access to captions, appearance, Siri, and Up Next queue.
+*/
+var SystemController = class {
+	#companionLink;
+	constructor(companionLink) {
+		this.#companionLink = companionLink;
+	}
+	/**
+	* Toggles closed captions on the device.
+	*/
+	async toggleCaptions() {
+		await this.#companionLink.toggleCaptions();
+	}
+	/**
+	* Sets the system appearance.
+	*
+	* @param mode - 'light' or 'dark'.
+	*/
+	async setAppearance(mode) {
+		await this.#companionLink.toggleSystemAppearance(mode === "light");
+	}
+	/**
+	* Enables or disables the "Reduce Loud Sounds" setting.
+	*/
+	async setReduceLoudSounds(enabled) {
+		await this.#companionLink.toggleReduceLoudSounds(enabled);
+	}
+	/**
+	* Enables or disables Find My mode.
+	*/
+	async setFindingMode(enabled) {
+		await this.#companionLink.toggleFindingMode(enabled);
+	}
+	/**
+	* Starts a Siri session.
+	*/
+	async siriStart() {
+		await this.#companionLink.siriStart();
+	}
+	/**
+	* Stops the active Siri session.
+	*/
+	async siriStop() {
+		await this.#companionLink.siriStop();
+	}
+	/**
+	* Fetches the Up Next queue.
+	*
+	* @param paginationToken - Optional token for paginated results.
+	*/
+	async fetchUpNext(paginationToken) {
+		return await this.#companionLink.fetchUpNext(paginationToken);
+	}
+	/**
+	* Adds an item to the Up Next queue.
+	*/
+	async addToUpNext(identifier, kind) {
+		await this.#companionLink.addToUpNext(identifier, kind);
+	}
+	/**
+	* Removes an item from the Up Next queue.
+	*/
+	async removeFromUpNext(identifier, kind) {
+		await this.#companionLink.removeFromUpNext(identifier, kind);
+	}
+};
+
+//#endregion
+//#region src/controller/volume.ts
+/**
+* Volume controller for Apple devices.
+* Supports absolute volume (set level), relative volume (up/down),
+* muting, fading, and per-device volume in multi-room setups.
+*/
+var VolumeController = class {
+	#airplay;
+	constructor(airplay) {
+		this.#airplay = airplay;
+	}
+	async set(volume) {
+		await this.#airplay.volume.set(volume);
+	}
+	async get() {
+		return await this.#airplay.volume.get();
+	}
+	async up() {
+		await this.#airplay.volume.up();
+	}
+	async down() {
+		await this.#airplay.volume.down();
+	}
+	async mute() {
+		await this.#airplay.volume.mute();
+	}
+	async unmute() {
+		await this.#airplay.volume.unmute();
+	}
+	async toggleMute() {
+		await this.#airplay.volume.toggleMute();
+	}
+	async fade(targetVolume, durationMs) {
+		await this.#airplay.volume.fade(targetVolume, durationMs);
+	}
+	async setForDevice(outputDeviceUID, volume) {
+		await this.#airplay.volume.setForDevice(outputDeviceUID, volume);
+	}
+	async getForDevice(outputDeviceUID) {
+		return await this.#airplay.volume.getForDevice(outputDeviceUID);
+	}
+	async muteDevice(outputDeviceUID) {
+		await this.#airplay.volume.muteDevice(outputDeviceUID);
+	}
+	async unmuteDevice(outputDeviceUID) {
+		await this.#airplay.volume.unmuteDevice(outputDeviceUID);
+	}
+	async adjust(adjustment, outputDeviceUID) {
+		await this.#airplay.volume.adjust(adjustment, outputDeviceUID);
+	}
+};
+
+//#endregion
+//#region src/internal/const.ts
+/**
+* Interval in milliseconds between periodic feedback requests to keep the AirPlay session alive.
+*/
+const FEEDBACK_INTERVAL = 2e3;
+/**
+* Symbol used to access the underlying AirPlay Protocol instance from an AirPlayDevice.
+*/
+const PROTOCOL = Symbol("com.basmilius.airplay:protocol");
+/**
+* Symbol used to subscribe AirPlayState to DataStream events.
+*/
+const STATE_SUBSCRIBE_SYMBOL = Symbol("com.basmilius.airplay:subscribe");
+/**
+* Symbol used to unsubscribe AirPlayState from DataStream events.
+*/
+const STATE_UNSUBSCRIBE_SYMBOL = Symbol("com.basmilius.airplay:unsubscribe");
+/**
+* Symbol used to access the underlying Companion Link Protocol instance from a CompanionLinkManager.
+*/
+const COMPANION_LINK_PROTOCOL = Symbol("com.basmilius.companion-link:protocol");
+
+//#endregion
+//#region src/internal/airplay-artwork.ts
+/**
+* Unified artwork controller for an AirPlay device.
+*
+* Provides a single `get()` method that resolves artwork from all available
+* sources in priority order:
+* 1. URL from now-playing metadata (artworkURL, remoteArtworks, template)
+* 2. Inline binary data from the playback queue (artworkData, dataArtworks)
+* 3. JPEG data from SET_ARTWORK_MESSAGE
+* 4. Fetches the playback queue if artwork is expected but not yet available
+*/
+var AirPlayArtwork = class {
+	get #protocol() {
+		return this.#device[PROTOCOL];
+	}
+	get #state() {
+		return this.#device.state;
+	}
+	#device;
+	#lastIdentifier = null;
+	#cached = null;
+	constructor(device) {
+		this.#device = device;
+	}
+	/**
+	* Gets the current artwork for the active now-playing item.
+	*
+	* Tries all available sources in priority order and returns a unified result.
+	* Results are cached by artwork identifier — subsequent calls for the same
+	* track return the cached result without additional requests.
+	*
+	* @param width - Desired artwork width in pixels (default: 600).
+	* @param height - Desired artwork height in pixels (-1 for proportional).
+	* @returns The artwork result, or null if no artwork is available.
+	*/
+	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 url = player.artworkUrl(width, height);
+		if (url) return this.#cache(identifier, {
+			url,
+			data: null,
+			mimeType: guessMimeType(url),
+			identifier,
+			width,
+			height: height < 0 ? 0 : height
+		});
+		const inlineData = player.currentItemArtwork;
+		if (inlineData && inlineData.byteLength > 0) {
+			const metadata = player.currentItemMetadata;
+			return this.#cache(identifier, {
+				url: null,
+				data: inlineData,
+				mimeType: metadata?.artworkMIMEType || "image/jpeg",
+				identifier,
+				width: 0,
+				height: 0
+			});
+		}
+		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 {
+			const location = player.playbackQueue?.location ?? 0;
+			await this.#protocol.dataStream.exchange(DataStreamMessage.playbackQueueRequest(location, 1, width, height < 0 ? 400 : height));
+			const fetchedData = player.currentItemArtwork;
+			if (fetchedData && fetchedData.byteLength > 0) {
+				const metadata = player.currentItemMetadata;
+				return this.#cache(identifier, {
+					url: null,
+					data: fetchedData,
+					mimeType: metadata?.artworkMIMEType || "image/jpeg",
+					identifier,
+					width: 0,
+					height: 0
+				});
+			}
+			const retryUrl = player.artworkUrl(width, height);
+			if (retryUrl) return this.#cache(identifier, {
+				url: retryUrl,
+				data: null,
+				mimeType: guessMimeType(retryUrl),
+				identifier,
+				width,
+				height: height < 0 ? 0 : height
+			});
+		} catch {}
+		this.#lastIdentifier = null;
+		this.#cached = null;
+		return null;
+	}
+	/**
+	* Clears the cached artwork, forcing a fresh fetch on the next `get()` call.
+	*/
+	clear() {
+		this.#lastIdentifier = null;
+		this.#cached = null;
+	}
+	#cache(identifier, result) {
+		this.#lastIdentifier = identifier;
+		this.#cached = result;
+		return result;
+	}
+};
+const guessMimeType = (url) => {
+	if (url.includes(".png")) return "image/png";
+	if (url.includes(".webp")) return "image/webp";
+	return "image/jpeg";
+};
+
+//#endregion
+//#region src/internal/airplay-player.ts
+/**
+* Offset in seconds between the Cocoa epoch (2001-01-01) and the Unix epoch (1970-01-01).
+*/
+const COCOA_EPOCH_OFFSET = 978307200;
+/**
+* Default player identifier used by the Apple TV when no specific player is active.
+*/
+const DEFAULT_PLAYER_ID = "MediaRemote-DefaultPlayer";
+/**
+* Converts an artwork URL to a browser-compatible format.
+* Apple's CDN serves HEIC by default, which most browsers can't display.
+* Replacing the extension with .jpg makes the CDN return JPEG instead.
+*/
+const convertArtworkUrl = (url) => {
+	return url.replace(/\.heic(\b|$)/gi, ".jpg");
+};
+/**
+* Extrapolates the current elapsed time based on a snapshot timestamp and playback rate.
+* Compensates for the time passed since the timestamp was recorded, scaled by the playback rate.
+*
+* @param elapsed - The elapsed time at the moment of the snapshot, in seconds.
+* @param cocoaTimestamp - The Cocoa epoch timestamp when the snapshot was taken.
+* @param rate - The playback rate (e.g. 1.0 for normal speed, 0 for paused).
+* @returns The extrapolated elapsed time in seconds, clamped to a minimum of 0.
+*/
+const 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);
+};
+/**
+* Represents a single media player within an app on the Apple TV.
+* Each app (Client) can have multiple players (e.g. picture-in-picture).
+* Tracks now-playing metadata, playback state, and provides elapsed time extrapolation
+* based on Cocoa timestamps and playback rate.
+*/
+var AirPlayPlayer = class {
+	/**
+	* Unique identifier for this player (e.g. a player path).
+	*/
+	get identifier() {
+		return this.#identifier;
+	}
+	/**
+	* Human-readable display name for this player.
+	*/
+	get displayName() {
+		return this.#displayName;
+	}
+	/**
+	* Whether this is the default fallback player (MediaRemote-DefaultPlayer).
+	*/
+	get isDefaultPlayer() {
+		return this.#identifier === DEFAULT_PLAYER_ID;
+	}
+	/**
+	* Raw now-playing info from the Apple TV, or null if unavailable.
+	*/
+	get nowPlayingInfo() {
+		return this.#nowPlayingInfo;
+	}
+	/**
+	* Current playback queue, or null if unavailable.
+	*/
+	get playbackQueue() {
+		return this.#playbackQueue;
+	}
+	/**
+	* Effective playback state.
+	*/
+	get playbackState() {
+		return this.#playbackState;
+	}
+	/**
+	* Timestamp of the last playback state update, used to discard stale updates.
+	*/
+	get playbackStateTimestamp() {
+		return this.#playbackStateTimestamp;
+	}
+	/**
+	* List of commands supported by this player.
+	*/
+	get supportedCommands() {
+		return this.#supportedCommands;
+	}
+	/**
+	* Current track title from NowPlayingInfo or content item metadata.
+	*/
+	get title() {
+		return this.#nowPlayingInfo?.title || this.currentItemMetadata?.title || "";
+	}
+	/**
+	* Current track artist from NowPlayingInfo or content item metadata.
+	*/
+	get artist() {
+		return this.#nowPlayingInfo?.artist || this.currentItemMetadata?.trackArtistName || "";
+	}
+	/**
+	* Current track album from NowPlayingInfo or content item metadata.
+	*/
+	get album() {
+		return this.#nowPlayingInfo?.album || this.currentItemMetadata?.albumName || "";
+	}
+	/**
+	* Genre of the current content item.
+	*/
+	get genre() {
+		return this.currentItemMetadata?.genre || "";
+	}
+	/**
+	* Series name for TV show content.
+	*/
+	get seriesName() {
+		return this.currentItemMetadata?.seriesName || "";
+	}
+	/**
+	* Season number for TV show content, or 0 if not applicable.
+	*/
+	get seasonNumber() {
+		return this.currentItemMetadata?.seasonNumber || 0;
+	}
+	/**
+	* Episode number for TV show content, or 0 if not applicable.
+	*/
+	get episodeNumber() {
+		return this.currentItemMetadata?.episodeNumber || 0;
+	}
+	/**
+	* Media type of the current content item (music, video, etc.).
+	*/
+	get mediaType() {
+		return this.currentItemMetadata?.mediaType ?? Proto$1.ContentItemMetadata_MediaType.UnknownMediaType;
+	}
+	/**
+	* Unique content identifier for the current item (e.g. iTunes store ID).
+	*/
+	get contentIdentifier() {
+		return this.currentItemMetadata?.contentIdentifier || "";
+	}
+	/**
+	* Duration of the current track in seconds, from NowPlayingInfo or metadata.
+	*/
+	get duration() {
+		return this.#nowPlayingInfo?.duration || this.currentItemMetadata?.duration || 0;
+	}
+	/**
+	* Current playback rate (1.0 = normal, 0 = paused, 2.0 = double speed).
+	*/
+	get playbackRate() {
+		return this.#nowPlayingInfo?.playbackRate ?? this.currentItemMetadata?.playbackRate ?? 0;
+	}
+	/**
+	* Whether the player is currently playing (based on effective playback state).
+	*/
+	get isPlaying() {
+		return this.playbackState === Proto$1.PlaybackState_Enum.Playing;
+	}
+	/**
+	* Current shuffle mode, derived from the ChangeShuffleMode command info.
+	*/
+	get shuffleMode() {
+		return this.#supportedCommands.find((c) => c.command === Proto$1.Command.ChangeShuffleMode)?.shuffleMode ?? Proto$1.ShuffleMode_Enum.Unknown;
+	}
+	/**
+	* Current repeat mode, derived from the ChangeRepeatMode command info.
+	*/
+	get repeatMode() {
+		return this.#supportedCommands.find((c) => c.command === Proto$1.Command.ChangeRepeatMode)?.repeatMode ?? Proto$1.RepeatMode_Enum.Unknown;
+	}
+	/**
+	* Extrapolated elapsed time in seconds. Uses the most recent timestamp
+	* from either NowPlayingInfo or content item metadata, accounting for
+	* playback rate to provide a real-time estimate.
+	*/
+	get elapsedTime() {
+		const npi = this.#nowPlayingInfo;
+		const meta = this.currentItemMetadata;
+		const npiValid = npi?.elapsedTime != null && npi.timestamp != null && npi.timestamp !== 0;
+		const metaValid = meta?.elapsedTime != null && meta.elapsedTimeTimestamp != null && meta.elapsedTimeTimestamp !== 0;
+		if (npiValid && metaValid) {
+			if (meta.elapsedTimeTimestamp > npi.timestamp) return extrapolateElapsed(meta.elapsedTime, meta.elapsedTimeTimestamp, meta.playbackRate);
+			return extrapolateElapsed(npi.elapsedTime, npi.timestamp, npi.playbackRate);
+		}
+		if (npiValid) return extrapolateElapsed(npi.elapsedTime, npi.timestamp, npi.playbackRate);
+		if (metaValid) return extrapolateElapsed(meta.elapsedTime, meta.elapsedTimeTimestamp, meta.playbackRate);
+		return npi?.elapsedTime || meta?.elapsedTime || 0;
+	}
+	/**
+	* The currently playing content item from the playback queue, or null.
+	*/
+	get currentItem() {
+		if (!this.#playbackQueue || this.#playbackQueue.contentItems.length === 0) return null;
+		return this.#playbackQueue.contentItems[this.#playbackQueue.location] ?? this.#playbackQueue.contentItems[0] ?? null;
+	}
+	/**
+	* Metadata of the current content item, or null if no item is playing.
+	*/
+	get currentItemMetadata() {
+		return this.currentItem?.metadata ?? null;
+	}
+	/**
+	* Unique identifier for the current artwork, used for change detection.
+	* Returns null if no artwork evidence exists.
+	*/
+	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;
+	}
+	/**
+	* Resolves the best available artwork URL for the current item.
+	* Checks metadata artworkURL, remote artworks, and iTunes template URLs in order.
+	*
+	* @param width - Desired artwork width in pixels (used for template URLs).
+	* @param height - Desired artwork height in pixels (-1 for automatic).
+	* @returns The artwork URL, or null if no artwork URL is available.
+	*/
+	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) try {
+			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;
+		} catch {}
+		return null;
+	}
+	/**
+	* Raw artwork data (image bytes) for the current item, or null if not embedded.
+	*/
+	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;
+	}
+	/**
+	* Convenience getter for the artwork URL at default dimensions (600px).
+	*/
+	get currentItemArtworkUrl() {
+		return this.artworkUrl();
+	}
+	/**
+	* Lyrics for the current content item, or null if unavailable.
+	*/
+	get currentItemLyrics() {
+		return this.currentItem?.lyrics ?? null;
+	}
+	#identifier;
+	#displayName;
+	#nowPlayingInfo = null;
+	#playbackQueue = null;
+	#playbackState;
+	#playbackStateTimestamp = 0;
+	#supportedCommands = [];
+	/**
+	* Creates a new Player instance.
+	*
+	* @param identifier - Unique player identifier.
+	* @param displayName - Human-readable display name.
+	*/
+	constructor(identifier, displayName) {
+		this.#identifier = identifier;
+		this.#displayName = displayName;
+		this.#playbackState = Proto$1.PlaybackState_Enum.Unknown;
+	}
+	/**
+	* Finds a command by its command type in the supported commands list.
+	*
+	* @param command - The command to look up.
+	* @returns The command info, or null if not found.
+	*/
+	findCommand(command) {
+		return this.#supportedCommands.find((c) => c.command === command) ?? null;
+	}
+	/**
+	* Checks whether a command is supported and enabled.
+	*
+	* @param command - The command to check.
+	* @returns True if the command is in the supported list and enabled.
+	*/
+	isCommandSupported(command) {
+		const info = this.findCommand(command);
+		return info != null && info.enabled !== false;
+	}
+	/**
+	* Updates the now-playing info for this player.
+	*
+	* @param nowPlayingInfo - The new now-playing info from the Apple TV.
+	*/
+	setNowPlayingInfo(nowPlayingInfo) {
+		this.#nowPlayingInfo = nowPlayingInfo;
+	}
+	/**
+	* Updates the playback queue for this player.
+	*
+	* @param playbackQueue - The new playback queue from the Apple TV.
+	*/
+	setPlaybackQueue(playbackQueue) {
+		this.#playbackQueue = playbackQueue;
+	}
+	/**
+	* Updates the playback state. Ignores updates with a timestamp older than the current one
+	* to prevent stale state from overwriting newer data.
+	*
+	* @param playbackState - The new playback state.
+	* @param playbackStateTimestamp - Timestamp of this state update.
+	*/
+	setPlaybackState(playbackState, playbackStateTimestamp) {
+		if (playbackStateTimestamp < this.#playbackStateTimestamp) return;
+		this.#playbackState = playbackState;
+		this.#playbackStateTimestamp = playbackStateTimestamp;
+	}
+	/**
+	* Replaces the list of supported commands for this player.
+	*
+	* @param supportedCommands - The new list of supported commands.
+	*/
+	setSupportedCommands(supportedCommands) {
+		this.#supportedCommands = supportedCommands;
+	}
+	/**
+	* Merges updated content item data into the existing playback queue.
+	* Updates metadata, artwork, lyrics, and info fields for the matching item.
+	*
+	* @param item - The content item with updated fields.
+	*/
+	updateContentItem(item) {
+		if (!this.#playbackQueue) return;
+		const existing = this.#playbackQueue.contentItems.find((i) => i.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.lyrics != null) existing.lyrics = item.lyrics;
+		if (item.info != null) existing.info = item.info;
+	}
+};
+
+//#endregion
+//#region src/internal/airplay-client.ts
+/**
+* Represents a now-playing app (client) on the Apple TV.
+* Each client is identified by its bundle identifier and can contain multiple players.
+* Proxies now-playing getters to the active player, merging player-specific and
+* default supported commands.
+*/
+var AirPlayClient = class {
+	/**
+	* Bundle identifier of the app (e.g. "com.apple.TVMusic").
+	*/
+	get bundleIdentifier() {
+		return this.#bundleIdentifier;
+	}
+	/**
+	* Human-readable display name of the app.
+	*/
+	get displayName() {
+		return this.#displayName;
+	}
+	/**
+	* Map of all known players for this client, keyed by player identifier.
+	*/
+	get players() {
+		return this.#players;
+	}
+	/**
+	* The currently active player, or null if none is active. Falls back to the default player.
+	*/
+	get activePlayer() {
+		return this.#players.get(this.#activePlayerId ?? "MediaRemote-DefaultPlayer") ?? null;
+	}
+	/**
+	* Now-playing info from the active player, or null.
+	*/
+	get nowPlayingInfo() {
+		return this.activePlayer?.nowPlayingInfo ?? null;
+	}
+	/**
+	* Playback queue from the active player, or null.
+	*/
+	get playbackQueue() {
+		return this.activePlayer?.playbackQueue ?? null;
+	}
+	/**
+	* Playback state from the active player, or Unknown.
+	*/
+	get playbackState() {
+		return this.activePlayer?.playbackState ?? Proto$1.PlaybackState_Enum.Unknown;
+	}
+	/**
+	* Timestamp of the last playback state update from the active player.
+	*/
+	get playbackStateTimestamp() {
+		return this.activePlayer?.playbackStateTimestamp ?? -1;
+	}
+	/**
+	* Merged list of supported commands from the active player and client defaults.
+	* Player commands take precedence; default commands are appended if not already present.
+	*/
+	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((c) => c.command));
+		const merged = [...playerCommands];
+		for (const cmd of this.#defaultSupportedCommands) if (!playerCommandSet.has(cmd.command)) merged.push(cmd);
+		return merged;
+	}
+	/**
+	* Current track title from the active player.
+	*/
+	get title() {
+		return this.activePlayer?.title ?? "";
+	}
+	/**
+	* Current track artist from the active player.
+	*/
+	get artist() {
+		return this.activePlayer?.artist ?? "";
+	}
+	/**
+	* Current track album from the active player.
+	*/
+	get album() {
+		return this.activePlayer?.album ?? "";
+	}
+	/**
+	* Genre of the current content from the active player.
+	*/
+	get genre() {
+		return this.activePlayer?.genre ?? "";
+	}
+	/**
+	* Series name for TV show content from the active player.
+	*/
+	get seriesName() {
+		return this.activePlayer?.seriesName ?? "";
+	}
+	/**
+	* Season number for TV show content from the active player.
+	*/
+	get seasonNumber() {
+		return this.activePlayer?.seasonNumber ?? 0;
+	}
+	/**
+	* Episode number for TV show content from the active player.
+	*/
+	get episodeNumber() {
+		return this.activePlayer?.episodeNumber ?? 0;
+	}
+	/**
+	* Media type of the current content from the active player.
+	*/
+	get mediaType() {
+		return this.activePlayer?.mediaType ?? Proto$1.ContentItemMetadata_MediaType.UnknownMediaType;
+	}
+	/**
+	* Content identifier of the current item from the active player.
+	*/
+	get contentIdentifier() {
+		return this.activePlayer?.contentIdentifier ?? "";
+	}
+	/**
+	* Duration of the current track in seconds from the active player.
+	*/
+	get duration() {
+		return this.activePlayer?.duration ?? 0;
+	}
+	/**
+	* Playback rate from the active player (1.0 = normal, 0 = paused).
+	*/
+	get playbackRate() {
+		return this.activePlayer?.playbackRate ?? 0;
+	}
+	/**
+	* Whether the active player is currently playing.
+	*/
+	get isPlaying() {
+		return this.activePlayer?.isPlaying ?? false;
+	}
+	/**
+	* Current shuffle mode from the active player.
+	*/
+	get shuffleMode() {
+		return this.activePlayer?.shuffleMode ?? Proto$1.ShuffleMode_Enum.Unknown;
+	}
+	/**
+	* Current repeat mode from the active player.
+	*/
+	get repeatMode() {
+		return this.activePlayer?.repeatMode ?? Proto$1.RepeatMode_Enum.Unknown;
+	}
+	/**
+	* Extrapolated elapsed time in seconds from the active player.
+	*/
+	get elapsedTime() {
+		return this.activePlayer?.elapsedTime ?? 0;
+	}
+	/**
+	* Artwork identifier for change detection from the active player.
+	*/
+	get artworkId() {
+		return this.activePlayer?.artworkId ?? null;
+	}
+	/**
+	* Resolves the best available artwork URL from the active player.
+	*
+	* @param width - Desired artwork width in pixels.
+	* @param height - Desired artwork height in pixels (-1 for automatic).
+	* @returns The artwork URL, or null if unavailable.
+	*/
+	artworkUrl(width = 600, height = -1) {
+		return this.activePlayer?.artworkUrl(width, height) ?? null;
+	}
+	/**
+	* Current content item from the active player's playback queue.
+	*/
+	get currentItem() {
+		return this.activePlayer?.currentItem ?? null;
+	}
+	/**
+	* Metadata of the current content item from the active player.
+	*/
+	get currentItemMetadata() {
+		return this.activePlayer?.currentItemMetadata ?? null;
+	}
+	/**
+	* Raw artwork data (image bytes) from the active player.
+	*/
+	get currentItemArtwork() {
+		return this.activePlayer?.currentItemArtwork ?? null;
+	}
+	/**
+	* Artwork URL at default dimensions from the active player.
+	*/
+	get currentItemArtworkUrl() {
+		return this.activePlayer?.currentItemArtworkUrl ?? null;
+	}
+	/**
+	* Lyrics for the current content item from the active player.
+	*/
+	get currentItemLyrics() {
+		return this.activePlayer?.currentItemLyrics ?? null;
+	}
+	#bundleIdentifier;
+	#displayName;
+	#players = /* @__PURE__ */ new Map();
+	#activePlayerId = null;
+	#defaultSupportedCommands = [];
+	/**
+	* Creates a new Client instance.
+	*
+	* @param bundleIdentifier - Bundle identifier of the app.
+	* @param displayName - Human-readable app name.
+	*/
+	constructor(bundleIdentifier, displayName) {
+		this.#bundleIdentifier = bundleIdentifier;
+		this.#displayName = displayName;
+	}
+	/**
+	* Gets an existing player or creates a new one if it does not exist.
+	*
+	* @param identifier - Unique player identifier.
+	* @param displayName - Human-readable player name (defaults to identifier).
+	* @returns The existing or newly created Player.
+	*/
+	getOrCreatePlayer(identifier, displayName) {
+		let player = this.#players.get(identifier);
+		if (!player) {
+			player = new AirPlayPlayer(identifier, displayName ?? identifier);
+			this.#players.set(identifier, player);
+		}
+		return player;
+	}
+	/**
+	* Sets the active player by identifier.
+	*
+	* @param identifier - Identifier of the player to activate.
+	*/
+	setActivePlayer(identifier) {
+		this.#activePlayerId = identifier;
+	}
+	/**
+	* Removes a player from this client. If the removed player was active,
+	* the active player is reset to null (falling back to the default player).
+	*
+	* @param identifier - Identifier of the player to remove.
+	*/
+	removePlayer(identifier) {
+		this.#players.delete(identifier);
+		if (this.#activePlayerId === identifier) this.#activePlayerId = null;
+	}
+	/**
+	* Sets the default supported commands for this client. These are used as
+	* fallback when the active player has no commands of its own.
+	*
+	* @param supportedCommands - The default command list.
+	*/
+	setDefaultSupportedCommands(supportedCommands) {
+		this.#defaultSupportedCommands = supportedCommands;
+	}
+	/**
+	* Finds a command by type, checking the active player first,
+	* then falling back to the default supported commands.
+	*
+	* @param command - The command to look up.
+	* @returns The command info, or null if not found.
+	*/
+	findCommand(command) {
+		const playerCmd = this.activePlayer?.findCommand(command) ?? null;
+		if (playerCmd) return playerCmd;
+		return this.#defaultSupportedCommands.find((c) => c.command === command) ?? null;
+	}
+	/**
+	* Checks whether a command is supported and enabled, checking both
+	* the active player and default commands.
+	*
+	* @param command - The command to check.
+	* @returns True if the command is supported and enabled.
+	*/
+	isCommandSupported(command) {
+		const info = this.findCommand(command);
+		return info != null && info.enabled !== false;
+	}
+	/**
+	* Updates the display name for this client.
+	*
+	* @param displayName - The new display name.
+	*/
+	updateDisplayName(displayName) {
+		this.#displayName = displayName;
+	}
+};
+
+//#endregion
+//#region src/internal/airplay-remote.ts
+/**
+* Error thrown when a SendCommand request fails on the Apple TV side.
+* Contains the specific send error and handler return status for diagnostics.
+*/
+var SendCommandError = class extends CommandError {
+	/**
+	* The send error reported by the Apple TV.
+	*/
+	sendError;
+	/**
+	* The handler return status reported by the Apple TV.
+	*/
+	handlerReturnStatus;
+	/**
+	* Creates a new SendCommandError.
+	*
+	* @param sendError - The send error code from the Apple TV.
+	* @param handlerReturnStatus - The handler return status from the Apple TV.
+	*/
+	constructor(sendError, handlerReturnStatus) {
+		super(`SendCommand failed: sendError=${Proto$1.SendError_Enum[sendError]}, handlerReturnStatus=${Proto$1.HandlerReturnStatus_Enum[handlerReturnStatus]}`);
+		this.name = "SendCommandError";
+		this.sendError = sendError;
+		this.handlerReturnStatus = handlerReturnStatus;
+	}
+};
+/**
+* Remote control for an AirPlay device.
+* Provides HID-based navigation and media keys (USB usage pages: Generic Desktop 0x01
+* and Consumer 0x0c), SendCommand-based media controls, keyboard/text input,
+* and touch/gesture simulation.
+*/
+var AirPlayRemote = class {
+	/**
+	* @returns The DataStream for sending HID events and commands.
+	*/
+	get #dataStream() {
+		return this.#protocol.dataStream;
+	}
+	/**
+	* @returns The underlying AirPlay Protocol instance.
+	*/
+	get #protocol() {
+		return this.#device[PROTOCOL];
+	}
+	#device;
+	/**
+	* Creates a new Remote controller.
+	*
+	* @param device - The AirPlay device to control.
+	*/
+	constructor(device) {
+		this.#device = device;
+	}
+	/**
+	* Sends an Up navigation key press (Generic Desktop, usage 0x8C).
+	*/
+	async up() {
+		await this.pressAndRelease(1, 140);
+	}
+	/**
+	* Sends a Down navigation key press (Generic Desktop, usage 0x8D).
+	*/
+	async down() {
+		await this.pressAndRelease(1, 141);
+	}
+	/**
+	* Sends a Left navigation key press (Generic Desktop, usage 0x8B).
+	*/
+	async left() {
+		await this.pressAndRelease(1, 139);
+	}
+	/**
+	* Sends a Right navigation key press (Generic Desktop, usage 0x8A).
+	*/
+	async right() {
+		await this.pressAndRelease(1, 138);
+	}
+	/**
+	* Sends a Menu key press (Generic Desktop, usage 0x86).
+	*/
+	async menu() {
+		await this.pressAndRelease(1, 134);
+	}
+	/**
+	* Sends a Select/Enter key press (Generic Desktop, usage 0x89).
+	*/
+	async select() {
+		await this.pressAndRelease(1, 137);
+	}
+	/**
+	* Sends a Home button press (Consumer, usage 0x40).
+	*/
+	async home() {
+		await this.pressAndRelease(12, 64);
+	}
+	/**
+	* Sends a Suspend/Sleep key press to put the device to sleep (Generic Desktop, usage 0x82).
+	*/
+	async suspend() {
+		await this.pressAndRelease(1, 130);
+	}
+	/**
+	* Sends a Wake key press to wake the device (Generic Desktop, usage 0x83).
+	*/
+	async wake() {
+		await this.pressAndRelease(1, 131);
+	}
+	/**
+	* Sends a Play key press (Consumer, usage 0xB0).
+	*/
+	async play() {
+		await this.pressAndRelease(12, 176);
+	}
+	/**
+	* Sends a Pause key press (Consumer, usage 0xB1).
+	*/
+	async pause() {
+		await this.pressAndRelease(12, 177);
+	}
+	/**
+	* Toggles play/pause based on the current playback state.
+	*/
+	async playPause() {
+		if (this.#device.state.nowPlayingClient?.isPlaying) await this.pause();
+		else await this.play();
+	}
+	/**
+	* Sends a Stop key press (Consumer, usage 0xB7).
+	*/
+	async stop() {
+		await this.pressAndRelease(12, 183);
+	}
+	/**
+	* Sends a Next Track key press (Consumer, usage 0xB5).
+	*/
+	async next() {
+		await this.pressAndRelease(12, 181);
+	}
+	/**
+	* Sends a Previous Track key press (Consumer, usage 0xB6).
+	*/
+	async previous() {
+		await this.pressAndRelease(12, 182);
+	}
+	/**
+	* Sends a Volume Up key press (Consumer, usage 0xE9).
+	*/
+	async volumeUp() {
+		await this.pressAndRelease(12, 233);
+	}
+	/**
+	* Sends a Volume Down key press (Consumer, usage 0xEA).
+	*/
+	async volumeDown() {
+		await this.pressAndRelease(12, 234);
+	}
+	/**
+	* Sends a Mute key press (Consumer, usage 0xE2).
+	*/
+	async mute() {
+		await this.pressAndRelease(12, 226);
+	}
+	/**
+	* Sends a Top Menu key press (Consumer, usage 0x60).
+	*/
+	async topMenu() {
+		await this.pressAndRelease(12, 96);
+	}
+	/**
+	* Sends a Channel Up key press (Consumer, usage 0x9C).
+	*/
+	async channelUp() {
+		await this.pressAndRelease(12, 156);
+	}
+	/**
+	* Sends a Channel Down key press (Consumer, usage 0x9D).
+	*/
+	async channelDown() {
+		await this.pressAndRelease(12, 157);
+	}
+	/**
+	* Sends a Play command via the MRP SendCommand protocol.
+	*/
+	async commandPlay() {
+		await this.#sendCommand(Proto$1.Command.Play);
+	}
+	/**
+	* Sends a Pause command via the MRP SendCommand protocol.
+	*/
+	async commandPause() {
+		await this.#sendCommand(Proto$1.Command.Pause);
+	}
+	/**
+	* Sends a TogglePlayPause command via the MRP SendCommand protocol.
+	*/
+	async commandTogglePlayPause() {
+		await this.#sendCommand(Proto$1.Command.TogglePlayPause);
+	}
+	/**
+	* Sends a Stop command via the MRP SendCommand protocol.
+	*/
+	async commandStop() {
+		await this.#sendCommand(Proto$1.Command.Stop);
+	}
+	/**
+	* Sends a NextTrack command via the MRP SendCommand protocol.
+	*/
+	async commandNextTrack() {
+		await this.#sendCommand(Proto$1.Command.NextTrack);
+	}
+	/**
+	* Sends a PreviousTrack command via the MRP SendCommand protocol.
+	*/
+	async commandPreviousTrack() {
+		await this.#sendCommand(Proto$1.Command.PreviousTrack);
+	}
+	/**
+	* Sends a SkipForward command with a configurable interval.
+	*
+	* @param interval - Seconds to skip forward (defaults to 15).
+	*/
+	async commandSkipForward(interval = 15) {
+		await this.#sendCommandRaw(DataStreamMessage.sendCommandWithSkipInterval(Proto$1.Command.SkipForward, interval));
+	}
+	/**
+	* Sends a SkipBackward command with a configurable interval.
+	*
+	* @param interval - Seconds to skip backward (defaults to 15).
+	*/
+	async commandSkipBackward(interval = 15) {
+		await this.#sendCommandRaw(DataStreamMessage.sendCommandWithSkipInterval(Proto$1.Command.SkipBackward, interval));
+	}
+	/**
+	* Seeks to an absolute playback position.
+	*
+	* @param position - The target position in seconds.
+	*/
+	async commandSeekToPosition(position) {
+		await this.#sendCommandRaw(DataStreamMessage.sendCommandWithPlaybackPosition(Proto$1.Command.SeekToPlaybackPosition, position));
+	}
+	/**
+	* Sets the shuffle mode.
+	*
+	* @param mode - The desired shuffle mode.
+	*/
+	async commandSetShuffleMode(mode) {
+		await this.#sendCommandRaw(DataStreamMessage.sendCommandWithShuffleMode(Proto$1.Command.ChangeShuffleMode, mode));
+	}
+	/**
+	* Sets the repeat mode.
+	*
+	* @param mode - The desired repeat mode.
+	*/
+	async commandSetRepeatMode(mode) {
+		await this.#sendCommandRaw(DataStreamMessage.sendCommandWithRepeatMode(Proto$1.Command.ChangeRepeatMode, mode));
+	}
+	/**
+	* Changes the playback rate (speed).
+	*
+	* @param rate - The desired playback rate (e.g. 1.0 for normal, 2.0 for double speed).
+	*/
+	async commandChangePlaybackRate(rate) {
+		await this.#sendCommandRaw(DataStreamMessage.sendCommandWithPlaybackRate(Proto$1.Command.ChangePlaybackRate, rate));
+	}
+	/**
+	* Cycles the shuffle mode to the next value.
+	*/
+	async commandAdvanceShuffleMode() {
+		await this.#sendCommand(Proto$1.Command.AdvanceShuffleMode);
+	}
+	/**
+	* Cycles the repeat mode to the next value.
+	*/
+	async commandAdvanceRepeatMode() {
+		await this.#sendCommand(Proto$1.Command.AdvanceRepeatMode);
+	}
+	/**
+	* Begins fast-forwarding playback.
+	*/
+	async commandBeginFastForward() {
+		await this.#sendCommand(Proto$1.Command.BeginFastForward);
+	}
+	/**
+	* Ends fast-forwarding playback.
+	*/
+	async commandEndFastForward() {
+		await this.#sendCommand(Proto$1.Command.EndFastForward);
+	}
+	/**
+	* Begins rewinding playback.
+	*/
+	async commandBeginRewind() {
+		await this.#sendCommand(Proto$1.Command.BeginRewind);
+	}
+	/**
+	* Ends rewinding playback.
+	*/
+	async commandEndRewind() {
+		await this.#sendCommand(Proto$1.Command.EndRewind);
+	}
+	/**
+	* Skips to the next chapter.
+	*/
+	async commandNextChapter() {
+		await this.#sendCommand(Proto$1.Command.NextChapter);
+	}
+	/**
+	* Skips to the previous chapter.
+	*/
+	async commandPreviousChapter() {
+		await this.#sendCommand(Proto$1.Command.PreviousChapter);
+	}
+	/**
+	* Marks the current track as liked.
+	*/
+	async commandLikeTrack() {
+		await this.#sendCommand(Proto$1.Command.LikeTrack);
+	}
+	/**
+	* Marks the current track as disliked.
+	*/
+	async commandDislikeTrack() {
+		await this.#sendCommand(Proto$1.Command.DislikeTrack);
+	}
+	/**
+	* Bookmarks the current track.
+	*/
+	async commandBookmarkTrack() {
+		await this.#sendCommand(Proto$1.Command.BookmarkTrack);
+	}
+	/**
+	* Adds the currently playing item to the user's library.
+	*/
+	async commandAddNowPlayingItemToLibrary() {
+		await this.#sendCommand(Proto$1.Command.AddNowPlayingItemToLibrary);
+	}
+	/**
+	* Sets a sleep timer that will stop playback after the specified duration.
+	* The timer works by attaching sleep timer options to a Pause command.
+	*
+	* @param seconds - Timer duration in seconds. Use 0 to cancel an active timer.
+	* @param stopMode - Stop mode: 0 = stop playback, 1 = pause, 2 = end of track, 3 = end of queue.
+	*/
+	async commandSetSleepTimer(seconds, stopMode = 0) {
+		await this.#sendCommandRaw(DataStreamMessage.sendCommandWithSleepTimer(seconds, stopMode));
+	}
+	/**
+	* Sets the text input field to the given text, replacing any existing content.
+	*
+	* @param text - The text to set.
+	*/
+	async textSet(text) {
+		await this.#dataStream.send(DataStreamMessage.textInput(text, Proto$1.ActionType_Enum.Set));
+	}
+	/**
+	* Appends text to the current text input field content.
+	*
+	* @param text - The text to append.
+	*/
+	async textAppend(text) {
+		await this.#dataStream.send(DataStreamMessage.textInput(text, Proto$1.ActionType_Enum.Insert));
+	}
+	/**
+	* Clears the text input field.
+	*/
+	async textClear() {
+		await this.#dataStream.send(DataStreamMessage.textInput("", Proto$1.ActionType_Enum.ClearAction));
+	}
+	/**
+	* Requests the current keyboard session state from the Apple TV.
+	*/
+	async getKeyboardSession() {
+		await this.#dataStream.send(DataStreamMessage.getKeyboardSession());
+	}
+	/**
+	* Simulates a tap at the given coordinates.
+	*
+	* @param x - Horizontal position in the virtual touch area.
+	* @param y - Vertical position in the virtual touch area.
+	* @param finger - Finger index for multi-touch (defaults to 1).
+	*/
+	async tap(x, y, finger = 1) {
+		await this.#sendTouch(x, y, 1, finger);
+		await waitFor(50);
+		await this.#sendTouch(x, y, 4, finger);
+	}
+	/**
+	* Simulates an upward swipe gesture.
+	*
+	* @param duration - Swipe duration in milliseconds (defaults to 200).
+	*/
+	async swipeUp(duration = 200) {
+		await this.#swipe(200, 400, 200, 100, duration);
+	}
+	/**
+	* Simulates a downward swipe gesture.
+	*
+	* @param duration - Swipe duration in milliseconds (defaults to 200).
+	*/
+	async swipeDown(duration = 200) {
+		await this.#swipe(200, 100, 200, 400, duration);
+	}
+	/**
+	* Simulates a leftward swipe gesture.
+	*
+	* @param duration - Swipe duration in milliseconds (defaults to 200).
+	*/
+	async swipeLeft(duration = 200) {
+		await this.#swipe(400, 200, 100, 200, duration);
+	}
+	/**
+	* Simulates a rightward swipe gesture.
+	*
+	* @param duration - Swipe duration in milliseconds (defaults to 200).
+	*/
+	async swipeRight(duration = 200) {
+		await this.#swipe(100, 200, 400, 200, duration);
+	}
+	/**
+	* Sends a double press of a HID key (two press-and-release cycles with a 150ms gap).
+	*
+	* @param usePage - USB HID usage page (1 = Generic Desktop, 12 = Consumer).
+	* @param usage - USB HID usage code.
+	*/
+	async doublePress(usePage, usage) {
+		await this.pressAndRelease(usePage, usage);
+		await waitFor(150);
+		await this.pressAndRelease(usePage, usage);
+	}
+	/**
+	* Sends a long press of a HID key (hold for a configurable duration).
+	*
+	* @param usePage - USB HID usage page (1 = Generic Desktop, 12 = Consumer).
+	* @param usage - USB HID usage code.
+	* @param duration - Hold duration in milliseconds (defaults to 1000).
+	*/
+	async longPress(usePage, usage, duration = 1e3) {
+		await this.#dataStream.exchange(DataStreamMessage.sendHIDEvent(usePage, usage, true));
+		await waitFor(duration);
+		await this.#dataStream.exchange(DataStreamMessage.sendHIDEvent(usePage, usage, false));
+	}
+	/**
+	* Sends a single press-and-release of a HID key with a 25ms hold.
+	*
+	* @param usePage - USB HID usage page (1 = Generic Desktop, 12 = Consumer).
+	* @param usage - USB HID usage code.
+	*/
+	async pressAndRelease(usePage, usage) {
+		await this.#dataStream.exchange(DataStreamMessage.sendHIDEvent(usePage, usage, true));
+		await waitFor(25);
+		await this.#dataStream.exchange(DataStreamMessage.sendHIDEvent(usePage, usage, false));
+	}
+	/**
+	* Sends a SendCommand request and checks the result.
+	*
+	* @param command - The command to send.
+	* @param options - Optional command options.
+	* @returns The command result message, or undefined if no result was returned.
+	* @throws SendCommandError when the Apple TV reports a send error.
+	*/
+	async #sendCommand(command, options) {
+		const response = await this.#dataStream.exchange(DataStreamMessage.sendCommand(command, options));
+		return this.#checkCommandResult(response);
+	}
+	/**
+	* Sends a pre-built command message and checks the result.
+	*
+	* @param message - The pre-built DataStream message to send.
+	* @returns The command result message, or undefined if no result was returned.
+	* @throws SendCommandError when the Apple TV reports a send error.
+	*/
+	async #sendCommandRaw(message) {
+		const response = await this.#dataStream.exchange(message);
+		return this.#checkCommandResult(response);
+	}
+	/**
+	* Validates the response from a SendCommand request and throws on error.
+	*
+	* @param response - The protocol message response.
+	* @returns The decoded result, or undefined if the response has no result extension.
+	* @throws SendCommandError when the result indicates a send error.
+	*/
+	#checkCommandResult(response) {
+		let result;
+		try {
+			result = DataStreamMessage.getExtension(response, Proto$1.sendCommandResultMessage);
+		} catch {
+			return;
+		}
+		if (!result) return;
+		if (result.sendError !== Proto$1.SendError_Enum.NoError) throw new SendCommandError(result.sendError, result.handlerReturnStatus);
+		return result;
+	}
+	/**
+	* Sends a virtual touch event at the given coordinates.
+	*
+	* @param x - Horizontal position.
+	* @param y - Vertical position.
+	* @param phase - Touch phase (1 = Began, 2 = Moved, 4 = Ended).
+	* @param finger - Finger index for multi-touch.
+	*/
+	async #sendTouch(x, y, phase, finger) {
+		await this.#dataStream.exchange(DataStreamMessage.sendVirtualTouchEvent(x, y, phase, finger));
+	}
+	/**
+	* Performs a swipe gesture by interpolating touch events between start and end coordinates.
+	*
+	* @param startX - Starting horizontal position.
+	* @param startY - Starting vertical position.
+	* @param endX - Ending horizontal position.
+	* @param endY - Ending vertical position.
+	* @param duration - Total swipe duration in milliseconds.
+	*/
+	async #swipe(startX, startY, endX, endY, duration) {
+		const steps = Math.max(4, Math.floor(duration / 50));
+		const deltaX = (endX - startX) / steps;
+		const deltaY = (endY - startY) / steps;
+		const stepDuration = duration / steps;
+		await this.#sendTouch(startX, startY, 1, 1);
+		for (let i = 1; i < steps; i++) {
+			await waitFor(stepDuration);
+			await this.#sendTouch(Math.round(startX + deltaX * i), Math.round(startY + deltaY * i), 2, 1);
+		}
+		await waitFor(stepDuration);
+		await this.#sendTouch(endX, endY, 4, 1);
+	}
+};
+
+//#endregion
+//#region src/internal/airplay-state.ts
+/**
+* Tracks the complete state of an AirPlay device: clients, players, now-playing,
+* volume, keyboard, output devices, and cluster info.
+* Listens to DataStream protocol messages and emits both low-level (1:1 with protocol)
+* and high-level (deduplicated, resolved) events.
+*/
+var AirPlayState = class extends EventEmitter {
+	/**
+	* @returns The DataStream for event subscription.
+	*/
+	get #dataStream() {
+		return this.#protocol.dataStream;
+	}
+	/**
+	* @returns The underlying AirPlay Protocol instance.
+	*/
+	get #protocol() {
+		return this.#device[PROTOCOL];
+	}
+	/**
+	* All known clients (apps) keyed by bundle identifier.
+	*/
+	get clients() {
+		return this.#clients;
+	}
+	/**
+	* Whether a keyboard/text input session is currently active on the Apple TV.
+	*/
+	get isKeyboardActive() {
+		return this.#keyboardState === Proto$1.KeyboardState_Enum.DidBeginEditing || this.#keyboardState === Proto$1.KeyboardState_Enum.Editing || this.#keyboardState === Proto$1.KeyboardState_Enum.TextDidChange;
+	}
+	/**
+	* Text editing attributes for the active keyboard session, or null.
+	*/
+	get keyboardAttributes() {
+		return this.#keyboardAttributes;
+	}
+	/**
+	* Current keyboard state enum value.
+	*/
+	get keyboardState() {
+		return this.#keyboardState;
+	}
+	/**
+	* The currently active now-playing client, or null if nothing is playing.
+	*/
+	get nowPlayingClient() {
+		return this.#nowPlayingClientBundleIdentifier ? this.#clients[this.#nowPlayingClientBundleIdentifier] ?? null : null;
+	}
+	/**
+	* UID of the primary output device (used for volume control and multi-room).
+	*/
+	get outputDeviceUID() {
+		return this.#outputDeviceUID;
+	}
+	/**
+	* List of all output device descriptors in the current AirPlay group.
+	*/
+	get outputDevices() {
+		return this.#outputDevices;
+	}
+	/**
+	* Cluster identifier for multi-room groups, or null.
+	*/
+	get clusterID() {
+		return this.#clusterID;
+	}
+	/**
+	* Cluster type code (0 if not clustered).
+	*/
+	get clusterType() {
+		return this.#clusterType;
+	}
+	/**
+	* Whether this device is aware of multi-room clusters.
+	*/
+	get isClusterAware() {
+		return this.#isClusterAware;
+	}
+	/**
+	* Whether this device is the leader of its multi-room cluster.
+	*/
+	get isClusterLeader() {
+		return this.#isClusterLeader;
+	}
+	/**
+	* Current playback queue participants (e.g. SharePlay users).
+	*/
+	get participants() {
+		return this.#participants;
+	}
+	/**
+	* Raw JPEG artwork data from the last SET_ARTWORK_MESSAGE, or null.
+	*/
+	get artworkJpegData() {
+		return this.#artworkJpegData;
+	}
+	/**
+	* Current volume level (0.0 - 1.0).
+	*/
+	get volume() {
+		return this.#volume;
+	}
+	/**
+	* Whether volume control is available on this device.
+	*/
+	get volumeAvailable() {
+		return this.#volumeAvailable;
+	}
+	/**
+	* Volume capabilities (absolute, relative, both, or none).
+	*/
+	get volumeCapabilities() {
+		return this.#volumeCapabilities;
+	}
+	/**
+	* Whether the device is currently muted.
+	*/
+	get volumeMuted() {
+		return this.#volumeMuted;
+	}
+	#device;
+	#clients;
+	#keyboardAttributes;
+	#keyboardState;
+	#nowPlayingClientBundleIdentifier;
+	#nowPlayingSnapshot;
+	#outputDeviceUID;
+	#outputDevices = [];
+	#clusterID;
+	#clusterType;
+	#isClusterAware;
+	#isClusterLeader;
+	#participants;
+	#artworkJpegData;
+	#volume;
+	#volumeAvailable;
+	#volumeCapabilities;
+	#volumeMuted;
+	/**
+	* Creates a new AirPlayState tracker.
+	*
+	* @param device - The AirPlay device to track state for.
+	*/
+	constructor(device) {
+		super();
+		this.#device = device;
+		this.clear();
+		this.onConfigureConnection = this.onConfigureConnection.bind(this);
+		this.onKeyboard = this.onKeyboard.bind(this);
+		this.onDeviceInfo = this.onDeviceInfo.bind(this);
+		this.onDeviceInfoUpdate = this.onDeviceInfoUpdate.bind(this);
+		this.onOriginClientProperties = this.onOriginClientProperties.bind(this);
+		this.onPlayerClientProperties = this.onPlayerClientProperties.bind(this);
+		this.onRemoveClient = this.onRemoveClient.bind(this);
+		this.onRemovePlayer = this.onRemovePlayer.bind(this);
+		this.onSendCommandResult = this.onSendCommandResult.bind(this);
+		this.onSendLyricsEvent = this.onSendLyricsEvent.bind(this);
+		this.onSetArtwork = this.onSetArtwork.bind(this);
+		this.onSetDefaultSupportedCommands = this.onSetDefaultSupportedCommands.bind(this);
+		this.onSetNowPlayingClient = this.onSetNowPlayingClient.bind(this);
+		this.onSetNowPlayingPlayer = this.onSetNowPlayingPlayer.bind(this);
+		this.onSetState = this.onSetState.bind(this);
+		this.onUpdateClient = this.onUpdateClient.bind(this);
+		this.onUpdateContentItem = this.onUpdateContentItem.bind(this);
+		this.onUpdateContentItemArtwork = this.onUpdateContentItemArtwork.bind(this);
+		this.onUpdatePlayer = this.onUpdatePlayer.bind(this);
+		this.onPlayerClientParticipantsUpdate = this.onPlayerClientParticipantsUpdate.bind(this);
+		this.onUpdateOutputDevice = this.onUpdateOutputDevice.bind(this);
+		this.onVolumeControlAvailability = this.onVolumeControlAvailability.bind(this);
+		this.onVolumeControlCapabilitiesDidChange = this.onVolumeControlCapabilitiesDidChange.bind(this);
+		this.onVolumeDidChange = this.onVolumeDidChange.bind(this);
+		this.onVolumeMutedDidChange = this.onVolumeMutedDidChange.bind(this);
+	}
+	/**
+	* Subscribes to all DataStream events to track device state. Called internally via symbol.
+	*/
+	[STATE_SUBSCRIBE_SYMBOL]() {
+		this.#dataStream.on("configureConnection", this.onConfigureConnection);
+		this.#dataStream.on("keyboard", this.onKeyboard);
+		this.#dataStream.on("deviceInfo", this.onDeviceInfo);
+		this.#dataStream.on("deviceInfoUpdate", this.onDeviceInfoUpdate);
+		this.#dataStream.on("originClientProperties", this.onOriginClientProperties);
+		this.#dataStream.on("playerClientProperties", this.onPlayerClientProperties);
+		this.#dataStream.on("removeClient", this.onRemoveClient);
+		this.#dataStream.on("removePlayer", this.onRemovePlayer);
+		this.#dataStream.on("sendCommandResult", this.onSendCommandResult);
+		this.#dataStream.on("sendLyricsEvent", this.onSendLyricsEvent);
+		this.#dataStream.on("setArtwork", this.onSetArtwork);
+		this.#dataStream.on("setDefaultSupportedCommands", this.onSetDefaultSupportedCommands);
+		this.#dataStream.on("setNowPlayingClient", this.onSetNowPlayingClient);
+		this.#dataStream.on("setNowPlayingPlayer", this.onSetNowPlayingPlayer);
+		this.#dataStream.on("setState", this.onSetState);
+		this.#dataStream.on("updateClient", this.onUpdateClient);
+		this.#dataStream.on("updateContentItem", this.onUpdateContentItem);
+		this.#dataStream.on("updateContentItemArtwork", this.onUpdateContentItemArtwork);
+		this.#dataStream.on("updatePlayer", this.onUpdatePlayer);
+		this.#dataStream.on("playerClientParticipantsUpdate", this.onPlayerClientParticipantsUpdate);
+		this.#dataStream.on("updateOutputDevice", this.onUpdateOutputDevice);
+		this.#dataStream.on("volumeControlAvailability", this.onVolumeControlAvailability);
+		this.#dataStream.on("volumeControlCapabilitiesDidChange", this.onVolumeControlCapabilitiesDidChange);
+		this.#dataStream.on("volumeDidChange", this.onVolumeDidChange);
+		this.#dataStream.on("volumeMutedDidChange", this.onVolumeMutedDidChange);
+	}
+	/**
+	* Unsubscribes from all DataStream events. Called internally via symbol.
+	*/
+	[STATE_UNSUBSCRIBE_SYMBOL]() {
+		const dataStream = this.#dataStream;
+		if (!dataStream) return;
+		dataStream.off("configureConnection", this.onConfigureConnection);
+		dataStream.off("keyboard", this.onKeyboard);
+		dataStream.off("deviceInfo", this.onDeviceInfo);
+		dataStream.off("deviceInfoUpdate", this.onDeviceInfoUpdate);
+		dataStream.off("originClientProperties", this.onOriginClientProperties);
+		dataStream.off("playerClientProperties", this.onPlayerClientProperties);
+		dataStream.off("removeClient", this.onRemoveClient);
+		dataStream.off("removePlayer", this.onRemovePlayer);
+		dataStream.off("sendCommandResult", this.onSendCommandResult);
+		dataStream.off("sendLyricsEvent", this.onSendLyricsEvent);
+		dataStream.off("setArtwork", this.onSetArtwork);
+		dataStream.off("setDefaultSupportedCommands", this.onSetDefaultSupportedCommands);
+		dataStream.off("setNowPlayingClient", this.onSetNowPlayingClient);
+		dataStream.off("setNowPlayingPlayer", this.onSetNowPlayingPlayer);
+		dataStream.off("setState", this.onSetState);
+		dataStream.off("updateClient", this.onUpdateClient);
+		dataStream.off("updateContentItem", this.onUpdateContentItem);
+		dataStream.off("updateContentItemArtwork", this.onUpdateContentItemArtwork);
+		dataStream.off("updatePlayer", this.onUpdatePlayer);
+		dataStream.off("playerClientParticipantsUpdate", this.onPlayerClientParticipantsUpdate);
+		dataStream.off("updateOutputDevice", this.onUpdateOutputDevice);
+		dataStream.off("volumeControlAvailability", this.onVolumeControlAvailability);
+		dataStream.off("volumeControlCapabilitiesDidChange", this.onVolumeControlCapabilitiesDidChange);
+		dataStream.off("volumeDidChange", this.onVolumeDidChange);
+		dataStream.off("volumeMutedDidChange", this.onVolumeMutedDidChange);
+	}
+	/**
+	* Resets all state to initial/default values. Called on connect and reconnect.
+	*/
+	clear() {
+		this.#clients = {};
+		this.#keyboardAttributes = null;
+		this.#keyboardState = Proto$1.KeyboardState_Enum.Unknown;
+		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 = Proto$1.VolumeCapabilities_Enum.None;
+		this.#volumeMuted = false;
+	}
+	/**
+	* Handles a ConfigureConnection message from the Apple TV.
+	*
+	* @param message - The configure connection message.
+	*/
+	onConfigureConnection(message) {
+		this.emit("configureConnection", message);
+	}
+	/**
+	* Handles keyboard state changes. Updates internal state and emits 'keyboard'.
+	*
+	* @param message - The keyboard message with state and attributes.
+	*/
+	onKeyboard(message) {
+		this.#keyboardState = message.state;
+		this.#keyboardAttributes = message.attributes ?? null;
+		this.emit("keyboard", message);
+	}
+	/**
+	* Handles initial device info. Updates output device UID and cluster info.
+	*
+	* @param message - The device info message.
+	*/
+	onDeviceInfo(message) {
+		this.#updateDeviceInfo(message);
+		this.emit("deviceInfo", message);
+	}
+	/**
+	* Handles device info updates (e.g. cluster changes). Updates output device UID and cluster info.
+	*
+	* @param message - The device info update message.
+	*/
+	onDeviceInfoUpdate(message) {
+		this.#updateDeviceInfo(message);
+		this.emit("deviceInfoUpdate", message);
+	}
+	/**
+	* Handles origin client properties updates.
+	*
+	* @param message - The origin client properties message.
+	*/
+	onOriginClientProperties(message) {
+		this.emit("originClientProperties", message);
+	}
+	/**
+	* Handles player client properties updates.
+	*
+	* @param message - The player client properties message.
+	*/
+	onPlayerClientProperties(message) {
+		this.emit("playerClientProperties", message);
+	}
+	/**
+	* Handles removal of a client (app). Clears the now-playing reference if
+	* the removed client was the active one.
+	*
+	* @param message - The remove client message.
+	*/
+	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("removeClient", message);
+		this.emit("clients", this.#clients);
+		if (wasActive) {
+			this.#emitActivePlayerChanged();
+			this.#emitNowPlayingChangedIfNeeded();
+		}
+	}
+	/**
+	* Handles command result notifications from the Apple TV.
+	*
+	* @param message - The send command result message.
+	*/
+	onSendCommandResult(message) {
+		this.emit("sendCommandResult", message);
+	}
+	/**
+	* Handles lyrics events (time-synced lyrics updates).
+	*
+	* @param message - The lyrics event message.
+	*/
+	onSendLyricsEvent(message) {
+		if (message.event) this.emit("lyricsEvent", message.event, message.playerPath);
+	}
+	/**
+	* Handles artwork set notifications.
+	*
+	* @param message - The set artwork message.
+	*/
+	onSetArtwork(message) {
+		if (message.jpegData?.byteLength > 0) this.#artworkJpegData = message.jpegData;
+		this.emit("setArtwork", message);
+	}
+	/**
+	* Handles default supported commands for a client. These serve as fallback
+	* commands when a player has no commands of its own.
+	*
+	* @param message - The set default supported commands message.
+	*/
+	onSetDefaultSupportedCommands(message) {
+		if (message.playerPath?.client?.bundleIdentifier && message.supportedCommands) this.#client(message.playerPath.client.bundleIdentifier, message.playerPath.client.displayName).setDefaultSupportedCommands(message.supportedCommands.supportedCommands);
+		this.emit("setDefaultSupportedCommands", message);
+	}
+	/**
+	* Handles the now-playing client changing (e.g. user switches app).
+	* Updates the active client reference and emits change events.
+	*
+	* @param message - The set now-playing client message.
+	*/
+	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);
+		this.emit("setNowPlayingClient", message);
+		if (oldBundleId !== this.#nowPlayingClientBundleIdentifier) this.#emitActivePlayerChanged();
+		this.#emitNowPlayingChangedIfNeeded();
+	}
+	/**
+	* Handles the active player changing within a client (e.g. PiP player becomes active).
+	* Creates the player if needed and sets it as the active player.
+	*
+	* @param message - The set now-playing player message.
+	*/
+	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.emit("setNowPlayingPlayer", message);
+		this.#emitNowPlayingChangedIfNeeded();
+	}
+	/**
+	* Handles comprehensive state updates. Processes playback state, now-playing info,
+	* supported commands, and playback queue in a single message.
+	* Emits granular events for each changed aspect.
+	*
+	* @param message - The set state message.
+	*/
+	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 isActiveClient = bundleIdentifier === this.#nowPlayingClientBundleIdentifier;
+		if (message.playbackState) {
+			const oldState = player.playbackState;
+			player.setPlaybackState(message.playbackState, message.playbackStateTimestamp);
+			if (isActiveClient && 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 (isActiveClient) this.emit("supportedCommandsChanged", client, player, player.supportedCommands);
+		}
+		if (message.playbackQueue) {
+			player.setPlaybackQueue(message.playbackQueue);
+			if (isActiveClient) this.emit("playbackQueueChanged", client, player);
+		}
+		this.emit("setState", message);
+		if (isActiveClient) this.#emitNowPlayingChangedIfNeeded();
+	}
+	/**
+	* Handles content item updates (metadata, artwork, lyrics changes for existing items).
+	*
+	* @param message - The update content item message.
+	*/
+	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);
+		this.emit("updateContentItem", message);
+		if (bundleIdentifier === this.#nowPlayingClientBundleIdentifier) this.#emitNowPlayingChangedIfNeeded();
+	}
+	/**
+	* Handles artwork updates for content items. Emits 'artworkChanged' if a client and player are active.
+	*
+	* @param message - The update content item artwork message.
+	*/
+	onUpdateContentItemArtwork(message) {
+		this.emit("updateContentItemArtwork", message);
+		const client = this.nowPlayingClient;
+		const player = client?.activePlayer;
+		if (client && player) this.emit("artworkChanged", client, player);
+	}
+	/**
+	* Handles player registration or update. Creates the player if it does not exist.
+	*
+	* @param message - The update player message.
+	*/
+	onUpdatePlayer(message) {
+		if (message.playerPath?.client?.bundleIdentifier && message.playerPath?.player?.identifier) this.#client(message.playerPath.client.bundleIdentifier, message.playerPath.client.displayName).getOrCreatePlayer(message.playerPath.player.identifier, message.playerPath.player.displayName);
+		this.emit("updatePlayer", message);
+	}
+	/**
+	* Handles player removal. Removes the player from its client and emits
+	* active player changed events if the removed player was active.
+	*
+	* @param message - The remove player message.
+	*/
+	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);
+		}
+		this.emit("removePlayer", message);
+		if (message.playerPath?.client?.bundleIdentifier === this.#nowPlayingClientBundleIdentifier) {
+			this.#emitActivePlayerChanged();
+			this.#emitNowPlayingChangedIfNeeded();
+		}
+	}
+	/**
+	* Handles client (app) registration or display name update.
+	*
+	* @param message - The update client message.
+	*/
+	onUpdateClient(message) {
+		if (!message.client?.bundleIdentifier) return;
+		this.#client(message.client.bundleIdentifier, message.client.displayName);
+		this.emit("updateClient", message);
+		this.emit("clients", this.#clients);
+	}
+	/**
+	* Handles output device list updates. Prefers cluster-aware devices when available.
+	*
+	* @param message - The update output device message.
+	*/
+	/**
+	* Handles playback queue participant updates (e.g. SharePlay users).
+	*
+	* @param message - The participants update message.
+	*/
+	onPlayerClientParticipantsUpdate(message) {
+		this.#participants = message.participants ?? [];
+		this.emit("playerClientParticipantsUpdate", message);
+	}
+	onUpdateOutputDevice(message) {
+		this.#outputDevices = message.clusterAwareOutputDevices?.length > 0 ? message.clusterAwareOutputDevices : message.outputDevices;
+		this.emit("updateOutputDevice", message);
+	}
+	/**
+	* Handles volume control availability changes.
+	*
+	* @param message - The volume control availability message.
+	*/
+	onVolumeControlAvailability(message) {
+		this.#volumeAvailable = message.volumeControlAvailable;
+		this.#volumeCapabilities = message.volumeCapabilities;
+		this.emit("volumeControlAvailability", message.volumeControlAvailable, message.volumeCapabilities);
+	}
+	/**
+	* Handles volume capabilities changes (e.g. device gains or loses absolute volume support).
+	*
+	* @param message - The volume capabilities change message.
+	*/
+	onVolumeControlCapabilitiesDidChange(message) {
+		if (!message.capabilities) return;
+		this.#volumeAvailable = message.capabilities.volumeControlAvailable;
+		this.#volumeCapabilities = message.capabilities.volumeCapabilities;
+		this.emit("volumeControlCapabilitiesDidChange", message.capabilities.volumeControlAvailable, message.capabilities.volumeCapabilities);
+	}
+	/**
+	* Handles volume level changes.
+	*
+	* @param message - The volume change message.
+	*/
+	onVolumeDidChange(message) {
+		this.#volume = message.volume;
+		this.emit("volumeDidChange", message.volume);
+	}
+	/**
+	* Handles mute state changes.
+	*
+	* @param message - The volume muted change message.
+	*/
+	onVolumeMutedDidChange(message) {
+		this.#volumeMuted = message.isMuted;
+		this.emit("volumeMutedDidChange", this.#volumeMuted);
+	}
+	/**
+	* Extracts output device UID and cluster information from a device info message.
+	*
+	* @param message - The device info message.
+	*/
+	#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 a Client for the given bundle identifier.
+	* Updates the display name if the client already exists.
+	*
+	* @param bundleIdentifier - The app's bundle identifier.
+	* @param displayName - The app's display name.
+	* @returns The existing or newly created Client.
+	*/
+	#client(bundleIdentifier, displayName) {
+		if (bundleIdentifier in this.#clients) {
+			const client = this.#clients[bundleIdentifier];
+			if (displayName) client.updateDisplayName(displayName);
+			return client;
+		} else {
+			const client = new AirPlayClient(bundleIdentifier, displayName);
+			this.#clients[bundleIdentifier] = client;
+			this.emit("clients", this.#clients);
+			return client;
+		}
+	}
+	/**
+	* Creates a snapshot of the current now-playing state for change detection.
+	*
+	* @returns A NowPlayingSnapshot of the current state.
+	*/
+	#createNowPlayingSnapshot() {
+		const client = this.nowPlayingClient;
+		const player = client?.activePlayer ?? null;
+		return {
+			bundleIdentifier: client?.bundleIdentifier ?? null,
+			playerIdentifier: player?.identifier ?? null,
+			playbackState: player?.playbackState ?? Proto$1.PlaybackState_Enum.Unknown,
+			title: player?.title ?? "",
+			artist: player?.artist ?? "",
+			album: player?.album ?? "",
+			genre: player?.genre ?? "",
+			duration: player?.duration ?? 0,
+			playbackRate: player?.playbackRate ?? 0,
+			shuffleMode: player?.shuffleMode ?? Proto$1.ShuffleMode_Enum.Unknown,
+			repeatMode: player?.repeatMode ?? Proto$1.RepeatMode_Enum.Unknown,
+			mediaType: player?.mediaType ?? Proto$1.ContentItemMetadata_MediaType.UnknownMediaType,
+			seriesName: player?.seriesName ?? "",
+			seasonNumber: player?.seasonNumber ?? 0,
+			episodeNumber: player?.episodeNumber ?? 0,
+			contentIdentifier: player?.contentIdentifier ?? "",
+			artworkId: player?.artworkId ?? null,
+			hasArtworkUrl: player?.artworkUrl() != null,
+			hasArtworkData: player?.currentItemArtwork != null,
+			isAlwaysLive: player?.nowPlayingInfo?.isAlwaysLive ?? false,
+			isAdvertisement: player?.nowPlayingInfo?.isAdvertisement ?? false
+		};
+	}
+	/**
+	* Emits the 'activePlayerChanged' event with the current client and player.
+	*/
+	#emitActivePlayerChanged() {
+		const client = this.nowPlayingClient;
+		this.emit("activePlayerChanged", client, client?.activePlayer ?? null);
+	}
+	/**
+	* Emits 'nowPlayingChanged' only if the now-playing snapshot has actually changed.
+	*/
+	#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);
+	}
+	/**
+	* Compares two NowPlayingSnapshot instances field-by-field for equality.
+	*
+	* @param a - First snapshot.
+	* @param b - Second snapshot.
+	* @returns True if all fields are equal.
+	*/
+	#snapshotsEqual(a, b) {
+		return a.bundleIdentifier === b.bundleIdentifier && a.playerIdentifier === b.playerIdentifier && a.playbackState === b.playbackState && a.title === b.title && a.artist === b.artist && 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.contentIdentifier === b.contentIdentifier && a.artworkId === b.artworkId && a.hasArtworkUrl === b.hasArtworkUrl && a.hasArtworkData === b.hasArtworkData && a.isAlwaysLive === b.isAlwaysLive && a.isAdvertisement === b.isAdvertisement;
+	}
+};
+
+//#endregion
+//#region src/internal/airplay-volume.ts
+/**
+* Volume adjustment step size as a fraction (0.05 = 5%).
+*/
+const VOLUME_STEP = .05;
+/**
+* Minimum interval between volume fade steps in milliseconds.
+*/
+const FADE_STEP_INTERVAL = 50;
+/**
+* Smart volume controller for an AirPlay device.
+* Automatically chooses between absolute volume (set a specific level) and
+* relative volume (HID volume up/down keys) based on the device's reported capabilities.
+*/
+var AirPlayVolume = class {
+	/**
+	* @returns The underlying AirPlay Protocol instance.
+	*/
+	get #protocol() {
+		return this.#device[PROTOCOL];
+	}
+	/**
+	* @returns The AirPlay state for volume and capability information.
+	*/
+	get #state() {
+		return this.#device.state;
+	}
+	#device;
+	/**
+	* Creates a new Volume controller.
+	*
+	* @param device - The AirPlay device to control volume for.
+	*/
+	constructor(device) {
+		this.#device = device;
+	}
+	/**
+	* Decreases the volume by one step. Uses absolute volume when available,
+	* falls back to HID relative volume keys otherwise.
+	*
+	* @throws CommandError when volume control is not available.
+	*/
+	async down() {
+		switch (this.#state.volumeCapabilities) {
+			case Proto$1.VolumeCapabilities_Enum.Absolute:
+			case Proto$1.VolumeCapabilities_Enum.Both:
+				const newVolume = Math.max(0, this.#state.volume - VOLUME_STEP);
+				await this.set(newVolume);
+				break;
+			case Proto$1.VolumeCapabilities_Enum.Relative:
+				await this.#device.remote.volumeDown();
+				break;
+			default: throw new CommandError("Volume control is not available.");
+		}
+	}
+	/**
+	* Increases the volume by one step. Uses absolute volume when available,
+	* falls back to HID relative volume keys otherwise.
+	*
+	* @throws CommandError when volume control is not available.
+	*/
+	async up() {
+		switch (this.#state.volumeCapabilities) {
+			case Proto$1.VolumeCapabilities_Enum.Absolute:
+			case Proto$1.VolumeCapabilities_Enum.Both:
+				const newVolume = Math.min(1, Math.max(0, this.#state.volume + VOLUME_STEP));
+				await this.set(newVolume);
+				break;
+			case Proto$1.VolumeCapabilities_Enum.Relative:
+				await this.#device.remote.volumeUp();
+				break;
+			default: throw new CommandError("Volume control is not available.");
+		}
+	}
+	/**
+	* Fetches the current volume level from the device.
+	*
+	* @returns The volume level as a float between 0.0 and 1.0.
+	* @throws CommandError when no output device is active or the request fails.
+	*/
+	async get() {
+		if (!this.#state.outputDeviceUID) throw new CommandError("No output device active.");
+		const response = await this.#protocol.dataStream.exchange(DataStreamMessage.getVolume(this.#state.outputDeviceUID));
+		if (response.type === Proto$1.ProtocolMessage_Type.GET_VOLUME_RESULT_MESSAGE) return DataStreamMessage.getExtension(response, Proto$1.getVolumeResultMessage).volume;
+		throw new CommandError("Failed to get volume.");
+	}
+	/**
+	* Sets the volume to an absolute level.
+	*
+	* @param volume - The desired volume level (clamped to 0.0 - 1.0).
+	* @throws CommandError when no output device is active or absolute volume is not supported.
+	*/
+	async set(volume) {
+		if (!this.#state.outputDeviceUID) throw new CommandError("No output device active.");
+		if (![Proto$1.VolumeCapabilities_Enum.Absolute, Proto$1.VolumeCapabilities_Enum.Both].includes(this.#state.volumeCapabilities)) throw new CommandError("Absolute volume control is not available.");
+		volume = Math.min(1, Math.max(0, volume));
+		this.#protocol.context.logger.info(`Setting volume to ${volume} for device ${this.#state.outputDeviceUID}`);
+		await this.#protocol.dataStream.exchange(DataStreamMessage.setVolume(this.#state.outputDeviceUID, volume));
+	}
+	/**
+	* Mutes the output device.
+	*
+	* @throws CommandError when no output device is active.
+	*/
+	async mute() {
+		if (!this.#state.outputDeviceUID) throw new CommandError("No output device active.");
+		await this.#protocol.dataStream.exchange(DataStreamMessage.setVolumeMuted(this.#state.outputDeviceUID, true));
+	}
+	/**
+	* Unmutes the output device.
+	*
+	* @throws CommandError when no output device is active.
+	*/
+	async unmute() {
+		if (!this.#state.outputDeviceUID) throw new CommandError("No output device active.");
+		await this.#protocol.dataStream.exchange(DataStreamMessage.setVolumeMuted(this.#state.outputDeviceUID, false));
+	}
+	/**
+	* Toggles the mute state of the output device.
+	*
+	* @throws CommandError when no output device is active.
+	*/
+	async toggleMute() {
+		if (this.#state.volumeMuted) await this.unmute();
+		else await this.mute();
+	}
+	/**
+	* Sets the volume for a specific output device in a speaker group.
+	* Use this to control individual speakers when multiple devices are grouped.
+	*
+	* @param outputDeviceUID - The unique identifier of the target output device.
+	* @param volume - The desired volume level (clamped to 0.0 - 1.0).
+	*/
+	async setForDevice(outputDeviceUID, volume) {
+		volume = Math.min(1, Math.max(0, volume));
+		this.#protocol.context.logger.info(`Setting volume to ${volume} for output device ${outputDeviceUID}`);
+		await this.#protocol.dataStream.exchange(DataStreamMessage.setVolume(outputDeviceUID, volume));
+	}
+	/**
+	* Fetches the volume for a specific output device in a speaker group.
+	*
+	* @param outputDeviceUID - The unique identifier of the target output device.
+	* @returns The volume level as a float between 0.0 and 1.0.
+	*/
+	async getForDevice(outputDeviceUID) {
+		const response = await this.#protocol.dataStream.exchange(DataStreamMessage.getVolume(outputDeviceUID));
+		if (response.type === Proto$1.ProtocolMessage_Type.GET_VOLUME_RESULT_MESSAGE) return DataStreamMessage.getExtension(response, Proto$1.getVolumeResultMessage).volume;
+		throw new CommandError("Failed to get volume for output device.");
+	}
+	/**
+	* Mutes a specific output device in a speaker group.
+	*
+	* @param outputDeviceUID - The unique identifier of the target output device.
+	*/
+	async muteDevice(outputDeviceUID) {
+		await this.#protocol.dataStream.exchange(DataStreamMessage.setVolumeMuted(outputDeviceUID, true));
+	}
+	/**
+	* Unmutes a specific output device in a speaker group.
+	*
+	* @param outputDeviceUID - The unique identifier of the target output device.
+	*/
+	async unmuteDevice(outputDeviceUID) {
+		await this.#protocol.dataStream.exchange(DataStreamMessage.setVolumeMuted(outputDeviceUID, false));
+	}
+	/**
+	* Adjusts the volume by a relative increment/decrement on a specific output device.
+	* This is the method Apple uses internally in Music.app for volume changes.
+	*
+	* @param adjustment - The volume adjustment to apply (IncrementSmall/Medium/Large, DecrementSmall/Medium/Large).
+	* @param outputDeviceUID - Optional UID of the target output device. Defaults to the active device.
+	*/
+	async adjust(adjustment, outputDeviceUID) {
+		const uid = outputDeviceUID ?? this.#state.outputDeviceUID;
+		if (!uid) throw new CommandError("No output device active.");
+		await this.#protocol.dataStream.exchange(DataStreamMessage.adjustVolume(adjustment, uid));
+	}
+	/**
+	* Smoothly fades the volume to a target level over a given duration.
+	* Uses linear interpolation with absolute volume set calls.
+	*
+	* @param targetVolume - The target volume level (0.0 - 1.0).
+	* @param durationMs - The fade duration in milliseconds.
+	* @throws CommandError when absolute volume control is not available.
+	*/
+	async fade(targetVolume, durationMs) {
+		if (!this.#state.outputDeviceUID) throw new CommandError("No output device active.");
+		if (![Proto$1.VolumeCapabilities_Enum.Absolute, Proto$1.VolumeCapabilities_Enum.Both].includes(this.#state.volumeCapabilities)) throw new CommandError("Absolute volume control is not available.");
+		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);
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/airplay-manager.ts
+/**
+* High-level abstraction for an AirPlay device (Apple TV or HomePod).
+* Manages the full lifecycle: connect, pair/verify, set up control/data/event streams,
+* and provides access to Remote, State, and Volume controllers.
+* Supports both transient (PIN-less) and credential-based pairing.
+*/
+var AirPlayManager = class extends EventEmitter {
+	/**
+	* @returns The underlying AirPlay Protocol instance (accessed via symbol for internal use).
+	*/
+	get [PROTOCOL]() {
+		return this.#protocol;
+	}
+	/**
+	* The mDNS discovery result used to connect to this device.
+	*/
+	get discoveryResult() {
+		return this.#discoveryResult;
+	}
+	/**
+	* Updates the discovery result, e.g. when the device's address changes.
+	*/
+	set discoveryResult(discoveryResult) {
+		this.#discoveryResult = discoveryResult;
+	}
+	/**
+	* Device capabilities derived from the AirPlay feature flags.
+	* Indicates which protocols and features the receiver supports.
+	*/
+	get capabilities() {
+		const has = (f) => this.#protocol?.hasReceiverFeature(f) ?? false;
+		return {
+			supportsAudio: has(AirPlayFeatureFlags.SupportsAirPlayAudio),
+			supportsBufferedAudio: has(AirPlayFeatureFlags.SupportsBufferedAudio),
+			supportsPTP: has(AirPlayFeatureFlags.SupportsPTP),
+			supportsRFC2198Redundancy: has(AirPlayFeatureFlags.SupportsRFC2198Redundancy),
+			supportsHangdogRemoteControl: has(AirPlayFeatureFlags.SupportsHangdogRemoteControl),
+			supportsUnifiedMediaControl: has(AirPlayFeatureFlags.SupportsUnifiedMediaControl),
+			supportsTransientPairing: has(AirPlayFeatureFlags.SupportsHKPairingAndAccessControl),
+			supportsSystemPairing: has(AirPlayFeatureFlags.SupportsSystemPairing),
+			supportsCoreUtilsPairing: has(AirPlayFeatureFlags.SupportsCoreUtilsPairingAndEncryption)
+		};
+	}
+	/**
+	* Whether the control stream TCP connection is currently active.
+	*/
+	get isConnected() {
+		return this.#protocol?.controlStream?.isConnected ?? false;
+	}
+	/**
+	* Raw receiver info dictionary from the /info endpoint, or undefined before connect.
+	*/
+	get receiverInfo() {
+		return this.#protocol?.receiverInfo;
+	}
+	/**
+	* The Artwork controller for fetching now-playing artwork from all sources.
+	*/
+	get artwork() {
+		return this.#artwork;
+	}
+	/**
+	* The Remote controller for HID keys, SendCommand, text input, and touch.
+	*/
+	get remote() {
+		return this.#remote;
+	}
+	/**
+	* The State tracker for now-playing, volume, keyboard, and output device state.
+	*/
+	get state() {
+		return this.#state;
+	}
+	/**
+	* The Volume controller for absolute and relative volume adjustments.
+	*/
+	get volume() {
+		return this.#volume;
+	}
+	/**
+	* The shared PTP timing server, if one is assigned for multi-room sync.
+	*/
+	get timingServer() {
+		return this.#timingServer;
+	}
+	/**
+	* Assigns a PTP timing server for multi-room audio synchronization.
+	*/
+	set timingServer(timingServer) {
+		this.#timingServer = timingServer;
+	}
+	#artwork;
+	#remote;
+	#state;
+	#volume;
+	#credentials;
+	#disconnect = false;
+	#discoveryResult;
+	#identity;
+	#feedbackInterval;
+	#keys;
+	#lastArtworkId = null;
+	#playUrlProtocol;
+	#prevDataStream;
+	#prevEventStream;
+	#protocol;
+	#streamProtocol;
+	#streamFeedbackInterval;
+	#timingServer;
+	/**
+	* Creates a new AirPlayDevice.
+	*
+	* @param discoveryResult - The mDNS discovery result for the target device.
+	* @param identity - Optional partial device identity to present during pairing.
+	*/
+	constructor(discoveryResult, identity) {
+		super();
+		this.#discoveryResult = discoveryResult;
+		this.#identity = identity;
+		this.#artwork = new AirPlayArtwork(this);
+		this.#remote = new AirPlayRemote(this);
+		this.#state = new AirPlayState(this);
+		this.onClose = this.onClose.bind(this);
+		this.onError = this.onError.bind(this);
+		this.onNowPlayingChanged = this.onNowPlayingChanged.bind(this);
+		this.onTimeout = this.onTimeout.bind(this);
+		this.#volume = new AirPlayVolume(this);
+	}
+	/**
+	* Connects to the AirPlay device, performs pairing/verification,
+	* and sets up all streams (control, data, event). Emits 'connected' on success.
+	* If credentials are set, uses pair-verify; otherwise uses transient pairing.
+	*/
+	async connect() {
+		if (this.#protocol) {
+			this.#protocol.controlStream.off("close", this.onClose);
+			this.#protocol.controlStream.off("error", this.onError);
+			this.#protocol.controlStream.off("timeout", this.onTimeout);
+			try {
+				this.#protocol.disconnect();
+			} catch {}
+		}
+		this.#disconnect = false;
+		this.#state.clear();
+		this.#protocol = new Protocol(this.#discoveryResult, this.#identity);
+		this.#protocol.controlStream.on("close", this.onClose);
+		this.#protocol.controlStream.on("error", this.onError);
+		this.#protocol.controlStream.on("timeout", this.onTimeout);
+		await this.#protocol.connect();
+		await this.#protocol.fetchInfo();
+		if (this.#credentials) this.#keys = await this.#protocol.verify.start(this.#credentials);
+		else {
+			await this.#protocol.pairing.start();
+			this.#keys = await this.#protocol.pairing.transient();
+		}
+		await this.#setup();
+		this.emit("connected");
+	}
+	/**
+	* Gracefully disconnects from the device, clears intervals, and tears down all streams.
+	*/
+	disconnect() {
+		this.#disconnect = true;
+		if (this.#feedbackInterval) {
+			clearInterval(this.#feedbackInterval);
+			this.#feedbackInterval = void 0;
+		}
+		this.#cleanupPlayUrl();
+		this.#cleanupStream();
+		this.#unsubscribe();
+		this.#protocol.disconnect();
+		this.emit("disconnected", false);
+	}
+	/**
+	* Disconnects gracefully, swallowing any errors during cleanup.
+	*/
+	disconnectSafely() {
+		try {
+			this.disconnect();
+		} catch (err) {
+			this.#protocol?.context?.logger?.warn("[device]", "Error during safe disconnect", err);
+		}
+	}
+	/**
+	* Enables or disables conversation detection on the output device (HomePod feature).
+	*
+	* @param enabled - Whether to enable conversation detection.
+	* @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.");
+		await this.#protocol.dataStream.send(DataStreamMessage.setConversationDetectionEnabled(enabled, outputDeviceUID));
+	}
+	/**
+	* Adds devices to the current multi-room output context.
+	*
+	* @param deviceUIDs - UIDs of the devices to add.
+	*/
+	async addOutputDevices(deviceUIDs) {
+		await this.#protocol.dataStream.exchange(DataStreamMessage.modifyOutputContext(deviceUIDs));
+	}
+	/**
+	* Removes devices from the current multi-room output context.
+	*
+	* @param deviceUIDs - UIDs of the devices to remove.
+	*/
+	async removeOutputDevices(deviceUIDs) {
+		await this.#protocol.dataStream.exchange(DataStreamMessage.modifyOutputContext([], deviceUIDs));
+	}
+	/**
+	* Replaces the entire multi-room output context with the given devices.
+	*
+	* @param deviceUIDs - UIDs of the devices to set as the output context.
+	*/
+	async setOutputDevices(deviceUIDs) {
+		await this.#protocol.dataStream.exchange(DataStreamMessage.modifyOutputContext([], [], deviceUIDs));
+	}
+	/**
+	* Plays a URL on the device (the device fetches and plays the content).
+	* Creates a separate Protocol instance to avoid conflicting with the
+	* existing remote control session, following the same approach as pyatv.
+	*
+	* @param url - The media URL to play.
+	* @param position - Start position in seconds (defaults to 0).
+	* @throws Error when not connected.
+	*/
+	async playUrl(url, position = 0) {
+		if (!this.#keys) throw new Error("Not connected. Call connect() first.");
+		this.#playUrlProtocol?.disconnect();
+		const playProtocol = new Protocol(this.#discoveryResult, this.#identity);
+		if (this.#timingServer) playProtocol.useTimingServer(this.#timingServer);
+		try {
+			await playProtocol.connect();
+			await playProtocol.fetchInfo();
+			let keys;
+			if (this.#credentials) keys = await playProtocol.verify.start(this.#credentials);
+			else {
+				await playProtocol.pairing.start();
+				keys = await playProtocol.pairing.transient();
+			}
+			playProtocol.controlStream.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
+			this.#playUrlProtocol = playProtocol;
+			await playProtocol.playUrl(url, keys.sharedSecret, keys.pairingId, position);
+		} catch (err) {
+			if (this.#playUrlProtocol !== playProtocol) playProtocol.disconnect();
+			throw err;
+		}
+	}
+	/**
+	* Waits for the current URL playback to finish, then cleans up the play URL protocol.
+	*/
+	async waitForPlaybackEnd() {
+		if (!this.#playUrlProtocol) return;
+		try {
+			await this.#playUrlProtocol.waitForPlaybackEnd();
+		} finally {
+			this.#cleanupPlayUrl();
+		}
+	}
+	/**
+	* Stops the current URL playback and cleans up the dedicated play URL protocol.
+	*/
+	stopPlayUrl() {
+		this.#cleanupPlayUrl();
+	}
+	/**
+	* Stops, disconnects, and discards the dedicated play URL protocol instance.
+	*/
+	#cleanupPlayUrl() {
+		if (this.#playUrlProtocol) {
+			this.#playUrlProtocol.stopPlayUrl();
+			this.#playUrlProtocol.disconnect();
+			this.#playUrlProtocol = void 0;
+		}
+	}
+	/**
+	* Streams audio from a source to the device via RAOP/RTP.
+	* Creates a separate Protocol instance to avoid conflicting with the
+	* existing remote control session, following the same approach as playUrl.
+	*
+	* @param source - The audio source to stream (e.g. MP3, WAV, URL, live).
+	*/
+	async streamAudio(source) {
+		if (!this.#keys) throw new Error("Not connected. Call connect() first.");
+		this.#cleanupStream();
+		const streamProtocol = new Protocol(this.#discoveryResult, this.#identity);
+		if (this.#timingServer) streamProtocol.useTimingServer(this.#timingServer);
+		try {
+			await streamProtocol.connect();
+			await streamProtocol.fetchInfo();
+			let keys;
+			if (this.#credentials) keys = await streamProtocol.verify.start(this.#credentials);
+			else {
+				await streamProtocol.pairing.start();
+				keys = await streamProtocol.pairing.transient();
+			}
+			streamProtocol.controlStream.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
+			this.#streamProtocol = streamProtocol;
+			await streamProtocol.setupEventStreamForAudioStreaming(keys.sharedSecret, keys.pairingId);
+			this.#streamFeedbackInterval = setInterval(async () => {
+				try {
+					await streamProtocol.feedback();
+				} catch {}
+			}, FEEDBACK_INTERVAL);
+			await streamProtocol.setupAudioStream(source);
+		} catch (err) {
+			if (this.#streamProtocol !== streamProtocol) streamProtocol.disconnect();
+			throw err;
+		} finally {
+			this.#cleanupStream();
+		}
+	}
+	/**
+	* Stops the current audio stream and cleans up the dedicated stream protocol.
+	*/
+	stopStreamAudio() {
+		this.#cleanupStream();
+	}
+	/**
+	* Stops, disconnects, and discards the dedicated audio stream protocol instance.
+	*/
+	#cleanupStream() {
+		if (this.#streamFeedbackInterval) {
+			clearInterval(this.#streamFeedbackInterval);
+			this.#streamFeedbackInterval = void 0;
+		}
+		if (this.#streamProtocol) {
+			this.#streamProtocol.disconnect();
+			this.#streamProtocol = void 0;
+		}
+	}
+	/**
+	* Sets the audio listening mode on the device (HomePod).
+	*
+	* @param mode - Listening mode string (e.g. 'Default', 'Vivid', 'LateNight').
+	*/
+	async setListeningMode(mode) {
+		const uid = this.state.outputDeviceUID;
+		if (uid) await this.#protocol.dataStream.send(DataStreamMessage.setListeningMode(mode, uid));
+	}
+	/**
+	* Sets the audio routing mode on the receiver via the control stream.
+	*
+	* @param mode - Audio mode (e.g. 'default', 'moviePlayback', 'spoken').
+	*/
+	async setAudioMode(mode) {
+		await this.#protocol.controlStream.setAudioMode(mode);
+	}
+	/**
+	* Triggers an audio fade on the device.
+	*
+	* @param fadeType - The fade type (0 = fade out, 1 = fade in).
+	*/
+	async audioFade(fadeType) {
+		await this.#protocol.dataStream.send(DataStreamMessage.audioFade(fadeType));
+	}
+	/**
+	* Wakes the device from sleep via the DataStream.
+	*/
+	async wake() {
+		await this.#protocol.dataStream.send(DataStreamMessage.wakeDevice());
+	}
+	/**
+	* Requests the playback queue from the device.
+	*
+	* @param length - Maximum number of queue items to retrieve.
+	*/
+	async requestPlaybackQueue(length) {
+		const location = this.#state.nowPlayingClient?.activePlayer?.playbackQueue?.location ?? 0;
+		await this.#protocol.dataStream.exchange(DataStreamMessage.playbackQueueRequest(location, length));
+	}
+	/**
+	* Sends a raw MRP command to the device via the DataStream.
+	*
+	* @param command - The command to send.
+	* @param options - Optional command options.
+	*/
+	async sendCommand(command, options) {
+		await this.#protocol.dataStream.exchange(DataStreamMessage.sendCommand(command, options));
+	}
+	/**
+	* Sets the pairing credentials for pair-verify authentication.
+	* Must be called before connect() if credential-based pairing is desired.
+	*
+	* @param credentials - The accessory credentials obtained from pair-setup.
+	*/
+	setCredentials(credentials) {
+		this.#credentials = credentials;
+	}
+	/**
+	* Sends a periodic feedback request to keep the AirPlay session alive.
+	*/
+	async #feedback() {
+		try {
+			await this.#protocol.feedback();
+		} catch (err) {
+			this.#protocol.context.logger.error("Feedback error", err);
+		}
+	}
+	/**
+	* Handles the control stream close event. Emits 'disconnected' with unexpected=true if not intentional.
+	*/
+	onClose() {
+		this.#protocol.context.logger.net("onClose() called on airplay device.");
+		if (this.#disconnect) return;
+		this.#disconnect = true;
+		this.disconnectSafely();
+		this.emit("disconnected", true);
+	}
+	/**
+	* Handles stream error events by logging them.
+	*
+	* @param err - The error that occurred.
+	*/
+	onError(err) {
+		this.#protocol.context.logger.error("AirPlay error", err);
+	}
+	/**
+	* Handles now-playing changes to auto-fetch artwork on track changes.
+	*/
+	onNowPlayingChanged(_client, player) {
+		const artworkId = player?.artworkId ?? null;
+		if (artworkId !== this.#lastArtworkId) {
+			this.#lastArtworkId = artworkId;
+			this.requestPlaybackQueue(1).catch(() => {});
+		}
+	}
+	/**
+	* Handles stream timeout events by destroying the control stream.
+	*/
+	onTimeout() {
+		this.#protocol.context.logger.error("AirPlay timeout");
+		this.#protocol.controlStream.destroy();
+	}
+	/**
+	* Sets up encryption, event/data streams, feedback interval, and initial state subscriptions.
+	* Called after successful pairing/verification.
+	*/
+	async #setup() {
+		const keys = this.#keys;
+		this.#protocol.controlStream.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
+		this.#unsubscribe();
+		if (this.#timingServer) this.#protocol.useTimingServer(this.#timingServer);
+		try {
+			this.#prevDataStream?.off("error", this.onError);
+			this.#prevDataStream?.off("timeout", this.onTimeout);
+			this.#prevEventStream?.off("error", this.onError);
+			this.#prevEventStream?.off("timeout", this.onTimeout);
+			await this.#protocol.setupEventStream(keys.sharedSecret, keys.pairingId);
+			await this.#protocol.setupDataStream(keys.sharedSecret, () => this.#subscribe());
+			this.#protocol.dataStream.on("error", this.onError);
+			this.#protocol.dataStream.on("timeout", this.onTimeout);
+			this.#protocol.eventStream.on("error", this.onError);
+			this.#protocol.eventStream.on("timeout", this.onTimeout);
+			this.#prevDataStream = this.#protocol.dataStream;
+			this.#prevEventStream = this.#protocol.eventStream;
+			if (this.#feedbackInterval) clearInterval(this.#feedbackInterval);
+			this.#feedbackInterval = setInterval(async () => await this.#feedback(), FEEDBACK_INTERVAL);
+			await this.#protocol.dataStream.exchange(DataStreamMessage.deviceInfo(keys.pairingId, this.#protocol.context.identity));
+			this.#protocol.dataStream.send(DataStreamMessage.setConnectionState());
+			this.#protocol.dataStream.send(DataStreamMessage.clientUpdatesConfig(true, true, true, true));
+			await this.#protocol.dataStream.exchange(DataStreamMessage.getState());
+			this.#lastArtworkId = null;
+			this.#state.on("nowPlayingChanged", this.onNowPlayingChanged);
+			this.#protocol.context.logger.info("Protocol ready.");
+		} catch (err) {
+			if (this.#feedbackInterval) {
+				clearInterval(this.#feedbackInterval);
+				this.#feedbackInterval = void 0;
+			}
+			this.#protocol.context.logger.error("[device]", "Setup failed, cleaning up", err);
+			this.#protocol.disconnect();
+			throw err;
+		}
+	}
+	/**
+	* Subscribes the state tracker to DataStream events.
+	*/
+	#subscribe() {
+		this.#state[STATE_SUBSCRIBE_SYMBOL]();
+	}
+	/**
+	* Unsubscribes the state tracker from DataStream events.
+	*/
+	#unsubscribe() {
+		try {
+			this.#state.off("nowPlayingChanged", this.onNowPlayingChanged);
+			this.#state[STATE_UNSUBSCRIBE_SYMBOL]();
+		} catch (err) {
+			this.#protocol.context.logger.error("State unsubscribe error", err);
+		}
+	}
+};
+
+//#endregion
+//#region src/internal/companion-link-state.ts
+/**
+* Default text input state when no text input session is active.
+*/
+const DEFAULT_TEXT_INPUT = {
+	isActive: false,
+	documentText: "",
+	isSecure: false,
+	keyboardType: 0,
+	autocorrection: false,
+	autocapitalization: false
+};
+/**
+* Tracks the state of a Companion Link device: attention state, media controls,
+* now-playing info, supported actions, text input, and volume availability.
+* Subscribes to protocol stream events and emits typed state change events.
+*/
+var CompanionLinkState = class extends EventEmitter {
+	/**
+	* Current attention state of the device (active, idle, screensaver, etc.).
+	*/
+	get attentionState() {
+		return this.#attentionState;
+	}
+	/**
+	* Parsed media capabilities indicating which controls are available.
+	*/
+	get mediaCapabilities() {
+		return this.#mediaCapabilities;
+	}
+	/**
+	* Raw media control flags bitmask from the device.
+	*/
+	get mediaControlFlags() {
+		return this.#mediaControlFlags;
+	}
+	/**
+	* Current now-playing info as a key-value dictionary, or null.
+	*/
+	get nowPlayingInfo() {
+		return this.#nowPlayingInfo;
+	}
+	/**
+	* Currently supported actions dictionary, or null.
+	*/
+	get supportedActions() {
+		return this.#supportedActions;
+	}
+	/**
+	* Current text input session state.
+	*/
+	get textInputState() {
+		return this.#textInputState;
+	}
+	/**
+	* Whether volume control is currently available via the Companion Link protocol.
+	*/
+	get volumeAvailable() {
+		return this.#volumeAvailable;
+	}
+	#protocol;
+	#attentionState = "unknown";
+	#mediaCapabilities = parseMediaControlFlags(0);
+	#mediaControlFlags = 0;
+	#nowPlayingInfo = null;
+	#supportedActions = null;
+	#textInputState = { ...DEFAULT_TEXT_INPUT };
+	#volumeAvailable = false;
+	/**
+	* Creates a new CompanionLinkState tracker.
+	*
+	* @param protocol - The Companion Link protocol instance to observe.
+	*/
+	constructor(protocol) {
+		super();
+		this.#protocol = protocol;
+		this.onMediaControl = this.onMediaControl.bind(this);
+		this.onSystemStatus = this.onSystemStatus.bind(this);
+		this.onTVSystemStatus = this.onTVSystemStatus.bind(this);
+		this.onNowPlayingInfo = this.onNowPlayingInfo.bind(this);
+		this.onSupportedActions = this.onSupportedActions.bind(this);
+		this.onTextInputStarted = this.onTextInputStarted.bind(this);
+		this.onTextInputStopped = this.onTextInputStopped.bind(this);
+	}
+	/**
+	* Subscribes to protocol stream events and registers interests for push notifications.
+	*/
+	subscribe() {
+		const stream = this.#protocol.stream;
+		stream.on("_iMC", this.onMediaControl);
+		stream.on("SystemStatus", this.onSystemStatus);
+		stream.on("TVSystemStatus", this.onTVSystemStatus);
+		stream.on("NowPlayingInfo", this.onNowPlayingInfo);
+		stream.on("SupportedActions", this.onSupportedActions);
+		stream.on("_tiStarted", this.onTextInputStarted);
+		stream.on("_tiStopped", this.onTextInputStopped);
+		this.#protocol.registerInterests(["_iMC"]);
+		this.#protocol.registerInterests(["SystemStatus"]);
+		this.#protocol.registerInterests(["TVSystemStatus"]);
+		this.#protocol.registerInterests(["NowPlayingInfo"]);
+		this.#protocol.registerInterests(["SupportedActions"]);
+	}
+	/**
+	* Unsubscribes from protocol stream events and deregisters interests.
+	*/
+	unsubscribe() {
+		const stream = this.#protocol.stream;
+		if (!stream.isConnected) return;
+		stream.off("_iMC", this.onMediaControl);
+		stream.off("SystemStatus", this.onSystemStatus);
+		stream.off("TVSystemStatus", this.onTVSystemStatus);
+		stream.off("NowPlayingInfo", this.onNowPlayingInfo);
+		stream.off("SupportedActions", this.onSupportedActions);
+		stream.off("_tiStarted", this.onTextInputStarted);
+		stream.off("_tiStopped", this.onTextInputStopped);
+		try {
+			this.#protocol.deregisterInterests(["_iMC"]);
+			this.#protocol.deregisterInterests(["SystemStatus"]);
+			this.#protocol.deregisterInterests(["TVSystemStatus"]);
+			this.#protocol.deregisterInterests(["NowPlayingInfo"]);
+			this.#protocol.deregisterInterests(["SupportedActions"]);
+		} catch {}
+	}
+	/**
+	* Fetches the initial attention state and media control status from the device.
+	*/
+	async fetchInitialState() {
+		try {
+			const state = await this.#protocol.getAttentionState();
+			this.#attentionState = state;
+			this.emit("attentionStateChanged", state);
+		} catch (err) {
+			this.#protocol.context.logger.warn("[cl-state]", "Failed to fetch initial attention state", err);
+		}
+		try {
+			await this.#protocol.fetchMediaControlStatus();
+		} catch (err) {
+			this.#protocol.context.logger.warn("[cl-state]", "Failed to fetch media control status", err);
+		}
+	}
+	/**
+	* Resets all state to initial/default values.
+	*/
+	clear() {
+		this.#attentionState = "unknown";
+		this.#mediaCapabilities = parseMediaControlFlags(0);
+		this.#mediaControlFlags = 0;
+		this.#nowPlayingInfo = null;
+		this.#supportedActions = null;
+		this.#textInputState = { ...DEFAULT_TEXT_INPUT };
+		this.#volumeAvailable = false;
+	}
+	/**
+	* Handles media control flag updates (_iMC). Parses the flags bitmask and
+	* emits events if capabilities or volume availability changed.
+	*
+	* @param data - The raw media control payload.
+	*/
+	onMediaControl(data) {
+		try {
+			const flags = Number(data?._mcF ?? 0);
+			if (flags !== this.#mediaControlFlags) {
+				this.#mediaControlFlags = flags;
+				this.#mediaCapabilities = parseMediaControlFlags(flags);
+				const wasVolumeAvailable = this.#volumeAvailable;
+				this.#volumeAvailable = this.#mediaCapabilities.volume;
+				this.emit("mediaControlFlagsChanged", flags, this.#mediaCapabilities);
+				if (wasVolumeAvailable !== this.#volumeAvailable) this.emit("volumeAvailabilityChanged", this.#volumeAvailable);
+			}
+		} catch (err) {
+			this.#protocol.context.logger.error("[cl-state]", "_iMC parse error", err);
+		}
+	}
+	/**
+	* Handles SystemStatus events (attention state changes from non-TV devices).
+	*
+	* @param data - The raw system status payload containing a state code.
+	*/
+	onSystemStatus(data) {
+		const state = convertAttentionState(data.state);
+		if (state !== this.#attentionState) {
+			this.#attentionState = state;
+			this.emit("attentionStateChanged", state);
+		}
+	}
+	/**
+	* Handles TVSystemStatus events (attention state changes from Apple TV).
+	*
+	* @param data - The raw TV system status payload containing a state code.
+	*/
+	onTVSystemStatus(data) {
+		const state = convertAttentionState(data.state);
+		if (state !== this.#attentionState) {
+			this.#attentionState = state;
+			this.emit("attentionStateChanged", state);
+		}
+	}
+	/**
+	* Handles NowPlayingInfo updates. Decodes the NSKeyedArchiver plist payload
+	* when present, otherwise uses the raw dictionary.
+	*
+	* @param data - The raw now-playing info payload.
+	*/
+	onNowPlayingInfo(data) {
+		try {
+			const payload = data;
+			if (payload?.NowPlayingInfoKey) {
+				const raw = payload.NowPlayingInfoKey;
+				const buf = Buffer.from(raw);
+				const plist = Plist.parse(buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength));
+				const decoded = NSKeyedArchiver.decode(plist);
+				this.#nowPlayingInfo = decoded && typeof decoded === "object" && !Array.isArray(decoded) ? decoded : null;
+			} else this.#nowPlayingInfo = payload ?? null;
+			this.emit("nowPlayingInfoChanged", this.#nowPlayingInfo);
+		} catch (err) {
+			this.#protocol.context.logger.error("[cl-state]", "NowPlayingInfo parse error", err);
+		}
+	}
+	/**
+	* Handles SupportedActions updates from the device.
+	*
+	* @param data - The raw supported actions payload.
+	*/
+	onSupportedActions(data) {
+		try {
+			const payload = data;
+			this.#supportedActions = payload ?? null;
+			this.emit("supportedActionsChanged", payload ?? {});
+		} catch (err) {
+			this.#protocol.context.logger.error("[cl-state]", "SupportedActions parse error", err);
+		}
+	}
+	/**
+	* Handles the start of a text input session. Parses the plist payload to extract
+	* document text, security mode, keyboard type, and autocorrection settings.
+	*
+	* @param data - The raw text input started payload.
+	*/
+	onTextInputStarted(data) {
+		try {
+			const payload = data;
+			let documentText = "";
+			let isSecure = false;
+			let keyboardType = 0;
+			let autocorrection = false;
+			let autocapitalization = false;
+			if (payload?._tiD) {
+				const plistData = Plist.parse(Buffer.from(payload._tiD).buffer);
+				documentText = plistData._tiDT ?? "";
+				isSecure = plistData._tiSR ?? false;
+				keyboardType = plistData._tiKT ?? 0;
+				autocorrection = plistData._tiAC ?? false;
+				autocapitalization = plistData._tiAP ?? false;
+			}
+			this.#textInputState = {
+				isActive: true,
+				documentText,
+				isSecure,
+				keyboardType,
+				autocorrection,
+				autocapitalization
+			};
+			this.emit("textInputChanged", this.#textInputState);
+		} catch (err) {
+			this.#protocol.context.logger.error("[cl-state]", "Text input started parse error", err);
+		}
+	}
+	/**
+	* Handles the end of a text input session. Resets the text input state to defaults.
+	*
+	* @param _data - The raw text input stopped payload (unused).
+	*/
+	onTextInputStopped(_data) {
+		this.#textInputState = { ...DEFAULT_TEXT_INPUT };
+		this.emit("textInputChanged", this.#textInputState);
+	}
+};
+/**
+* Parses a media control flags bitmask into a structured MediaCapabilities object.
+*
+* @param flags - The raw bitmask from the _iMC event.
+* @returns An object indicating which media controls are available.
+*/
+function parseMediaControlFlags(flags) {
+	return {
+		play: (flags & MediaControlFlag.Play) !== 0,
+		pause: (flags & MediaControlFlag.Pause) !== 0,
+		previousTrack: (flags & MediaControlFlag.PreviousTrack) !== 0,
+		nextTrack: (flags & MediaControlFlag.NextTrack) !== 0,
+		fastForward: (flags & MediaControlFlag.FastForward) !== 0,
+		rewind: (flags & MediaControlFlag.Rewind) !== 0,
+		volume: (flags & MediaControlFlag.Volume) !== 0,
+		skipForward: (flags & MediaControlFlag.SkipForward) !== 0,
+		skipBackward: (flags & MediaControlFlag.SkipBackward) !== 0
+	};
+}
+
+//#endregion
+//#region src/internal/companion-link-manager.ts
+/**
+* High-level abstraction for a Companion Link device (Apple TV).
+* Manages the OPack-based Companion Link protocol lifecycle: connect, pair-verify,
+* session setup, and provides access to HID buttons, app launching, user accounts,
+* media control, text input, touch, Siri, and system controls.
+* Requires credentials (obtained from pair-setup) to connect.
+*/
+var CompanionLinkManager = class extends EventEmitter {
+	/**
+	* @returns The underlying Companion Link Protocol instance (accessed via symbol for internal use).
+	*/
+	get [COMPANION_LINK_PROTOCOL]() {
+		return this.#protocol;
+	}
+	/**
+	* The mDNS discovery result used to connect to this device.
+	*/
+	get discoveryResult() {
+		return this.#discoveryResult;
+	}
+	/**
+	* Updates the discovery result, e.g. when the device's address changes.
+	*/
+	set discoveryResult(discoveryResult) {
+		this.#discoveryResult = discoveryResult;
+	}
+	/**
+	* Whether the Companion Link stream is currently connected.
+	*/
+	get isConnected() {
+		return this.#protocol?.stream?.isConnected ?? false;
+	}
+	/**
+	* The state tracker for attention, media controls, now-playing, and text input.
+	*/
+	get state() {
+		return this.#state;
+	}
+	/**
+	* Current text input session state (convenience accessor).
+	*/
+	get textInputState() {
+		return this.#state.textInputState;
+	}
+	#credentials;
+	#disconnect = false;
+	#discoveryResult;
+	#heartbeatInterval;
+	#keys;
+	#protocol;
+	#state;
+	/**
+	* Creates a new CompanionLinkDevice.
+	*
+	* @param discoveryResult - The mDNS discovery result for the target device.
+	*/
+	constructor(discoveryResult) {
+		super();
+		this.#discoveryResult = discoveryResult;
+		this.onClose = this.onClose.bind(this);
+		this.onError = this.onError.bind(this);
+		this.onTimeout = this.onTimeout.bind(this);
+	}
+	/**
+	* Connects to the Companion Link device, performs pair-verify, and sets up
+	* all protocol sessions (system info, TVRC, touch, text input).
+	* Emits 'connected' on success.
+	*
+	* @throws CredentialsError when no credentials are set.
+	*/
+	async connect() {
+		if (!this.#credentials) throw new CredentialsError("Credentials are required to connect to a Companion Link device.");
+		if (this.#protocol) {
+			this.#protocol.stream.off("close", this.onClose);
+			this.#protocol.stream.off("error", this.onError);
+			this.#protocol.stream.off("timeout", this.onTimeout);
+		}
+		this.#disconnect = false;
+		this.#protocol = new Protocol$1(this.#discoveryResult);
+		this.#protocol.stream.on("close", this.onClose);
+		this.#protocol.stream.on("error", this.onError);
+		this.#protocol.stream.on("timeout", this.onTimeout);
+		await this.#protocol.connect();
+		this.#keys = await this.#protocol.verify.start(this.#credentials);
+		await this.#setup();
+		this.emit("connected");
+	}
+	/**
+	* Gracefully disconnects from the device, clears heartbeat interval, and unsubscribes from events.
+	*/
+	async disconnect() {
+		this.#disconnect = true;
+		if (this.#heartbeatInterval) {
+			clearInterval(this.#heartbeatInterval);
+			this.#heartbeatInterval = void 0;
+		}
+		this.#state?.unsubscribe();
+		await this.#protocol.disconnect();
+	}
+	/**
+	* Disconnects gracefully, swallowing any errors during cleanup.
+	*/
+	async disconnectSafely() {
+		try {
+			await this.disconnect();
+		} catch {}
+	}
+	/**
+	* Sets the pairing credentials required for pair-verify authentication.
+	* Must be called before connect().
+	*
+	* @param credentials - The accessory credentials from pair-setup.
+	*/
+	async setCredentials(credentials) {
+		this.#credentials = credentials;
+	}
+	/**
+	* Fetches the current attention state of the device (active, idle, screensaver, etc.).
+	*
+	* @returns The current attention state.
+	*/
+	async getAttentionState() {
+		return await this.#protocol.getAttentionState();
+	}
+	/**
+	* Fetches the list of apps that can be launched on the device.
+	*
+	* @returns Array of launchable app descriptors.
+	*/
+	async getLaunchableApps() {
+		return await this.#protocol.getLaunchableApps();
+	}
+	/**
+	* Fetches the list of user accounts configured on the device.
+	*
+	* @returns Array of user account descriptors.
+	*/
+	async getUserAccounts() {
+		return await this.#protocol.getUserAccounts();
+	}
+	/**
+	* Fetches the current now-playing information from the device.
+	*
+	* @returns The now-playing info payload.
+	*/
+	async fetchNowPlayingInfo() {
+		return await this.#protocol.fetchNowPlayingInfo();
+	}
+	/**
+	* Fetches the currently supported actions from the device.
+	*
+	* @returns The supported actions payload.
+	*/
+	async fetchSupportedActions() {
+		return await this.#protocol.fetchSupportedActions();
+	}
+	/**
+	* Fetches the current media control status (available controls bitmask).
+	*
+	* @returns The media control status payload.
+	*/
+	async fetchMediaControlStatus() {
+		return await this.#protocol.fetchMediaControlStatus();
+	}
+	/**
+	* Launches an app on the device by its bundle identifier.
+	*
+	* @param bundleId - The bundle identifier of the app to launch.
+	*/
+	async launchApp(bundleId) {
+		await this.#protocol.launchApp(bundleId);
+	}
+	/**
+	* Opens a URL on the device (universal link or app-specific URL scheme).
+	*
+	* @param url - The URL to open.
+	*/
+	async launchUrl(url) {
+		await this.#protocol.launchUrl(url);
+	}
+	/**
+	* Sends a media control command (play, pause, next, etc.) via the Companion Link protocol.
+	*
+	* @param command - The media control command key.
+	* @param content - Optional additional content for the command.
+	*/
+	async mediaControlCommand(command, content) {
+		await this.#protocol.mediaControlCommand(command, content);
+	}
+	/**
+	* Sends a HID button press via the Companion Link protocol.
+	*
+	* @param command - The HID command key (e.g. 'up', 'select', 'menu').
+	* @param type - Optional press type (short, long, double).
+	* @param holdDelayMs - Optional hold duration in milliseconds for long presses.
+	*/
+	async pressButton(command, type, holdDelayMs) {
+		await this.#protocol.pressButton(command, type, holdDelayMs);
+	}
+	/**
+	* Switches to a different user account on the device.
+	*
+	* @param accountId - The ID of the user account to switch to.
+	*/
+	async switchUserAccount(accountId) {
+		await this.#protocol.switchUserAccount(accountId);
+	}
+	/**
+	* Sets the text input field to the given text, replacing any existing content.
+	*
+	* @param text - The text to set.
+	*/
+	async textSet(text) {
+		await this.#protocol.textInputCommand(text, true);
+	}
+	/**
+	* Appends text to the current text input field content.
+	*
+	* @param text - The text to append.
+	*/
+	async textAppend(text) {
+		await this.#protocol.textInputCommand(text, false);
+	}
+	/**
+	* Clears the text input field.
+	*/
+	async textClear() {
+		await this.#protocol.textInputCommand("", true);
+	}
+	/**
+	* Sends a raw touch event to the device.
+	*
+	* @param finger - Finger index (0-based).
+	* @param phase - Touch phase (0 = Began, 1 = Moved, 2 = Ended).
+	* @param x - Horizontal position.
+	* @param y - Vertical position.
+	*/
+	async sendTouchEvent(finger, phase, x, y) {
+		await this.#protocol.sendTouchEvent(finger, phase, x, y);
+	}
+	/**
+	* Simulates a tap at the given coordinates.
+	*
+	* @param x - Horizontal position (defaults to center 500).
+	* @param y - Vertical position (defaults to center 500).
+	*/
+	async tap(x = 500, y = 500) {
+		await this.sendTouchEvent(0, 0, x, y);
+		await waitFor(50);
+		await this.sendTouchEvent(0, 2, x, y);
+	}
+	/**
+	* Simulates a swipe gesture in the given direction.
+	*
+	* @param direction - Swipe direction.
+	* @param duration - Swipe duration in milliseconds (defaults to 200).
+	*/
+	async swipe(direction, duration = 200) {
+		const [startX, startY, endX, endY] = {
+			up: [
+				500,
+				700,
+				500,
+				300
+			],
+			down: [
+				500,
+				300,
+				500,
+				700
+			],
+			left: [
+				700,
+				500,
+				300,
+				500
+			],
+			right: [
+				300,
+				500,
+				700,
+				500
+			]
+		}[direction];
+		const steps = Math.max(4, Math.floor(duration / 50));
+		const deltaX = (endX - startX) / steps;
+		const deltaY = (endY - startY) / steps;
+		const stepDuration = duration / steps;
+		await this.sendTouchEvent(0, 0, startX, startY);
+		for (let i = 1; i < steps; i++) {
+			await waitFor(stepDuration);
+			await this.sendTouchEvent(0, 1, Math.round(startX + deltaX * i), Math.round(startY + deltaY * i));
+		}
+		await waitFor(stepDuration);
+		await this.sendTouchEvent(0, 2, endX, endY);
+	}
+	/**
+	* Toggles closed captions on the device.
+	*/
+	async toggleCaptions() {
+		await this.#protocol.toggleCaptions();
+	}
+	/**
+	* Toggles the system appearance between light and dark mode.
+	*
+	* @param light - True for light mode, false for dark mode.
+	*/
+	async toggleSystemAppearance(light) {
+		await this.#protocol.toggleSystemAppearance(light);
+	}
+	/**
+	* Enables or disables the "Reduce Loud Sounds" setting.
+	*
+	* @param enabled - Whether to enable the setting.
+	*/
+	async toggleReduceLoudSounds(enabled) {
+		await this.#protocol.toggleReduceLoudSounds(enabled);
+	}
+	/**
+	* Enables or disables finding mode (Find My integration).
+	*
+	* @param enabled - Whether to enable finding mode.
+	*/
+	async toggleFindingMode(enabled) {
+		await this.#protocol.toggleFindingMode(enabled);
+	}
+	/**
+	* Fetches the "Up Next" queue from the device.
+	*
+	* @param paginationToken - Optional token for paginated results.
+	* @returns The Up Next queue payload.
+	*/
+	async fetchUpNext(paginationToken) {
+		return await this.#protocol.fetchUpNext(paginationToken);
+	}
+	/**
+	* Adds an item to the "Up Next" queue.
+	*
+	* @param identifier - Content item identifier.
+	* @param kind - Content kind descriptor.
+	*/
+	async addToUpNext(identifier, kind) {
+		await this.#protocol.addToUpNext(identifier, kind);
+	}
+	/**
+	* Removes an item from the "Up Next" queue.
+	*
+	* @param identifier - Content item identifier.
+	* @param kind - Content kind descriptor.
+	*/
+	async removeFromUpNext(identifier, kind) {
+		await this.#protocol.removeFromUpNext(identifier, kind);
+	}
+	/**
+	* Marks a content item as watched.
+	*
+	* @param identifier - Content item identifier.
+	* @param kind - Content kind descriptor.
+	*/
+	async markAsWatched(identifier, kind) {
+		await this.#protocol.markAsWatched(identifier, kind);
+	}
+	/**
+	* Starts a Siri session on the device.
+	*/
+	async siriStart() {
+		await this.#protocol.siriStart();
+	}
+	/**
+	* Stops the active Siri session on the device.
+	*/
+	async siriStop() {
+		await this.#protocol.siriStop();
+	}
+	/**
+	* Sets up encryption, protocol sessions (system info, TVRC, touch, text input),
+	* heartbeat interval, and state tracking. Called after successful pair-verify.
+	*/
+	async #setup() {
+		const keys = this.#keys;
+		this.#protocol.stream.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
+		try {
+			await this.#protocol.systemInfo(this.#credentials.pairingId);
+			await this.#protocol.sessionStart();
+			await this.#protocol.tvrcSessionStart();
+			await this.#protocol.touchStart();
+			await this.#protocol.tiStart();
+			this.#heartbeatInterval = setInterval(() => {
+				try {
+					this.#protocol.noOp();
+				} catch (err) {
+					this.#protocol.context.logger.error("Heartbeat failed", err);
+				}
+			}, 15e3);
+			if (this.#state) this.#state.removeAllListeners();
+			this.#state = new CompanionLinkState(this.#protocol);
+			this.#state.on("attentionStateChanged", (s) => this.emit("attentionStateChanged", s));
+			this.#state.on("mediaControlFlagsChanged", (f, c) => this.emit("mediaControlFlagsChanged", f, c));
+			this.#state.on("nowPlayingInfoChanged", (i) => this.emit("nowPlayingInfoChanged", i));
+			this.#state.on("supportedActionsChanged", (a) => this.emit("supportedActionsChanged", a));
+			this.#state.on("textInputChanged", (s) => this.emit("textInputChanged", s));
+			this.#state.on("volumeAvailabilityChanged", (a) => this.emit("volumeAvailabilityChanged", a));
+			this.#state.subscribe();
+			await this.#state.fetchInitialState();
+		} catch (err) {
+			clearInterval(this.#heartbeatInterval);
+			this.#heartbeatInterval = void 0;
+			throw err;
+		}
+	}
+	/**
+	* Handles the stream close event. Emits 'disconnected' with unexpected=true if not intentional.
+	*/
+	onClose() {
+		this.#protocol.context.logger.net("onClose() called on companion link device.");
+		if (!this.#disconnect) {
+			this.disconnectSafely();
+			this.emit("disconnected", true);
+		} else this.emit("disconnected", false);
+	}
+	/**
+	* Handles stream error events by logging them.
+	*
+	* @param err - The error that occurred.
+	*/
+	onError(err) {
+		this.#protocol.context.logger.error("Companion Link error", err);
+	}
+	/**
+	* Handles stream timeout events by destroying the stream.
+	*/
+	onTimeout() {
+		this.#protocol.context.logger.error("Companion Link timeout");
+		this.#protocol.stream.destroy();
+	}
+};
+
+//#endregion
+//#region src/pairing/pairing-session.ts
+/**
+* Step-based pairing session for Apple TV devices.
+*
+* Provides a three-phase pairing flow suitable for external UI frameworks
+* (e.g., Homey's pairing wizard) where PIN entry happens asynchronously:
+*
+* ```ts
+* const session = tv.createPairingSession();
+* await session.start();              // Connects and triggers PIN dialog on TV
+* await session.pin('1234');           // Submits PIN, executes M1-M6
+* const credentials = await session.end();  // Returns credentials, cleans up
+* ```
+*/
+var PairingSession = class {
+	#protocol;
+	#credentials;
+	#discoveryResult;
+	#identity;
+	#finished = false;
+	constructor(discoveryResult, identity) {
+		this.#discoveryResult = discoveryResult;
+		this.#identity = identity;
+	}
+	/**
+	* Connects to the device and triggers the PIN dialog.
+	* After this method returns, the Apple TV displays a 4-digit PIN on screen.
+	*/
+	async start() {
+		this.#protocol = new Protocol(this.#discoveryResult, this.#identity);
+		await this.#protocol.connect();
+		await this.#protocol.fetchInfo();
+		await this.#protocol.pairing.start();
+		await this.#protocol.pairing.pinStart();
+	}
+	/**
+	* Submits the PIN and executes the M1-M6 key exchange.
+	*
+	* @param code - The 4-digit PIN displayed on the Apple TV screen.
+	*/
+	async pin(code) {
+		if (!this.#protocol) throw new Error("PairingSession.start() must be called before pin().");
+		const internal = this.#protocol.pairing.internal;
+		const m1 = await internal.m1();
+		const m2 = await internal.m2(m1, code);
+		const m3 = await internal.m3(m2);
+		const m4 = await internal.m4(m3);
+		const m5 = await internal.m5(m4);
+		const credentials = await internal.m6(m4, m5);
+		if (!credentials) throw new Error("Pairing failed: could not obtain credentials.");
+		this.#credentials = credentials;
+	}
+	/**
+	* Finishes the pairing session, cleans up the protocol connection,
+	* and returns the obtained credentials.
+	*
+	* @returns Long-term credentials for future connections.
+	*/
+	async end() {
+		if (!this.#credentials) throw new Error("PairingSession.pin() must be called before end().");
+		const credentials = this.#credentials;
+		this.#cleanup();
+		return credentials;
+	}
+	/**
+	* Aborts the pairing session and cleans up without returning credentials.
+	* Use this when the user cancels pairing.
+	*/
+	abort() {
+		this.#cleanup();
+	}
+	#cleanup() {
+		if (this.#finished) return;
+		this.#finished = true;
+		try {
+			this.#protocol?.disconnect();
+		} catch {}
+	}
+};
+
+//#endregion
+//#region src/device/device.ts
+/**
+* Abstract base class for all Apple devices.
+* Provides shared controllers and lifecycle management.
+*/
+var AbstractDevice = class extends EventEmitter {
+	#airplay;
+	#discoveryResult;
+	#identity;
+	remote;
+	playback;
+	state;
+	volume;
+	artwork;
+	media;
+	multiroom;
+	constructor(options) {
+		super();
+		if (!options.airplay && !options.address) throw new Error("Either `airplay` discovery result or `address` must be provided.");
+		this.#discoveryResult = options.airplay ?? {
+			id: options.address,
+			txt: {},
+			fqdn: options.address,
+			address: options.address,
+			modelName: "",
+			familyName: null,
+			service: {
+				port: 7e3,
+				protocol: "tcp",
+				type: "_airplay._tcp"
+			},
+			packet: null
+		};
+		this.#identity = options.identity;
+		this.#airplay = new AirPlayManager(this.#discoveryResult, this.#identity);
+		const timingServer = options.timingServer ?? getGlobalTimingServer();
+		if (timingServer) this.#airplay.timingServer = timingServer;
+		this.remote = new RemoteController(this.#airplay);
+		this.playback = new PlaybackController(this.#airplay);
+		this.state = new StateController(this.#airplay);
+		this.volume = new VolumeController(this.#airplay);
+		this.artwork = new ArtworkController(this.#airplay);
+		this.media = new MediaController(this.#airplay);
+		this.multiroom = new MultiroomController(this.#airplay);
+		this.#airplay.on("connected", () => this.onAirPlayConnected());
+		this.#airplay.on("disconnected", (unexpected) => this.onAirPlayDisconnected(unexpected));
+	}
+	/**
+	* The unique identifier of the device (from mDNS discovery).
+	*/
+	get id() {
+		return this.#discoveryResult.id;
+	}
+	/**
+	* The human-readable name of the device.
+	*/
+	get name() {
+		return this.#discoveryResult.familyName ?? this.#discoveryResult.fqdn;
+	}
+	/**
+	* The IP address of the device.
+	*/
+	get address() {
+		return this.#discoveryResult.address;
+	}
+	/**
+	* Whether the device is currently connected.
+	*/
+	get isConnected() {
+		return this.#airplay.isConnected;
+	}
+	/**
+	* Raw receiver info from the AirPlay /info endpoint.
+	*/
+	get receiverInfo() {
+		return this.#airplay.receiverInfo;
+	}
+	/**
+	* AirPlay device capabilities (features supported by the receiver).
+	*/
+	get capabilities() {
+		return this.#airplay.capabilities;
+	}
+	/**
+	* Updates the discovery result (e.g. when the device's IP address changes).
+	*/
+	set discoveryResult(result) {
+		this.#airplay.discoveryResult = result;
+	}
+	/**
+	* Updates the timing server for multi-room audio sync.
+	*/
+	set timingServer(server) {
+		this.#airplay.timingServer = server;
+	}
+	/**
+	* The underlying AirPlay protocol manager.
+	* Use this for low-level protocol access, raw state events, or features
+	* not covered by the high-level controllers.
+	*/
+	get airplay() {
+		return this.#airplay;
+	}
+	/**
+	* Creates a step-based pairing session for interactive PIN entry flows.
+	*
+	* ```ts
+	* const session = tv.createPairingSession();
+	* await session.start();           // Connects and triggers PIN dialog
+	* await session.pin('1234');        // Submits PIN, executes M1-M6
+	* const creds = await session.end(); // Returns credentials, cleans up
+	* ```
+	*/
+	createPairingSession() {
+		return new PairingSession(this.#discoveryResult, this.#identity);
+	}
+	/**
+	* Pairs with the device using a callback-based PIN flow.
+	* Convenience method that wraps createPairingSession().
+	*
+	* @param options - Pairing options with onPinRequired callback.
+	* @returns Long-term credentials for future connections.
+	*/
+	async pair(options) {
+		const session = this.createPairingSession();
+		await session.start();
+		const pin = await options.onPinRequired();
+		await session.pin(pin);
+		return await session.end();
+	}
+	/**
+	* Disconnects from the device.
+	*/
+	disconnect() {
+		this.state.unsubscribe();
+		this.#airplay.disconnectSafely();
+	}
+	/**
+	* Called when AirPlay connects successfully. Override for additional setup.
+	*/
+	onAirPlayConnected() {
+		this.state.subscribe();
+	}
+	/**
+	* Called when AirPlay disconnects. Override for additional cleanup.
+	*/
+	onAirPlayDisconnected(unexpected) {
+		this.state.unsubscribe();
+	}
+};
+
+//#endregion
+//#region src/device/apple-tv.ts
+/**
+* High-level Apple TV device combining AirPlay and Companion Link protocols.
+* Provides remote control, media playback, app launching, keyboard input,
+* power management, and system settings.
+*
+* ```ts
+* const tv = new AppleTV({ airplay: result, companionLink: clResult });
+*
+* // First time — pair
+* const session = tv.createPairingSession();
+* await session.start();
+* await session.pin('1234');
+* const credentials = await session.end();
+*
+* // Connect with credentials
+* await tv.connect(credentials);
+* await tv.playback.play();
+* ```
+*/
+var AppleTV = class extends AbstractDevice {
+	#companionLink;
+	accounts;
+	apps;
+	keyboard;
+	power;
+	system;
+	constructor(options) {
+		super(options);
+		this.keyboard = new KeyboardController(this.airplay);
+		if (options.companionLink) {
+			this.#companionLink = new CompanionLinkManager(options.companionLink);
+			this.accounts = new AccountsController(this.#companionLink);
+			this.apps = new AppsController(this.#companionLink);
+			this.power = new PowerController(this.airplay, this.#companionLink);
+			this.system = new SystemController(this.#companionLink);
+			this.#companionLink.on("attentionStateChanged", (state) => {
+				this.emit("power", state);
+			});
+			this.#companionLink.on("textInputChanged", (state) => {
+				this.emit("textInput", state);
+			});
+		}
+	}
+	/**
+	* The underlying Companion Link protocol manager, or undefined if no
+	* Companion Link discovery result was provided.
+	* Use this for low-level protocol access or features not covered by controllers.
+	*/
+	get companionLink() {
+		return this.#companionLink;
+	}
+	get isConnected() {
+		const airplayConnected = this.airplay.isConnected;
+		const companionLinkConnected = this.#companionLink?.isConnected ?? true;
+		return airplayConnected && companionLinkConnected;
+	}
+	/**
+	* Connects to the Apple TV using AirPlay and (optionally) Companion Link.
+	*
+	* @param credentials - Pairing credentials from pair-setup.
+	*/
+	async connect(credentials) {
+		this.airplay.setCredentials(credentials);
+		await this.airplay.connect();
+		if (this.#companionLink) try {
+			await this.#companionLink.setCredentials(credentials);
+			await this.#companionLink.connect();
+		} catch {}
+	}
+	disconnect() {
+		super.disconnect();
+		this.#companionLink?.disconnectSafely();
+	}
+	onAirPlayConnected() {
+		super.onAirPlayConnected();
+		this.emit("connected");
+	}
+	onAirPlayDisconnected(unexpected) {
+		super.onAirPlayDisconnected(unexpected);
+		this.emit("disconnected", unexpected);
+	}
+};
+
+//#endregion
+//#region src/device/homepod.ts
+/**
+* High-level HomePod device using AirPlay only (transient pairing).
+* Provides media playback, URL playback, audio streaming, and volume control.
+* No credentials needed — transient pairing is handled transparently.
+*
+* ```ts
+* const pod = new HomePod({ airplay: result });
+* await pod.connect();
+* await pod.media.playUrl('https://example.com/song.mp3');
+* ```
+*/
+var HomePod = class extends AbstractDevice {
+	constructor(options) {
+		super(options);
+	}
+	/**
+	* Connects to the HomePod using transient pairing (no credentials needed).
+	*/
+	async connect() {
+		await this.airplay.connect();
+	}
+	onAirPlayConnected() {
+		super.onAirPlayConnected();
+		this.emit("connected");
+	}
+	onAirPlayDisconnected(unexpected) {
+		super.onAirPlayDisconnected(unexpected);
+		this.emit("disconnected", unexpected);
+	}
+};
+
+//#endregion
+//#region src/device/homepod-mini.ts
+/**
+* High-level HomePod Mini device.
+* Functionally identical to HomePod, different device model.
+*/
+var HomePodMini = class extends HomePod {};
+
+//#endregion
+//#region src/discover.ts
+/**
+* Discovers Apple devices on the local network via mDNS.
+* Returns device descriptors that can be passed to createDevice().
+*/
+async function discover() {
+	const airplayResults = await Discovery.airplay().find();
+	const companionLinkResults = await Discovery.companionLink().find();
+	const byAddress = /* @__PURE__ */ new Map();
+	for (const result of airplayResults) byAddress.set(result.address, {
+		id: result.id,
+		name: result.familyName ?? result.fqdn,
+		address: result.address,
+		modelName: result.modelName,
+		deviceType: detectDeviceType(result.modelName),
+		services: { airplay: result }
+	});
+	for (const result of companionLinkResults) {
+		const existing = byAddress.get(result.address);
+		if (existing) byAddress.set(result.address, {
+			...existing,
+			services: {
+				...existing.services,
+				companionLink: result
+			}
+		});
+		else byAddress.set(result.address, {
+			id: result.id,
+			name: result.familyName ?? result.fqdn,
+			address: result.address,
+			modelName: result.modelName,
+			deviceType: detectDeviceType(result.modelName),
+			services: { companionLink: result }
+		});
+	}
+	return Array.from(byAddress.values());
+}
+/**
+* Creates a typed device instance from a discovery result.
+* Automatically selects AppleTV, HomePod, or HomePodMini based on the model.
+*/
+function createDevice(discovered) {
+	switch (discovered.deviceType) {
+		case "appletv": return new AppleTV({
+			airplay: discovered.services.airplay,
+			companionLink: discovered.services.companionLink
+		});
+		case "homepod-mini": return new HomePodMini({ airplay: discovered.services.airplay });
+		default: return new HomePod({ airplay: discovered.services.airplay });
+	}
+}
+/**
+* Detects the device type from the model name string.
+*/
+function detectDeviceType(modelName) {
+	if (!modelName) return "unknown";
+	if (/^AppleTV/i.test(modelName)) return "appletv";
+	if (/AudioAccessory[56]/i.test(modelName)) return "homepod-mini";
+	if (/AudioAccessory/i.test(modelName)) return "homepod";
+	return "unknown";
+}
+
+//#endregion
+export { PROTOCOL as AIRPLAY_PROTOCOL, AbstractDevice, AccountsController, AirPlayArtwork, AirPlayClient, AirPlayManager, AirPlayPlayer, AirPlayRemote, AirPlayState, AirPlayVolume, AppleTV, AppsController, ArtworkController, COMPANION_LINK_PROTOCOL, CompanionLinkManager, CompanionLinkState, HomePod, HomePodMini, KeyboardController, MediaController, MultiroomController, PairingSession, PlaybackController, PowerController, Proto, RemoteController, SendCommandError, StateController, SystemController, TimingServer, VolumeController, configure, createDevice, discover };