@basmilius/apple-common 0.8.2 → 0.9.2

package/dist/index.mjs

@@ -1,14 +1,20 @@
+import { createRequire } from "node:module";
 import { randomBytes, randomFillSync, randomUUID } from "node:crypto";
-import mdns from "node-dns-sd";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { Socket, createConnection } from "node:net";
 import { createInterface } from "node:readline";
+import { createSocket } from "node:dgram";
+import { networkInterfaces } from "node:os";
 import { EventEmitter } from "node:events";
-import { Socket } from "node:net";
 import { NTP, OPack, TLV8 } from "@basmilius/apple-encoding";
 import { Chacha20, Curve25519, Ed25519, hkdf } from "@basmilius/apple-encryption";
 import { SRP, SrpClient } from "fast-srp-hap";
-import { createSocket } from "node:dgram";
-import { networkInterfaces } from "node:os";
 
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
 //#region ../../node_modules/.bun/uuid@13.0.0/node_modules/uuid/dist-node/stringify.js
 const byteToHex = [];
 for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
@@ -53,6 +59,178 @@ function v4(options, buf, offset) {
 	return _v4(options, buf, offset);
 }
 
+//#endregion
+//#region src/airplayFeatures.ts
+const AirPlayFeatureFlags = {
+	SupportsAirPlayVideoV1: 1n << 0n,
+	SupportsAirPlayPhoto: 1n << 1n,
+	SupportsAirPlayVideoFairPlay: 1n << 2n,
+	SupportsAirPlayVideoVolumeControl: 1n << 3n,
+	SupportsAirPlayVideoHTTPLiveStreams: 1n << 4n,
+	SupportsAirPlaySlideShow: 1n << 5n,
+	SupportsAirPlayScreen: 1n << 7n,
+	SupportsAirPlayAudio: 1n << 9n,
+	AudioRedundant: 1n << 11n,
+	Authentication_4: 1n << 14n,
+	MetadataFeatures_0: 1n << 15n,
+	MetadataFeatures_1: 1n << 16n,
+	MetadataFeatures_2: 1n << 17n,
+	AudioFormats_0: 1n << 18n,
+	AudioFormats_1: 1n << 19n,
+	AudioFormats_2: 1n << 20n,
+	AudioFormats_3: 1n << 21n,
+	Authentication_1: 1n << 23n,
+	Authentication_8: 1n << 26n,
+	SupportsLegacyPairing: 1n << 27n,
+	HasUnifiedAdvertiserInfo: 1n << 30n,
+	IsCarPlay: 1n << 32n,
+	SupportsAirPlayVideoPlayQueue: 1n << 33n,
+	SupportsAirPlayFromCloud: 1n << 34n,
+	SupportsTLS_PSK: 1n << 35n,
+	SupportsUnifiedMediaControl: 1n << 38n,
+	SupportsBufferedAudio: 1n << 40n,
+	SupportsPTP: 1n << 41n,
+	SupportsScreenMultiCodec: 1n << 42n,
+	SupportsSystemPairing: 1n << 43n,
+	IsAPValeriaScreenSender: 1n << 44n,
+	SupportsHKPairingAndAccessControl: 1n << 46n,
+	SupportsCoreUtilsPairingAndEncryption: 1n << 48n,
+	SupportsAirPlayVideoV2: 1n << 49n,
+	MetadataFeatures_3: 1n << 50n,
+	SupportsUnifiedPairSetupAndMFi: 1n << 51n,
+	SupportsSetPeersExtendedMessage: 1n << 52n,
+	SupportsAPSync: 1n << 54n,
+	SupportsWoL: 1n << 55n,
+	SupportsWoL2: 1n << 56n,
+	SupportsHangdogRemoteControl: 1n << 58n,
+	SupportsAudioStreamConnectionSetup: 1n << 59n,
+	SupportsAudioMetadataControl: 1n << 60n,
+	SupportsRFC2198Redundancy: 1n << 61n
+};
+const PASSWORD_BIT = 128n;
+const LEGACY_PAIRING_BIT = 512n;
+const PIN_REQUIRED_BIT = 8n;
+const parseFeatures = (features) => {
+	const parts = features.split(",").map((part) => part.trim());
+	if (parts.length === 1) return BigInt(parts[0]);
+	if (parts.length === 2) {
+		const low = BigInt(parts[0]);
+		return BigInt(parts[1]) << 32n | low;
+	}
+	throw new Error(`Invalid features format: ${features}`);
+};
+const hasFeatureFlag = (features, flag) => (features & flag) !== 0n;
+const describeFlags = (features) => {
+	const result = [];
+	for (const [name, flag] of Object.entries(AirPlayFeatureFlags)) if (hasFeatureFlag(features, flag)) result.push(name);
+	return result;
+};
+const getProtocolVersion = (txt) => {
+	const featuresStr = txt.features ?? txt.ft;
+	if (!featuresStr) return 1;
+	const features = parseFeatures(featuresStr);
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsUnifiedMediaControl)) return 2;
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsCoreUtilsPairingAndEncryption)) return 2;
+	return 1;
+};
+const getPairingRequirement = (txt) => {
+	const featuresStr = txt.features ?? txt.ft;
+	if (!featuresStr) return "none";
+	const features = parseFeatures(featuresStr);
+	const sf = txt.sf ? BigInt(txt.sf) : 0n;
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsHKPairingAndAccessControl)) return "homekit";
+	if ((sf & PIN_REQUIRED_BIT) !== 0n) return "pin";
+	if (hasFeatureFlag(features, AirPlayFeatureFlags.SupportsSystemPairing)) return "transient";
+	if ((sf & LEGACY_PAIRING_BIT) !== 0n) return "pin";
+	return "none";
+};
+const isPasswordRequired = (txt) => {
+	if (txt.pw === "true") return true;
+	return ((txt.sf ? BigInt(txt.sf) : 0n) & PASSWORD_BIT) !== 0n;
+};
+const isRemoteControlSupported = (txt) => {
+	const featuresStr = txt.features ?? txt.ft;
+	if (!featuresStr) return false;
+	return hasFeatureFlag(parseFeatures(featuresStr), AirPlayFeatureFlags.SupportsHangdogRemoteControl);
+};
+
+//#endregion
+//#region src/storage.ts
+const credentialKey = (deviceId, protocol) => `${deviceId}:${protocol}`;
+const serializeCredentials = (credentials) => ({
+	accessoryIdentifier: credentials.accessoryIdentifier,
+	accessoryLongTermPublicKey: credentials.accessoryLongTermPublicKey.toString("base64"),
+	pairingId: credentials.pairingId.toString("base64"),
+	publicKey: credentials.publicKey.toString("base64"),
+	secretKey: credentials.secretKey.toString("base64")
+});
+const deserializeCredentials = (stored) => ({
+	accessoryIdentifier: stored.accessoryIdentifier,
+	accessoryLongTermPublicKey: Buffer.from(stored.accessoryLongTermPublicKey, "base64"),
+	pairingId: Buffer.from(stored.pairingId, "base64"),
+	publicKey: Buffer.from(stored.publicKey, "base64"),
+	secretKey: Buffer.from(stored.secretKey, "base64")
+});
+const createEmptyData = () => ({
+	version: 1,
+	devices: {},
+	credentials: {}
+});
+var Storage = class {
+	#data = createEmptyData();
+	get data() {
+		return this.#data;
+	}
+	setData(data) {
+		this.#data = data;
+	}
+	getDevice(identifier) {
+		return this.#data.devices[identifier];
+	}
+	setDevice(identifier, device) {
+		this.#data.devices[identifier] = device;
+	}
+	removeDevice(identifier) {
+		delete this.#data.devices[identifier];
+		for (const key of Object.keys(this.#data.credentials)) if (key.startsWith(`${identifier}:`)) delete this.#data.credentials[key];
+	}
+	listDevices() {
+		return Object.values(this.#data.devices);
+	}
+	getCredentials(deviceId, protocol) {
+		const stored = this.#data.credentials[credentialKey(deviceId, protocol)];
+		if (!stored) return;
+		return deserializeCredentials(stored);
+	}
+	setCredentials(deviceId, protocol, credentials) {
+		this.#data.credentials[credentialKey(deviceId, protocol)] = serializeCredentials(credentials);
+	}
+	removeCredentials(deviceId, protocol) {
+		delete this.#data.credentials[credentialKey(deviceId, protocol)];
+	}
+};
+var JsonStorage = class extends Storage {
+	#path;
+	constructor(path) {
+		super();
+		this.#path = path ?? join(process.env.HOME ?? process.env.USERPROFILE ?? ".", ".config", "apple-protocols", "storage.json");
+	}
+	async load() {
+		if (!existsSync(this.#path)) return;
+		const raw = readFileSync(this.#path, "utf-8");
+		const json = JSON.parse(raw);
+		if (json.version === 1) this.setData(json);
+	}
+	async save() {
+		mkdirSync(dirname(this.#path), { recursive: true });
+		writeFileSync(this.#path, JSON.stringify(this.data, null, 2), "utf-8");
+	}
+};
+var MemoryStorage = class extends Storage {
+	async load() {}
+	async save() {}
+};
+
 //#endregion
 //#region src/cli.ts
 async function prompt(message) {
@@ -77,23 +255,452 @@ const AIRPLAY_SERVICE = "_airplay._tcp.local";
 const COMPANION_LINK_SERVICE = "_companion-link._tcp.local";
 const RAOP_SERVICE = "_raop._tcp.local";
 
+//#endregion
+//#region src/mdns.ts
+const MDNS_ADDRESS = "224.0.0.251";
+const MDNS_PORT = 5353;
+const QUERY_ID = 13823;
+const SERVICES_PER_MSG = 3;
+const QueryType = {
+	A: 1,
+	PTR: 12,
+	TXT: 16,
+	AAAA: 28,
+	SRV: 33,
+	ANY: 255
+};
+const encodeQName = (name) => {
+	const parts = [];
+	const labels = splitServiceName(name);
+	for (const label of labels) {
+		const encoded = Buffer.from(label, "utf-8");
+		if (encoded.byteLength > 63) parts.push(Buffer.from([63]), encoded.subarray(0, 63));
+		else parts.push(Buffer.from([encoded.byteLength]), encoded);
+	}
+	parts.push(Buffer.from([0]));
+	return Buffer.concat(parts);
+};
+const splitServiceName = (name) => {
+	const match = name.match(/\._[a-z]+\._(?:tcp|udp)\.local$/);
+	if (match) return [name.substring(0, match.index), ...match[0].substring(1).split(".")];
+	return name.split(".");
+};
+const encodeDnsHeader = (header) => {
+	const buf = Buffer.allocUnsafe(12);
+	buf.writeUInt16BE(header.id, 0);
+	buf.writeUInt16BE(header.flags, 2);
+	buf.writeUInt16BE(header.qdcount, 4);
+	buf.writeUInt16BE(header.ancount, 6);
+	buf.writeUInt16BE(header.nscount, 8);
+	buf.writeUInt16BE(header.arcount, 10);
+	return buf;
+};
+const encodeDnsQuestion = (name, qtype, unicastResponse = false) => {
+	const qname = encodeQName(name);
+	const suffix = Buffer.allocUnsafe(4);
+	suffix.writeUInt16BE(qtype, 0);
+	suffix.writeUInt16BE(unicastResponse ? 32769 : 1, 2);
+	return Buffer.concat([qname, suffix]);
+};
+const createQueryPackets = (services, qtype = QueryType.PTR, unicastResponse = false) => {
+	const packets = [];
+	for (let i = 0; i < services.length; i += SERVICES_PER_MSG) {
+		const chunk = services.slice(i, i + SERVICES_PER_MSG);
+		const questions = chunk.map((s) => encodeDnsQuestion(s, qtype, unicastResponse));
+		const header = encodeDnsHeader({
+			id: QUERY_ID,
+			flags: 0,
+			qdcount: chunk.length,
+			ancount: 0,
+			nscount: 0,
+			arcount: 0
+		});
+		packets.push(Buffer.concat([header, ...questions]));
+	}
+	return packets;
+};
+const decodeQName = (buf, offset) => {
+	const labels = [];
+	let currentOffset = offset;
+	let jumped = false;
+	let returnOffset = offset;
+	while (currentOffset < buf.byteLength) {
+		const length = buf[currentOffset];
+		if (length === 0) {
+			if (!jumped) returnOffset = currentOffset + 1;
+			break;
+		}
+		if ((length & 192) === 192) {
+			const pointer = (length & 63) << 8 | buf[currentOffset + 1];
+			if (!jumped) returnOffset = currentOffset + 2;
+			currentOffset = pointer;
+			jumped = true;
+			continue;
+		}
+		currentOffset++;
+		labels.push(buf.toString("utf-8", currentOffset, currentOffset + length));
+		currentOffset += length;
+		if (!jumped) returnOffset = currentOffset;
+	}
+	return [labels.join("."), returnOffset];
+};
+const decodeDnsHeader = (buf) => ({
+	id: buf.readUInt16BE(0),
+	flags: buf.readUInt16BE(2),
+	qdcount: buf.readUInt16BE(4),
+	ancount: buf.readUInt16BE(6),
+	nscount: buf.readUInt16BE(8),
+	arcount: buf.readUInt16BE(10)
+});
+const decodeQuestion = (buf, offset) => {
+	const [qname, newOffset] = decodeQName(buf, offset);
+	return [{
+		qname,
+		qtype: buf.readUInt16BE(newOffset),
+		qclass: buf.readUInt16BE(newOffset + 2)
+	}, newOffset + 4];
+};
+const decodeTxtRecord = (buf, offset, length) => {
+	const properties = {};
+	let pos = offset;
+	const end = offset + length;
+	while (pos < end) {
+		const strLen = buf[pos];
+		pos++;
+		if (strLen === 0 || pos + strLen > end) break;
+		const str = buf.toString("utf-8", pos, pos + strLen);
+		pos += strLen;
+		const eqIndex = str.indexOf("=");
+		if (eqIndex >= 0) properties[str.substring(0, eqIndex)] = str.substring(eqIndex + 1);
+		else properties[str] = "";
+	}
+	return properties;
+};
+const decodeSrvRecord = (buf, offset) => {
+	const priority = buf.readUInt16BE(offset);
+	const weight = buf.readUInt16BE(offset + 2);
+	const port = buf.readUInt16BE(offset + 4);
+	const [target] = decodeQName(buf, offset + 6);
+	return {
+		priority,
+		weight,
+		port,
+		target
+	};
+};
+const decodeResource = (buf, offset) => {
+	const [qname, nameEnd] = decodeQName(buf, offset);
+	const qtype = buf.readUInt16BE(nameEnd);
+	const qclass = buf.readUInt16BE(nameEnd + 2);
+	const ttl = buf.readUInt32BE(nameEnd + 4);
+	const rdLength = buf.readUInt16BE(nameEnd + 8);
+	const rdOffset = nameEnd + 10;
+	let rdata;
+	switch (qtype) {
+		case QueryType.A:
+			rdata = `${buf[rdOffset]}.${buf[rdOffset + 1]}.${buf[rdOffset + 2]}.${buf[rdOffset + 3]}`;
+			break;
+		case QueryType.AAAA: {
+			const parts = [];
+			for (let i = 0; i < 8; i++) parts.push(buf.readUInt16BE(rdOffset + i * 2).toString(16));
+			rdata = parts.join(":");
+			break;
+		}
+		case QueryType.PTR: {
+			const [name] = decodeQName(buf, rdOffset);
+			rdata = name;
+			break;
+		}
+		case QueryType.SRV:
+			rdata = decodeSrvRecord(buf, rdOffset);
+			break;
+		case QueryType.TXT:
+			rdata = decodeTxtRecord(buf, rdOffset, rdLength);
+			break;
+		default: rdata = buf.subarray(rdOffset, rdOffset + rdLength);
+	}
+	return [{
+		qname,
+		qtype,
+		qclass,
+		ttl,
+		rdata
+	}, rdOffset + rdLength];
+};
+const decodeDnsResponse = (buf) => {
+	const header = decodeDnsHeader(buf);
+	let offset = 12;
+	for (let i = 0; i < header.qdcount; i++) {
+		const [, newOffset] = decodeQuestion(buf, offset);
+		offset = newOffset;
+	}
+	const answers = [];
+	for (let i = 0; i < header.ancount; i++) {
+		const [record, newOffset] = decodeResource(buf, offset);
+		answers.push(record);
+		offset = newOffset;
+	}
+	for (let i = 0; i < header.nscount; i++) {
+		const [, newOffset] = decodeResource(buf, offset);
+		offset = newOffset;
+	}
+	const resources = [];
+	for (let i = 0; i < header.arcount; i++) {
+		const [record, newOffset] = decodeResource(buf, offset);
+		resources.push(record);
+		offset = newOffset;
+	}
+	return {
+		header,
+		answers,
+		resources
+	};
+};
+var ServiceCollector = class {
+	#ptrMap = /* @__PURE__ */ new Map();
+	#srvMap = /* @__PURE__ */ new Map();
+	#txtMap = /* @__PURE__ */ new Map();
+	#addressMap = /* @__PURE__ */ new Map();
+	addRecords(answers, resources) {
+		for (const record of [...answers, ...resources]) switch (record.qtype) {
+			case QueryType.PTR: {
+				const existing = this.#ptrMap.get(record.qname);
+				if (existing) existing.add(record.rdata);
+				else this.#ptrMap.set(record.qname, new Set([record.rdata]));
+				break;
+			}
+			case QueryType.SRV:
+				this.#srvMap.set(record.qname, record.rdata);
+				break;
+			case QueryType.TXT:
+				this.#txtMap.set(record.qname, record.rdata);
+				break;
+			case QueryType.A:
+				this.#addressMap.set(record.qname, record.rdata);
+				break;
+		}
+	}
+	get services() {
+		const results = [];
+		for (const [serviceType, instanceNames] of this.#ptrMap) for (const instanceQName of instanceNames) {
+			const srv = this.#srvMap.get(instanceQName);
+			if (!srv || srv.port === 0) continue;
+			const address = this.#addressMap.get(srv.target);
+			if (!address) continue;
+			const txt = this.#txtMap.get(instanceQName) ?? {};
+			const typeIndex = instanceQName.indexOf("._");
+			const name = typeIndex >= 0 ? instanceQName.substring(0, typeIndex) : instanceQName;
+			if (!results.some((s) => s.name === name && s.type === serviceType)) results.push({
+				name,
+				type: serviceType,
+				address,
+				port: srv.port,
+				properties: txt
+			});
+		}
+		return results;
+	}
+};
+const WAKE_PORTS$1 = [
+	7e3,
+	3689,
+	49152,
+	32498
+];
+const knock = (address) => {
+	const promises = WAKE_PORTS$1.map((port) => new Promise((resolve) => {
+		const socket = createConnection({
+			host: address,
+			port,
+			timeout: 500
+		});
+		socket.on("connect", () => {
+			socket.destroy();
+			resolve();
+		});
+		socket.on("error", () => {
+			socket.destroy();
+			resolve();
+		});
+		socket.on("timeout", () => {
+			socket.destroy();
+			resolve();
+		});
+	}));
+	return Promise.all(promises).then(() => {});
+};
+const unicast = (hosts, services, timeout = 4) => {
+	return new Promise((resolve) => {
+		const queries = createQueryPackets(services);
+		const collector = new ServiceCollector();
+		const sockets = [];
+		let resolved = false;
+		const finish = () => {
+			if (resolved) return;
+			resolved = true;
+			clearInterval(interval);
+			for (const socket of sockets) try {
+				socket.close();
+			} catch {}
+			resolve(collector.services);
+		};
+		for (const host of hosts) {
+			const socket = createSocket("udp4");
+			sockets.push(socket);
+			socket.on("message", (data) => {
+				try {
+					const response = decodeDnsResponse(data);
+					collector.addRecords(response.answers, response.resources);
+				} catch {}
+			});
+			socket.on("error", () => {});
+		}
+		let interval;
+		Promise.all(hosts.map((h) => knock(h))).then(() => {
+			const sendQueries = () => {
+				for (let i = 0; i < hosts.length; i++) for (const query of queries) sockets[i]?.send(query, MDNS_PORT, hosts[i]);
+			};
+			sendQueries();
+			interval = setInterval(sendQueries, 1e3);
+			setTimeout(finish, timeout * 1e3);
+		});
+	});
+};
+const multicast = (services, timeout = 4) => {
+	return new Promise((resolve) => {
+		const collector = new ServiceCollector();
+		const queries = createQueryPackets(services);
+		const sockets = [];
+		let resolved = false;
+		let interval;
+		const finish = () => {
+			if (resolved) return;
+			resolved = true;
+			clearInterval(interval);
+			for (const socket of sockets) try {
+				socket.close();
+			} catch {}
+			resolve(collector.services);
+		};
+		const onMessage = (data) => {
+			try {
+				const response = decodeDnsResponse(data);
+				collector.addRecords(response.answers, response.resources);
+			} catch {}
+		};
+		const addSocket = (address, port) => {
+			return new Promise((resolveSocket) => {
+				const socket = createSocket({
+					type: "udp4",
+					reuseAddr: true
+				});
+				socket.on("message", onMessage);
+				socket.on("error", () => {
+					resolveSocket(null);
+				});
+				socket.bind(port, address ?? "", () => {
+					if (address) try {
+						socket.setMulticastInterface(address);
+						socket.addMembership(MDNS_ADDRESS, address);
+					} catch {}
+					else try {
+						socket.addMembership(MDNS_ADDRESS);
+					} catch {}
+					sockets.push(socket);
+					resolveSocket(socket);
+				});
+			});
+		};
+		const getPrivateAddresses = () => {
+			try {
+				const { networkInterfaces } = __require("node:os");
+				const interfaces = networkInterfaces();
+				const addresses = [];
+				for (const nets of Object.values(interfaces)) for (const net of nets) if (net.family === "IPv4" && net.internal === false) addresses.push(net.address);
+				return addresses;
+			} catch {
+				return [];
+			}
+		};
+		const setup = async () => {
+			await addSocket(null, MDNS_PORT);
+			for (const address of getPrivateAddresses()) await addSocket(address, 0);
+			if (sockets.length === 0) {
+				resolve([]);
+				return;
+			}
+			const sendQueries = () => {
+				for (const socket of sockets) for (const query of queries) try {
+					socket.send(query, MDNS_PORT, MDNS_ADDRESS);
+				} catch {}
+			};
+			sendQueries();
+			interval = setInterval(sendQueries, 1e3);
+			setTimeout(finish, timeout * 1e3);
+		};
+		setup();
+	});
+};
+
 //#endregion
 //#region src/discovery.ts
+const CACHE_TTL = 3e4;
+const WAKE_PORTS = [
+	7e3,
+	3689,
+	49152,
+	32498
+];
+const toDiscoveryResult = (service) => {
+	const txt = service.properties;
+	const featuresStr = txt.features ?? txt.ft;
+	const model = txt.model ?? txt.am ?? "";
+	const protocol = service.type.includes("._tcp") ? "tcp" : "udp";
+	const hostname = service.name.replace(/\s+/g, "-");
+	return {
+		id: `${hostname}.local`,
+		fqdn: `${hostname}.local`,
+		address: service.address,
+		modelName: model,
+		familyName: null,
+		txt,
+		features: featuresStr ? tryParseFeatures(featuresStr) : void 0,
+		service: {
+			port: service.port,
+			protocol,
+			type: service.type
+		},
+		packet: null
+	};
+};
+const tryParseFeatures = (features) => {
+	try {
+		return parseFeatures(features);
+	} catch {
+		return;
+	}
+};
 var Discovery = class Discovery {
+	static #cache = /* @__PURE__ */ new Map();
 	#service;
 	constructor(service) {
 		this.#service = service;
 	}
-	async find() {
-		return (await mdns.discover({ name: this.#service })).map((result) => ({
-			id: generateId(result) ?? result.fqdn,
-			txt: getTxt(result),
-			...result
-		}));
+	async find(useCache = true) {
+		if (useCache) {
+			const cached = Discovery.#cache.get(this.#service);
+			if (cached && cached.expiresAt > Date.now()) return cached.results;
+		}
+		const mapped = (await multicast([this.#service], 4)).map(toDiscoveryResult);
+		Discovery.#cache.set(this.#service, {
+			results: mapped,
+			expiresAt: Date.now() + CACHE_TTL
+		});
+		return mapped;
 	}
 	async findUntil(id, tries = 10, timeout = 1e3) {
 		while (tries > 0) {
-			const devices = await this.find();
+			const devices = await this.find(false);
 			const device = devices.find((device) => device.id === id);
 			if (device) return device;
 			console.log();
@@ -102,7 +709,57 @@ var Discovery = class Discovery {
 			tries--;
 			await waitFor(timeout);
 		}
-		throw new Error("Device not found after serveral tries, aborting.");
+		throw new Error("Device not found after several tries, aborting.");
+	}
+	static clearCache() {
+		Discovery.#cache.clear();
+	}
+	static async wake(address) {
+		const promises = WAKE_PORTS.map((port) => new Promise((resolve) => {
+			const socket = createConnection({
+				host: address,
+				port,
+				timeout: 500
+			});
+			socket.on("connect", () => {
+				socket.destroy();
+				resolve();
+			});
+			socket.on("error", () => {
+				socket.destroy();
+				resolve();
+			});
+			socket.on("timeout", () => {
+				socket.destroy();
+				resolve();
+			});
+		}));
+		await Promise.all(promises);
+	}
+	static async discoverAll() {
+		const allServices = await multicast([
+			AIRPLAY_SERVICE,
+			COMPANION_LINK_SERVICE,
+			RAOP_SERVICE
+		], 4);
+		const devices = /* @__PURE__ */ new Map();
+		for (const service of allServices) {
+			const result = toDiscoveryResult(service);
+			const existing = devices.get(result.id);
+			if (existing) {
+				if (service.type === AIRPLAY_SERVICE) existing.airplay = result;
+				else if (service.type === COMPANION_LINK_SERVICE) existing.companionLink = result;
+				else if (service.type === RAOP_SERVICE) existing.raop = result;
+			} else devices.set(result.id, {
+				id: result.id,
+				name: result.fqdn,
+				address: result.address,
+				airplay: service.type === AIRPLAY_SERVICE ? result : void 0,
+				companionLink: service.type === COMPANION_LINK_SERVICE ? result : void 0,
+				raop: service.type === RAOP_SERVICE ? result : void 0
+			});
+		}
+		return [...devices.values()];
 	}
 	static airplay() {
 		return new Discovery(AIRPLAY_SERVICE);
@@ -114,29 +771,6 @@ var Discovery = class Discovery {
 		return new Discovery(RAOP_SERVICE);
 	}
 };
-function generateId(result) {
-	if (!result?.packet) return null;
-	const { answers = [], additionals = [] } = result.packet;
-	const allRecords = [...answers, ...additionals];
-	const srvRecord = allRecords.find((record) => record.type === "SRV");
-	if (srvRecord?.rdata?.target) return srvRecord.rdata.target;
-	if (result.address) {
-		const addressRecord = allRecords.find((record) => (record.type === "A" || record.type === "AAAA") && record.rdata === result.address);
-		if (addressRecord?.name) return addressRecord.name;
-	}
-	const aRecord = allRecords.find((record) => record.type === "A");
-	if (aRecord?.name) return aRecord.name;
-	if (result.modelName) return `${result.modelName.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-]/g, "")}.local`;
-	return null;
-}
-function getTxt(result) {
-	if (!result.packet) return {};
-	const { answers = [], additionals = [] } = result.packet;
-	const records = [...answers, ...additionals];
-	const txt = {};
-	for (const record of records) if (record.type === "TXT" && record.rdata) Object.assign(txt, record.rdata);
-	return txt;
-}
 
 //#endregion
 //#region src/symbols.ts
@@ -841,5 +1475,5 @@ function splitUInt53(number) {
 }
 
 //#endregion
-export { AIRPLAY_SERVICE, AIRPLAY_TRANSIENT_PIN, AccessoryPair, AccessoryVerify, COMPANION_LINK_SERVICE, Connection, Context, Discovery, ENCRYPTION, EncryptionAwareConnection, EncryptionState, HTTP_TIMEOUT, RAOP_SERVICE, TimingServer, generateActiveRemoteId, generateDacpId, generateSessionId, getLocalIP, getMacAddress, prompt, randomInt32, randomInt64, reporter, uint16ToBE, uint53ToLE, v4 as uuid, waitFor };
+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 };
 //# sourceMappingURL=index.mjs.map