@devioarts/capacitor-mdns 0.1.0 → 0.2.0

package/electron/dist/plugin.cjs.js

@@ -2,29 +2,94 @@
 
 var Bonjour = require('bonjour-service');
 var electron = require('electron');
+var node_path = require('node:path');
+var node_url = require('node:url');
+var node_events = require('node:events');
+var node_net = require('node:net');
 
+const DEFAULT_DISCOVER_TIMEOUT_MS = 3000;
+/** `setTimeout` treats delays above 2^31-1 as 1ms, so clamp. */
+const MAX_TIMER_MS = 2147483647;
 /**
  * Electron main-process implementation of the mDNS/Bonjour functionality.
  *
  * Uses the `bonjour-service` package to:
  * - publish (advertise) a single service;
  * - discover services of a given type and normalize results to the shared schema;
- * - wire the API over Electron's ipcMain (see registerIpc/attachOnReady).
+ * - wire the API over Electron's ipcMain through init().
  *
  * Notes:
  * - Instance name matching is normalized and prefix-safe, mirroring iOS/Android behavior.
  * - TXT records are forwarded as strings when present.
  */
-class mDNS {
-    constructor() {
-        this.publishTimeoutMs = 5000;
-        this.stopTimeoutMs = 3000;
+class mDNS extends node_events.EventEmitter {
+    constructor(bonjour, options = {}) {
+        var _a, _b, _c;
+        super();
         this.broadcastQueue = Promise.resolve();
         this.destroyed = false;
+        /** Settle callbacks of in-flight discoveries, so destroy() can end them instead of leaving them waiting. */
+        this.activeDiscoveries = new Set();
+        this.stoppedBrowsers = new Set();
+        this.deactivateBrowser = new Map();
         //<editor-fold desc="Init/Destroy">
         this.ipcRegistered = false;
-        //</editor-fold>
-        this.bonjour = new Bonjour();
+        this.onNetworkError = (err) => {
+            var _a, _b, _c;
+            this.networkError = this.toErr(err);
+            (_a = this.pendingPublishError) === null || _a === void 0 ? void 0 : _a.call(this, err);
+            const type = (_c = (_b = this.watch) === null || _b === void 0 ? void 0 : _b.types[0]) !== null && _c !== void 0 ? _c : '';
+            const watching = !!this.watch;
+            void this.stopWatching();
+            for (const abort of [...this.activeDiscoveries])
+                abort(this.toErr(err));
+            if (watching)
+                this.notify('watchError', { type, errorMessage: this.toErr(err), watching: false });
+            else
+                console.warn('[mDNS]', err);
+        };
+        this.trustedOrigins = new Set((_a = options.trustedOrigins) !== null && _a !== void 0 ? _a : []);
+        if (bonjour)
+            this.attachBonjour(bonjour);
+        this.publishTimeoutMs = (_b = options.publishTimeoutMs) !== null && _b !== void 0 ? _b : 5000;
+        this.stopTimeoutMs = (_c = options.stopTimeoutMs) !== null && _c !== void 0 ? _c : 3000;
+    }
+    attachBonjour(bonjour) {
+        var _a, _b;
+        this.bonjourInstance = bonjour;
+        // shortcut: Bonjour 1.4 needs its internal transport for errors/TTL; recheck these tests on dependency upgrades.
+        this.transport = (_a = bonjour.server) === null || _a === void 0 ? void 0 : _a.mdns;
+        (_b = this.transport) === null || _b === void 0 ? void 0 : _b.on('error', this.onNetworkError);
+        return bonjour;
+    }
+    get bonjour() {
+        var _a;
+        return ((_a = this.bonjourInstance) !== null && _a !== void 0 ? _a : this.attachBonjour(new Bonjour({}, (err) => console.warn('[mDNS] query response failed:', err))));
+    }
+    trustedUrl(raw) {
+        try {
+            const url = new URL(raw);
+            // Capacitor Electron's default dev renderer; packaged apps require an explicit origin.
+            if ((electron.app === null || electron.app === void 0 ? void 0 : electron.app.isPackaged) === false && `${url.protocol}//${url.host}` === 'http://localhost:5173')
+                return true;
+            if (url.protocol === 'capacitor-electron:' &&
+                url.hostname === 'localhost' &&
+                !url.username &&
+                !url.password &&
+                !url.port)
+                return true;
+            if (url.protocol === 'file:') {
+                const path = node_path.relative(electron.app.getAppPath(), node_url.fileURLToPath(url));
+                return path !== '..' && !path.startsWith(`..${node_path.sep}`) && !node_path.isAbsolute(path);
+            }
+            return this.trustedOrigins.has(`${url.protocol}//${url.host}`);
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    trustedSender(event) {
+        return (!!event.senderFrame && event.senderFrame === event.sender.mainFrame && this.trustedUrl(event.senderFrame.url));
     }
     registerIpc() {
         if (this.ipcRegistered)
@@ -34,14 +99,25 @@ class mDNS {
             electron.ipcMain.removeHandler('mdns:stopBroadcast');
             electron.ipcMain.removeHandler('mdns:discover');
             electron.ipcMain.removeHandler('mdns:getPluginPlatform');
+            electron.ipcMain.removeHandler('mdns:watchServices');
+            electron.ipcMain.removeHandler('mdns:stopWatching');
         }
         catch (_a) {
             /* ignore */
         }
-        electron.ipcMain.handle('mdns:startBroadcast', (_evt, o) => this.startBroadcast(o));
-        electron.ipcMain.handle('mdns:stopBroadcast', () => this.stopBroadcast());
-        electron.ipcMain.handle('mdns:discover', (_evt, o) => this.discover(o));
-        electron.ipcMain.handle('mdns:getPluginPlatform', () => this.getPluginPlatform());
+        const handle = (channel, action) => {
+            electron.ipcMain.handle(channel, (event, options) => {
+                if (!this.trustedSender(event))
+                    throw new Error('Untrusted mDNS IPC sender');
+                return action(options);
+            });
+        };
+        handle('mdns:startBroadcast', (o) => this.startBroadcast(o));
+        handle('mdns:stopBroadcast', () => this.stopBroadcast());
+        handle('mdns:discover', (o) => this.discover(o));
+        handle('mdns:getPluginPlatform', () => this.getPluginPlatform());
+        handle('mdns:watchServices', (o) => this.watchServices(o));
+        handle('mdns:stopWatching', () => this.stopWatching());
         this.ipcRegistered = true;
     }
     unregisterIpc() {
@@ -52,23 +128,33 @@ class mDNS {
             electron.ipcMain.removeHandler('mdns:stopBroadcast');
             electron.ipcMain.removeHandler('mdns:discover');
             electron.ipcMain.removeHandler('mdns:getPluginPlatform');
+            electron.ipcMain.removeHandler('mdns:watchServices');
+            electron.ipcMain.removeHandler('mdns:stopWatching');
         }
         catch (_a) {
             /* ignore */
         }
         this.ipcRegistered = false;
     }
-    /** Manual IPC registration (if you set autoRegisterIpc: false). Idempotent. */
+    /** Register manual IPC handlers. Idempotent. */
     init() {
         this.registerIpc();
     }
     async destroy() {
+        var _a;
         this.destroyed = true;
+        (_a = this.pendingPublishError) === null || _a === void 0 ? void 0 : _a.call(this, new Error('mDNS instance destroyed during publish'));
+        await this.stopWatching();
         this.unregisterIpc();
+        for (const abort of [...this.activeDiscoveries])
+            abort('mDNS instance destroyed during discovery');
         await this.withBroadcastLock(async () => {
+            var _a, _b;
             await this.stopBroadcastUnlocked();
             try {
-                this.bonjour.destroy();
+                (_a = this.bonjourInstance) === null || _a === void 0 ? void 0 : _a.destroy();
+                (_b = this.transport) === null || _b === void 0 ? void 0 : _b.removeListener('error', this.onNetworkError);
+                this.advertiser = undefined;
             }
             catch (err) {
                 console.warn('[mDNS] bonjour.destroy error:', err);
@@ -94,7 +180,7 @@ class mDNS {
         return run;
     }
     normalize(name) {
-        return name.replace(/ \(\d+\)$/, '');
+        return name.replace(/ \(\d+\)$/, '').replace(/\./g, '-');
     }
     matchesTarget(candidate, target) {
         if (!target)
@@ -102,47 +188,79 @@ class mDNS {
         const c = this.normalize(candidate), t = this.normalize(target);
         return c === t || c.startsWith(t);
     }
+    /**
+     * Parse a `_name._tcp.` style type. Absent/blank input means the default `_http._tcp.`;
+     * anything malformed is rejected (null) rather than silently advertised as something else.
+     */
     parseType(typeWithDot) {
+        if (typeWithDot != null && typeof typeWithDot !== 'string')
+            return null;
         const raw = typeof typeWithDot === 'string' && typeWithDot.trim() ? typeWithDot.trim() : '_http._tcp.';
-        const s = raw.replace(/\.$/, '');
-        const m = /^_([^.]+)\._(tcp|udp)$/.exec(s);
-        if (!m)
-            return { type: 'http', protocol: 'tcp' };
-        return { type: m[1], protocol: m[2] };
+        const m = /^_([a-z0-9](?:[a-z0-9-]{0,13}[a-z0-9])?)\._(tcp|udp)\.?$/i.exec(raw);
+        return m && /[a-z]/i.test(m[1]) && !m[1].includes('--')
+            ? { type: m[1].toLowerCase(), protocol: m[2].toLowerCase() }
+            : null;
+    }
+    validateName(name) {
+        return name != null &&
+            (typeof name !== 'string' || Buffer.byteLength(name.trim(), 'utf8') > 63 || /[\x00-\x1f\x7f]/.test(name))
+            ? 'Invalid instance name (maximum 63 UTF-8 bytes, no control characters)'
+            : null;
+    }
+    validateTxt(txt) {
+        if (txt == null)
+            return null;
+        if (!this.isRecord(txt))
+            return 'TXT must be an object of strings';
+        const keys = new Set();
+        let totalBytes = 0;
+        for (const [key, value] of Object.entries(txt)) {
+            if (!/^[\x20-\x7e]+$/.test(key) || key.includes('=') || keys.has(key.toLowerCase()))
+                return 'Invalid or duplicate TXT key';
+            if (typeof value !== 'string' || Buffer.byteLength(`${key}=${value}`, 'utf8') > 255)
+                return 'TXT entries must be strings of at most 255 UTF-8 bytes including key=';
+            totalBytes += Buffer.byteLength(`${key}=${value}`, 'utf8') + 1;
+            if (totalBytes > 1300)
+                return 'TXT record must fit in 1300 bytes including length prefixes';
+            keys.add(key.toLowerCase());
+        }
+        return null;
+    }
+    invalidTypeMessage(typeWithDot) {
+        return `Invalid service type: ${String(typeWithDot)} (expected e.g. "_http._tcp.")`;
+    }
+    normalizeTimeout(value) {
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return DEFAULT_DISCOVER_TIMEOUT_MS;
+        return Math.min(Math.max(0, Math.trunc(value)), MAX_TIMER_MS);
     }
     toFullType(type, protocol) {
         return `_${type}._${protocol}.`;
     }
-    hasCbStop(x) {
-        return !!x && typeof x.stop === 'function';
-    }
     async safeStopService(svc) {
-        if (!svc || !this.hasCbStop(svc))
+        if (!svc)
             return;
-        try {
-            await new Promise((res) => {
-                let settled = false;
-                const done = () => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    if (timeout)
-                        clearTimeout(timeout);
+        await new Promise((res, reject) => {
+            let settled = false;
+            const done = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeout)
+                    clearTimeout(timeout);
+                if (error)
+                    reject(error);
+                else
                     res();
-                };
-                const timeout = setTimeout(done, this.stopTimeoutMs);
-                try {
-                    svc.stop(done);
-                }
-                catch (e) {
-                    console.warn('[mDNS] service.stop threw:', e);
-                    done();
-                }
-            });
-        }
-        catch (err) {
-            console.warn('[mDNS] service.stop error:', err);
-        }
+            };
+            const timeout = setTimeout(() => done(new Error(`Timed out waiting for service stop after ${this.stopTimeoutMs}ms`)), this.stopTimeoutMs);
+            try {
+                svc.stop(done);
+            }
+            catch (e) {
+                done(e);
+            }
+        });
     }
     safeStopBrowser(b) {
         if (!b)
@@ -168,16 +286,31 @@ class mDNS {
      */
     async startBroadcast(options) {
         return this.withBroadcastLock(async () => {
+            var _a, _b;
             const safeOptions = (options !== null && options !== void 0 ? options : {});
-            const portError = this.validatePort(safeOptions.port);
+            const portError = (_b = (_a = this.validatePort(safeOptions.port)) !== null && _a !== void 0 ? _a : this.validateName(safeOptions.name)) !== null && _b !== void 0 ? _b : this.validateTxt(safeOptions.txt);
             if (portError)
-                return { publishing: false, name: '', error: true, errorMessage: portError };
+                return { publishing: !!this.advertiser, name: '', error: true, errorMessage: portError };
             if (this.destroyed)
                 return { publishing: false, name: '', error: true, errorMessage: 'mDNS instance is destroyed' };
-            await this.stopBroadcastUnlocked();
-            const { type, protocol } = this.parseType(safeOptions.type);
+            if (this.networkError)
+                return { publishing: !!this.advertiser, name: '', error: true, errorMessage: this.networkError };
+            const parsed = this.parseType(safeOptions.type);
+            if (!parsed) {
+                return {
+                    publishing: !!this.advertiser,
+                    name: '',
+                    error: true,
+                    errorMessage: this.invalidTypeMessage(safeOptions.type),
+                };
+            }
+            const { type, protocol } = parsed;
+            const stopped = await this.stopBroadcastUnlocked();
+            if (stopped.error)
+                return Object.assign(Object.assign({}, stopped), { name: '' });
             return new Promise((resolve) => {
                 let settled = false;
+                let failing = false;
                 let timeout = null;
                 const safeResolve = (r) => {
                     if (!settled) {
@@ -186,6 +319,7 @@ class mDNS {
                             clearTimeout(timeout);
                             timeout = null;
                         }
+                        this.pendingPublishError = undefined;
                         resolve(r);
                     }
                 };
@@ -209,32 +343,68 @@ class mDNS {
                         }
                     };
                     const onUp = () => {
+                        if (failing || settled)
+                            return;
                         cleanupListeners();
                         safeResolve({ publishing: true, name: svc.name || '', error: false, errorMessage: null });
                     };
-                    const onError = (err) => {
-                        cleanupListeners();
-                        void this.safeStopService(svc);
-                        if (this.advertiser === svc)
-                            this.advertiser = undefined;
-                        safeResolve({ publishing: false, name: '', error: true, errorMessage: this.toErr(err) });
-                    };
-                    const onTimeout = () => {
+                    const onError = async (err) => {
+                        if (failing || settled)
+                            return;
+                        failing = true;
+                        if (timeout)
+                            clearTimeout(timeout);
+                        timeout = null;
                         cleanupListeners();
-                        void this.safeStopService(svc);
-                        if (this.advertiser === svc)
-                            this.advertiser = undefined;
+                        const stopped = await this.stopBroadcastUnlocked();
                         safeResolve({
-                            publishing: false,
+                            publishing: stopped.publishing,
                             name: '',
                             error: true,
-                            errorMessage: `Timed out waiting for service publish after ${this.publishTimeoutMs}ms`,
+                            errorMessage: [this.toErr(err), stopped.errorMessage].filter(Boolean).join('; '),
                         });
                     };
+                    const onTimeout = () => {
+                        void onError(new Error(svc.activated === false
+                            ? 'Service name is already in use on the network'
+                            : `Timed out waiting for service publish after ${this.publishTimeoutMs}ms`));
+                    };
+                    // shortcut: Bonjour 1.4 sends goodbye for conflicting probes; remove this hook when its probe teardown is fixed.
+                    const serviceRecords = svc.records;
+                    let announcementStarted = svc.published === true;
+                    svc.records = () => {
+                        if (svc.destroyed)
+                            return [];
+                        // Bonjour sets published only after the send callback, but records are already registered before it.
+                        announcementStarted = true;
+                        return serviceRecords.call(svc);
+                    };
+                    const stop = svc.stop.bind(svc);
+                    svc.stop = (callback) => {
+                        const announced = announcementStarted || svc.published === true;
+                        const conflict = !callback && svc.activated && !announced;
+                        const records = svc.records;
+                        if (!announced)
+                            svc.records = () => [];
+                        try {
+                            stop(callback);
+                            svc.destroyed = true;
+                        }
+                        finally {
+                            svc.records = records;
+                        }
+                        if (conflict)
+                            void onError(new Error('Service name is already in use on the network'));
+                    };
                     svc.once('up', onUp);
                     svc.once('error', onError);
                     timeout = setTimeout(onTimeout, this.publishTimeoutMs);
                     this.advertiser = svc;
+                    this.pendingPublishError = (error) => {
+                        void onError(error);
+                    };
+                    if (this.networkError)
+                        this.pendingPublishError(new Error(this.networkError));
                 }
                 catch (e) {
                     safeResolve({ publishing: false, name: '', error: true, errorMessage: this.toErr(e) });
@@ -258,7 +428,7 @@ class mDNS {
             return { publishing: false, error: false, errorMessage: null };
         }
         catch (e) {
-            return { publishing: false, error: true, errorMessage: this.toErr(e) };
+            return { publishing: !!this.advertiser, error: true, errorMessage: this.toErr(e) };
         }
     }
     /**
@@ -268,24 +438,51 @@ class mDNS {
      * @param options See MdnsDiscoverOptions for type/name/timeout.
      */
     async discover(options = {}) {
+        var _a;
         const safeOptions = (options !== null && options !== void 0 ? options : {});
         if (this.destroyed) {
             return { error: true, errorMessage: 'mDNS instance is destroyed', servicesFound: 0, services: [] };
         }
-        const { type, protocol } = this.parseType(safeOptions.type);
-        const targetId = typeof safeOptions.name === 'string' && safeOptions.name ? safeOptions.name : null;
-        const timeoutMs = typeof safeOptions.timeout === 'number' ? safeOptions.timeout : 3000;
+        if (this.networkError)
+            return { error: true, errorMessage: this.networkError, servicesFound: 0, services: [] };
+        const parsed = this.parseType(safeOptions.type);
+        if (!parsed) {
+            return {
+                error: true,
+                errorMessage: this.invalidTypeMessage(safeOptions.type),
+                servicesFound: 0,
+                services: [],
+            };
+        }
+        const inputError = (_a = this.validateName(safeOptions.name)) !== null && _a !== void 0 ? _a : (safeOptions.timeout != null && (typeof safeOptions.timeout !== 'number' || !Number.isFinite(safeOptions.timeout))
+            ? 'Invalid timeout'
+            : null);
+        if (inputError)
+            return { error: true, errorMessage: inputError, servicesFound: 0, services: [] };
+        for (const abort of [...this.activeDiscoveries])
+            abort('Discovery replaced by a new request');
+        const { type, protocol } = parsed;
+        const targetId = typeof safeOptions.name === 'string' && safeOptions.name.trim() ? safeOptions.name.trim() : null;
+        const timeoutMs = this.normalizeTimeout(safeOptions.timeout);
         let browser = null;
         const services = [];
         let hadError = false;
         let errMsg = null;
         return new Promise((resolve) => {
+            var _a;
             let timer = null;
             let settled = false;
-            const finish = () => {
+            const finish = (abortMessage) => {
+                var _a;
                 if (settled)
                     return;
                 settled = true;
+                this.activeDiscoveries.delete(finish);
+                (_a = this.transport) === null || _a === void 0 ? void 0 : _a.removeListener('response', onResponse);
+                if (abortMessage) {
+                    hadError = true;
+                    errMsg = abortMessage;
+                }
                 if (browser) {
                     this.safeStopBrowser(browser);
                     browser = null;
@@ -297,36 +494,66 @@ class mDNS {
                 resolve({
                     error: hadError,
                     errorMessage: errMsg,
-                    services,
-                    servicesFound: services.length,
+                    services: hadError ? [] : services.filter((s) => s.hosts.length > 0),
+                    servicesFound: hadError ? 0 : services.filter((s) => s.hosts.length > 0).length,
                 });
             };
+            const up = (s) => {
+                if (settled)
+                    return;
+                const item = this.serviceResult(s, this.toFullType(type, protocol));
+                if (!this.matchesTarget(item.name, targetId))
+                    return;
+                const previous = services.find((x) => x.name === item.name && x.port === item.port);
+                if (previous)
+                    Object.assign(previous, item, { hosts: this.orderHosts([...previous.hosts, ...item.hosts]) });
+                else
+                    services.push(item);
+                if (targetId && item.hosts.length)
+                    finish();
+                else if (!item.hosts.length && item.hostname) {
+                    this.queryAddresses(item.hostname);
+                }
+            };
+            const onResponse = (packet) => {
+                var _a, _b, _c;
+                if (settled)
+                    return;
+                const records = [...((_a = packet.answers) !== null && _a !== void 0 ? _a : []), ...((_b = packet.additionals) !== null && _b !== void 0 ? _b : [])];
+                for (const item of services) {
+                    for (const record of records) {
+                        if ((record.type === 'A' || record.type === 'AAAA') &&
+                            record.ttl &&
+                            typeof record.data === 'string' &&
+                            record.name.toLowerCase() === ((_c = item.hostname) === null || _c === void 0 ? void 0 : _c.toLowerCase()) &&
+                            !item.hosts.includes(record.data))
+                            item.hosts = this.orderHosts([...item.hosts, record.data]);
+                    }
+                }
+                if (targetId && services.some((item) => item.hosts.length))
+                    finish();
+            };
+            this.activeDiscoveries.add(finish);
             try {
-                browser = this.bonjour.find({ type, protocol }, (s) => {
-                    var _a;
-                    if (!this.matchesTarget(s.name || '', targetId))
-                        return;
-                    const item = {
-                        name: s.name || '',
-                        type: this.toFullType(type, protocol),
-                        domain: 'local.',
-                        port: (_a = s.port) !== null && _a !== void 0 ? _a : 0,
-                        hosts: Array.isArray(s.addresses) ? s.addresses.slice() : [],
-                        txt: s.txt && Object.keys(s.txt).length ? this.normalizeTxt(s.txt) : undefined,
-                    };
-                    const key = `${item.name}:${item.port}`;
-                    if (!services.some((x) => `${x.name}:${x.port}` === key))
-                        services.push(item);
-                    if (targetId && this.matchesTarget(item.name, targetId))
-                        finish();
-                });
+                const bonjour = this.bonjour;
+                if (settled)
+                    return;
+                (_a = this.transport) === null || _a === void 0 ? void 0 : _a.on('response', onResponse);
+                browser = bonjour.find({ type, protocol }, up);
+                if (settled) {
+                    this.safeStopBrowser(browser);
+                    browser = null;
+                    return;
+                }
+                browser.on('srv-update', up);
+                browser.on('txt-update', up);
                 // Record error and let the timeout conclude; results will still be returned.
                 const onBrowserError = (err) => {
                     hadError = true;
                     errMsg = this.toErr(err);
                 };
                 browser.on('error', onBrowserError);
-                timer = setTimeout(finish, Math.max(0, timeoutMs));
+                timer = setTimeout(() => finish(), timeoutMs);
             }
             catch (err) {
                 hadError = true;
@@ -338,6 +565,209 @@ class mDNS {
     normalizeTxt(txt) {
         return Object.fromEntries(Object.entries(txt).map(([key, value]) => [key, Buffer.isBuffer(value) ? value.toString('utf8') : String(value)]));
     }
+    queryAddresses(hostname) {
+        var _a, _b, _c, _d;
+        try {
+            (_b = (_a = this.transport) === null || _a === void 0 ? void 0 : _a.query) === null || _b === void 0 ? void 0 : _b.call(_a, hostname, 'A');
+            (_d = (_c = this.transport) === null || _c === void 0 ? void 0 : _c.query) === null || _d === void 0 ? void 0 : _d.call(_c, hostname, 'AAAA');
+        }
+        catch (err) {
+            this.onNetworkError(new Error(this.toErr(err)));
+        }
+    }
+    orderHosts(hosts) {
+        return [...new Set(hosts)].sort((a, b) => Number(node_net.isIPv4(b)) - Number(node_net.isIPv4(a)));
+    }
+    serviceResult(s, type) {
+        var _a, _b;
+        const suffix = `.${type}local`;
+        const name = ((_a = s.fqdn) === null || _a === void 0 ? void 0 : _a.toLowerCase().endsWith(suffix.toLowerCase())) ? s.fqdn.slice(0, -suffix.length) : s.name || '';
+        return Object.assign(Object.assign({ name,
+            type, domain: 'local.', port: (_b = s.port) !== null && _b !== void 0 ? _b : 0, hosts: this.orderHosts(Array.isArray(s.addresses) ? s.addresses : []) }, (s.host ? { hostname: s.host } : {})), (s.txt && Object.keys(s.txt).length ? { txt: this.normalizeTxt(s.txt) } : {}));
+    }
+    notify(event, data) {
+        var _a;
+        this.emit(event, data);
+        for (const win of (_a = electron.BrowserWindow === null || electron.BrowserWindow === void 0 ? void 0 : electron.BrowserWindow.getAllWindows()) !== null && _a !== void 0 ? _a : []) {
+            if (!win.isDestroyed() && !win.webContents.isDestroyed() && this.trustedUrl(win.webContents.getURL())) {
+                win.webContents.send(`event-mDNS-${event}`, data);
+                win.webContents.send(`mdns:event:${event}`, data);
+            }
+        }
+    }
+    /** Thanks to Idrimi for the original continuous discovery feature (PR #7). */
+    async watchServices(options) {
+        var _a;
+        const failed = (message) => ({ error: true, errorMessage: message, watchersStarted: 0 });
+        if (this.destroyed)
+            return failed('mDNS instance is destroyed');
+        if (this.networkError)
+            return failed(this.networkError);
+        if (!Array.isArray(options === null || options === void 0 ? void 0 : options.types) || !options.types.length)
+            return failed("Missing or empty 'types' array");
+        const types = new Map();
+        for (const raw of options.types) {
+            const parsed = typeof raw === 'string' && raw.trim() ? this.parseType(raw) : null;
+            if (!parsed)
+                return failed(this.invalidTypeMessage(raw));
+            types.set(this.toFullType(parsed.type, parsed.protocol), parsed);
+        }
+        const cleanup = this.stopWatch();
+        if (cleanup)
+            return failed(cleanup);
+        const bonjour = this.bonjour;
+        if (this.networkError)
+            return failed(this.networkError);
+        const watch = { types: [...types.keys()], browsers: [], services: new Map() };
+        this.watch = watch;
+        const addBrowser = (type, parsed) => {
+            let active = true;
+            const up = (s) => {
+                var _a;
+                if (this.watch !== watch || !active)
+                    return;
+                const service = this.serviceResult(s, type);
+                const key = `${type}|${service.name}`;
+                const previous = watch.services.get(key);
+                if (!service.hosts.length && (previous === null || previous === void 0 ? void 0 : previous.service.hostname) === service.hostname)
+                    service.hosts = [...((_a = previous === null || previous === void 0 ? void 0 : previous.service.hosts) !== null && _a !== void 0 ? _a : [])];
+                const isNew = !(previous === null || previous === void 0 ? void 0 : previous.announced) && service.hosts.length > 0;
+                watch.services.set(key, {
+                    service,
+                    fqdn: s.fqdn || `${service.name}.${type}local`,
+                    expires: s.ttl ? Date.now() + s.ttl * 1000 : Infinity,
+                    announced: !!(previous === null || previous === void 0 ? void 0 : previous.announced) || isNew,
+                });
+                if (!service.hosts.length && service.hostname)
+                    this.queryAddresses(service.hostname);
+                if (isNew)
+                    this.notify('serviceFound', { service: structuredClone(service) });
+            };
+            const browser = bonjour.find(parsed, up);
+            browser.on('down', (s) => {
+                if (this.watch !== watch || !active)
+                    return;
+                const key = `${type}|${this.serviceResult(s, type).name}`;
+                const previous = watch.services.get(key);
+                watch.services.delete(key);
+                if (previous === null || previous === void 0 ? void 0 : previous.announced)
+                    this.notify('serviceLost', { service: structuredClone(previous.service) });
+            });
+            browser.on('srv-update', up);
+            browser.on('txt-update', up);
+            this.deactivateBrowser.set(browser, () => {
+                active = false;
+            });
+            if (this.watch !== watch) {
+                this.stopWatchBrowser(browser);
+                return;
+            }
+            watch.browsers.push(browser);
+        };
+        try {
+            for (const [type, parsed] of types)
+                addBrowser(type, parsed);
+            if (this.watch !== watch)
+                return failed('Watch stopped during startup');
+            watch.onResponse = (packet) => {
+                var _a, _b;
+                if (this.watch !== watch)
+                    return;
+                const records = [...((_a = packet.answers) !== null && _a !== void 0 ? _a : []), ...((_b = packet.additionals) !== null && _b !== void 0 ? _b : [])];
+                for (const item of watch.services.values()) {
+                    const ptr = records.find((r) => r.type === 'PTR' && String(r.data).toLowerCase() === item.fqdn.toLowerCase());
+                    if (ptr)
+                        item.expires = Date.now() + ptr.ttl * 1000;
+                    const addresses = records.filter((r) => { var _a; return (r.type === 'A' || r.type === 'AAAA') && r.name.toLowerCase() === ((_a = item.service.hostname) === null || _a === void 0 ? void 0 : _a.toLowerCase()); });
+                    for (const address of addresses) {
+                        if (typeof address.data !== 'string')
+                            continue;
+                        const hosts = item.service.hosts.filter((host) => host !== address.data);
+                        item.service.hosts = this.orderHosts(address.ttl ? [...hosts, address.data] : hosts);
+                    }
+                    if (!item.announced && item.service.hosts.length) {
+                        item.announced = true;
+                        this.notify('serviceFound', { service: structuredClone(item.service) });
+                        if (this.watch !== watch)
+                            return;
+                    }
+                }
+            };
+            (_a = this.transport) === null || _a === void 0 ? void 0 : _a.on('response', watch.onResponse);
+            let ticks = 0;
+            watch.timer = setInterval(() => {
+                var _a;
+                if (this.watch !== watch)
+                    return;
+                try {
+                    const expired = [...watch.services.entries()].filter(([, item]) => item.expires <= Date.now());
+                    for (const [key, item] of expired) {
+                        watch.services.delete(key);
+                        if (item.announced)
+                            this.notify('serviceLost', { service: structuredClone(item.service) });
+                        if (this.watch !== watch)
+                            return;
+                    }
+                    // A fresh Browser forgets expired entries retained by bonjour-service's internal cache.
+                    if (expired.length) {
+                        for (const browser of watch.browsers.splice(0))
+                            this.stopWatchBrowser(browser);
+                        for (const [type, parsed] of types)
+                            addBrowser(type, parsed);
+                    }
+                    else if (++ticks % 30 === 0) {
+                        for (const browser of watch.browsers)
+                            (_a = browser.update) === null || _a === void 0 ? void 0 : _a.call(browser);
+                    }
+                }
+                catch (err) {
+                    this.onNetworkError(err instanceof Error ? err : new Error(this.toErr(err)));
+                }
+            }, 1000);
+            watch.timer.unref();
+            return { error: false, errorMessage: null, watchersStarted: types.size };
+        }
+        catch (err) {
+            this.stopWatch();
+            return failed(this.toErr(err));
+        }
+    }
+    stopWatchBrowser(browser) {
+        var _a;
+        (_a = this.deactivateBrowser.get(browser)) === null || _a === void 0 ? void 0 : _a();
+        this.deactivateBrowser.delete(browser);
+        try {
+            browser.stop();
+            this.stoppedBrowsers.delete(browser);
+        }
+        catch (err) {
+            this.stoppedBrowsers.add(browser);
+            throw err;
+        }
+    }
+    stopWatch() {
+        var _a, _b;
+        const watch = this.watch;
+        this.watch = undefined;
+        if (watch === null || watch === void 0 ? void 0 : watch.timer)
+            clearInterval(watch.timer);
+        if (watch === null || watch === void 0 ? void 0 : watch.onResponse)
+            (_a = this.transport) === null || _a === void 0 ? void 0 : _a.removeListener('response', watch.onResponse);
+        const errors = [];
+        for (const browser of new Set([...((_b = watch === null || watch === void 0 ? void 0 : watch.browsers) !== null && _b !== void 0 ? _b : []), ...this.stoppedBrowsers])) {
+            try {
+                this.stopWatchBrowser(browser);
+            }
+            catch (err) {
+                errors.push(this.toErr(err));
+            }
+        }
+        return errors.length ? errors.join('; ') : null;
+    }
+    async stopWatching() {
+        const errorMessage = this.stopWatch();
+        return { watching: false, error: !!errorMessage, errorMessage };
+    }
 }
 
 exports.mDNS = mDNS;