@push.rocks/smartdns 7.5.1 → 7.8.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartdns',
-    version: '7.5.1',
+    version: '7.8.0',
     description: 'A robust TypeScript library providing advanced DNS management and resolution capabilities including support for DNSSEC, custom DNS servers, and integration with various DNS providers.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxzQkFBc0I7SUFDNUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHlMQUF5TDtDQUN2TSxDQUFBIn0=

package/dist_ts_client/classes.dnsclient.d.ts

@@ -1,47 +1,28 @@
 import * as plugins from './plugins.js';
 export type TDnsProvider = 'google' | 'cloudflare';
 export declare const makeNodeProcessUseDnsProvider: (providerArg: TDnsProvider) => void;
+export type TResolutionStrategy = 'doh' | 'udp' | 'system' | 'prefer-system' | 'prefer-udp';
 export interface ISmartDnsConstructorOptions {
-}
-export interface IDnsJsonResponse {
-    Status: number;
-    TC: boolean;
-    RD: boolean;
-    RA: boolean;
-    AD: boolean;
-    CD: boolean;
-    Question: Array<{
-        name: string;
-        type: number;
-    }>;
-    Answer: Array<{
-        name: string;
-        type: number;
-        TTL: number;
-        data: string;
-    }>;
-    Additional: [];
-    Comment: string;
+    strategy?: TResolutionStrategy;
+    allowDohFallback?: boolean;
+    timeoutMs?: number;
 }
 /**
- * class dnsly offers methods for working with dns from a dns provider like Google DNS
+ * Smartdns offers methods for working with DNS resolution.
+ * Supports system resolver, UDP wire-format, and DoH (DNS-over-HTTPS) via a Rust binary.
  */
 export declare class Smartdns {
-    dnsServerIp: string;
-    dnsServerPort: number;
+    private strategy;
+    private allowDohFallback;
+    private timeoutMs;
+    private rustBridge;
     dnsTypeMap: {
         [key: string]: number;
     };
-    /**
-     * constructor for class dnsly
-     */
     constructor(optionsArg: ISmartDnsConstructorOptions);
+    private getRustBridge;
     /**
-     * check a dns record until it has propagated to Google DNS
-     * should be considerably fast
-     * @param recordNameArg
-     * @param recordTypeArg
-     * @param expectedValue
+     * check a dns record until it has propagated
      */
     checkUntilAvailable(recordNameArg: string, recordTypeArg: plugins.tsclass.network.TDnsRecordType, expectedValue: string, cyclesArg?: number, intervalArg?: number): Promise<boolean>;
     /**
@@ -64,4 +45,12 @@ export declare class Smartdns {
     getNameServers(domainNameArg: string): Promise<string[]>;
     convertDnsTypeNameToTypeNumber(dnsTypeNameArg: string): number;
     convertDnsTypeNumberToTypeName(dnsTypeNumberArg: number): plugins.tsclass.network.TDnsRecordType;
+    /**
+     * Convert a DNS type string from Rust (e.g. "A", "AAAA") to the canonical TDnsRecordType.
+     */
+    private convertDnsTypeNameToCanonical;
+    /**
+     * Destroy the Rust client bridge and free resources.
+     */
+    destroy(): void;
 }

package/dist_ts_client/classes.dnsclient.js

@@ -1,4 +1,5 @@
 import * as plugins from './plugins.js';
