matterbridge 3.4.5 → 3.4.6-dev-20251228-76bd627

package/dist/dgram/mdns.js

@@ -1,30 +1,5 @@
-/**
- * @description This file contains the class Mdns.
- * @file mdns.ts
- * @author Luca Liguori
- * @created 2025-03-22
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-// AnsiLogger imports
-import { BLUE, CYAN, db, er, GREEN, idn, MAGENTA, nf, rs } from 'node-ansi-logger';
-// Utils imports
+import { BLUE, CYAN, db, GREEN, idn, MAGENTA, nf, rs } from 'node-ansi-logger';
 import { hasParameter } from '../utils/commandLine.js';
-// Net imports
 import { Multicast } from './multicast.js';
 export var DnsRecordType;
 (function (DnsRecordType) {
@@ -116,7 +91,6 @@ export var DnsRecordType;
     DnsRecordType[DnsRecordType["DOA"] = 259] = "DOA";
     DnsRecordType[DnsRecordType["AMTRELAY"] = 260] = "AMTRELAY";
     DnsRecordType[DnsRecordType["ZONEVERSION"] = 261] = "ZONEVERSION";
-    // 262-32767 are unassigned/reserved
     DnsRecordType[DnsRecordType["TA"] = 32768] = "TA";
     DnsRecordType[DnsRecordType["DLV"] = 32769] = "DLV";
 })(DnsRecordType || (DnsRecordType = {}));
@@ -130,25 +104,34 @@ export var DnsClass;
 export var DnsClassFlag;
 (function (DnsClassFlag) {
     DnsClassFlag[DnsClassFlag["FLUSH"] = 32768] = "FLUSH";
-    // eslint-disable-next-line @typescript-eslint/no-duplicate-enum-values
     DnsClassFlag[DnsClassFlag["QU"] = 32768] = "QU";
 })(DnsClassFlag || (DnsClassFlag = {}));
+export function isMdns(message) {
+    if (!message || message.length < 12)
+        return false;
+    const id = message.readUInt16BE(0);
+    return id === 0;
+}
+export function isMdnsQuery(message) {
+    if (message.length < 12)
+        return false;
+    const id = message.readUInt16BE(0);
+    const flags = message.readUInt16BE(2);
+    const qr = (flags & 0x8000) >> 15;
+    return id == 0 && qr === 0;
+}
+export function isMdnsResponse(message) {
+    if (message.length < 12)
+        return false;
+    const id = message.readUInt16BE(0);
+    const flags = message.readUInt16BE(2);
+    const qr = (flags & 0x8000) >> 15;
+    return id == 0 && qr === 1;
+}
 export class Mdns extends Multicast {
     deviceQueries = new Map();
     deviceResponses = new Map();
     filters = [];
-    /**
-     * Creates an instance of the Mdns class.
-     *
-     * @param {string} name - The internal name of the mDNS server for the logs.
-     * @param {string} multicastAddress - The multicast address for mDNS (i.e. 224.0.0.251 for udp4 or ff02::fb for udp6).
-     * @param {number} multicastPort - The port for mDNS (i.e. 5353).
-     * @param {('udp4' | 'udp6')} socketType - The type of socket to create (either 'udp4' or 'udp6').
-     * @param {boolean} [reuseAddr] - Whether to reuse the address. Defaults to true.
-     * @param {string} [interfaceName] - The optional name of the network interface to use.
-     * @param {string} [interfaceAddress] - The optional IP address of the network interface to use.
-     * @param {string} [outgoingInterfaceAddress] - The address of the outgoing network interface.
-     */
     constructor(name, multicastAddress, multicastPort, socketType, reuseAddr = true, interfaceName, interfaceAddress, outgoingInterfaceAddress) {
         super(name, multicastAddress, multicastPort, socketType, reuseAddr, interfaceName, interfaceAddress, outgoingInterfaceAddress);
     }
@@ -168,17 +151,16 @@ export class Mdns extends Multicast {
                 this.onQuery(rinfo, result);
             }
             else {
-                const ptr = result.answers?.find((record) => record.name === '_shelly._tcp.local' && record.type === 12 /* DnsRecordType.PTR */) ||
-                    result.answers?.find((record) => record.name === '_http._tcp.local' && record.type === 12 /* DnsRecordType.PTR */) ||
-                    result.answers?.find((record) => record.type === 12 /* DnsRecordType.PTR */) ||
-                    result.answers?.find((record) => record.type === 16 /* DnsRecordType.TXT */) ||
+                const ptr = result.answers?.find((record) => record.name === '_shelly._tcp.local' && record.type === 12) ||
+                    result.answers?.find((record) => record.name === '_http._tcp.local' && record.type === 12) ||
+                    result.answers?.find((record) => record.type === 12) ||
+                    result.answers?.find((record) => record.type === 16) ||
                     result.answers
                     ? result.answers[0]
-                    : undefined; // Fallback to the first answer if no PTR or TXT found
-                this.deviceResponses.set(rinfo.address, { rinfo, response: result, dataPTR: ptr?.type === 12 /* DnsRecordType.PTR */ ? ptr?.data : ptr?.name });
+                    : undefined;
+                this.deviceResponses.set(rinfo.address, { rinfo, response: result, dataPTR: ptr?.type === 12 ? ptr?.data : ptr?.name });
                 this.onResponse(rinfo, result);
             }
