@basmilius/apple-common 0.9.18 → 0.9.19

package/dist/index.d.mts

@@ -437,6 +437,30 @@ declare const RAOP_SERVICE = "_raop._tcp.local";
 //#region src/symbols.d.ts
 declare const ENCRYPTION: unique symbol;
 //#endregion
+//#region src/recovery.d.ts
+type EventMap$1 = {
+  recovering: [attempt: number];
+  recovered: [];
+  failed: [errors: Error[]];
+};
+type ConnectionRecoveryOptions = {
+  maxAttempts?: number;
+  baseDelay?: number;
+  maxDelay?: number;
+  useExponentialBackoff?: boolean;
+  reconnectInterval?: number;
+  onReconnect: () => Promise<void>;
+};
+declare class ConnectionRecovery extends EventEmitter<EventMap$1> {
+  #private;
+  constructor(options: ConnectionRecoveryOptions);
+  get isRecovering(): boolean;
+  get attempt(): number;
+  handleDisconnect(unexpected: boolean): void;
+  reset(): void;
+  dispose(): void;
+}
+//#endregion
 //#region src/timing.d.ts
 declare class TimingServer {
   #private;
@@ -457,6 +481,78 @@ declare function randomInt64(): bigint;
 declare function uint16ToBE(value: number): Buffer;
 declare function uint53ToLE(value: number): Buffer;
 //#endregion
+//#region src/deviceModel.d.ts
+declare enum DeviceModel {
+  Unknown = 0,
+  AppleTVGen2 = 1,
+  AppleTVGen3 = 2,
+  AppleTVHD = 3,
+  AppleTV4K = 4,
+  AppleTV4KGen2 = 5,
+  AppleTV4KGen3 = 6,
+  HomePod = 10,
+  HomePodMini = 11,
+  HomePodGen2 = 12,
+  AirPortExpress = 20,
+  AirPortExpressGen2 = 21
+}
+declare enum DeviceType {
+  Unknown = 0,
+  AppleTV = 1,
+  HomePod = 2,
+  AirPort = 3
+}
+declare const lookupDeviceModel: (identifier: string) => DeviceModel;
+declare const getDeviceModelName: (model: DeviceModel) => string;
+declare const getDeviceType: (model: DeviceModel) => DeviceType;
+declare const isAppleTV: (model: DeviceModel) => boolean;
+declare const isHomePod: (model: DeviceModel) => boolean;
+declare const isAirPort: (model: DeviceModel) => boolean;
+//#endregion
+//#region src/errors.d.ts
+declare class AppleProtocolError extends Error {
+  constructor(message: string);
+}
+declare class ConnectionError extends AppleProtocolError {
+  constructor(message: string);
+}
+declare class ConnectionTimeoutError extends ConnectionError {
+  constructor(message?: string);
+}
+declare class ConnectionClosedError extends ConnectionError {
+  constructor(message?: string);
+}
+declare class PairingError extends AppleProtocolError {
+  constructor(message: string);
+}
+declare class AuthenticationError extends PairingError {
+  constructor(message: string);
+}
+declare class CredentialsError extends PairingError {
+  constructor(message: string);
+}
+declare class CommandError extends AppleProtocolError {
+  constructor(message: string);
+}
+declare class SetupError extends AppleProtocolError {
+  constructor(message: string);
+}
+declare class DiscoveryError extends AppleProtocolError {
+  constructor(message: string);
+}
+declare class EncryptionError extends AppleProtocolError {
+  constructor(message: string);
+}
+declare class InvalidResponseError extends AppleProtocolError {
+  constructor(message: string);
+}
+declare class TimeoutError extends AppleProtocolError {
+  constructor(message: string);
+}
+declare class PlaybackError extends AppleProtocolError {
+  constructor(message: string);
+}
+//#endregion
 //#region src/audioSource.d.ts
 interface AudioSource {
   get duration(): number;
@@ -466,4 +562,4 @@ interface AudioSource {
   stop(): Promise<void>;
 }
 //#endregion
-export { AIRPLAY_SERVICE, AIRPLAY_TRANSIENT_PIN, type AccessoryCredentials, type AccessoryKeys, AccessoryPair, AccessoryVerify, type AirPlayFeatureFlagName, AirPlayFeatureFlags, type AudioSource, COMPANION_LINK_SERVICE, type CombinedDiscoveryResult, Connection, type ConnectionState, Context, Discovery, type DiscoveryResult, ENCRYPTION, EncryptionAwareConnection, EncryptionState, type EventMap, HTTP_TIMEOUT, JsonStorage, type Logger, type MdnsService, MemoryStorage, type PairingRequirement, type ProtocolType, RAOP_SERVICE, type Reporter, Storage, type StorageData, type StoredDevice, TimingServer, describeFlags, generateActiveRemoteId, generateDacpId, generateSessionId, getLocalIP, getMacAddress, getPairingRequirement, getProtocolVersion, hasFeatureFlag, isPasswordRequired, isRemoteControlSupported, multicast as mdnsMulticast, unicast as mdnsUnicast, parseFeatures, prompt, randomInt32, randomInt64, reporter, uint16ToBE, uint53ToLE, v4 as uuid, waitFor };
+export { AIRPLAY_SERVICE, AIRPLAY_TRANSIENT_PIN, type AccessoryCredentials, type AccessoryKeys, AccessoryPair, AccessoryVerify, type AirPlayFeatureFlagName, AirPlayFeatureFlags, AppleProtocolError, type AudioSource, AuthenticationError, COMPANION_LINK_SERVICE, type CombinedDiscoveryResult, CommandError, Connection, ConnectionClosedError, ConnectionError, ConnectionRecovery, type ConnectionRecoveryOptions, type ConnectionState, ConnectionTimeoutError, Context, CredentialsError, DeviceModel, DeviceType, Discovery, DiscoveryError, type DiscoveryResult, ENCRYPTION, EncryptionAwareConnection, EncryptionError, EncryptionState, type EventMap, HTTP_TIMEOUT, InvalidResponseError, JsonStorage, type Logger, type MdnsService, MemoryStorage, PairingError, type PairingRequirement, PlaybackError, type ProtocolType, RAOP_SERVICE, type Reporter, SetupError, Storage, type StorageData, type StoredDevice, TimeoutError, TimingServer, describeFlags, generateActiveRemoteId, generateDacpId, generateSessionId, getDeviceModelName, getDeviceType, getLocalIP, getMacAddress, getPairingRequirement, getProtocolVersion, hasFeatureFlag, isAirPort, isAppleTV, isHomePod, isPasswordRequired, isRemoteControlSupported, lookupDeviceModel, multicast as mdnsMulticast, unicast as mdnsUnicast, parseFeatures, prompt, randomInt32, randomInt64, reporter, uint16ToBE, uint53ToLE, v4 as uuid, waitFor };

package/dist/index.mjs

@@ -257,6 +257,93 @@ const AIRPLAY_SERVICE = "_airplay._tcp.local";
 const COMPANION_LINK_SERVICE = "_companion-link._tcp.local";
 const RAOP_SERVICE = "_raop._tcp.local";
 
+//#endregion
+//#region src/errors.ts
+var AppleProtocolError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AppleProtocolError";
+	}
+};
+var ConnectionError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "ConnectionError";
+	}
+};
+var ConnectionTimeoutError = class extends ConnectionError {
+	constructor(message = "Connection timed out.") {
+		super(message);
+		this.name = "ConnectionTimeoutError";
+	}
+};
+var ConnectionClosedError = class extends ConnectionError {
+	constructor(message = "Connection closed unexpectedly.") {
+		super(message);
+		this.name = "ConnectionClosedError";
+	}
+};
+var PairingError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "PairingError";
+	}
+};
+var AuthenticationError = class extends PairingError {
+	constructor(message) {
+		super(message);
+		this.name = "AuthenticationError";
+	}
+};
+var CredentialsError = class extends PairingError {
+	constructor(message) {
+		super(message);
+		this.name = "CredentialsError";
+	}
+};
+var CommandError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "CommandError";
+	}
+};
+var SetupError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "SetupError";
+	}
+};
+var DiscoveryError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "DiscoveryError";
+	}
+};
+var EncryptionError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "EncryptionError";
+	}
+};
+var InvalidResponseError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "InvalidResponseError";
+	}
+};
+var TimeoutError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "TimeoutError";
+	}
+};
+var PlaybackError = class extends AppleProtocolError {
+	constructor(message) {
+		super(message);
+		this.name = "PlaybackError";
+	}
+};
+
 //#endregion
 //#region src/mdns.ts
 const MDNS_ADDRESS = "224.0.0.251";
