@agentdocumentformat/cli 0.7.7 → 0.8.0

package/dist/chunks/chunk-DDTTSKGG.mjs

@@ -0,0 +1,2443 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  require_es6
+} from "./chunk-KDDVQKCG.mjs";
+import {
+  peerName,
+  txtWithinBounds
+} from "./chunk-M2F7C2UJ.mjs";
+import {
+  __commonJS,
+  __require,
+  __toESM
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/bonjour-service/dist/lib/utils/dns-equal.js
+var require_dns_equal = __commonJS({
+  "node_modules/bonjour-service/dist/lib/utils/dns-equal.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.default = dnsEqual;
+    var capitalLetterRegex = /[A-Z]/g;
+    function toLowerCase(input) {
+      return input.toLowerCase();
+    }
+    function dnsEqual(a, b) {
+      let aFormatted = a.replace(capitalLetterRegex, toLowerCase), bFormatted = b.replace(capitalLetterRegex, toLowerCase);
+      return aFormatted === bFormatted;
+    }
+  }
+});
+
+// node_modules/bonjour-service/dist/lib/dns-txt.js
+var require_dns_txt = __commonJS({
+  "node_modules/bonjour-service/dist/lib/dns-txt.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.DnsTxt = void 0;
+    var DnsTxt = class {
+      constructor(opts = {}) {
+        this.binary = opts ? opts.binary : !1;
+      }
+      encode(data = {}) {
+        return Object.entries(data).map(([key, value]) => {
+          let item = `${key}=${value}`;
+          return Buffer.from(item);
+        });
+      }
+      decode(buffer) {
+        var data = {};
+        try {
+          let parts = buffer.toString().split(/=(.+)/), key = parts[0], value = parts[1];
+          data[key] = value;
+        } catch {
+        }
+        return data;
+      }
+      decodeAll(buffer) {
+        return buffer.filter((i) => i.length > 1).map((i) => this.decode(i)).reduce((prev, curr) => {
+          var obj = prev;
+          let [key] = Object.keys(curr), [value] = Object.values(curr);
+          return obj[key] = value, obj;
+        }, {});
+      }
+    };
+    exports.DnsTxt = DnsTxt;
+    exports.default = DnsTxt;
+  }
+});
+
+// node_modules/bonjour-service/dist/lib/service-types.js
+var require_service_types = __commonJS({
+  "node_modules/bonjour-service/dist/lib/service-types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.toType = exports.toString = void 0;
+    var Prefix = (name) => "_" + name, AllowedProp = (key) => ["name", "protocol", "subtype"].includes(key), toString = (data) => {
+      let formatted = {
+        name: data.name,
+        protocol: data.protocol,
+        subtype: data.subtype
+      };
+      return Object.entries(formatted).filter(([key, val]) => AllowedProp(key) && val !== void 0).reduce((prev, [key, val]) => (typeof val === "object" ? val.map((i) => prev.push(Prefix(i))) : prev.push(Prefix(val)), prev), []).join(".");
+    };
+    exports.toString = toString;
+    var toType = (string) => {
+      let parts = string.split("."), subtype;
+      for (let i in parts)
+        parts[i][0] === "_" && (parts[i] = parts[i].slice(1));
+      return parts.includes("sub") && (subtype = parts.shift(), parts.shift()), {
+        name: parts.shift(),
+        protocol: parts.shift() || null,
+        subtype
+      };
+    };
+    exports.toType = toType;
+  }
+});
+
+// node_modules/bonjour-service/dist/lib/service.js
+var require_service = __commonJS({
+  "node_modules/bonjour-service/dist/lib/service.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { default: mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.Service = void 0;
+    var os_1 = __importDefault(__require("os")), dns_txt_1 = __importDefault(require_dns_txt()), events_1 = __require("events"), service_types_1 = require_service_types(), TLD = ".local", Service = class extends events_1.EventEmitter {
+      constructor(config) {
+        if (super(), this.probe = !0, this.published = !1, this.activated = !1, this.destroyed = !1, this.txtService = new dns_txt_1.default(), !config.name)
+          throw new Error("ServiceConfig requires `name` property to be set");
+        if (!config.type)
+          throw new Error("ServiceConfig requires `type` property to be set");
+        if (!config.port)
+          throw new Error("ServiceConfig requires `port` property to be set");
+        this.name = config.name.split(".").join("-"), this.protocol = config.protocol || "tcp", this.type = (0, service_types_1.toString)({ name: config.type, protocol: this.protocol }), this.port = config.port, this.host = config.host || os_1.default.hostname(), this.fqdn = `${this.name}.${this.type}${TLD}`, this.txt = config.txt, this.subtypes = config.subtypes, this.disableIPv6 = !!config.disableIPv6;
+      }
+      records() {
+        var records = [this.RecordPTR(this), this.RecordSRV(this), this.RecordTXT(this)];
+        for (let subtype of this.subtypes || [])
+          records.push(this.RecordSubtypePTR(this, subtype));
+        let ifaces = Object.values(os_1.default.networkInterfaces());
+        for (let iface of ifaces) {
+          let addrs = iface;
+          for (let addr of addrs)
+            if (!(addr.internal || addr.mac === "00:00:00:00:00:00"))
+              switch (addr.family) {
+                case "IPv4":
+                  records.push(this.RecordA(this, addr.address));
+                  break;
+                case "IPv6":
+                  if (this.disableIPv6)
+                    break;
+                  records.push(this.RecordAAAA(this, addr.address));
+                  break;
+              }
+        }
+        return records;
+      }
+      RecordPTR(service) {
+        return {
+          name: `${service.type}${TLD}`,
+          type: "PTR",
+          ttl: 28800,
+          data: service.fqdn
+        };
+      }
+      RecordSubtypePTR(service, subtype) {
+        return {
+          name: `_${subtype}._sub.${service.type}${TLD}`,
+          type: "PTR",
+          ttl: 28800,
+          data: `${service.name}.${service.type}${TLD}`
+        };
+      }
+      RecordSRV(service) {
+        return {
+          name: service.fqdn,
+          type: "SRV",
+          ttl: 120,
+          data: {
+            port: service.port,
+            target: service.host
+          }
+        };
+      }
+      RecordTXT(service) {
+        return {
+          name: service.fqdn,
+          type: "TXT",
+          ttl: 4500,
+          data: this.txtService.encode(service.txt)
+        };
+      }
+      RecordA(service, ip) {
+        return {
+          name: service.host,
+          type: "A",
+          ttl: 120,
+          data: ip
+        };
+      }
+      RecordAAAA(service, ip) {
+        return {
+          name: service.host,
+          type: "AAAA",
+          ttl: 120,
+          data: ip
+        };
+      }
+    };
+    exports.Service = Service;
+    exports.default = Service;
+  }
+});
+
+// node_modules/bonjour-service/dist/lib/registry.js
+var require_registry = __commonJS({
+  "node_modules/bonjour-service/dist/lib/registry.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { default: mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.Registry = void 0;
+    var dns_equal_1 = __importDefault(require_dns_equal()), service_1 = __importDefault(require_service()), REANNOUNCE_MAX_MS = 3600 * 1e3, REANNOUNCE_FACTOR = 3, noop = function() {
+    }, Registry = class {
+      constructor(server) {
+        this.services = [], this.server = server;
+      }
+      publish(config) {
+        function start(service2, registry, opts) {
+          service2.activated || (service2.activated = !0, registry.services.push(service2), service2 instanceof service_1.default && (opts?.probe ? registry.probe(registry.server.mdns, service2, (exists) => {
+            if (exists) {
+              service2.stop !== void 0 && service2.stop(), console.log(new Error("Service name is already in use on the network"));
+              return;
+            }
+            registry.announce(registry.server, service2);
+          }) : registry.announce(registry.server, service2)));
+        }
+        function stop(service2, registry, callback) {
+          if (callback || (callback = noop), !service2.activated || !(service2 instanceof service_1.default))
+            return process.nextTick(callback);
+          registry.teardown(registry.server, service2, callback);
+          let index = registry.services.indexOf(service2);
+          index !== -1 && registry.services.splice(index, 1);
+        }
+        let service = new service_1.default(config);
+        return service.start = start.bind(null, service, this), service.stop = stop.bind(null, service, this), service.start({ probe: config.probe !== !1 }), service;
+      }
+      unpublishAll(callback) {
+        this.teardown(this.server, this.services, callback), this.services = [];
+      }
+      destroy() {
+        this.services.map((service) => service.destroyed = !0);
+      }
+      probe(mdns, service, callback) {
+        var sent = !1, retries = 0, timer;
+        let send = () => {
+          !service.activated || service.destroyed || mdns.query(service.fqdn, "ANY", function() {
+            sent = !0, timer = setTimeout(++retries < 3 ? send : done, 250), timer.unref();
+          });
+        }, onresponse = (packet) => {
+          sent && (packet.answers.some(matchRR) || packet.additionals.some(matchRR)) && done(!0);
+        }, matchRR = (rr) => (0, dns_equal_1.default)(rr.name, service.fqdn), done = (exists) => {
+          mdns.removeListener("response", onresponse), clearTimeout(timer), callback(!!exists);
+        };
+        mdns.on("response", onresponse), setTimeout(send, Math.random() * 250);
+      }
+      announce(server, service) {
+        var delay = 1e3, packet = service.records();
+        server.register(packet);
+        let broadcast = () => {
+          !service.activated || service.destroyed || server.mdns.respond(packet, function() {
+            service.published || (service.activated = !0, service.published = !0, service.emit("up")), delay = delay * REANNOUNCE_FACTOR, delay < REANNOUNCE_MAX_MS && !service.destroyed && setTimeout(broadcast, delay).unref();
+          });
+        };
+        broadcast();
+      }
+      teardown(server, services, callback) {
+        Array.isArray(services) || (services = [services]), services = services.filter((service) => service.activated);
+        var records = services.flatMap(function(service) {
+          service.activated = !1;
+          var records2 = service.records();
+          return records2.forEach((record) => {
+            record.ttl = 0;
+          }), records2;
+        });
+        if (records.length === 0)
+          return callback && process.nextTick(callback);
+        server.unregister(records), server.mdns.respond(records, function() {
+          services.forEach(function(service) {
+            service.published = !1;
+          }), typeof callback == "function" && callback.apply(null, arguments);
+        });
+      }
+    };
+    exports.Registry = Registry;
+    exports.default = Registry;
+  }
+});
+
+// node_modules/dns-packet/types.js
+var require_types = __commonJS({
+  "node_modules/dns-packet/types.js"(exports) {
+    "use strict";
+    exports.toString = function(type) {
+      switch (type) {
+        case 1:
+          return "A";
+        case 10:
+          return "NULL";
+        case 28:
+          return "AAAA";
+        case 18:
+          return "AFSDB";
+        case 42:
+          return "APL";
+        case 257:
+          return "CAA";
+        case 60:
+          return "CDNSKEY";
+        case 59:
+          return "CDS";
+        case 37:
+          return "CERT";
+        case 5:
+          return "CNAME";
+        case 49:
+          return "DHCID";
+        case 32769:
+          return "DLV";
+        case 39:
+          return "DNAME";
+        case 48:
+          return "DNSKEY";
+        case 43:
+          return "DS";
+        case 55:
+          return "HIP";
+        case 13:
+          return "HINFO";
+        case 45:
+          return "IPSECKEY";
+        case 25:
+          return "KEY";
+        case 36:
+          return "KX";
+        case 29:
+          return "LOC";
+        case 15:
+          return "MX";
+        case 35:
+          return "NAPTR";
+        case 2:
+          return "NS";
+        case 47:
+          return "NSEC";
+        case 50:
+          return "NSEC3";
+        case 51:
+          return "NSEC3PARAM";
+        case 12:
+          return "PTR";
+        case 46:
+          return "RRSIG";
+        case 17:
+          return "RP";
+        case 24:
+          return "SIG";
+        case 6:
+          return "SOA";
+        case 99:
+          return "SPF";
+        case 33:
+          return "SRV";
+        case 44:
+          return "SSHFP";
+        case 32768:
+          return "TA";
+        case 249:
+          return "TKEY";
+        case 52:
+          return "TLSA";
+        case 250:
+          return "TSIG";
+        case 16:
+          return "TXT";
+        case 252:
+          return "AXFR";
+        case 251:
+          return "IXFR";
+        case 41:
+          return "OPT";
+        case 255:
+          return "ANY";
+      }
+      return "UNKNOWN_" + type;
+    };
+    exports.toType = function(name) {
+      switch (name.toUpperCase()) {
+        case "A":
+          return 1;
+        case "NULL":
+          return 10;
+        case "AAAA":
+          return 28;
+        case "AFSDB":
+          return 18;
+        case "APL":
+          return 42;
+        case "CAA":
+          return 257;
+        case "CDNSKEY":
+          return 60;
+        case "CDS":
+          return 59;
+        case "CERT":
+          return 37;
+        case "CNAME":
+          return 5;
+        case "DHCID":
+          return 49;
+        case "DLV":
+          return 32769;
+        case "DNAME":
+          return 39;
+        case "DNSKEY":
+          return 48;
+        case "DS":
+          return 43;
+        case "HIP":
+          return 55;
+        case "HINFO":
+          return 13;
+        case "IPSECKEY":
+          return 45;
+        case "KEY":
+          return 25;
+        case "KX":
+          return 36;
+        case "LOC":
+          return 29;
+        case "MX":
+          return 15;
+        case "NAPTR":
+          return 35;
+        case "NS":
+          return 2;
+        case "NSEC":
+          return 47;
+        case "NSEC3":
+          return 50;
+        case "NSEC3PARAM":
+          return 51;
+        case "PTR":
+          return 12;
+        case "RRSIG":
+          return 46;
+        case "RP":
+          return 17;
+        case "SIG":
+          return 24;
+        case "SOA":
+          return 6;
+        case "SPF":
+          return 99;
+        case "SRV":
+          return 33;
+        case "SSHFP":
+          return 44;
+        case "TA":
+          return 32768;
+        case "TKEY":
+          return 249;
+        case "TLSA":
+          return 52;
+        case "TSIG":
+          return 250;
+        case "TXT":
+          return 16;
+        case "AXFR":
+          return 252;
+        case "IXFR":
+          return 251;
+        case "OPT":
+          return 41;
+        case "ANY":
+          return 255;
+        case "*":
+          return 255;
+      }
+      return name.toUpperCase().startsWith("UNKNOWN_") ? parseInt(name.slice(8)) : 0;
+    };
+  }
+});
+
+// node_modules/dns-packet/rcodes.js
+var require_rcodes = __commonJS({
+  "node_modules/dns-packet/rcodes.js"(exports) {
+    "use strict";
+    exports.toString = function(rcode) {
+      switch (rcode) {
+        case 0:
+          return "NOERROR";
+        case 1:
+          return "FORMERR";
+        case 2:
+          return "SERVFAIL";
+        case 3:
+          return "NXDOMAIN";
+        case 4:
+          return "NOTIMP";
+        case 5:
+          return "REFUSED";
+        case 6:
+          return "YXDOMAIN";
+        case 7:
+          return "YXRRSET";
+        case 8:
+          return "NXRRSET";
+        case 9:
+          return "NOTAUTH";
+        case 10:
+          return "NOTZONE";
+        case 11:
+          return "RCODE_11";
+        case 12:
+          return "RCODE_12";
+        case 13:
+          return "RCODE_13";
+        case 14:
+          return "RCODE_14";
+        case 15:
+          return "RCODE_15";
+      }
+      return "RCODE_" + rcode;
+    };
+    exports.toRcode = function(code) {
+      switch (code.toUpperCase()) {
+        case "NOERROR":
+          return 0;
+        case "FORMERR":
+          return 1;
+        case "SERVFAIL":
+          return 2;
+        case "NXDOMAIN":
+          return 3;
+        case "NOTIMP":
+          return 4;
+        case "REFUSED":
+          return 5;
+        case "YXDOMAIN":
+          return 6;
+        case "YXRRSET":
+          return 7;
+        case "NXRRSET":
+          return 8;
+        case "NOTAUTH":
+          return 9;
+        case "NOTZONE":
+          return 10;
+        case "RCODE_11":
+          return 11;
+        case "RCODE_12":
+          return 12;
+        case "RCODE_13":
+          return 13;
+        case "RCODE_14":
+          return 14;
+        case "RCODE_15":
+          return 15;
+      }
+      return 0;
+    };
+  }
+});
+
+// node_modules/dns-packet/opcodes.js
+var require_opcodes = __commonJS({
+  "node_modules/dns-packet/opcodes.js"(exports) {
+    "use strict";
+    exports.toString = function(opcode) {
+      switch (opcode) {
+        case 0:
+          return "QUERY";
+        case 1:
+          return "IQUERY";
+        case 2:
+          return "STATUS";
+        case 3:
+          return "OPCODE_3";
+        case 4:
+          return "NOTIFY";
+        case 5:
+          return "UPDATE";
+        case 6:
+          return "OPCODE_6";
+        case 7:
+          return "OPCODE_7";
+        case 8:
+          return "OPCODE_8";
+        case 9:
+          return "OPCODE_9";
+        case 10:
+          return "OPCODE_10";
+        case 11:
+          return "OPCODE_11";
+        case 12:
+          return "OPCODE_12";
+        case 13:
+          return "OPCODE_13";
+        case 14:
+          return "OPCODE_14";
+        case 15:
+          return "OPCODE_15";
+      }
+      return "OPCODE_" + opcode;
+    };
+    exports.toOpcode = function(code) {
+      switch (code.toUpperCase()) {
+        case "QUERY":
+          return 0;
+        case "IQUERY":
+          return 1;
+        case "STATUS":
+          return 2;
+        case "OPCODE_3":
+          return 3;
+        case "NOTIFY":
+          return 4;
+        case "UPDATE":
+          return 5;
+        case "OPCODE_6":
+          return 6;
+        case "OPCODE_7":
+          return 7;
+        case "OPCODE_8":
+          return 8;
+        case "OPCODE_9":
+          return 9;
+        case "OPCODE_10":
+          return 10;
+        case "OPCODE_11":
+          return 11;
+        case "OPCODE_12":
+          return 12;
+        case "OPCODE_13":
+          return 13;
+        case "OPCODE_14":
+          return 14;
+        case "OPCODE_15":
+          return 15;
+      }
+      return 0;
+    };
+  }
+});
+
+// node_modules/dns-packet/classes.js
+var require_classes = __commonJS({
+  "node_modules/dns-packet/classes.js"(exports) {
+    "use strict";
+    exports.toString = function(klass) {
+      switch (klass) {
+        case 1:
+          return "IN";
+        case 2:
+          return "CS";
+        case 3:
+          return "CH";
+        case 4:
+          return "HS";
+        case 255:
+          return "ANY";
+      }
+      return "UNKNOWN_" + klass;
+    };
+    exports.toClass = function(name) {
+      switch (name.toUpperCase()) {
+        case "IN":
+          return 1;
+        case "CS":
+          return 2;
+        case "CH":
+          return 3;
+        case "HS":
+          return 4;
+        case "ANY":
+          return 255;
+      }
+      return 0;
+    };
+  }
+});
+
+// node_modules/dns-packet/optioncodes.js
+var require_optioncodes = __commonJS({
+  "node_modules/dns-packet/optioncodes.js"(exports) {
+    "use strict";
+    exports.toString = function(type) {
+      switch (type) {
+        // list at
+        // https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-11
+        case 1:
+          return "LLQ";
+        case 2:
+          return "UL";
+        case 3:
+          return "NSID";
+        case 5:
+          return "DAU";
+        case 6:
+          return "DHU";
+        case 7:
+          return "N3U";
+        case 8:
+          return "CLIENT_SUBNET";
+        case 9:
+          return "EXPIRE";
+        case 10:
+          return "COOKIE";
+        case 11:
+          return "TCP_KEEPALIVE";
+        case 12:
+          return "PADDING";
+        case 13:
+          return "CHAIN";
+        case 14:
+          return "KEY_TAG";
+        case 26946:
+          return "DEVICEID";
+      }
+      return type < 0 ? null : `OPTION_${type}`;
+    };
+    exports.toCode = function(name) {
+      if (typeof name == "number")
+        return name;
+      if (!name)
+        return -1;
+      switch (name.toUpperCase()) {
+        case "OPTION_0":
+          return 0;
+        case "LLQ":
+          return 1;
+        case "UL":
+          return 2;
+        case "NSID":
+          return 3;
+        case "OPTION_4":
+          return 4;
+        case "DAU":
+          return 5;
+        case "DHU":
+          return 6;
+        case "N3U":
+          return 7;
+        case "CLIENT_SUBNET":
+          return 8;
+        case "EXPIRE":
+          return 9;
+        case "COOKIE":
+          return 10;
+        case "TCP_KEEPALIVE":
+          return 11;
+        case "PADDING":
+          return 12;
+        case "CHAIN":
+          return 13;
+        case "KEY_TAG":
+          return 14;
+        case "DEVICEID":
+          return 26946;
+        case "OPTION_65535":
+          return 65535;
+      }
+      let m = name.match(/_(\d+)$/);
+      return m ? parseInt(m[1], 10) : -1;
+    };
+  }
+});
+
+// node_modules/@leichtgewicht/ip-codec/index.cjs
+var require_ip_codec = __commonJS({
+  "node_modules/@leichtgewicht/ip-codec/index.cjs"(exports, module) {
+    "use strict";
+    var ipCodec = (function(exports2) {
+      "use strict";
+      Object.defineProperty(exports2, "__esModule", {
+        value: !0
+      }), exports2.decode = decode, exports2.encode = encode, exports2.familyOf = familyOf, exports2.name = void 0, exports2.sizeOf = sizeOf, exports2.v6 = exports2.v4 = void 0;
+      let v4Regex = /^(\d{1,3}\.){3,3}\d{1,3}$/, v4Size = 4, v6Regex = /^(::)?(((\d{1,3}\.){3}(\d{1,3}){1})?([0-9a-f]){0,4}:{0,2}){1,8}(::)?$/i, v6Size = 16, v4 = {
+        name: "v4",
+        size: v4Size,
+        isFormat: (ip) => v4Regex.test(ip),
+        encode(ip, buff, offset) {
+          offset = ~~offset, buff = buff || new Uint8Array(offset + v4Size);
+          let max = ip.length, n = 0;
+          for (let i = 0; i < max; ) {
+            let c = ip.charCodeAt(i++);
+            c === 46 ? (buff[offset++] = n, n = 0) : n = n * 10 + (c - 48);
+          }
+          return buff[offset] = n, buff;
+        },
+        decode(buff, offset) {
+          return offset = ~~offset, `${buff[offset++]}.${buff[offset++]}.${buff[offset++]}.${buff[offset]}`;
+        }
+      };
+      exports2.v4 = v4;
+      let v6 = {
+        name: "v6",
+        size: v6Size,
+        isFormat: (ip) => ip.length > 0 && v6Regex.test(ip),
+        encode(ip, buff, offset) {
+          offset = ~~offset;
+          let end = offset + v6Size, fill = -1, hexN = 0, decN = 0, prevColon = !0, useDec = !1;
+          buff = buff || new Uint8Array(offset + v6Size);
+          for (let i = 0; i < ip.length; i++) {
+            let c = ip.charCodeAt(i);
+            c === 58 ? (prevColon ? fill !== -1 ? (offset < end && (buff[offset] = 0), offset < end - 1 && (buff[offset + 1] = 0), offset += 2) : offset < end && (fill = offset) : (useDec === !0 ? (offset < end && (buff[offset] = decN), offset++) : (offset < end && (buff[offset] = hexN >> 8), offset < end - 1 && (buff[offset + 1] = hexN & 255), offset += 2), hexN = 0, decN = 0), prevColon = !0, useDec = !1) : c === 46 ? (offset < end && (buff[offset] = decN), offset++, decN = 0, hexN = 0, prevColon = !1, useDec = !0) : (prevColon = !1, c >= 97 ? c -= 87 : c >= 65 ? c -= 55 : (c -= 48, decN = decN * 10 + c), hexN = (hexN << 4) + c);
+          }
+          if (prevColon === !1)
+            useDec === !0 ? (offset < end && (buff[offset] = decN), offset++) : (offset < end && (buff[offset] = hexN >> 8), offset < end - 1 && (buff[offset + 1] = hexN & 255), offset += 2);
+          else if (fill === 0)
+            offset < end && (buff[offset] = 0), offset < end - 1 && (buff[offset + 1] = 0), offset += 2;
+          else if (fill !== -1) {
+            offset += 2;
+            for (let i = Math.min(offset - 1, end - 1); i >= fill + 2; i--)
+              buff[i] = buff[i - 2];
+            buff[fill] = 0, buff[fill + 1] = 0, fill = offset;
+          }
+          if (fill !== offset && fill !== -1)
+            for (offset > end - 2 && (offset = end - 2); end > fill; )
+              buff[--end] = offset < end && offset > fill ? buff[--offset] : 0;
+          else
+            for (; offset < end; )
+              buff[offset++] = 0;
+          return buff;
+        },
+        decode(buff, offset) {
+          offset = ~~offset;
+          let result = "";
+          for (let i = 0; i < v6Size; i += 2)
+            i !== 0 && (result += ":"), result += (buff[offset + i] << 8 | buff[offset + i + 1]).toString(16);
+          return result.replace(/(^|:)0(:0)*:0(:|$)/, "$1::$3").replace(/:{3,4}/, "::");
+        }
+      };
+      exports2.v6 = v6;
+      let name = "ip";
+      exports2.name = name;
+      function sizeOf(ip) {
+        if (v4.isFormat(ip)) return v4.size;
+        if (v6.isFormat(ip)) return v6.size;
+        throw Error(`Invalid ip address: ${ip}`);
+      }
+      function familyOf(string) {
+        return sizeOf(string) === v4.size ? 1 : 2;
+      }
+      function encode(ip, buff, offset) {
+        offset = ~~offset;
+        let size = sizeOf(ip);
+        return typeof buff == "function" && (buff = buff(offset + size)), size === v4.size ? v4.encode(ip, buff, offset) : v6.encode(ip, buff, offset);
+      }
+      function decode(buff, offset, length) {
+        if (offset = ~~offset, length = length || buff.length - offset, length === v4.size)
+          return v4.decode(buff, offset, length);
+        if (length === v6.size)
+          return v6.decode(buff, offset, length);
+        throw Error(`Invalid buffer size needs to be ${v4.size} for v4 or ${v6.size} for v6.`);
+      }
+      return "default" in exports2 ? exports2.default : exports2;
+    })({});
+    typeof define == "function" && define.amd ? define([], function() {
+      return ipCodec;
+    }) : typeof module == "object" && typeof exports == "object" && (module.exports = ipCodec);
+  }
+});
+
+// node_modules/dns-packet/index.js
+var require_dns_packet = __commonJS({
+  "node_modules/dns-packet/index.js"(exports) {
+    "use strict";
+    var Buffer2 = __require("buffer").Buffer, types = require_types(), rcodes = require_rcodes(), opcodes = require_opcodes(), classes = require_classes(), optioncodes = require_optioncodes(), ip = require_ip_codec(), QUERY_FLAG = 0, RESPONSE_FLAG = 32768, FLUSH_MASK = 32768, NOT_FLUSH_MASK = ~FLUSH_MASK, QU_MASK = 32768, NOT_QU_MASK = ~QU_MASK, name = exports.name = {};
+    name.encode = function(str, buf, offset, { mail = !1 } = {}) {
+      buf || (buf = Buffer2.alloc(name.encodingLength(str))), offset || (offset = 0);
+      let oldOffset = offset, n = str.replace(/^\.|\.$/gm, "");
+      if (n.length) {
+        let list = [];
+        if (mail) {
+          let localPart = "";
+          n.split(".").forEach((label) => {
+            label.endsWith("\\") ? localPart += (localPart.length ? "." : "") + label.slice(0, -1) : list.length === 0 && localPart.length ? list.push(localPart + "." + label) : list.push(label);
+          });
+        } else
+          list = n.split(".");
+        for (let i = 0; i < list.length; i++) {
+          let len = buf.write(list[i], offset + 1);
+          buf[offset] = len, offset += len + 1;
+        }
+      }
+      return buf[offset++] = 0, name.encode.bytes = offset - oldOffset, buf;
+    };
+    name.encode.bytes = 0;
+    name.decode = function(buf, offset, { mail = !1 } = {}) {
+      offset || (offset = 0);
+      let list = [], oldOffset = offset, totalLength = 0, consumedBytes = 0, jumped = !1;
+      for (; ; ) {
+        if (offset >= buf.length)
+          throw new Error("Cannot decode name (buffer overflow)");
+        let len = buf[offset++];
+        if (consumedBytes += jumped ? 0 : 1, len === 0)
+          break;
+        if ((len & 192) === 0) {
+          if (offset + len > buf.length)
+            throw new Error("Cannot decode name (buffer overflow)");
+          if (totalLength += len + 1, totalLength > 254)
+            throw new Error("Cannot decode name (name too long)");
+          let label = buf.toString("utf-8", offset, offset + len);
+          mail && (label = label.replace(/\./g, "\\.")), list.push(label), offset += len, consumedBytes += jumped ? 0 : len;
+        } else if ((len & 192) === 192) {
+          if (offset + 1 > buf.length)
+            throw new Error("Cannot decode name (buffer overflow)");
+          let jumpOffset = buf.readUInt16BE(offset - 1) - 49152;
+          if (jumpOffset >= oldOffset)
+            throw new Error("Cannot decode name (bad pointer)");
+          offset = jumpOffset, oldOffset = jumpOffset, consumedBytes += jumped ? 0 : 1, jumped = !0;
+        } else
+          throw new Error("Cannot decode name (bad label)");
+      }
+      return name.decode.bytes = consumedBytes, list.length === 0 ? "." : list.join(".");
+    };
+    name.decode.bytes = 0;
+    name.encodingLength = function(n) {
+      return n === "." || n === ".." ? 1 : Buffer2.byteLength(n.replace(/^\.|\.$/gm, "")) + 2;
+    };
+    var string = {};
+    string.encode = function(s, buf, offset) {
+      buf || (buf = Buffer2.alloc(string.encodingLength(s))), offset || (offset = 0);
+      let len = buf.write(s, offset + 1);
+      return buf[offset] = len, string.encode.bytes = len + 1, buf;
+    };
+    string.encode.bytes = 0;
+    string.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let len = buf[offset], s = buf.toString("utf-8", offset + 1, offset + 1 + len);
+      return string.decode.bytes = len + 1, s;
+    };
+    string.decode.bytes = 0;
+    string.encodingLength = function(s) {
+      return Buffer2.byteLength(s) + 1;
+    };
+    var header = {};
+    header.encode = function(h, buf, offset) {
+      buf || (buf = header.encodingLength(h)), offset || (offset = 0);
+      let flags = (h.flags || 0) & 32767, type = h.type === "response" ? RESPONSE_FLAG : QUERY_FLAG;
+      return buf.writeUInt16BE(h.id || 0, offset), buf.writeUInt16BE(flags | type, offset + 2), buf.writeUInt16BE(h.questions.length, offset + 4), buf.writeUInt16BE(h.answers.length, offset + 6), buf.writeUInt16BE(h.authorities.length, offset + 8), buf.writeUInt16BE(h.additionals.length, offset + 10), buf;
+    };
+    header.encode.bytes = 12;
+    header.decode = function(buf, offset) {
+      if (offset || (offset = 0), buf.length < 12) throw new Error("Header must be 12 bytes");
+      let flags = buf.readUInt16BE(offset + 2);
+      return {
+        id: buf.readUInt16BE(offset),
+        type: flags & RESPONSE_FLAG ? "response" : "query",
+        flags: flags & 32767,
+        flag_qr: (flags >> 15 & 1) === 1,
+        opcode: opcodes.toString(flags >> 11 & 15),
+        flag_aa: (flags >> 10 & 1) === 1,
+        flag_tc: (flags >> 9 & 1) === 1,
+        flag_rd: (flags >> 8 & 1) === 1,
+        flag_ra: (flags >> 7 & 1) === 1,
+        flag_z: (flags >> 6 & 1) === 1,
+        flag_ad: (flags >> 5 & 1) === 1,
+        flag_cd: (flags >> 4 & 1) === 1,
+        rcode: rcodes.toString(flags & 15),
+        questions: new Array(buf.readUInt16BE(offset + 4)),
+        answers: new Array(buf.readUInt16BE(offset + 6)),
+        authorities: new Array(buf.readUInt16BE(offset + 8)),
+        additionals: new Array(buf.readUInt16BE(offset + 10))
+      };
+    };
+    header.decode.bytes = 12;
+    header.encodingLength = function() {
+      return 12;
+    };
+    var runknown = exports.unknown = {};
+    runknown.encode = function(data, buf, offset) {
+      return buf || (buf = Buffer2.alloc(runknown.encodingLength(data))), offset || (offset = 0), buf.writeUInt16BE(data.length, offset), data.copy(buf, offset + 2), runknown.encode.bytes = data.length + 2, buf;
+    };
+    runknown.encode.bytes = 0;
+    runknown.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let len = buf.readUInt16BE(offset), data = buf.slice(offset + 2, offset + 2 + len);
+      return runknown.decode.bytes = len + 2, data;
+    };
+    runknown.decode.bytes = 0;
+    runknown.encodingLength = function(data) {
+      return data.length + 2;
+    };
+    var rns = exports.ns = {};
+    rns.encode = function(data, buf, offset) {
+      return buf || (buf = Buffer2.alloc(rns.encodingLength(data))), offset || (offset = 0), name.encode(data, buf, offset + 2), buf.writeUInt16BE(name.encode.bytes, offset), rns.encode.bytes = name.encode.bytes + 2, buf;
+    };
+    rns.encode.bytes = 0;
+    rns.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let len = buf.readUInt16BE(offset), dd = name.decode(buf, offset + 2);
+      return rns.decode.bytes = len + 2, dd;
+    };
+    rns.decode.bytes = 0;
+    rns.encodingLength = function(data) {
+      return name.encodingLength(data) + 2;
+    };
+    var rsoa = exports.soa = {};
+    rsoa.encode = function(data, buf, offset) {
+      buf || (buf = Buffer2.alloc(rsoa.encodingLength(data))), offset || (offset = 0);
+      let oldOffset = offset;
+      return offset += 2, name.encode(data.mname, buf, offset), offset += name.encode.bytes, name.encode(data.rname, buf, offset, { mail: !0 }), offset += name.encode.bytes, buf.writeUInt32BE(data.serial || 0, offset), offset += 4, buf.writeUInt32BE(data.refresh || 0, offset), offset += 4, buf.writeUInt32BE(data.retry || 0, offset), offset += 4, buf.writeUInt32BE(data.expire || 0, offset), offset += 4, buf.writeUInt32BE(data.minimum || 0, offset), offset += 4, buf.writeUInt16BE(offset - oldOffset - 2, oldOffset), rsoa.encode.bytes = offset - oldOffset, buf;
+    };
+    rsoa.encode.bytes = 0;
+    rsoa.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, data = {};
+      return offset += 2, data.mname = name.decode(buf, offset), offset += name.decode.bytes, data.rname = name.decode(buf, offset, { mail: !0 }), offset += name.decode.bytes, data.serial = buf.readUInt32BE(offset), offset += 4, data.refresh = buf.readUInt32BE(offset), offset += 4, data.retry = buf.readUInt32BE(offset), offset += 4, data.expire = buf.readUInt32BE(offset), offset += 4, data.minimum = buf.readUInt32BE(offset), offset += 4, rsoa.decode.bytes = offset - oldOffset, data;
+    };
+    rsoa.decode.bytes = 0;
+    rsoa.encodingLength = function(data) {
+      return 22 + name.encodingLength(data.mname) + name.encodingLength(data.rname);
+    };
+    var rtxt = exports.txt = {};
+    rtxt.encode = function(data, buf, offset) {
+      Array.isArray(data) || (data = [data]);
+      for (let i = 0; i < data.length; i++)
+        if (typeof data[i] == "string" && (data[i] = Buffer2.from(data[i])), !Buffer2.isBuffer(data[i]))
+          throw new Error("Must be a Buffer");
+      buf || (buf = Buffer2.alloc(rtxt.encodingLength(data))), offset || (offset = 0);
+      let oldOffset = offset;
+      return offset += 2, data.forEach(function(d) {
+        buf[offset++] = d.length, d.copy(buf, offset, 0, d.length), offset += d.length;
+      }), buf.writeUInt16BE(offset - oldOffset - 2, oldOffset), rtxt.encode.bytes = offset - oldOffset, buf;
+    };
+    rtxt.encode.bytes = 0;
+    rtxt.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, remaining = buf.readUInt16BE(offset);
+      offset += 2;
+      let data = [];
+      for (; remaining > 0; ) {
+        let len = buf[offset++];
+        if (--remaining, remaining < len)
+          throw new Error("Buffer overflow");
+        data.push(buf.slice(offset, offset + len)), offset += len, remaining -= len;
+      }
+      return rtxt.decode.bytes = offset - oldOffset, data;
+    };
+    rtxt.decode.bytes = 0;
+    rtxt.encodingLength = function(data) {
+      Array.isArray(data) || (data = [data]);
+      let length = 2;
+      return data.forEach(function(buf) {
+        typeof buf == "string" ? length += Buffer2.byteLength(buf) + 1 : length += buf.length + 1;
+      }), length;
+    };
+    var rnull = exports.null = {};
+    rnull.encode = function(data, buf, offset) {
+      buf || (buf = Buffer2.alloc(rnull.encodingLength(data))), offset || (offset = 0), typeof data == "string" && (data = Buffer2.from(data)), data || (data = Buffer2.alloc(0));
+      let oldOffset = offset;
+      offset += 2;
+      let len = data.length;
+      return data.copy(buf, offset, 0, len), offset += len, buf.writeUInt16BE(offset - oldOffset - 2, oldOffset), rnull.encode.bytes = offset - oldOffset, buf;
+    };
+    rnull.encode.bytes = 0;
+    rnull.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, len = buf.readUInt16BE(offset);
+      offset += 2;
+      let data = buf.slice(offset, offset + len);
+      return offset += len, rnull.decode.bytes = offset - oldOffset, data;
+    };
+    rnull.decode.bytes = 0;
+    rnull.encodingLength = function(data) {
+      return data ? (Buffer2.isBuffer(data) ? data.length : Buffer2.byteLength(data)) + 2 : 2;
+    };
+    var rhinfo = exports.hinfo = {};
+    rhinfo.encode = function(data, buf, offset) {
+      buf || (buf = Buffer2.alloc(rhinfo.encodingLength(data))), offset || (offset = 0);
+      let oldOffset = offset;
+      return offset += 2, string.encode(data.cpu, buf, offset), offset += string.encode.bytes, string.encode(data.os, buf, offset), offset += string.encode.bytes, buf.writeUInt16BE(offset - oldOffset - 2, oldOffset), rhinfo.encode.bytes = offset - oldOffset, buf;
+    };
+    rhinfo.encode.bytes = 0;
+    rhinfo.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, data = {};
+      return offset += 2, data.cpu = string.decode(buf, offset), offset += string.decode.bytes, data.os = string.decode(buf, offset), offset += string.decode.bytes, rhinfo.decode.bytes = offset - oldOffset, data;
+    };
+    rhinfo.decode.bytes = 0;
+    rhinfo.encodingLength = function(data) {
+      return string.encodingLength(data.cpu) + string.encodingLength(data.os) + 2;
+    };
+    var rptr = exports.ptr = {}, rcname = exports.cname = rptr, rdname = exports.dname = rptr;
+    rptr.encode = function(data, buf, offset) {
+      return buf || (buf = Buffer2.alloc(rptr.encodingLength(data))), offset || (offset = 0), name.encode(data, buf, offset + 2), buf.writeUInt16BE(name.encode.bytes, offset), rptr.encode.bytes = name.encode.bytes + 2, buf;
+    };
+    rptr.encode.bytes = 0;
+    rptr.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let data = name.decode(buf, offset + 2);
+      return rptr.decode.bytes = name.decode.bytes + 2, data;
+    };
+    rptr.decode.bytes = 0;
+    rptr.encodingLength = function(data) {
+      return name.encodingLength(data) + 2;
+    };
+    var rsrv = exports.srv = {};
+    rsrv.encode = function(data, buf, offset) {
+      buf || (buf = Buffer2.alloc(rsrv.encodingLength(data))), offset || (offset = 0), buf.writeUInt16BE(data.priority || 0, offset + 2), buf.writeUInt16BE(data.weight || 0, offset + 4), buf.writeUInt16BE(data.port || 0, offset + 6), name.encode(data.target, buf, offset + 8);
+      let len = name.encode.bytes + 6;
+      return buf.writeUInt16BE(len, offset), rsrv.encode.bytes = len + 2, buf;
+    };
+    rsrv.encode.bytes = 0;
+    rsrv.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let len = buf.readUInt16BE(offset), data = {};
+      return data.priority = buf.readUInt16BE(offset + 2), data.weight = buf.readUInt16BE(offset + 4), data.port = buf.readUInt16BE(offset + 6), data.target = name.decode(buf, offset + 8), rsrv.decode.bytes = len + 2, data;
+    };
+    rsrv.decode.bytes = 0;
+    rsrv.encodingLength = function(data) {
+      return 8 + name.encodingLength(data.target);
+    };
+    var rcaa = exports.caa = {};
+    rcaa.ISSUER_CRITICAL = 128;
+    rcaa.encode = function(data, buf, offset) {
+      let len = rcaa.encodingLength(data);
+      return buf || (buf = Buffer2.alloc(rcaa.encodingLength(data))), offset || (offset = 0), data.issuerCritical && (data.flags = rcaa.ISSUER_CRITICAL), buf.writeUInt16BE(len - 2, offset), offset += 2, buf.writeUInt8(data.flags || 0, offset), offset += 1, string.encode(data.tag, buf, offset), offset += string.encode.bytes, buf.write(data.value, offset), offset += Buffer2.byteLength(data.value), rcaa.encode.bytes = len, buf;
+    };
+    rcaa.encode.bytes = 0;
+    rcaa.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let len = buf.readUInt16BE(offset);
+      offset += 2;
+      let oldOffset = offset, data = {};
+      return data.flags = buf.readUInt8(offset), offset += 1, data.tag = string.decode(buf, offset), offset += string.decode.bytes, data.value = buf.toString("utf-8", offset, oldOffset + len), data.issuerCritical = !!(data.flags & rcaa.ISSUER_CRITICAL), rcaa.decode.bytes = len + 2, data;
+    };
+    rcaa.decode.bytes = 0;
+    rcaa.encodingLength = function(data) {
+      return string.encodingLength(data.tag) + string.encodingLength(data.value) + 2;
+    };
+    var rmx = exports.mx = {};
+    rmx.encode = function(data, buf, offset) {
+      buf || (buf = Buffer2.alloc(rmx.encodingLength(data))), offset || (offset = 0);
+      let oldOffset = offset;
+      return offset += 2, buf.writeUInt16BE(data.preference || 0, offset), offset += 2, name.encode(data.exchange, buf, offset), offset += name.encode.bytes, buf.writeUInt16BE(offset - oldOffset - 2, oldOffset), rmx.encode.bytes = offset - oldOffset, buf;
+    };
+    rmx.encode.bytes = 0;
+    rmx.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, data = {};
+      return offset += 2, data.preference = buf.readUInt16BE(offset), offset += 2, data.exchange = name.decode(buf, offset), offset += name.decode.bytes, rmx.decode.bytes = offset - oldOffset, data;
+    };
+    rmx.encodingLength = function(data) {
+      return 4 + name.encodingLength(data.exchange);
+    };
+    var ra = exports.a = {};
+    ra.encode = function(host, buf, offset) {
+      return buf || (buf = Buffer2.alloc(ra.encodingLength(host))), offset || (offset = 0), buf.writeUInt16BE(4, offset), offset += 2, ip.v4.encode(host, buf, offset), ra.encode.bytes = 6, buf;
+    };
+    ra.encode.bytes = 0;
+    ra.decode = function(buf, offset) {
+      offset || (offset = 0), offset += 2;
+      let host = ip.v4.decode(buf, offset);
+      return ra.decode.bytes = 6, host;
+    };
+    ra.decode.bytes = 0;
+    ra.encodingLength = function() {
+      return 6;
+    };
+    var raaaa = exports.aaaa = {};
+    raaaa.encode = function(host, buf, offset) {
+      return buf || (buf = Buffer2.alloc(raaaa.encodingLength(host))), offset || (offset = 0), buf.writeUInt16BE(16, offset), offset += 2, ip.v6.encode(host, buf, offset), raaaa.encode.bytes = 18, buf;
+    };
+    raaaa.encode.bytes = 0;
+    raaaa.decode = function(buf, offset) {
+      offset || (offset = 0), offset += 2;
+      let host = ip.v6.decode(buf, offset);
+      return raaaa.decode.bytes = 18, host;
+    };
+    raaaa.decode.bytes = 0;
+    raaaa.encodingLength = function() {
+      return 18;
+    };
+    var roption = exports.option = {};
+    roption.encode = function(option, buf, offset) {
+      buf || (buf = Buffer2.alloc(roption.encodingLength(option))), offset || (offset = 0);
+      let oldOffset = offset, code = optioncodes.toCode(option.code);
+      if (buf.writeUInt16BE(code, offset), offset += 2, option.data)
+        buf.writeUInt16BE(option.data.length, offset), offset += 2, option.data.copy(buf, offset), offset += option.data.length;
+      else
+        switch (code) {
+          // case 3: NSID.  No encode makes sense.
+          // case 5,6,7: Not implementable
+          case 8:
+            let spl = option.sourcePrefixLength || 0, fam = option.family || ip.familyOf(option.ip), ipBuf = ip.encode(option.ip, Buffer2.alloc), ipLen = Math.ceil(spl / 8);
+            buf.writeUInt16BE(ipLen + 4, offset), offset += 2, buf.writeUInt16BE(fam, offset), offset += 2, buf.writeUInt8(spl, offset++), buf.writeUInt8(option.scopePrefixLength || 0, offset++), ipBuf.copy(buf, offset, 0, ipLen), offset += ipLen;
+            break;
+          // case 9: EXPIRE (experimental)
+          // case 10: COOKIE.  No encode makes sense.
+          case 11:
+            option.timeout ? (buf.writeUInt16BE(2, offset), offset += 2, buf.writeUInt16BE(option.timeout, offset), offset += 2) : (buf.writeUInt16BE(0, offset), offset += 2);
+            break;
+          case 12:
+            let len = option.length || 0;
+            buf.writeUInt16BE(len, offset), offset += 2, buf.fill(0, offset, offset + len), offset += len;
+            break;
+          // case 13:  CHAIN.  Experimental.
+          case 14:
+            let tagsLen = option.tags.length * 2;
+            buf.writeUInt16BE(tagsLen, offset), offset += 2;
+            for (let tag of option.tags)
+              buf.writeUInt16BE(tag, offset), offset += 2;
+            break;
+          default:
+            throw new Error(`Unknown roption code: ${option.code}`);
+        }
+      return roption.encode.bytes = offset - oldOffset, buf;
+    };
+    roption.encode.bytes = 0;
+    roption.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let option = {};
+      option.code = buf.readUInt16BE(offset), option.type = optioncodes.toString(option.code), offset += 2;
+      let len = buf.readUInt16BE(offset);
+      switch (offset += 2, option.data = buf.slice(offset, offset + len), option.code) {
+        // case 3: NSID.  No decode makes sense.
+        case 8:
+          option.family = buf.readUInt16BE(offset), offset += 2, option.sourcePrefixLength = buf.readUInt8(offset++), option.scopePrefixLength = buf.readUInt8(offset++);
+          let padded = Buffer2.alloc(option.family === 1 ? 4 : 16);
+          buf.copy(padded, 0, offset, offset + len - 4), option.ip = ip.decode(padded);
+          break;
+        // case 12: Padding.  No decode makes sense.
+        case 11:
+          len > 0 && (option.timeout = buf.readUInt16BE(offset), offset += 2);
+          break;
+        case 14:
+          option.tags = [];
+          for (let i = 0; i < len; i += 2)
+            option.tags.push(buf.readUInt16BE(offset)), offset += 2;
+      }
+      return roption.decode.bytes = len + 4, option;
+    };
+    roption.decode.bytes = 0;
+    roption.encodingLength = function(option) {
+      if (option.data)
+        return option.data.length + 4;
+      switch (optioncodes.toCode(option.code)) {
+        case 8:
+          let spl = option.sourcePrefixLength || 0;
+          return Math.ceil(spl / 8) + 8;
+        case 11:
+          return typeof option.timeout == "number" ? 6 : 4;
+        case 12:
+          return option.length + 4;
+        case 14:
+          return 4 + option.tags.length * 2;
+      }
+      throw new Error(`Unknown roption code: ${option.code}`);
+    };
+    var ropt = exports.opt = {};
+    ropt.encode = function(options, buf, offset) {
+      buf || (buf = Buffer2.alloc(ropt.encodingLength(options))), offset || (offset = 0);
+      let oldOffset = offset, rdlen = encodingLengthList(options, roption);
+      return buf.writeUInt16BE(rdlen, offset), offset = encodeList(options, roption, buf, offset + 2), ropt.encode.bytes = offset - oldOffset, buf;
+    };
+    ropt.encode.bytes = 0;
+    ropt.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, options = [], rdlen = buf.readUInt16BE(offset);
+      offset += 2;
+      let o = 0;
+      for (; rdlen > 0; )
+        options[o++] = roption.decode(buf, offset), offset += roption.decode.bytes, rdlen -= roption.decode.bytes;
+      return ropt.decode.bytes = offset - oldOffset, options;
+    };
+    ropt.decode.bytes = 0;
+    ropt.encodingLength = function(options) {
+      return 2 + encodingLengthList(options || [], roption);
+    };
+    var rdnskey = exports.dnskey = {};
+    rdnskey.PROTOCOL_DNSSEC = 3;
+    rdnskey.ZONE_KEY = 128;
+    rdnskey.SECURE_ENTRYPOINT = 32768;
+    rdnskey.encode = function(key, buf, offset) {
+      buf || (buf = Buffer2.alloc(rdnskey.encodingLength(key))), offset || (offset = 0);
+      let oldOffset = offset, keydata = key.key;
+      if (!Buffer2.isBuffer(keydata))
+        throw new Error("Key must be a Buffer");
+      return offset += 2, buf.writeUInt16BE(key.flags, offset), offset += 2, buf.writeUInt8(rdnskey.PROTOCOL_DNSSEC, offset), offset += 1, buf.writeUInt8(key.algorithm, offset), offset += 1, keydata.copy(buf, offset, 0, keydata.length), offset += keydata.length, rdnskey.encode.bytes = offset - oldOffset, buf.writeUInt16BE(rdnskey.encode.bytes - 2, oldOffset), buf;
+    };
+    rdnskey.encode.bytes = 0;
+    rdnskey.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset;
+      var key = {}, length = buf.readUInt16BE(offset);
+      if (offset += 2, key.flags = buf.readUInt16BE(offset), offset += 2, buf.readUInt8(offset) !== rdnskey.PROTOCOL_DNSSEC)
+        throw new Error("Protocol must be 3");
+      return offset += 1, key.algorithm = buf.readUInt8(offset), offset += 1, key.key = buf.slice(offset, oldOffset + length + 2), offset += key.key.length, rdnskey.decode.bytes = offset - oldOffset, key;
+    };
+    rdnskey.decode.bytes = 0;
+    rdnskey.encodingLength = function(key) {
+      return 6 + Buffer2.byteLength(key.key);
+    };
+    var rrrsig = exports.rrsig = {};
+    rrrsig.encode = function(sig, buf, offset) {
+      buf || (buf = Buffer2.alloc(rrrsig.encodingLength(sig))), offset || (offset = 0);
+      let oldOffset = offset, signature = sig.signature;
+      if (!Buffer2.isBuffer(signature))
+        throw new Error("Signature must be a Buffer");
+      return offset += 2, buf.writeUInt16BE(types.toType(sig.typeCovered), offset), offset += 2, buf.writeUInt8(sig.algorithm, offset), offset += 1, buf.writeUInt8(sig.labels, offset), offset += 1, buf.writeUInt32BE(sig.originalTTL, offset), offset += 4, buf.writeUInt32BE(sig.expiration, offset), offset += 4, buf.writeUInt32BE(sig.inception, offset), offset += 4, buf.writeUInt16BE(sig.keyTag, offset), offset += 2, name.encode(sig.signersName, buf, offset), offset += name.encode.bytes, signature.copy(buf, offset, 0, signature.length), offset += signature.length, rrrsig.encode.bytes = offset - oldOffset, buf.writeUInt16BE(rrrsig.encode.bytes - 2, oldOffset), buf;
+    };
+    rrrsig.encode.bytes = 0;
+    rrrsig.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset;
+      var sig = {}, length = buf.readUInt16BE(offset);
+      return offset += 2, sig.typeCovered = types.toString(buf.readUInt16BE(offset)), offset += 2, sig.algorithm = buf.readUInt8(offset), offset += 1, sig.labels = buf.readUInt8(offset), offset += 1, sig.originalTTL = buf.readUInt32BE(offset), offset += 4, sig.expiration = buf.readUInt32BE(offset), offset += 4, sig.inception = buf.readUInt32BE(offset), offset += 4, sig.keyTag = buf.readUInt16BE(offset), offset += 2, sig.signersName = name.decode(buf, offset), offset += name.decode.bytes, sig.signature = buf.slice(offset, oldOffset + length + 2), offset += sig.signature.length, rrrsig.decode.bytes = offset - oldOffset, sig;
+    };
+    rrrsig.decode.bytes = 0;
+    rrrsig.encodingLength = function(sig) {
+      return 20 + name.encodingLength(sig.signersName) + Buffer2.byteLength(sig.signature);
+    };
+    var rrp = exports.rp = {};
+    rrp.encode = function(data, buf, offset) {
+      buf || (buf = Buffer2.alloc(rrp.encodingLength(data))), offset || (offset = 0);
+      let oldOffset = offset;
+      return offset += 2, name.encode(data.mbox || ".", buf, offset, { mail: !0 }), offset += name.encode.bytes, name.encode(data.txt || ".", buf, offset), offset += name.encode.bytes, rrp.encode.bytes = offset - oldOffset, buf.writeUInt16BE(rrp.encode.bytes - 2, oldOffset), buf;
+    };
+    rrp.encode.bytes = 0;
+    rrp.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, data = {};
+      return offset += 2, data.mbox = name.decode(buf, offset, { mail: !0 }) || ".", offset += name.decode.bytes, data.txt = name.decode(buf, offset) || ".", offset += name.decode.bytes, rrp.decode.bytes = offset - oldOffset, data;
+    };
+    rrp.decode.bytes = 0;
+    rrp.encodingLength = function(data) {
+      return 2 + name.encodingLength(data.mbox || ".") + name.encodingLength(data.txt || ".");
+    };
+    var typebitmap = {};
+    typebitmap.encode = function(typelist, buf, offset) {
+      buf || (buf = Buffer2.alloc(typebitmap.encodingLength(typelist))), offset || (offset = 0);
+      let oldOffset = offset;
+      for (var typesByWindow = [], i = 0; i < typelist.length; i++) {
+        var typeid = types.toType(typelist[i]);
+        typesByWindow[typeid >> 8] === void 0 && (typesByWindow[typeid >> 8] = []), typesByWindow[typeid >> 8][typeid >> 3 & 31] |= 1 << 7 - (typeid & 7);
+      }
+      for (i = 0; i < typesByWindow.length; i++)
+        if (typesByWindow[i] !== void 0) {
+          var windowBuf = Buffer2.from(typesByWindow[i]);
+          buf.writeUInt8(i, offset), offset += 1, buf.writeUInt8(windowBuf.length, offset), offset += 1, windowBuf.copy(buf, offset), offset += windowBuf.length;
+        }
+      return typebitmap.encode.bytes = offset - oldOffset, buf;
+    };
+    typebitmap.encode.bytes = 0;
+    typebitmap.decode = function(buf, offset, length) {
+      offset || (offset = 0);
+      let oldOffset = offset;
+      for (var typelist = []; offset - oldOffset < length; ) {
+        var window = buf.readUInt8(offset);
+        offset += 1;
+        var windowLength = buf.readUInt8(offset);
+        offset += 1;
+        for (var i = 0; i < windowLength; i++)
+          for (var b = buf.readUInt8(offset + i), j = 0; j < 8; j++)
+            if (b & 1 << 7 - j) {
+              var typeid = types.toString(window << 8 | i << 3 | j);
+              typelist.push(typeid);
+            }
+        offset += windowLength;
+      }
+      return typebitmap.decode.bytes = offset - oldOffset, typelist;
+    };
+    typebitmap.decode.bytes = 0;
+    typebitmap.encodingLength = function(typelist) {
+      for (var extents = [], i = 0; i < typelist.length; i++) {
+        var typeid = types.toType(typelist[i]);
+        extents[typeid >> 8] = Math.max(extents[typeid >> 8] || 0, typeid & 255);
+      }
+      var len = 0;
+      for (i = 0; i < extents.length; i++)
+        extents[i] !== void 0 && (len += 2 + Math.ceil((extents[i] + 1) / 8));
+      return len;
+    };
+    var rnsec = exports.nsec = {};
+    rnsec.encode = function(record, buf, offset) {
+      buf || (buf = Buffer2.alloc(rnsec.encodingLength(record))), offset || (offset = 0);
+      let oldOffset = offset;
+      return offset += 2, name.encode(record.nextDomain, buf, offset), offset += name.encode.bytes, typebitmap.encode(record.rrtypes, buf, offset), offset += typebitmap.encode.bytes, rnsec.encode.bytes = offset - oldOffset, buf.writeUInt16BE(rnsec.encode.bytes - 2, oldOffset), buf;
+    };
+    rnsec.encode.bytes = 0;
+    rnsec.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset;
+      var record = {}, length = buf.readUInt16BE(offset);
+      return offset += 2, record.nextDomain = name.decode(buf, offset), offset += name.decode.bytes, record.rrtypes = typebitmap.decode(buf, offset, length - (offset - oldOffset)), offset += typebitmap.decode.bytes, rnsec.decode.bytes = offset - oldOffset, record;
+    };
+    rnsec.decode.bytes = 0;
+    rnsec.encodingLength = function(record) {
+      return 2 + name.encodingLength(record.nextDomain) + typebitmap.encodingLength(record.rrtypes);
+    };
+    var rnsec3 = exports.nsec3 = {};
+    rnsec3.encode = function(record, buf, offset) {
+      buf || (buf = Buffer2.alloc(rnsec3.encodingLength(record))), offset || (offset = 0);
+      let oldOffset = offset, salt = record.salt;
+      if (!Buffer2.isBuffer(salt))
+        throw new Error("salt must be a Buffer");
+      let nextDomain = record.nextDomain;
+      if (!Buffer2.isBuffer(nextDomain))
+        throw new Error("nextDomain must be a Buffer");
+      return offset += 2, buf.writeUInt8(record.algorithm, offset), offset += 1, buf.writeUInt8(record.flags, offset), offset += 1, buf.writeUInt16BE(record.iterations, offset), offset += 2, buf.writeUInt8(salt.length, offset), offset += 1, salt.copy(buf, offset, 0, salt.length), offset += salt.length, buf.writeUInt8(nextDomain.length, offset), offset += 1, nextDomain.copy(buf, offset, 0, nextDomain.length), offset += nextDomain.length, typebitmap.encode(record.rrtypes, buf, offset), offset += typebitmap.encode.bytes, rnsec3.encode.bytes = offset - oldOffset, buf.writeUInt16BE(rnsec3.encode.bytes - 2, oldOffset), buf;
+    };
+    rnsec3.encode.bytes = 0;
+    rnsec3.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset;
+      var record = {}, length = buf.readUInt16BE(offset);
+      offset += 2, record.algorithm = buf.readUInt8(offset), offset += 1, record.flags = buf.readUInt8(offset), offset += 1, record.iterations = buf.readUInt16BE(offset), offset += 2;
+      let saltLength = buf.readUInt8(offset);
+      offset += 1, record.salt = buf.slice(offset, offset + saltLength), offset += saltLength;
+      let hashLength = buf.readUInt8(offset);
+      return offset += 1, record.nextDomain = buf.slice(offset, offset + hashLength), offset += hashLength, record.rrtypes = typebitmap.decode(buf, offset, length - (offset - oldOffset)), offset += typebitmap.decode.bytes, rnsec3.decode.bytes = offset - oldOffset, record;
+    };
+    rnsec3.decode.bytes = 0;
+    rnsec3.encodingLength = function(record) {
+      return 8 + record.salt.length + record.nextDomain.length + typebitmap.encodingLength(record.rrtypes);
+    };
+    var rds = exports.ds = {};
+    rds.encode = function(digest, buf, offset) {
+      buf || (buf = Buffer2.alloc(rds.encodingLength(digest))), offset || (offset = 0);
+      let oldOffset = offset, digestdata = digest.digest;
+      if (!Buffer2.isBuffer(digestdata))
+        throw new Error("Digest must be a Buffer");
+      return offset += 2, buf.writeUInt16BE(digest.keyTag, offset), offset += 2, buf.writeUInt8(digest.algorithm, offset), offset += 1, buf.writeUInt8(digest.digestType, offset), offset += 1, digestdata.copy(buf, offset, 0, digestdata.length), offset += digestdata.length, rds.encode.bytes = offset - oldOffset, buf.writeUInt16BE(rds.encode.bytes - 2, oldOffset), buf;
+    };
+    rds.encode.bytes = 0;
+    rds.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset;
+      var digest = {}, length = buf.readUInt16BE(offset);
+      return offset += 2, digest.keyTag = buf.readUInt16BE(offset), offset += 2, digest.algorithm = buf.readUInt8(offset), offset += 1, digest.digestType = buf.readUInt8(offset), offset += 1, digest.digest = buf.slice(offset, oldOffset + length + 2), offset += digest.digest.length, rds.decode.bytes = offset - oldOffset, digest;
+    };
+    rds.decode.bytes = 0;
+    rds.encodingLength = function(digest) {
+      return 6 + Buffer2.byteLength(digest.digest);
+    };
+    var rsshfp = exports.sshfp = {};
+    rsshfp.getFingerprintLengthForHashType = function(hashType) {
+      switch (hashType) {
+        case 1:
+          return 20;
+        case 2:
+          return 32;
+      }
+    };
+    rsshfp.encode = function(record, buf, offset) {
+      buf || (buf = Buffer2.alloc(rsshfp.encodingLength(record))), offset || (offset = 0);
+      let oldOffset = offset;
+      offset += 2, buf[offset] = record.algorithm, offset += 1, buf[offset] = record.hash, offset += 1;
+      let fingerprintBuf = Buffer2.from(record.fingerprint.toUpperCase(), "hex");
+      if (fingerprintBuf.length !== rsshfp.getFingerprintLengthForHashType(record.hash))
+        throw new Error("Invalid fingerprint length");
+      return fingerprintBuf.copy(buf, offset), offset += fingerprintBuf.byteLength, rsshfp.encode.bytes = offset - oldOffset, buf.writeUInt16BE(rsshfp.encode.bytes - 2, oldOffset), buf;
+    };
+    rsshfp.encode.bytes = 0;
+    rsshfp.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, record = {};
+      offset += 2, record.algorithm = buf[offset], offset += 1, record.hash = buf[offset], offset += 1;
+      let fingerprintLength = rsshfp.getFingerprintLengthForHashType(record.hash);
+      return record.fingerprint = buf.slice(offset, offset + fingerprintLength).toString("hex").toUpperCase(), offset += fingerprintLength, rsshfp.decode.bytes = offset - oldOffset, record;
+    };
+    rsshfp.decode.bytes = 0;
+    rsshfp.encodingLength = function(record) {
+      return 4 + Buffer2.from(record.fingerprint, "hex").byteLength;
+    };
+    var rnaptr = exports.naptr = {};
+    rnaptr.encode = function(data, buf, offset) {
+      buf || (buf = Buffer2.alloc(rnaptr.encodingLength(data))), offset || (offset = 0);
+      let oldOffset = offset;
+      return offset += 2, buf.writeUInt16BE(data.order || 0, offset), offset += 2, buf.writeUInt16BE(data.preference || 0, offset), offset += 2, string.encode(data.flags, buf, offset), offset += string.encode.bytes, string.encode(data.services, buf, offset), offset += string.encode.bytes, string.encode(data.regexp, buf, offset), offset += string.encode.bytes, name.encode(data.replacement, buf, offset), offset += name.encode.bytes, rnaptr.encode.bytes = offset - oldOffset, buf.writeUInt16BE(rnaptr.encode.bytes - 2, oldOffset), buf;
+    };
+    rnaptr.encode.bytes = 0;
+    rnaptr.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, data = {};
+      return offset += 2, data.order = buf.readUInt16BE(offset), offset += 2, data.preference = buf.readUInt16BE(offset), offset += 2, data.flags = string.decode(buf, offset), offset += string.decode.bytes, data.services = string.decode(buf, offset), offset += string.decode.bytes, data.regexp = string.decode(buf, offset), offset += string.decode.bytes, data.replacement = name.decode(buf, offset), offset += name.decode.bytes, rnaptr.decode.bytes = offset - oldOffset, data;
+    };
+    rnaptr.decode.bytes = 0;
+    rnaptr.encodingLength = function(data) {
+      return string.encodingLength(data.flags) + string.encodingLength(data.services) + string.encodingLength(data.regexp) + name.encodingLength(data.replacement) + 6;
+    };
+    var rtlsa = exports.tlsa = {};
+    rtlsa.encode = function(cert, buf, offset) {
+      buf || (buf = Buffer2.alloc(rtlsa.encodingLength(cert))), offset || (offset = 0);
+      let oldOffset = offset, certdata = cert.certificate;
+      if (!Buffer2.isBuffer(certdata))
+        throw new Error("Certificate must be a Buffer");
+      return offset += 2, buf.writeUInt8(cert.usage, offset), offset += 1, buf.writeUInt8(cert.selector, offset), offset += 1, buf.writeUInt8(cert.matchingType, offset), offset += 1, certdata.copy(buf, offset, 0, certdata.length), offset += certdata.length, rtlsa.encode.bytes = offset - oldOffset, buf.writeUInt16BE(rtlsa.encode.bytes - 2, oldOffset), buf;
+    };
+    rtlsa.encode.bytes = 0;
+    rtlsa.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, cert = {}, length = buf.readUInt16BE(offset);
+      return offset += 2, cert.usage = buf.readUInt8(offset), offset += 1, cert.selector = buf.readUInt8(offset), offset += 1, cert.matchingType = buf.readUInt8(offset), offset += 1, cert.certificate = buf.slice(offset, oldOffset + length + 2), offset += cert.certificate.length, rtlsa.decode.bytes = offset - oldOffset, cert;
+    };
+    rtlsa.decode.bytes = 0;
+    rtlsa.encodingLength = function(cert) {
+      return 5 + Buffer2.byteLength(cert.certificate);
+    };
+    var renc = exports.record = function(type) {
+      switch (type.toUpperCase()) {
+        case "A":
+          return ra;
+        case "PTR":
+          return rptr;
+        case "CNAME":
+          return rcname;
+        case "DNAME":
+          return rdname;
+        case "TXT":
+          return rtxt;
+        case "NULL":
+          return rnull;
+        case "AAAA":
+          return raaaa;
+        case "SRV":
+          return rsrv;
+        case "HINFO":
+          return rhinfo;
+        case "CAA":
+          return rcaa;
+        case "NS":
+          return rns;
+        case "SOA":
+          return rsoa;
+        case "MX":
+          return rmx;
+        case "OPT":
+          return ropt;
+        case "DNSKEY":
+          return rdnskey;
+        case "RRSIG":
+          return rrrsig;
+        case "RP":
+          return rrp;
+        case "NSEC":
+          return rnsec;
+        case "NSEC3":
+          return rnsec3;
+        case "SSHFP":
+          return rsshfp;
+        case "DS":
+          return rds;
+        case "NAPTR":
+          return rnaptr;
+        case "TLSA":
+          return rtlsa;
+      }
+      return runknown;
+    }, answer = exports.answer = {};
+    answer.encode = function(a, buf, offset) {
+      buf || (buf = Buffer2.alloc(answer.encodingLength(a))), offset || (offset = 0);
+      let oldOffset = offset;
+      if (name.encode(a.name, buf, offset), offset += name.encode.bytes, buf.writeUInt16BE(types.toType(a.type), offset), a.type.toUpperCase() === "OPT") {
+        if (a.name !== ".")
+          throw new Error("OPT name must be root.");
+        buf.writeUInt16BE(a.udpPayloadSize || 4096, offset + 2), buf.writeUInt8(a.extendedRcode || 0, offset + 4), buf.writeUInt8(a.ednsVersion || 0, offset + 5), buf.writeUInt16BE(a.flags || 0, offset + 6), offset += 8, ropt.encode(a.options || [], buf, offset), offset += ropt.encode.bytes;
+      } else {
+        let klass = classes.toClass(a.class === void 0 ? "IN" : a.class);
+        a.flush && (klass |= FLUSH_MASK), buf.writeUInt16BE(klass, offset + 2), buf.writeUInt32BE(a.ttl || 0, offset + 4), offset += 8;
+        let enc = renc(a.type);
+        enc.encode(a.data, buf, offset), offset += enc.encode.bytes;
+      }
+      return answer.encode.bytes = offset - oldOffset, buf;
+    };
+    answer.encode.bytes = 0;
+    answer.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let a = {}, oldOffset = offset;
+      if (a.name = name.decode(buf, offset), offset += name.decode.bytes, a.type = types.toString(buf.readUInt16BE(offset)), a.type === "OPT")
+        a.udpPayloadSize = buf.readUInt16BE(offset + 2), a.extendedRcode = buf.readUInt8(offset + 4), a.ednsVersion = buf.readUInt8(offset + 5), a.flags = buf.readUInt16BE(offset + 6), a.flag_do = (a.flags >> 15 & 1) === 1, a.options = ropt.decode(buf, offset + 8), offset += 8 + ropt.decode.bytes;
+      else {
+        let klass = buf.readUInt16BE(offset + 2);
+        a.ttl = buf.readUInt32BE(offset + 4), a.class = classes.toString(klass & NOT_FLUSH_MASK), a.flush = !!(klass & FLUSH_MASK);
+        let enc = renc(a.type);
+        a.data = enc.decode(buf, offset + 8), offset += 8 + enc.decode.bytes;
+      }
+      return answer.decode.bytes = offset - oldOffset, a;
+    };
+    answer.decode.bytes = 0;
+    answer.encodingLength = function(a) {
+      let data = a.data !== null && a.data !== void 0 ? a.data : a.options;
+      return name.encodingLength(a.name) + 8 + renc(a.type).encodingLength(data);
+    };
+    var question = exports.question = {};
+    question.encode = function(q, buf, offset) {
+      buf || (buf = Buffer2.alloc(question.encodingLength(q))), offset || (offset = 0);
+      let oldOffset = offset;
+      return name.encode(q.name, buf, offset), offset += name.encode.bytes, buf.writeUInt16BE(types.toType(q.type), offset), offset += 2, buf.writeUInt16BE(classes.toClass(q.class === void 0 ? "IN" : q.class), offset), offset += 2, question.encode.bytes = offset - oldOffset, q;
+    };
+    question.encode.bytes = 0;
+    question.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, q = {};
+      return q.name = name.decode(buf, offset), offset += name.decode.bytes, q.type = types.toString(buf.readUInt16BE(offset)), offset += 2, q.class = classes.toString(buf.readUInt16BE(offset)), offset += 2, q.class & QU_MASK && (q.class &= NOT_QU_MASK), question.decode.bytes = offset - oldOffset, q;
+    };
+    question.decode.bytes = 0;
+    question.encodingLength = function(q) {
+      return name.encodingLength(q.name) + 4;
+    };
+    exports.AUTHORITATIVE_ANSWER = 1024;
+    exports.TRUNCATED_RESPONSE = 512;
+    exports.RECURSION_DESIRED = 256;
+    exports.RECURSION_AVAILABLE = 128;
+    exports.AUTHENTIC_DATA = 32;
+    exports.CHECKING_DISABLED = 16;
+    exports.DNSSEC_OK = 32768;
+    exports.encode = function(result, buf, offset) {
+      let allocing = !buf;
+      allocing && (buf = Buffer2.alloc(exports.encodingLength(result))), offset || (offset = 0);
+      let oldOffset = offset;
+      return result.questions || (result.questions = []), result.answers || (result.answers = []), result.authorities || (result.authorities = []), result.additionals || (result.additionals = []), header.encode(result, buf, offset), offset += header.encode.bytes, offset = encodeList(result.questions, question, buf, offset), offset = encodeList(result.answers, answer, buf, offset), offset = encodeList(result.authorities, answer, buf, offset), offset = encodeList(result.additionals, answer, buf, offset), exports.encode.bytes = offset - oldOffset, allocing && exports.encode.bytes !== buf.length ? buf.slice(0, exports.encode.bytes) : buf;
+    };
+    exports.encode.bytes = 0;
+    exports.decode = function(buf, offset) {
+      offset || (offset = 0);
+      let oldOffset = offset, result = header.decode(buf, offset);
+      return offset += header.decode.bytes, offset = decodeList(result.questions, question, buf, offset), offset = decodeList(result.answers, answer, buf, offset), offset = decodeList(result.authorities, answer, buf, offset), offset = decodeList(result.additionals, answer, buf, offset), exports.decode.bytes = offset - oldOffset, result;
+    };
+    exports.decode.bytes = 0;
+    exports.encodingLength = function(result) {
+      return header.encodingLength(result) + encodingLengthList(result.questions || [], question) + encodingLengthList(result.answers || [], answer) + encodingLengthList(result.authorities || [], answer) + encodingLengthList(result.additionals || [], answer);
+    };
+    exports.streamEncode = function(result) {
+      let buf = exports.encode(result), sbuf = Buffer2.alloc(2);
+      sbuf.writeUInt16BE(buf.byteLength);
+      let combine = Buffer2.concat([sbuf, buf]);
+      return exports.streamEncode.bytes = combine.byteLength, combine;
+    };
+    exports.streamEncode.bytes = 0;
+    exports.streamDecode = function(sbuf) {
+      let len = sbuf.readUInt16BE(0);
+      if (sbuf.byteLength < len + 2)
+        return null;
+      let result = exports.decode(sbuf.slice(2));
+      return exports.streamDecode.bytes = exports.decode.bytes, result;
+    };
+    exports.streamDecode.bytes = 0;
+    function encodingLengthList(list, enc) {
+      let len = 0;
+      for (let i = 0; i < list.length; i++) len += enc.encodingLength(list[i]);
+      return len;
+    }
+    function encodeList(list, enc, buf, offset) {
+      for (let i = 0; i < list.length; i++)
+        enc.encode(list[i], buf, offset), offset += enc.encode.bytes;
+      return offset;
+    }
+    function decodeList(list, enc, buf, offset) {
+      for (let i = 0; i < list.length; i++)
+        list[i] = enc.decode(buf, offset), offset += enc.decode.bytes;
+      return offset;
+    }
+  }
+});
+
+// node_modules/thunky/index.js
+var require_thunky = __commonJS({
+  "node_modules/thunky/index.js"(exports, module) {
+    "use strict";
+    var nextTick = nextTickArgs;
+    process.nextTick(upgrade, 42);
+    module.exports = thunky;
+    function thunky(fn) {
+      var state = run;
+      return thunk;
+      function thunk(callback) {
+        state(callback || noop);
+      }
+      function run(callback) {
+        var stack = [callback];
+        state = wait, fn(done);
+        function wait(callback2) {
+          stack.push(callback2);
+        }
+        function done(err) {
+          var args = arguments;
+          for (state = isError(err) ? run : finished; stack.length; ) finished(stack.shift());
+          function finished(callback2) {
+            nextTick(apply, callback2, args);
+          }
+        }
+      }
+    }
+    function isError(err) {
+      return Object.prototype.toString.call(err) === "[object Error]";
+    }
+    function noop() {
+    }
+    function apply(callback, args) {
+      callback.apply(null, args);
+    }
+    function upgrade(val) {
+      val === 42 && (nextTick = process.nextTick);
+    }
+    function nextTickArgs(fn, a, b) {
+      process.nextTick(function() {
+        fn(a, b);
+      });
+    }
+  }
+});
+
+// node_modules/multicast-dns/index.js
+var require_multicast_dns = __commonJS({
+  "node_modules/multicast-dns/index.js"(exports, module) {
+    "use strict";
+    var packet = require_dns_packet(), dgram = __require("dgram"), thunky = require_thunky(), events = __require("events"), os = __require("os"), noop = function() {
+    };
+    module.exports = function(opts) {
+      opts || (opts = {});
+      var that = new events.EventEmitter(), port = typeof opts.port == "number" ? opts.port : 5353, type = opts.type || "udp4", ip = opts.ip || opts.host || (type === "udp4" ? "224.0.0.251" : null), me = { address: ip, port }, memberships = {}, destroyed = !1, interval = null;
+      if (type === "udp6" && (!ip || !opts.interface))
+        throw new Error("For IPv6 multicast you must specify `ip` and `interface`");
+      var socket = opts.socket || dgram.createSocket({
+        type,
+        reuseAddr: opts.reuseAddr !== !1,
+        toString: function() {
+          return type;
+        }
+      });
+      socket.on("error", function(err) {
+        err.code === "EACCES" || err.code === "EADDRINUSE" ? that.emit("error", err) : that.emit("warning", err);
+      }), socket.on("message", function(message, rinfo) {
+        try {
+          message = packet.decode(message);
+        } catch (err) {
+          that.emit("warning", err);
+          return;
+        }
+        that.emit("packet", message, rinfo), message.type === "query" && that.emit("query", message, rinfo), message.type === "response" && that.emit("response", message, rinfo);
+      }), socket.on("listening", function() {
+        port || (port = me.port = socket.address().port), opts.multicast !== !1 && (that.update(), interval = setInterval(that.update, 5e3), socket.setMulticastTTL(opts.ttl || 255), socket.setMulticastLoopback(opts.loopback !== !1));
+      });
+      var bind = thunky(function(cb) {
+        if (!port || opts.bind === !1) return cb(null);
+        socket.once("error", cb), socket.bind(port, opts.bind || opts.interface, function() {
+          socket.removeListener("error", cb), cb(null);
+        });
+      });
+      return bind(function(err) {
+        if (err) return that.emit("error", err);
+        that.emit("ready");
+      }), that.send = function(value, rinfo, cb) {
+        if (typeof rinfo == "function") return that.send(value, null, rinfo);
+        cb || (cb = noop), rinfo ? !rinfo.host && !rinfo.address && (rinfo.address = me.address) : rinfo = me, bind(onbind);
+        function onbind(err) {
+          if (destroyed) return cb();
+          if (err) return cb(err);
+          var message = packet.encode(value);
+          socket.send(message, 0, message.length, rinfo.port, rinfo.address || rinfo.host, cb);
+        }
+      }, that.response = that.respond = function(res, rinfo, cb) {
+        Array.isArray(res) && (res = { answers: res }), res.type = "response", res.flags = (res.flags || 0) | packet.AUTHORITATIVE_ANSWER, that.send(res, rinfo, cb);
+      }, that.query = function(q, type2, rinfo, cb) {
+        if (typeof type2 == "function") return that.query(q, null, null, type2);
+        if (typeof type2 == "object" && type2 && type2.port) return that.query(q, null, type2, rinfo);
+        if (typeof rinfo == "function") return that.query(q, type2, null, rinfo);
+        cb || (cb = noop), typeof q == "string" && (q = [{ name: q, type: type2 || "ANY" }]), Array.isArray(q) && (q = { type: "query", questions: q }), q.type = "query", that.send(q, rinfo, cb);
+      }, that.destroy = function(cb) {
+        if (cb || (cb = noop), destroyed) return process.nextTick(cb);
+        destroyed = !0, clearInterval(interval);
+        for (var iface in memberships)
+          try {
+            socket.dropMembership(ip, iface);
+          } catch {
+          }
+        memberships = {}, socket.close(cb);
+      }, that.update = function() {
+        for (var ifaces = opts.interface ? [].concat(opts.interface) : allInterfaces(), updated = !1, i = 0; i < ifaces.length; i++) {
+          var addr = ifaces[i];
+          if (!memberships[addr])
+            try {
+              socket.addMembership(ip, addr), memberships[addr] = !0, updated = !0;
+            } catch (err) {
+              that.emit("warning", err);
+            }
+        }
+        if (updated) {
+          if (socket.setMulticastInterface)
+            try {
+              socket.setMulticastInterface(opts.interface || defaultInterface());
+            } catch (err) {
+              that.emit("warning", err);
+            }
+          that.emit("networkInterface");
+        }
+      }, that;
+    };
+    function defaultInterface() {
+      for (var networks = os.networkInterfaces(), names = Object.keys(networks), i = 0; i < names.length; i++)
+        for (var net = networks[names[i]], j = 0; j < net.length; j++) {
+          var iface = net[j];
+          if (isIPv4(iface.family) && !iface.internal)
+            return os.platform() === "darwin" && names[i] === "en0" ? iface.address : "0.0.0.0";
+        }
+      return "127.0.0.1";
+    }
+    function allInterfaces() {
+      for (var networks = os.networkInterfaces(), names = Object.keys(networks), res = [], i = 0; i < names.length; i++)
+        for (var net = networks[names[i]], j = 0; j < net.length; j++) {
+          var iface = net[j];
+          if (isIPv4(iface.family)) {
+            res.push(iface.address);
+            break;
+          }
+        }
+      return res;
+    }
+    function isIPv4(family) {
+      return family === 4 || family === "IPv4";
+    }
+  }
+});
+
+// node_modules/bonjour-service/dist/lib/mdns-server.js
+var require_mdns_server = __commonJS({
+  "node_modules/bonjour-service/dist/lib/mdns-server.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { default: mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.Server = void 0;
+    var multicast_dns_1 = __importDefault(require_multicast_dns()), es6_1 = __importDefault(require_es6()), dns_equal_1 = __importDefault(require_dns_equal()), Server = class {
+      constructor(opts, errorCallback) {
+        this.registry = {}, this.mdns = (0, multicast_dns_1.default)(opts), this.mdns.setMaxListeners(0), this.mdns.on("query", this.respondToQuery.bind(this)), this.errorCallback = errorCallback ?? function(err) {
+          throw err;
+        };
+      }
+      register(records) {
+        let shouldRegister = (record) => {
+          var subRegistry = this.registry[record.type];
+          if (!subRegistry)
+            subRegistry = this.registry[record.type] = [];
+          else if (subRegistry.some(this.isDuplicateRecord(record)))
+            return;
+          subRegistry.push(record);
+        };
+        Array.isArray(records) ? records.forEach(shouldRegister) : shouldRegister(records);
+      }
+      unregister(records) {
+        let shouldUnregister = (record) => {
+          let type = record.type;
+          type in this.registry && (this.registry[type] = this.registry[type].filter((i) => i.name !== record.name));
+        };
+        Array.isArray(records) ? records.forEach(shouldUnregister) : shouldUnregister(records);
+      }
+      respondToQuery(query) {
+        let self = this;
+        query.questions.forEach((question) => {
+          var type = question.type, name = question.name, answers = type === "ANY" ? Object.keys(self.registry).map(self.recordsFor.bind(self, name)).flat(1) : self.recordsFor(name, type);
+          if (answers.length !== 0) {
+            var additionals = [];
+            type !== "ANY" && (answers.forEach((answer) => {
+              answer.type === "PTR" && (additionals = additionals.concat(self.recordsFor(answer.data, "SRV")).concat(self.recordsFor(answer.data, "TXT")));
+            }), additionals.filter(function(record) {
+              return record.type === "SRV";
+            }).map(function(record) {
+              return record.data.target;
+            }).filter(this.unique()).forEach(function(target) {
+              additionals = additionals.concat(self.recordsFor(target, "A")).concat(self.recordsFor(target, "AAAA"));
+            })), self.mdns.respond({ answers, additionals }, (err) => {
+              err && this.errorCallback(err);
+            });
+          }
+        });
+      }
+      recordsFor(name, type) {
+        return type in this.registry ? this.registry[type].filter((record) => {
+          var _name = ~name.indexOf(".") ? record.name : record.name.split(".")[0];
+          return (0, dns_equal_1.default)(_name, name);
+        }) : [];
+      }
+      isDuplicateRecord(a) {
+        return (b) => a.type === b.type && a.name === b.name && (0, es6_1.default)(a.data, b.data);
+      }
+      unique() {
+        var set = [];
+        return (obj) => ~set.indexOf(obj) ? !1 : (set.push(obj), !0);
+      }
+    };
+    exports.Server = Server;
+    exports.default = Server;
+  }
+});
+
+// node_modules/bonjour-service/dist/lib/utils/filter-service.js
+var require_filter_service = __commonJS({
+  "node_modules/bonjour-service/dist/lib/utils/filter-service.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.default = (service, txtQuery) => {
+      if (txtQuery === void 0)
+        return !0;
+      let serviceTxt = service.txt, query = Object.entries(txtQuery).map(([key, value]) => {
+        let queryValue = serviceTxt[key];
+        return !(queryValue === void 0 || value != queryValue);
+      });
+      return query.length == 0 ? !0 : !query.includes(!1);
+    };
+  }
+});
+
+// node_modules/bonjour-service/dist/lib/utils/filter-txt.js
+var require_filter_txt = __commonJS({
+  "node_modules/bonjour-service/dist/lib/utils/filter-txt.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.default = (data) => Object.keys(data).filter((key) => !key.includes("binary")).reduce((cur, key) => Object.assign(cur, { [key]: data[key] }), {});
+  }
+});
+
+// node_modules/bonjour-service/dist/lib/utils/equal-txt.js
+var require_equal_txt = __commonJS({
+  "node_modules/bonjour-service/dist/lib/utils/equal-txt.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.default = equalTxt;
+    function equalTxt(a, b) {
+      if (a === void 0 || b === void 0)
+        return !1;
+      let aKeys = Object.keys(a), bKeys = Object.keys(b);
+      if (aKeys.length != bKeys.length)
+        return !1;
+      for (let key of aKeys)
+        if (a[key] != b[key])
+          return !1;
+      return !0;
+    }
+  }
+});
+
+// node_modules/bonjour-service/dist/lib/browser.js
+var require_browser = __commonJS({
+  "node_modules/bonjour-service/dist/lib/browser.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { default: mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.Browser = void 0;
+    var dns_txt_1 = __importDefault(require_dns_txt()), dns_equal_1 = __importDefault(require_dns_equal()), events_1 = __require("events"), service_types_1 = require_service_types(), filter_service_1 = __importDefault(require_filter_service()), filter_txt_1 = __importDefault(require_filter_txt()), equal_txt_1 = __importDefault(require_equal_txt()), TLD = ".local", WILDCARD = "_services._dns-sd._udp" + TLD, Browser = class _Browser extends events_1.EventEmitter {
+      constructor(mdns, opts, onup) {
+        if (super(), this.onresponse = void 0, this.serviceMap = {}, this.wildcard = !1, this._services = [], typeof opts == "function")
+          return new _Browser(mdns, null, opts);
+        this.mdns = mdns, this.txt = new dns_txt_1.default(opts !== null && opts.txt != null ? opts.txt : void 0), opts === null || opts.type === void 0 ? (this.name = WILDCARD, this.wildcard = !0) : (this.name = (0, service_types_1.toString)({ name: opts.type, protocol: opts.protocol || "tcp" }) + TLD, opts.name && (this.name = opts.name + "." + this.name), this.wildcard = !1), opts != null && opts.txt !== void 0 && (this.txtQuery = (0, filter_txt_1.default)(opts.txt)), onup && this.on("up", onup), this.start();
+      }
+      start() {
+        if (!(this.onresponse || this.name === void 0)) {
+          var self = this, nameMap = {};
+          this.wildcard || (nameMap[this.name] = !0), this.onresponse = (packet, rinfo) => {
+            self.wildcard && packet.answers.forEach((answer) => {
+              answer.type !== "PTR" || answer.name !== self.name || answer.name in nameMap || (nameMap[answer.data] = !0, self.mdns.query(answer.data, "PTR"));
+            }), Object.keys(nameMap).forEach(function(name) {
+              self.goodbyes(name, packet).forEach(self.removeService.bind(self));
+              var matches = self.buildServicesFor(name, packet, self.txt, rinfo);
+              matches.length !== 0 && matches.forEach((service) => {
+                if (self.serviceMap[service.fqdn]) {
+                  self.updateService(service);
+                  return;
+                }
+                self.addService(service);
+              });
+            });
+          }, this.mdns.on("response", this.onresponse), this.update();
+        }
+      }
+      stop() {
+        this.onresponse && (this.mdns.removeListener("response", this.onresponse), this.onresponse = void 0);
+      }
+      update() {
+        this.mdns.query(this.name, "PTR");
+      }
+      get services() {
+        return this._services;
+      }
+      addService(service) {
+        (0, filter_service_1.default)(service, this.txtQuery) !== !1 && (this._services.push(service), this.serviceMap[service.fqdn] = !0, this.emit("up", service));
+      }
+      updateService(service) {
+        var _a;
+        if (!(0, equal_txt_1.default)(service.txt, ((_a = this._services.find((s) => (0, dns_equal_1.default)(s.fqdn, service.fqdn))) === null || _a === void 0 ? void 0 : _a.txt) || {})) {
+          if (!(0, filter_service_1.default)(service, this.txtQuery)) {
+            this.removeService(service.fqdn);
+            return;
+          }
+          this._services = this._services.map(function(s) {
+            return (0, dns_equal_1.default)(s.fqdn, service.fqdn) ? service : s;
+          }), this.emit("txt-update", service);
+        }
+      }
+      removeService(fqdn) {
+        var service, index;
+        this._services.some(function(s, i) {
+          if ((0, dns_equal_1.default)(s.fqdn, fqdn))
+            return service = s, index = i, !0;
+        }), !(!service || index === void 0) && (this._services.splice(index, 1), delete this.serviceMap[fqdn], this.emit("down", service));
+      }
+      goodbyes(name, packet) {
+        return packet.answers.concat(packet.additionals).filter((rr) => rr.type === "PTR" && rr.ttl === 0 && (0, dns_equal_1.default)(rr.name, name)).map((rr) => rr.data);
+      }
+      buildServicesFor(name, packet, txt, referer) {
+        var records = packet.answers.concat(packet.additionals).filter((rr) => rr.ttl > 0);
+        return records.filter((rr) => rr.type === "PTR" && (0, dns_equal_1.default)(rr.name, name)).map((ptr) => {
+          let service = {
+            addresses: [],
+            subtypes: []
+          };
+          if (records.filter((rr) => rr.type === "PTR" && (0, dns_equal_1.default)(rr.data, ptr.data) && rr.name.includes("._sub")).forEach((rr) => {
+            let types = (0, service_types_1.toType)(rr.name);
+            service.subtypes.push(types.subtype);
+          }), records.filter((rr) => (rr.type === "SRV" || rr.type === "TXT") && (0, dns_equal_1.default)(rr.name, ptr.data)).forEach((rr) => {
+            if (rr.type === "SRV") {
+              var parts = rr.name.split("."), name2 = parts[0], types = (0, service_types_1.toType)(parts.slice(1, -1).join("."));
+              service.name = name2, service.fqdn = rr.name, service.host = rr.data.target, service.referer = referer, service.port = rr.data.port, service.type = types.name, service.protocol = types.protocol;
+            } else rr.type === "TXT" && (service.rawTxt = rr.data, service.txt = this.txt.decodeAll(rr.data));
+          }), !!service.name)
+            return records.filter((rr) => (rr.type === "A" || rr.type === "AAAA") && (0, dns_equal_1.default)(rr.name, service.host)).forEach((rr) => service.addresses.push(rr.data)), service;
+        }).filter((rr) => !!rr);
+      }
+    };
+    exports.Browser = Browser;
+    exports.default = Browser;
+  }
+});
+
+// node_modules/bonjour-service/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/bonjour-service/dist/index.js"(exports) {
+    "use strict";
+    var __importDefault = exports && exports.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { default: mod };
+    };
+    Object.defineProperty(exports, "__esModule", { value: !0 });
+    exports.Browser = exports.Service = exports.Bonjour = void 0;
+    var registry_1 = __importDefault(require_registry()), mdns_server_1 = __importDefault(require_mdns_server()), browser_1 = __importDefault(require_browser());
+    exports.Browser = browser_1.default;
+    var service_1 = __importDefault(require_service());
+    exports.Service = service_1.default;
+    var Bonjour2 = class {
+      constructor(opts = {}, errorCallback) {
+        this.server = new mdns_server_1.default(opts, errorCallback), this.registry = new registry_1.default(this.server);
+      }
+      publish(opts) {
+        return this.registry.publish(opts);
+      }
+      unpublishAll(callback) {
+        return this.registry.unpublishAll(callback);
+      }
+      find(opts = null, onup) {
+        return new browser_1.default(this.server.mdns, opts, onup);
+      }
+      findOne(opts = null, timeout = 1e4, callback) {
+        let browser = new browser_1.default(this.server.mdns, opts);
+        var timer;
+        return browser.once("up", (service) => {
+          timer !== void 0 && clearTimeout(timer), browser.stop(), callback && callback(service);
+        }), timer = setTimeout(() => {
+          browser.stop(), callback && callback(null);
+        }, timeout), browser;
+      }
+      destroy(callback) {
+        this.registry.destroy(), this.server.mdns.destroy(callback);
+      }
+    };
+    exports.Bonjour = Bonjour2;
+    exports.default = Bonjour2;
+  }
+});
+
+// src/main/services/mdns-service.ts
+var import_bonjour_service = __toESM(require_dist());
+import { randomBytes } from "crypto";
+import { EventEmitter } from "events";
+import { isIP } from "net";
+import { hostname, networkInterfaces } from "os";
+var MAX_TS_ADDRESSES = 4, SERVICE_TYPE = "adf-runtime", LEGACY_DAEMON_SERVICE_TYPE = "adf-daemon", FINGERPRINT = /^[A-Z2-7]{4}-[A-Z2-7]{4}$/, PROTO_VERSION = "alf/0.2", DIRECTORY_PATH = "/agents", GOODBYE_FLUSH_MS = 100, MdnsService = class extends EventEmitter {
+  bonjour = null;
+  published = null;
+  discovered = /* @__PURE__ */ new Map();
+  /** Remote-access sightings: fingerprint → source (`mdns:<instance>`, `legacy:<instance>`, `tailnet:<address>`) → sighting. */
+  remotes = /* @__PURE__ */ new Map();
+  selfRuntimeId = null;
+  selfFingerprint = null;
+  base = null;
+  announced = null;
+  announcedRemote = !1;
+  /**
+   * The instance name of a record without the mesh when no alias is set: random
+   * per service, so per network (a network change restarts the service). Nothing
+   * in such a record links it to this runtime on another network.
+   */
+  hiddenToken = randomBytes(6).toString("hex");
+  /** True iff we've successfully published our own service record. */
+  isAnnouncing() {
+    return this.published !== null;
+  }
+  /** True while the published record carries remote access. */
+  isAnnouncingRemote() {
+    return this.published !== null && this.announcedRemote;
+  }
+  async start(opts) {
+    let iface = opts.iface ?? pickMdnsInterface();
+    try {
+      let bonjourOpts = iface ? { interface: iface, bind: "0.0.0.0" } : void 0;
+      this.bonjour = new import_bonjour_service.Bonjour(bonjourOpts);
+    } catch (err) {
+      this.emitUnavailable(err);
+      return;
+    }
+    if (console.log(`[mdns] using interface=${iface ?? "<default/all>"} (bind=${iface ? "0.0.0.0" : "<default>"})`), this.selfRuntimeId = opts.runtimeId, this.base = { port: opts.port, runtimeId: opts.runtimeId, ...opts.runtimeDid ? { runtimeDid: opts.runtimeDid } : {} }, await this.updateAnnouncement(opts), opts.browse)
+      try {
+        let browser = this.bonjour.find({ type: SERVICE_TYPE, protocol: "tcp" });
+        browser.on("up", (service) => this.onServiceUp(service)), browser.on("down", (service) => this.onServiceDown(service));
+        let legacy = this.bonjour.find({ type: LEGACY_DAEMON_SERVICE_TYPE, protocol: "tcp" });
+        legacy.on("up", (service) => this.onLegacyDaemonUp(service)), legacy.on("down", (service) => this.onLegacyDaemonDown(service)), console.log(`[mdns] browsing for _${SERVICE_TYPE}._tcp peers (and legacy _${LEGACY_DAEMON_SERVICE_TYPE}._tcp)`);
+      } catch (err) {
+        console.error("[mdns] browse failed:", err);
+      }
+  }
+  /**
+   * Publish, change or withdraw the one announcement without touching the
+   * browser. bonjour-service cannot change a published TXT record, so a
+   * change (pairing window opened, remote access on) re-publishes.
+   */
+  async updateAnnouncement(next) {
+    let bonjour = this.bonjour, base = this.base;
+    if (!bonjour || !base) return;
+    let mesh = next.mesh ?? !0, remote = next.announce ? next.remote ?? null : null, key = next.announce ? JSON.stringify({ mesh, remote }) : null;
+    if (key !== this.announced) {
+      if (this.published) {
+        let old = this.published;
+        this.published = null, await new Promise((resolve) => {
+          try {
+            old.stop?.(() => resolve()) ?? resolve();
+          } catch {
+            resolve();
+          }
+          setTimeout(resolve, GOODBYE_FLUSH_MS);
+        });
+      }
+      if (this.announced = key, this.announcedRemote = !1, this.selfFingerprint = remote?.fingerprint ?? this.selfFingerprint, !!next.announce)
+        try {
+          let host = ensureLocalSuffix(hostname()), hidden = !mesh && !!remote, txt = hidden ? {} : {
+            runtime_id: base.runtimeId,
+            proto: PROTO_VERSION,
+            directory: DIRECTORY_PATH
+          };
+          if (!hidden && base.runtimeDid && (txt.runtime_did = base.runtimeDid), remote) {
+            txt.v = "1", txt.fp = remote.fingerprint, txt.pair = remote.pairingOpen ? "1" : "0", txt.daemon_port = String(remote.port);
+            let ts = (remote.tailnet ?? []).filter((a) => isIP(a) !== 0).slice(0, MAX_TS_ADDRESSES);
+            ts.length > 0 && (txt.ts = ts.join(",")), hidden || (txt.api = remote.api, txt.name = remote.name);
+          }
+          this.published = bonjour.publish({
+            name: hidden ? remote.alias || `adf-${this.hiddenToken}` : `adf-${base.runtimeId}`,
+            type: SERVICE_TYPE,
+            protocol: "tcp",
+            // A mesh that is not LAN-visible has nothing to reach on its port: the daemon's then.
+            port: hidden ? remote.port : base.port,
+            host,
+            txt,
+            // The name is runtime_id-unique, so the only record that can hold
+            // it is our OWN stale announcement from before a restart — probing
+            // sees that ghost within its TTL and throws "Service name is
+            // already in use on the network" (async, from multicast-dns'
+            // onresponse, so no try/catch reaches it). Skip the probe.
+            probe: !1
+          }), this.announcedRemote = !!remote, console.log(`[mdns] announcing _${SERVICE_TYPE}._tcp as ${host}:${base.port} (runtime_id=${base.runtimeId}${mesh ? "" : ", mesh not visible"}${remote ? `, remote access fp ${remote.fingerprint} on ${remote.port}, pairing ${remote.pairingOpen ? "open" : "closed"}` : ""})`);
+        } catch (err) {
+          console.error("[mdns] publish failed:", err);
+        }
+    }
+  }
+  async stop() {
+    let b = this.bonjour;
+    if (b) {
+      this.bonjour = null;
+      try {
+        await new Promise((resolve) => {
+          try {
+            b.unpublishAll(() => resolve());
+          } catch {
+            resolve();
+          }
+        });
+      } catch {
+      }
+      await new Promise((resolve) => setTimeout(resolve, GOODBYE_FLUSH_MS));
+      try {
+        b.destroy();
+      } catch {
+      }
+      this.published = null, this.announced = null, this.announcedRemote = !1, this.discovered.clear(), this.remotes.clear();
+    }
+  }
+  /**
+   * The feed: every ADF computer found, with both capabilities. The mesh
+   * list is the entries with a mesh; Studio's Discovered list and
+   * `adf pair` are the entries with remote access.
+   */
+  peers() {
+    let out = [], byAddress = /* @__PURE__ */ new Map(), clashEntry = (fp, sighting, count) => ({
+      key: `fp:${fp}@${sighting.address}`,
+      name: sighting.name,
+      source: sighting.kind === "tailnet" ? "tailnet" : "mdns",
+      mesh: null,
+      remote: { url: buildBaseUrl(sighting.address, sighting.port), port: sighting.port, fingerprint: fp, pairingOpen: sighting.pairingOpen, kind: sighting.kind, clash: count }
+    });
+    for (let [fp, sightings] of this.remotes) {
+      let list = [...sightings.values()];
+      if (list.length === 0) continue;
+      let lan = list.filter((s) => s.kind === "lan"), tailnet = list.filter((s) => s.kind === "tailnet"), merged = lan.length === 1 && tailnet.length === 1 && lan[0].listed.includes(tailnet[0].address.toLowerCase());
+      if (!merged && list.length > 1) {
+        for (let s of list) out.push(clashEntry(fp, s, list.length));
+        continue;
+      }
+      let best = merged ? tailnet[0] : list[0], entry = {
+        key: `fp:${fp}`,
+        // Merged: the tailnet host's own name (authenticated address), not the LAN record's.
+        name: best.name,
+        source: best.kind === "tailnet" ? "tailnet" : "mdns",
+        mesh: null,
+        remote: { url: buildBaseUrl(best.address, best.port), port: best.port, fingerprint: fp, pairingOpen: list.some((s) => s.pairingOpen), kind: best.kind, clash: null }
+      };
+      out.push(entry), byAddress.set(best.address.toLowerCase(), entry);
+    }
+    for (let runtime of this.discovered.values()) {
+      let host = "";
+      try {
+        host = new URL(runtime.url).hostname.replace(/^\[|\]$/g, "").toLowerCase();
+      } catch {
+      }
+      let entry = host ? byAddress.get(host) : void 0;
+      if (entry && !entry.mesh) {
+        entry.key = runtime.runtime_id, entry.mesh = { url: runtime.url, port: runtime.port }, entry.source === "mdns" && (entry.source = runtime.source ?? "mdns");
+        continue;
+      }
+      out.push({
+        key: runtime.runtime_id,
+        name: runtime.host.replace(/\.local\.?$/, ""),
+        source: runtime.source ?? "mdns",
+        mesh: { url: runtime.url, port: runtime.port },
+        remote: null
+      });
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name) || a.key.localeCompare(b.key));
+  }
+  /** The tailnet sweep found an ADF daemon with remote access on (GET /remote/hello, already bounded and checked). */
+  upsertTailnetDaemon(found) {
+    if (!FINGERPRINT.test(found.fingerprint) || found.fingerprint === this.selfFingerprint) return;
+    let name = peerName(found.name) ?? found.fingerprint;
+    this.setSighting(found.fingerprint, `tailnet:${found.address}`, { name, address: found.address, port: found.port, pairingOpen: found.pairingOpen, kind: "tailnet", runtimeId: null, listed: [] }) && this.emit("peers_changed");
+  }
+  /** After a tailnet sweep: sightings it no longer found (`<fingerprint>@<address>`) go. */
+  expireTailnetDaemons(seen) {
+    let changed = !1;
+    for (let [fp, sightings] of this.remotes) {
+      for (let [source, s] of sightings)
+        s.kind !== "tailnet" || seen.has(`${fp}@${s.address}`) || (sightings.delete(source), changed = !0);
+      sightings.size === 0 && this.remotes.delete(fp);
+    }
+    changed && this.emit("peers_changed");
+  }
+  /** Store a sighting; true when something changed. */
+  setSighting(fp, source, sighting) {
+    let sightings = this.remotes.get(fp) ?? /* @__PURE__ */ new Map(), before = JSON.stringify(sightings.get(source) ?? null);
+    return sightings.set(source, sighting), this.remotes.set(fp, sightings), before !== JSON.stringify(sighting);
+  }
+  /** Drop sightings that match; true when something went. */
+  dropSightings(match) {
+    let changed = !1;
+    for (let [fp, sightings] of this.remotes) {
+      for (let [source, s] of sightings)
+        match(fp, source, s) && (sightings.delete(source), changed = !0);
+      sightings.size === 0 && this.remotes.delete(fp);
+    }
+    return changed;
+  }
+  getDiscoveredRuntimes() {
+    return [...this.discovered.values()];
+  }
+  getDiscovered(runtimeId) {
+    return this.discovered.get(runtimeId);
+  }
+  /**
+   * Insert/refresh a peer found outside mDNS (tailnet sweep, manual list).
+   * mDNS entries win by default — a same-broadcast-domain route beats an
+   * overlay route to the same runtime — so an external upsert never clobbers
+   * one. `force` overrides that: the browser only ever removes an entry on an
+   * explicit goodbye packet, so after a network move a dead LAN entry would
+   * shadow a working overlay route forever. The tailnet sweep passes `force`
+   * once it has probed the mDNS route and found it dead.
+   */
+  upsertExternalPeer(entry, opts) {
+    if (entry.runtime_id === this.selfRuntimeId) return;
+    let now = Date.now(), existing = this.discovered.get(entry.runtime_id);
+    if (existing && (existing.source ?? "mdns") === "mdns" && !opts?.force)
+      return;
+    let next = {
+      runtime_id: entry.runtime_id,
+      runtime_did: entry.runtime_did ?? existing?.runtime_did,
+      proto: entry.proto ?? PROTO_VERSION,
+      directory_path: DIRECTORY_PATH,
+      host: entry.host,
+      port: entry.port,
+      url: entry.url,
+      first_seen: existing?.first_seen ?? now,
+      last_seen: now,
+      source: entry.source
+    }, isNew = !existing || existing.url !== next.url;
+    this.discovered.set(entry.runtime_id, next), isNew && (this.emit("discovered", next), this.emit("peers_changed"));
+  }
+  /** Remove an externally-sourced peer (never touches mDNS entries). */
+  removeExternalPeer(runtimeId) {
+    let entry = this.discovered.get(runtimeId);
+    !entry || (entry.source ?? "mdns") === "mdns" || (this.discovered.delete(runtimeId), this.emit("expired", entry), this.emit("peers_changed"));
+  }
+  // --- Internal ---
+  onServiceUp(service) {
+    let txt = service.txt ?? {}, runtimeId = typeof txt.runtime_id == "string" ? txt.runtime_id : void 0;
+    if (!txtWithinBounds(txt)) return;
+    if (!runtimeId) {
+      this.onRemoteOnlyUp(service, txt);
+      return;
+    }
+    if (runtimeId === this.selfRuntimeId) return;
+    let runtimeDid = typeof txt.runtime_did == "string" ? txt.runtime_did : void 0, proto = typeof txt.proto == "string" ? txt.proto : PROTO_VERSION, directoryPath = typeof txt.directory == "string" ? txt.directory : DIRECTORY_PATH, host = service.host || service.fqdn || "", port = service.port;
+    if (!host || !port) return;
+    let referer = service.referer, isPrivateV4 = (ip) => /^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.)/.test(ip), addresses = service.addresses ?? [], reachHost = referer?.address ?? addresses.find(isPrivateV4) ?? host, fp = txtString(txt, "fp"), daemonPort = Number(txtString(txt, "daemon_port")), source = `mdns:${service.name}`, remoteAccess = !!fp && FINGERPRINT.test(fp) && txtString(txt, "v") === "1" && Number.isInteger(daemonPort) && daemonPort > 0 && daemonPort < 65536;
+    if (remoteAccess) {
+      let name = peerName(txtString(txt, "name")) ?? peerName(host.replace(/\.local\.?$/, "")) ?? fp;
+      this.dropSightings((f, src) => src === source && f !== fp), this.setSighting(fp, source, { name, address: reachHost, port: daemonPort, pairingOpen: txtString(txt, "pair") === "1", kind: "lan", runtimeId, listed: listedAddresses(service) });
+    } else
+      this.dropSightings((_f, src, s) => src === source || s.runtimeId === runtimeId);
+    let now = Date.now(), existing = this.discovered.get(runtimeId);
+    if (txtString(txt, "mesh") === "0") {
+      existing && (this.discovered.delete(runtimeId), this.emit("expired", existing)), this.emit("peers_changed");
+      return;
+    }
+    let entry = {
+      runtime_id: runtimeId,
+      runtime_did: runtimeDid,
+      proto,
+      directory_path: directoryPath,
+      host,
+      port,
+      url: buildBaseUrl(reachHost, port),
+      first_seen: existing?.first_seen ?? now,
+      last_seen: now,
+      ...remoteAccess ? { fingerprint: fp, daemon_port: daemonPort } : {}
+    };
+    this.discovered.set(runtimeId, entry), this.emit("discovered", entry), this.emit("peers_changed");
+  }
+  /** TODO(remove after the next release): `_adf-daemon._tcp` of this PR's intermediate commits. */
+  onLegacyDaemonUp(service) {
+    let txt = service.txt ?? {};
+    if (!txtWithinBounds(txt)) return;
+    let fp = txtString(txt, "fp");
+    if (!fp || !FINGERPRINT.test(fp) || txtString(txt, "v") !== "1" || !service.port || fp === this.selfFingerprint) return;
+    let address = sourceAddress(service);
+    if (!address) return;
+    let name = peerName(service.name) ?? fp;
+    this.setSighting(fp, `legacy:${service.name}`, { name, address, port: service.port, pairingOpen: txtString(txt, "pair") === "1", kind: "lan", runtimeId: null, listed: listedAddresses(service) }), this.emit("peers_changed");
+  }
+  onLegacyDaemonDown(service) {
+    let fp = txtString(service.txt ?? {}, "fp");
+    this.dropSightings((f, src) => service.name ? src === `legacy:${service.name}` : f === fp && src.startsWith("legacy:")) && this.emit("peers_changed");
+  }
+  /** A record with remote access only (the mesh hidden): no runtime id, keyed by fingerprint. */
+  onRemoteOnlyUp(service, txt) {
+    let fp = txtString(txt, "fp"), daemonPort = Number(txtString(txt, "daemon_port"));
+    if (!fp || !FINGERPRINT.test(fp) || txtString(txt, "v") !== "1" || !Number.isInteger(daemonPort) || daemonPort <= 0 || daemonPort >= 65536 || fp === this.selfFingerprint) return;
+    let address = sourceAddress(service);
+    if (!address) return;
+    let host = (service.host || "").replace(/\.local\.?$/, ""), name = (/^adf-[0-9a-f]{12}$/.test(service.name ?? "") ? null : peerName(service.name)) ?? peerName(host) ?? fp, source = `mdns:${service.name}`;
+    this.dropSightings((f, src) => src === source && f !== fp), this.setSighting(fp, source, { name, address, port: daemonPort, pairingOpen: txtString(txt, "pair") === "1", kind: "lan", runtimeId: null, listed: listedAddresses(service) }), this.emit("peers_changed");
+  }
+  onServiceDown(service) {
+    let txt = service.txt ?? {}, runtimeId = typeof txt.runtime_id == "string" ? txt.runtime_id : void 0, fp = txtString(txt, "fp");
+    this.dropSightings((f, src, s) => (service.name ? src === `mdns:${service.name}` : !1) || !!runtimeId && s.runtimeId === runtimeId || !service.name && !runtimeId && f === fp && src.startsWith("mdns:"));
+    let entry = runtimeId ? this.discovered.get(runtimeId) : void 0;
+    runtimeId && entry && (this.discovered.delete(runtimeId), this.emit("expired", entry)), this.emit("peers_changed");
+  }
+  emitUnavailable(err) {
+    let reason = err instanceof Error ? err.message : String(err);
+    console.log(`[mdns] unavailable: ${reason}. LAN discovery disabled; direct-address messaging still works.`), this.emit("unavailable", { reason });
+  }
+}, VIRTUAL_IFACE_RE = /^(lo\d*|gif\d*|stf\d*|awdl\d*|llw\d*|anpi\d*|ap\d+|bridge\d*|utun\d*|ipsec\d*|ppp\d*|tun\d*|tap\d*|veth|vmnet\d*|vboxnet\d*|docker\d*|br-|wg\d*|tailscale\d*|zt[a-z0-9]+)/i, VIRTUAL_IFACE_WIN_RE = /(vEthernet|VMware|VirtualBox|Hyper-?V|WSL|Bluetooth|Loopback|Npcap|Pseudo-|Wintun|Tailscale|TAP-Windows|OpenVPN)/i;
+function isRFC1918(ipv4) {
+  let [o1, o2] = ipv4.split(".").map(Number);
+  return o1 === 10 || o1 === 172 && o2 >= 16 && o2 <= 31 || o1 === 192 && o2 === 168;
+}
+function isCGNAT(ipv4) {
+  let [o1, o2] = ipv4.split(".").map(Number);
+  return o1 === 100 && o2 >= 64 && o2 <= 127;
+}
+function pickMdnsInterface(ifaces = networkInterfaces(), envOverride = process.env.ADF_MDNS_INTERFACE) {
+  if (envOverride && envOverride.trim()) return envOverride.trim();
+  let candidates = [];
+  for (let [name, addrs] of Object.entries(ifaces))
+    if (addrs && !(VIRTUAL_IFACE_RE.test(name) || VIRTUAL_IFACE_WIN_RE.test(name)))
+      for (let a of addrs) {
+        if (a.internal || a.family !== "IPv4" || isCGNAT(a.address) || !isRFC1918(a.address)) continue;
+        let score = 0;
+        /^en\d|^eth\d|^wl/i.test(name) && (score += 10), /^(Ethernet|Wi-?Fi)/i.test(name) && (score += 10), candidates.push({ name, address: a.address, score });
+      }
+  if (candidates.length !== 0)
+    return candidates.sort((a, b) => b.score - a.score), candidates[0].address;
+}
+function ensureLocalSuffix(host) {
+  if (!host) return "adf-runtime.local";
+  let lower = host.toLowerCase();
+  return lower.endsWith(".local") || lower.endsWith(".local.") || host.includes(":") ? host : `${host}.local`;
+}
+function txtString(txt, key) {
+  let value = txt[key];
+  return typeof value == "string" ? value : typeof value == "number" || typeof value == "boolean" ? String(value) : value instanceof Uint8Array ? Buffer.from(value).toString("utf8") : null;
+}
+function listedAddresses(service) {
+  return [...(service.addresses ?? []).filter((a) => typeof a == "string" && a.length <= 64).slice(0, 32), ...tsAddresses(service.txt ?? {})].map((a) => a.toLowerCase());
+}
+function tsAddresses(txt) {
+  let raw = txtString(txt, "ts");
+  return raw ? raw.split(",").map((a) => a.trim()).filter((a) => a.length > 0 && a.length <= 64 && isIP(a) !== 0).slice(0, MAX_TS_ADDRESSES) : [];
+}
+function sourceAddress(service) {
+  let referer = service.referer?.address, addresses = (service.addresses ?? []).filter((a) => typeof a == "string" && a.length <= 64), address = referer ?? addresses.find((ip) => /^(10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.)/.test(ip)) ?? addresses[0];
+  return address && address.length <= 64 ? address : null;
+}
+function buildBaseUrl(host, port) {
+  return `http://${host.includes(":") && !/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(host) ? `[${host}]` : host}:${port}`;
+}
+
+export {
+  MdnsService,
+  VIRTUAL_IFACE_RE,
+  VIRTUAL_IFACE_WIN_RE,
+  isRFC1918,
+  isCGNAT
+};