@corewire/companion-link 0.0.0 → 1.0.0-next.1

package/dist/index.mjs

@@ -0,0 +1,1857 @@
+import { t as __exportAll } from "./chunk-w6R9maHv.mjs";
+import { randomInt } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { CommandError, ConnectionClosedError, CredentialsError, InvalidResponseError, PairingError, TimeoutError, reporter, waitFor } from "@corewire/core";
+import { Context, DEFAULT_CLIENT_NAME, EncryptionAwareConnection, buildNonce } from "@corewire/core/transport";
+import { NSKeyedArchiver, OPack, Plist, RTI } from "@corewire/core/encoding";
+import { ChaCha20, HKDF } from "@corewire/core/crypto";
+import { PairSetup, PairVerify } from "@corewire/core/pairing";
+import { Discovery } from "@corewire/core/discovery";
+
+//#region src/const.ts
+/** Siri Remote buttons, as the command ids of the `_hidC` request. */
+const HidCommand = {
+	Up: 1,
+	Down: 2,
+	Left: 3,
+	Right: 4,
+	Menu: 5,
+	Select: 6,
+	Home: 7,
+	VolumeUp: 8,
+	VolumeDown: 9,
+	Siri: 10,
+	Screensaver: 11,
+	Sleep: 12,
+	Wake: 13,
+	PlayPause: 14,
+	ChannelIncrement: 15,
+	ChannelDecrement: 16,
+	Guide: 17,
+	PageUp: 18,
+	PageDown: 19,
+	SkipForward: 20,
+	SkipBackward: 21,
+	Back: 22,
+	Exit: 23,
+	Info: 24,
+	CaptionsToggle: 25,
+	Accessibility: 26,
+	InputSelect: 27,
+	Mute: 29,
+	Power: 30
+};
+/** Playback and caption commands of the `_mcc` request. */
+const MediaControlCommand = {
+	Play: 1,
+	Pause: 2,
+	NextTrack: 3,
+	PreviousTrack: 4,
+	GetVolume: 5,
+	SetVolume: 6,
+	SkipBy: 7,
+	FastForwardBegin: 8,
+	FastForwardEnd: 9,
+	RewindBegin: 10,
+	RewindEnd: 11,
+	GetCaptionSettings: 12,
+	SetCaptionSettings: 13
+};
+/** Bit flags of the media controls the Apple TV supports right now, from the media control status. */
+const MediaControlFlag = {
+	Play: 1,
+	Pause: 2,
+	PreviousTrack: 4,
+	NextTrack: 8,
+	FastForward: 16,
+	Rewind: 32,
+	Volume: 256,
+	SkipForward: 512,
+	SkipBackward: 1024
+};
+
+//#endregion
+//#region src/frame.ts
+/** The first byte of every frame header; it decides how the payload is parsed and routed. */
+const FrameType = {
+	Unknown: 0,
+	NoOp: 1,
+	PairSetupStart: 3,
+	PairSetupNext: 4,
+	PairVerifyStart: 5,
+	PairVerifyNext: 6,
+	OPackUnencrypted: 7,
+	OPackEncrypted: 8,
+	OPackPacked: 9,
+	PairingRequest: 10,
+	PairingResponse: 11,
+	SessionStartRequest: 16,
+	SessionStartResponse: 17,
+	SessionData: 18,
+	FamilyIdentityRequest: 32,
+	FamilyIdentityResponse: 33,
+	FamilyIdentityUpdate: 34
+};
+/** The `_t` field of an OPack message. */
+const MessageType = {
+	Event: 1,
+	Request: 2,
+	Response: 3
+};
+/** Frame types with an OPack payload. */
+const OPackFrameTypes = [
+	FrameType.PairSetupStart,
+	FrameType.PairSetupNext,
+	FrameType.PairVerifyStart,
+	FrameType.PairVerifyNext,
+	FrameType.OPackUnencrypted,
+	FrameType.OPackEncrypted,
+	FrameType.OPackPacked
+];
+/** Pair-setup and pair-verify frames. They have no `_x` exchange id, so they get a queue id of their own. */
+const PairingFrameTypes = [
+	FrameType.PairSetupStart,
+	FrameType.PairSetupNext,
+	FrameType.PairVerifyStart,
+	FrameType.PairVerifyNext
+];
+
+//#endregion
+//#region src/messages.ts
+var messages_exports = /* @__PURE__ */ __exportAll({
+	addToUpNext: () => addToUpNext,
+	appSignInRequest: () => appSignInRequest,
+	deregisterInterests: () => deregisterInterests,
+	fetchAttentionState: () => fetchAttentionState,
+	fetchCurrentTopShelfItems: () => fetchCurrentTopShelfItems,
+	fetchLaunchableApps: () => fetchLaunchableApps,
+	fetchMediaControlStatus: () => fetchMediaControlStatus,
+	fetchNowPlayingInfo: () => fetchNowPlayingInfo,
+	fetchSiriRemoteInfo: () => fetchSiriRemoteInfo,
+	fetchSupportedActions: () => fetchSupportedActions,
+	fetchUpNext: () => fetchUpNext,
+	fetchUserAccounts: () => fetchUserAccounts,
+	gameControllerEvent: () => gameControllerEvent,
+	gameControllerStart: () => gameControllerStart,
+	gameControllerStop: () => gameControllerStop,
+	hidCommand: () => hidCommand,
+	hidTouchEvent: () => hidTouchEvent,
+	launchApp: () => launchApp,
+	launchUrl: () => launchUrl,
+	markAsWatched: () => markAsWatched,
+	mediaCaptionSettingGet: () => mediaCaptionSettingGet,
+	mediaCaptionSettingSet: () => mediaCaptionSettingSet,
+	mediaControlCommand: () => mediaControlCommand,
+	mediaSkipBySeconds: () => mediaSkipBySeconds,
+	playMedia: () => playMedia,
+	registerInterests: () => registerInterests,
+	removeFromUpNext: () => removeFromUpNext,
+	restrictedAccessRequest: () => restrictedAccessRequest,
+	sessionStart: () => sessionStart,
+	sessionStop: () => sessionStop,
+	siriStart: () => siriStart,
+	siriStop: () => siriStop,
+	switchActiveUserAccount: () => switchActiveUserAccount,
+	switchUserAccount: () => switchUserAccount,
+	systemInfo: () => systemInfo,
+	tiChange: () => tiChange,
+	tiStart: () => tiStart,
+	tiStop: () => tiStop,
+	toggleCaptions: () => toggleCaptions,
+	toggleFindingMode: () => toggleFindingMode,
+	toggleReduceLoudSounds: () => toggleReduceLoudSounds,
+	toggleSystemAppearance: () => toggleSystemAppearance,
+	touchEvent: () => touchEvent,
+	touchStart: () => touchStart,
+	touchStop: () => touchStop,
+	tvProviderRequest: () => tvProviderRequest,
+	tvrcSessionStart: () => tvrcSessionStart,
+	tvrcSessionStop: () => tvrcSessionStop
+});
+/** A request; the device replies. */
+function request(identifier, content = {}) {
+	return {
+		_i: identifier,
+		_t: MessageType.Request,
+		_c: content
+	};
+}
+/** A request with Bluetooth high priority off (`_btHP: false`), for messages that should not cause a Bluetooth wake. */
+function requestBtHP(identifier, content = {}) {
+	return {
+		_i: identifier,
+		_t: MessageType.Request,
+		_btHP: false,
+		_c: content
+	};
+}
+/** An event; the device sends no reply. */
+function event(identifier, content = {}) {
+	return {
+		_i: identifier,
+		_t: MessageType.Event,
+		_c: content
+	};
+}
+/** The `_systemInfo` request of the startup: the identity, model and services of this controller. */
+function systemInfo(pairingId, name, model = "iPhone16,2", sourceVersion = "715.2") {
+	return requestBtHP("_systemInfo", {
+		_bf: 0,
+		_cf: 512,
+		_clFl: 128,
+		_i: "b561af32aea6",
+		_idsID: pairingId.toString(),
+		_pubID: "DA:6D:1E:D8:A0:4F",
+		_sf: 1099511628032,
+		_sv: sourceVersion,
+		model,
+		name,
+		_lP: 50402,
+		_dC: "1",
+		_stA: [
+			"com.apple.sharingd.AirDrop",
+			"SymptomNetworkDiagnostics",
+			"com.apple.photosface.network-service",
+			"com.apple.ApplicationService.chrono",
+			"com.apple.DDUI-Picker",
+			"com.apple.biomesyncd.cascade.rapport",
+			"com.apple.SeymourSession",
+			"com.apple.workflow.remotewidgets",
+			"SCD.MessageCenter.remoteIntelligence",
+			"DeviceSharingDaemonApplicationService",
+			"com.apple.biomesyncd.rapport",
+			"com.apple.devicediscoveryui.rapportwake",
+			"com.apple.healthd.rapport",
+			"com.apple.dropin.setup",
+			"com.apple.coreduet.sync",
+			"com.apple.siri.wakeup",
+			"com.apple.wifivelocityd.rapportWake",
+			"com.apple.Seymour",
+			"CPSRemoteLLM",
+			"com.apple.networkrelay.on-demand-setup",
+			"com.apple.home.messaging",
+			"com.apple.accessibility.axremoted.rapportWake",
+			"com.apple.continuitycapture.sideband",
+			"com.apple.announce",
+			"com.apple.coreidv.coreidvd.handoff"
+		]
+	});
+}
+/** Starts a session with the `com.apple.tvremoteservices` service under a session id of our own. */
+function sessionStart(localSid) {
+	return {
+		_i: "_sessionStart",
+		_t: MessageType.Request,
+		_btHP: false,
+		_c: {
+			_srvT: "com.apple.tvremoteservices",
+			_sid: localSid,
+			_btHP: false
+		}
+	};
+}
+function sessionStop(localSid) {
+	return request("_sessionStop", {
+		_srvT: "com.apple.tvremoteservices",
+		_sid: localSid
+	});
+}
+/** Starts a TV Remote Control session, which `tvremoted` handles on the Apple TV. */
+function tvrcSessionStart() {
+	return {
+		_i: "TVRCSessionStart",
+		_t: MessageType.Request,
+		_btHP: false,
+		_inUseProc: "tvremoted",
+		_c: { ProtocolVersionKey: "1.2" }
+	};
+}
+function tvrcSessionStop() {
+	return request("TVRCSessionStop");
+}
+/** One button edge of a {@link HidCommand}; `down` false sends the release. */
+function hidCommand(commandId, down) {
+	return request("_hidC", {
+		_hBtS: down ? 1 : 2,
+		_hidC: commandId
+	});
+}
+/** Starts the virtual touchpad; the size sets its coordinate space. */
+function touchStart(width = 1e3, height = 1e3) {
+	return requestBtHP("_touchStart", {
+		_height: OPack.float(height),
+		_tFl: 0,
+		_width: OPack.float(width)
+	});
+}
+function touchStop() {
+	return request("_touchStop", { _i: 1 });
+}
+/**
+* A `_touchC` event, in the coordinate space of the touchpad.
+*
+* @param finger - The finger index, 0-based.
+* @param phase - A {@link TouchPhase} value.
+*/
+function touchEvent(finger, phase, x, y) {
+	return event("_touchC", {
+		_tFg: finger,
+		_tPh: phase,
+		_tX: OPack.float(x),
+		_tY: OPack.float(y)
+	});
+}
+/**
+* A `_hidT` event, the form an Apple remote sends touchpad gestures in on the wire. Unlike
+* {@link touchEvent}, the coordinates are integers and the event carries a timestamp.
+*
+* @param finger - The finger index, 1-based.
+* @param phase - A {@link HidTouchPhase} value.
+* @param timestamp - A monotonic timestamp in nanoseconds.
+*/
+function hidTouchEvent(finger, phase, x, y, timestamp = Number(process.hrtime.bigint())) {
+	return event("_hidT", {
+		_ns: OPack.sizedInteger(timestamp, 8),
+		_tFg: finger,
+		_cx: Math.round(x),
+		_tPh: phase,
+		_cy: Math.round(y)
+	});
+}
+/** Starts remote text input (RTI); the reply carries the keyboard session. */
+function tiStart() {
+	return requestBtHP("_tiStart", { _tiV: 1 });
+}
+function tiStop() {
+	return requestBtHP("_tiStop");
+}
+/** A `_tiC` event with serialized RTITextOperations. */
+function tiChange(tiD) {
+	return event("_tiC", {
+		_tiV: 1,
+		_tiD: tiD
+	});
+}
+/**
+* A `_mcc` request.
+*
+* @param commandId - A {@link MediaControlCommand} value.
+* @param content - Extra fields, such as the volume for `SetVolume`.
+*/
+function mediaControlCommand(commandId, content) {
+	return request("_mcc", {
+		_mcc: commandId,
+		...content ?? {}
+	});
+}
+/** Skips forward, or backward for a negative number of seconds. */
+function mediaSkipBySeconds(seconds) {
+	return request("_mcc", {
+		_mcc: MediaControlCommand.SkipBy,
+		_ski: seconds
+	});
+}
+function mediaCaptionSettingGet() {
+	return request("_mcc", { _mcc: MediaControlCommand.GetCaptionSettings });
+}
+function mediaCaptionSettingSet(enabled) {
+	return request("_mcc", {
+		_mcc: MediaControlCommand.SetCaptionSettings,
+		_cse: enabled
+	});
+}
+function launchApp(bundleId) {
+	return request("_launchApp", { _bundleID: bundleId });
+}
+/** Opens a URL; the device picks the app through universal links. */
+function launchUrl(url) {
+	return request("_launchApp", { _urlS: url });
+}
+/** Asks for the attention (power) state. */
+function fetchAttentionState() {
+	return request("FetchAttentionState");
+}
+function fetchLaunchableApps() {
+	return request("FetchLaunchableApplicationsEvent");
+}
+function fetchMediaControlStatus() {
+	return request("FetchMediaControlStatus");
+}
+function fetchNowPlayingInfo() {
+	return request("FetchCurrentNowPlayingInfoEvent");
+}
+function fetchSiriRemoteInfo() {
+	return request("FetchSiriRemoteInfo");
+}
+function fetchSupportedActions() {
+	return request("FetchSupportedActionsEvent");
+}
+function fetchCurrentTopShelfItems() {
+	return requestBtHP("FetchCurrentTopShelfItemsEvent");
+}
+function fetchUserAccounts() {
+	return request("FetchUserAccountsEvent");
+}
+function switchUserAccount(accountId) {
+	return request("SwitchUserAccountEvent", { SwitchAccountID: accountId });
+}
+/**
+* Tells the Apple TV which iCloud account (alternate DSID) this controller is active on. An iOS
+* remote sends it during the startup.
+*/
+function switchActiveUserAccount(iCloudAltDSID) {
+	return requestBtHP("SwitchActiveUserAccountEvent", { iCloudAltDSID });
+}
+/** Registers interest in events the device pushes, such as `_iMC` or `SystemStatus`. */
+function registerInterests(events) {
+	return event("_interest", { _regEvents: events });
+}
+function deregisterInterests(events) {
+	return event("_interest", { _deregEvents: events });
+}
+function toggleCaptions() {
+	return request("ToggleCaptions");
+}
+/** Light appearance when `light` is true, dark when false. */
+function toggleSystemAppearance(light) {
+	return request("ToggleSystemAppearance", { SystemAppearanceLight: light });
+}
+function toggleReduceLoudSounds(enabled) {
+	return request("ToggleReduceLoudSounds", { ReduceLoundSoundsEnabled: enabled });
+}
+/** Turns the Find My finding mode on or off. */
+function toggleFindingMode(enabled) {
+	return request("ToggleFindingMode", { FindingModeEnabledKey: enabled });
+}
+/** @param paginationToken - Fetches the page after the one that returned it. */
+function fetchUpNext(paginationToken) {
+	return request("FetchUpNextInfoEvent", paginationToken ? { PaginationTokenKey: paginationToken } : {});
+}
+/** @param kind - The content kind, such as movie or episode. */
+function addToUpNext(identifier, kind) {
+	return request("AddToUpNextEvent", {
+		IdentifierKey: identifier,
+		KindKey: kind
+	});
+}
+function removeFromUpNext(identifier, kind) {
+	return request("RemoveFromUpNextEvent", {
+		IdentifierKey: identifier,
+		KindKey: kind
+	});
+}
+function markAsWatched(identifier, kind) {
+	return request("MarkAsWatchedEvent", {
+		IdentifierKey: identifier,
+		KindKey: kind
+	});
+}
+function playMedia(item) {
+	return request("PlayMediaEvent", item);
+}
+/** Starts Siri push-to-talk. */
+function siriStart() {
+	return request("_siriStart");
+}
+/** Ends Siri push-to-talk. */
+function siriStop() {
+	return request("_siriStop");
+}
+/** One stick position (-1 to 1 per axis) and the button state, as an event without a reply. */
+function gameControllerEvent(x, y, isDown) {
+	return event("_gcC", {
+		_gcX: x,
+		_gcY: y,
+		_gcBtS: isDown ? 1 : 0
+	});
+}
+function gameControllerStart() {
+	return requestBtHP("_gcStart");
+}
+function gameControllerStop() {
+	return requestBtHP("_gcStop");
+}
+/**
+* Runs the sign-in of an Apple TV app through this controller, as a paired iPhone or iPad does.
+*
+* @param requestType - The kind of sign-in: `appleID`, `password` or `custom`.
+*/
+function appSignInRequest(bundleId, requestType = "appleID") {
+	return request("_cpsAISR", {
+		_bundleID: bundleId,
+		_reqType: requestType
+	});
+}
+/** A TV provider (MVPD) sign-in request. */
+function tvProviderRequest(providerUrl, providerName) {
+	return request("_cpsTVPR", {
+		_pvUrl: providerUrl,
+		_pvName: providerName
+	});
+}
+/** A restricted access (parental controls) approval request. */
+function restrictedAccessRequest(restrictionType) {
+	return request("_cpsRAR", { _raType: restrictionType });
+}
+
+//#endregion
+//#region src/accounts.ts
+/** User accounts on the device, and the experimental sign-in, TV provider and parental approval requests. */
+var Accounts = class {
+	#channel;
+	constructor(channel) {
+		this.#channel = channel;
+	}
+	async list() {
+		const reply = await this.#channel.exchange(fetchUserAccounts());
+		return Object.entries(reply._c).map(([accountId, name]) => ({
+			accountId,
+			name
+		}));
+	}
+	async switch(accountId) {
+		await this.#channel.exchange(switchUserAccount(accountId));
+	}
+	/** Tells the device which iCloud account (alternate DSID) this controller is active on. */
+	async switchActive(iCloudAltDSID) {
+		await this.#channel.exchange(switchActiveUserAccount(iCloudAltDSID));
+	}
+	/** @param requestType The kind of sign-in: `appleID`, `password` or `custom`. */
+	async requestAppSignIn(bundleId, requestType = "appleID") {
+		return await this.#channel.exchange(appSignInRequest(bundleId, requestType));
+	}
+	async requestTVProvider(providerUrl, providerName) {
+		return await this.#channel.exchange(tvProviderRequest(providerUrl, providerName));
+	}
+	async requestRestrictedAccess(restrictionType) {
+		return await this.#channel.exchange(restrictedAccessRequest(restrictionType));
+	}
+};
+
+//#endregion
+//#region src/apps.ts
+/** The apps on the device: listing, launching, opening a URL and the top shelf. */
+var Apps = class {
+	#channel;
+	constructor(channel) {
+		this.#channel = channel;
+	}
+	async list() {
+		const reply = await this.#channel.exchange(fetchLaunchableApps());
+		return Object.entries(reply._c).map(([bundleId, name]) => ({
+			bundleId,
+			name
+		}));
+	}
+	async launch(bundleId) {
+		await this.#channel.exchange(launchApp(bundleId));
+	}
+	/** Opens a URL; the device picks the app through universal links or the URL scheme. */
+	async openUrl(url) {
+		await this.#channel.exchange(launchUrl(url));
+	}
+	/** The top shelf items the device shows now, as the raw reply. */
+	async topShelf() {
+		return await this.#channel.exchange(fetchCurrentTopShelfItems());
+	}
+};
+
+//#endregion
+//#region src/channel.ts
+/**
+* What the groups of a session send with: encrypted requests that check the reply, events without
+* one, and the events the device sends. Listeners go when the session signal aborts.
+*/
+var Channel = class {
+	/** Aborts when the session ends. */
+	get signal() {
+		return this.#signal;
+	}
+	/** Whether the socket can still carry a frame; false while the session closes. */
+	get isConnected() {
+		return this.#stream.isConnected;
+	}
+	#listeners = /* @__PURE__ */ new Map();
+	#signal;
+	#stream;
+	constructor(stream, signal) {
+		this.#signal = signal;
+		this.#stream = stream;
+		if (signal.aborted) return;
+		const onEvent = (name, content) => this.#dispatch(name, content);
+		stream.on("event", onEvent);
+		signal.addEventListener("abort", () => {
+			stream.off("event", onEvent);
+			this.#listeners.clear();
+		}, { once: true });
+	}
+	/**
+	* Sends a request and resolves with its reply.
+	*
+	* @throws {CommandError} When the reply carries `_em` or a non-zero `_ec`.
+	* @throws {TimeoutError} When no reply arrives in time.
+	* @throws {ConnectionClosedError} When the session ends first.
+	*/
+	async exchange(message) {
+		const [, response] = await this.#stream.exchange(FrameType.OPackEncrypted, message);
+		const reply = objectOrFail(response);
+		if (reply._em || reply._ec !== void 0 && Number(reply._ec) !== 0) {
+			const details = [reply._ed, reply._ec === void 0 ? void 0 : Number(reply._ec)].filter((value) => value !== void 0).join(" ");
+			throw new CommandError(`${message._i}: ${reply._em || "Command failed"}${details ? ` (${details})` : ""}`);
+		}
+		return reply;
+	}
+	/**
+	* Sends an event, which gets no reply.
+	*
+	* @throws {ConnectionClosedError} When the session has ended.
+	*/
+	send(message) {
+		this.#stream.sendOPack(FrameType.OPackEncrypted, message);
+	}
+	/** Calls the listener with the `_c` of every event with this name, until the session ends. */
+	listen(name, listener) {
+		if (this.#signal.aborted) return;
+		let listeners = this.#listeners.get(name);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			this.#listeners.set(name, listeners);
+		}
+		listeners.add(listener);
+	}
+	unlisten(name, listener) {
+		this.#listeners.get(name)?.delete(listener);
+	}
+	#dispatch(name, content) {
+		for (const listener of [...this.#listeners.get(name) ?? []]) listener(content);
+	}
+};
+/** @throws {TypeError} When the value is not an object. */
+function objectOrFail(value) {
+	if (value !== null && typeof value === "object") return value;
+	throw new TypeError("Expected an object.");
+}
+
+//#endregion
+//#region src/hid.ts
+/** Remote buttons as HID commands, and the experimental game controller. */
+var Hid = class {
+	#channel;
+	constructor(channel) {
+		this.#channel = channel;
+	}
+	/** Sends one button edge: down, or up when `down` is false. */
+	async command(command, down = false) {
+		await this.#channel.exchange(hidCommand(HidCommand[command], down));
+	}
+	/**
+	* A full press: down and up for a single tap, that twice without a pause for a double tap,
+	* and for a hold the release after `holdDelayMs`.
+	*/
+	async press(command, type = "SingleTap", holdDelayMs = 500) {
+		switch (type) {
+			case "DoubleTap":
+				await this.command(command, true);
+				await this.command(command, false);
+				await this.command(command, true);
+				await this.command(command, false);
+				break;
+			case "Hold":
+				await this.command(command, true);
+				await waitFor(holdDelayMs);
+				await this.command(command, false);
+				break;
+			case "SingleTap":
+				await this.command(command, true);
+				await this.command(command, false);
+				break;
+		}
+	}
+	async gameControllerStart() {
+		await this.#channel.exchange(gameControllerStart());
+	}
+	async gameControllerStop() {
+		await this.#channel.exchange(gameControllerStop());
+	}
+	/** One stick position (-1 to 1 per axis) and the button state. */
+	sendGameControllerEvent(x, y, isDown) {
+		this.#channel.send(gameControllerEvent(x, y, isDown));
+	}
+};
+
+//#endregion
+//#region src/interests.ts
+/** The events the device pushes once interest in them is registered, such as `_iMC` or `SystemStatus`. */
+var Interests = class {
+	#channel;
+	constructor(channel) {
+		this.#channel = channel;
+	}
+	/** Registers interest in the events, in one `_interest` event. */
+	register(events) {
+		this.#channel.send(registerInterests(events));
+	}
+	/** Deregisters interest in the events; nothing when the socket is gone, so a teardown cannot fail on it. */
+	deregister(events) {
+		if (!this.#channel.isConnected) return;
+		this.#channel.send(deregisterInterests(events));
+	}
+	/** Listens to an event, until the session ends, and registers interest in it. */
+	subscribe(event, listener) {
+		this.#channel.listen(event, listener);
+		this.register([event]);
+	}
+	/** Stops listening, when a listener is given, and deregisters interest in the event. */
+	unsubscribe(event, listener) {
+		if (listener) this.#channel.unlisten(event, listener);
+		this.deregister([event]);
+	}
+};
+
+//#endregion
+//#region src/media.ts
+/**
+* Media control over `_mcc`, what the device reports about playback, and playing a media item.
+* The flags follow the `_iMC` events; the state reports a change.
+*/
+var Media = class {
+	get capabilities() {
+		return this.#state.mediaCapabilities;
+	}
+	/** The raw `_iMC` bitmask, see `MediaControlFlag`. */
+	get flags() {
+		return this.#state.mediaControlFlags;
+	}
+	get nowPlayingInfo() {
+		return this.#state.nowPlayingInfo;
+	}
+	get supportedActions() {
+		return this.#state.supportedActions;
+	}
+	get volumeAvailable() {
+		return this.#state.volumeAvailable;
+	}
+	#channel;
+	#state;
+	constructor(channel, state) {
+		this.#channel = channel;
+		this.#state = state;
+	}
+	/** @param content Extra fields of the command, such as the volume for `SetVolume`. */
+	async command(command, content) {
+		return await this.#channel.exchange(mediaControlCommand(MediaControlCommand[command], content));
+	}
+	/** Skips forward, or backward for a negative number of seconds. */
+	async skipBy(seconds) {
+		return await this.#channel.exchange(mediaSkipBySeconds(seconds));
+	}
+	/** Asks for the media control status; the reply is not used. */
+	async fetchControlStatus() {
+		await this.#channel.exchange(fetchMediaControlStatus());
+	}
+	/** The now playing information, as the raw reply. */
+	async fetchNowPlayingInfo() {
+		return await this.#channel.exchange(fetchNowPlayingInfo());
+	}
+	/** Asks for the supported actions; the reply is not used. */
+	async fetchSupportedActions() {
+		await this.#channel.exchange(fetchSupportedActions());
+	}
+	/** Plays a media item, described by the OPack dictionary the device expects. */
+	async play(item) {
+		await this.#channel.exchange(playMedia(item));
+	}
+};
+
+//#endregion
+//#region src/stream.ts
+/** A 1-byte frame type and a 3-byte big-endian payload length. */
+const HEADER_SIZE = 4;
+/** A peer that sends more than this without completing a frame is broken. */
+const MAX_BUFFER_SIZE = 1024 * 1024;
+/** Pairing replies carry no `_x`, so the one pending pairing exchange waits under this key. */
+const PAIRING_QUEUE_IDENTIFIER = -1;
+const DEFAULT_EXCHANGE_TIMEOUT = 1e4;
+const MESSAGE_TYPE_NAMES = {
+	[MessageType.Event]: "event",
+	[MessageType.Request]: "request",
+	[MessageType.Response]: "response"
+};
+/**
+* The Companion Link socket: OPack frames of `[type:1][length:3][payload][tag:16?]`, the header
+* being the AAD once encryption is on. The nonce is the 64-bit little-endian message counter at
+* offset 0 of 12 bytes. {@link exchange} waits for the reply with the same `_x`; every other frame
+* with an `_i` becomes an `event`.
+*/
+var Stream = class extends EncryptionAwareConnection {
+	#pending = /* @__PURE__ */ new Map();
+	#buffer = Buffer.alloc(0);
+	#xid = randomInt(0, 2 ** 16);
+	constructor(context, address, port) {
+		super(context, address, port);
+		const connection = this;
+		connection.on("closed", () => this.#onClosed());
+		connection.on("data", (data) => this.#onData(data));
+		connection.on("error", (error) => this.#rejectAll(error));
+	}
+	/**
+	* Sends an OPack frame and resolves with the decoded reply. Pairing frames share one slot,
+	* because their replies carry no `_x`.
+	*
+	* @throws {TimeoutError} When no reply arrives in time.
+	* @throws {ConnectionClosedError} When the stream ends first.
+	*/
+	exchange(type, message, timeout = DEFAULT_EXCHANGE_TIMEOUT) {
+		if (this.signal.aborted) return Promise.reject(new ConnectionClosedError("Stream cleanup."));
+		const key = PairingFrameTypes.includes(type) ? PAIRING_QUEUE_IDENTIFIER : message._x !== void 0 && message._x !== null ? Number(message._x) : this.#xid;
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.#pending.delete(key);
+				reject(new TimeoutError(`Exchange timed out for type ${type}`));
+			}, timeout);
+			this.#pending.set(key, {
+				resolve: (frame) => {
+					clearTimeout(timer);
+					resolve(frame);
+				},
+				reject: (error) => {
+					clearTimeout(timer);
+					reject(error);
+				},
+				timer
+			});
+			try {
+				this.sendOPack(type, message);
+			} catch (err) {
+				this.#pending.delete(key);
+				clearTimeout(timer);
+				reject(err);
+			}
+		});
+	}
+	/**
+	* Encodes an object as OPack and sends it, with the next `_x` unless it carries one.
+	*
+	* @throws {ConnectionClosedError} When the stream has ended.
+	*/
+	sendOPack(type, message) {
+		if (this.signal.aborted) throw new ConnectionClosedError("Cannot write to a disconnected connection.");
+		const xid = this.#xid++;
+		message._x ??= OPack.sizedInteger(xid, 8);
+		this.context.logger.raw("[companion-link]", "Sending opack frame", type, this.isEncrypted, message);
+		if (reporter.tapsTraffic) this.context.logger.traffic("companionLink", "out", summarize(type, message), message);
+		this.send(type, Buffer.from(OPack.encode(message)));
+	}
+	/** Writes one frame; encrypted once encryption is on, except NoOp, which stays plaintext. */
+	send(type, payload) {
+		const encryption = type === FrameType.NoOp ? void 0 : this.encryption;
+		const header = Buffer.allocUnsafe(HEADER_SIZE);
+		header.writeUint8(type, 0);
+		header.writeUintBE(payload.byteLength + (encryption ? ChaCha20.CHACHA20_AUTH_TAG_LENGTH : 0), 1, 3);
+		this.context.logger.raw("[companion-link]", "Sending data frame", this.isEncrypted, type);
+		if (!encryption) {
+			this.write(Buffer.concat([header, payload]));
+			return;
+		}
+		const nonce = buildNonce(encryption.writeCount++, "counter-at-0");
+		const encrypted = ChaCha20.encrypt(encryption.writeKey, nonce, header, payload);
+		this.write(Buffer.concat([
+			header,
+			encrypted.ciphertext,
+			encrypted.authTag
+		]));
+	}
+	#decrypt(frame) {
+		const header = frame.subarray(0, HEADER_SIZE);
+		const payloadLength = header.readUintBE(1, 3);
+		if (payloadLength < ChaCha20.CHACHA20_AUTH_TAG_LENGTH) throw new Error(`Encrypted frame payload too short: ${payloadLength} bytes (minimum 16 for auth tag)`);
+		const payload = frame.subarray(HEADER_SIZE, HEADER_SIZE + payloadLength);
+		const authTag = payload.subarray(payload.byteLength - ChaCha20.CHACHA20_AUTH_TAG_LENGTH);
+		const ciphertext = payload.subarray(0, payload.byteLength - ChaCha20.CHACHA20_AUTH_TAG_LENGTH);
+		const nonce = buildNonce(this.encryption.readCount++, "counter-at-0");
+		return Buffer.concat([header, ChaCha20.decrypt(this.encryption.readKey, nonce, header, ciphertext, authTag)]);
+	}
+	/**
+	* A reply settles its exchange, a pairing frame the pairing slot, anything else with an `_i`
+	* becomes an event.
+	*/
+	#handle(header, payload) {
+		const type = header.readUint8();
+		if (!OPackFrameTypes.includes(type)) {
+			this.context.logger.warn("[companion-link]", "Packet not handled, no opack frame.");
+			return;
+		}
+		const message = OPack.decode(payload);
+		this.context.logger.raw("[companion-link]", "Decoded OPACK", {
+			header,
+			payload: message
+		});
+		if (reporter.tapsTraffic) this.context.logger.traffic("companionLink", "in", summarize(type, message), message);
+		if ("_x" in message && message._t === MessageType.Response && this.#settle(Number(message._x), header, message)) return;
+		if (PairingFrameTypes.includes(type) && this.#settle(PAIRING_QUEUE_IDENTIFIER, header, message)) return;
+		if (!("_i" in message)) {
+			this.context.logger.warn("[companion-link]", "Unhandled message", message);
+			return;
+		}
+		this.emit("event", message._i, message._c);
+	}
+	#onClosed() {
+		this.#buffer = Buffer.alloc(0);
+		this.#rejectAll(new ConnectionClosedError("Stream cleanup."));
+	}
+	#onData(data) {
+		this.#buffer = Buffer.concat([this.#buffer, data]);
+		if (this.#buffer.byteLength > MAX_BUFFER_SIZE) {
+			this.context.logger.error("[companion-link]", `Buffer exceeded max size (${this.#buffer.byteLength} bytes), closing the connection.`);
+			this.#buffer = Buffer.alloc(0);
+			this.destroy(/* @__PURE__ */ new Error("Buffer overflow: exceeded maximum buffer size"));
+			return;
+		}
+		try {
+			while (this.#buffer.byteLength >= HEADER_SIZE) {
+				const header = this.#buffer.subarray(0, HEADER_SIZE);
+				const totalLength = HEADER_SIZE + header.readUintBE(1, 3);
+				if (this.#buffer.byteLength < totalLength) {
+					this.context.logger.debug("[companion-link]", `Data packet is too short needed=${totalLength} available=${this.#buffer.byteLength} receivedLength=${data.byteLength}`);
+					return;
+				}
+				this.context.logger.raw("[companion-link]", `Received frame length=${totalLength} availableLength=${this.#buffer.byteLength} receivedLength=${data.byteLength}`);
+				let frame = Buffer.from(this.#buffer.subarray(0, totalLength));
+				this.#buffer = this.#buffer.subarray(totalLength);
+				this.context.logger.raw("[companion-link]", `Handle frame, ${this.#buffer.byteLength} bytes left...`);
+				if (this.isEncrypted) frame = this.#decrypt(frame);
+				this.#handle(header, frame.subarray(HEADER_SIZE));
+			}
+		} catch (err) {
+			this.context.logger.error("[companion-link]", "onStreamData()", err);
+			this.emit("error", err instanceof Error ? err : new Error(String(err)));
+		}
+	}
+	#rejectAll(error) {
+		for (const { reject } of this.#pending.values()) reject(error);
+		this.#pending.clear();
+	}
+	#settle(key, header, message) {
+		const pending = this.#pending.get(key);
+		if (!pending) return false;
+		this.#pending.delete(key);
+		pending.resolve([header.readUint8(), message]);
+		return true;
+	}
+};
+function summarize(frameType, message) {
+	return [
+		Object.keys(FrameType).find((name) => FrameType[name] === frameType) ?? `frame=${frameType}`,
+		MESSAGE_TYPE_NAMES[Number(message._t)],
+		message._i,
+		"_x" in message ? `x=${Number(message._x)}` : void 0
+	].filter((part) => part !== void 0).join(" ");
+}
+
+//#endregion
+//#region src/pairing.ts
+const PAIRING_TIMEOUT = 3e4;
+/**
+* Sends each pairing message as `_pd` in an OPack frame: a start frame for M1, a next frame after
+* that. `extra` carries the field that tells pair-setup and pair-verify apart.
+*/
+function frameTransport(stream, startFrame, nextFrame, extra) {
+	return async (payload, step) => {
+		const [, response] = await stream.exchange(step === "m1" ? startFrame : nextFrame, {
+			_pd: payload,
+			...extra
+		}, PAIRING_TIMEOUT);
+		if (typeof response !== "object" || response === null) throw new InvalidResponseError("Invalid response from receiver.");
+		return response["_pd"];
+	};
+}
+/**
+* Pair-verify over OPack frames, followed by the channel keys. The HKDF info strings are named
+* from the device's side: it encrypts with `ServerEncrypt-main`, our read key.
+*/
+async function verifyPairing(stream, context, credentials) {
+	const keys = await new PairVerify(context, frameTransport(stream, FrameType.PairVerifyStart, FrameType.PairVerifyNext, { _auTy: 4 })).start(credentials);
+	const { readKey: accessoryToControllerKey, writeKey: controllerToAccessoryKey } = HKDF.deriveEncryptionKeys(keys.sharedSecret, "", "ServerEncrypt-main", "ClientEncrypt-main");
+	return {
+		accessoryToControllerKey,
+		controllerToAccessoryKey,
+		pairingId: keys.pairingId,
+		sharedSecret: keys.sharedSecret
+	};
+}
+/**
+* Starts a PIN pairing: connects and sends pair-setup M1, upon which the device shows its PIN.
+* Finish with {@link PinPairing.pin}, which returns the long-term credentials.
+*
+* @throws {PairingError} When the device refuses to start pairing.
+* @throws {ConnectionClosedError} When the signal aborts first.
+*/
+async function pair(target, options = {}) {
+	const context = options.context ?? new Context(target.id ?? target.address, options.identity);
+	const stream = new Stream(context, target.address, target.port);
+	const interrupt = () => stream.destroy();
+	options.signal?.addEventListener("abort", interrupt, {
+		once: true,
+		signal: stream.signal
+	});
+	try {
+		await stream.connect();
+		const setup = new PairSetup(context, frameTransport(stream, FrameType.PairSetupStart, FrameType.PairSetupNext, { _pwTy: 1 }));
+		await setup.start();
+		return new PinPairing(stream, setup, await setup.m1());
+	} catch (err) {
+		stream.destroy();
+		throw options.signal?.aborted ? new ConnectionClosedError("Pairing was interrupted.") : err;
+	}
+}
+/** A PIN pairing whose PIN the device shows now. One connection, used once. */
+var PinPairing = class {
+	/** Aborts when the pairing connection closes. */
+	get signal() {
+		return this.#stream.signal;
+	}
+	#m1;
+	#setup;
+	#stream;
+	constructor(stream, setup, m1) {
+		this.#m1 = m1;
+		this.#setup = setup;
+		this.#stream = stream;
+	}
+	/**
+	* Runs pair-setup M2 to M6 with the PIN from the screen. The connection stays open; call
+	* {@link close} when done.
+	*
+	* @throws {PairingError} When a step fails or the PIN is wrong.
+	*/
+	async pin(code) {
+		const m2 = await this.#setup.m2(this.#m1, code);
+		const m3 = await this.#setup.m3(m2);
+		const m4 = await this.#setup.m4(m3);
+		const m5 = await this.#setup.m5(m4);
+		const credentials = await this.#setup.m6(m4, m5);
+		if (!credentials) throw new PairingError("Pairing failed, could not get accessory keys.");
+		return credentials;
+	}
+	/** Closes the pairing connection. */
+	close() {
+		this.#stream.destroy();
+	}
+};
+
+//#endregion
+//#region src/utils.ts
+/** Maps the numeric attention state of the Apple TV to its name; `unknown` for any other value. */
+function convertAttentionState(state) {
+	switch (state) {
+		case 1: return "asleep";
+		case 2: return "screensaver";
+		case 3: return "awake";
+		case 4: return "idle";
+		default: return "unknown";
+	}
+}
+
+//#endregion
+//#region src/power.ts
+/**
+* Attention state and the power buttons. The state follows the `SystemStatus` and `TVSystemStatus`
+* events; its `attentionStateChanged` event reports a change.
+*/
+var Power = class {
+	/** The attention state the device reported last. */
+	get attentionState() {
+		return this.#state.attentionState;
+	}
+	#channel;
+	#hid;
+	#state;
+	constructor(channel, hid, state) {
+		this.#channel = channel;
+		this.#hid = hid;
+		this.#state = state;
+	}
+	/** Asks the device for its attention state; the state is left as it is. */
+	async fetch() {
+		return convertAttentionState((await this.#channel.exchange(fetchAttentionState()))._c.state);
+	}
+	async isAwake() {
+		return await this.fetch() === "awake";
+	}
+	/** Presses the Wake button. */
+	async wake() {
+		await this.#hid.press("Wake", "SingleTap");
+	}
+	/** Presses the Sleep button. */
+	async sleep() {
+		await this.#hid.press("Sleep", "SingleTap");
+	}
+};
+
+//#endregion
+//#region src/state.ts
+/** The events the state derives something from; a session registers interest in the first five. */
+const STATE_EVENTS = [
+	"_iMC",
+	"SystemStatus",
+	"TVSystemStatus",
+	"NowPlayingInfo",
+	"SupportedActions",
+	"_tiStarted",
+	"_tiStopped"
+];
+const DEFAULT_TEXT_INPUT = {
+	isActive: false,
+	documentText: "",
+	isSecure: false,
+	keyboardType: 0,
+	autocorrection: false,
+	autocapitalization: false
+};
+/**
+* What a Companion Link device reports about itself: attention state, media controls, now playing,
+* supported actions and text input. A model without I/O: feed it with {@link apply}, from a session
+* or from recorded events.
+*/
+var CompanionLinkState = class extends EventEmitter {
+	get attentionState() {
+		return this.#attentionState;
+	}
+	get mediaCapabilities() {
+		return this.#mediaCapabilities;
+	}
+	/** The raw `_iMC` bitmask, see {@link MediaControlFlag}. */
+	get mediaControlFlags() {
+		return this.#mediaControlFlags;
+	}
+	get nowPlayingInfo() {
+		return this.#nowPlayingInfo;
+	}
+	get supportedActions() {
+		return this.#supportedActions;
+	}
+	get textInputState() {
+		return this.#textInputState;
+	}
+	get volumeAvailable() {
+		return this.#volumeAvailable;
+	}
+	#attentionState;
+	#mediaCapabilities;
+	#mediaControlFlags;
+	#nowPlayingInfo;
+	#supportedActions;
+	#textInputState;
+	#volumeAvailable;
+	constructor() {
+		super();
+		this.clear();
+	}
+	/**
+	* Applies the `_c` of one event. Events the state does not track are ignored.
+	* `FetchAttentionState` takes the content of that reply and always emits, also when the state
+	* did not change, so a fresh session reports its attention state once.
+	*
+	* @throws When the content is malformed; text input falls back to its default state first.
+	*/
+	apply(name, content) {
+		switch (name) {
+			case "_iMC": return this.#onMediaControl(content);
+			case "SystemStatus":
+			case "TVSystemStatus": return this.#onSystemStatus(content);
+			case "NowPlayingInfo": return this.#onNowPlayingInfo(content);
+			case "SupportedActions": return this.#onSupportedActions(content);
+			case "_tiStarted": return this.#onTextInputStarted(content);
+			case "_tiStopped": return this.#onTextInputStopped();
+			case "FetchAttentionState": return this.#onAttentionStateFetched(content);
+		}
+	}
+	/** Resets every value to its initial one, without events. */
+	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;
+	}
+	#onAttentionStateFetched(content) {
+		const state = convertAttentionState(content.state);
+		this.#attentionState = state;
+		this.emit("attentionStateChanged", state);
+	}
+	/** Emits only when the flags change, and the volume event only when the volume bit flips. */
+	#onMediaControl(content) {
+		const flags = Number(content?._mcF ?? 0);
+		if (flags === this.#mediaControlFlags) return;
+		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);
+	}
+	/** The NSKeyedArchiver plist in `NowPlayingInfoKey` when present, otherwise the dictionary itself. */
+	#onNowPlayingInfo(content) {
+		if (content?.NowPlayingInfoKey) {
+			const bytes = Buffer.from(content.NowPlayingInfoKey);
+			const plist = Plist.parse(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
+			const decoded = NSKeyedArchiver.decode(plist);
+			this.#nowPlayingInfo = decoded && typeof decoded === "object" && !Array.isArray(decoded) ? decoded : null;
+		} else this.#nowPlayingInfo = content ?? null;
+		this.emit("nowPlayingInfoChanged", this.#nowPlayingInfo);
+	}
+	#onSupportedActions(content) {
+		this.#supportedActions = content ?? null;
+		this.emit("supportedActionsChanged", content ?? {});
+	}
+	/** Only the states 1 to 4 count, as a number or a numeric string; a repeat emits nothing. */
+	#onSystemStatus(content) {
+		const value = content?.state;
+		if (typeof value !== "number" && !(typeof value === "string" && /^[1-4]$/.test(value))) return;
+		const state = convertAttentionState(Number(value));
+		if (state === "unknown" || state === this.#attentionState) return;
+		this.#attentionState = state;
+		this.emit("attentionStateChanged", state);
+	}
+	#onTextInputStarted(content) {
+		try {
+			if (!content?._tiD) this.#textInputState = { ...DEFAULT_TEXT_INPUT };
+			else {
+				const { uuid, ...state } = RTI.decodeSession(content._tiD);
+				this.#textInputState = {
+					isActive: true,
+					...state
+				};
+			}
+			this.emit("textInputChanged", this.#textInputState);
+		} catch (err) {
+			this.#textInputState = { ...DEFAULT_TEXT_INPUT };
+			this.emit("textInputChanged", this.#textInputState);
+			throw err;
+		}
+	}
+	#onTextInputStopped() {
+		this.#textInputState = { ...DEFAULT_TEXT_INPUT };
+		this.emit("textInputChanged", this.#textInputState);
+	}
+};
+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/system.ts
+/** System settings, Siri and the Up Next queue. */
+var System = class {
+	#channel;
+	constructor(channel) {
+		this.#channel = channel;
+	}
+	async toggleCaptions() {
+		await this.#channel.exchange(toggleCaptions());
+	}
+	/** The caption settings, over `_mcc`. */
+	async getCaptionSetting() {
+		return await this.#channel.exchange(mediaCaptionSettingGet());
+	}
+	async setCaptionSetting(enabled) {
+		return await this.#channel.exchange(mediaCaptionSettingSet(enabled));
+	}
+	/** Light appearance when true, dark when false. */
+	async setAppearance(light) {
+		await this.#channel.exchange(toggleSystemAppearance(light));
+	}
+	async setReduceLoudSounds(enabled) {
+		await this.#channel.exchange(toggleReduceLoudSounds(enabled));
+	}
+	async setFindingMode(enabled) {
+		await this.#channel.exchange(toggleFindingMode(enabled));
+	}
+	/** Push-to-talk begin; see `supportsSiriPTT` on the session. */
+	async siriStart() {
+		await this.#channel.exchange(siriStart());
+	}
+	async siriStop() {
+		await this.#channel.exchange(siriStop());
+	}
+	/** What the device knows about the paired Siri Remote, from the plist in the reply. */
+	async siriRemoteInfo() {
+		const reply = await this.#channel.exchange(fetchSiriRemoteInfo());
+		return Plist.parse(Uint8Array.from(reply._c.SiriRemoteInfoKey).buffer);
+	}
+	/** The Up Next queue, as the raw reply. */
+	async fetchUpNext(paginationToken) {
+		return await this.#channel.exchange(fetchUpNext(paginationToken));
+	}
+	async addToUpNext(identifier, kind) {
+		await this.#channel.exchange(addToUpNext(identifier, kind));
+	}
+	async removeFromUpNext(identifier, kind) {
+		await this.#channel.exchange(removeFromUpNext(identifier, kind));
+	}
+	async markAsWatched(identifier, kind) {
+		await this.#channel.exchange(markAsWatched(identifier, kind));
+	}
+};
+
+//#endregion
+//#region src/text.ts
+/**
+* Remote text input into the focused field. Operations run one at a time; each one starts the
+* text input session anew for the keyboard session UUID. An operation queued before the field
+* changed, stopped or the session ended fails instead of typing into the wrong field.
+*/
+var Text = class {
+	/** The text input session the device reported last. */
+	get state() {
+		return this.#state.textInputState;
+	}
+	#channel;
+	#state;
+	#generation = 0;
+	#queue = Promise.resolve();
+	#session;
+	constructor(channel, state) {
+		this.#channel = channel;
+		this.#state = state;
+		channel.listen("_tiStarted", (content) => this.#onStarted(content));
+		channel.listen("_tiStopped", () => this.#onStopped());
+		channel.signal.addEventListener("abort", () => this.#generation++, { once: true });
+	}
+	/** Replaces the text of the field. */
+	async set(text) {
+		await this.command(text, true);
+	}
+	async append(text) {
+		await this.command(text, false);
+	}
+	async clear() {
+		await this.command("", true);
+	}
+	/**
+	* Clears the field when asked, then inserts the text when there is any.
+	*
+	* @throws {Error} When no field has focus, or the field changed before the operation ran.
+	*/
+	command(text, clearPreviousInput) {
+		const generation = this.#generation;
+		const operation = this.#queue.then(async () => {
+			if (generation !== this.#generation) throw new Error("Text input session changed.");
+			const reply = await this.start();
+			if (generation !== this.#generation) throw new Error("Text input session changed; retry with the active field.");
+			const data = reply?._c?._tiD;
+			if (!data) throw new Error("No active text input session.");
+			const session = RTI.decodeSession(data);
+			if (clearPreviousInput) this.#channel.send(tiChange(Buffer.from(RTI.encodeOperation(session.uuid, "", true))));
+			if (text) this.#channel.send(tiChange(Buffer.from(RTI.encodeOperation(session.uuid, text, false))));
+			return text;
+		});
+		this.#queue = operation.catch(() => {});
+		return operation;
+	}
+	/** Starts the text input session; the reply carries the keyboard session in `_c._tiD`. */
+	async start() {
+		return await this.#channel.exchange(tiStart());
+	}
+	async stop() {
+		await this.#channel.exchange(tiStop());
+	}
+	/** A field with another keyboard session UUID is another field. */
+	#onStarted(content) {
+		try {
+			const uuid = Buffer.from(RTI.decodeSession(content?._tiD).uuid).toString("hex");
+			if (this.#session && this.#session !== uuid) this.#generation++;
+			this.#session = uuid;
+		} catch {
+			this.#generation++;
+			this.#session = void 0;
+		}
+	}
+	#onStopped() {
+		this.#generation++;
+		this.#session = void 0;
+	}
+};
+
+//#endregion
+//#region src/types.ts
+/** The phases of the `_touchC` event, the 0-based `UITouchPhase` values. */
+const TouchPhase = {
+	Began: 0,
+	Moved: 1,
+	Ended: 2,
+	Cancelled: 3,
+	Stationary: 4
+};
+/** The phases of the `_hidT` event. Unlike {@link TouchPhase}, the HID touch stream on the wire is 1-based. */
+const HidTouchPhase = {
+	Began: 1,
+	Moved: 2,
+	Stationary: 3,
+	Ended: 4,
+	Cancelled: 5
+};
+
+//#endregion
+//#region src/touch.ts
+/** The finger a gesture reports itself as; the HID touch stream is 1-based. */
+const TOUCH_FINGER = 1;
+/** Start and end point of a swipe in the 0 to 1000 touchpad space. */
+const SWIPES = {
+	up: [
+		500,
+		700,
+		500,
+		300
+	],
+	down: [
+		500,
+		300,
+		500,
+		700
+	],
+	left: [
+		700,
+		500,
+		300,
+		500
+	],
+	right: [
+		300,
+		500,
+		700,
+		500
+	]
+};
+/** The virtual touchpad. Coordinates run from 0 to 1000 on both axes. */
+var Touch = class {
+	#channel;
+	#hid;
+	constructor(channel, hid) {
+		this.#channel = channel;
+		this.#hid = hid;
+	}
+	/**
+	* Sends a `_touchC` event. Kept for protocol work: tvOS registers no handler for it, so
+	* {@link sendHid} is what reaches the device.
+	*
+	* @param finger The finger index, 0-based.
+	* @param phase A `TouchPhase` value.
+	*/
+	send(finger, phase, x, y) {
+		this.#channel.send(touchEvent(finger, phase, x, y));
+	}
+	/**
+	* Sends a `_hidT` event, the form the HID daemon of the Apple TV listens for.
+	*
+	* @param finger The finger index, 1-based.
+	* @param phase A {@link HidTouchPhase} value.
+	*/
+	sendHid(finger, phase, x, y) {
+		this.#channel.send(hidTouchEvent(finger, phase, x, y));
+	}
+	/**
+	* Taps the touch surface, which selects whatever has focus. The HID touch device reports
+	* contact and position only, so a touch that lands and lifts moves no focus and clicks
+	* nothing; a real remote sends the Select button for a tap.
+	*
+	* @param holdMs How long to hold, in milliseconds. Omit for a plain tap.
+	*/
+	async tap(holdMs) {
+		if (holdMs === void 0) {
+			await this.#hid.press("Select", "SingleTap");
+			return;
+		}
+		await this.#hid.press("Select", "Hold", holdMs);
+	}
+	/** Began, at least four Moved samples spread over `duration` milliseconds, then Ended at the end point. */
+	async swipe(direction, duration = 200) {
+		const [startX, startY, endX, endY] = SWIPES[direction];
+		const steps = Math.max(4, Math.floor(duration / 50));
+		const deltaX = (endX - startX) / steps;
+		const deltaY = (endY - startY) / steps;
+		const stepDuration = duration / steps;
+		this.sendHid(TOUCH_FINGER, HidTouchPhase.Began, startX, startY);
+		for (let i = 1; i <= steps; i++) {
+			await waitFor(stepDuration);
+			this.sendHid(TOUCH_FINGER, HidTouchPhase.Moved, Math.round(startX + deltaX * i), Math.round(startY + deltaY * i));
+		}
+		this.sendHid(TOUCH_FINGER, HidTouchPhase.Ended, endX, endY);
+	}
+};
+
+//#endregion
+//#region src/session.ts
+/** NoOp frames keep the connection alive; the device answers none of them. */
+const HEARTBEAT_INTERVAL = 15e3;
+/**
+* The graceful stop and the socket close together. A slow but alive Apple TV can take up to 10 s to
+* answer `_sessionStop`; a half-open peer would otherwise hold the close for minutes.
+*/
+const CLOSE_TIMEOUT = 1e4;
+/** The state events the device only pushes after an `_interest` registration. */
+const INTEREST_EVENTS = [
+	"_iMC",
+	"SystemStatus",
+	"TVSystemStatus",
+	"NowPlayingInfo",
+	"SupportedActions"
+];
+/** The interests a graceful stop deregisters in one event, after each one on its own. */
+const STOP_INTERESTS = [
+	"_iMC",
+	"SystemStatus",
+	"TVSystemStatus"
+];
+/**
+* The device or the socket ended the connection after it opened and before the session was
+* ready, which a caller may want to treat like a session that dropped.
+*/
+var SetupClosedError = class extends ConnectionClosedError {
+	reason;
+	constructor(reason) {
+		super(`The Companion Link connection closed during setup (${reason}).`);
+		this.name = "SetupClosedError";
+		this.reason = reason;
+	}
+};
+/** Package-internal: lets {@link connect} run the startup, which no caller of a session may repeat. */
+let startup;
+/**
+* Connects to a Companion Link device and returns a ready session. It runs TCP, pair-verify and
+* encryption, then the startup: `_systemInfo`, `_sessionStart`, `TVRCSessionStart`, optionally
+* `SwitchActiveUserAccountEvent`, `_touchStart` and `_tiStart` as requests, the heartbeat, one
+* `_interest` event per state event, and the attention state and media control status.
+*
+* @throws {CredentialsError} Without credentials.
+* @throws {PairingError} When pair-verify fails.
+* @throws {ConnectionClosedError} When the signal aborts or the device closes during the handshake.
+*/
+async function connect(target, options) {
+	if (!options?.credentials) throw new CredentialsError("Credentials are required to connect to a Companion Link device.");
+	const signal = options.signal;
+	if (signal?.aborted) throw new ConnectionClosedError("Companion Link setup was interrupted.");
+	const context = options.context ?? new Context(target.id ?? target.address, options.identity);
+	const stream = new Stream(context, target.address, target.port);
+	const interrupt = () => stream.destroy();
+	stream.on("error", (error) => context.logger.error("Companion Link error", error));
+	signal?.addEventListener("abort", interrupt, { once: true });
+	let closedBy;
+	try {
+		await stream.connect();
+		stream.on("closed", (reason) => {
+			closedBy = reason;
+		});
+		const keys = await verifyPairing(stream, context, options.credentials);
+		if (signal?.aborted || !stream.isConnected) throw new ConnectionClosedError("Companion Link setup was interrupted.");
+		stream.enableEncryption(keys.accessoryToControllerKey, keys.controllerToAccessoryKey);
+		const session = new CompanionLinkSession({
+			target,
+			context,
+			stream,
+			state: options.state ?? new CompanionLinkState(),
+			signal
+		});
+		await startup(session, options.credentials, options.activeUserAccount);
+		return session;
+	} catch (err) {
+		stream.destroy();
+		if (signal?.aborted) throw new ConnectionClosedError("Companion Link setup was interrupted.");
+		throw closedBy && closedBy !== "local" ? new SetupClosedError(closedBy) : err;
+	} finally {
+		signal?.removeEventListener("abort", interrupt);
+	}
+}
+/**
+* One authenticated Companion Link connection, with its methods in groups. It lives once: it ends
+* exactly once, with a reason, and then its {@link signal} aborts and the heartbeat, listeners and
+* pending requests go with it. Requests on an ended session fail with {@link ConnectionClosedError}.
+*/
+var CompanionLinkSession = class extends EventEmitter {
+	static {
+		startup = (session, credentials, activeUserAccount) => session.#start(credentials, activeUserAccount);
+	}
+	/** Why the session ended, or undefined while it is open. */
+	get closeReason() {
+		return this.#closeReason;
+	}
+	get context() {
+		return this.#context;
+	}
+	get isOpen() {
+		return !this.signal.aborted;
+	}
+	/** Aborts with a {@link ConnectionClosedError} when the session ends. */
+	get signal() {
+		return this.#controller.signal;
+	}
+	/** The source version the device reported in `_systemInfo`, such as `715.2`; `0` when it sent none. */
+	get sourceVersion() {
+		return this.#sourceVersion;
+	}
+	/** The encrypted OPack stream, for raw frames. */
+	get stream() {
+		return this.#stream;
+	}
+	/** Media control needs source version 250.3 or later. */
+	get supportsMediaControl() {
+		return compareVersions(this.#sourceVersion, "250.3") >= 0;
+	}
+	/** Siri push-to-talk needs source version 600.20 or later. */
+	get supportsSiriPTT() {
+		return compareVersions(this.#sourceVersion, "600.20") >= 0;
+	}
+	/** Remote text input needs source version 340.15 or later. */
+	get supportsTextInput() {
+		return compareVersions(this.#sourceVersion, "340.15") >= 0;
+	}
+	get target() {
+		return this.#target;
+	}
+	accounts;
+	apps;
+	hid;
+	interests;
+	media;
+	power;
+	state;
+	system;
+	text;
+	touch;
+	#channel;
+	#context;
+	#controller = new AbortController();
+	#stateListeners = [];
+	#stream;
+	#target;
+	#closeReason;
+	#closing;
+	#heartbeat;
+	#sessionId = 0n;
+	#sessionIdLocal = 0;
+	#sourceVersion = "0";
+	/** Use {@link connect}; a session starts from a verified, encrypted stream. */
+	constructor(parts) {
+		super();
+		this.#context = parts.context;
+		this.#stream = parts.stream;
+		this.#target = parts.target;
+		this.state = parts.state;
+		this.#channel = new Channel(this.#stream, this.signal);
+		this.hid = new Hid(this.#channel);
+		this.touch = new Touch(this.#channel, this.hid);
+		this.text = new Text(this.#channel, this.state);
+		this.power = new Power(this.#channel, this.hid, this.state);
+		this.apps = new Apps(this.#channel);
+		this.accounts = new Accounts(this.#channel);
+		this.media = new Media(this.#channel, this.state);
+		this.system = new System(this.#channel);
+		this.interests = new Interests(this.#channel);
+		this.#stream.on("closed", (reason, error) => this.#end(reason, error));
+		if (!this.#stream.isConnected) this.#end("remote");
+		parts.signal?.addEventListener("abort", () => this.#end("local"), {
+			once: true,
+			signal: this.signal
+		});
+	}
+	/**
+	* Ends the session gracefully: stops the heartbeat, deregisters the interests, stops text
+	* input, touch, the remote control session and the service session (each failure ignored),
+	* then closes the socket. Resolves once it is closed; a peer that does not finish within
+	* {@link CLOSE_TIMEOUT} gets its socket destroyed.
+	*/
+	close() {
+		this.#closing ??= this.#close();
+		return this.#closing;
+	}
+	/** Sends a NoOp frame, which stays plaintext. */
+	noOp() {
+		this.#context.logger.debug("Sending no-op operation.");
+		this.#stream.send(FrameType.NoOp, Buffer.allocUnsafe(0));
+	}
+	/** Throws when the session ended while a startup step was waiting. */
+	#checkpoint() {
+		if (this.signal.aborted) throw new ConnectionClosedError("Companion Link setup was interrupted.");
+	}
+	async #close() {
+		if (this.signal.aborted) return;
+		this.#stopHeartbeat();
+		this.#stopStateFeed();
+		const deadline = setTimeout(() => {
+			this.#context.logger.warn("[companion-link]", `Graceful stop did not finish within ${CLOSE_TIMEOUT} ms, destroying the socket.`);
+			this.#end("local");
+		}, CLOSE_TIMEOUT);
+		try {
+			await this.#gracefulStop();
+		} catch (err) {
+			this.#context.logger.warn("[companion-link]", "Graceful stop failed during disconnect", err);
+		}
+		try {
+			await this.#stream.disconnect();
+		} catch (err) {
+			this.#context.logger.warn("[companion-link]", "Closing the socket failed during disconnect", err);
+		} finally {
+			clearTimeout(deadline);
+			this.#end("local");
+		}
+	}
+	/** The single exit: stops the heartbeat, aborts the signal (listeners clean up there), destroys the stream and emits `closed`. */
+	#end(reason, error) {
+		if (this.#closeReason) return;
+		this.#closeReason = reason;
+		this.#context.logger.net("[session]", `Companion Link session closed (${reason}${error ? `: ${error.message}` : ""}).`);
+		this.#stopHeartbeat();
+		this.#controller.abort(new ConnectionClosedError(`Companion Link session closed (${reason}).`));
+		this.#stream.destroy();
+		this.emit("closed", reason, error);
+	}
+	/** Feeds the state from here on and registers interest in its events, one `_interest` event each. */
+	#feedState() {
+		for (const name of STATE_EVENTS) {
+			const listener = (content) => {
+				try {
+					this.state.apply(name, content);
+				} catch (err) {
+					this.#context.logger.error("[cl-state]", `${name} parse error`, err);
+				}
+			};
+			this.#channel.listen(name, listener);
+			this.#stateListeners.push([name, listener]);
+		}
+		for (const event of INTEREST_EVENTS) try {
+			this.interests.register([event]);
+		} catch (err) {
+			this.#context.logger.warn("[cl-state]", `Failed to register interest for ${event}`, err);
+		}
+	}
+	/** Each step stops early once the socket is gone. */
+	async #gracefulStop() {
+		if (!this.#stream.isConnected) return;
+		this.interests.deregister(STOP_INTERESTS);
+		try {
+			await this.text.stop();
+		} catch {}
+		if (!this.#stream.isConnected) return;
+		try {
+			await this.#channel.exchange(touchStop());
+		} catch {}
+		if (!this.#stream.isConnected) return;
+		try {
+			await this.#channel.exchange(tvrcSessionStop());
+		} catch {}
+		if (!this.#stream.isConnected) return;
+		try {
+			await this.#sessionStop();
+		} catch {}
+	}
+	async #sessionStop() {
+		if (this.#sessionId === 0n) return;
+		await this.#channel.exchange(sessionStop(this.#sessionIdLocal));
+		this.#sessionId = 0n;
+		this.#sessionIdLocal = 0;
+	}
+	async #start(credentials, activeUserAccount) {
+		const channel = this.#channel;
+		const systemInfo$1 = await channel.exchange(systemInfo(credentials.pairingId, this.#context.identity.name ?? DEFAULT_CLIENT_NAME));
+		this.#checkpoint();
+		const sourceVersion = systemInfo$1?._c?._sv;
+		if (sourceVersion) {
+			this.#sourceVersion = String(sourceVersion);
+			this.#context.logger.info("[companion-link]", `Receiver sourceVersion: ${sourceVersion} (mediaControl=${this.supportsMediaControl}, textInput=${this.supportsTextInput}, siriPTT=${this.supportsSiriPTT})`);
+		}
+		const localSid = randomInt(0, 2 ** 32 - 1);
+		const sessionStart$1 = await channel.exchange(sessionStart(localSid));
+		this.#checkpoint();
+		this.#sessionIdLocal = localSid;
+		this.#sessionId = BigInt(Number(sessionStart$1?._c?._sid ?? 0)) << 32n | BigInt(localSid);
+		await channel.exchange(tvrcSessionStart());
+		this.#checkpoint();
+		if (activeUserAccount) {
+			await this.accounts.switchActive(activeUserAccount);
+			this.#checkpoint();
+		}
+		await channel.exchange(touchStart());
+		this.#checkpoint();
+		await this.text.start();
+		this.#checkpoint();
+		this.#startHeartbeat();
+		this.#feedState();
+		try {
+			const attention = await channel.exchange(fetchAttentionState());
+			this.state.apply("FetchAttentionState", attention._c);
+		} catch (err) {
+			this.#context.logger.warn("[cl-state]", "Failed to fetch initial attention state", err);
+		}
+		try {
+			await this.media.fetchControlStatus();
+		} catch (err) {
+			this.#context.logger.warn("[cl-state]", "Failed to fetch media control status", err);
+		}
+		this.#checkpoint();
+	}
+	#startHeartbeat() {
+		this.#heartbeat = setInterval(() => {
+			try {
+				this.noOp();
+			} catch (err) {
+				this.#context.logger.error("Heartbeat failed", err);
+			}
+		}, HEARTBEAT_INTERVAL);
+	}
+	#stopHeartbeat() {
+		clearInterval(this.#heartbeat);
+		this.#heartbeat = void 0;
+	}
+	/** Stops feeding the state and deregisters each of its interests on its own. */
+	#stopStateFeed() {
+		if (this.#stateListeners.length === 0) return;
+		for (const [name, listener] of this.#stateListeners.splice(0)) this.#channel.unlisten(name, listener);
+		try {
+			for (const event of INTEREST_EVENTS) this.interests.deregister([event]);
+		} catch {}
+	}
+};
+/** Compares dot-separated versions segment by segment; negative when `a` is lower. */
+function compareVersions(a, b) {
+	const partsA = a.split(".").map(Number);
+	const partsB = b.split(".").map(Number);
+	const length = Math.max(partsA.length, partsB.length);
+	for (let i = 0; i < length; i++) {
+		const segmentA = partsA[i] ?? 0;
+		const segmentB = partsB[i] ?? 0;
+		if (segmentA !== segmentB) return segmentA - segmentB;
+	}
+	return 0;
+}
+
+//#endregion
+//#region src/discovery.ts
+const COMPANION_LINK_SERVICE = "_companion-link._tcp.local";
+/** Finds the devices on the local network that accept Companion Link connections. */
+async function discover(options = {}) {
+	return await new Discovery(COMPANION_LINK_SERVICE).find(options.useCache ?? true);
+}
+/** The target of a discovery result. Reads the address, the port, the id and the TXT record only. */
+function toTarget(result) {
+	return {
+		address: result.address,
+		port: result.service.port,
+		id: result.id,
+		txt: result.txt
+	};
+}
+
+//#endregion
+export { Accounts, Apps, COMPANION_LINK_SERVICE, Channel, CompanionLinkSession, CompanionLinkState, FrameType, Hid, HidCommand, HidTouchPhase, Interests, Media, MediaControlCommand, MediaControlFlag, MessageType, messages_exports as Messages, OPackFrameTypes, PairingFrameTypes, PinPairing, Power, SetupClosedError, Stream, System, Text, Touch, TouchPhase, connect, convertAttentionState, discover, pair, toTarget };