+import { RustDnsClientBridge } from './classes.rustdnsclientbridge.js';
 export const makeNodeProcessUseDnsProvider = (providerArg) => {
     switch (providerArg) {
         case 'cloudflare':
@@ -19,27 +20,38 @@ export const makeNodeProcessUseDnsProvider = (providerArg) => {
     }
 };
 /**
- * class dnsly offers methods for working with dns from a dns provider like Google DNS
+ * Smartdns offers methods for working with DNS resolution.
+ * Supports system resolver, UDP wire-format, and DoH (DNS-over-HTTPS) via a Rust binary.
  */
 export class Smartdns {
-    /**
-     * constructor for class dnsly
-     */
     constructor(optionsArg) {
+        this.strategy = 'prefer-system';
+        this.allowDohFallback = true;
+        this.rustBridge = null;
         this.dnsTypeMap = {
             A: 1,
-            AAAA: 28,
+            NS: 2,
             CNAME: 5,
+            SOA: 6,
+            PTR: 12,
             MX: 15,
             TXT: 16,
+            AAAA: 28,
+            SRV: 33,
         };
+        this.strategy = optionsArg?.strategy || 'prefer-system';
+        this.allowDohFallback =
+            optionsArg?.allowDohFallback === undefined ? true : optionsArg.allowDohFallback;
+        this.timeoutMs = optionsArg?.timeoutMs;
+    }
+    getRustBridge() {
+        if (!this.rustBridge) {
+            this.rustBridge = new RustDnsClientBridge();
+        }
+        return this.rustBridge;
     }
     /**
-     * check a dns record until it has propagated to Google DNS
-     * should be considerably fast
-     * @param recordNameArg
-     * @param recordTypeArg
-     * @param expectedValue
+     * check a dns record until it has propagated
      */
     async checkUntilAvailable(recordNameArg, recordTypeArg, expectedValue, cyclesArg = 50, intervalArg = 500) {
         let runCycles = 0;
@@ -65,7 +77,6 @@ export class Smartdns {
                     }
                 }
                 catch (err) {
-                    // console.log(err);
                     await plugins.smartdelay.delayFor(intervalArg);
                     return await doCheck();
                 }
@@ -96,44 +107,96 @@ export class Smartdns {
         return await this.getRecords(recordNameArg, 'TXT');
     }
     async getRecords(recordNameArg, recordTypeArg, retriesCounterArg = 20) {
-        const requestUrl = `https://cloudflare-dns.com/dns-query?name=${recordNameArg}&type=${recordTypeArg}&do=1`;
-        const returnArray = [];
-        const getResponseBody = async (counterArg = 0) => {
-            const response = await plugins.smartrequest.request(requestUrl, {
-                method: 'GET',
-                headers: {
-                    accept: 'application/dns-json',
-                },
-            });
-            const responseBody = response.body;
-            if (responseBody?.Status !== 0 && counterArg < retriesCounterArg) {
-                await plugins.smartdelay.delayFor(500);
-                return getResponseBody(counterArg + 1);
+        const trySystem = async () => {
+            // Prefer dns.lookup for A/AAAA so hosts file and OS resolver are honored
+            if (recordTypeArg === 'A' || recordTypeArg === 'AAAA') {
+                const family = recordTypeArg === 'A' ? 4 : 6;
+                const addresses = await new Promise((resolve, reject) => {
+                    const timer = this.timeoutMs
+                        ? setTimeout(() => reject(new Error('system lookup timeout')), this.timeoutMs)
+                        : null;
+                    plugins.dns.lookup(recordNameArg, { family, all: true }, (err, result) => {
+                        if (timer)
+                            clearTimeout(timer);
+                        if (err)
+                            return reject(err);
+                        resolve(result || []);
+                    });
+                });
+                return addresses.map((a) => ({
+                    name: recordNameArg,
+                    type: recordTypeArg,
+                    dnsSecEnabled: false,
+                    value: a.address,
+                }));
             }
-            else {
-                return responseBody;
+            if (recordTypeArg === 'TXT') {
+                const records = await new Promise((resolve, reject) => {
+                    const timer = this.timeoutMs
+                        ? setTimeout(() => reject(new Error('system resolveTxt timeout')), this.timeoutMs)
+                        : null;
+                    plugins.dns.resolveTxt(recordNameArg, (err, res) => {
+                        if (timer)
+                            clearTimeout(timer);
+                        if (err)
+                            return reject(err);
+                        resolve(res || []);
+                    });
+                });
+                return records.map((chunks) => ({
+                    name: recordNameArg,
+                    type: 'TXT',
+                    dnsSecEnabled: false,
+                    value: chunks.join(''),
+                }));
             }
+            return [];
         };
-        const responseBody = await getResponseBody();
-        if (!responseBody.Answer || !typeof responseBody.Answer[Symbol.iterator]) {
-            return returnArray;
-        }
-        for (const dnsEntry of responseBody.Answer) {
-            if (dnsEntry.data.startsWith('"') && dnsEntry.data.endsWith('"')) {
-                dnsEntry.data = dnsEntry.data.replace(/^"(.*)"$/, '$1');
+        const tryRust = async (protocol) => {
+            const bridge = this.getRustBridge();
+            const result = await bridge.resolve(recordNameArg, recordTypeArg, protocol, undefined, undefined, this.timeoutMs);
+            return result.answers.map((answer) => ({
+                name: answer.name,
+                type: this.convertDnsTypeNameToCanonical(answer.type) || recordTypeArg,
+                dnsSecEnabled: result.adFlag,
+                value: answer.value,
+            }));
+        };
+        try {
+            if (this.strategy === 'system') {
+                return await trySystem();
+            }
+            if (this.strategy === 'doh') {
+                return await tryRust('doh');
             }
-            if (dnsEntry.name.endsWith('.')) {
-                dnsEntry.name = dnsEntry.name.substring(0, dnsEntry.name.length - 1);
+            if (this.strategy === 'udp') {
+                return await tryRust('udp');
+            }
+            if (this.strategy === 'prefer-udp') {
+                try {
+                    const udpRes = await tryRust('udp');
+                    if (udpRes.length > 0)
+                        return udpRes;
+                    return await tryRust('doh');
+                }
+                catch (err) {
+                    return await tryRust('doh');
+                }
+            }
+            // prefer-system (default)
+            try {
+                const sysRes = await trySystem();
+                if (sysRes.length > 0)
+                    return sysRes;
+                return this.allowDohFallback ? await tryRust('doh') : [];
+            }
+            catch (err) {
+                return this.allowDohFallback ? await tryRust('doh') : [];
             }
-            returnArray.push({
-                name: dnsEntry.name,
-                type: this.convertDnsTypeNumberToTypeName(dnsEntry.type),
-                dnsSecEnabled: responseBody.AD,
-                value: dnsEntry.data,
-            });
         }
-        // console.log(responseBody);
-        return returnArray;
+        catch (finalErr) {
+            return [];
+        }
     }
     /**
      * gets a record using nodejs dns resolver
@@ -182,5 +245,24 @@ export class Smartdns {
         }
         return null;
     }
+    /**
+     * Convert a DNS type string from Rust (e.g. "A", "AAAA") to the canonical TDnsRecordType.
+     */
+    convertDnsTypeNameToCanonical(typeName) {
+        const upper = typeName.toUpperCase();
+        if (upper in this.dnsTypeMap) {
+            return upper;
+        }
+        return null;
+    }
+    /**
+     * Destroy the Rust client bridge and free resources.
+     */
+    destroy() {
+        if (this.rustBridge) {
+            this.rustBridge.kill();
+            this.rustBridge = null;
+        }
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dnsclient.js","sourceRoot":"","sources":["../ts_client/classes.dnsclient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAIvE,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,WAAyB,EAAE,EAAE;IACzE,QAAQ,WAAW,EAAE,CAAC;QACpB,KAAK,YAAY;YACf,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;gBACrB,SAAS;gBACT,SAAS;gBACT,wBAAwB;gBACxB,wBAAwB;aACzB,CAAC,CAAC;YACH,MAAM;QACR,KAAK,QAAQ;YACX,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC;gBACrB,SAAS;gBACT,SAAS;gBACT,wBAAwB;gBACxB,wBAAwB;aACzB,CAAC,CAAC;IACP,CAAC;AACH,CAAC,CAAC;AAUF;;;GAGG;AACH,MAAM,OAAO,QAAQ;IAkBnB,YAAY,UAAuC;QAjB3C,aAAQ,GAAwB,eAAe,CAAC;QAChD,qBAAgB,GAAG,IAAI,CAAC;QAExB,eAAU,GAA+B,IAAI,CAAC;QAE/C,eAAU,GAA8B;YAC7C,CAAC,EAAE,CAAC;YACJ,EAAE,EAAE,CAAC;YACL,KAAK,EAAE,CAAC;YACR,GAAG,EAAE,CAAC;YACN,GAAG,EAAE,EAAE;YACP,EAAE,EAAE,EAAE;YACN,GAAG,EAAE,EAAE;YACP,IAAI,EAAE,EAAE;YACR,GAAG,EAAE,EAAE;SACR,CAAC;QAGA,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,QAAQ,IAAI,eAAe,CAAC;QACxD,IAAI,CAAC,gBAAgB;YACnB,UAAU,EAAE,gBAAgB,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,gBAAgB,CAAC;QAClF,IAAI,CAAC,SAAS,GAAG,UAAU,EAAE,SAAS,CAAC;IACzC,CAAC;IAEO,aAAa;QACnB,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,IAAI,CAAC,UAAU,GAAG,IAAI,mBAAmB,EAAE,CAAC;QAC9C,CAAC;QACD,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,mBAAmB,CAC9B,aAAqB,EACrB,aAAqD,EACrD,aAAqB,EACrB,YAAoB,EAAE,EACtB,cAAsB,GAAG;QAEzB,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,MAAM,OAAO,GAAG,KAAK,IAAI,EAAE;YACzB,IAAI,SAAS,GAAG,SAAS,EAAE,CAAC;gBAC1B,SAAS,EAAE,CAAC;gBACZ,IAAI,CAAC;oBACH,IAAI,aAAmD,CAAC;oBACxD,IAAI,SAAS,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;wBACxC,aAAa,GAAG,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;oBACzE,CAAC;yBAAM,CAAC;wBACN,aAAa,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;oBAChF,CAAC;oBACD,MAAM,QAAQ,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;oBACxC,IAAI,QAAQ,KAAK,aAAa,EAAE,CAAC;wBAC/B,OAAO,CAAC,GAAG,CACT,4DAA4D,aAAa,4BAA4B,aAAa,qBAAqB,aAAa,KAAK,CAC1J,CAAC;wBACF,OAAO,IAAI,CAAC;oBACd,CAAC;yBAAM,CAAC;wBACN,MAAM,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;wBAC/C,OAAO,MAAM,OAAO,EAAE,CAAC;oBACzB,CAAC;gBACH,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,MAAM,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;oBAC/C,OAAO,MAAM,OAAO,EAAE,CAAC;gBACzB,CAAC;YACH,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,GAAG,CACT,2DAA2D,aAAa,eAAe,aAAa,MAAM,aAAa,KAAK,CAC7H,CAAC;gBACF,OAAO,KAAK,CAAC;YACf,CAAC;QACH,CAAC,CAAC;QACF,OAAO,MAAM,OAAO,EAAE,CAAC;IACzB,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,WAAW,CAAC,aAAqB;QAC5C,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,GAAG,CAAC,CAAC;IACnD,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,cAAc,CAAC,aAAqB;QAC/C,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IACtD,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,aAAa,CAAC,aAAqB;QAC9C,OAAO,MAAM,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IACrD,CAAC;IAEM,KAAK,CAAC,UAAU,CACrB,aAAqB,EACrB,aAAqD,EACrD,iBAAiB,GAAG,EAAE;QAEtB,MAAM,SAAS,GAAG,KAAK,IAAmD,EAAE;YAC1E,yEAAyE;YACzE,IAAI,aAAa,KAAK,GAAG,IAAI,aAAa,KAAK,MAAM,EAAE,CAAC;gBACtD,MAAM,MAAM,GAAG,aAAa,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC7C,MAAM,SAAS,GAAG,MAAM,IAAI,OAAO,CAAwB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;oBAC7E,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS;wBAC1B,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC;wBAC9E,CAAC,CAAC,IAAI,CAAC;oBACT,OAAO,CAAC,GAAG,CAAC,MAAM,CAChB,aAAa,EACb,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,EACrB,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;wBACd,IAAI,KAAK;4BAAE,YAAY,CAAC,KAAY,CAAC,CAAC;wBACtC,IAAI,GAAG;4BAAE,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;wBAC5B,OAAO,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;oBACxB,CAAC,CACF,CAAC;gBACJ,CAAC,CAAC,CAAC;gBACH,OAAO,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;oBAC3B,IAAI,EAAE,aAAa;oBACnB,IAAI,EAAE,aAAa;oBACnB,aAAa,EAAE,KAAK;oBACpB,KAAK,EAAE,CAAC,CAAC,OAAO;iBACjB,CAAC,CAAC,CAAC;YACN,CAAC;YACD,IAAI,aAAa,KAAK,KAAK,EAAE,CAAC;gBAC5B,MAAM,OAAO,GAAG,MAAM,IAAI,OAAO,CAAa,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;oBAChE,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS;wBAC1B,CAAC,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC;wBAClF,CAAC,CAAC,IAAI,CAAC;oBACT,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,aAAa,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE;wBACjD,IAAI,KAAK;4BAAE,YAAY,CAAC,KAAY,CAAC,CAAC;wBACtC,IAAI,GAAG;4BAAE,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC;wBAC5B,OAAO,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC;oBACrB,CAAC,CAAC,CAAC;gBACL,CAAC,CAAC,CAAC;gBACH,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;oBAC9B,IAAI,EAAE,aAAa;oBACnB,IAAI,EAAE,KAA+C;oBACrD,aAAa,EAAE,KAAK;oBACpB,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;iBACvB,CAAC,CAAC,CAAC;YACN,CAAC;YACD,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC;QAEF,MAAM,OAAO,GAAG,KAAK,EAAE,QAAuB,EAAiD,EAAE;YAC/F,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YACpC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CACjC,aAAa,EACb,aAAa,EACb,QAAQ,EACR,SAAS,EACT,SAAS,EACT,IAAI,CAAC,SAAS,CACf,CAAC;YACF,OAAO,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;gBACrC,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,IAAI,CAAC,6BAA6B,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,aAAa;gBACtE,aAAa,EAAE,MAAM,CAAC,MAAM;gBAC5B,KAAK,EAAE,MAAM,CAAC,KAAK;aACpB,CAAC,CAAC,CAAC;QACN,CAAC,CAAC;QAEF,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC/B,OAAO,MAAM,SAAS,EAAE,CAAC;YAC3B,CAAC;YACD,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;gBAC5B,OAAO,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;YAC9B,CAAC;YACD,IAAI,IAAI,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;gBAC5B,OAAO,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;YAC9B,CAAC;YACD,IAAI,IAAI,CAAC,QAAQ,KAAK,YAAY,EAAE,CAAC;gBACnC,IAAI,CAAC;oBACH,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;oBACpC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;wBAAE,OAAO,MAAM,CAAC;oBACrC,OAAO,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;gBAC9B,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,OAAO,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC;gBAC9B,CAAC;YACH,CAAC;YACD,0BAA0B;YAC1B,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,SAAS,EAAE,CAAC;gBACjC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;oBAAE,OAAO,MAAM,CAAC;gBACrC,OAAO,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3D,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,IAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,MAAM,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3D,CAAC;QACH,CAAC;QAAC,OAAO,QAAQ,EAAE,CAAC;YAClB,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,oBAAoB,CAC/B,aAAqB,EACrB,aAAqD;QAErD,MAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,EAAwC,CAAC;QAChF,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,aAAa,EAAE,aAAa,EAAE,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE;YACpE,IAAI,GAAG,EAAE,CAAC;gBACR,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBACjB,OAAO;YACT,CAAC;YACD,MAAM,WAAW,GAAyC,EAAE,CAAC;YAC7D,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;gBACnC,WAAW,CAAC,IAAI,CAAC;oBACf,IAAI,EAAE,aAAa;oBACnB,KAAK,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;oBAC/B,IAAI,EAAE,aAAa;oBACnB,aAAa,EAAE,KAAK;iBACrB,CAAC,CAAC;YACL,CAAC;YACD,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAEM,KAAK,CAAC,cAAc,CAAC,aAAqB;QAC/C,MAAM,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,EAAY,CAAC;QACpD,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE;YACnD,IAAI,CAAC,GAAG,EAAE,CAAC;gBACT,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YACvB,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBACjB,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACnB,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC;IAC5B,CAAC;IAEM,8BAA8B,CAAC,cAAsB;QAC1D,OAAO,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IACzC,CAAC;IAEM,8BAA8B,CACnC,gBAAwB;QAExB,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAClC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,gBAAgB,EAAE,CAAC;gBAC9C,OAAO,GAA6C,CAAC;YACvD,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACK,6BAA6B,CAAC,QAAgB;QACpD,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QACrC,IAAI,KAAK,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YAC7B,OAAO,KAA+C,CAAC;QACzD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;YACpB,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;YACvB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACzB,CAAC;IACH,CAAC;CACF"}

package/dist_ts_client/classes.rustdnsclientbridge.d.ts

@@ -0,0 +1,59 @@
+export type TClientDnsCommands = {
+    resolve: {
+        params: IResolveParams;
+        result: IResolveResult;
+    };
+    ping: {
+        params: Record<string, never>;
+        result: {
+            pong: boolean;
+        };
+    };
+};
+export interface IResolveParams {
+    name: string;
+    recordType: string;
+    protocol: 'udp' | 'doh';
+    serverAddr?: string;
+    dohUrl?: string;
+    timeoutMs?: number;
+}
+export interface IClientDnsAnswer {
+    name: string;
+    type: string;
+    ttl: number;
+    value: string;
+}
+export interface IResolveResult {
+    answers: IClientDnsAnswer[];
+    adFlag: boolean;
+    rcode: number;
+}
+/**
+ * Bridge to the Rust DNS client binary via smartrust IPC.
+ */
+export declare class RustDnsClientBridge {
+    private bridge;
+    private spawnPromise;
+    constructor();
+    /**
+     * Lazily spawn the Rust binary. Only spawns once, caches the promise.
+     */
+    ensureSpawned(): Promise<void>;
+    /**
+     * Resolve a DNS query through the Rust binary.
+     */
+    resolve(name: string, recordType: string, protocol: 'udp' | 'doh', serverAddr?: string, dohUrl?: string, timeoutMs?: number): Promise<IResolveResult>;
+    /**
+     * Ping the Rust binary for health check.
+     */
+    ping(): Promise<boolean>;
+    /**
+     * Kill the Rust process.
+     */
+    kill(): void;
+    /**
+     * Whether the bridge is running.
+     */
+    get running(): boolean;
+}

package/dist_ts_client/classes.rustdnsclientbridge.js

@@ -0,0 +1,110 @@
+import * as plugins from './plugins.js';
+/**
+ * Bridge to the Rust DNS client binary via smartrust IPC.
+ */
+export class RustDnsClientBridge {
+    constructor() {
+        this.spawnPromise = null;
+        const packageDir = plugins.path.resolve(plugins.path.dirname(new URL(import.meta.url).pathname), '..');
+        // Determine platform suffix for dist_rust binaries (matches tsrust naming)
+        const platformSuffix = getPlatformSuffix();
+        const localPaths = [];
+        // dist_rust/ candidates (tsrust cross-compiled output, platform-specific)
+        if (platformSuffix) {
+            localPaths.push(plugins.path.join(packageDir, 'dist_rust', `rustdns-client_${platformSuffix}`));
+        }
+        // dist_rust/ without suffix (native build)
+        localPaths.push(plugins.path.join(packageDir, 'dist_rust', 'rustdns-client'));
+        // Local dev build paths
+        localPaths.push(plugins.path.join(packageDir, 'rust', 'target', 'release', 'rustdns-client'));
+        localPaths.push(plugins.path.join(packageDir, 'rust', 'target', 'debug', 'rustdns-client'));
+        this.bridge = new plugins.smartrust.RustBridge({
+            binaryName: 'rustdns-client',
+            cliArgs: ['--management'],
+            requestTimeoutMs: 30_000,
+            readyTimeoutMs: 10_000,
+            localPaths,
+            searchSystemPath: false,
+        });
+        this.bridge.on('stderr', (line) => {
+            if (line.trim()) {
+                console.log(`[rustdns-client] ${line}`);
+            }
+        });
+    }
+    /**
+     * Lazily spawn the Rust binary. Only spawns once, caches the promise.
+     */
+    async ensureSpawned() {
+        if (!this.spawnPromise) {
+            this.spawnPromise = this.bridge.spawn();
+        }
+        const ok = await this.spawnPromise;
+        if (!ok) {
+            this.spawnPromise = null;
+            throw new Error('Failed to spawn rustdns-client binary');
+        }
+    }
+    /**
+     * Resolve a DNS query through the Rust binary.
+     */
+    async resolve(name, recordType, protocol, serverAddr, dohUrl, timeoutMs) {
+        await this.ensureSpawned();
+        const params = {
+            name,
+            recordType,
+            protocol,
+        };
+        if (serverAddr)
+            params.serverAddr = serverAddr;
+        if (dohUrl)
+            params.dohUrl = dohUrl;
+        if (timeoutMs)
+            params.timeoutMs = timeoutMs;
+        return this.bridge.sendCommand('resolve', params);
+    }
+    /**
+     * Ping the Rust binary for health check.
+     */
+    async ping() {
+        await this.ensureSpawned();
+        const result = await this.bridge.sendCommand('ping', {});
+        return result.pong;
+    }
+    /**
+     * Kill the Rust process.
+     */
+    kill() {
+        this.bridge.kill();
+        this.spawnPromise = null;
+    }
+    /**
+     * Whether the bridge is running.
+     */
+    get running() {
+        return this.bridge.running;
+    }
+}
+/**
+ * Get the tsrust platform suffix for the current platform.
+ */
+function getPlatformSuffix() {
+    const platform = process.platform;
+    const arch = process.arch;
+    const platformMap = {
+        'linux': 'linux',
+        'darwin': 'macos',
+        'win32': 'windows',
+    };
+    const archMap = {
+        'x64': 'amd64',
+        'arm64': 'arm64',
+    };
+    const p = platformMap[platform];
+    const a = archMap[arch];
+    if (p && a) {
+        return `${p}_${a}`;
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts_client/index.d.ts

@@ -1 +1,2 @@
 export * from './classes.dnsclient.js';
+export * from './classes.rustdnsclientbridge.js';

package/dist_ts_client/index.js

@@ -1,2 +1,3 @@
 export * from './classes.dnsclient.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19jbGllbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQyJ9
+export * from './classes.rustdnsclientbridge.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90c19jbGllbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGtDQUFrQyxDQUFDIn0=

package/dist_ts_client/plugins.d.ts

@@ -2,9 +2,16 @@ import * as smartenv from '@push.rocks/smartenv';
 import type dnsType from 'dns';
 declare const dns: typeof dnsType;
 export { dns };
+import * as path from 'path';
+import { EventEmitter } from 'events';
+export { path };
+export declare const events: {
+    EventEmitter: typeof EventEmitter;
+};
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrequest from '@push.rocks/smartrequest';
-export { smartdelay, smartenv, smartpromise, smartrequest };
+import * as smartrust from '@push.rocks/smartrust';
+export { smartdelay, smartenv, smartpromise, smartrequest, smartrust };
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };

package/dist_ts_client/plugins.js

@@ -2,11 +2,17 @@ import * as smartenv from '@push.rocks/smartenv';
 const smartenvInstance = new smartenv.Smartenv();
 const dns = await smartenvInstance.getSafeNodeModule('dns');
 export { dns };
+// node native scope
+import * as path from 'path';
+import { EventEmitter } from 'events';
+export { path };
+export const events = { EventEmitter };
 // pushrocks scope
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrequest from '@push.rocks/smartrequest';
-export { smartdelay, smartenv, smartpromise, smartrequest };
+import * as smartrust from '@push.rocks/smartrust';
+export { smartdelay, smartenv, smartpromise, smartrequest, smartrust };
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2NsaWVudC9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztBQUdqRCxNQUFNLEdBQUcsR0FBbUIsTUFBTSxnQkFBZ0IsQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUU1RSxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUM7QUFFZixrQkFBa0I7QUFDbEIsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFFekQsT0FBTyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxDQUFDO0FBRTVELE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxFQUFFLE9BQU8sRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzX2NsaWVudC9wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztBQUdqRCxNQUFNLEdBQUcsR0FBbUIsTUFBTSxnQkFBZ0IsQ0FBQyxpQkFBaUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztBQUU1RSxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUM7QUFFZixvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUV0QyxPQUFPLEVBQUUsSUFBSSxFQUFFLENBQUM7QUFDaEIsTUFBTSxDQUFDLE1BQU0sTUFBTSxHQUFHLEVBQUUsWUFBWSxFQUFFLENBQUM7QUFFdkMsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFFbkQsT0FBTyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsWUFBWSxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUUsQ0FBQztBQUV2RSxPQUFPLEtBQUssT0FBTyxNQUFNLGtCQUFrQixDQUFDO0FBRTVDLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQyJ9