@corewire/core 0.0.0 → 1.0.0-beta.1

package/dist/discovery.mjs

@@ -0,0 +1,763 @@
+import { r as __require } from "./chunk-wE0WeVzl.mjs";
+import { l as DiscoveryError } from "./errors-DVv1n4fL.mjs";
+import { t as Logger } from "./reporter-DfM6vPT0.mjs";
+import { t as waitFor } from "./utils-DY5OKUuy.mjs";
+import { createSocket } from "node:dgram";
+import { createConnection } from "node:net";
+import { networkInterfaces } from "node:os";
+
+//#region src/discovery/mdns.ts
+/** The IPv4 multicast address of mDNS, from RFC 6762. */
+const MDNS_ADDRESS$1 = "224.0.0.251";
+const MDNS_PORT$1 = 5353;
+const QUERY_ID = 13823;
+/** The number of service questions in one DNS message. */
+const SERVICES_PER_MSG = 3;
+/** The DNS record types that discovery asks for and reads. */
+const QueryType = {
+	A: 1,
+	PTR: 12,
+	TXT: 16,
+	AAAA: 28,
+	SRV: 33,
+	ANY: 255
+};
+/**
+* Encodes a domain name as DNS labels, each prefixed with its length and the last followed
+* by a zero byte. A label longer than 63 bytes is cut off.
+*/
+function 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);
+}
+/**
+* Splits a service name into DNS labels. An instance name can contain dots, so the split
+* happens at the service type: `Living Room._hap._tcp.local` gives
+* `['Living Room', '_hap', '_tcp', 'local']`.
+*/
+function splitServiceName(name) {
+	const match = name.match(/\._[a-z0-9-]+\._(?:tcp|udp)\.local$/);
+	if (match) return [name.substring(0, match.index), ...match[0].substring(1).split(".")];
+	return name.split(".");
+}
+/**
+* Encodes the 12-byte DNS header.
+*/
+function 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;
+}
+/**
+* Encodes one DNS question.
+*
+* @param unicastResponse - Sets the QU bit, which asks for a unicast response.
+*/
+function 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]);
+}
+/**
+* Builds the DNS query packets for the service types, {@link SERVICES_PER_MSG} questions per packet.
+*
+* @param services - The mDNS service types, such as `_hap._tcp.local`.
+* @param unicastResponse - Sets the QU bit, which asks for a unicast response.
+*/
+function 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((service) => encodeDnsQuestion(service, 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;
+}
+/** The number of compression pointers to follow in one name, so a pointer loop ends. */
+const MAX_POINTER_JUMPS = 128;
+/**
+* Decodes a DNS name and follows its compression pointers (RFC 1035 section 4.1.4).
+*
+* @returns The name and the offset after it in the packet.
+*/
+function 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];
+		if (length === 0) {
+			if (!jumped) returnOffset = currentOffset + 1;
+			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;
+			jumped = true;
+			continue;
+		}
+		currentOffset++;
+		if (currentOffset + length > buf.byteLength) break;
+		labels.push(buf.toString("utf-8", currentOffset, currentOffset + length));
+		currentOffset += length;
+		if (!jumped) returnOffset = currentOffset;
+	}
+	return [labels.join("."), returnOffset];
+}
+/**
+* Decodes the 12-byte DNS header.
+*/
+function decodeDnsHeader(buf) {
+	return {
+		id: buf.readUInt16BE(0),
+		flags: buf.readUInt16BE(2),
+		qdcount: buf.readUInt16BE(4),
+		ancount: buf.readUInt16BE(6),
+		nscount: buf.readUInt16BE(8),
+		arcount: buf.readUInt16BE(10)
+	};
+}
+/**
+* Decodes one DNS question.
+*
+* @returns The question and the offset after it.
+*/
+function decodeQuestion(buf, offset) {
+	const [qname, newOffset] = decodeQName(buf, offset);
+	return [{
+		qname,
+		qtype: buf.readUInt16BE(newOffset),
+		qclass: buf.readUInt16BE(newOffset + 2)
+	}, newOffset + 4];
+}
+/**
+* Decodes the data of a TXT record into properties. Each entry is a length-prefixed UTF-8
+* `key=value` string; an entry without `=` gets an empty value.
+*/
+function decodeTxtRecord(buf, offset, length) {
+	const properties = {};
+	let pos = offset;
+	const end = offset + length;
+	while (pos < end) {
+		const entryLength = buf[pos];
+		pos++;
+		if (entryLength === 0 || pos + entryLength > end) break;
+		const entry = buf.toString("utf-8", pos, pos + entryLength);
+		pos += entryLength;
+		const eqIndex = entry.indexOf("=");
+		if (eqIndex >= 0) properties[entry.substring(0, eqIndex)] = entry.substring(eqIndex + 1);
+		else properties[entry] = "";
+	}
+	return properties;
+}
+/**
+* Decodes the data of an SRV record.
+*/
+function 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
+	};
+}
+/**
+* Decodes one resource record. The data of A, AAAA, PTR, SRV and TXT records is parsed;
+* other types keep their raw bytes.
+*
+* @returns The record and the offset after it, or null when the packet ends inside the record header.
+*/
+function decodeResource(buf, offset) {
+	const [qname, nameEnd] = decodeQName(buf, offset);
+	if (nameEnd + 10 > buf.byteLength) return null;
+	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];
+}
+/**
+* Decodes a DNS response into its header, answers and additional records. The question and
+* authority sections are skipped.
+*/
+function 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 result = decodeResource(buf, offset);
+		if (!result) break;
+		const [record, newOffset] = result;
+		answers.push(record);
+		offset = newOffset;
+	}
+	for (let i = 0; i < header.nscount; i++) {
+		const result = decodeResource(buf, offset);
+		if (!result) break;
+		offset = result[1];
+	}
+	const resources = [];
+	for (let i = 0; i < header.arcount; i++) {
+		const result = decodeResource(buf, offset);
+		if (!result) break;
+		const [record, newOffset] = result;
+		resources.push(record);
+		offset = newOffset;
+	}
+	return {
+		header,
+		answers,
+		resources
+	};
+}
+/**
+* Collects the records of several mDNS responses and joins their PTR, SRV, TXT and A records
+* into {@link MdnsService} values.
+*/
+var ServiceCollector = class {
+	/** The instance names per service type, from PTR records. */
+	#ptrMap = /* @__PURE__ */ new Map();
+	/** The SRV record per instance name. */
+	#srvMap = /* @__PURE__ */ new Map();
+	/** The TXT properties per instance name. */
+	#txtMap = /* @__PURE__ */ new Map();
+	/** The IPv4 address per hostname, from A records. */
+	#addressMap = /* @__PURE__ */ new Map();
+	/**
+	* Sorts answer and additional records into the maps by record type.
+	*/
+	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;
+		}
+	}
+	/**
+	* The services that have a PTR record, an SRV record with a nonzero port and an A record
+	* for the SRV target.
+	*/
+	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((result) => result.name === name && result.type === serviceType)) results.push({
+				name,
+				type: serviceType,
+				address,
+				port: srv.port,
+				properties: txt
+			});
+		}
+		return results;
+	}
+};
+/**
+* Opens a TCP connection to each port to wake a sleeping device before a query. The caller
+* knows which ports wake it. Resolves once every attempt settled.
+*/
+function knock(address, ports) {
+	const promises = 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();
+		});
+	}));
+	return Promise.all(promises).then(() => {});
+}
+/**
+* Queries hosts with unicast DNS-SD. It knocks on the `wakePorts` of each host first, then
+* sends the queries to port 5353 of each host every second. It stops when `timeout` ends or
+* every host answered for every service.
+*
+* @param hosts - IP addresses of the hosts to query.
+* @param timeout - Duration in seconds.
+*/
+function mdnsUnicast(hosts, services, timeout = 4, wakePorts = []) {
+	const expectedCount = hosts.length * services.length;
+	return new Promise((resolve) => {
+		const queries = createQueryPackets(services, QueryType.PTR, true);
+		const collector = new ServiceCollector();
+		const socket = createSocket("udp4");
+		let resolved = false;
+		const finish = () => {
+			if (resolved) return;
+			resolved = true;
+			clearInterval(interval);
+			try {
+				socket.close();
+			} catch {}
+			resolve(collector.services.filter((service) => services.includes(service.type)));
+		};
+		socket.on("message", (data) => {
+			try {
+				const response = decodeDnsResponse(data);
+				collector.addRecords(response.answers, response.resources);
+				if (collector.services.length >= expectedCount) finish();
+			} catch {}
+		});
+		socket.on("error", () => {});
+		for (const host of hosts) knock(host, wakePorts);
+		const sendQueries = () => {
+			for (const host of hosts) for (const query of queries) socket.send(query, MDNS_PORT$1, host);
+		};
+		let interval;
+		sendQueries();
+		interval = setInterval(sendQueries, 1e3);
+		setTimeout(finish, timeout * 1e3);
+	});
+}
+/**
+* Discovers services with multicast DNS-SD on every local interface. It binds port 5353 when
+* it can, plus one socket on a random port per interface.
+*
+* @param timeout - Duration in seconds.
+*/
+function mdnsMulticast(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.filter((service) => services.includes(service.type)));
+		};
+		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$1, address);
+					} catch {}
+					else try {
+						socket.addMembership(MDNS_ADDRESS$1);
+					} 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$1);
+			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$1, MDNS_ADDRESS$1);
+				} catch {}
+			};
+			sendQueries();
+			interval = setInterval(sendQueries, 1e3);
+			setTimeout(finish, timeout * 1e3);
+		};
+		setup();
+	});
+}
+
+//#endregion
+//#region src/discovery/discovery.ts
+const CACHE_TTL = 3e4;
+const logger = new Logger("discovery");
+/**
+* Finds the services of one mDNS service type. Each protocol package knows its own service
+* type and what its TXT record means.
+*
+* Results stay cached for 30 seconds per service type, and concurrent scans for the same types
+* share one multicast query. All instances share the cache on purpose, so protocol packages and
+* `@corewire/devices` do not each flood the network with their own query.
+*/
+var Discovery = class Discovery {
+	static #cache = /* @__PURE__ */ new Map();
+	static #scans = /* @__PURE__ */ new Map();
+	get service() {
+		return this.#service;
+	}
+	#service;
+	/** @param service - The mDNS service type, such as `_hap._tcp.local`. */
+	constructor(service) {
+		this.#service = service;
+	}
+	async find(useCache = true) {
+		const now = performance.now();
+		for (const [key, entry] of Discovery.#cache) if (entry.expiresAt <= now) Discovery.#cache.delete(key);
+		return (await Discovery.findServices([this.#service], useCache)).get(this.#service);
+	}
+	/**
+	* Scans again until a device with this id answers. Skips the cache on every attempt.
+	*
+	* @param timeout - Delay in milliseconds between attempts.
+	* @throws {DiscoveryError} If the device does not answer within `tries` attempts.
+	*/
+	async findUntil(id, tries = 10, timeout = 1e3) {
+		while (tries > 0) {
+			const devices = await this.find(false);
+			const device = devices.find((device) => device.id === id);
+			if (device) return device;
+			logger.debug(`Device '${id}' not found, retrying in ${timeout}ms...`, devices.map((device) => device.id));
+			tries--;
+			await waitFor(timeout);
+		}
+		throw new DiscoveryError(`Device '${id}' not found after several tries, aborting.`);
+	}
+	/**
+	* Queries one host with unicast DNS-SD, bypassing the cache.
+	*
+	* @param timeout - Discovery duration in seconds.
+	* @param wakePorts - Ports to knock on first, to wake a sleeping device.
+	*/
+	async findByAddress(address, timeout = 4, wakePorts = []) {
+		const match = (await mdnsUnicast([address], [this.#service], timeout, wakePorts)).find((service) => service.address === address);
+		return match ? toDiscoveryResult(match) : null;
+	}
+	/** Scans for several service types with one multicast query, shared with a scan in flight for the same types. */
+	static async findServices(services, useCache = true) {
+		const result = /* @__PURE__ */ new Map();
+		const missing = [...new Set(services)].filter((service) => {
+			const cached = Discovery.#cache.get(service);
+			if (useCache && cached && cached.expiresAt > performance.now()) {
+				result.set(service, cached.results);
+				return false;
+			}
+			return true;
+		}).sort();
+		if (missing.length === 0) return result;
+		const key = missing.join(",");
+		let scan = Discovery.#scans.get(key);
+		if (!scan) {
+			scan = mdnsMulticast(missing, 4).then((records) => {
+				const found = /* @__PURE__ */ new Map();
+				for (const service of missing) {
+					const results = records.filter((record) => record.type === service || `${record.type}.local` === service).map(toDiscoveryResult);
+					found.set(service, results);
+					Discovery.#cache.set(service, {
+						results,
+						expiresAt: performance.now() + CACHE_TTL
+					});
+				}
+				return found;
+			}).finally(() => Discovery.#scans.delete(key));
+			Discovery.#scans.set(key, scan);
+		}
+		for (const [service, records] of await scan) result.set(service, records);
+		return result;
+	}
+	static clearCache() {
+		Discovery.#cache.clear();
+	}
+	/** Knocks on each port to wake a sleeping device. */
+	static wake(address, ports) {
+		return knock(address, ports);
+	}
+};
+function toDiscoveryResult(service) {
+	const txt = service.properties;
+	const hostname = service.name.replace(/\s+/g, "-");
+	return {
+		id: `${hostname}.local`,
+		fqdn: `${hostname}.local`,
+		address: service.address,
+		txt,
+		service: {
+			port: service.port,
+			protocol: service.type.includes("._tcp") ? "tcp" : "udp",
+			type: service.type
+		}
+	};
+}
+
+//#endregion
+//#region src/discovery/responder.ts
+/** The IPv4 multicast address of mDNS, from RFC 6762. */
+const MDNS_ADDRESS = "224.0.0.251";
+const MDNS_PORT = 5353;
+/** The DNS record types that the responder writes. */
+const Type = {
+	A: 1,
+	PTR: 12,
+	TXT: 16,
+	SRV: 33
+};
+/** Class IN with the cache-flush bit set, used for records unique to this host. */
+const CLASS_FLUSH = 32769;
+/** Class IN, used for the shared PTR record. */
+const CLASS_IN = 1;
+/** The TTL of every record in seconds. */
+const TTL = 120;
+/**
+* Advertises one service with PTR, SRV, TXT and A records every 2 seconds, and again on each
+* query that mentions its type. It does not parse DNS questions, so it suits quiet test networks.
+* A controller can need the instance name and TXT record of a real device before it lists the service.
+*/
+var MdnsResponder = class MdnsResponder {
+	#logger;
+	#service;
+	#address;
+	#socket;
+	#timer;
+	/**
+	* @param address - The local IPv4 address that the A record publishes.
+	*/
+	constructor(logger, service, address = MdnsResponder.localAddress()) {
+		this.#logger = logger;
+		this.#service = service;
+		this.#address = address;
+	}
+	/** Returns the first non-internal IPv4 address of this host, or `0.0.0.0` if none is found. */
+	static localAddress() {
+		for (const nets of Object.values(networkInterfaces())) for (const net of nets ?? []) if (net.family === "IPv4" && !net.internal) return net.address;
+		return "0.0.0.0";
+	}
+	/** Binds the multicast socket and announces the service every 2 seconds. */
+	start() {
+		const socket = createSocket({
+			type: "udp4",
+			reuseAddr: true
+		});
+		socket.on("error", (error) => {
+			this.#logger.warn("[mdns]", "mDNS responder socket error", error.message);
+		});
+		socket.on("message", (data) => {
+			if ((data.readUInt16BE(2) & 32768) === 0 && data.includes(Buffer.from(this.#service.type.split(".")[0]))) this.#announce();
+		});
+		socket.bind(MDNS_PORT, () => {
+			try {
+				socket.addMembership(MDNS_ADDRESS);
+				socket.setMulticastTTL(255);
+			} catch {}
+			this.#logger.info("[mdns]", `Advertising ${this.#service.instance} ${this.#service.type} on ${this.#address}:${this.#service.port}`);
+			this.#announce();
+		});
+		this.#socket = socket;
+		this.#timer = setInterval(() => this.#announce(), 2e3);
+	}
+	/** Stops announcing and closes the socket. */
+	stop() {
+		if (this.#timer) {
+			clearInterval(this.#timer);
+			this.#timer = void 0;
+		}
+		try {
+			this.#socket?.close();
+		} catch {}
+		this.#socket = void 0;
+	}
+	/** Multicasts the full record set. */
+	#announce() {
+		if (!this.#socket) return;
+		const message = this.#buildResponse();
+		try {
+			this.#socket.send(message, MDNS_PORT, MDNS_ADDRESS);
+		} catch (error) {
+			this.#logger.warn("[mdns]", "mDNS announce failed", error.message);
+		}
+	}
+	/** Encodes the PTR, SRV, TXT and A records as one mDNS response. */
+	#buildResponse() {
+		const instanceFqdn = `${this.#service.instance}.${this.#service.type}`;
+		const header = Buffer.allocUnsafe(12);
+		header.writeUInt16BE(0, 0);
+		header.writeUInt16BE(33792, 2);
+		header.writeUInt16BE(0, 4);
+		header.writeUInt16BE(4, 6);
+		header.writeUInt16BE(0, 8);
+		header.writeUInt16BE(0, 10);
+		const ptr = record(this.#service.type, Type.PTR, CLASS_IN, encodeName(instanceFqdn));
+		const srv = record(instanceFqdn, Type.SRV, CLASS_FLUSH, encodeSrv(this.#service.port, this.#service.host));
+		const txt = record(instanceFqdn, Type.TXT, CLASS_FLUSH, encodeTxt(this.#service.txt));
+		const address = record(this.#service.host, Type.A, CLASS_FLUSH, encodeAddress(this.#address));
+		return Buffer.concat([
+			header,
+			ptr,
+			srv,
+			txt,
+			address
+		]);
+	}
+};
+/** Encodes a domain name as length-prefixed DNS labels and a closing zero byte. A label keeps at most 63 bytes. */
+function encodeName(name) {
+	const parts = [];
+	for (const label of name.split(".")) {
+		if (label.length === 0) continue;
+		const encoded = Buffer.from(label, "utf8").subarray(0, 63);
+		parts.push(Buffer.from([encoded.byteLength]), encoded);
+	}
+	parts.push(Buffer.from([0]));
+	return Buffer.concat(parts);
+}
+/** Wraps rdata in a resource record: name, type, class, TTL, rdata length and rdata. */
+function record(name, type, recordClass, rdata) {
+	const head = encodeName(name);
+	const meta = Buffer.allocUnsafe(10);
+	meta.writeUInt16BE(type, 0);
+	meta.writeUInt16BE(recordClass, 2);
+	meta.writeUInt32BE(TTL, 4);
+	meta.writeUInt16BE(rdata.byteLength, 8);
+	return Buffer.concat([
+		head,
+		meta,
+		rdata
+	]);
+}
+/** Encodes SRV rdata: priority, weight, port and the target host name. */
+function encodeSrv(port, host) {
+	const head = Buffer.allocUnsafe(6);
+	head.writeUInt16BE(0, 0);
+	head.writeUInt16BE(0, 2);
+	head.writeUInt16BE(port, 4);
+	return Buffer.concat([head, encodeName(host)]);
+}
+/** Encodes TXT rdata as a sequence of length-prefixed `key=value` strings. */
+function encodeTxt(txt) {
+	const parts = [];
+	for (const [key, value] of Object.entries(txt)) {
+		const entry = Buffer.from(value === "" ? key : `${key}=${value}`, "utf8").subarray(0, 255);
+		parts.push(Buffer.from([entry.byteLength]), entry);
+	}
+	if (parts.length === 0) parts.push(Buffer.from([0]));
+	return Buffer.concat(parts);
+}
+/** Encodes an IPv4 dotted-quad address as 4 bytes. */
+function encodeAddress(address) {
+	const octets = address.split(".").map((part) => Number.parseInt(part, 10) & 255);
+	return Buffer.from(octets.length === 4 ? octets : [
+		0,
+		0,
+		0,
+		0
+	]);
+}
+
+//#endregion
+export { Discovery, MdnsResponder, mdnsMulticast, mdnsUnicast };