matterbridge 3.4.5-dev-20251225-742588e → 3.4.6-dev-20251228-e06f048

package/CHANGELOG.md

@@ -28,7 +28,19 @@ Advantages:
 - individual plugin isolation in childbridge mode;
 - ability to update the plugin in childbridge mode without restarting matterbridge;
 
-## [3.4.5] - Dev branch
+## [3.4.6] - Dev branch
+
+### Added
+
+### Changed
+
+- [package]: Updated dependencies.
+
+### Fixed
+
+<a href="https://www.buymeacoffee.com/luligugithub"><img src="https://matterbridge.io/bmc-button.svg" alt="Buy me a coffee" width="80"></a>
+
+## [3.4.5] - 2025-12-27
 
 ### Added
 
@@ -36,17 +48,14 @@ Advantages:
 - [DevContainer]: Since is now possible to pair from Dev Container, named volumes have been added to persist storage and plugins across rebuilds.
 - [mb_mdns]: Added query and advertise interval. Improved help for easy mDNS testing.
 - [mb_mdns]: Advertise full DNS-SD record set (PTR/SRV/TXT/A/AAAA) for matterbridge.\_http.\_tcp.local on port 8283.
-- [mdns]: Added TXT/SRV/A/AAAA encoders into the Mdns class.
-- [mb_mdns]: Added broadcast parameter to allow advertising when multicast is not available.
-- [mb_mdns]: Added \_matterbridge.\_tcp.local to query and advertise.
-- [mb_mdns]: Added localhost parameter to send unicast messages to localhost.
-- [mb_mdns]: Added unicastIpv4 parameter to send unicast messages.
-- [mb_mdns]: Added unicastIpv6 parameter to send unicast messages.
+- [Mdns]: Added TXT/SRV/A/AAAA encoders into the Mdns class.
+- [Mdns]: Mdns.sendResponse now accepts an array and sends multi-answer responses.
+- [MdnsReflectorClient]: Added MdnsReflectorClient class.
+- [MdnsReflectorServer]: Added MdnsReflectorServer class.
 
 ### Changed
 
 - [package]: Updated dependencies.
-- [mdns]: Mdns.sendResponse now accepts an array and sends multi-answer responses.
 
 ### Fixed
 

package/dist/dgram/dgram.js

@@ -2,7 +2,11 @@ import dgram from 'node:dgram';
 import EventEmitter from 'node:events';
 import os from 'node:os';
 import { AnsiLogger, BLUE, db, idn, nf, rs } from 'node-ansi-logger';