-            // Apply filters if any
             if (this.filters.length > 0) {
                 this.log.debug(`mDNS message filtered out by filters: ${this.filters.join(', ')}`);
                 for (const filter of this.filters) {
@@ -200,28 +182,20 @@ export class Mdns extends Multicast {
             this.log.error(`Error decoding mDNS message: ${error instanceof Error ? error.message : error}`);
         }
     }
-    /**
-     * Decodes an mDNS message, including the header, question section, answer section,
-     * authority section, and additional section.
-     *
-     * @param {Buffer} msg - The raw mDNS message buffer.
-     * @returns {MdnsMessage} An object representing the decoded mDNS message.
-     * @throws {Error} if the message is too short.
-     */
     decodeMdnsMessage(msg) {
         if (msg.length < 12) {
             throw new Error('mDNS message too short');
         }
         const id = msg.readUInt16BE(0);
         const flags = msg.readUInt16BE(2);
-        const qr = (flags & 0x8000) >> 15; // Bit 15: 0=query, 1=response.
-        const opcode = (flags & 0x7800) >> 11; // Bits 14-11.
-        const aa = Boolean(flags & 0x0400); // Bit 10.
-        const tc = Boolean(flags & 0x0200); // Bit 9.
-        const rd = Boolean(flags & 0x0100); // Bit 8.
-        const ra = Boolean(flags & 0x0080); // Bit 7.
-        const z = (flags & 0x0070) >> 4; // Bits 6-4.
-        const rcode = flags & 0x000f; // Bits 3-0.
+        const qr = (flags & 0x8000) >> 15;
+        const opcode = (flags & 0x7800) >> 11;
+        const aa = Boolean(flags & 0x0400);
+        const tc = Boolean(flags & 0x0200);
+        const rd = Boolean(flags & 0x0100);
+        const ra = Boolean(flags & 0x0080);
+        const z = (flags & 0x0070) >> 4;
+        const rcode = flags & 0x000f;
         const qdCount = msg.readUInt16BE(4);
         const anCount = msg.readUInt16BE(6);
         const nsCount = msg.readUInt16BE(8);
@@ -246,7 +220,6 @@ export class Mdns extends Multicast {
             additionals: [],
         };
         let offset = 12;
-        // Decode the question section.
         for (let i = 0; i < qdCount; i++) {
             const qnameResult = this.decodeDnsName(msg, offset);
             const qname = qnameResult.name;
@@ -257,19 +230,16 @@ export class Mdns extends Multicast {
             offset += 2;
             mdnsMessage.questions?.push({ name: qname, type: qtype, class: qclass });
         }
-        // Decode the answer section.
         for (let i = 0; i < anCount; i++) {
             const rrResult = this.decodeResourceRecord(msg, offset);
             mdnsMessage.answers?.push(rrResult.record);
             offset = rrResult.newOffset;
         }
-        // Decode the authority (NS) section.
         for (let i = 0; i < nsCount; i++) {
             const rrResult = this.decodeResourceRecord(msg, offset);
             mdnsMessage.authorities?.push(rrResult.record);
             offset = rrResult.newOffset;
         }
-        // Decode the additional records section.
         for (let i = 0; i < arCount; i++) {
             const rrResult = this.decodeResourceRecord(msg, offset);
             mdnsMessage.additionals?.push(rrResult.record);
@@ -277,25 +247,15 @@ export class Mdns extends Multicast {
         }
         return mdnsMessage;
     }
-    /**
-     * Decodes a DNS name from a buffer, handling compression.
-     *
-     * @param {Buffer} msg - The full mDNS message buffer.
-     * @param {number} offset - The offset at which the DNS name starts.
-     * @returns {{ name: string; newOffset: number }} An object with the decoded name and the new offset.
-     * @throws {Error} if the offset exceeds the buffer length or too many iterations are performed.
-     */
     decodeDnsName(msg, offset) {
         const labels = [];
         let jumped = false;
         let originalOffset = offset;
-        let iterations = 0; // Prevent infinite loops
+        let iterations = 0;
         while (true) {
-            // Safety guard: prevent infinite loops in malformed messages.
             if (iterations++ > 1000) {
                 throw new Error('Too many iterations while decoding DNS name. Possible malformed message.');
             }
-            // Check that offset is within buffer bounds.
             if (offset >= msg.length) {
                 throw new Error('Offset exceeds buffer length while decoding DNS name.');
             }
@@ -304,9 +264,7 @@ export class Mdns extends Multicast {
                 offset++;
                 break;
             }
-            // Check for pointer (first two bits are 11)
             if ((len & 0xc0) === 0xc0) {
-                // Ensure the pointer has two bytes available.
                 if (offset + 1 >= msg.length) {
                     throw new Error('Incomplete pointer encountered while decoding DNS name.');
                 }
@@ -319,7 +277,6 @@ export class Mdns extends Multicast {
                 continue;
             }
             offset++;
-            // Check that the label length doesn't go beyond the buffer.
             if (offset + len > msg.length) {
                 throw new Error('Label length exceeds buffer bounds while decoding DNS name.');
             }
@@ -328,15 +285,6 @@ export class Mdns extends Multicast {
         }
         return { name: labels.join('.'), newOffset: jumped ? originalOffset : offset };
     }
-    /**
-     * Encodes a domain name into the DNS label format.
-     *
-     * For example, "example.local" becomes:
-     * [7] "example" [5] "local" [0]
-     *
-     * @param {string} name - The domain name to encode.
-     * @returns {Buffer} The encoded domain name as a Buffer.
-     */
     encodeDnsName(name) {
         const labels = name.split('.');
         const buffers = labels.map((label) => {
@@ -344,25 +292,8 @@ export class Mdns extends Multicast {
             lenBuf.writeUInt8(label.length, 0);
             return Buffer.concat([lenBuf, Buffer.from(label)]);
         });
-        // Append the null byte to terminate the name.
         return Buffer.concat([...buffers, Buffer.from([0])]);
     }
-    /**
-     * Encodes TXT record RDATA.
-     *
-     * In DNS/mDNS, TXT RDATA is a sequence of one or more <character-string>,
-     * each encoded as: [length byte][UTF-8 bytes].
-     *
-     * @param {string[]} txt - Array of TXT entries, e.g. ["key=value", "path=/"].
-     * @returns {Buffer} Encoded TXT RDATA.
-     * @throws {Error} If any entry exceeds 255 bytes.
-     *
-     * @example
-     * const txtRdata = mdns.encodeTxtRdata(['txtvers=1', 'path=/']);
-     * mdns.sendResponse([
-     *   { name: 'example._http._tcp.local', rtype: DnsRecordType.TXT, rclass: DnsClass.IN | DnsClassFlag.FLUSH, ttl: 120, rdata: txtRdata },
-     * ]);
-     */
     encodeTxtRdata(txt) {
         const parts = txt.map((entry) => {
             const value = Buffer.from(entry, 'utf8');
@@ -372,21 +303,6 @@ export class Mdns extends Multicast {
         });
         return Buffer.concat(parts);
     }
-    /**
-     * Encodes SRV record RDATA.
-     *
-     * SRV RDATA layout (RFC 2782):
-     * - priority (2 bytes)
-     * - weight   (2 bytes)
-     * - port     (2 bytes)
-     * - target   (DNS name)
-     *
-     * @param {number} priority - SRV priority.
-     * @param {number} weight - SRV weight.
-     * @param {number} port - Service port.
-     * @param {string} target - Target hostname (e.g. "matterbridge.local").
-     * @returns {Buffer} Encoded SRV RDATA.
-     */
     encodeSrvRdata(priority, weight, port, target) {
         const fixed = Buffer.alloc(6);
         fixed.writeUInt16BE(priority, 0);
@@ -394,13 +310,6 @@ export class Mdns extends Multicast {
         fixed.writeUInt16BE(port, 4);
         return Buffer.concat([fixed, this.encodeDnsName(target)]);
     }
-    /**
-     * Encodes an IPv4 address for an A record RDATA (4 bytes).
-     *
-     * @param {string} ipv4 - IPv4 address, e.g. "192.168.1.10".
-     * @returns {Buffer} 4-byte buffer.
-     * @throws {Error} If the address is not a valid dotted-quad.
-     */
     encodeA(ipv4) {
         const parts = ipv4.split('.').map((p) => Number(p));
         if (parts.length !== 4 || parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) {
@@ -408,19 +317,8 @@ export class Mdns extends Multicast {
         }
         return Buffer.from(parts);
     }
-    /**
-     * Encodes an IPv6 address for an AAAA record RDATA (16 bytes).
-     *
-     * Supports the "::" zero-compression form and ignores an optional scope id
-     * suffix (e.g. "fe80::1%12" or "fe80::1%eth0").
-     *
-     * @param {string} ipv6WithOptionalScope - IPv6 address (optionally with scope id).
-     * @returns {Buffer} 16-byte buffer.
-     * @throws {Error} If the address is not a valid IPv6 literal.
-     */
     encodeAAAA(ipv6WithOptionalScope) {
         const ipv6 = ipv6WithOptionalScope.split('%')[0];
-        // Expand IPv6 to 8 groups of 16-bit words.
         const [left, right] = ipv6.split('::');
         const leftParts = left ? left.split(':').filter(Boolean) : [];
         const rightParts = right ? right.split(':').filter(Boolean) : [];
@@ -430,9 +328,10 @@ export class Mdns extends Multicast {
                 throw new Error(`Invalid IPv6 address: ${ipv6WithOptionalScope}`);
             const groups = [...leftParts, ...Array(missing).fill('0'), ...rightParts];
             return Buffer.from(groups.flatMap((g) => {
-                const word = parseInt(g || '0', 16);
-                if (!Number.isFinite(word) || word < 0 || word > 0xffff)
+                const word = parseInt(g, 16);
+                if (!Number.isFinite(word) || word < 0 || word > 0xffff) {
                     throw new Error(`Invalid IPv6 group: ${g}`);
+                }
                 return [(word >> 8) & 0xff, word & 0xff];
             }));
         }
@@ -440,25 +339,18 @@ export class Mdns extends Multicast {
         if (groups.length !== 8)
             throw new Error(`Invalid IPv6 address: ${ipv6WithOptionalScope}`);
         return Buffer.from(groups.flatMap((g) => {
-            const word = parseInt(g || '0', 16);
+            if (!g)
+                throw new Error(`Invalid IPv6 group: ${g}`);
+            const word = parseInt(g, 16);
             if (!Number.isFinite(word) || word < 0 || word > 0xffff)
                 throw new Error(`Invalid IPv6 group: ${g}`);
             return [(word >> 8) & 0xff, word & 0xff];
         }));
     }
-    /**
-     * Decodes a DNS resource record.
-     *
-     * @param {Buffer} msg - The full mDNS message buffer.
-     * @param {number} offset - The offset at which the resource record starts.
-     * @returns {{ record: MdnsRecord; newOffset: number }} An object containing the decoded record and the new offset.
-     */
     decodeResourceRecord(msg, offset) {
-        // Decode the NAME field (which may be compressed)
         const nameResult = this.decodeDnsName(msg, offset);
         const name = nameResult.name;
         offset = nameResult.newOffset;
-        // Read TYPE (16 bits), CLASS (16 bits), TTL (32 bits), and RDLENGTH (16 bits)
         const type = msg.readUInt16BE(offset);
         offset += 2;
         const rrclass = msg.readUInt16BE(offset);
@@ -468,14 +360,12 @@ export class Mdns extends Multicast {
         const rdlength = msg.readUInt16BE(offset);
         offset += 2;
         let data = '';
-        if (type === 12 /* DnsRecordType.PTR */) {
-            // PTR record (type 12): decode its RDATA as a domain name.
+        if (type === 12) {
             const ptrResult = this.decodeDnsName(msg, offset);
             data = ptrResult.name;
             offset += rdlength;
         }
-        else if (type === 16 /* DnsRecordType.TXT */) {
-            // TXT record: may consist of one or more length-prefixed strings.
+        else if (type === 16) {
             const txtStrings = [];
             const end = offset + rdlength;
             while (offset < end) {
@@ -487,8 +377,7 @@ export class Mdns extends Multicast {
             }
             data = txtStrings.join(', ');
         }
-        else if (type === 33 /* DnsRecordType.SRV */) {
-            // SRV record (type === 33): consists of 2 bytes for priority, 2 for weight, 2 for port, followed by the target domain name.
+        else if (type === 33) {
             const priority = msg.readUInt16BE(offset);
             const weight = msg.readUInt16BE(offset + 2);
             const port = msg.readUInt16BE(offset + 4);
@@ -502,16 +391,13 @@ export class Mdns extends Multicast {
             });
             offset = srvTargetResult.newOffset;
         }
-        else if (type === 1 /* DnsRecordType.A */) {
-            // A record (type 1): an IPv4 address stored in 4 bytes.
+        else if (type === 1) {
             const ipBytes = msg.slice(offset, offset + 4);
             data = Array.from(ipBytes).join('.');
             offset += 4;
         }
-        else if (type === 28 /* DnsRecordType.AAAA */) {
-            // AAAA record (type 28): IPv6 address stored in 16 bytes.
+        else if (type === 28) {
             const ipBytes = msg.slice(offset, offset + 16);
-            // Convert the 16 bytes into an IPv6 address string (colon-separated)
             const ipv6Parts = [];
             for (let i = 0; i < 16; i += 2) {
                 ipv6Parts.push(ipBytes.readUInt16BE(i).toString(16));
@@ -519,14 +405,10 @@ export class Mdns extends Multicast {
             data = ipv6Parts.join(':');
             offset += 16;
         }
-        else if (type === 47 /* DnsRecordType.NSEC */) {
-            // NSEC record: RDATA consists of:
-            //   - Next Domain Name (in DNS label format)
-            //   - Type Bit Maps (variable length)
+        else if (type === 47) {
             const { name: nextDomain, newOffset } = this.decodeDnsName(msg, offset);
             const nextDomainLength = newOffset - offset;
             offset = newOffset;
-            // Calculate the remaining length for the type bit maps.
             const bitmapLength = rdlength - nextDomainLength;
             const bitmapData = msg.slice(offset, offset + bitmapLength);
             const types = [];
@@ -553,7 +435,6 @@ export class Mdns extends Multicast {
             offset += bitmapLength;
         }
         else {
-            // Fall back
             data = msg.slice(offset, offset + rdlength).toString('hex');
             offset += rdlength;
         }
@@ -562,234 +443,185 @@ export class Mdns extends Multicast {
             newOffset: offset,
         };
     }
-    /**
-     * Sends a DNS query with multiple questions.
-     *
-     * @param {Array<{ name: string; type: number; class: number; unicastResponse?: boolean }>} questions - Array of questions
-     * to include in the query.
-     * @returns {Buffer<ArrayBuffer>} The constructed query buffer.
-     *
-     * @remarks
-     * Each question should have a name (e.g., "_http._tcp.local"), type (e.g., DnsRecordType.PTR), class (e.g., DnsClass.IN),
-     * and an optional unicastResponse flag (this will add the DnsClassFlag.QU flag to the query).
-     */
     sendQuery(questions) {
         const header = Buffer.alloc(12);
-        header.writeUInt16BE(0, 0); // ID
-        header.writeUInt16BE(0, 2); // Flags
-        header.writeUInt16BE(questions.length, 4); // QDCOUNT
-        header.writeUInt16BE(0, 6); // ANCOUNT
-        header.writeUInt16BE(0, 8); // NSCOUNT
-        header.writeUInt16BE(0, 10); // ARCOUNT
+        header.writeUInt16BE(0, 0);
+        header.writeUInt16BE(0, 2);
+        header.writeUInt16BE(questions.length, 4);
+        header.writeUInt16BE(0, 6);
+        header.writeUInt16BE(0, 8);
+        header.writeUInt16BE(0, 10);
         const questionBuffers = questions.map(({ name, type: qtype, class: qclass, unicastResponse = false }) => {
             const qname = this.encodeDnsName(name);
             const qfields = Buffer.alloc(4);
             qfields.writeUInt16BE(qtype, 0);
-            qfields.writeUInt16BE(unicastResponse ? qclass | 32768 /* DnsClassFlag.QU */ : qclass, 2);
+            qfields.writeUInt16BE(unicastResponse ? qclass | 32768 : qclass, 2);
             return Buffer.concat([qname, qfields]);
         });
         const query = Buffer.concat([header, ...questionBuffers]);
         if (hasParameter('v') || hasParameter('verbose')) {
             const decoded = this.decodeMdnsMessage(query);
-            this.logMdnsMessage(decoded);
+            this.logMdnsMessage(decoded, undefined, 'Sending query mDNS message');
         }
         this.socket.send(query, 0, query.length, this.multicastPort, this.multicastAddress, (error) => {
             if (error) {
-                this.log.error(`Dgram mDNS server failed to send query message: ${error.message}`);
+                this.log.error(`Dgram mDNS server failed to send query message: ${error instanceof Error ? error.message : error}`);
                 this.emit('error', error);
             }
             else {
-                const names = questions
-                    .map((q) => `- name ${MAGENTA}${q.name}${db} type ${MAGENTA}${this.dnsTypeToString(q.type)}${db} class ${MAGENTA}${this.dnsQuestionClassToString(q.class)}${db} unicastResponse ${MAGENTA}${q.unicastResponse}${db}`)
-                    .join('\n');
-                this.log.debug(`Dgram mDNS server sent query message:\n${names}`);
+                this.log.debug(`Dgram mDNS server sent query message`);
                 this.emit('sent', query, this.multicastAddress, this.multicastPort);
             }
         });
         return query;
     }
-    /**
-     * Constructs an mDNS response packet and sends it to the multicast address and port.
-     *
-     * @param {Array<{ name: string; rtype: number; rclass: number; ttl: number; rdata: Buffer }>} answers - Array of answer records.
-     * @returns {Buffer<ArrayBuffer>} The constructed response buffer.
-     *
-     * @example
-     *   const ptrRdata = mdnsIpv4.encodeDnsName('matterbridge._http._tcp.local');
-     *   mdnsIpv4.sendResponse([{ name: '_http._tcp.local', rtype: DnsRecordType.PTR, rclass: DnsClass.IN, ttl: 120, rdata: ptrRdata }]);
-     */
     sendResponse(answers) {
         if (!Array.isArray(answers) || answers.length === 0) {
             throw new Error('sendResponse requires a non-empty answers array');
         }
-        // Create a 12-byte DNS header.
         const header = Buffer.alloc(12);
-        header.writeUInt16BE(0, 0); // ID is set to 0 in mDNS.
-        // Set flags: QR (response) bit and AA (authoritative answer) bit.
+        header.writeUInt16BE(0, 0);
         header.writeUInt16BE(0x8400, 2);
-        header.writeUInt16BE(0, 4); // QDCOUNT: 0 questions in response.
-        header.writeUInt16BE(answers.length, 6); // ANCOUNT: number of answer records.
-        header.writeUInt16BE(0, 8); // NSCOUNT: 0 authority records.
-        header.writeUInt16BE(0, 10); // ARCOUNT: 0 additional records.
+        header.writeUInt16BE(0, 4);
+        header.writeUInt16BE(answers.length, 6);
+        header.writeUInt16BE(0, 8);
+        header.writeUInt16BE(0, 10);
         const answerBuffers = answers.map(({ name, rtype, rclass, ttl, rdata }) => {
-            // Encode the domain name in DNS label format.
             const aname = this.encodeDnsName(name);
-            // Prepare the fixed part of the answer record:
-            // - 2 bytes for qtype,
-            // - 2 bytes for qclass,
-            // - 4 bytes for TTL,
-            // - 2 bytes for RDLENGTH (length of the rdata).
             const answerFixed = Buffer.alloc(10);
-            answerFixed.writeUInt16BE(rtype, 0); // Record type.
-            answerFixed.writeUInt16BE(rclass, 2); // Record class.
-            answerFixed.writeUInt32BE(ttl, 4); // Time-to-live.
-            answerFixed.writeUInt16BE(rdata.length, 8); // RDLENGTH.
-            // Concatenate the answer: encoded name, fixed fields, and resource data.
+            answerFixed.writeUInt16BE(rtype, 0);
+            answerFixed.writeUInt16BE(rclass, 2);
+            answerFixed.writeUInt32BE(ttl, 4);
+            answerFixed.writeUInt16BE(rdata.length, 8);
             return Buffer.concat([aname, answerFixed, rdata]);
         });
-        // Concatenate header and answers to form the complete mDNS response packet.
         const response = Buffer.concat([header, ...answerBuffers]);
         if (hasParameter('v') || hasParameter('verbose')) {
             const decoded = this.decodeMdnsMessage(response);
-            this.logMdnsMessage(decoded);
+            this.logMdnsMessage(decoded, undefined, 'Sending response mDNS message');
         }
-        // Send the response packet via the socket.
         this.socket.send(response, 0, response.length, this.multicastPort, this.multicastAddress, (error) => {
             if (error) {
-                const items = answers.map((a) => `- name ${MAGENTA}${a.name}${er} type ${MAGENTA}${this.dnsTypeToString(a.rtype)}${er} class ${MAGENTA}${this.dnsResponseClassToString(a.rclass)}${er} ttl ${MAGENTA}${a.ttl}${er}`).join('\n');
-                this.log.error(`Dgram mDNS server failed to send response message (${MAGENTA}${answers.length}${er} answers): ${error instanceof Error ? error.message : error}\n${items}`);
+                this.log.error(`Dgram mDNS server failed to send response message: ${error instanceof Error ? error.message : error}`);
                 this.emit('error', error);
             }
             else {
-                const items = answers.map((a) => `- name ${MAGENTA}${a.name}${db} type ${MAGENTA}${this.dnsTypeToString(a.rtype)}${db} class ${MAGENTA}${this.dnsResponseClassToString(a.rclass)}${db} ttl ${MAGENTA}${a.ttl}${db}`).join('\n');
-                this.log.debug(`Dgram mDNS server sent response message:\n${items}`);
+                this.log.debug(`Dgram mDNS server sent response message`);
                 this.emit('sent', response, this.multicastAddress, this.multicastPort);
             }
         });
         return response;
     }
-    /**
-     * Converts a DNS record type numeric value to its string representation.
-     *
-     * @param {number} type - The numeric DNS record type.
-     * @returns {string} The string representation of the record type.
-     */
     dnsTypeToString(type) {
         const typeMap = {
-            [1 /* DnsRecordType.A */]: 'A',
-            [2 /* DnsRecordType.NS */]: 'NS',
-            [3 /* DnsRecordType.MD */]: 'MD',
-            [4 /* DnsRecordType.MF */]: 'MF',
-            [5 /* DnsRecordType.CNAME */]: 'CNAME',
-            [6 /* DnsRecordType.SOA */]: 'SOA',
-            [7 /* DnsRecordType.MB */]: 'MB',
-            [8 /* DnsRecordType.MG */]: 'MG',
-            [9 /* DnsRecordType.MR */]: 'MR',
-            [10 /* DnsRecordType.NULL */]: 'NULL',
-            [11 /* DnsRecordType.WKS */]: 'WKS',
-            [12 /* DnsRecordType.PTR */]: 'PTR',
-            [13 /* DnsRecordType.HINFO */]: 'HINFO',
-            [14 /* DnsRecordType.MINFO */]: 'MINFO',
-            [15 /* DnsRecordType.MX */]: 'MX',
-            [16 /* DnsRecordType.TXT */]: 'TXT',
-            [17 /* DnsRecordType.RP */]: 'RP',
-            [18 /* DnsRecordType.AFSDB */]: 'AFSDB',
-            [19 /* DnsRecordType.X25 */]: 'X25',
-            [20 /* DnsRecordType.ISDN */]: 'ISDN',
-            [21 /* DnsRecordType.RT */]: 'RT',
-            [22 /* DnsRecordType.NSAP */]: 'NSAP',
-            [23 /* DnsRecordType.NSAP_PTR */]: 'NSAP_PTR',
-            [24 /* DnsRecordType.SIG */]: 'SIG',
-            [25 /* DnsRecordType.KEY */]: 'KEY',
-            [26 /* DnsRecordType.PX */]: 'PX',
-            [27 /* DnsRecordType.GPOS */]: 'GPOS',
-            [28 /* DnsRecordType.AAAA */]: 'AAAA',
-            [29 /* DnsRecordType.LOC */]: 'LOC',
-            [30 /* DnsRecordType.NXT */]: 'NXT',
-            [31 /* DnsRecordType.EID */]: 'EID',
-            [32 /* DnsRecordType.NIMLOC */]: 'NIMLOC',
-            [33 /* DnsRecordType.SRV */]: 'SRV',
-            [34 /* DnsRecordType.ATMA */]: 'ATMA',
-            [35 /* DnsRecordType.NAPTR */]: 'NAPTR',
-            [36 /* DnsRecordType.KX */]: 'KX',
-            [37 /* DnsRecordType.CERT */]: 'CERT',
-            [38 /* DnsRecordType.A6 */]: 'A6',
-            [39 /* DnsRecordType.DNAME */]: 'DNAME',
-            [40 /* DnsRecordType.SINK */]: 'SINK',
-            [41 /* DnsRecordType.OPT */]: 'OPT',
-            [42 /* DnsRecordType.APL */]: 'APL',
-            [43 /* DnsRecordType.DS */]: 'DS',
-            [44 /* DnsRecordType.SSHFP */]: 'SSHFP',
-            [45 /* DnsRecordType.IPSECKEY */]: 'IPSECKEY',
-            [46 /* DnsRecordType.RRSIG */]: 'RRSIG',
-            [47 /* DnsRecordType.NSEC */]: 'NSEC',
-            [48 /* DnsRecordType.DNSKEY */]: 'DNSKEY',
-            [49 /* DnsRecordType.DHCID */]: 'DHCID',
-            [50 /* DnsRecordType.NSEC3 */]: 'NSEC3',
-            [51 /* DnsRecordType.NSEC3PARAM */]: 'NSEC3PARAM',
-            [52 /* DnsRecordType.TLSA */]: 'TLSA',
-            [53 /* DnsRecordType.SMIMEA */]: 'SMIMEA',
-            [55 /* DnsRecordType.HIP */]: 'HIP',
-            [56 /* DnsRecordType.NINFO */]: 'NINFO',
-            [57 /* DnsRecordType.RKEY */]: 'RKEY',
-            [58 /* DnsRecordType.TALINK */]: 'TALINK',
-            [59 /* DnsRecordType.CDS */]: 'CDS',
-            [60 /* DnsRecordType.CDNSKEY */]: 'CDNSKEY',
-            [61 /* DnsRecordType.OPENPGPKEY */]: 'OPENPGPKEY',
-            [62 /* DnsRecordType.CSYNC */]: 'CSYNC',
-            [63 /* DnsRecordType.ZONEMD */]: 'ZONEMD',
-            [64 /* DnsRecordType.SVCB */]: 'SVCB',
-            [65 /* DnsRecordType.HTTPS */]: 'HTTPS',
-            [99 /* DnsRecordType.SPF */]: 'SPF',
-            [100 /* DnsRecordType.UINFO */]: 'UINFO',
-            [101 /* DnsRecordType.UID */]: 'UID',
-            [102 /* DnsRecordType.GID */]: 'GID',
-            [103 /* DnsRecordType.UNSPEC */]: 'UNSPEC',
-            [104 /* DnsRecordType.NID */]: 'NID',
-            [105 /* DnsRecordType.L32 */]: 'L32',
-            [106 /* DnsRecordType.L64 */]: 'L64',
-            [107 /* DnsRecordType.LP */]: 'LP',
-            [108 /* DnsRecordType.EUI48 */]: 'EUI48',
-            [109 /* DnsRecordType.EUI64 */]: 'EUI64',
-            [249 /* DnsRecordType.TKEY */]: 'TKEY',
-            [250 /* DnsRecordType.TSIG */]: 'TSIG',
-            [251 /* DnsRecordType.IXFR */]: 'IXFR',
-            [252 /* DnsRecordType.AXFR */]: 'AXFR',
-            [253 /* DnsRecordType.MAILB */]: 'MAILB',
-            [254 /* DnsRecordType.MAILA */]: 'MAILA',
-            [255 /* DnsRecordType.ANY */]: 'ANY',
-            [256 /* DnsRecordType.URI */]: 'URI',
-            [257 /* DnsRecordType.CAA */]: 'CAA',
-            [258 /* DnsRecordType.AVC */]: 'AVC',
-            [259 /* DnsRecordType.DOA */]: 'DOA',
-            [260 /* DnsRecordType.AMTRELAY */]: 'AMTRELAY',
-            [261 /* DnsRecordType.ZONEVERSION */]: 'ZONEVERSION',
-            [32768 /* DnsRecordType.TA */]: 'TA',
-            [32769 /* DnsRecordType.DLV */]: 'DLV',
+            [1]: 'A',
+            [2]: 'NS',
+            [3]: 'MD',
+            [4]: 'MF',
+            [5]: 'CNAME',
+            [6]: 'SOA',
+            [7]: 'MB',
+            [8]: 'MG',
+            [9]: 'MR',
+            [10]: 'NULL',
+            [11]: 'WKS',
+            [12]: 'PTR',
+            [13]: 'HINFO',
+            [14]: 'MINFO',
+            [15]: 'MX',
+            [16]: 'TXT',
+            [17]: 'RP',
+            [18]: 'AFSDB',
+            [19]: 'X25',
+            [20]: 'ISDN',
+            [21]: 'RT',
+            [22]: 'NSAP',
+            [23]: 'NSAP_PTR',
+            [24]: 'SIG',
+            [25]: 'KEY',
+            [26]: 'PX',
+            [27]: 'GPOS',
+            [28]: 'AAAA',
+            [29]: 'LOC',
+            [30]: 'NXT',
+            [31]: 'EID',
+            [32]: 'NIMLOC',
+            [33]: 'SRV',
+            [34]: 'ATMA',
+            [35]: 'NAPTR',
+            [36]: 'KX',
+            [37]: 'CERT',
+            [38]: 'A6',
+            [39]: 'DNAME',
+            [40]: 'SINK',
+            [41]: 'OPT',
+            [42]: 'APL',
+            [43]: 'DS',
+            [44]: 'SSHFP',
+            [45]: 'IPSECKEY',
+            [46]: 'RRSIG',
+            [47]: 'NSEC',
+            [48]: 'DNSKEY',
+            [49]: 'DHCID',
+            [50]: 'NSEC3',
+            [51]: 'NSEC3PARAM',
+            [52]: 'TLSA',
+            [53]: 'SMIMEA',
+            [55]: 'HIP',
+            [56]: 'NINFO',
+            [57]: 'RKEY',
+            [58]: 'TALINK',
+            [59]: 'CDS',
+            [60]: 'CDNSKEY',
+            [61]: 'OPENPGPKEY',
+            [62]: 'CSYNC',
+            [63]: 'ZONEMD',
+            [64]: 'SVCB',
+            [65]: 'HTTPS',
+            [99]: 'SPF',
+            [100]: 'UINFO',
+            [101]: 'UID',
+            [102]: 'GID',
+            [103]: 'UNSPEC',
+            [104]: 'NID',
+            [105]: 'L32',
+            [106]: 'L64',
+            [107]: 'LP',
+            [108]: 'EUI48',
+            [109]: 'EUI64',
+            [249]: 'TKEY',
+            [250]: 'TSIG',
+            [251]: 'IXFR',
+            [252]: 'AXFR',
+            [253]: 'MAILB',
+            [254]: 'MAILA',
+            [255]: 'ANY',
+            [256]: 'URI',
+            [257]: 'CAA',
+            [258]: 'AVC',
+            [259]: 'DOA',
+            [260]: 'AMTRELAY',
+            [261]: 'ZONEVERSION',
+            [32768]: 'TA',
+            [32769]: 'DLV',
         };
         return typeMap[type] ?? `TYPE${type}`;
     }
-    /**
-     * Converts a DNS response class numeric value to its string representation.
-     *
-     * @param {number} cls - The numeric DNS class.
-     * @returns {string} The string representation of the DNS class.
-     */
     dnsResponseClassToString(cls) {
-        const isFlush = !!(cls & 32768 /* DnsClassFlag.FLUSH */);
+        const isFlush = !!(cls & 32768);
         const baseClass = cls & 0x7fff;
         let classStr;
         switch (baseClass) {
-            case 1 /* DnsClass.IN */:
+            case 1:
                 classStr = 'IN';
                 break;
-            case 3 /* DnsClass.CH */:
+            case 3:
                 classStr = 'CH';
                 break;
-            case 4 /* DnsClass.HS */:
+            case 4:
                 classStr = 'HS';
                 break;
-            case 255 /* DnsClass.ANY */:
+            case 255:
                 classStr = 'ANY';
                 break;
             default:
@@ -797,28 +629,21 @@ export class Mdns extends Multicast {
         }
         return isFlush ? `${classStr}|FLUSH` : classStr;
     }
-    /**
-     * Converts a DNS question class to a human-readable string.
-     * Adds support for mDNS QU (unicast-response) bit.
-     *
-     * @param {number} cls - The numeric question class.
-     * @returns {string} The string representation, e.g. "IN|QU"
-     */
     dnsQuestionClassToString(cls) {
-        const isQU = !!(cls & 32768 /* DnsClassFlag.QU */);
+        const isQU = !!(cls & 32768);
         const baseClass = cls & 0x7fff;
         let classStr;
         switch (baseClass) {
-            case 1 /* DnsClass.IN */:
+            case 1:
                 classStr = 'IN';
                 break;
-            case 3 /* DnsClass.CH */:
+            case 3:
                 classStr = 'CH';
                 break;
-            case 4 /* DnsClass.HS */:
+            case 4:
                 classStr = 'HS';
                 break;
-            case 255 /* DnsClass.ANY */:
+            case 255:
                 classStr = 'ANY';
                 break;
             default:
@@ -826,13 +651,6 @@ export class Mdns extends Multicast {
         }
         return isQU ? `${classStr}|QU` : classStr;
     }
-    /**
-     * Logs the decoded mDNS message header.
-     *
-     * @param {MdnsMessage} msg - The mDNS message header object.
-     * @param {AnsiLogger} [log] - The logger to use (defaults to this.log).
-     * @param {string} [text] - Optional additional text to include in the log.
-     */
     logMdnsMessage(msg, log = this.log, text = 'Decoded mDNS message') {
         log.info(`${text}: ID ${MAGENTA}${msg.id}${nf}, QR ${GREEN}${msg.qr === 0 ? 'Query' : 'Response'}${nf}, OPCODE ${MAGENTA}${msg.opcode}${nf}, AA ${MAGENTA}${msg.aa}${nf}, TC ${MAGENTA}${msg.tc}${nf}, RD ${MAGENTA}${msg.rd}${nf}, RA ${MAGENTA}${msg.ra}${nf}, Z ${MAGENTA}${msg.z}${nf}, RCODE ${MAGENTA}${msg.rcode}${nf}, QDCount ${MAGENTA}${msg.qdCount}${nf}, ANCount ${MAGENTA}${msg.anCount}${nf}, NSCount ${MAGENTA}${msg.nsCount}${nf}, ARCount ${MAGENTA}${msg.arCount}${nf}`);
         msg.questions?.forEach((question) => {
@@ -849,14 +667,9 @@ export class Mdns extends Multicast {
         });
         log.info(`---\n`);
     }
-    /**
-     * Logs the discovered devices from the mDNS queries and responses.
-     */
     logDevices() {
         this.log.info(`Discovered query devices: ${MAGENTA}${this.deviceQueries.size}${nf}`);
-        // Collect devices into an array
         const deviceQueryArray = Array.from(this.deviceQueries.entries());
-        // Sort the array by numeric value of the IP address
         deviceQueryArray.sort(([addressA], [addressB]) => {
             const partsA = addressA.split('.').map(Number);
             const partsB = addressB.split('.').map(Number);
@@ -865,17 +678,13 @@ export class Mdns extends Multicast {
                 if (diff !== 0)
                     return diff;
             }
-            // istanbul ignore next
             return 0;
         });
-        // Log the sorted devices
         deviceQueryArray.forEach(([rinfo, response]) => {
             this.log.info(`- ${MAGENTA}${rinfo}${nf} family ${BLUE}${response.rinfo.family}${nf} address ${BLUE}${response.rinfo.address}${nf} port ${BLUE}${response.rinfo.port}${nf}`);
         });
         this.log.info(`Discovered response devices: ${MAGENTA}${this.deviceResponses.size}${nf}`);
-        // Collect devices into an array
         const deviceResponseArray = Array.from(this.deviceResponses.entries());
-        // Sort the array by numeric value of the IP address
         deviceResponseArray.sort(([addressA], [addressB]) => {
             const partsA = addressA.split(/[:.]/).map((part) => parseInt(part, 16));
             const partsB = addressB.split(/[:.]/).map((part) => parseInt(part, 16));
@@ -884,13 +693,10 @@ export class Mdns extends Multicast {
                 if (diff !== 0)
                     return diff;
             }
-            // istanbul ignore next
             return 0;
         });
-        // Log the sorted devices
         deviceResponseArray.forEach(([rinfo, response]) => {
             this.log.info(`- ${MAGENTA}${rinfo}${nf} family ${BLUE}${response.rinfo.family}${nf} address ${BLUE}${response.rinfo.address}${nf} port ${BLUE}${response.rinfo.port}${nf} PTR ${GREEN}${response.dataPTR}${nf}`);
         });
     }
 }
-//# sourceMappingURL=mdns.js.map