tangerine 2.0.2 → 2.1.1

package/README.md

@@ -398,6 +398,7 @@ Similar to the `options` argument from `new dns.promises.Resolver(options)` invo
 | `returnHTTPErrors`        | `Boolean`                                                                     | `false`                                                                                                                                     | Whether to return HTTP errors instead of mapping them to corresponding DNS errors.                                                                                                                                                                                                                                                                                                                                                                                      |
 | `smartRotate`             | `Boolean`                                                                     | `true`                                                                                                                                      | Whether to do smart server rotation if servers fail.                                                                                                                                                                                                                                                                                                                                                                                                                    |
 | `defaultHTTPErrorMessage` | `String`                                                                      | `"Unsuccessful HTTP response"`                                                                                                              | Default fallback message if `statusCode` returned from HTTP request was not found in [http.STATUS_CODES](https://nodejs.org/api/http.html#httpstatus_codes).                                                                                                                                                                                                                                                                                                            |
+| `parallelResolution`      | `Boolean`                                                                     | `false`                                                                                                                                     | Enable parallel resolution for querying DNS servers.                                                                                                                                                                                                                                                                                                                                                                                                                    |
 
 
 ## Cache
@@ -533,15 +534,27 @@ We have written extensive benchmarks to show that :tangerine: Tangerine is as fa
 
 #### Latest Automated Benchmark Results
 
-**Last Updated:** 2025-12-21
+**Last Updated:** 2026-03-05
 
 | Node Version | Platform | Arch | Timestamp    |
 | ------------ | -------- | ---- | ------------ |
 | v18.20.8     | linux    | x64  | Dec 21, 2025 |
-| v20.19.6     | linux    | x64  | Dec 21, 2025 |
+| v20.19.6     | linux    | x64  | Jan 22, 2026 |
+| v20.20.0     | linux    | x64  | Feb 25, 2026 |
 | v22.21.1     | linux    | x64  | Dec 21, 2025 |
+| v22.22.0     | linux    | x64  | Jan 23, 2026 |
 | v24.12.0     | linux    | x64  | Dec 21, 2025 |
+| v24.13.0     | linux    | x64  | Feb 19, 2026 |
+| v24.13.1     | linux    | x64  | Mar 4, 2026  |
+| v24.14.0     | linux    | x64  | Mar 5, 2026  |
 | v25.2.1      | linux    | x64  | Dec 21, 2025 |
+| v25.3.0      | linux    | x64  | Jan 14, 2026 |
+| v25.4.0      | linux    | x64  | Jan 20, 2026 |
+| v25.5.0      | linux    | x64  | Jan 27, 2026 |
+| v25.6.0      | linux    | x64  | Feb 4, 2026  |
+| v25.6.1      | linux    | x64  | Feb 11, 2026 |
+| v25.7.0      | linux    | x64  | Feb 25, 2026 |
+| v25.8.0      | linux    | x64  | Mar 4, 2026  |
 
 <details>
 <summary>Click to expand detailed benchmark results</summary>
@@ -597,12 +610,12 @@ Fastest without caching is: dns.promises.reverse without caching
 
 ```text
 Started: lookup
-tangerine.lookup POST with caching using Cloudflare x 795 ops/sec ±195.51% (87 runs sampled)
-tangerine.lookup POST without caching using Cloudflare x 306 ops/sec ±1.81% (83 runs sampled)
-tangerine.lookup GET with caching using Cloudflare x 298,127 ops/sec ±0.28% (90 runs sampled)
-tangerine.lookup GET without caching using Cloudflare x 307 ops/sec ±1.94% (83 runs sampled)
-dns.promises.lookup with caching using Cloudflare x 9,509,305 ops/sec ±0.47% (88 runs sampled)
-dns.promises.lookup without caching using Cloudflare x 3,250 ops/sec ±0.73% (85 runs sampled)
+tangerine.lookup POST with caching using Cloudflare x 820 ops/sec ±195.45% (88 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 212 ops/sec ±2.98% (79 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 290,812 ops/sec ±0.74% (88 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 260 ops/sec ±2.00% (82 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 8,961,323 ops/sec ±0.78% (86 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 3,143 ops/sec ±0.57% (85 runs sampled)
 Fastest without caching is: dns.promises.lookup without caching using Cloudflare
 ```
 
@@ -610,29 +623,67 @@ Fastest without caching is: dns.promises.lookup without caching using Cloudflare
 
 ```text
 Started: resolve
-tangerine.resolve POST with caching using Cloudflare x 1,016 ops/sec ±195.82% (89 runs sampled)
-tangerine.resolve POST without caching using Cloudflare x 303 ops/sec ±3.25% (79 runs sampled)
-tangerine.resolve GET with caching using Cloudflare x 1,071,513 ops/sec ±0.32% (89 runs sampled)
-tangerine.resolve GET without caching using Cloudflare x 339 ops/sec ±1.13% (84 runs sampled)
-tangerine.resolve POST with caching using Google x 1,031,970 ops/sec ±0.28% (90 runs sampled)
-tangerine.resolve POST without caching using Google x 356 ops/sec ±13.06% (79 runs sampled)
-tangerine.resolve GET with caching using Google x 1,032,838 ops/sec ±0.28% (90 runs sampled)
-tangerine.resolve GET without caching using Google x 364 ops/sec ±5.78% (77 runs sampled)
-resolver.resolve with caching using Cloudflare x 7,820,907 ops/sec ±0.65% (86 runs sampled)
-resolver.resolve without caching using Cloudflare x 16.20 ops/sec ±189.31% (79 runs sampled)
-Fastest without caching is: tangerine.resolve GET without caching using Google
+tangerine.resolve POST with caching using Cloudflare x 1,034 ops/sec ±195.81% (89 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 221 ops/sec ±1.83% (80 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,044,036 ops/sec ±0.36% (89 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 272 ops/sec ±1.57% (83 runs sampled)
+tangerine.resolve POST with caching using Google x 1,035,748 ops/sec ±0.31% (89 runs sampled)
+tangerine.resolve POST without caching using Google x 236 ops/sec ±0.93% (85 runs sampled)
+tangerine.resolve GET with caching using Google x 1,027,998 ops/sec ±0.25% (89 runs sampled)
+tangerine.resolve GET without caching using Google x 230 ops/sec ±1.04% (83 runs sampled)
+resolver.resolve with caching using Cloudflare x 7,717,855 ops/sec ±0.67% (85 runs sampled)
+resolver.resolve without caching using Cloudflare x 24.10 ops/sec ±180.34% (37 runs sampled)
+Fastest without caching is: tangerine.resolve GET without caching using Cloudflare
+```
+
+**reverse:**
+
+```text
+spawnSync /bin/sh ETIMEDOUT
+```
+
+##### Node.js v20.20.0
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 732 ops/sec ±195.51% (87 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 117 ops/sec ±1.61% (79 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 299,941 ops/sec ±1.15% (89 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 117 ops/sec ±1.43% (80 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 1,383 ops/sec ±195.97% (87 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 2,374 ops/sec ±0.56% (86 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 974 ops/sec ±195.82% (89 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 130 ops/sec ±1.30% (87 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,049,956 ops/sec ±1.53% (85 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 117 ops/sec ±1.79% (79 runs sampled)
+tangerine.resolve POST with caching using Google x 1,019,993 ops/sec ±0.48% (88 runs sampled)
+tangerine.resolve POST without caching using Google x 106 ops/sec ±4.78% (83 runs sampled)
+tangerine.resolve GET with caching using Google x 1,030,533 ops/sec ±0.28% (89 runs sampled)
+tangerine.resolve GET without caching using Google x 123 ops/sec ±0.59% (83 runs sampled)
+resolver.resolve with caching using Cloudflare x 7,658,904 ops/sec ±0.60% (86 runs sampled)
+resolver.resolve without caching using Cloudflare x 13.28 ops/sec ±201.81% (11 runs sampled)
+Fastest without caching is: tangerine.resolve POST without caching using Cloudflare
 ```
 
 **reverse:**
 
 ```text
 Started: reverse
-tangerine.reverse GET with caching x 1,002 ops/sec ±195.36% (87 runs sampled)
-tangerine.reverse GET without caching x 323 ops/sec ±1.36% (85 runs sampled)
-resolver.reverse with caching x 78.33 ops/sec ±196.00% (88 runs sampled)
-resolver.reverse without caching x 0.10 ops/sec ±23.12% (5 runs sampled)
-dns.promises.reverse with caching x 7,759,048 ops/sec ±1.08% (79 runs sampled)
-dns.promises.reverse without caching x 1.25 ops/sec ±163.63% (80 runs sampled)
+tangerine.reverse GET with caching x 991 ops/sec ±195.36% (87 runs sampled)
+tangerine.reverse GET without caching x 129 ops/sec ±0.76% (86 runs sampled)
+resolver.reverse with caching x 0.10 ops/sec ±0.01% (5 runs sampled)
+resolver.reverse without caching x 2.80 ops/sec ±112.00% (74 runs sampled)
+dns.promises.reverse with caching x 7,904,185 ops/sec ±0.60% (85 runs sampled)
+dns.promises.reverse without caching x 8.68 ops/sec ±202.85% (14 runs sampled)
 Fastest without caching is: tangerine.reverse GET without caching
 ```
 
@@ -674,6 +725,51 @@ Fastest without caching is: tangerine.resolve GET without caching using Google
 spawnSync /bin/sh ETIMEDOUT
 ```
 
+##### Node.js v22.22.0
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 1,163 ops/sec ±195.31% (90 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 54.38 ops/sec ±5.55% (88 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 313,634 ops/sec ±0.27% (89 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 55.58 ops/sec ±6.39% (71 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 9,649,217 ops/sec ±0.65% (88 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 3,178 ops/sec ±0.70% (85 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,186 ops/sec ±195.79% (89 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 55.82 ops/sec ±5.02% (84 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,099,153 ops/sec ±0.22% (90 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 59.25 ops/sec ±5.73% (73 runs sampled)
+tangerine.resolve POST with caching using Google x 1,095 ops/sec ±195.81% (88 runs sampled)
+tangerine.resolve POST without caching using Google x 60.23 ops/sec ±10.05% (80 runs sampled)
+tangerine.resolve GET with caching using Google x 1,107,393 ops/sec ±0.67% (90 runs sampled)
+tangerine.resolve GET without caching using Google x 54.10 ops/sec ±10.64% (74 runs sampled)
+resolver.resolve with caching using Cloudflare x 8,395,785 ops/sec ±0.65% (89 runs sampled)
+resolver.resolve without caching using Cloudflare x 67.84 ops/sec ±0.83% (80 runs sampled)
+Fastest without caching is: resolver.resolve without caching using Cloudflare, tangerine.resolve POST without caching using Google
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 1,114 ops/sec ±195.34% (89 runs sampled)
+tangerine.reverse GET without caching x 55.88 ops/sec ±4.70% (89 runs sampled)
+resolver.reverse with caching x 8,531,724 ops/sec ±0.82% (84 runs sampled)
+resolver.reverse without caching x 68.04 ops/sec ±0.73% (81 runs sampled)
+dns.promises.reverse with caching x 8,533,071 ops/sec ±0.84% (81 runs sampled)
+dns.promises.reverse without caching x 67.08 ops/sec ±0.82% (79 runs sampled)
+Fastest without caching is: resolver.reverse without caching
+```
+
 ##### Node.js v24.12.0
 
 **lookup:**
@@ -712,6 +808,141 @@ Fastest without caching is: tangerine.resolve GET without caching using Google
 spawnSync /bin/sh ETIMEDOUT
 ```
 
+##### Node.js v24.13.0
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 330,489 ops/sec ±1.61% (85 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 248 ops/sec ±1.98% (80 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 321,967 ops/sec ±0.26% (90 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 224 ops/sec ±1.85% (76 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 734 ops/sec ±195.99% (87 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 2,207 ops/sec ±0.51% (85 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,158,368 ops/sec ±0.28% (90 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 246 ops/sec ±1.93% (80 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,114,486 ops/sec ±0.29% (88 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 252 ops/sec ±1.20% (85 runs sampled)
+tangerine.resolve POST with caching using Google x 1,134,382 ops/sec ±0.24% (88 runs sampled)
+tangerine.resolve POST without caching using Google x 168 ops/sec ±36.15% (70 runs sampled)
+tangerine.resolve GET with caching using Google x 1,139,056 ops/sec ±0.61% (90 runs sampled)
+tangerine.resolve GET without caching using Google x 297 ops/sec ±2.73% (75 runs sampled)
+resolver.resolve with caching using Cloudflare x 8,289,380 ops/sec ±7.32% (88 runs sampled)
+resolver.resolve without caching using Cloudflare x 316 ops/sec ±1.92% (79 runs sampled)
+Fastest without caching is: resolver.resolve without caching using Cloudflare
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 339,770 ops/sec ±0.42% (90 runs sampled)
+tangerine.reverse GET without caching x 240 ops/sec ±2.18% (77 runs sampled)
+resolver.reverse with caching x 8,523,002 ops/sec ±0.83% (87 runs sampled)
+resolver.reverse without caching x 15.57 ops/sec ±194.42% (31 runs sampled)
+dns.promises.reverse with caching x 8,765,472 ops/sec ±1.03% (82 runs sampled)
+dns.promises.reverse without caching x 5.51 ops/sec ±179.54% (80 runs sampled)
+Fastest without caching is: tangerine.reverse GET without caching
+```
+
+##### Node.js v24.13.1
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 333,315 ops/sec ±1.61% (85 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 227 ops/sec ±1.93% (82 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 320,901 ops/sec ±0.68% (90 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 262 ops/sec ±2.60% (81 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 10,104,926 ops/sec ±1.20% (84 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 2,172 ops/sec ±0.39% (86 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,155,993 ops/sec ±0.68% (89 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 238 ops/sec ±1.44% (82 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,130,246 ops/sec ±0.43% (89 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 271 ops/sec ±1.13% (85 runs sampled)
+tangerine.resolve POST with caching using Google x 534 ops/sec ±195.91% (89 runs sampled)
+tangerine.resolve POST without caching using Google x 180 ops/sec ±23.75% (71 runs sampled)
+tangerine.resolve GET with caching using Google x 1,127,220 ops/sec ±0.26% (91 runs sampled)
+tangerine.resolve GET without caching using Google x 194 ops/sec ±16.84% (63 runs sampled)
+resolver.resolve with caching using Cloudflare x 8,475,317 ops/sec ±0.93% (83 runs sampled)
+resolver.resolve without caching using Cloudflare x 345 ops/sec ±1.00% (78 runs sampled)
+Fastest without caching is: resolver.resolve without caching using Cloudflare
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 331,840 ops/sec ±0.57% (89 runs sampled)
+tangerine.reverse GET without caching x 241 ops/sec ±1.30% (80 runs sampled)
+resolver.reverse with caching x 8,769,670 ops/sec ±0.60% (87 runs sampled)
+resolver.reverse without caching x 24.95 ops/sec ±193.07% (22 runs sampled)
+dns.promises.reverse with caching x 8,895,968 ops/sec ±0.71% (88 runs sampled)
+dns.promises.reverse without caching x 0.05 ops/sec ±112.55% (5 runs sampled)
+Fastest without caching is: tangerine.reverse GET without caching
+```
+
+##### Node.js v24.14.0
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 1,403 ops/sec ±195.16% (90 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 70.67 ops/sec ±3.34% (84 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 317,797 ops/sec ±0.25% (91 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 63.36 ops/sec ±6.51% (78 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 9,932,885 ops/sec ±1.21% (87 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 2,310 ops/sec ±0.39% (89 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,269 ops/sec ±195.78% (89 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 85.54 ops/sec ±0.68% (81 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,117,794 ops/sec ±0.40% (90 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 69.12 ops/sec ±5.91% (84 runs sampled)
+tangerine.resolve POST with caching using Google x 1,675 ops/sec ±195.71% (90 runs sampled)
+tangerine.resolve POST without caching using Google x 57.66 ops/sec ±13.41% (79 runs sampled)
+tangerine.resolve GET with caching using Google x 1,117,350 ops/sec ±0.62% (90 runs sampled)
+tangerine.resolve GET without caching using Google x 56.23 ops/sec ±5.75% (72 runs sampled)
+resolver.resolve with caching using Cloudflare x 8,740,674 ops/sec ±0.82% (83 runs sampled)
+resolver.resolve without caching using Cloudflare x 71.31 ops/sec ±1.31% (72 runs sampled)
+Fastest without caching is: tangerine.resolve POST without caching using Cloudflare
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 1,286 ops/sec ±195.26% (90 runs sampled)
+tangerine.reverse GET without caching x 85.95 ops/sec ±0.80% (81 runs sampled)
+resolver.reverse with caching x 8,753,410 ops/sec ±0.98% (85 runs sampled)
+resolver.reverse without caching x 72.25 ops/sec ±1.42% (74 runs sampled)
+dns.promises.reverse with caching x 8,707,156 ops/sec ±0.92% (84 runs sampled)
+dns.promises.reverse without caching x 71.90 ops/sec ±1.46% (70 runs sampled)
+Fastest without caching is: tangerine.reverse GET without caching
+```
+
 ##### Node.js v25.2.1
 
 **lookup:**
@@ -757,6 +988,321 @@ dns.promises.reverse without caching x 5.11 ops/sec ±189.52% (76 runs sampled)
 Fastest without caching is: resolver.reverse without caching, dns.promises.reverse without caching
 ```
 
+##### Node.js v25.3.0
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 1,178 ops/sec ±195.33% (88 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 86.96 ops/sec ±1.37% (82 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 340,510 ops/sec ±0.25% (90 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 89.52 ops/sec ±1.42% (84 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 1,352 ops/sec ±195.97% (88 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 3,261 ops/sec ±0.86% (83 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,099 ops/sec ±195.82% (89 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 88.57 ops/sec ±0.78% (83 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,182,619 ops/sec ±0.51% (91 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 89.35 ops/sec ±9.03% (88 runs sampled)
+tangerine.resolve POST with caching using Google x 1,174,915 ops/sec ±2.35% (89 runs sampled)
+tangerine.resolve POST without caching using Google x 129 ops/sec ±9.63% (75 runs sampled)
+tangerine.resolve GET with caching using Google x 1,187,141 ops/sec ±0.30% (89 runs sampled)
+tangerine.resolve GET without caching using Google x 195 ops/sec ±0.85% (84 runs sampled)
+resolver.resolve with caching using Cloudflare x 8,288,775 ops/sec ±10.11% (89 runs sampled)
+resolver.resolve without caching using Cloudflare x 105 ops/sec ±0.63% (82 runs sampled)
+Fastest without caching is: tangerine.resolve GET without caching using Google
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 1,146 ops/sec ±195.30% (90 runs sampled)
+tangerine.reverse GET without caching x 88.05 ops/sec ±0.92% (83 runs sampled)
+resolver.reverse with caching x 8,812,418 ops/sec ±0.46% (85 runs sampled)
+resolver.reverse without caching x 3.08 ops/sec ±203.97% (19 runs sampled)
+dns.promises.reverse with caching x 8,647,756 ops/sec ±2.62% (87 runs sampled)
+dns.promises.reverse without caching x 0.09 ops/sec ±139.17% (6 runs sampled)
+Fastest without caching is: tangerine.reverse GET without caching
+```
+
+##### Node.js v25.4.0
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 338,506 ops/sec ±2.96% (86 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 252 ops/sec ±1.53% (83 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 328,384 ops/sec ±0.24% (89 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 256 ops/sec ±2.15% (80 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 10,091,995 ops/sec ±0.78% (85 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 3,114 ops/sec ±0.68% (84 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,178,120 ops/sec ±0.63% (89 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 268 ops/sec ±1.42% (84 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,158,024 ops/sec ±0.37% (88 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 263 ops/sec ±1.56% (82 runs sampled)
+tangerine.resolve POST with caching using Google x 1,126,115 ops/sec ±2.39% (89 runs sampled)
+tangerine.resolve POST without caching using Google x 203 ops/sec ±1.10% (85 runs sampled)
+tangerine.resolve GET with caching using Google x 1,124,263 ops/sec ±3.04% (88 runs sampled)
+tangerine.resolve GET without caching using Google x 231 ops/sec ±0.71% (85 runs sampled)
+resolver.resolve with caching using Cloudflare x 8,795,845 ops/sec ±0.45% (87 runs sampled)
+resolver.resolve without caching using Cloudflare x 299 ops/sec ±1.31% (69 runs sampled)
+Fastest without caching is: resolver.resolve without caching using Cloudflare
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 346,432 ops/sec ±0.67% (87 runs sampled)
+tangerine.reverse GET without caching x 257 ops/sec ±1.24% (83 runs sampled)
+resolver.reverse with caching x 8,836,675 ops/sec ±0.85% (83 runs sampled)
+resolver.reverse without caching x 11.00 ops/sec ±189.21% (38 runs sampled)
+dns.promises.reverse with caching x 8,483,041 ops/sec ±1.55% (84 runs sampled)
+dns.promises.reverse without caching x 1.79 ops/sec ±162.11% (82 runs sampled)
+Fastest without caching is: tangerine.reverse GET without caching
+```
+
+##### Node.js v25.5.0
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 336,308 ops/sec ±3.97% (90 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 142 ops/sec ±24.14% (42 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 331,518 ops/sec ±0.25% (90 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 317 ops/sec ±5.55% (84 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 10,144,557 ops/sec ±0.80% (85 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 3,269 ops/sec ±0.69% (84 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,173,581 ops/sec ±0.26% (90 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 336 ops/sec ±1.29% (83 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,154,032 ops/sec ±0.25% (90 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 211 ops/sec ±21.96% (60 runs sampled)
+tangerine.resolve POST with caching using Google x 1,143,112 ops/sec ±2.40% (87 runs sampled)
+tangerine.resolve POST without caching using Google x 247 ops/sec ±18.82% (74 runs sampled)
+tangerine.resolve GET with caching using Google x 1,169,919 ops/sec ±0.28% (90 runs sampled)
+tangerine.resolve GET without caching using Google x 312 ops/sec ±9.26% (78 runs sampled)
+resolver.resolve with caching using Cloudflare x 8,264,910 ops/sec ±3.31% (82 runs sampled)
+resolver.resolve without caching using Cloudflare x 322 ops/sec ±40.27% (68 runs sampled)
+Fastest without caching is: tangerine.resolve POST without caching using Cloudflare, tangerine.resolve GET without caching using Google
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 337,763 ops/sec ±4.41% (90 runs sampled)
+tangerine.reverse GET without caching x 334 ops/sec ±1.57% (82 runs sampled)
+resolver.reverse with caching x 8,764,547 ops/sec ±1.05% (84 runs sampled)
+resolver.reverse without caching x 20.89 ops/sec ±188.69% (22 runs sampled)
+dns.promises.reverse with caching x 8,832,576 ops/sec ±0.52% (87 runs sampled)
+dns.promises.reverse without caching x 6.82 ops/sec ±176.67% (70 runs sampled)
+Fastest without caching is: tangerine.reverse GET without caching
+```
+
+##### Node.js v25.6.0
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 1,022 ops/sec ±195.41% (85 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 46.93 ops/sec ±6.02% (78 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 329,068 ops/sec ±1.17% (87 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 47.00 ops/sec ±5.36% (77 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 10,120,744 ops/sec ±2.31% (81 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 3,219 ops/sec ±0.75% (85 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,127 ops/sec ±195.81% (89 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 47.64 ops/sec ±5.35% (78 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,183,153 ops/sec ±0.42% (90 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 47.85 ops/sec ±5.73% (79 runs sampled)
+tangerine.resolve POST with caching using Google x 1,167 ops/sec ±195.80% (90 runs sampled)
+tangerine.resolve POST without caching using Google x 52.32 ops/sec ±14.47% (67 runs sampled)
+tangerine.resolve GET with caching using Google x 1,168,373 ops/sec ±2.94% (89 runs sampled)
+tangerine.resolve GET without caching using Google x 61.96 ops/sec ±11.75% (66 runs sampled)
+resolver.resolve with caching using Cloudflare x 8,658,908 ops/sec ±0.86% (83 runs sampled)
+resolver.resolve without caching using Cloudflare x 53.79 ops/sec ±0.56% (84 runs sampled)
+Fastest without caching is: tangerine.resolve GET without caching using Google
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 1,107 ops/sec ±195.37% (90 runs sampled)
+tangerine.reverse GET without caching x 47.62 ops/sec ±5.44% (78 runs sampled)
+resolver.reverse with caching x 8,843,572 ops/sec ±1.73% (86 runs sampled)
+resolver.reverse without caching x 53.71 ops/sec ±0.41% (84 runs sampled)
+dns.promises.reverse with caching x 8,869,703 ops/sec ±2.34% (85 runs sampled)
+dns.promises.reverse without caching x 54.03 ops/sec ±0.34% (85 runs sampled)
+Fastest without caching is: dns.promises.reverse without caching
+```
+
+##### Node.js v25.6.1
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 1,041 ops/sec ±195.41% (90 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 46.90 ops/sec ±7.12% (78 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 329,597 ops/sec ±1.03% (89 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 47.84 ops/sec ±5.63% (79 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 10,033,729 ops/sec ±1.66% (86 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 3,175 ops/sec ±0.61% (87 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,066 ops/sec ±195.81% (86 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 48.96 ops/sec ±6.55% (81 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,133,219 ops/sec ±0.30% (90 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 47.66 ops/sec ±5.34% (79 runs sampled)
+tangerine.resolve POST with caching using Google x 1,132 ops/sec ±195.81% (89 runs sampled)
+tangerine.resolve POST without caching using Google x 48.55 ops/sec ±13.69% (66 runs sampled)
+tangerine.resolve GET with caching using Google x 1,130,722 ops/sec ±2.88% (89 runs sampled)
+tangerine.resolve GET without caching using Google x 53.90 ops/sec ±10.91% (67 runs sampled)
+resolver.resolve with caching using Cloudflare x 8,443,169 ops/sec ±2.56% (86 runs sampled)
+resolver.resolve without caching using Cloudflare x 53.86 ops/sec ±0.65% (84 runs sampled)
+Fastest without caching is: resolver.resolve without caching using Cloudflare
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 1,105 ops/sec ±195.39% (89 runs sampled)
+tangerine.reverse GET without caching x 48.86 ops/sec ±6.37% (80 runs sampled)
+resolver.reverse with caching x 8,883,018 ops/sec ±0.41% (86 runs sampled)
+resolver.reverse without caching x 54.19 ops/sec ±0.53% (85 runs sampled)
+dns.promises.reverse with caching x 8,752,480 ops/sec ±2.56% (86 runs sampled)
+dns.promises.reverse without caching x 54.28 ops/sec ±0.35% (85 runs sampled)
+Fastest without caching is: dns.promises.reverse without caching, resolver.reverse without caching
+```
+
+##### Node.js v25.7.0
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 873 ops/sec ±195.51% (87 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 58.82 ops/sec ±7.44% (74 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 333,990 ops/sec ±1.19% (86 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 53.11 ops/sec ±10.66% (70 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 626 ops/sec ±195.99% (86 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 2,470 ops/sec ±0.50% (87 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,243 ops/sec ±195.79% (89 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 57.08 ops/sec ±11.16% (74 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,132,703 ops/sec ±0.28% (90 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 56.05 ops/sec ±5.64% (80 runs sampled)
+tangerine.resolve POST with caching using Google x 1,497 ops/sec ±195.73% (88 runs sampled)
+tangerine.resolve POST without caching using Google x 60.56 ops/sec ±7.75% (77 runs sampled)
+tangerine.resolve GET with caching using Google x 1,096,216 ops/sec ±2.92% (88 runs sampled)
+tangerine.resolve GET without caching using Google x 41.16 ops/sec ±24.89% (66 runs sampled)
+resolver.resolve with caching using Cloudflare x 8,732,718 ops/sec ±2.67% (86 runs sampled)
+resolver.resolve without caching using Cloudflare x 65.84 ops/sec ±1.17% (78 runs sampled)
+Fastest without caching is: resolver.resolve without caching using Cloudflare, tangerine.resolve POST without caching using Google
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 1,193 ops/sec ±195.33% (88 runs sampled)
+tangerine.reverse GET without caching x 56.89 ops/sec ±11.00% (73 runs sampled)
+resolver.reverse with caching x 8,938,970 ops/sec ±0.65% (88 runs sampled)
+resolver.reverse without caching x 66.14 ops/sec ±2.95% (78 runs sampled)
+dns.promises.reverse with caching x 8,783,854 ops/sec ±1.77% (87 runs sampled)
+dns.promises.reverse without caching x 67.14 ops/sec ±0.80% (79 runs sampled)
+Fastest without caching is: dns.promises.reverse without caching, resolver.reverse without caching
+```
+
+##### Node.js v25.8.0
+
+**lookup:**
+
+```text
+Started: lookup
+tangerine.lookup POST with caching using Cloudflare x 348,234 ops/sec ±1.43% (89 runs sampled)
+tangerine.lookup POST without caching using Cloudflare x 245 ops/sec ±1.75% (83 runs sampled)
+tangerine.lookup GET with caching using Cloudflare x 340,115 ops/sec ±0.72% (89 runs sampled)
+tangerine.lookup GET without caching using Cloudflare x 223 ops/sec ±2.25% (81 runs sampled)
+dns.promises.lookup with caching using Cloudflare x 1,759 ops/sec ±195.97% (88 runs sampled)
+dns.promises.lookup without caching using Cloudflare x 2,223 ops/sec ±0.55% (87 runs sampled)
+Fastest without caching is: dns.promises.lookup without caching using Cloudflare
+```
+
+**resolve:**
+
+```text
+Started: resolve
+tangerine.resolve POST with caching using Cloudflare x 1,224,642 ops/sec ±0.58% (87 runs sampled)
+tangerine.resolve POST without caching using Cloudflare x 248 ops/sec ±1.54% (83 runs sampled)
+tangerine.resolve GET with caching using Cloudflare x 1,168,649 ops/sec ±0.55% (85 runs sampled)
+tangerine.resolve GET without caching using Cloudflare x 264 ops/sec ±1.04% (82 runs sampled)
+tangerine.resolve POST with caching using Google x 1,411 ops/sec ±195.76% (87 runs sampled)
+tangerine.resolve POST without caching using Google x 178 ops/sec ±24.83% (67 runs sampled)
+tangerine.resolve GET with caching using Google x 1,188,395 ops/sec ±0.40% (88 runs sampled)
+tangerine.resolve GET without caching using Google x 237 ops/sec ±14.93% (74 runs sampled)
+resolver.resolve with caching using Cloudflare x 8.39 ops/sec ±196.00% (84 runs sampled)
+resolver.resolve without caching using Cloudflare x 109 ops/sec ±113.88% (68 runs sampled)
+Fastest without caching is: tangerine.resolve GET without caching using Cloudflare, tangerine.resolve POST without caching using Google
+```
+
+**reverse:**
+
+```text
+Started: reverse
+tangerine.reverse GET with caching x 346,448 ops/sec ±4.35% (86 runs sampled)
+tangerine.reverse GET without caching x 259 ops/sec ±1.42% (83 runs sampled)
+resolver.reverse with caching x 9,199,217 ops/sec ±0.52% (88 runs sampled)
+resolver.reverse without caching x 13.67 ops/sec ±188.06% (45 runs sampled)
+dns.promises.reverse with caching x 9,227,637 ops/sec ±0.33% (89 runs sampled)
+dns.promises.reverse without caching x 0.07 ops/sec ±133.35% (5 runs sampled)
+Fastest without caching is: tangerine.reverse GET without caching
+```
+
 </details>
 
 <!-- BENCHMARK_RESULTS_END -->

package/index.d.ts

@@ -134,6 +134,13 @@ export type TangerineOptions = {
    */
   smartRotate?: boolean;
 
+  /**
+   * Whether to resolve against all configured servers in parallel and return
+   * the first successful response.
+   * @default false
+   */
+  parallelResolution?: boolean;
+
   /**
    * Default error message for unsuccessful HTTP responses.
    * @default 'Unsuccessful HTTP response'

package/index.js

@@ -13,6 +13,7 @@ const hostile = require('hostile');
 const ipaddr = require('ipaddr.js');
 const isStream = require('is-stream');
 const mergeOptions = require('merge-options');
+const pAny = require('p-any');
 const pMap = require('p-map');
 const pWaitFor = require('p-wait-for');
 const packet = require('dns-packet');
@@ -451,6 +452,8 @@ class Tangerine extends dns.promises.Resolver {
         returnHTTPErrors: false,
         // whether to smart rotate and bump-to-end servers that have issues
         smartRotate: true,
+        // whether to resolve all servers in parallel and use first successful result
+        parallelResolution: false,
         // fallback if status code was not found in http.STATUS_CODES
         defaultHTTPErrorMessage: 'Unsuccessful HTTP response'
       },
@@ -490,6 +493,12 @@ class Tangerine extends dns.promises.Resolver {
     if (!['verbatim', 'ipv4first'].includes(this.options.dnsOrder))
       throw new Error('DNS order must be either verbatim or ipv4first');
 
+    if (this.options.parallelResolution === undefined)
+      this.options.parallelResolution = false;
+
+    if (typeof this.options.parallelResolution !== 'boolean')
+      throw new Error('parallelResolution must be a boolean');
+
     // if `cache: false` then caching is disabled
     // but note that this doesn't disable `got` dnsCache which is separate
     // so to turn that off, you need to supply `dnsCache: undefined` in `got` object (?)
@@ -1131,7 +1140,7 @@ class Tangerine extends dns.promises.Resolver {
   }
 
   // <https://github.com/hildjj/dohdec/tree/main/pkg/dohdec>
-  // eslint-disable-next-line complexity
+
   async #query(name, rrtype = 'A', ecsSubnet, abortController) {
     if (!dohdec) await pWaitFor(() => Boolean(dohdec));
     debug('query', {
@@ -1158,46 +1167,105 @@ class Tangerine extends dns.promises.Resolver {
       // <https://github.com/nodejs/node/issues/33353#issuecomment-627259827>
       let buffer;
       const errors = [];
-      // NOTE: we would have used `p-map-series` but it did not support abort/break
       const servers = [...this.options.servers];
-      for (const server of servers) {
+
+      const parseBody = async (body) => {
+        // <https://sindresorhus.com/blog/goodbye-nodejs-buffer>
+        if (Buffer.isBuffer(body)) return body;
+        if (typeof body.arrayBuffer === 'function')
+          return Buffer.from(await body.arrayBuffer());
+        if (isStream(body)) return getStream.buffer(body);
+        const err = new TypeError('Unsupported body type');
+        err.body = body;
+        throw err;
+      };
+
+      const getRequestAbortController = (parallelAbortController) => {
+        if (!parallelAbortController)
+          return {
+            requestAbortController: abortController,
+            cleanupAbortController() {}
+          };
+
+        const requestAbortController = new AbortController();
+        const parentSignal = abortController?.signal;
+        const parallelSignal = parallelAbortController.signal;
+        const onAbort = () => {
+          if (!requestAbortController.signal.aborted)
+            requestAbortController.abort(parentSignal.reason);
+        };
+
+        const onParallelAbort = () => {
+          if (!requestAbortController.signal.aborted)
+            requestAbortController.abort(parallelSignal.reason);
+        };
+
+        if (parentSignal?.aborted) onAbort();
+        else if (parentSignal)
+          parentSignal.addEventListener('abort', onAbort, { once: true });
+
+        if (parallelSignal.aborted) onParallelAbort();
+        else
+          parallelSignal.addEventListener('abort', onParallelAbort, {
+            once: true
+          });
+
+        return {
+          requestAbortController,
+          cleanupAbortController() {
+            parentSignal?.removeEventListener('abort', onAbort);
+            parallelSignal.removeEventListener('abort', onParallelAbort);
+          }
+        };
+      };
+
+      const addServerErrors = (server, ipErrors) => {
+        if (ipErrors.length === 0) return;
+
+        // if the `server` had all errors, then remove it and add to end
+        // (this ensures we don't keep retrying servers that keep timing out)
+        // (which improves upon default c-ares behavior)
+        if (this.options.servers.size > 1 && this.options.smartRotate) {
+          const err = this.constructor.combineErrors([
+            new Error('Rotating DNS servers due to issues'),
+            ...ipErrors
+          ]);
+          this.options.logger.error(err, { server });
+          this.options.servers.delete(server);
+          this.options.servers.add(server);
+        }
+
+        errors.push(...ipErrors);
+      };
+
+      const throwOnNotFound = (err) => {
+        if (err.code === dns.NOTFOUND) throw err;
+      };
+
+      const queryServer = async (server, parallelAbortController) => {
         const ipErrors = [];
+        let lastError;
+
         for (let i = 0; i < this.options.tries; i++) {
+          const { requestAbortController, cleanupAbortController } =
+            getRequestAbortController(parallelAbortController);
+
           try {
-            // <https://github.com/sindresorhus/p-map-series/blob/bc1b9f5e19ed62363bff3d7dc5ecc1fd820ccb51/index.js#L1-L11>
             // eslint-disable-next-line no-await-in-loop
             const response = await this.#request(
               pkt,
               server,
-              abortController,
+              requestAbortController,
               this.options.timeout * 2 ** i
             );
 
-            // if aborted signal then returns early
-            // eslint-disable-next-line max-depth
             if (response) {
               const { body, headers } = response;
               const statusCode = response.status || response.statusCode;
               debug('response', { statusCode, headers });
 
-              // eslint-disable-next-line max-depth
-              if (body && statusCode >= 200 && statusCode < 300) {
-                // <https://sindresorhus.com/blog/goodbye-nodejs-buffer>
-                // eslint-disable-next-line max-depth
-                if (Buffer.isBuffer(body)) buffer = body;
-                else if (typeof body.arrayBuffer === 'function')
-                  // eslint-disable-next-line no-await-in-loop
-                  buffer = Buffer.from(await body.arrayBuffer());
-                // eslint-disable-next-line no-await-in-loop
-                else if (isStream(body)) buffer = await getStream.buffer(body);
-                else {
-                  const err = new TypeError('Unsupported body type');
-                  err.body = body;
-                  throw err;
-                }
-
-                break;
-              }
+              if (body && statusCode >= 200 && statusCode < 300)
+                return parseBody(body);
 
               // <https://github.com/nodejs/undici/issues/3353>
               if (
@@ -1221,18 +1289,18 @@ class Tangerine extends dns.promises.Resolver {
             }
           } catch (err) {
             debug(err);
+            lastError = err;
 
             //
             // NOTE: if NOTFOUND error occurs then don't attempt further requests
             // <https://nodejs.org/api/dns.html#dnssetserversservers>
             //
 
-            if (err.code === dns.NOTFOUND) throw err;
+            throwOnNotFound(err);
 
             if (err.status >= 429) ipErrors.push(err);
 
             // break out of the loop if status code was not retryable
-
             if (
               !(
                 err.statusCode &&
@@ -1241,26 +1309,43 @@ class Tangerine extends dns.promises.Resolver {
               !(err.code && this.constructor.RETRY_ERROR_CODES.has(err.code))
             )
               break;
+          } finally {
+            cleanupAbortController();
           }
         }
 
-        // break out if we had a response
-        if (buffer) break;
-        if (ipErrors.length > 0) {
-          // if the `server` had all errors, then remove it and add to end
-          // (this ensures we don't keep retrying servers that keep timing out)
-          // (which improves upon default c-ares behavior)
-          if (this.options.servers.size > 1 && this.options.smartRotate) {
-            const err = this.constructor.combineErrors([
-              new Error('Rotating DNS servers due to issues'),
-              ...ipErrors
-            ]);
-            this.options.logger.error(err, { server });
-            this.options.servers.delete(server);
-            this.options.servers.add(server);
-          }
+        addServerErrors(server, ipErrors);
+
+        throw lastError || new Error(`No response from ${server}`);
+      };
 
-          errors.push(...ipErrors);
+      if (this.options.parallelResolution) {
+        const parallelAbortController = new AbortController();
+
+        try {
+          buffer = await pAny(
+            servers.map((server) =>
+              queryServer(server, parallelAbortController)
+            )
+          );
+        } catch (err) {
+          if (errors.length > 0) throw this.constructor.combineErrors(errors);
+          throw err;
+        } finally {
+          if (!parallelAbortController.signal.aborted)
+            parallelAbortController.abort('CANCELLED');
+        }
+      } else {
+        // NOTE: we would have used `p-map-series` but it did not support abort/break
+        for (const server of servers) {
+          try {
+            // eslint-disable-next-line no-await-in-loop
+            buffer = await queryServer(server);
+            break;
+          } catch (err) {
+            throwOnNotFound(err);
+            debug(err);
+          }
         }
       }
 
@@ -1943,6 +2028,20 @@ class Tangerine extends dns.promises.Resolver {
     if (result.answers.length === 0 && !options.noThrowOnNODATA)
       throw this.constructor.createError(name, rrtype, dns.NODATA);
 
+    //
+    // RFC 7672 Section 2.2.2: Expose DNSSEC validation status (AD flag)
+    // When options.dnssecSecure is true, return an object with the answers
+    // and a boolean indicating whether the response was DNSSEC-validated.
+    // This allows callers (e.g. mx-connect DANE) to check if the MX host's
+    // zone is signed before attempting TLSA lookups.
+    //
+    if (options?.dnssecSecure) {
+      return {
+        secure: Boolean(result.flag_ad),
+        answers: result.answers
+      };
+    }
+
     // filter the answers for the same type
     result.answers = result.answers.filter((answer) => answer.type === rrtype);
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tangerine",
   "description": "Tangerine is the best Node.js drop-in replacement for dns.promises.Resolver using DNS over HTTPS (\"DoH\") via undici with built-in retries, timeouts, smart server rotation, AbortControllers, and caching support for multiple backends (with TTL and purge support).",
-  "version": "2.0.2",
+  "version": "2.1.1",
   "author": "Forward Email (https://forwardemail.net)",
   "bugs": {
     "url": "https://github.com/forwardemail/nodejs-dns-over-https-tangerine/issues"
@@ -18,6 +18,7 @@
     "ipaddr.js": "^2.2.0",
     "is-stream": "2.0.1",
     "merge-options": "3.0.4",
+    "p-any": "3",
     "p-map": "4",
     "p-wait-for": "3",
     "port-numbers": "6.0.1",
@@ -32,7 +33,7 @@
     "axios": "^1.7.3",
     "benchmark": "^2.1.4",
     "cross-env": "^7.0.3",
-    "eslint": "^9.8.0",
+    "eslint": "^8.57.1",
     "eslint-config-xo-lass": "^2.0.1",
     "fetch-mock": "^10.1.1",
     "fixpack": "^4.0.0",