+import { hasParameter } from '../utils/commandLine.js';
 export class Dgram extends EventEmitter {
+    verbose = hasParameter('v') || hasParameter('verbose');
+    debug = hasParameter('d') || hasParameter('debug') || hasParameter('v') || hasParameter('verbose');
+    silent = hasParameter('s') || hasParameter('silent');
     log;
     socket;
     bound = false;
@@ -12,7 +16,7 @@ export class Dgram extends EventEmitter {
     interfaceNetmask;
     constructor(name, socketType, reuseAddr = true, interfaceName, interfaceAddress) {
         super();
-        this.log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: "debug" });
+        this.log = new AnsiLogger({ logName: name, logTimestampFormat: 4, logLevel: this.debug ? "debug" : this.silent ? "notice" : "info" });
         this.socket = dgram.createSocket({ type: socketType, reuseAddr });
         this.socketType = socketType;
         this.interfaceName = interfaceName;

package/dist/dgram/mb_mdns.js

@@ -1,14 +1,15 @@
+import os from 'node:os';
 import { getIntParameter, getParameter, getStringArrayParameter, hasParameter } from '../utils/commandLine.js';
 import { MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT } from './multicast.js';
 import { Mdns } from './mdns.js';
-import { Unicast } from './unicast.js';
-import { MDNS_REFLECTOR_ADDRESS, MDNS_REFLECTOR_PORT } from './mMdnsReflector.js';
+import { MdnsReflectorClient } from './mdnsReflectorClient.js';
+import { MdnsReflectorServer } from './mdnsReflectorServer.js';
 {
     if (hasParameter('h') || hasParameter('help')) {
-        console.log(`Copyright (c) Matterbridge. All rights reserved.\n`);
+        console.log(`Copyright (c) Matterbridge. All rights reserved. Version 1.0.0.\n`);
         console.log(`Usage: mb_mdns [options...]
 
-If no command line is provided, mb_mdns shows all incoming mDNS records.
+If no command line is provided, mb_mdns shows all incoming mDNS records on all interfaces (0.0.0.0 and ::).
 
 Options:
   -h, --help                                Show this help message and exit.
@@ -17,14 +18,17 @@ Options:
   --ipv6InterfaceAddress <address>          IPv6 address of the network interface to bind to (default: ::).
   --outgoingIpv4InterfaceAddress <address>  Outgoing IPv4 address of the network interface (default first external address).
   --outgoingIpv6InterfaceAddress <address>  Outgoing IPv6 address of the network interface (default first external address).
-  --unicastIpv4 <address>                   Unicast IPv4 address to send mDNS advertisements to (default: disabled).
-  --unicastIpv6 <address>                   Unicast IPv6 address to send mDNS advertisements to (default: disabled).
-  --broadcast                               Enable broadcasting of mDNS advertisements (default: disabled).
-  --localhost                               Enable sending mDNS advertisements to localhost (default: disabled).
   --advertise <interval>                    Enable matterbridge mDNS advertisement each ms (default interval: 10000ms).
   --query <interval>                        Enable common mDNS services query each ms (default interval: 10000ms).
   --filter <string...>                      Filter strings to match in the mDNS record name (default: no filter).
+  --noIpv4                                  Disable IPv4 mDNS server (default: enabled).
+  --noIpv6                                  Disable IPv6 mDNS server (default: enabled).
+  --no-timeout                              Disable automatic timeout of 10 minutes. Reflector mode disables timeout automatically.
+  --reflector-client                        Enable mDNS reflector client (default: disabled).
+  --reflector-server                        Enable mDNS reflector server (default: disabled).
+  -d, --debug                               Enable debug logging (default: disabled).
   -v, --verbose                             Enable verbose logging (default: disabled).
+  -s, --silent                              Enable silent mode, only log notices, warnings and errors.
 
 Examples:
   # Listen for Matter device commissioner service records only on eth0 interface
@@ -52,42 +56,29 @@ Examples:
     let mdnsIpv6QueryInterval;
     let mdnsIpv4AdvertiseInterval;
     let mdnsIpv6AdvertiseInterval;
-    const mdnsIpv4 = new Mdns('mDNS Server udp4', MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_PORT, 'udp4', true, getParameter('interfaceName'), getParameter('ipv4InterfaceAddress') || '0.0.0.0', getParameter('outgoingIpv4InterfaceAddress'));
-    const mdnsIpv6 = new Mdns('mDNS Server udp6', MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT, 'udp6', true, getParameter('interfaceName'), getParameter('ipv6InterfaceAddress') || '::', getParameter('outgoingIpv6InterfaceAddress'));
-    const unicast = new Unicast('mDNS Unicast Server', 'udp4', false, undefined, MDNS_REFLECTOR_ADDRESS, MDNS_REFLECTOR_PORT);
-    if (hasParameter('v') || hasParameter('verbose')) {
-        mdnsIpv4.log.logLevel = "debug";
-        mdnsIpv6.log.logLevel = "debug";
-        unicast.log.logLevel = "debug";
-    }
-    else {
-        mdnsIpv4.log.logLevel = "info";
-        mdnsIpv6.log.logLevel = "info";
-        unicast.log.logLevel = "info";
-    }
-    mdnsIpv4.listNetworkInterfaces();
-    const filters = getStringArrayParameter('filter');
-    if (filters) {
-        mdnsIpv4.filters.push(...filters);
-        mdnsIpv6.filters.push(...filters);
-    }
+    let mdnsIpv4 = undefined;
+    let mdnsIpv6 = undefined;
+    let reflectorClient = undefined;
+    let reflectorServer = undefined;
     async function cleanupAndLogAndExit() {
-        if (hasParameter('advertise')) {
-            advertise(mdnsIpv4, 0);
-            advertise(mdnsIpv6, 0);
-        }
-        await new Promise((resolve) => setTimeout(resolve, 250));
         clearInterval(mdnsIpv4QueryInterval);
         clearInterval(mdnsIpv6QueryInterval);
         clearInterval(mdnsIpv4AdvertiseInterval);
         clearInterval(mdnsIpv6AdvertiseInterval);
-        mdnsIpv4.stop();
-        mdnsIpv6.stop();
-        unicast.stop();
+        if (hasParameter('advertise')) {
+            if (mdnsIpv4)
+                advertise(mdnsIpv4, 0);
+            if (mdnsIpv6)
+                advertise(mdnsIpv6, 0);
+        }
         await new Promise((resolve) => setTimeout(resolve, 250));
-        mdnsIpv4.logDevices();
-        mdnsIpv6.logDevices();
-        process.exit(0);
+        mdnsIpv4?.stop();
+        mdnsIpv6?.stop();
+        mdnsIpv4?.logDevices();
+        mdnsIpv6?.logDevices();
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        await reflectorClient?.stop();
+        await reflectorServer?.stop();
     }
     const query = (mdns) => {
         mdns.log.info('Sending mDNS query for services...');
@@ -125,141 +116,92 @@ Examples:
             { name: httpInstanceName, rtype: 16, rclass: 1 | 32768, ttl, rdata: txtRdata },
             { name: matterbridgeInstanceName, rtype: 16, rclass: 1 | 32768, ttl, rdata: txtRdata },
         ];
-        try {
-            const ipv4 = mdns.getIpv4InterfaceAddress(mdns.interfaceName);
-            if (ipv4) {
-                answers.push({ name: hostName, rtype: 1, rclass: 1 | 32768, ttl, rdata: mdns.encodeA(ipv4) });
+        const interfaces = os.networkInterfaces();
+        let interfaceInfos = mdns.interfaceName ? interfaces[mdns.interfaceName] : undefined;
+        if (!interfaceInfos) {
+            interfaceInfos = [];
+            for (const name of Object.keys(interfaces)) {
+                const infos = interfaces[name];
+                if (infos && infos.length > 0 && !infos[0].internal) {
+                    interfaceInfos.push(...infos);
+                    break;
+                }
             }
         }
-        catch (error) {
-            mdns.log.warn(`Error sending mDNS advertisement for matterbridge service A record: ${error.message}`);
-        }
         try {
-            const ipv6 = mdns.getIpv6InterfaceAddress(mdns.interfaceName);
-            if (ipv6) {
-                answers.push({ name: hostName, rtype: 28, rclass: 1 | 32768, ttl, rdata: mdns.encodeAAAA(ipv6) });
+            for (const info of interfaceInfos) {
+                if (info.family === 'IPv4' && !info.internal) {
+                    const ipv4 = info.address;
+                    answers.push({ name: hostName, rtype: 1, rclass: 1 | 32768, ttl, rdata: mdns.encodeA(ipv4) });
+                }
+                else if (info.family === 'IPv6' && !info.internal) {
+                    const ipv6 = info.address;
+                    answers.push({ name: hostName, rtype: 28, rclass: 1 | 32768, ttl, rdata: mdns.encodeAAAA(ipv6) });
+                }
             }
         }
         catch (error) {
-            mdns.log.warn(`Error sending mDNS advertisement for matterbridge service AAAA record: ${error.message}`);
-        }
-        const response = mdns.sendResponse(answers);
-        if (hasParameter('broadcast')) {
-            try {
-                const address = mdns.socketType === 'udp4' ? mdns.getIpv4InterfaceAddress(mdns.interfaceName) : mdns.getIpv6InterfaceAddress(mdns.interfaceName);
-                const mask = mdns.socketType === 'udp4' ? mdns.getNetmask(address) : undefined;
-                const broadcastAddress = mdns.socketType === 'udp4' ? mdns.getIpv4BroadcastAddress(address, mask) : mdns.getIpv6BroadcastAddress();
-                mdns.log.info(`***Broadcasting mDNS advertisement for matterbridge service to ${broadcastAddress}...`);
-                mdns.socket.send(response, 0, response.length, MDNS_MULTICAST_PORT, broadcastAddress, (error) => {
-                    if (error) {
-                        mdns.log.error(`Error broadcasting mDNS advertisement to ${broadcastAddress}: ${error.message}`);
-                    }
-                    else {
-                        mdns.log.info(`**mDNS advertisement broadcasted successfully to ${broadcastAddress}`);
-                    }
-                });
-            }
-            catch (error) {
-                mdns.log.error(`Error broadcasting mDNS advertisement: ${error.message}`);
-            }
-        }
-        if (mdns.socketType === 'udp4' && hasParameter('localhost')) {
-            try {
-                mdns.log.info(`**Sending mDNS advertisement for matterbridge service to localhost...`);
-                mdns.socket.send(response, 0, response.length, MDNS_REFLECTOR_PORT, MDNS_REFLECTOR_ADDRESS, (error) => {
-                    if (error) {
-                        mdns.log.error(`**Error sending mDNS advertisement to localhost: ${error.message}`);
-                    }
-                    else {
-                        mdns.log.info(`**mDNS advertisement sent successfully to localhost`);
-                    }
-                });
-            }
-            catch (error) {
-                mdns.log.error(`**Error sending mDNS advertisement to localhost: ${error.message}`);
-            }
-        }
-        if (mdns.socketType === 'udp4' && getParameter('unicastIpv4')) {
-            const unicastAddress = getParameter('unicastIpv4');
-            try {
-                mdns.log.info(`**Sending mDNS advertisement for matterbridge service to unicast ${unicastAddress}...`);
-                mdns.socket.send(response, 0, response.length, MDNS_MULTICAST_PORT, unicastAddress, (error) => {
-                    if (error) {
-                        mdns.log.error(`Error sending mDNS advertisement to unicast ${unicastAddress}: ${error.message}`);
-                    }
-                    else {
-                        mdns.log.info(`**mDNS advertisement sent successfully to unicast ${unicastAddress}`);
-                    }
-                });
-            }
-            catch (error) {
-                mdns.log.error(`Error sending mDNS advertisement to unicast ${unicastAddress}: ${error.message}`);
-            }
-        }
-        if (mdns.socketType === 'udp6' && getParameter('unicastIpv6')) {
-            const unicastAddress = getParameter('unicastIpv6');
-            try {
-                mdns.log.info(`**Sending mDNS advertisement for matterbridge service to unicast ${unicastAddress}...`);
-                mdns.socket.send(response, 0, response.length, MDNS_MULTICAST_PORT, unicastAddress, (error) => {
-                    if (error) {
-                        mdns.log.error(`Error sending mDNS advertisement to unicast ${unicastAddress}: ${error.message}`);
-                    }
-                    else {
-                        mdns.log.info(`**mDNS advertisement sent successfully to unicast ${unicastAddress}`);
-                    }
-                });
-            }
-            catch (error) {
-                mdns.log.error(`Error sending mDNS advertisement to unicast ${unicastAddress}: ${error.message}`);
-            }
+            mdns.log.error(`Error encoding network interface addresses: ${error.message}`);
         }
+        const _response = mdns.sendResponse(answers);
     };
-    process.on('SIGINT', async () => {
-        await cleanupAndLogAndExit();
-    });
-    if (!hasParameter('noIpv4'))
+    if (!hasParameter('noIpv4') && !hasParameter('reflector-server') && !hasParameter('reflector-client')) {
+        mdnsIpv4 = new Mdns('mDNS Server udp4', MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_PORT, 'udp4', true, getParameter('interfaceName'), getParameter('ipv4InterfaceAddress') || '0.0.0.0', getParameter('outgoingIpv4InterfaceAddress'));
+        if (hasParameter('v') || hasParameter('verbose'))
+            mdnsIpv4.listNetworkInterfaces();
+        const filters = getStringArrayParameter('filter');
+        if (filters)
+            mdnsIpv4.filters.push(...filters);
         mdnsIpv4.start();
-    mdnsIpv4.on('ready', (address) => {
-        mdnsIpv4.log.info(`mdnsIpv4 server ready on ${address.family} ${address.address}:${address.port}`);
-        if (hasParameter('advertise')) {
-            advertise(mdnsIpv4);
-            mdnsIpv4AdvertiseInterval = setInterval(() => {
+        mdnsIpv4.on('ready', (address) => {
+            mdnsIpv4?.log.info(`mdnsIpv4 server ready on ${address.family} ${address.address}:${address.port}`);
+            if (hasParameter('advertise')) {
                 advertise(mdnsIpv4);
-            }, getIntParameter('advertise') || 10000).unref();
-        }
-        if (hasParameter('query')) {
-            query(mdnsIpv4);
-            mdnsIpv4QueryInterval = setInterval(() => {
+                mdnsIpv4AdvertiseInterval = setInterval(() => advertise(mdnsIpv4), getIntParameter('advertise') || 10000).unref();
+            }
+            if (hasParameter('query')) {
                 query(mdnsIpv4);
-            }, getIntParameter('query') || 10000).unref();
-        }
-    });
-    if (!hasParameter('noIpv6'))
+                mdnsIpv4QueryInterval = setInterval(() => query(mdnsIpv4), getIntParameter('query') || 10000).unref();
+            }
+        });
+    }
+    if (!hasParameter('noIpv6') && !hasParameter('reflector-server') && !hasParameter('reflector-client')) {
+        mdnsIpv6 = new Mdns('mDNS Server udp6', MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT, 'udp6', true, getParameter('interfaceName'), getParameter('ipv6InterfaceAddress') || '::', getParameter('outgoingIpv6InterfaceAddress'));
+        if (hasParameter('v') || hasParameter('verbose'))
+            mdnsIpv6.listNetworkInterfaces();
+        const filters = getStringArrayParameter('filter');
+        if (filters)
+            mdnsIpv6.filters.push(...filters);
         mdnsIpv6.start();
-    mdnsIpv6.on('ready', (address) => {
-        mdnsIpv6.log.info(`mdnsIpv6 server ready on ${address.family} ${address.address}:${address.port}`);
-        if (hasParameter('advertise')) {
-            advertise(mdnsIpv6);
-            mdnsIpv6AdvertiseInterval = setInterval(() => {
+        mdnsIpv6.on('ready', (address) => {
+            mdnsIpv6?.log.info(`mdnsIpv6 server ready on ${address.family} ${address.address}:${address.port}`);
+            if (hasParameter('advertise')) {
                 advertise(mdnsIpv6);
-            }, getIntParameter('advertise') || 10000).unref();
-        }
-        if (hasParameter('query')) {
-            query(mdnsIpv6);
-            mdnsIpv6QueryInterval = setInterval(() => {
+                mdnsIpv6AdvertiseInterval = setInterval(() => advertise(mdnsIpv6), getIntParameter('advertise') || 10000).unref();
+            }
+            if (hasParameter('query')) {
                 query(mdnsIpv6);
-            }, getIntParameter('query') || 10000).unref();
-        }
-    });
-    if (hasParameter('reflector'))
-        unicast.start();
-    unicast.on('bound', (address) => {
-        unicast.log.info(`**Bound on ${address.family} ${address.address}:${address.port}`);
-    });
-    unicast.on('message', (msg, rinfo) => {
-        unicast.log.info(`**Received message from ${rinfo.address}:${rinfo.port} - ${msg.length} bytes`);
+                mdnsIpv6QueryInterval = setInterval(() => query(mdnsIpv6), getIntParameter('query') || 10000).unref();
+            }
+        });
+    }
+    if (hasParameter('reflector-client')) {
+        reflectorClient = new MdnsReflectorClient();
+        await reflectorClient.start();
+    }
+    if (hasParameter('reflector-server')) {
+        reflectorServer = new MdnsReflectorServer();
+        await reflectorServer.start();
+    }
+    process.on('SIGINT', async () => {
+        await cleanupAndLogAndExit();
     });
-    setTimeout(async () => {
+    process.on('SIGTERM', async () => {
         await cleanupAndLogAndExit();
-    }, 600000).unref();
+    });
+    if (!hasParameter('no-timeout') && !hasParameter('reflector-server') && !hasParameter('reflector-client')) {
+        setTimeout(async () => {
+            await cleanupAndLogAndExit();
+        }, 600000).unref();
+    }
 }

package/dist/dgram/mdns.js

@@ -631,21 +631,21 @@ export class Mdns extends Multicast {
         }
         return isQU ? `${classStr}|QU` : classStr;
     }
-    logMdnsMessage(msg) {
-        this.log.info(`Decoded mDNS message: 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}`);
+    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) => {
-            this.log.info(`Question: ${CYAN}${question.name}${nf} type ${idn}${this.dnsTypeToString(question.type)}${rs}${nf} class ${CYAN}${this.dnsQuestionClassToString(question.class)}${nf}`);
+            log.info(`Question: ${CYAN}${question.name}${nf} type ${idn}${this.dnsTypeToString(question.type)}${rs}${nf} class ${CYAN}${this.dnsQuestionClassToString(question.class)}${nf}`);
         });
         msg.answers?.forEach((answer) => {
-            this.log.info(`Answer: ${CYAN}${answer.name}${nf} type ${idn}${this.dnsTypeToString(answer.type)}${rs}${nf} class ${CYAN}${this.dnsResponseClassToString(answer.class)}${nf} ttl ${CYAN}${answer.ttl}${nf} data ${CYAN}${answer.data}${nf}`);
+            log.info(`Answer: ${CYAN}${answer.name}${nf} type ${idn}${this.dnsTypeToString(answer.type)}${rs}${nf} class ${CYAN}${this.dnsResponseClassToString(answer.class)}${nf} ttl ${CYAN}${answer.ttl}${nf} data ${CYAN}${answer.data}${nf}`);
         });
         msg.authorities?.forEach((authority) => {
-            this.log.info(`Authority: ${CYAN}${authority.name}${nf} type ${idn}${this.dnsTypeToString(authority.type)}${rs}${nf} class ${CYAN}${this.dnsResponseClassToString(authority.class)}${nf} ttl ${CYAN}${authority.ttl}${nf} data ${CYAN}${authority.data}${nf}`);
+            log.info(`Authority: ${CYAN}${authority.name}${nf} type ${idn}${this.dnsTypeToString(authority.type)}${rs}${nf} class ${CYAN}${this.dnsResponseClassToString(authority.class)}${nf} ttl ${CYAN}${authority.ttl}${nf} data ${CYAN}${authority.data}${nf}`);
         });
         msg.additionals?.forEach((additional) => {
-            this.log.info(`Additional: ${CYAN}${additional.name}${nf} type ${idn}${this.dnsTypeToString(additional.type)}${rs}${nf} class ${CYAN}${this.dnsResponseClassToString(additional.class)}${nf} ttl ${CYAN}${additional.ttl}${nf} data ${CYAN}${additional.data}${nf}`);
+            log.info(`Additional: ${CYAN}${additional.name}${nf} type ${idn}${this.dnsTypeToString(additional.type)}${rs}${nf} class ${CYAN}${this.dnsResponseClassToString(additional.class)}${nf} ttl ${CYAN}${additional.ttl}${nf} data ${CYAN}${additional.data}${nf}`);
         });
-        this.log.info(`---\n`);
+        log.info(`---\n`);
     }
     logDevices() {
         this.log.info(`Discovered query devices: ${MAGENTA}${this.deviceQueries.size}${nf}`);

package/dist/dgram/mdnsReflectorClient.js

@@ -0,0 +1,108 @@
+import { AnsiLogger, BLUE, nt } from 'node-ansi-logger';
+import { getStringArrayParameter, hasParameter } from '../utils/commandLine.js';
+import { Mdns } from './mdns.js';
+import { MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT } from './multicast.js';
+import { Unicast } from './unicast.js';
+import { MDNS_REFLECTOR_ADDRESS, MDNS_REFLECTOR_BIND_ADDRESS_IPV4, MDNS_REFLECTOR_BIND_ADDRESS_IPV6, MDNS_REFLECTOR_HOST_DOCKER, MDNS_REFLECTOR_PORT } from './mdnsReflectorTypes.js';
+export class MdnsReflectorClient {
+    verbose = hasParameter('v') || hasParameter('verbose');
+    debug = hasParameter('d') || hasParameter('debug') || hasParameter('v') || hasParameter('verbose');
+    silent = hasParameter('s') || hasParameter('silent');
+    log = new AnsiLogger({ logName: 'MdnsReflectorClient', logTimestampFormat: 4, logLevel: this.debug ? "debug" : this.silent ? "notice" : "info" });
+    mdnsIpv4 = new Mdns('mDNS udp4 Server', MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_PORT, 'udp4', true, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV4);
+    mdnsIpv6 = new Mdns('mDNS udp6 Server', MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT, 'udp6', true, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV6);
+    unicastIpv4 = new Unicast('mDNS udp4 Reflector Client', 'udp4', false, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV4);
+    unicastIpv6 = new Unicast('mDNS udp6 Reflector Client', 'udp6', false, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV6);
+    constructor() {
+        this.log.logNameColor = '\x1b[38;5;97m';
+        this.mdnsIpv4.log.logNameColor = '\x1b[38;5;97m';
+        this.mdnsIpv4.log.logLevel = "warn";
+        this.mdnsIpv6.log.logNameColor = '\x1b[38;5;97m';
+        this.mdnsIpv6.log.logLevel = "warn";
+        this.unicastIpv4.log.logNameColor = '\x1b[38;5;97m';
+        this.unicastIpv4.log.logLevel = "warn";
+        this.unicastIpv6.log.logNameColor = '\x1b[38;5;97m';
+        this.unicastIpv6.log.logLevel = "warn";
+        const filters = getStringArrayParameter('filter');
+        if (filters)
+            this.mdnsIpv4.filters.push(...filters);
+        if (filters)
+            this.mdnsIpv6.filters.push(...filters);
+    }
+    async start() {
+        this.log.notice('mDNS Reflector Client starting...');
+        this.mdnsIpv4.on('error', (err) => {
+            this.log.error(`mDNS udp4 Server error:\n${err.stack}`);
+        });
+        this.mdnsIpv6.on('error', (err) => {
+            this.log.error(`mDNS udp6 Server error:\n${err.stack}`);
+        });
+        this.unicastIpv4.on('error', (err) => {
+            this.log.error(`mDNS udp4 Reflector Client error:\n${err.stack}`);
+        });
+        this.unicastIpv6.on('error', (err) => {
+            this.log.error(`mDNS udp6 Reflector Client error:\n${err.stack}`);
+        });
+        const promises = [];
+        promises[0] = new Promise((resolve) => {
+            this.mdnsIpv4.once('bound', () => resolve());
+            this.mdnsIpv4.start();
+        });
+        promises[1] = new Promise((resolve) => {
+            this.mdnsIpv6.once('bound', () => resolve());
+            this.mdnsIpv6.start();
+        });
+        promises[2] = new Promise((resolve) => {
+            this.unicastIpv4.once('bound', () => resolve());
+            this.unicastIpv4.start();
+        });
+        promises[3] = new Promise((resolve) => {
+            this.unicastIpv6.once('bound', () => resolve());
+            this.unicastIpv6.start();
+        });
+        await Promise.all(promises);
+        this.mdnsIpv4.on('message', (msg, rinfo) => {
+            this.log.notice(`Sending message from mDNS ipv4 multicast ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to unicast ipv4 reflector`);
+            this.unicastIpv4.send(msg, MDNS_REFLECTOR_HOST_DOCKER, MDNS_REFLECTOR_PORT);
+            this.unicastIpv4.send(msg, MDNS_REFLECTOR_ADDRESS, MDNS_REFLECTOR_PORT);
+        });
+        this.mdnsIpv6.on('message', (msg, rinfo) => {
+            this.log.notice(`Sending message from mDNS ipv6 multicast ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to unicast ipv6 reflector`);
+            this.unicastIpv6.send(msg, MDNS_REFLECTOR_HOST_DOCKER, MDNS_REFLECTOR_PORT);
+            this.unicastIpv6.send(msg, MDNS_REFLECTOR_ADDRESS, MDNS_REFLECTOR_PORT);
+        });
+        this.unicastIpv4.on('message', (msg, rinfo) => {
+            this.log.notice(`Received message from unicast reflector on ipv4 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt}: ${msg.toString()}`);
+        });
+        this.unicastIpv6.on('message', (msg, rinfo) => {
+            this.log.notice(`Received message from unicast reflector on ipv6 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt}: ${msg.toString()}`);
+        });
+        this.log.notice('mDNS Reflector Client started.');
+    }
+    async stop() {
+        this.log.notice('mDNS Reflector Client stopping...');
+        const promises = [];
+        promises[0] = new Promise((resolve) => {
+            this.mdnsIpv4.once('closed', () => resolve());
+            this.mdnsIpv4.stop();
+        });
+        promises[1] = new Promise((resolve) => {
+            this.mdnsIpv6.once('closed', () => resolve());
+            this.mdnsIpv6.stop();
+        });
+        promises[2] = new Promise((resolve) => {
+            this.unicastIpv4.once('closed', () => resolve());
+            this.unicastIpv4.stop();
+        });
+        promises[3] = new Promise((resolve) => {
+            this.unicastIpv6.once('closed', () => resolve());
+            this.unicastIpv6.stop();
+        });
+        await Promise.all(promises);
+        this.mdnsIpv4.removeAllListeners();
+        this.mdnsIpv6.removeAllListeners();
+        this.unicastIpv4.removeAllListeners();
+        this.unicastIpv6.removeAllListeners();
+        this.log.notice('mDNS Reflector Client stopped.');
+    }
+}

package/dist/dgram/mdnsReflectorServer.js

@@ -0,0 +1,253 @@
+import os from 'node:os';
+import { AnsiLogger, BLUE, nt } from 'node-ansi-logger';
+import { hasParameter, getStringArrayParameter } from '../utils/commandLine.js';
+import { Mdns } from './mdns.js';
+import { MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT } from './multicast.js';
+import { Unicast } from './unicast.js';
+import { MDNS_REFLECTOR_BIND_ADDRESS_IPV4, MDNS_REFLECTOR_BIND_ADDRESS_IPV6, MDNS_REFLECTOR_PORT } from './mdnsReflectorTypes.js';
+export class MdnsReflectorServer {
+    verbose = hasParameter('v') || hasParameter('verbose');
+    debug = hasParameter('d') || hasParameter('debug') || hasParameter('v') || hasParameter('verbose');
+    silent = hasParameter('s') || hasParameter('silent');
+    log = new AnsiLogger({ logName: 'MdnsReflectorServer', logTimestampFormat: 4, logLevel: this.debug ? "debug" : this.silent ? "notice" : "info" });
+    mdnsIpv4 = new Mdns('mDNS udp4 Server', MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_PORT, 'udp4', true, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV4);
+    mdnsIpv6 = new Mdns('mDNS udp6 Server', MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT, 'udp6', true, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV6);
+    unicastIpv4 = new Unicast('mDNS udp4 Reflector Server', 'udp4', true, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV4, MDNS_REFLECTOR_PORT);
+    unicastIpv6 = new Unicast('mDNS udp6 Reflector Server', 'udp6', true, undefined, MDNS_REFLECTOR_BIND_ADDRESS_IPV6, MDNS_REFLECTOR_PORT);
+    ipv4Clients = new Map();
+    ipv6Clients = new Map();
+    constructor() {
+        this.log.logNameColor = '\x1b[38;5;115m';
+        this.mdnsIpv4.log.logNameColor = '\x1b[38;5;115m';
+        this.mdnsIpv4.log.logLevel = "warn";
+        this.mdnsIpv6.log.logNameColor = '\x1b[38;5;115m';
+        this.mdnsIpv6.log.logLevel = "warn";
+        this.unicastIpv4.log.logNameColor = '\x1b[38;5;115m';
+        this.unicastIpv4.log.logLevel = "warn";
+        this.unicastIpv6.log.logNameColor = '\x1b[38;5;115m';
+        this.unicastIpv6.log.logLevel = "warn";
+        const filters = getStringArrayParameter('filter');
+        if (filters)
+            this.mdnsIpv4.filters.push(...filters);
+        if (filters)
+            this.mdnsIpv6.filters.push(...filters);
+    }
+    getBroadcastAddress(mdns) {
+        try {
+            const address = mdns.socketType === 'udp4' ? mdns.getIpv4InterfaceAddress(mdns.interfaceName) : mdns.getIpv6InterfaceAddress(mdns.interfaceName);
+            const mask = mdns.socketType === 'udp4' ? mdns.getNetmask(address) : undefined;
+            const broadcastAddress = mdns.socketType === 'udp4' ? mdns.getIpv4BroadcastAddress(address, mask) : mdns.getIpv6BroadcastAddress();
+            return broadcastAddress;
+        }
+        catch (error) {
+            mdns.log.error(`Error getting broadcast address: ${error.message}`);
+        }
+    }
+    upgradeAddress(msg) {
+        if (!msg || msg.length < 12)
+            return msg;
+        const preferredInterfaceName = this.mdnsIpv4.interfaceName ?? this.mdnsIpv6.interfaceName;
+        const interfaces = os.networkInterfaces();
+        const pickInterface = () => {
+            if (preferredInterfaceName) {
+                const preferred = interfaces[preferredInterfaceName];
+                if (preferred?.some((info) => info && !info.internal))
+                    return preferredInterfaceName;
+            }
+            for (const [name, infos] of Object.entries(interfaces)) {
+                if (infos?.some((info) => info && !info.internal))
+                    return name;
+            }
+            return undefined;
+        };
+        const selectedInterfaceName = pickInterface();
+        this.log.info(`**UpgradeAddress selected interface for address upgrade: ${selectedInterfaceName || 'N/A'}`);
+        const selectedInfos = selectedInterfaceName ? (interfaces[selectedInterfaceName] ?? []) : [];
+        const hostIpv4 = selectedInfos.find((info) => info && !info.internal && info.family === 'IPv4')?.address;
+        const hostIpv6List = (() => {
+            const set = new Set();
+            for (const info of selectedInfos) {
+                if (!info || info.internal || info.family !== 'IPv6')
+                    continue;
+                const normalized = info.address.split('%')[0].toLowerCase();
+                if (normalized)
+                    set.add(normalized);
+            }
+            return [...set];
+        })();
+        this.log.info(`**UpgradeAddress Host IPv4 for address upgrade: ${hostIpv4 || 'N/A'}`);
+        this.log.info(`**UpgradeAddress Host IPv6 for address upgrade: ${hostIpv6List.length > 0 ? hostIpv6List.join(', ') : 'N/A'}`);
+        if (!hostIpv4 && hostIpv6List.length === 0)
+            return msg;
+        const upgradedMsg = Buffer.from(msg);
+        const qdCount = upgradedMsg.readUInt16BE(4);
+        const anCount = upgradedMsg.readUInt16BE(6);
+        const nsCount = upgradedMsg.readUInt16BE(8);
+        const arCount = upgradedMsg.readUInt16BE(10);
+        let offset = 12;
+        try {
+            for (let i = 0; i < qdCount; i++) {
+                const qnameResult = this.mdnsIpv4.decodeDnsName(upgradedMsg, offset);
+                offset = qnameResult.newOffset;
+                offset += 4;
+                if (offset > upgradedMsg.length)
+                    return msg;
+            }
+            const hostA = hostIpv4 ? this.mdnsIpv4.encodeA(hostIpv4) : undefined;
+            const hostAAAAs = hostIpv6List.map((ipv6) => this.mdnsIpv6.encodeAAAA(ipv6));
+            let hostAAAAIndex = 0;
+            const upgradeResourceRecords = (count) => {
+                for (let i = 0; i < count; i++) {
+                    const nameResult = this.mdnsIpv4.decodeDnsName(upgradedMsg, offset);
+                    offset = nameResult.newOffset;
+                    if (offset + 10 > upgradedMsg.length)
+                        return;
+                    const type = upgradedMsg.readUInt16BE(offset);
+                    offset += 2;
+                    offset += 2;
+                    offset += 4;
+                    const rdlength = upgradedMsg.readUInt16BE(offset);
+                    offset += 2;
+                    const rdataOffset = offset;
+                    const endOfRdata = rdataOffset + rdlength;
+                    if (endOfRdata > upgradedMsg.length)
+                        return;
+                    if (type === 1 && rdlength === 4 && hostA) {
+                        hostA.copy(upgradedMsg, rdataOffset);
+                    }
+                    else if (type === 28 && rdlength === 16 && hostAAAAs.length > 0) {
+                        const hostAAAA = hostAAAAs[Math.min(hostAAAAIndex, hostAAAAs.length - 1)];
+                        hostAAAA.copy(upgradedMsg, rdataOffset);
+                        hostAAAAIndex++;
+                    }
+                    offset = endOfRdata;
+                }
+            };
+            upgradeResourceRecords(anCount);
+            upgradeResourceRecords(nsCount);
+            upgradeResourceRecords(arCount);
+        }
+        catch (error) {
+            this.log.error(`**UpgradeAddress failed to parse message: ${error.message}`);
+            return msg;
+        }
+        this.log.info(`**UpgradeAddress message completed. Interface: ${selectedInterfaceName || 'N/A'}, Host IPv4: ${hostIpv4 || 'N/A'}, Host IPv6: ${hostIpv6List.length > 0 ? hostIpv6List.join(', ') : 'N/A'}`);
+        if (hasParameter('log-reflector-messages')) {
+            try {
+                let decodedMessage = this.mdnsIpv4.decodeMdnsMessage(msg);
+                this.mdnsIpv4.logMdnsMessage(decodedMessage, this.log, '**Original mDNS message');
+                decodedMessage = this.mdnsIpv4.decodeMdnsMessage(upgradedMsg);
+                this.mdnsIpv4.logMdnsMessage(decodedMessage, this.log, '**Upgraded mDNS message');
+            }
+            catch (error) {
+                this.log.error(`**UpgradeAddress failed to decode message: ${error.message}`);
+            }
+        }
+        return upgradedMsg;
+    }
+    async start() {
+        this.log.notice('mDNS Reflector Server starting...');
+        this.mdnsIpv4.on('error', (err) => {
+            this.log.error(`mDNS udp4 Server error:\n${err.stack}`);
+        });
+        this.mdnsIpv6.on('error', (err) => {
+            this.log.error(`mDNS udp6 Server error:\n${err.stack}`);
+        });
+        this.unicastIpv4.on('error', (err) => {
+            this.log.error(`mDNS udp4 Reflector Server error:\n${err.stack}`);
+        });
+        this.unicastIpv6.on('error', (err) => {
+            this.log.error(`mDNS udp6 Reflector Server error:\n${err.stack}`);
+        });
+        const promises = [];
+        promises[0] = new Promise((resolve) => {
+            this.mdnsIpv4.once('bound', () => resolve());
+            this.mdnsIpv4.start();
+        });
+        promises[1] = new Promise((resolve) => {
+            this.mdnsIpv6.once('bound', () => resolve());
+            this.mdnsIpv6.start();
+        });
+        promises[2] = new Promise((resolve) => {
+            this.unicastIpv4.once('bound', () => resolve());
+            this.unicastIpv4.start();
+        });
+        promises[3] = new Promise((resolve) => {
+            this.unicastIpv6.once('bound', () => resolve());
+            this.unicastIpv6.start();
+        });
+        await Promise.all(promises);
+        this.unicastIpv4.on('message', (msg, rinfo) => {
+            this.ipv4Clients.set(`${rinfo.address}:${rinfo.port}`, rinfo);
+            this.log.notice(`Reflecting message from unicast client ipv4 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to mDNS ipv4 multicast`);
+            const upgradedMsg = this.upgradeAddress(msg);
+            this.mdnsIpv4.send(upgradedMsg, MDNS_MULTICAST_IPV4_ADDRESS, MDNS_MULTICAST_PORT);
+            if (hasParameter('broadcast')) {
+                const broadcastAddress = this.getBroadcastAddress(this.mdnsIpv4);
+                if (broadcastAddress) {
+                    this.log.notice(`Reflecting message from unicast client ipv4 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to ipv4 broadcast address ${BLUE}${broadcastAddress}${nt}:${BLUE}${MDNS_MULTICAST_PORT}${nt}`);
+                    this.mdnsIpv4.send(upgradedMsg, broadcastAddress, MDNS_MULTICAST_PORT);
+                }
+            }
+            if (hasParameter('localhost')) {
+                this.log.notice(`Reflecting message from unicast client ipv4 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to ipv4 localhost address ${BLUE}localhost${nt}:${BLUE}${MDNS_MULTICAST_PORT}${nt}`);
+                this.mdnsIpv4.send(upgradedMsg, 'localhost', MDNS_MULTICAST_PORT);
+            }
+            this.unicastIpv4.send(Buffer.from('mDNS Reflector Server reflected your message'), rinfo.address, rinfo.port);
+        });
+        this.unicastIpv6.on('message', (msg, rinfo) => {
+            this.ipv6Clients.set(`${rinfo.address}:${rinfo.port}`, rinfo);
+            this.log.notice(`Reflecting message from unicast client ipv6 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to mDNS ipv6 multicast`);
+            const upgradedMsg = this.upgradeAddress(msg);
+            this.mdnsIpv6.send(upgradedMsg, MDNS_MULTICAST_IPV6_ADDRESS, MDNS_MULTICAST_PORT);
+            if (hasParameter('broadcast')) {
+                const broadcastAddress = this.getBroadcastAddress(this.mdnsIpv6);
+                if (broadcastAddress) {
+                    this.log.notice(`Reflecting message from unicast client ipv6 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to ipv6 broadcast address ${BLUE}${broadcastAddress}${nt}:${BLUE}${MDNS_MULTICAST_PORT}${nt}`);
+                    this.mdnsIpv6.send(upgradedMsg, broadcastAddress, MDNS_MULTICAST_PORT);
+                }
+            }
+            if (hasParameter('localhost')) {
+                this.log.notice(`Reflecting message from unicast client ipv6 ${BLUE}${rinfo.address}${nt}:${BLUE}${rinfo.port}${nt} to ipv6 localhost address ${BLUE}localhost${nt}:${BLUE}${MDNS_MULTICAST_PORT}${nt}`);
+                this.mdnsIpv6.send(upgradedMsg, 'localhost', MDNS_MULTICAST_PORT);
+            }
+            this.unicastIpv6.send(Buffer.from('mDNS Reflector Server reflected your message'), rinfo.address, rinfo.port);
+        });
+        this.log.notice('mDNS Reflector Server started.');
+    }
+    async stop() {
+        this.log.notice('mDNS Reflector Server stopping...');
+        for (const client of this.ipv4Clients.values()) {
+            this.log.debug(`Notifying ipv4 client ${client.address}:${client.port} about server stopping`);
+            this.unicastIpv4.send(Buffer.from('mDNS Reflector Server is stopping'), client.address, client.port);
+        }
+        for (const client of this.ipv6Clients.values()) {
+            this.log.debug(`Notifying ipv6 client ${client.address}:${client.port} about server stopping`);
+            this.unicastIpv6.send(Buffer.from('mDNS Reflector Server is stopping'), client.address, client.port);
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        const promises = [];
+        promises[0] = new Promise((resolve) => {
+            this.mdnsIpv4.once('closed', () => resolve());
+            this.mdnsIpv4.stop();
+        });
+        promises[1] = new Promise((resolve) => {
+            this.mdnsIpv6.once('closed', () => resolve());
+            this.mdnsIpv6.stop();
+        });
+        promises[2] = new Promise((resolve) => {
+            this.unicastIpv4.once('closed', () => resolve());
+            this.unicastIpv4.stop();
+        });
+        promises[3] = new Promise((resolve) => {
+            this.unicastIpv6.once('closed', () => resolve());
+            this.unicastIpv6.stop();
+        });
+        await Promise.all(promises);
+        this.mdnsIpv4.removeAllListeners();
+        this.mdnsIpv6.removeAllListeners();
+        this.unicastIpv4.removeAllListeners();
+        this.unicastIpv6.removeAllListeners();
+        this.log.notice('mDNS Reflector Server stopped.');
+    }
+}

package/dist/dgram/mdnsReflectorTypes.js

@@ -0,0 +1,5 @@
+export const MDNS_REFLECTOR_BIND_ADDRESS_IPV4 = '0.0.0.0';
+export const MDNS_REFLECTOR_BIND_ADDRESS_IPV6 = '::';
+export const MDNS_REFLECTOR_ADDRESS = 'localhost';
+export const MDNS_REFLECTOR_HOST_DOCKER = 'host.docker.internal';
+export const MDNS_REFLECTOR_PORT = 15353;

package/dist/utils/commandLine.js

@@ -16,7 +16,7 @@ export function getParameter(name) {
     let markerIndex = commandArguments.indexOf(`-${name}`);
     if (markerIndex === -1)
         markerIndex = commandArguments.indexOf(`--${name}`);
-    if (markerIndex === -1 || markerIndex + 1 === commandArguments.length)
+    if (markerIndex === -1 || markerIndex + 1 === commandArguments.length || commandArguments[markerIndex + 1].startsWith('-'))
         return undefined;
     return commandArguments[markerIndex + 1];
 }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "matterbridge",
-  "version": "3.4.5-dev-20251225-742588e",
+  "version": "3.4.6-dev-20251228-e06f048",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "matterbridge",
-      "version": "3.4.5-dev-20251225-742588e",
+      "version": "3.4.6-dev-20251228-e06f048",
       "license": "Apache-2.0",
       "dependencies": {
         "@matter/main": "0.15.6",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "matterbridge",
-  "version": "3.4.5-dev-20251225-742588e",
+  "version": "3.4.6-dev-20251228-e06f048",
   "description": "Matterbridge plugin manager for Matter",
   "author": "https://github.com/Luligu",
   "license": "Apache-2.0",

package/dist/dgram/mMdnsReflector.js

@@ -1,2 +0,0 @@
-export const MDNS_REFLECTOR_ADDRESS = '127.0.0.1';
-export const MDNS_REFLECTOR_PORT = 15353;