@devioarts/capacitor-mdns 0.0.3 → 0.2.0

package/electron/dist/plugin.cjs.js

@@ -0,0 +1,774 @@
+'use strict';
+
+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 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 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;
+        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)
+            return;
+        try {
+            electron.ipcMain.removeHandler('mdns:startBroadcast');
+            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 */
+        }
+        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() {
+        if (!this.ipcRegistered)
+            return;
+        try {
+            electron.ipcMain.removeHandler('mdns:startBroadcast');
+            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;
+    }
+    /** 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 {
+                (_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);
+            }
+        });
+    }
+    // ----------------------------- utils -----------------------------
+    toErr(err) {
+        return err instanceof Error ? err.message : String(err);
+    }
+    validatePort(port) {
+        return Number.isInteger(port) && typeof port === 'number' && port > 0 && port <= 65535
+            ? null
+            : 'Missing/invalid port';
+    }
+    isRecord(value) {
+        return !!value && typeof value === 'object' && !Array.isArray(value);
+    }
+    withBroadcastLock(work) {
+        // Publish and stop share one Bonjour service; serializing them prevents orphaned advertisers.
+        const run = this.broadcastQueue.catch(() => undefined).then(work);
+        this.broadcastQueue = run.catch(() => undefined);
+        return run;
+    }
+    normalize(name) {
+        return name.replace(/ \(\d+\)$/, '').replace(/\./g, '-');
+    }
+    matchesTarget(candidate, target) {
+        if (!target)
+            return true;
+        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 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}.`;
+    }
+    async safeStopService(svc) {
+        if (!svc)
+            return;
+        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(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)
+            return;
+        try {
+            b.stop();
+        }
+        catch (err) {
+            console.warn('[mDNS] browser.stop error:', err);
+        }
+    }
+    // ----------------------------- API -----------------------------
+    /**
+     * Return the Electron main-process implementation marker.
+     */
+    async getPluginPlatform() {
+        return { platform: 'electron' };
+    }
+    /**
+     * Publish (advertise) a single Bonjour/mDNS service via bonjour-service.
+     * @param options See MdnsBroadcastOptions for type/name/port/txt.
+     * @returns Result indicating whether publishing is active and the final name.
+     */
+    async startBroadcast(options) {
+        return this.withBroadcastLock(async () => {
+            var _a, _b;
+            const safeOptions = (options !== null && options !== void 0 ? options : {});
+            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: !!this.advertiser, name: '', error: true, errorMessage: portError };
+            if (this.destroyed)
+                return { publishing: false, name: '', error: true, errorMessage: 'mDNS instance is destroyed' };
+            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) {
+                        settled = true;
+                        if (timeout) {
+                            clearTimeout(timeout);
+                            timeout = null;
+                        }
+                        this.pendingPublishError = undefined;
+                        resolve(r);
+                    }
+                };
+                try {
+                    const svc = this.bonjour.publish({
+                        name: typeof safeOptions.name === 'string' && safeOptions.name.trim()
+                            ? safeOptions.name.trim()
+                            : 'DevIOArtsMDNS',
+                        type,
+                        protocol,
+                        port: safeOptions.port,
+                        txt: this.isRecord(safeOptions.txt) ? this.normalizeTxt(safeOptions.txt) : undefined,
+                    });
+                    const cleanupListeners = () => {
+                        try {
+                            svc.removeListener('up', onUp);
+                            svc.removeListener('error', onError);
+                        }
+                        catch (_a) {
+                            /* ignore */
+                        }
+                    };
+                    const onUp = () => {
+                        if (failing || settled)
+                            return;
+                        cleanupListeners();
+                        safeResolve({ publishing: true, name: svc.name || '', error: false, errorMessage: null });
+                    };
+                    const onError = async (err) => {
+                        if (failing || settled)
+                            return;
+                        failing = true;
+                        if (timeout)
+                            clearTimeout(timeout);
+                        timeout = null;
+                        cleanupListeners();
+                        const stopped = await this.stopBroadcastUnlocked();
+                        safeResolve({
+                            publishing: stopped.publishing,
+                            name: '',
+                            error: true,
+                            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) });
+                }
+            });
+        });
+    }
+    /**
+     * Stop advertising the current service if any and clear internal state.
+     * @returns Result indicating whether the advertiser is active and error info.
+     */
+    async stopBroadcast() {
+        return this.withBroadcastLock(() => this.stopBroadcastUnlocked());
+    }
+    async stopBroadcastUnlocked() {
+        try {
+            if (this.advertiser) {
+                await this.safeStopService(this.advertiser);
+                this.advertiser = undefined;
+            }
+            return { publishing: false, error: false, errorMessage: null };
+        }
+        catch (e) {
+            return { publishing: !!this.advertiser, error: true, errorMessage: this.toErr(e) };
+        }
+    }
+    /**
+     * Discover services of the given type and optionally filter by instance name.
+     * Deduplicates by (name:port), collects IPv4/IPv6 addresses and TXT, and
+     * resolves with either an early-exit match or after a timeout.
+     * @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: [] };
+        }
+        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 = (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;
+                }
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+                resolve({
+                    error: hadError,
+                    errorMessage: errMsg,
+                    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 {
+                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(), timeoutMs);
+            }
+            catch (err) {
+                hadError = true;
+                errMsg = this.toErr(err);
+                finish();
+            }
+        });
+    }
+    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;
+//# sourceMappingURL=plugin.cjs.js.map