zynor 0.1.0 → 0.1.2

package/dist/native.d.ts

@@ -724,6 +724,15 @@ declare class NativeProvider {
 	resolveCaa(hostname: string, options?: AbortOptions): Promise<CaaRecord[]>;
 	resolveCname(hostname: string, options?: AbortOptions): Promise<string[]>;
 	resolveMx(hostname: string, options?: AbortOptions): Promise<MxRecord[]>;
+	/**
+	 * @internal Resolve MX for many hostnames at once. With the Rust binding
+	 * this is a SINGLE FFI call for the whole array (concurrency handled inside
+	 * Rust) — the lever that collapses per-email boundary crossings. Without
+	 * the binding it falls back to parallel libuv calls (same shape, no FFI
+	 * win). Per-host failures yield `[]` in that slot; never rejects wholesale.
+	 * Not queued — the caller governs concurrency at the page level.
+	 */
+	resolveMxBatch(hostnames: string[], options?: AbortOptions): Promise<MxRecord[][]>;
 	resolveNaptr(hostname: string, options?: AbortOptions): Promise<NaptrRecord[]>;
 	resolveNs(hostname: string, options?: AbortOptions): Promise<string[]>;
 	resolvePtr(hostname: string, options?: AbortOptions): Promise<string[]>;
@@ -2158,6 +2167,10 @@ declare const records: readonly [
 		readonly name: "Turbify";
 		readonly mx: "mx-biz.mail.am0.yahoodns.net";
 	},
+	{
+		readonly name: "Turbify";
+		readonly mx: "mx-van.mail.am0.yahoodns.net";
+	},
 	{
 		readonly name: "Turbify";
 		readonly mx: "mx-biz.mail.am.yahoodns.net";
@@ -2650,7 +2663,7 @@ declare class EmailValidator {
 	private yahooList;
 	private domain;
 	private static instance;
-	private dns;
+	protected dns: Zynor;
 	private validateCache;
 	private ipCache;
 	private inflight;
@@ -3302,6 +3315,9 @@ export interface RustAnyRecord {
 }
 export interface RustBinding {
 	resolveMx(hostname: string, options?: RustResolveOptions | null): Promise<RustMxRecord[]>;
+	/** Resolve MX for many hostnames in one FFI call. `out[i]` ↔ `hostnames[i]`;
+	 *  a per-host failure yields `[]` for that slot (never rejects wholesale). */
+	resolveMxBatch(hostnames: string[], options?: RustResolveOptions | null): Promise<RustMxRecord[][]>;
 	resolveA(hostname: string, options?: RustResolveOptions | null): Promise<string[]>;
 	resolveAaaa(hostname: string, options?: RustResolveOptions | null): Promise<string[]>;
 	resolveCname(hostname: string, options?: RustResolveOptions | null): Promise<string[]>;
@@ -3667,6 +3683,19 @@ declare class Zynor {
 	 * consumers must continue to use the queued resolve* methods.
 	 */
 	_resolveDirect<T>(hostname: string, type: RecordType, options?: AbortOptions): Promise<T>;
+	/**
+	 * @internal Validator-only (native `each`). Resolve MX for many hostnames in
+	 * a SINGLE batched call and seed the DNS LRU cache under the same `MX:<host>`
+	 * keys that {@link _resolveDirect} reads. After warming, each per-email MX
+	 * lookup is a cache hit — zero FFI per email. This is what collapses millions
+	 * of per-email native crossings into one batched call per page.
+	 *
+	 * No-op when the cache is disabled (the default `zynor` validator runs with
+	 * `cache: { enabled: false }`, so this is only effective for the native
+	 * entry, which enables it). Never throws — a batch failure just leaves the
+	 * cache cold and validation falls back to per-email resolution.
+	 */
+	_warmMxCache(hostnames: string[], options?: AbortOptions): Promise<void>;
 	/**
 	 * Returns the sum of concurrency limits across all enabled DNS providers.
 	 * Used by `validateBulk` to determine default parallelism.
@@ -3747,6 +3776,31 @@ declare class Zynor$1 extends Zynor {
  */
 declare class EmailValidator$1 extends EmailValidator {
 	protected createDns(config?: Omit<ZynorConfig, "cache">): Zynor$1;
+	/**
+	 * Page-based streaming override of {@link BaseEmailValidator.each}.
+	 *
+	 * The default (libuv) `each` does one DNS lookup per email — millions of
+	 * native (napi) crossings for a large list, which can exhaust the host
+	 * runtime. This native variant processes a page at a time: it resolves
+	 * every unique domain in the page with ONE batched FFI call (warming the
+	 * resolver's MX cache), then validates the page reading from that warm
+	 * cache (zero FFI per email), then emits the completed page. Awaiting
+	 * `onBatch` before the next page is natural backpressure — memory stays
+	 * bounded to a single page.
+	 *
+	 * Same surface and semantics as the base: `perPage`/`concurrency`
+	 * defaults, per-email errors become error-shaped results (never abort the
+	 * run), an `onBatch` throw aborts and rejects, and an aborted signal stops
+	 * cleanly without emitting a partial page.
+	 */
+	each(emails: string[], options: {
+		concurrency?: number;
+		perPage?: number;
+		deep?: boolean;
+		logo?: boolean;
+		signal?: AbortSignal;
+		timeout?: number;
+	} | undefined, onBatch: (batch: EmailResponse[]) => void | Promise<void>): Promise<void>;
 }
 export declare const resetDefaultResolver: () => void;
 export declare const setDefaultResolver: (resolver: Zynor$1) => void;