@@ -321,10 +408,12 @@ function createQueryPackets(services, qtype = QueryType.PTR, unicastResponse = f
 	}
 	return packets;
 }
+const MAX_POINTER_JUMPS = 128;
 const decodeQName = (buf, offset) => {
 	const labels = [];
 	let currentOffset = offset;
 	let jumped = false;
+	let jumps = 0;
 	let returnOffset = offset;
 	while (currentOffset < buf.byteLength) {
 		const length = buf[currentOffset];
@@ -333,6 +422,7 @@ const decodeQName = (buf, offset) => {
 			break;
 		}
 		if ((length & 192) === 192) {
+			if (++jumps > MAX_POINTER_JUMPS) break;
 			const pointer = (length & 63) << 8 | buf[currentOffset + 1];
 			if (!jumped) returnOffset = currentOffset + 2;
 			currentOffset = pointer;
@@ -713,7 +803,7 @@ var Discovery = class Discovery {
 			tries--;
 			await waitFor(timeout);
 		}
-		throw new Error("Device not found after several tries, aborting.");
+		throw new DiscoveryError(`Device '${id}' not found after several tries, aborting.`);
 	}
 	static clearCache() {
 		Discovery.#cache.clear();
@@ -826,7 +916,7 @@ var Connection = class extends EventEmitter {
 	}
 	async connect() {
 		if (this.#state === "connected") return;
-		if (this.#state === "connecting") throw new Error("A connection is already being established.");
+		if (this.#state === "connecting") throw new ConnectionError("A connection is already being established.");
 		this.#retryEnabled = true;
 		this.#retryAttempt = 0;
 		return this.#attemptConnect();
@@ -861,7 +951,7 @@ var Connection = class extends EventEmitter {
 	}
 	write(data) {
 		if (!this.#socket || this.state !== "connected" || !this.#socket.writable) {
-			this.#emitInternal("error", /* @__PURE__ */ new Error("Cannot write to a disconnected connection."));
+			this.#emitInternal("error", new ConnectionClosedError("Cannot write to a disconnected connection."));
 			return;
 		}
 		this.#socket.write(data, (err) => {
@@ -942,7 +1032,7 @@ var Connection = class extends EventEmitter {
 			this.#context.logger.net(`Connection closed (${hadError ? "with error" : "normally"}).`);
 		}
 		this.#emitInternal("close", hadError);
-		if (wasConnected && this.#retryEnabled && hadError) this.#scheduleRetry(/* @__PURE__ */ new Error("Connection closed unexpectedly."));
+		if (wasConnected && this.#retryEnabled && hadError) this.#scheduleRetry(new ConnectionClosedError());
 	}
 	#onConnect() {
 		this.#state = "connected";
@@ -974,7 +1064,7 @@ var Connection = class extends EventEmitter {
 	}
 	#onTimeout() {
 		this.#context.logger.error("Connection timed out.");
-		const err = /* @__PURE__ */ new Error("Connection timed out.");
+		const err = new ConnectionTimeoutError();
 		this.#emitInternal("timeout");
 		if (this.#state === "connecting") this.#scheduleRetry(err);
 		else {
@@ -3176,7 +3266,7 @@ var AccessoryPair = class extends BasePairing {
 		const m4 = await this.m4(m3);
 		const m5 = await this.m5(m4);
 		const m6 = await this.m6(m4, m5);
-		if (!m6) throw new Error("Pairing failed, could not get accessory keys.");
+		if (!m6) throw new PairingError("Pairing failed, could not get accessory keys.");
 		return m6;
 	}
 	async transient() {
@@ -3337,7 +3427,7 @@ var AccessoryPair = class extends BasePairing {
 			accessoryIdentifier,
 			accessoryLongTermPublicKey
 		]);
-		if (!Ed25519.verify(accessoryInfo, accessorySignature, accessoryLongTermPublicKey)) throw new Error("Invalid accessory signature.");
+		if (!Ed25519.verify(accessoryInfo, accessorySignature, accessoryLongTermPublicKey)) throw new AuthenticationError("Invalid accessory signature.");
 		return {
 			accessoryIdentifier: accessoryIdentifier.toString(),
 			accessoryLongTermPublicKey,
@@ -3410,13 +3500,13 @@ var AccessoryVerify = class extends BasePairing {
 		const tlv = TLV8.decode(data);
 		const accessoryIdentifier = tlv.get(TLV8.Value.Identifier);
 		const accessorySignature = tlv.get(TLV8.Value.Signature);
-		if (accessoryIdentifier.toString() !== localAccessoryIdentifier) throw new Error(`Invalid accessory identifier. Expected ${accessoryIdentifier.toString()} to be ${localAccessoryIdentifier}.`);
+		if (accessoryIdentifier.toString() !== localAccessoryIdentifier) throw new AuthenticationError(`Invalid accessory identifier. Expected ${accessoryIdentifier.toString()} to be ${localAccessoryIdentifier}.`);
 		const accessoryInfo = Buffer.concat([
 			m1.serverPublicKey,
 			accessoryIdentifier,
 			this.#ephemeralKeyPair.publicKey
 		]);
-		if (!Ed25519.verify(accessoryInfo, accessorySignature, longTermPublicKey)) throw new Error("Invalid accessory signature.");
+		if (!Ed25519.verify(accessoryInfo, accessorySignature, longTermPublicKey)) throw new AuthenticationError("Invalid accessory signature.");
 		return {
 			serverEphemeralPublicKey: m1.serverPublicKey,
 			sessionKey,
@@ -3463,6 +3553,112 @@ var AccessoryVerify = class extends BasePairing {
 //#region src/symbols.ts
 const ENCRYPTION = Symbol();
 
+//#endregion
+//#region src/recovery.ts
+var ConnectionRecovery = class extends EventEmitter {
+	#options;
+	#attempt = 0;
+	#errors = [];
+	#isRecovering = false;
+	#isScheduledReconnecting = false;
+	#retryTimeout;
+	#reconnectInterval;
+	#disposed = false;
+	constructor(options) {
+		super();
+		this.#options = {
+			maxAttempts: 3,
+			baseDelay: 1e3,
+			maxDelay: 3e4,
+			useExponentialBackoff: true,
+			reconnectInterval: 0,
+			...options
+		};
+		if (this.#options.reconnectInterval > 0) this.#startReconnectInterval();
+	}
+	get isRecovering() {
+		return this.#isRecovering;
+	}
+	get attempt() {
+		return this.#attempt;
+	}
+	handleDisconnect(unexpected) {
+		if (this.#disposed || !unexpected) return;
+		this.#stopReconnectInterval();
+		this.#recover();
+	}
+	reset() {
+		this.#attempt = 0;
+		this.#errors = [];
+		this.#isRecovering = false;
+		if (this.#retryTimeout) {
+			clearTimeout(this.#retryTimeout);
+			this.#retryTimeout = void 0;
+		}
+		if (this.#options.reconnectInterval > 0) this.#startReconnectInterval();
+	}
+	dispose() {
+		this.#disposed = true;
+		this.#isRecovering = false;
+		this.#isScheduledReconnecting = false;
+		if (this.#retryTimeout) {
+			clearTimeout(this.#retryTimeout);
+			this.#retryTimeout = void 0;
+		}
+		this.#stopReconnectInterval();
+		this.removeAllListeners();
+	}
+	#recover() {
+		if (this.#isRecovering || this.#disposed) return;
+		if (this.#attempt >= this.#options.maxAttempts) {
+			this.emit("failed", this.#errors);
+			return;
+		}
+		this.#isRecovering = true;
+		this.#attempt++;
+		this.emit("recovering", this.#attempt);
+		const delay = this.#calculateDelay();
+		this.#retryTimeout = setTimeout(async () => {
+			this.#retryTimeout = void 0;
+			try {
+				await this.#options.onReconnect();
+				this.#isRecovering = false;
+				this.#attempt = 0;
+				this.#errors = [];
+				this.emit("recovered");
+				if (this.#options.reconnectInterval > 0) this.#startReconnectInterval();
+			} catch (err) {
+				this.#isRecovering = false;
+				this.#errors.push(err instanceof Error ? err : new Error(String(err)));
+				this.#recover();
+			}
+		}, delay);
+	}
+	#calculateDelay() {
+		if (!this.#options.useExponentialBackoff) return this.#options.baseDelay;
+		const delay = this.#options.baseDelay * Math.pow(2, this.#attempt - 1);
+		return Math.min(delay, this.#options.maxDelay);
+	}
+	#startReconnectInterval() {
+		this.#stopReconnectInterval();
+		this.#reconnectInterval = setInterval(async () => {
+			if (this.#isRecovering || this.#disposed || this.#isScheduledReconnecting) return;
+			this.#isScheduledReconnecting = true;
+			try {
+				await this.#options.onReconnect();
+			} catch (_) {} finally {
+				this.#isScheduledReconnecting = false;
+			}
+		}, this.#options.reconnectInterval);
+	}
+	#stopReconnectInterval() {
+		if (this.#reconnectInterval) {
+			clearInterval(this.#reconnectInterval);
+			this.#reconnectInterval = void 0;
+		}
+	}
+};
+
 //#endregion
 //#region src/timing.ts
 var TimingServer = class {
@@ -3485,13 +3681,18 @@ var TimingServer = class {
 	}
 	listen() {
 		return new Promise((resolve, reject) => {
-			this.#socket.once("error", reject);
-			this.#socket.once("listening", () => {
-				this.#socket.removeListener("error", reject);
+			const onError = (err) => {
+				this.#socket.removeListener("listening", onListening);
+				reject(err);
+			};
+			const onListening = () => {
+				this.#socket.removeListener("error", onError);
 				this.#onListening();
 				resolve();
-			});
-			this.#socket.bind(0, resolve);
+			};
+			this.#socket.once("error", onError);
+			this.#socket.once("listening", onListening);
+			this.#socket.bind(0);
 		});
 	}
 	#onConnect() {
@@ -3596,4 +3797,89 @@ function splitUInt53(number) {
 }
 
 //#endregion
-export { AIRPLAY_SERVICE, AIRPLAY_TRANSIENT_PIN, AccessoryPair, AccessoryVerify, AirPlayFeatureFlags, COMPANION_LINK_SERVICE, Connection, Context, Discovery, ENCRYPTION, EncryptionAwareConnection, EncryptionState, HTTP_TIMEOUT, JsonStorage, MemoryStorage, RAOP_SERVICE, Storage, TimingServer, describeFlags, generateActiveRemoteId, generateDacpId, generateSessionId, getLocalIP, getMacAddress, getPairingRequirement, getProtocolVersion, hasFeatureFlag, isPasswordRequired, isRemoteControlSupported, multicast as mdnsMulticast, unicast as mdnsUnicast, parseFeatures, prompt, randomInt32, randomInt64, reporter, uint16ToBE, uint53ToLE, v4 as uuid, waitFor };
+//#region src/deviceModel.ts
+let DeviceModel = /* @__PURE__ */ function(DeviceModel) {
+	DeviceModel[DeviceModel["Unknown"] = 0] = "Unknown";
+	DeviceModel[DeviceModel["AppleTVGen2"] = 1] = "AppleTVGen2";
+	DeviceModel[DeviceModel["AppleTVGen3"] = 2] = "AppleTVGen3";
+	DeviceModel[DeviceModel["AppleTVHD"] = 3] = "AppleTVHD";
+	DeviceModel[DeviceModel["AppleTV4K"] = 4] = "AppleTV4K";
+	DeviceModel[DeviceModel["AppleTV4KGen2"] = 5] = "AppleTV4KGen2";
+	DeviceModel[DeviceModel["AppleTV4KGen3"] = 6] = "AppleTV4KGen3";
+	DeviceModel[DeviceModel["HomePod"] = 10] = "HomePod";
+	DeviceModel[DeviceModel["HomePodMini"] = 11] = "HomePodMini";
+	DeviceModel[DeviceModel["HomePodGen2"] = 12] = "HomePodGen2";
+	DeviceModel[DeviceModel["AirPortExpress"] = 20] = "AirPortExpress";
+	DeviceModel[DeviceModel["AirPortExpressGen2"] = 21] = "AirPortExpressGen2";
+	return DeviceModel;
+}({});
+let DeviceType = /* @__PURE__ */ function(DeviceType) {
+	DeviceType[DeviceType["Unknown"] = 0] = "Unknown";
+	DeviceType[DeviceType["AppleTV"] = 1] = "AppleTV";
+	DeviceType[DeviceType["HomePod"] = 2] = "HomePod";
+	DeviceType[DeviceType["AirPort"] = 3] = "AirPort";
+	return DeviceType;
+}({});
+const MODEL_IDENTIFIERS = {
+	"AppleTV2,1": DeviceModel.AppleTVGen2,
+	"AppleTV3,1": DeviceModel.AppleTVGen3,
+	"AppleTV3,2": DeviceModel.AppleTVGen3,
+	"AppleTV5,3": DeviceModel.AppleTVHD,
+	"AppleTV6,2": DeviceModel.AppleTV4K,
+	"AppleTV11,1": DeviceModel.AppleTV4KGen2,
+	"AppleTV14,1": DeviceModel.AppleTV4KGen3,
+	"AudioAccessory1,1": DeviceModel.HomePod,
+	"AudioAccessory1,2": DeviceModel.HomePod,
+	"AudioAccessory5,1": DeviceModel.HomePodMini,
+	"AudioAccessorySingle5,1": DeviceModel.HomePodMini,
+	"AudioAccessory6,1": DeviceModel.HomePodGen2,
+	"AirPort4,107": DeviceModel.AirPortExpress,
+	"AirPort10,115": DeviceModel.AirPortExpressGen2
+};
+const INTERNAL_NAMES = {
+	"K66AP": DeviceModel.AppleTVGen2,
+	"J33AP": DeviceModel.AppleTVGen3,
+	"J33IAP": DeviceModel.AppleTVGen3,
+	"J42dAP": DeviceModel.AppleTVHD,
+	"J105aAP": DeviceModel.AppleTV4K,
+	"J305AP": DeviceModel.AppleTV4KGen2,
+	"J255AP": DeviceModel.AppleTV4KGen3,
+	"B520AP": DeviceModel.HomePodMini
+};
+const MODEL_NAMES = {
+	[DeviceModel.Unknown]: "Unknown",
+	[DeviceModel.AppleTVGen2]: "Apple TV (2nd generation)",
+	[DeviceModel.AppleTVGen3]: "Apple TV (3rd generation)",
+	[DeviceModel.AppleTVHD]: "Apple TV HD",
+	[DeviceModel.AppleTV4K]: "Apple TV 4K (1st generation)",
+	[DeviceModel.AppleTV4KGen2]: "Apple TV 4K (2nd generation)",
+	[DeviceModel.AppleTV4KGen3]: "Apple TV 4K (3rd generation)",
+	[DeviceModel.HomePod]: "HomePod",
+	[DeviceModel.HomePodMini]: "HomePod mini",
+	[DeviceModel.HomePodGen2]: "HomePod (2nd generation)",
+	[DeviceModel.AirPortExpress]: "AirPort Express",
+	[DeviceModel.AirPortExpressGen2]: "AirPort Express (2nd generation)"
+};
+const MODEL_TYPES = {
+	[DeviceModel.Unknown]: DeviceType.Unknown,
+	[DeviceModel.AppleTVGen2]: DeviceType.AppleTV,
+	[DeviceModel.AppleTVGen3]: DeviceType.AppleTV,
+	[DeviceModel.AppleTVHD]: DeviceType.AppleTV,
+	[DeviceModel.AppleTV4K]: DeviceType.AppleTV,
+	[DeviceModel.AppleTV4KGen2]: DeviceType.AppleTV,
+	[DeviceModel.AppleTV4KGen3]: DeviceType.AppleTV,
+	[DeviceModel.HomePod]: DeviceType.HomePod,
+	[DeviceModel.HomePodMini]: DeviceType.HomePod,
+	[DeviceModel.HomePodGen2]: DeviceType.HomePod,
+	[DeviceModel.AirPortExpress]: DeviceType.AirPort,
+	[DeviceModel.AirPortExpressGen2]: DeviceType.AirPort
+};
+const lookupDeviceModel = (identifier) => MODEL_IDENTIFIERS[identifier] ?? INTERNAL_NAMES[identifier] ?? DeviceModel.Unknown;
+const getDeviceModelName = (model) => MODEL_NAMES[model] ?? "Unknown";
+const getDeviceType = (model) => MODEL_TYPES[model] ?? DeviceType.Unknown;
+const isAppleTV = (model) => getDeviceType(model) === DeviceType.AppleTV;
+const isHomePod = (model) => getDeviceType(model) === DeviceType.HomePod;
+const isAirPort = (model) => getDeviceType(model) === DeviceType.AirPort;
+
+//#endregion
+export { AIRPLAY_SERVICE, AIRPLAY_TRANSIENT_PIN, AccessoryPair, AccessoryVerify, AirPlayFeatureFlags, AppleProtocolError, AuthenticationError, COMPANION_LINK_SERVICE, CommandError, Connection, ConnectionClosedError, ConnectionError, ConnectionRecovery, ConnectionTimeoutError, Context, CredentialsError, DeviceModel, DeviceType, Discovery, DiscoveryError, ENCRYPTION, EncryptionAwareConnection, EncryptionError, EncryptionState, HTTP_TIMEOUT, InvalidResponseError, JsonStorage, MemoryStorage, PairingError, PlaybackError, RAOP_SERVICE, SetupError, Storage, TimeoutError, TimingServer, describeFlags, generateActiveRemoteId, generateDacpId, generateSessionId, getDeviceModelName, getDeviceType, getLocalIP, getMacAddress, getPairingRequirement, getProtocolVersion, hasFeatureFlag, isAirPort, isAppleTV, isHomePod, isPasswordRequired, isRemoteControlSupported, lookupDeviceModel, multicast as mdnsMulticast, unicast as mdnsUnicast, parseFeatures, prompt, randomInt32, randomInt64, reporter, uint16ToBE, uint53ToLE, v4 as uuid, waitFor };

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@basmilius/apple-common",
     "description": "Common features shared across various apple protocol packages.",
-    "version": "0.9.18",
+    "version": "0.9.19",
     "type": "module",
     "license": "MIT",
     "author": {
@@ -45,8 +45,8 @@
         }
     },
     "dependencies": {
-        "@basmilius/apple-encoding": "0.9.18",
-        "@basmilius/apple-encryption": "0.9.18"
+        "@basmilius/apple-encoding": "0.9.19",
+        "@basmilius/apple-encryption": "0.9.19"
     },
     "devDependencies": {
         "@types/bun": "^1.3.11",