@devioarts/capacitor-mdns 0.1.0 → 0.2.0

package/ios/Sources/mDNSPlugin/mDNSPlugin.swift

@@ -1,5 +1,6 @@
 import Capacitor
 import Foundation
+import CoreFoundation
 
 /**
  * Capacitor bridge for the iOS mDNS plugin.
@@ -23,24 +24,37 @@ public class mDNSPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "getPluginPlatform", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "startBroadcast", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "stopBroadcast", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "discover", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "discover", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "watchServices", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopWatching", returnType: CAPPluginReturnPromise)
     ]
 
     private let mdns = MDNS()
 
+    override public func load() {
+        super.load()
+        mdns.watchDelegate = self
+    }
+
     // MARK: - Helpers
 
     private func jnull(_ v: String?) -> Any {
         return v ?? NSNull()
     }
 
-    private func normalizeType(_ raw: String?) -> String {
-        var t = raw?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
-        if t.isEmpty { t = "_http._tcp." }
-        if t.last != "." { t += "." }
-        return t
+    private func stringOption(_ call: CAPPluginCall, _ key: String) throws -> String? {
+        guard let raw = call.options[key], !(raw is NSNull) else { return nil }
+        guard let value = raw as? String else { throw inputError("Invalid \(key)") }
+        return value
+    }
+    private func inputError(_ message: String) -> NSError {
+        NSError(domain: "mDNS", code: -1, userInfo: [NSLocalizedDescriptionKey: message])
+    }
+    private func numberOption(_ call: CAPPluginCall, _ key: String, fallback: Double) throws -> Double {
+        guard let raw = call.options[key], !(raw is NSNull) else { return fallback }
+        guard let value = raw as? NSNumber, CFGetTypeID(value) != CFBooleanGetTypeID(), value.doubleValue.isFinite else { throw inputError("Invalid \(key)") }
+        return value.doubleValue
     }
-
     // MARK: - API
 
     /// getPluginPlatform()
@@ -52,21 +66,23 @@ public class mDNSPlugin: CAPPlugin, CAPBridgedPlugin {
 
     /// startBroadcast({ type?, name?, port, txt? })
     @objc public func startBroadcast(_ call: CAPPluginCall) {
-        let type = normalizeType(call.getString("type"))
-        let name = (call.getString("name")?.trimmingCharacters(in: .whitespacesAndNewlines)).flatMap { $0.isEmpty ? nil : $0 } ?? "DevIOArtsMDNS"
-        let port = call.getInt("port") ?? 0
-        let txt  = call.getObject("txt") as? [String: String]
-
-        guard (1...65535).contains(port) else {
-            call.resolve([
-                "publishing": false,
-                "name": "",
-                "error": true,
-                "errorMessage": "Missing/invalid port"
-            ])
+        let type: String, name: String, port: Int, txt: [String: String]?
+        do {
+            type = try MDNS.validatedType(stringOption(call, "type") ?? "")
+            name = try MDNS.validatedName(stringOption(call, "name") ?? "")
+            let number = try numberOption(call, "port", fallback: 0)
+            guard (1...65535).contains(number), number.rounded(.towardZero) == number else { throw inputError("Missing/invalid port") }
+            port = Int(number)
+            let raw = call.options["txt"]
+            if raw == nil || raw is NSNull { txt = nil } else {
+                guard let values = raw as? [String: String] else { throw inputError("TXT must be an object of strings") }
+                txt = values
+            }
+            try MDNS.validateTXT(txt)
+        } catch {
+            call.resolve(["publishing": mdns.isPublishing, "name": "", "error": true, "errorMessage": error.localizedDescription])
             return
         }
-
         mdns.broadcast(type: type, name: name, port: port, txt: txt) { result in
             switch result {
             case .success(let finalName):
@@ -107,11 +123,17 @@ public class mDNSPlugin: CAPPlugin, CAPBridgedPlugin {
 
     /// discover({ type?, name?, timeout? })
     @objc public func discover(_ call: CAPPluginCall) {
-        let type = normalizeType(call.getString("type"))
-        let targetName = (call.getString("name")?.trimmingCharacters(in: .whitespacesAndNewlines)).flatMap { $0.isEmpty ? nil : $0 }
-        let timeout = call.getInt("timeout") ?? 3000
+        let type: String, targetName: String?, timeout: Int
+        do {
+            type = try MDNS.validatedType(stringOption(call, "type") ?? "")
+            let name = try MDNS.validatedName(stringOption(call, "name") ?? "")
+            targetName = name.isEmpty ? nil : name
+            timeout = Int(min(2_147_483_647, max(0, try numberOption(call, "timeout", fallback: 3000))))
+        } catch {
+            call.resolve(["error": true, "errorMessage": error.localizedDescription, "servicesFound": 0, "services": []])
+            return
+        }
         let useNW = call.getBool("useNW") ?? true
-
         mdns.discover(type: type, name: targetName, timeoutMs: timeout, useNW: useNW) { result in
             switch result {
             case .success(let services):
@@ -131,4 +153,35 @@ public class mDNSPlugin: CAPPlugin, CAPBridgedPlugin {
             }
         }
     }
+
+    @objc public func watchServices(_ call: CAPPluginCall) {
+        guard let types = call.getArray("types", String.self), !types.isEmpty else {
+            call.resolve(["error": true, "errorMessage": "Expected a nonempty array of service types", "watchersStarted": 0])
+            return
+        }
+        mdns.watchServices(types: types) { result in
+            switch result {
+            case .success(let count): call.resolve(["error": false, "errorMessage": NSNull(), "watchersStarted": count])
+            case .failure(let error): call.resolve(["error": true, "errorMessage": error.localizedDescription, "watchersStarted": 0])
+            }
+        }
+    }
+
+    @objc public func stopWatching(_ call: CAPPluginCall) {
+        mdns.stopWatching {
+            call.resolve(["watching": false, "error": false, "errorMessage": NSNull()])
+        }
+    }
+}
+
+extension mDNSPlugin: MDNSWatchDelegate {
+    public func mdns(_ mdns: MDNS, didFindService service: [String: Any]) {
+        notifyListeners("serviceFound", data: ["service": service])
+    }
+    public func mdns(_ mdns: MDNS, didLoseService service: [String: Any]) {
+        notifyListeners("serviceLost", data: ["service": service])
+    }
+    public func mdns(_ mdns: MDNS, watchError type: String, message: String, watching: Bool) {
+        notifyListeners("watchError", data: ["type": type, "errorMessage": message, "watching": watching])
+    }
 }

package/ios/Tests/mDNSPluginTests/BridgeTests.swift

@@ -0,0 +1,46 @@
+import Capacitor
+import XCTest
+@testable import mDNSPlugin
+
+final class BridgeTests: XCTestCase {
+    private func invoke(_ method: String, options: [String: Any], perform: (CAPPluginCall) -> Void) throws -> [String: Any] {
+        var result: [String: Any]?
+        let call = try XCTUnwrap(CAPPluginCall(
+            callbackId: "test", methodName: method, options: options,
+            success: { response, _ in result = response?.data },
+            error: { _ in XCTFail("Invalid input must resolve with error: true") }
+        ))
+        perform(call)
+        return try XCTUnwrap(result)
+    }
+
+    func testBroadcastRejectsInvalidRawBridgeValues() throws {
+        let plugin = mDNSPlugin()
+        let cases: [[String: Any]] = [
+            ["port": 80.5], ["port": true], ["port": "80"], ["port": Double.nan],
+            ["port": 0], ["port": 65536], ["port": 80, "txt": ["a": 1]],
+            ["port": 80, "txt": ["a": true]], ["port": 80, "type": 1], ["port": 80, "name": true]
+        ]
+        for options in cases {
+            let result = try invoke("startBroadcast", options: options, perform: plugin.startBroadcast)
+            XCTAssertEqual(result["error"] as? Bool, true, "\(options)")
+            XCTAssertEqual(result["publishing"] as? Bool, false)
+            XCTAssertEqual(result["name"] as? String, "")
+            XCTAssertFalse(try XCTUnwrap(result["errorMessage"] as? String).isEmpty)
+        }
+    }
+
+    func testDiscoveryRejectsInvalidRawBridgeValues() throws {
+        let plugin = mDNSPlugin()
+        let cases: [[String: Any]] = [
+            ["timeout": true], ["timeout": "50"], ["timeout": Double.nan],
+            ["timeout": Double.infinity], ["type": 1], ["name": true]
+        ]
+        for options in cases {
+            let result = try invoke("discover", options: options, perform: plugin.discover)
+            XCTAssertEqual(result["error"] as? Bool, true)
+            XCTAssertEqual(result["servicesFound"] as? Int, 0)
+            XCTAssertTrue(try XCTUnwrap(result["services"] as? [Any]).isEmpty)
+        }
+    }
+}

package/ios/Tests/mDNSPluginTests/MDNSTests.swift

@@ -0,0 +1,490 @@
+import XCTest
+import Network
+@testable import mDNSPlugin
+
+// MARK: - Fakes
+
+/// `NetService` that never touches the network; tests drive the delegate callbacks by hand.
+private final class FakeNetService: NetService {
+    var resolveCalls = 0
+    var publishCalls = 0
+    var stopCalls = 0
+    var fakePort = 8080
+    var fakeAddresses: [Data]?
+    var fakeTXT: Data?
+
+    override func resolve(withTimeout timeout: TimeInterval) { resolveCalls += 1 }
+    override func publish() { publishCalls += 1 }
+    override func stop() { stopCalls += 1 }
+    override var port: Int { fakePort }
+    override var addresses: [Data]? { fakeAddresses }
+    override func txtRecordData() -> Data? { fakeTXT }
+}
+
+private final class FakeBrowser: NetServiceBrowser {
+    var stopCalls = 0
+    override func searchForServices(ofType type: String, inDomain domainString: String) {}
+    override func stop() { stopCalls += 1 }
+}
+
+private final class WatchProbe: MDNSWatchDelegate {
+    var found: [[String: Any]] = []
+    var lost: [[String: Any]] = []
+    var errors: [(String, Bool)] = []
+    func mdns(_ mdns: MDNS, didFindService service: [String: Any]) { found.append(service) }
+    func mdns(_ mdns: MDNS, didLoseService service: [String: Any]) { lost.append(service) }
+    func mdns(_ mdns: MDNS, watchError type: String, message: String, watching: Bool) { errors.append((message, watching)) }
+}
+
+private final class Rig {
+    let mdns = MDNS()
+    var services: [FakeNetService] = []
+    var browsers: [FakeBrowser] = []
+
+    init(settleMs: Int = 30, publishTimeoutMs: Int = 5000) {
+        mdns.publishTimeoutMs = publishTimeoutMs
+        mdns.makeBrowser = { [weak self] in
+            let browser = FakeBrowser()
+            self?.browsers.append(browser)
+            return browser
+        }
+        mdns.makeService = { [weak self] domain, type, name, port in
+            let s = port.map { FakeNetService(domain: domain, type: type, name: name, port: $0) }
+                ?? FakeNetService(domain: domain, type: type, name: name)
+            self?.services.append(s)
+            return s
+        }
+    }
+
+    /// Start a discovery on the fallback browser and record its outcome.
+    func discover(name: String? = nil, timeoutMs: Int = 2000, outcome: @escaping (Result<[[String: Any]], Error>) -> Void) {
+        mdns.discover(type: "_http._tcp.", name: name, timeoutMs: timeoutMs, useNW: false, completion: outcome)
+    }
+
+    func found(_ name: String, type: String = "_http._tcp.", domain: String = "local.") {
+        mdns.handleServiceFound(name: name, type: type, domain: domain)
+    }
+
+    func resolve(_ service: FakeNetService, host: String = "192.168.1.5") {
+        var addr = sockaddr_in()
+        addr.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
+        addr.sin_family = sa_family_t(AF_INET)
+        inet_pton(AF_INET, host, &addr.sin_addr)
+        service.fakeAddresses = [withUnsafeBytes(of: &addr) { Data($0) }]
+        mdns.netServiceDidResolveAddress(service)
+    }
+}
+
+// MARK: - Tests
+
+final class MDNSTests: XCTestCase {
+
+    private func pause(_ seconds: TimeInterval) {
+        let e = expectation(description: "delay")
+        DispatchQueue.main.asyncAfter(deadline: .now() + seconds) { e.fulfill() }
+        wait(for: [e], timeout: seconds + 2)
+    }
+
+    func testBrowsingContinuesForTheEntireTimeoutAfterAnIdleResult() {
+        let rig = Rig()
+        var outcome: Result<[[String: Any]], Error>?
+        let done = expectation(description: "full timeout")
+        rig.discover(timeoutMs: 300) { outcome = $0; done.fulfill() }
+        rig.found("First")
+        rig.resolve(rig.services[0])
+        pause(0.15)
+        XCTAssertNil(outcome)
+        rig.found("Late")
+        rig.resolve(rig.services[1])
+        wait(for: [done], timeout: 1)
+        guard case .success(let services)? = outcome else { return XCTFail("expected success") }
+        XCTAssertEqual(services.count, 2)
+    }
+    func testNameMatchingTreatsDotsAndHyphensEqually() {
+        let rig = Rig()
+        var outcome: Result<[[String: Any]], Error>?
+        rig.discover(name: "My-Device") { outcome = $0 }
+        rig.found("My.Device")
+        rig.resolve(rig.services[0])
+        guard case .success(let services)? = outcome else { return XCTFail("expected early match") }
+        XCTAssertEqual(services.first?["name"] as? String, "My.Device")
+    }
+    func testValidationEnforcesDnsAndUtf8LimitsWithoutStoppingPublisher() {
+        let rig = Rig()
+        rig.mdns.broadcast(type: "_http._tcp.", name: "Good", port: 80, txt: nil) { _ in }
+        for type in ["_123._tcp.", "_ab--cd._tcp.", "_abcdefghijklmnop._tcp.", "http"] {
+            XCTAssertThrowsError(try MDNS.validatedType(type))
+        }
+        XCTAssertEqual(try? MDNS.validatedType(" _HTTP._TCP "), "_http._tcp.")
+        XCTAssertThrowsError(try MDNS.validatedName(String(repeating: "é", count: 32)))
+        for txt in [["": "x"], ["a=b": "x"], ["a": String(repeating: "é", count: 127)], ["A": "", "a": ""], Dictionary(uniqueKeysWithValues: (0..<6).map { ("k\($0)", String(repeating: "x", count: 250)) })] {
+            rig.mdns.broadcast(type: "_http._tcp.", name: "Bad", port: 81, txt: txt) { result in
+                guard case .failure = result else { return XCTFail("invalid TXT accepted") }
+            }
+            XCTAssertEqual(rig.services[0].stopCalls, 0)
+        }
+    }
+    // MARK: Discovery
+
+    func testSlowResolveDoesNotFinishBeforeTheServiceIsResolved() {
+        let rig = Rig(settleMs: 30)
+        var outcome: Result<[[String: Any]], Error>?
+        let done = expectation(description: "discovery")
+        rig.discover { outcome = $0; done.fulfill() }
+
+        rig.found("A")
+        pause(0.15) // several debounce windows pass while the resolver is still outstanding
+        XCTAssertNil(outcome, "must not settle while a resolver is pending")
+
+        rig.resolve(rig.services[0])
+        wait(for: [done], timeout: 2)
+
+        guard case .success(let services)? = outcome else { return XCTFail("expected success") }
+        XCTAssertEqual(services.count, 1)
+        XCTAssertEqual(services.first?["name"] as? String, "A")
+        XCTAssertEqual(services.first?["port"] as? Int, 8080)
+        XCTAssertEqual(services.first?["hosts"] as? [String], ["192.168.1.5"])
+    }
+
+    func testRepeatedBrowseResultsDoNotSpawnDuplicateResolvers() {
+        let rig = Rig()
+        rig.discover { _ in }
+
+        // NWBrowser redelivers its full result set on every change, with un-normalized type/domain.
+        rig.found("A", type: "_http._tcp", domain: "local")
+        rig.found("A", type: "_http._tcp", domain: "local")
+        rig.found("A", type: "_http._tcp.", domain: "local.")
+        rig.found("A", type: "_http._tcp", domain: "")
+
+        XCTAssertEqual(rig.services.count, 1)
+        XCTAssertEqual(rig.services[0].resolveCalls, 1)
+    }
+
+    func testResolvedServiceWithoutAddressesKeepsWaitingForAddresses() {
+        let rig = Rig()
+        let done = expectation(description: "discovery")
+        rig.discover(name: "A", timeoutMs: 80) { outcome in
+            guard case .success(let services) = outcome else {
+                done.fulfill()
+                return XCTFail("expected success")
+            }
+            XCTAssertTrue(services.isEmpty)
+            done.fulfill()
+        }
+        rig.found("A")
+        rig.mdns.netServiceDidResolveAddress(rig.services[0])
+        wait(for: [done], timeout: 2)
+    }
+
+    func testTargetNameFiltersCandidatesAndFinishesEarly() {
+        let rig = Rig()
+        var outcome: Result<[[String: Any]], Error>?
+        let done = expectation(description: "discovery")
+        rig.discover(name: "Foo", timeoutMs: 10_000) { outcome = $0; done.fulfill() }
+
+        rig.found("Other")
+        XCTAssertEqual(rig.services.count, 0, "non-matching candidates must not be resolved")
+
+        rig.found("Foo (2)")
+        XCTAssertEqual(rig.services.count, 1)
+        rig.resolve(rig.services[0])
+        wait(for: [done], timeout: 1) // early exit, long before the 10s hard timeout
+
+        guard case .success(let services)? = outcome else { return XCTFail("expected success") }
+        XCTAssertEqual(services.compactMap { $0["name"] as? String }, ["Foo (2)"])
+    }
+
+    func testHardTimeoutReturnsOnlyResolvedServices() {
+        let rig = Rig()
+        var outcome: Result<[[String: Any]], Error>?
+        let done = expectation(description: "discovery")
+        rig.discover(timeoutMs: 80) { outcome = $0; done.fulfill() }
+
+        rig.found("NeverResolves")
+        wait(for: [done], timeout: 2)
+
+        guard case .success(let services)? = outcome else { return XCTFail("expected success") }
+        XCTAssertTrue(services.isEmpty)
+    }
+
+    func testUnresolvableServiceDoesNotBlockSettling() {
+        let rig = Rig(settleMs: 30)
+        var outcome: Result<[[String: Any]], Error>?
+        let done = expectation(description: "discovery")
+        rig.discover { outcome = $0; done.fulfill() }
+
+        rig.found("Bad")
+        rig.found("Good")
+        rig.mdns.netService(rig.services[0], didNotResolve: [:])
+        rig.resolve(rig.services[1])
+        wait(for: [done], timeout: 2)
+
+        guard case .success(let services)? = outcome else { return XCTFail("expected success") }
+        XCTAssertEqual(services.compactMap { $0["name"] as? String }, ["Good"])
+    }
+
+    func testNewDiscoveryReplacesTheOldOneAndIgnoresItsStaleCallbacks() {
+        let rig = Rig()
+        var first: Result<[[String: Any]], Error>?
+        var second: Result<[[String: Any]], Error>?
+        rig.discover { first = $0 }
+        rig.found("Old")
+        let stale = rig.services[0]
+
+        rig.discover { second = $0 }
+        guard case .failure(let err)? = first else { return XCTFail("first discovery must fail as replaced") }
+        XCTAssertTrue(err.localizedDescription.contains("replaced"))
+
+        rig.resolve(stale) // callback from the previous session
+        pause(0.1)
+        XCTAssertNil(second, "a stale resolver must not complete the new discovery")
+    }
+
+    // MARK: Publishing
+
+    func testPublishSuccessReportsServiceName() {
+        let rig = Rig()
+        var outcome: Result<String, Error>?
+        rig.mdns.broadcast(type: "_http._tcp.", name: "Svc", port: 8080, txt: ["k": "v"]) { outcome = $0 }
+
+        let svc = rig.services[0]
+        XCTAssertEqual(svc.publishCalls, 1)
+        rig.mdns.netServiceDidPublish(svc)
+
+        guard case .success(let name)? = outcome else { return XCTFail("expected success") }
+        XCTAssertEqual(name, "Svc")
+    }
+
+    func testPublishTimeoutFailsAndStopsThePublisher() {
+        let rig = Rig(publishTimeoutMs: 50)
+        let done = expectation(description: "publish")
+        var outcome: Result<String, Error>?
+        rig.mdns.broadcast(type: "_http._tcp.", name: "Svc", port: 8080, txt: nil) { outcome = $0; done.fulfill() }
+        wait(for: [done], timeout: 2)
+
+        guard case .failure(let err)? = outcome else { return XCTFail("expected failure") }
+        XCTAssertTrue(err.localizedDescription.contains("Timed out"))
+        XCTAssertEqual(rig.services[0].stopCalls, 1)
+    }
+
+    func testNewBroadcastFailsThePreviousPendingOne() {
+        let rig = Rig()
+        var first: Result<String, Error>?
+        var second: Result<String, Error>?
+        rig.mdns.broadcast(type: "_http._tcp.", name: "A", port: 1, txt: nil) { first = $0 }
+        rig.mdns.broadcast(type: "_http._tcp.", name: "B", port: 2, txt: nil) { second = $0 }
+
+        guard case .failure(let err)? = first else { return XCTFail("first broadcast must fail as replaced") }
+        XCTAssertTrue(err.localizedDescription.contains("Replaced"))
+        XCTAssertNil(second)
+        XCTAssertEqual(rig.services[0].stopCalls, 1)
+
+        rig.mdns.netServiceDidPublish(rig.services[0]) // stale publisher: ignored
+        XCTAssertNil(second)
+        rig.mdns.netServiceDidPublish(rig.services[1])
+        guard case .success(let name)? = second else { return XCTFail("expected success") }
+        XCTAssertEqual(name, "B")
+    }
+
+    func testDidNotPublishReportsErrorAndAllowsRepublishing() {
+        let rig = Rig()
+        var first: Result<String, Error>?
+        rig.mdns.broadcast(type: "_http._tcp.", name: "A", port: 1, txt: nil) { first = $0 }
+        rig.mdns.netService(rig.services[0], didNotPublish: [NetService.errorCode: NSNumber(value: -72001)])
+
+        guard case .failure(let err)? = first else { return XCTFail("expected failure") }
+        XCTAssertEqual((err as NSError).code, -72001)
+
+        var second: Result<String, Error>?
+        rig.mdns.broadcast(type: "_http._tcp.", name: "A", port: 1, txt: nil) { second = $0 }
+        rig.mdns.netServiceDidPublish(rig.services[1])
+        guard case .success? = second else { return XCTFail("expected success") }
+    }
+
+    func testStopBroadcastIsIdempotentAndFailsAPendingPublish() throws {
+        let rig = Rig()
+        var outcome: Result<String, Error>?
+        rig.mdns.broadcast(type: "_http._tcp.", name: "A", port: 1, txt: nil) { outcome = $0 }
+
+        try rig.mdns.stopBroadcast()
+        try rig.mdns.stopBroadcast()
+
+        guard case .failure? = outcome else { return XCTFail("pending publish must be failed by stop") }
+        XCTAssertEqual(rig.services[0].stopCalls, 1)
+    }
+
+    func testInvalidPortFailsImmediately() {
+        let rig = Rig()
+        for port in [0, -1, 65536] {
+            var outcome: Result<String, Error>?
+            rig.mdns.broadcast(type: "_http._tcp.", name: "A", port: port, txt: nil) { outcome = $0 }
+            guard case .failure? = outcome else { return XCTFail("port \(port) must be rejected") }
+        }
+        XCTAssertTrue(rig.services.isEmpty)
+    }
+
+    // MARK: Helpers
+
+    func testParseHostsHandlesIPv4AndIPv6() {
+        var v4 = sockaddr_in()
+        v4.sin_len = UInt8(MemoryLayout<sockaddr_in>.size)
+        v4.sin_family = sa_family_t(AF_INET)
+        inet_pton(AF_INET, "10.1.2.3", &v4.sin_addr)
+
+        var v6 = sockaddr_in6()
+        v6.sin6_len = UInt8(MemoryLayout<sockaddr_in6>.size)
+        v6.sin6_family = sa_family_t(AF_INET6)
+        inet_pton(AF_INET6, "fe80::1", &v6.sin6_addr)
+
+        let hosts = parseHosts([withUnsafeBytes(of: &v6) { Data($0) }, withUnsafeBytes(of: &v4) { Data($0) }])
+        XCTAssertEqual(hosts, ["10.1.2.3", "fe80::1"])
+        XCTAssertEqual(parseHosts(nil), [])
+        XCTAssertEqual(parseHosts([]), [])
+
+        v6.sin6_scope_id = 7
+        XCTAssertEqual(parseHosts([withUnsafeBytes(of: &v6) { Data($0) }]), ["fe80::1%7"])
+    }
+
+    func testLocalNetworkDeniedDetection() {
+        XCTAssertTrue(MDNS.isLocalNetworkDenied(.dns(-65570)))
+        XCTAssertFalse(MDNS.isLocalNetworkDenied(.dns(-65537)))
+        XCTAssertFalse(MDNS.isLocalNetworkDenied(.posix(.ECONNREFUSED)))
+    }
+}
+
+// MARK: - Continuous discovery regressions
+
+extension MDNSTests {
+    private func watch(_ rig: Rig, _ probe: WatchProbe, types: [String] = ["_http._tcp."]) {
+        rig.mdns.watchDelegate = probe
+        rig.mdns.watchServices(types: types, useNW: false) { result in
+            guard case .success? = Optional(result) else { return XCTFail("watch failed: \(result)") }
+        }
+    }
+
+    func testWatchDeduplicatesTypesAndReturnsFullLostSnapshot() {
+        let rig = Rig()
+        let probe = WatchProbe()
+        watch(rig, probe, types: [" _http._tcp", "_http._tcp.", "_ipp._tcp."])
+        XCTAssertEqual(rig.browsers.count, 2)
+        let browser = rig.browsers[0]
+        let found = FakeNetService(domain: "local.", type: "_http._tcp.", name: "A")
+        rig.mdns.netServiceBrowser(browser, didFind: found, moreComing: false)
+        rig.mdns.netServiceBrowser(browser, didFind: found, moreComing: false)
+        XCTAssertEqual(rig.services.count, 1)
+        rig.resolve(rig.services[0])
+        XCTAssertEqual(probe.found.count, 1)
+        XCTAssertEqual(probe.found[0]["hosts"] as? [String], ["192.168.1.5"])
+        rig.mdns.netServiceBrowser(browser, didRemove: found, moreComing: false)
+        XCTAssertEqual(probe.lost.count, 1)
+        XCTAssertEqual(probe.lost[0] as NSDictionary, probe.found[0] as NSDictionary)
+        rig.mdns.stopWatching()
+        XCTAssertTrue(rig.browsers.allSatisfy { $0.stopCalls == 1 })
+    }
+
+    func testWatchLossAndStopIgnoreLateResolveAndBrowserCallbacks() {
+        let rig = Rig()
+        let probe = WatchProbe()
+        watch(rig, probe)
+        rig.mdns.handleWatchFound(name: "A", type: "_http._tcp", domain: "local")
+        let oldResolver = rig.services[0]
+        rig.mdns.handleWatchLost(name: "A", type: "_http._tcp.", domain: "local.")
+        rig.resolve(oldResolver)
+        XCTAssertTrue(probe.found.isEmpty)
+        XCTAssertTrue(probe.lost.isEmpty)
+        rig.mdns.handleWatchFound(name: "B", type: "_http._tcp.", domain: "local.")
+        let oldBrowser = rig.browsers[0]
+        rig.mdns.stopWatching()
+        watch(rig, probe)
+        rig.resolve(rig.services[1])
+        rig.mdns.netServiceBrowser(oldBrowser, didFind: oldResolver, moreComing: false)
+        rig.mdns.netServiceBrowser(oldBrowser, didNotSearch: [:])
+        XCTAssertTrue(probe.found.isEmpty)
+        XCTAssertTrue(probe.errors.isEmpty)
+        XCTAssertEqual(rig.services.count, 2)
+        rig.mdns.stopWatching()
+    }
+
+    func testWatchRetriesFailedResolveAndAllowsRediscoveryAfterExhaustion() {
+        let rig = Rig()
+        let probe = WatchProbe()
+        watch(rig, probe)
+        rig.mdns.handleWatchFound(name: "A", type: "_http._tcp.", domain: "local.")
+        for attempt in 0..<4 {
+            rig.mdns.netService(rig.services[attempt], didNotResolve: [:])
+            if attempt < 3 { pause(0.2) }
+        }
+        XCTAssertEqual(probe.errors.count, 1)
+        XCTAssertEqual(probe.errors[0].1, true)
+        rig.mdns.handleWatchFound(name: "A", type: "_http._tcp.", domain: "local.")
+        rig.resolve(rig.services[4])
+        XCTAssertEqual(probe.found.count, 1)
+        rig.mdns.stopWatching()
+    }
+
+    func testWatchRetriesWhenResolverNeverCallsBackAndCancelsRetryOnStop() {
+        let rig = Rig()
+        rig.mdns.resolveTimeoutSeconds = 0.03
+        watch(rig, WatchProbe())
+        rig.mdns.handleWatchFound(name: "A", type: "_http._tcp.", domain: "local.")
+        pause(0.22)
+        XCTAssertGreaterThanOrEqual(rig.services.count, 2)
+        rig.mdns.stopWatching()
+        let count = rig.services.count
+        pause(0.25)
+        XCTAssertEqual(rig.services.count, count)
+    }
+
+    func testWatchAndDiscoverStayIndependentAndInvalidReplacementKeepsWatch() {
+        let rig = Rig()
+        let probe = WatchProbe()
+        watch(rig, probe)
+        var discovery: Result<[[String: Any]], Error>?
+        rig.discover(name: "Once") { discovery = $0 }
+        rig.found("Once")
+        rig.mdns.handleWatchFound(name: "Watched", type: "_http._tcp.", domain: "local.")
+        rig.resolve(rig.services[1])
+        XCTAssertEqual(probe.found.count, 1)
+        XCTAssertNil(discovery)
+        for types in [[], [" "], ["http"]] {
+            rig.mdns.watchServices(types: types, useNW: false) { result in
+                guard case .failure = result else { return XCTFail("invalid watch accepted") }
+            }
+        }
+        XCTAssertEqual(rig.browsers[0].stopCalls, 0)
+        rig.mdns.stopWatching()
+        rig.resolve(rig.services[0])
+        pause(0.05)
+        guard case .success(let services)? = discovery else { return XCTFail("discovery failed") }
+        XCTAssertEqual(services.compactMap { $0["name"] as? String }, ["Once"])
+    }
+
+    func testNetworkWatchSnapshotsDeduplicateAndLossCancelsPendingResolution() {
+        let rig = Rig()
+        let probe = WatchProbe()
+        watch(rig, probe)
+        let values = [BrowseService(name: "A", type: "_http._tcp", domain: "local")]
+        rig.mdns.handleWatchResults(values, type: "_http._tcp.")
+        rig.mdns.handleWatchResults(values, type: "_http._tcp.")
+        XCTAssertEqual(rig.services.count, 1)
+        rig.mdns.handleWatchResults([], type: "_http._tcp.")
+        rig.resolve(rig.services[0])
+        XCTAssertTrue(probe.found.isEmpty)
+        XCTAssertTrue(probe.lost.isEmpty)
+        rig.mdns.stopWatching()
+    }
+
+    func testDeniedNetworkPermissionStopsWatchAndReportsError() {
+        let rig = Rig()
+        let probe = WatchProbe()
+        watch(rig, probe)
+        rig.mdns.handleWatchState(.waiting(.dns(-65570)), type: "_http._tcp.")
+        XCTAssertEqual(probe.errors.count, 1)
+        XCTAssertFalse(probe.errors[0].1)
+        XCTAssertTrue(probe.errors[0].0.contains("denied"))
+        XCTAssertEqual(rig.browsers[0].stopCalls, 1)
+        rig.mdns.handleWatchFound(name: "Late", type: "_http._tcp.", domain: "local.")
+        XCTAssertTrue(rig.services.isEmpty)
+    }
+
+}