@chainfuse/helpers 4.2.14 → 4.3.0

package/dist/dns.d.mts

@@ -1,74 +1,84 @@
-/**
- * Supported parameters for Cloudflare's 1.1.1.1 DNS over HTTPS API
- */
-export interface DohBodyRequest {
-    /** Query name (required) */
-    name: string;
-    /** Query type - either a numeric value or text. Default is 'A' */
-    type?: string | number;
-    /**
-     * DO bit - whether the client wants DNSSEC data.
-     * Either empty or one of `0`, `false`, `1`, or `true`. Default is `false`
-     */
-    do?: string | number | boolean;
+import type { CacheStorageLike } from '@chainfuse/types';
+import type { DurableObjectState, ExecutionContext } from '@cloudflare/workers-types/experimental';
+import * as dnsPacket from 'dns-packet';
+import * as zm from 'zod/mini';
+export declare enum DNSRecordType {
+    'A (IPv4 Address)' = "A",
+    'AAAA (IPv6 Address)' = "AAAA",
+    'AFSDB (AFS database)' = "AFSDB",
+    'APL (Address Prefix List)' = "APL",
+    'AXFR (Zone transfer)' = "AXFR",
+    'CAA (CA authorizations)' = "CAA",
+    'CDNSKEY (Child DNSKEY)' = "CDNSKEY",
+    'CDS (Child DS)' = "CDS",
+    'CERT (Certificate)' = "CERT",
+    'CNAME (Canonical Name)' = "CNAME",
+    'DNAME (Delegation Name)' = "DNAME",
+    'DHCID (DHCP Identifier)' = "DHCID",
+    'DLV (DNSSEC Lookaside Validation)' = "DLV",
+    'DNSKEY (DNSSEC Key)' = "DNSKEY",
+    'DS (Delegation Signer)' = "DS",
+    'HINFO (Host Info)' = "HINFO",
+    'HIP (Host Identity Protocol)' = "HIP",
+    'IXFR (Incremental Zone Transfer)' = "IXFR",
+    'IPSECKEY (IPSEC Key)' = "IPSECKEY",
+    'KEY (Key record)' = "KEY",
+    'KX (Key Exchanger)' = "KX",
+    'LOC (Location)' = "LOC",
+    'MX (Mail Exchange)' = "MX",
+    'NAPTR (Name Authority Pointer)' = "NAPTR",
+    'NS (Name Server)' = "NS",
+    'NSEC (Next Secure)' = "NSEC",
+    'NSEC3 (Next Secure v3)' = "NSEC3",
+    'NSEC3PARAM (NSEC3 Parameters)' = "NSEC3PARAM",
+    'NULL (Experimental null RR)' = "NULL",
+    'OPT (EDNS Options)' = "OPT",
+    'PTR (Pointer)' = "PTR",
+    'RRSIG (DNSSEC Signature)' = "RRSIG",
+    'RP (Responsible Person)' = "RP",
+    'SIG (Signature)' = "SIG",
+    'SOA (Start of Authority)' = "SOA",
+    'SRV (Service)' = "SRV",
+    'SSHFP (SSH Fingerprint)' = "SSHFP",
+    'TA (DNSSEC Trust Anchor)' = "TA",
+    'TKEY (Transaction Key)' = "TKEY",
+    'TLSA (certificate associations)' = "TLSA",
+    'TSIG (Transaction Signature)' = "TSIG",
+    'TXT (Text)' = "TXT",
+    'URI (Uniform Resource Identifier)' = "URI"
+}
+export declare class DnsHelpers<C extends CacheStorageLike, EC extends Pick<ExecutionContext | DurableObjectState, 'waitUntil'> = Pick<ExecutionContext | DurableObjectState, 'waitUntil'>> {
+    private nameservers;
+    private cache?;
+    private backgroundContext?;
+    static readonly constructorArgs: zm.ZodMiniObject<{
+        nameservers: zm.ZodMiniArray<zm.ZodMiniCodec<zm.ZodMiniURL, zm.ZodMiniCustom<URL, URL>>>;
+    }, zm.z.core.$strip>;
     /**
-     * CD bit - disable validation.
-     * Either empty or one of `0`, `false`, `1`, or `true`. Default is `false`
+     * Create a DNS helper instance.
+     * @param args Parsed constructor args containing the resolver nameserver URLs.
+     * @param cacheStore Optional CacheStorage-like implementation to persist DNS lookups; if null, cache is disabled.
      */
-    cd?: string | number | boolean;
-}
-/**
- * A record structure with name, type, TTL, and data.
- */
-interface Record {
-    /** The record owner */
-    name: string;
-    /** The type of DNS record. Defined here: https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-4 */
-    type: number;
-    /** The number of seconds the answer can be stored in cache before it is considered stale */
-    TTL: number;
-    /** The value of the DNS record for the given name and type. The data will be in text for standardized record types and in hex for unknown types */
-    data: string;
-}
-/**
- * A successful DNS response from Cloudflare's 1.1.1.1 DNS over HTTPS API
- */
-export interface DohSuccessfulResponse {
-    /** The Response Code of the DNS Query. Defined here: https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-6 */
-    Status: number;
-    /** True if the truncated bit was set. This happens when the DNS answer is larger than a single UDP or TCP packet */
-    TC: boolean;
-    /** True if the Recursive Desired bit was set. This is always set to true for Cloudflare DNS over HTTPS */
-    RD: boolean;
-    /** True if the Recursion Available bit was set. This is always set to true for Cloudflare DNS over HTTPS */
-    RA: boolean;
-    /** True if every record in the answer was verified with DNSSEC */
-    AD: boolean;
-    /** True if the client asked to disable DNSSEC validation. In this case, Cloudflare will still fetch the DNSSEC-related records, but it will not attempt to validate the records */
-    CD: boolean;
-    /** The record name requested */
-    Question: Record[];
-    /** The answer record */
-    Answer?: Record[];
-    /** The authority record */
-    Authority: Record[];
-    /** The additional record */
-    Additional: Record[];
-    /** List of EDE messages. Refer to Extended DNS error codes for more information */
-    Comment?: string[];
-}
-/**
- * An error response from Cloudflare's 1.1.1.1 DNS over HTTPS API
- */
-export interface DohErrorResponse {
-    /** An explanation of the error that occurred */
-    error: string;
-}
-export declare class DnsHelpers {
-    private nameserver_url;
-    constructor(nameserver_url: string | URL);
-    query(qName: string, qType?: string | number, qDo?: string | number | boolean, qCd?: string | number | boolean, timeout?: number): Promise<DohSuccessfulResponse | DohErrorResponse>;
-    private makeGetQuery;
-    private sendDohMsg;
+    constructor(args: zm.input<(typeof DnsHelpers)['constructorArgs']>, cacheStore?: C | null, backgroundContext?: EC);
+    static readonly queryArgs: zm.ZodMiniObject<{
+        questions: zm.ZodMiniArray<zm.ZodMiniObject<{
+            hostname: zm.ZodMiniString<string>;
+            recordType: zm.ZodMiniDefault<zm.ZodMiniEnum<typeof DNSRecordType>>;
+        }, zm.z.core.$strip>>;
+        flags: zm.ZodMiniDefault<zm.ZodMiniObject<{
+            recursion: zm.ZodMiniDefault<zm.ZodMiniBoolean<boolean>>;
+            dnssecCheck: zm.ZodMiniDefault<zm.ZodMiniBoolean<boolean>>;
+        }, zm.z.core.$strip>>;
+        timeout: zm.ZodMiniUnion<readonly [zm.ZodMiniCustom<AbortSignal, AbortSignal>, zm.ZodMiniPipe<zm.ZodMiniDefault<zm.ZodMiniNumberFormat>, zm.ZodMiniTransform<AbortSignal, number>>]>;
+    }, zm.z.core.$strip>;
+    query(_args: zm.input<(typeof DnsHelpers)['queryArgs']>): Promise<{
+        readonly flags: {
+            readonly 'Official Authority': boolean;
+            readonly 'DNSSEC Verified': boolean;
+            readonly 'Recursion Available': boolean;
+            readonly Truncated: boolean;
+        };
+        readonly answers: dnsPacket.Answer[] | undefined;
+    }>;
+    private _query;
 }
-export {};

package/dist/dns.mjs

@@ -1,46 +1,336 @@
+import * as dnsPacket from 'dns-packet';
+import * as zm from 'zod/mini';
+import { CryptoHelpers } from "./crypto.mjs";
+export var DNSRecordType;
+(function (DNSRecordType) {
+    DNSRecordType["A (IPv4 Address)"] = "A";
+    DNSRecordType["AAAA (IPv6 Address)"] = "AAAA";
+    DNSRecordType["AFSDB (AFS database)"] = "AFSDB";
+    DNSRecordType["APL (Address Prefix List)"] = "APL";
+    DNSRecordType["AXFR (Zone transfer)"] = "AXFR";
+    DNSRecordType["CAA (CA authorizations)"] = "CAA";
+    DNSRecordType["CDNSKEY (Child DNSKEY)"] = "CDNSKEY";
+    DNSRecordType["CDS (Child DS)"] = "CDS";
+    DNSRecordType["CERT (Certificate)"] = "CERT";
+    DNSRecordType["CNAME (Canonical Name)"] = "CNAME";
+    DNSRecordType["DNAME (Delegation Name)"] = "DNAME";
+    DNSRecordType["DHCID (DHCP Identifier)"] = "DHCID";
+    DNSRecordType["DLV (DNSSEC Lookaside Validation)"] = "DLV";
+    DNSRecordType["DNSKEY (DNSSEC Key)"] = "DNSKEY";
+    DNSRecordType["DS (Delegation Signer)"] = "DS";
+    DNSRecordType["HINFO (Host Info)"] = "HINFO";
+    DNSRecordType["HIP (Host Identity Protocol)"] = "HIP";
+    DNSRecordType["IXFR (Incremental Zone Transfer)"] = "IXFR";
+    DNSRecordType["IPSECKEY (IPSEC Key)"] = "IPSECKEY";
+    DNSRecordType["KEY (Key record)"] = "KEY";
+    DNSRecordType["KX (Key Exchanger)"] = "KX";
+    DNSRecordType["LOC (Location)"] = "LOC";
+    DNSRecordType["MX (Mail Exchange)"] = "MX";
+    DNSRecordType["NAPTR (Name Authority Pointer)"] = "NAPTR";
+    DNSRecordType["NS (Name Server)"] = "NS";
+    DNSRecordType["NSEC (Next Secure)"] = "NSEC";
+    DNSRecordType["NSEC3 (Next Secure v3)"] = "NSEC3";
+    DNSRecordType["NSEC3PARAM (NSEC3 Parameters)"] = "NSEC3PARAM";
+    DNSRecordType["NULL (Experimental null RR)"] = "NULL";
+    DNSRecordType["OPT (EDNS Options)"] = "OPT";
+    DNSRecordType["PTR (Pointer)"] = "PTR";
+    DNSRecordType["RRSIG (DNSSEC Signature)"] = "RRSIG";
+    DNSRecordType["RP (Responsible Person)"] = "RP";
+    DNSRecordType["SIG (Signature)"] = "SIG";
+    DNSRecordType["SOA (Start of Authority)"] = "SOA";
+    DNSRecordType["SRV (Service)"] = "SRV";
+    DNSRecordType["SSHFP (SSH Fingerprint)"] = "SSHFP";
+    DNSRecordType["TA (DNSSEC Trust Anchor)"] = "TA";
+    DNSRecordType["TKEY (Transaction Key)"] = "TKEY";
+    DNSRecordType["TLSA (certificate associations)"] = "TLSA";
+    DNSRecordType["TSIG (Transaction Signature)"] = "TSIG";
+    DNSRecordType["TXT (Text)"] = "TXT";
+    DNSRecordType["URI (Uniform Resource Identifier)"] = "URI";
+})(DNSRecordType || (DNSRecordType = {}));
 export class DnsHelpers {
-    nameserver_url;
-    constructor(nameserver_url) {
-        this.nameserver_url = new URL(nameserver_url);
+    nameservers;
+    cache;
+    backgroundContext;
+    static constructorArgs = zm.object({
+        nameservers: zm
+            .array(zm.codec(zm.url({ protocol: /^(https|tls)$/, hostname: zm.regexes.domain }).check(zm.trim(), zm.minLength(1)), zm.instanceof(URL), {
+            decode: (urlString) => new URL(urlString),
+            encode: (url) => url.href,
+        }))
+            .check(zm.minLength(1)),
+    });
+    /**
+     * Create a DNS helper instance.
+     * @param args Parsed constructor args containing the resolver nameserver URLs.
+     * @param cacheStore Optional CacheStorage-like implementation to persist DNS lookups; if null, cache is disabled.
+     */
+    constructor(args, cacheStore, backgroundContext) {
+        const { nameservers } = DnsHelpers.constructorArgs.parse(args);
+        this.nameservers = nameservers;
+        if (cacheStore !== null) {
+            cacheStore ??= globalThis.caches;
+            if ('open' in cacheStore && typeof cacheStore.open === 'function') {
+                this.cache = cacheStore.open('dns');
+            }
+            else {
+                throw new Error('Cache store must be a CacheStorage (or equivalent of)');
+            }
+        }
+        this.backgroundContext = backgroundContext;
     }
-    query(qName, qType = 'A', qDo = false, qCd = false, timeout = 10 * 1000) {
-        return new Promise((resolve, reject) => {
-            this.sendDohMsg(timeout, this.makeGetQuery(this.nameserver_url, qName, qType, qDo, qCd))
-                .then((response) => {
-                if (response.ok) {
-                    response.json().then(resolve).catch(reject);
+    static queryArgs = zm.object({
+        questions: zm
+            .array(zm.object({
+            hostname: zm.string().check(zm.trim(), zm.minLength(1), 
+            // DNS dpec is 255 - final period and non-printed zero octect for root
+            zm.maxLength(253), zm.regex(zm.regexes.domain)),
+            recordType: zm._default(zm.enum(DNSRecordType), DNSRecordType['A (IPv4 Address)']),
+        }))
+            .check(zm.minLength(1)),
+        flags: zm._default(zm.object({
+            recursion: zm._default(zm.boolean(), true),
+            dnssecCheck: zm._default(zm.boolean(), true),
+        }), { recursion: true, dnssecCheck: true }),
+        timeout: zm.union([
+            zm.instanceof(AbortSignal),
+            zm.pipe(zm._default(zm.int().check(zm.positive()), 30 * 1000), zm.transform((ms) => AbortSignal.timeout(ms))),
+        ]),
+    });
+    query(_args) {
+        const args = DnsHelpers.queryArgs.parse(_args);
+        // Throw immediately if already aborted
+        args.timeout.throwIfAborted();
+        return Promise.race([
+            // Passthrough signal and carry over the rest
+            this._query(args.timeout, args.questions, args.flags),
+            // Shortcircuit on abort
+            new Promise((_, reject) => args.timeout.addEventListener('abort', () => {
+                if (args.timeout.reason instanceof DOMException) {
+                    reject(new Error(`${args.timeout.reason.name}: ${args.timeout.reason.message}`, { cause: args.timeout.reason.cause }));
+                }
+                else if (args.timeout.reason instanceof Error) {
+                    reject(args.timeout.reason);
+                }
+                else if (typeof args.timeout.reason === 'string') {
+                    reject(new Error(args.timeout.reason));
+                }
+                else if (args.timeout.reason) {
+                    reject(new Error(JSON.stringify(args.timeout.reason)));
                 }
                 else {
-                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
-                    reject(response.status);
+                    reject(new Error('AbortError'));
                 }
-            })
-                .catch(reject);
-        });
+            }, { once: true })),
+        ]);
     }
-    makeGetQuery(url, qName, qType = 'A', qDo = false, qCd = false) {
-        url.searchParams.set('name', qName);
-        url.searchParams.set('type', qType.toString());
-        url.searchParams.set('do', qDo.toString());
-        url.searchParams.set('cd', qCd.toString());
-        return url;
-    }
-    async sendDohMsg(timeout = 10 * 1000, url = this.nameserver_url) {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeout);
-        const response = await fetch(url, {
-            method: 'GET',
-            headers: {
-                Accept: 'application/dns-json',
-            },
-            signal: controller.signal,
-        });
-        clearTimeout(timer);
-        if (response.ok || response.status === 304) {
-            return response;
+    async _query(signal, questions, flags) {
+        let cacheRequest;
+        let computedflags = 0;
+        if ('recursion' in flags && flags.recursion === true) {
+            computedflags |= dnsPacket.RECURSION_DESIRED;
+        }
+        if ('dnssecCheck' in flags) {
+            if (flags.dnssecCheck) {
+                computedflags |= dnsPacket.DNSSEC_OK;
+            }
+            else {
+                computedflags |= dnsPacket.CHECKING_DISABLED;
+            }
+        }
+        let responsePacket;
+        const errors = [];
+        for (const nameserver of this.nameservers) {
+            // Reset
+            cacheRequest = undefined;
+            responsePacket = undefined;
+            if (this.cache) {
+                const cacheServerUrl = new URL(nameserver);
+                // Cache hard requires http or https protocol
+                cacheServerUrl.protocol = 'https:';
+                // For cache niceness, follow similar to `application/dns-json` format
+                cacheServerUrl.searchParams.set('questions', await CryptoHelpers.getHash('SHA-256', JSON.stringify(questions)));
+                cacheServerUrl.searchParams.set('flags', computedflags.toString());
+                cacheRequest = new Request(cacheServerUrl, { headers: { Accept: 'application/dns-json' }, signal });
+                responsePacket = await (await this.cache).match(cacheRequest).then((response) => {
+                    if (response?.ok) {
+                        return response.json().then((json) => json);
+                    }
+                    else {
+                        return undefined;
+                    }
+                });
+            }
+            const fromCache = Boolean(responsePacket);
+            try {
+                responsePacket ??= await (() => {
+                    const queryPacket = {
+                        type: 'query',
+                        // 1 (inclusive) to 65536 (exclusive)
+                        id: Math.floor(Math.random() * 65535) + 1,
+                        flags: computedflags,
+                        questions: questions.map((q) => ({
+                            name: q.hostname,
+                            type: q.recordType,
+                            class: 'IN',
+                        })),
+                    };
+                    if (nameserver.protocol === 'https:') {
+                        const dnsQueryBuf = dnsPacket.encode(queryPacket);
+                        return fetch(nameserver, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/dns-message',
+                                Accept: 'application/dns-message',
+                            },
+                            signal,
+                            body: new Uint8Array(dnsQueryBuf),
+                        })
+                            .then(async (response) => {
+                            if (response.ok) {
+                                return response.arrayBuffer();
+                            }
+                            else {
+                                throw new Error(`${response?.status} ${response?.statusText}`, { cause: await response?.text() });
+                            }
+                        })
+                            .then((buf) => import('node:buffer').then(({ Buffer }) => dnsPacket.decode(Buffer.from(buf))));
+                    }
+                    else if (nameserver.protocol === 'tls:') {
+                        const dnsQueryBuf = dnsPacket.streamEncode(queryPacket);
+                        return Promise.all([import('node:tls'), import('node:buffer')]).then(([{ connect }, { Buffer }]) => new Promise((resolve, reject) => {
+                            // Setup TLS client
+                            const client = connect({
+                                // RFC 7858 requires 1.2+
+                                minVersion: 'TLSv1.2',
+                                port: nameserver.port === '' ? 853 : parseInt(nameserver.port, 10),
+                                host: nameserver.hostname,
+                                ...(nameserver.pathname !== '' && { path: nameserver.pathname }),
+                            }, () => {
+                                client.write(dnsQueryBuf);
+                            });
+                            // Setup abort handling
+                            const onAbort = () => {
+                                const error = (() => {
+                                    if (signal.reason instanceof DOMException) {
+                                        return new Error(`${signal.reason.name}: ${signal.reason.message}`, { cause: signal.reason.cause });
+                                    }
+                                    else if (signal.reason instanceof Error) {
+                                        return signal.reason;
+                                    }
+                                    else if (typeof signal.reason === 'string') {
+                                        return new Error(signal.reason);
+                                    }
+                                    else if (signal.reason) {
+                                        return new Error(JSON.stringify(signal.reason));
+                                    }
+                                    else {
+                                        return new Error('AbortError');
+                                    }
+                                })();
+                                client.destroy(error);
+                                reject(error);
+                            };
+                            signal.addEventListener('abort', onAbort, { once: true });
+                            // Finish setting up client
+                            client.once('error', reject);
+                            let rawBody = Buffer.from(new Uint8Array(0));
+                            let expectedLength = 0;
+                            client.on('data', (data) => {
+                                if (rawBody.byteLength === 0) {
+                                    expectedLength = data.readUInt16BE(0);
+                                    if (expectedLength < 12) {
+                                        reject(new Error('Below DNS minimum packet length (DNS Header is 12 bytes)'));
+                                    }
+                                    rawBody = Buffer.from(data);
+                                }
+                                else {
+                                    rawBody = Buffer.concat([rawBody, data]);
+                                }
+                                /**
+                                 * @link https://tools.ietf.org/html/rfc7858#section-3.3
+                                 * @link https://tools.ietf.org/html/rfc1035#section-4.2.2
+                                 * The message is prefixed with a two byte length field which gives the message length, excluding the two byte length field.
+                                 */
+                                if (rawBody.length === expectedLength + 2) {
+                                    client.destroy();
+                                    resolve(dnsPacket.streamDecode(rawBody));
+                                }
+                            });
+                            client.once('end', () => signal.removeEventListener('abort', onAbort));
+                        }));
+                    }
+                    else {
+                        throw new Error(`Unsupported protocol: ${nameserver.protocol}`);
+                    }
+                })().then(async (packet) => {
+                    const formattedPacket = {
+                        ...packet,
+                        answers: await import('node:buffer').then(({ Buffer }) => (packet.answers ?? []).map((a) => {
+                            if ('data' in a) {
+                                if (Array.isArray(a.data)) {
+                                    return { ...a, data: a.data.map((part) => (typeof part === 'string' ? part : part.toString('utf8'))) };
+                                }
+                                else if (Buffer.isBuffer(a.data)) {
+                                    return { ...a, data: a.data.toString('utf8') };
+                                }
+                                else if (typeof a.data === 'object') {
+                                    return { ...a, data: a.data };
+                                }
+                                else {
+                                    return { ...a, data: a.data.toString() };
+                                }
+                            }
+                            else {
+                                return a;
+                            }
+                        })),
+                    };
+                    if (this.cache && !fromCache) {
+                        // Re-assign response to make it mutable
+                        const cacheResponse = new Response(JSON.stringify(formattedPacket), { headers: { 'Content-Type': 'application/dns-json' } });
+                        const cachePromise = (async () => {
+                            const answersWithTtl = (formattedPacket.answers ?? []).filter((a) => 'ttl' in a);
+                            const ttl = answersWithTtl.length > 0 ? Math.min(...answersWithTtl.map((a) => ('ttl' in a ? a.ttl : 0))) : 0;
+                            cacheResponse.headers.set('Cache-Control', `public, max-age=${ttl}, s-maxage=${ttl}`);
+                            await CryptoHelpers.generateETag(cacheResponse)
+                                .then((etag) => cacheResponse.headers.set('ETag', etag))
+                                .catch((err) => console.warn('ETag generation failed', err));
+                            return (await this.cache).put(cacheRequest, cacheResponse);
+                        })();
+                        if (this.backgroundContext) {
+                            this.backgroundContext.waitUntil(cachePromise);
+                        }
+                        else {
+                            await cachePromise;
+                        }
+                    }
+                    // Go back to nice JSON format
+                    return formattedPacket;
+                });
+                if (responsePacket)
+                    break;
+            }
+            catch (err) {
+                errors.push(err instanceof Error ? err : new Error(String(err)));
+                continue;
+            }
+        }
+        if (responsePacket) {
+            return {
+                flags: {
+                    'Official Authority': Boolean((responsePacket.flags ?? 0) & dnsPacket.AUTHORITATIVE_ANSWER),
+                    'DNSSEC Verified': Boolean((responsePacket.flags ?? 0) & dnsPacket.AUTHENTIC_DATA),
+                    'Recursion Available': Boolean((responsePacket.flags ?? 0) & dnsPacket.RECURSION_AVAILABLE),
+                    Truncated: Boolean((responsePacket.flags ?? 0) & dnsPacket.TRUNCATED_RESPONSE),
+                },
+                answers: responsePacket.answers,
+            };
         }
         else {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            if (errors.length > 0) {
+                throw new AggregateError(errors, 'No nameserver responded');
+            }
+            throw new Error('No nameserver responded');
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@chainfuse/helpers",
-	"version": "4.2.14",
+	"version": "4.3.0",
 	"description": "",
 	"author": "ChainFuse",
 	"homepage": "https://github.com/ChainFuse/packages/tree/main/packages/helpers#readme",
@@ -84,13 +84,15 @@
 		"@discordjs/rest": "^2.6.0",
 		"chalk": "^5.6.2",
 		"cloudflare": "^5.2.0",
+		"dns-packet": "^5.6.1",
 		"drizzle-orm": "^0.45.1",
 		"strip-ansi": "^7.1.2",
 		"uuid": "^13.0.0",
-		"zod": "^4.3.5"
+		"zod": "^4.3.6"
 	},
 	"devDependencies": {
-		"@cloudflare/workers-types": "^4.20260120.0"
+		"@cloudflare/workers-types": "^4.20260128.0",
+		"@types/dns-packet": "^5.6.5"
 	},
-	"gitHead": "7465800b60661c071d9ca65c41368bb474e6c94c"
+	"gitHead": "3a294f5b789b6beedafb3aa9925a797c26fdc00a"
 }