@visulima/email-verifier 1.0.1 → 1.0.2

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## @visulima/email-verifier [1.0.2](https://github.com/visulima/visulima/compare/%40visulima%2Femail-verifier%401.0.1...%40visulima%2Femail-verifier%401.0.2) (2026-08-02)
+
+
+### Dependencies
+
+* **@visulima/disposable-email-domains:** upgraded to 1.1.0
+* **@visulima/email-provider-mx:** upgraded to 1.0.1
+* **@visulima/free-email-domains:** upgraded to 1.0.1
+
 ## @visulima/email-verifier [1.0.1](https://github.com/visulima/visulima/compare/%40visulima%2Femail-verifier%401.0.0...%40visulima%2Femail-verifier%401.0.1) (2026-07-15)
 
 

package/dist/checks/character.d.ts

@@ -1,6 +1,6 @@
 /**
-* The result of local-part character analysis.
-*/
+ * The result of local-part character analysis.
+ */
 interface CharacterResult {
   /** Ratio of digits to total characters in the local part (0–1). */
   digitRatio: number;
@@ -12,20 +12,20 @@ interface CharacterResult {
   reasons: string[];
 }
 /**
-* Analyzes the local part of an email for irregular characteristics that
-* correlate with low-quality, spam-trap, or machine-generated addresses.
-*
-* Heuristic and intentionally conservative — it flags *patterns* (excessive
-* length, digit-heavy locals, long unpronounceable consonant runs, long repeats)
-* rather than asserting invalidity.
-* @param email The email address to analyze.
-* @returns The character analysis result.
-* @example
-* ```ts
-* import { analyzeCharacters } from "@visulima/email-verifier/checks/character";
-*
-* analyzeCharacters("aaaaaaa@example.com").irregular; // long repeat ⇒ true
-* ```
-*/
+ * Analyzes the local part of an email for irregular characteristics that
+ * correlate with low-quality, spam-trap, or machine-generated addresses.
+ *
+ * Heuristic and intentionally conservative — it flags *patterns* (excessive
+ * length, digit-heavy locals, long unpronounceable consonant runs, long repeats)
+ * rather than asserting invalidity.
+ * @param email The email address to analyze.
+ * @returns The character analysis result.
+ * @example
+ * ```ts
+ * import { analyzeCharacters } from "@visulima/email-verifier/checks/character";
+ *
+ * analyzeCharacters("aaaaaaa@example.com").irregular; // long repeat ⇒ true
+ * ```
+ */
 declare const analyzeCharacters: (email: string) => CharacterResult;
 export { type CharacterResult, analyzeCharacters, analyzeCharacters as default };

package/dist/checks/mx.d.ts

@@ -1 +1 @@
-export { type C as Cache, type I as InMemoryCache, type M as MxCheckOptions, type b as MxCheckResult, type c as MxRecord, type d as MxResolution, e as checkMxRecords, e as default } from "../packem_shared/mx.d-NAesS5sg.js";
+export { type C as Cache, type I as InMemoryCache, type M as MxCheckOptions, type b as MxCheckResult, type c as MxRecord, type d as MxResolution, e as checkMxRecords, e as default } from "../packem_shared/mx.d-HxIDdxvR.js";

package/dist/checks/mx.js

@@ -1 +1 @@
-import{createRequire as d}from"node:module";const u=d(import.meta.url),o=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,f=e=>{if(typeof o<"u"&&o.versions&&o.versions.node){const[r,s]=o.versions.node.split(".").map(Number);if(r>22||r===22&&s>=3||r===20&&s>=16)return o.getBuiltinModule(e)}return u(e)},{resolveMx:v,resolve4:p,resolve6:h}=f("node:dns/promises"),c=async e=>{try{if((await p(e)).length>0)return!0}catch{}try{return(await h(e)).length>0}catch{return!1}},l=e=>({domainResolves:!0,records:[{exchange:e,priority:0}],resolvedVia:"address",valid:!0}),g=async(e,r)=>{try{const s=(await v(e)).map(t=>({exchange:t.exchange,priority:t.priority}));return s.length>0?{domainResolves:!0,records:s.toSorted((t,a)=>t.priority-a.priority),resolvedVia:"mx",valid:!0}:r&&await c(e)?l(e):{domainResolves:!1,records:[],resolvedVia:"none",valid:!1}}catch(s){return r&&await c(e)?l(e):{domainResolves:!1,error:s instanceof Error?s.message:String(s),resolvedVia:"none",valid:!1}}},y=async(e,r={})=>{const{fallbackToAddress:s=!0}=r,t=r.ttl??36e5,a=`${e}:${String(s)}`;if(r.cache){const n=await r.cache.get(a);if(n!==void 0)return n}const i=await g(e,s);return r.cache&&await r.cache.set(a,i,t),i};export{y as checkMxRecords,y as default};
+import{createRequire as f}from"node:module";let h;const v=e=>(h??=f(import.meta.url))(e),n=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,p=e=>{if(typeof n<"u"&&n.versions&&n.versions.node){const[r,t]=n.versions.node.split(".").map(Number);if(r>22||r===22&&t>=3||r===20&&t>=16)return n.getBuiltinModule(e)}return v(e)},{resolveMx:g,resolve4:y,resolve6:_}=p("node:dns/promises"),m=new Set(["EAI_AGAIN","ECONNREFUSED","EREFUSED","ESERVFAIL","ETIMEDOUT","ETIMEOUT"]),E=e=>{const{code:r}=e??{};return r!==void 0&&m.has(r)},l=async e=>{try{if((await y(e)).length>0)return!0}catch{}try{return(await _(e)).length>0}catch{return!1}},u=e=>({domainResolves:!0,records:[{exchange:e,priority:0}],resolvedVia:"address",valid:!0}),w=async(e,r)=>{try{const t=(await g(e)).map(o=>({exchange:o.exchange,priority:o.priority}));return t.length>0?{domainResolves:!0,records:t.toSorted((o,s)=>o.priority-s.priority),resolvedVia:"mx",valid:!0}:r&&await l(e)?u(e):{domainResolves:!1,records:[],resolvedVia:"none",valid:!1}}catch(t){return r&&await l(e)?u(e):{deferred:E(t),domainResolves:!1,error:t instanceof Error?t.message:String(t),resolvedVia:"none",valid:!1}}},i=new Map,M=async(e,r={})=>{const{fallbackToAddress:t=!0}=r,o=r.ttl??36e5,s=`${e}:${String(t)}`;if(r.cache){const a=await r.cache.get(s);if(a!==void 0)return a}const c=i.get(s);if(c)return c;const d=(async()=>{const a=await w(e,t);return r.cache&&!a.deferred&&await r.cache.set(s,a,o),a})();i.set(s,d);try{return await d}finally{i.delete(s)}};export{M as checkMxRecords,M as default};

package/dist/checks/role.d.ts

@@ -1,41 +1,41 @@
 /**
-* Local-part prefixes that indicate a no-reply / do-not-reply mailbox.
-* These are a strict subset of {@link ROLE_ACCOUNT_PREFIXES}.
-*/
+ * Local-part prefixes that indicate a no-reply / do-not-reply mailbox.
+ * These are a strict subset of {@link ROLE_ACCOUNT_PREFIXES}.
+ */
 declare const NO_REPLY_PREFIXES: ReadonlySet<string>;
 /**
-* Local-part prefixes that identify a role-based (shared, function) mailbox
-* rather than a personal one. Superset of RFC 2142 plus common real-world roles.
-*/
+ * Local-part prefixes that identify a role-based (shared, function) mailbox
+ * rather than a personal one. Superset of RFC 2142 plus common real-world roles.
+ */
 declare const ROLE_ACCOUNT_PREFIXES: ReadonlySet<string>;
 /**
-* Determines whether an email address is a role-based account.
-*
-* Matches the whole local part, the part before any `+tag`, and each
-* dot/dash/underscore-separated token (so `sales.john`, `info+news`, and
-* `no-reply` are all caught).
-* @param email The email address to check.
-* @param customPrefixes Optional additional role prefixes to recognize.
-* @returns True when the address is a role account.
-* @example
-* ```ts
-* import { isRoleAccount } from "@visulima/email-verifier/checks/role";
-*
-* isRoleAccount("info@example.com"); // true
-* isRoleAccount("john.doe@example.com"); // false
-* ```
-*/
+ * Determines whether an email address is a role-based account.
+ *
+ * Matches the whole local part, the part before any `+tag`, and each
+ * dot/dash/underscore-separated token (so `sales.john`, `info+news`, and
+ * `no-reply` are all caught).
+ * @param email The email address to check.
+ * @param customPrefixes Optional additional role prefixes to recognize.
+ * @returns True when the address is a role account.
+ * @example
+ * ```ts
+ * import { isRoleAccount } from "@visulima/email-verifier/checks/role";
+ *
+ * isRoleAccount("info@example.com"); // true
+ * isRoleAccount("john.doe@example.com"); // false
+ * ```
+ */
 declare const isRoleAccount: (email: string, customPrefixes?: Iterable<string>) => boolean;
 /**
-* Determines whether an email address is a no-reply / do-not-reply mailbox.
-* @param email The email address to check.
-* @returns True when the address is a no-reply mailbox.
-* @example
-* ```ts
-* import { isNoReply } from "@visulima/email-verifier/checks/role";
-*
-* isNoReply("no-reply@example.com"); // true
-* ```
-*/
+ * Determines whether an email address is a no-reply / do-not-reply mailbox.
+ * @param email The email address to check.
+ * @returns True when the address is a no-reply mailbox.
+ * @example
+ * ```ts
+ * import { isNoReply } from "@visulima/email-verifier/checks/role";
+ *
+ * isNoReply("no-reply@example.com"); // true
+ * ```
+ */
 declare const isNoReply: (email: string) => boolean;
 export { NO_REPLY_PREFIXES, ROLE_ACCOUNT_PREFIXES, isRoleAccount as default, isNoReply, isRoleAccount };

package/dist/checks/role.js

@@ -1 +1 @@
-import{splitAddress as c}from"../packem_shared/extractDomain-CYJf1_0N.js";const l=new Set(["do-not-reply","do_not_reply","donotreply","no-reply","no_reply","noreply","notification","notifications","notify"]),n=new Set(["abuse","accounting","accounts","admin","administrator","all","billing","board","career","careers","ceo","cfo","compliance","contact","contacts","cto","customercare","customerservice","dev","developer","devnull","do-not-reply","do_not_reply","donotreply","enquiries","enquiry","everyone","feedback","finance","ftp","hello","help","helpdesk","hi","hostmaster","hr","info","information","inquiries","inquiry","investor","investors","it","jobs","legal","list","list-request","mail","mailer-daemon","mailerdaemon","majordomo","marketing","media","members","newsletter","no-reply","no_reply","noc","noreply","notification","notifications","notify","office","operations","order","orders","postmaster","press","privacy","purchasing","recruitment","register","registration","root","sales","secretary","security","service","services","shop","spam","staff","subscribe","support","sysadmin","team","tech","test","unsubscribe","usenet","uucp","webmaster","welcome","www"]),u=/[.\-_+]/,o=(t,e,r)=>{if(e.has(t))return!0;if(r){for(const s of r)if(s.toLowerCase()===t)return!0}return!1},m=(t,e)=>{const r=c(t);if(!r)return!1;const{localPart:s}=r,i=s.split("+")[0];if(o(s,n,e)||o(i,n,e))return!0;const a=i.split(u).filter(Boolean);return a.length>1&&a.some(p=>o(p,n,e))},d=t=>{const e=c(t);if(!e)return!1;const r=e.localPart.split("+")[0];return o(e.localPart,l)||o(r,l)};export{l as NO_REPLY_PREFIXES,n as ROLE_ACCOUNT_PREFIXES,m as default,d as isNoReply,m as isRoleAccount};
+import{splitAddress as m}from"../packem_shared/extractDomain-CYJf1_0N.js";const p=new Set(["do-not-reply","do_not_reply","donotreply","no-reply","no_reply","noreply","notification","notifications","notify"]),i=new Set(["abuse","accounting","accounts","admin","administrator","all","billing","board","career","careers","ceo","cfo","compliance","contact","contacts","cto","customercare","customerservice","dev","developer","devnull","do-not-reply","do_not_reply","donotreply","enquiries","enquiry","everyone","feedback","finance","ftp","hello","help","helpdesk","hi","hostmaster","hr","info","information","inquiries","inquiry","investor","investors","it","jobs","legal","list","list-request","mail","mailer-daemon","mailerdaemon","majordomo","marketing","media","members","newsletter","no-reply","no_reply","noc","noreply","notification","notifications","notify","office","operations","order","orders","postmaster","press","privacy","purchasing","recruitment","register","registration","root","sales","secretary","security","service","services","shop","spam","staff","subscribe","support","sysadmin","team","tech","test","unsubscribe","usenet","uucp","webmaster","welcome","www"]),u=/[.\-_+]/,t=(o,e,r)=>e.has(o)||(r?.has(o)??!1),f=(o,e)=>{const r=m(o);if(!r)return!1;const{localPart:a}=r,l=a.split("+")[0],s=e?new Set([...e].map(n=>n.toLowerCase())):void 0;if(t(a,i,s)||t(l,i,s))return!0;const c=l.split(u).filter(Boolean);return c.length>1&&c.some(n=>t(n,i,s))},y=o=>{const e=m(o);if(!e)return!1;const r=e.localPart.split("+")[0];return t(e.localPart,p)||t(r,p)};export{p as NO_REPLY_PREFIXES,i as ROLE_ACCOUNT_PREFIXES,f as default,y as isNoReply,f as isRoleAccount};

package/dist/checks/smtp.d.ts

@@ -1,43 +1,43 @@
-import { b as MxCheckResult, C as Cache, c as MxRecord } from "../packem_shared/mx.d-NAesS5sg.js";
+import { b as MxCheckResult, C as Cache, c as MxRecord } from "../packem_shared/mx.d-HxIDdxvR.js";
 /**
-* Options for SMTP verification.
-*/
+ * Options for SMTP verification.
+ */
 interface SmtpVerificationOptions {
   /** Cache for the underlying MX lookup. */
   cache?: Cache<MxCheckResult>;
   /**
-  * Number of random, almost-certainly-nonexistent addresses to probe for
-  * catch-all detection. More probes reduce false positives from
-  * deferred-rejection servers. Set to 0 to disable.
-  * @default 1
-  */
+   * Number of random, almost-certainly-nonexistent addresses to probe for
+   * catch-all detection. More probes reduce false positives from
+   * deferred-rejection servers. Set to 0 to disable.
+   * @default 1
+   */
   catchAllProbes?: number;
   /**
-  * MAIL FROM address used during the probe; defaults to `verify@` followed by
-  * the HELO host.
-  */
+   * MAIL FROM address used during the probe; defaults to `verify@` followed by
+   * the HELO host.
+   */
   fromEmail?: string;
   /**
-  * HELO/EHLO hostname presented to the remote server.
-  * @default the address domain
-  */
+   * HELO/EHLO hostname presented to the remote server.
+   * @default the address domain
+   */
   heloHost?: string;
   /**
-  * Pre-resolved MX records to probe, in priority order. When provided, the
-  * probe skips its own DNS lookup — the orchestrator passes the records it
-  * already resolved so the domain is not queried twice.
-  */
+   * Pre-resolved MX records to probe, in priority order. When provided, the
+   * probe skips its own DNS lookup — the orchestrator passes the records it
+   * already resolved so the domain is not queried twice.
+   */
   mxRecords?: MxRecord[];
   port?: number;
   /**
-  * Number of times to retry the whole probe on a temporary (greylist) failure.
-  * @default 1
-  */
+   * Number of times to retry the whole probe on a temporary (greylist) failure.
+   * @default 1
+   */
   retries?: number;
   /**
-  * Delay in milliseconds between greylist retries.
-  * @default 5000
-  */
+   * Delay in milliseconds between greylist retries.
+   * @default 5000
+   */
   retryDelay?: number;
   /** Cache for SMTP results. */
   smtpCache?: Cache<SmtpVerificationResult>;
@@ -45,8 +45,8 @@ interface SmtpVerificationOptions {
   ttl?: number;
 }
 /**
-* Detailed result of an SMTP verification attempt.
-*/
+ * Detailed result of an SMTP verification attempt.
+ */
 interface SmtpVerificationResult {
   /** True when the server accepts a random, nonexistent recipient (catch-all). */
   acceptAll?: boolean;
@@ -64,30 +64,5 @@ interface SmtpVerificationResult {
   /** True when the real RCPT TO was accepted (250). */
   valid: boolean;
 }
-/**
-* Verifies an email address over SMTP without sending a message.
-*
-* Performs the full handshake (greeting → EHLO/HELO → MAIL FROM → RCPT TO),
-* then — when the real recipient is accepted — issues additional RCPT TO probes
-* for random addresses to detect catch-all (accept-all) servers. Temporary
-* (4xx) failures are surfaced as `deferred` and retried up to `retries` times to
-* survive greylisting, and over-quota responses set `mailboxFull`.
-*
-* Note: many networks block outbound port 25 and many servers refuse or tarpit
-* verification probes, so treat a `deferred`/errored result as inconclusive
-* rather than undeliverable.
-* @param email The email address to verify.
-* @param options Verification options.
-* @returns The detailed SMTP verification result.
-* @example
-* ```ts
-* import { verifySmtp } from "@visulima/email-verifier/checks/smtp";
-*
-* const result = await verifySmtp("user@example.com", { catchAllProbes: 2 });
-* if (result.valid && !result.acceptAll) {
-*     console.log("Mailbox exists");
-* }
-* ```
-*/
 declare const verifySmtp: (email: string, options?: SmtpVerificationOptions) => Promise<SmtpVerificationResult>;
 export { type SmtpVerificationOptions, type SmtpVerificationResult, verifySmtp as default, verifySmtp };

package/dist/checks/smtp.js

@@ -1,7 +1,7 @@
-import{createRequire as x}from"node:module";import{splitAddress as M}from"../packem_shared/extractDomain-CYJf1_0N.js";import{checkMxRecords as j}from"./mx.js";const $=x(import.meta.url),h=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,R=r=>{if(typeof h<"u"&&h.versions&&h.versions.node){const[e,t]=h.versions.node.split(".").map(Number);if(e>22||e===22&&t>=3||e===20&&t>=16)return h.getBuiltinModule(r)}return $(r)},{Socket:T}=R("node:net"),y=/[\u0000-\u001F\u007F]/,k=/\b([245]\.\d{1,3}\.\d{1,3})\b/,C=/^(\d{3})(?: |$)/,E=/\r?\n/,g="abcdefghijklmnopqrstuvwxyz0123456789",P=(r=20)=>{let e="";for(let t=0;t<r;t+=1)e+=g[Math.floor(Math.random()*g.length)]??"";return e},S=async r=>new Promise(e=>{setTimeout(e,r)});class _{transcript="";buffer="";completed=[];failure;finished=!1;socket;waiter;constructor(e){this.socket=e,e.on("data",o=>{this.transcript+=o.toString(),this.buffer+=o.toString(),this.drain()});const t=o=>{this.finished=!0,this.failure=o??new Error("Connection closed by server"),this.completed.length===0&&this.waiter&&(this.waiter.reject(this.failure),this.waiter=void 0)};e.on("error",t),e.on("close",()=>{t()}),e.on("timeout",()=>{t(new Error("SMTP socket timeout")),e.destroy()})}async command(e){return this.transcript+=`${e}\r
+import{createRequire as x}from"node:module";import{splitAddress as L}from"../packem_shared/extractDomain-CYJf1_0N.js";import{checkMxRecords as _}from"./mx.js";let R;const M=r=>(R??=x(import.meta.url))(r),m=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,T=r=>{if(typeof m<"u"&&m.versions&&m.versions.node){const[e,t]=m.versions.node.split(".").map(Number);if(e>22||e===22&&t>=3||e===20&&t>=16)return m.getBuiltinModule(r)}return M(r)},{Socket:j}=T("node:net"),b=/[\u0000-\u001F\u007F]/,k=/\b([245]\.\d{1,3}\.\d{1,3})\b/,C=/^(\d{3})(?: |$)/,E=/\r?\n/,$="abcdefghijklmnopqrstuvwxyz0123456789",P=(r=20)=>{let e="";for(let t=0;t<r;t+=1)e+=$[Math.floor(Math.random()*$.length)]??"";return e},S=async r=>new Promise(e=>{setTimeout(e,r)});class A{transcript="";buffer="";completed=[];failure;finished=!1;socket;waiter;constructor(e){this.socket=e,e.on("data",s=>{this.transcript+=s.toString(),this.buffer+=s.toString(),this.drain()});const t=s=>{this.finished=!0,this.failure=s??new Error("Connection closed by server"),this.completed.length===0&&this.waiter&&(this.waiter.reject(this.failure),this.waiter=void 0)};e.on("error",t),e.on("close",()=>{t()}),e.on("timeout",()=>{t(new Error("SMTP socket timeout")),e.destroy()})}async command(e){return this.transcript+=`${e}\r
 `,this.socket.write(`${e}\r
 `),this.readReply()}close(){try{this.socket.write(`QUIT\r
-`)}catch{}this.socket.removeAllListeners(),this.socket.destroy()}async readReply(){if(this.completed.length>0)return this.completed.shift();if(this.finished)throw this.failure??new Error("Connection closed");return new Promise((e,t)=>{this.waiter={reject:t,resolve:e}})}drain(){const e=this.buffer.split(E);this.buffer=e.pop()??"";let t=[];for(const o of e){t.push(o);const a=C.exec(o);if(a){const i=t.join(`
-`),c=k.exec(i)?.[1];this.completed.push({code:Number.parseInt(a[1],10),enhanced:c,text:i}),t=[]}}if(t.length>0&&(this.buffer=`${t.join(`
+`)}catch{}this.socket.removeAllListeners(),this.socket.destroy()}async readReply(){if(this.completed.length>0)return this.completed.shift();if(this.finished)throw this.failure??new Error("Connection closed");return new Promise((e,t)=>{this.waiter={reject:t,resolve:e}})}drain(){const e=this.buffer.split(E);this.buffer=e.pop()??"";let t=[];for(const s of e){t.push(s);const c=C.exec(s);if(c){const o=t.join(`
+`),l=k.exec(o)?.[1];this.completed.push({code:Number.parseInt(c[1],10),enhanced:l,text:o}),t=[]}}if(t.length>0&&(this.buffer=`${t.join(`
 `)}
-${this.buffer}`),this.waiter&&this.completed.length>0){const{resolve:o}=this.waiter;this.waiter=void 0,o(this.completed.shift())}}}const A=r=>{const{code:e,enhanced:t}=r;return e>=200&&e<300?{code:e,enhancedCode:t,valid:!0}:e===452||e===552||t==="4.2.2"||t==="5.2.2"?{code:e,deferred:e===452,enhancedCode:t,mailboxFull:!0,valid:!1}:e>=400&&e<500?{code:e,deferred:!0,enhancedCode:t,valid:!1}:{code:e,enhancedCode:t,valid:!1}},L=async(r,e,t)=>new Promise((o,a)=>{const i=new T;i.setTimeout(t);const c=f=>{i.removeAllListeners(),i.destroy(),a(f)},l=()=>{c(new Error("SMTP connection timeout"))};i.once("error",c),i.once("timeout",l),i.connect(e,r,()=>{i.removeListener("error",c),i.removeListener("timeout",l),o(new _(i))})}),H=async(r,e,t,o)=>{const{catchAllProbes:a=1,port:i=25,timeout:c=5e3}=o,l=o.heloHost??e,f=o.fromEmail??`verify@${l}`;let n;try{n=await L(t.exchange,i,c);const d=await n.readReply();if(d.code!==220)return{deferred:!0,error:`Unexpected greeting: ${d.text}`,valid:!1};let s=await n.command(`EHLO ${l}`);if(s.code!==250&&(s=await n.command(`HELO ${l}`),s.code!==250))return{deferred:!0,error:`HELO rejected: ${s.text}`,valid:!1};const u=await n.command(`MAIL FROM:<${f}>`);if(u.code!==250)return{deferred:!0,error:`MAIL FROM rejected: ${u.text}`,valid:!1};const b=await n.command(`RCPT TO:<${r}>`),p=A(b);let m;if(p.valid&&a>0){m=!0;for(let v=0;v<a;v+=1){const w=await n.command(`RCPT TO:<${P()}@${e}>`);if(w.code<200||w.code>=300){m=!1;break}}}return{...p,acceptAll:m,smtpResponse:n.transcript}}finally{n?.close()}},O=async(r,e,t,o)=>{let a="SMTP verification did not complete";for(const i of t)try{return await H(r,e,i,o)}catch(c){a=c instanceof Error?c.message:String(c)}return{deferred:!0,error:a,valid:!1}},I=r=>{if(r.heloHost!==void 0&&y.test(r.heloHost))return{error:"Invalid heloHost: control characters are not allowed",valid:!1};if(r.fromEmail!==void 0&&y.test(r.fromEmail))return{error:"Invalid fromEmail: control characters are not allowed",valid:!1}},B=async(r,e={})=>{const t=M(r);if(!t)return{error:"Invalid email format",valid:!1};const{domain:o}=t,a=I(e);if(a)return a;const{retries:i=1,retryDelay:c=5e3,ttl:l=36e5}=e,f=["smtp",t.address,e.fromEmail??"",String(e.port??25),e.heloHost??"",String(e.catchAllProbes??1),(e.mxRecords??[]).map(s=>s.exchange).join(",")].join("|");if(e.smtpCache){const s=await e.smtpCache.get(f);if(s!==void 0)return s}let n=e.mxRecords;if(!n||n.length===0){const s=await j(o,{cache:e.cache,fallbackToAddress:!1});if(!s.valid||!s.records||s.records.length===0)return{error:s.error??"No MX records found",mxRecords:s.records,valid:!1};n=s.records}let d={error:"SMTP verification did not complete",valid:!1};for(let s=0;s<=i&&(d=await O(t.address,o,n,e),!(!d.deferred||s===i));s+=1)await S(c);return d={...d,mxRecords:n},e.smtpCache&&!d.deferred&&await e.smtpCache.set(f,d,l),d};export{B as default,B as verifySmtp};
+${this.buffer}`),this.waiter&&this.completed.length>0){const{resolve:s}=this.waiter;this.waiter=void 0,s(this.completed.shift())}}}const H=r=>{const{code:e,enhanced:t}=r;return e>=200&&e<300?{code:e,enhancedCode:t,valid:!0}:e===452||e===552||t==="4.2.2"||t==="5.2.2"?{code:e,deferred:e===452,enhancedCode:t,mailboxFull:!0,valid:!1}:e>=400&&e<500?{code:e,deferred:!0,enhancedCode:t,valid:!1}:{code:e,enhancedCode:t,valid:!1}},O=async(r,e,t)=>new Promise((s,c)=>{const o=new j;o.setTimeout(t);const l=a=>{o.removeAllListeners(),o.destroy(),c(a)},i=()=>{l(new Error("SMTP connection timeout"))};o.once("error",l),o.once("timeout",i),o.connect(e,r,()=>{o.removeListener("error",l),o.removeListener("timeout",i),s(new A(o))})}),I=async(r,e,t,s)=>{const{catchAllProbes:c=1,port:o=25,timeout:l=5e3}=s,i=s.heloHost??e,a=s.fromEmail??`verify@${i}`;let d;try{d=await O(t.exchange,o,l);const u=await d.readReply();if(u.code!==220)return{connectionLevel:!0,deferred:!0,error:`Unexpected greeting: ${u.text}`,valid:!1};let n=await d.command(`EHLO ${i}`);if(n.code!==250&&(n=await d.command(`HELO ${i}`),n.code!==250))return{connectionLevel:!0,deferred:!0,error:`HELO rejected: ${n.text}`,valid:!1};const h=await d.command(`MAIL FROM:<${a}>`);if(h.code!==250)return{connectionLevel:!0,deferred:!0,error:`MAIL FROM rejected: ${h.text}`,valid:!1};const f=await d.command(`RCPT TO:<${r}>`),w=H(f);let p;if(w.valid&&c>0){p=!0;for(let y=0;y<c;y+=1){const g=await d.command(`RCPT TO:<${P()}@${e}>`);if(g.code<200||g.code>=300){p=!1;break}}}return{...w,acceptAll:p,smtpResponse:d.transcript}}finally{d?.close()}},q=async(r,e,t,s)=>{let c="SMTP verification did not complete",o;for(const l of t){let i;try{i=await I(r,e,l,s)}catch(a){c=a instanceof Error?a.message:String(a);continue}if(i.connectionLevel){o=i;continue}return i}if(o){const{connectionLevel:l,...i}=o;return i}return{deferred:!0,error:c,valid:!1}},F=r=>{if(r.heloHost!==void 0&&b.test(r.heloHost))return{error:"Invalid heloHost: control characters are not allowed",valid:!1};if(r.fromEmail!==void 0&&b.test(r.fromEmail))return{error:"Invalid fromEmail: control characters are not allowed",valid:!1}},v=new Map,z=async(r,e={})=>{const t=L(r);if(!t)return{error:"Invalid email format",valid:!1};const{domain:s}=t,c=F(e);if(c)return c;const{retries:o=1,retryDelay:l=5e3,ttl:i=36e5}=e,a=["smtp",t.address,e.fromEmail??"",String(e.port??25),e.heloHost??"",String(e.catchAllProbes??1),(e.mxRecords??[]).map(n=>n.exchange).join(",")].join("|");if(e.smtpCache){const n=await e.smtpCache.get(a);if(n!==void 0)return n}const d=v.get(a);if(d)return d;const u=(async()=>{let n=e.mxRecords;if(!n||n.length===0){const f=await _(s,{cache:e.cache,fallbackToAddress:!1});if(!f.valid||!f.records||f.records.length===0)return{error:f.error??"No MX records found",mxRecords:f.records,valid:!1};n=f.records}let h={error:"SMTP verification did not complete",valid:!1};for(let f=0;f<=o&&(h=await q(t.address,s,n,e),!(!h.deferred||f===o));f+=1)await S(l);return h={...h,mxRecords:n},e.smtpCache&&!h.deferred&&await e.smtpCache.set(a,h,i),h})();v.set(a,u);try{return await u}finally{v.delete(a)}};export{z as default,z as verifySmtp};

package/dist/checks/symbol.d.ts

@@ -1,6 +1,6 @@
 /**
-* The result of symbol / Unicode analysis.
-*/
+ * The result of symbol / Unicode analysis.
+ */
 interface SymbolResult {
   /** True when the address mixes Unicode scripts (a homoglyph-spoofing signal). */
   hasMixedScripts: boolean;
@@ -12,18 +12,18 @@ interface SymbolResult {
   scripts: string[];
 }
 /**
-* Detects symbols, emoji, and mixed Unicode scripts in an email address.
-*
-* Mixed-script local parts (e.g. Latin + Cyrillic) are a classic homoglyph /
-* spoofing signal; symbol or emoji characters indicate a non-standard address.
-* @param email The email address to analyze.
-* @returns The symbol analysis result.
-* @example
-* ```ts
-* import { analyzeSymbols } from "@visulima/email-verifier/checks/symbol";
-*
-* analyzeSymbols("раypal@example.com").hasMixedScripts; // true (Cyrillic "ра")
-* ```
-*/
+ * Detects symbols, emoji, and mixed Unicode scripts in an email address.
+ *
+ * Mixed-script local parts (e.g. Latin + Cyrillic) are a classic homoglyph /
+ * spoofing signal; symbol or emoji characters indicate a non-standard address.
+ * @param email The email address to analyze.
+ * @returns The symbol analysis result.
+ * @example
+ * ```ts
+ * import { analyzeSymbols } from "@visulima/email-verifier/checks/symbol";
+ *
+ * analyzeSymbols("раypal@example.com").hasMixedScripts; // true (Cyrillic "ра")
+ * ```
+ */
 declare const analyzeSymbols: (email: string) => SymbolResult;
 export { type SymbolResult, analyzeSymbols, analyzeSymbols as default };

package/dist/checks/syntax.d.ts

@@ -1,19 +1,19 @@
 /**
-* Validates an email address format according to basic RFC standards.
-*
-* This is intentionally pragmatic rather than a full RFC 5322 parser: it rejects
-* the address shapes that never deliver (missing parts, consecutive dots, leading
-* or trailing dots, hyphen-bounded domain labels) while accepting the long tail
-* of legitimate real-world addresses.
-* @param email The email address string to validate.
-* @returns True if the email address is syntactically valid, false otherwise.
-* @example
-* ```ts
-* import { validateSyntax } from "@visulima/email-verifier/checks/syntax";
-*
-* validateSyntax("user@example.com"); // true
-* validateSyntax("user@@example.com"); // false
-* ```
-*/
+ * Validates an email address format according to basic RFC standards.
+ *
+ * This is intentionally pragmatic rather than a full RFC 5322 parser: it rejects
+ * the address shapes that never deliver (missing parts, consecutive dots, leading
+ * or trailing dots, hyphen-bounded domain labels) while accepting the long tail
+ * of legitimate real-world addresses.
+ * @param email The email address string to validate.
+ * @returns True if the email address is syntactically valid, false otherwise.
+ * @example
+ * ```ts
+ * import { validateSyntax } from "@visulima/email-verifier/checks/syntax";
+ *
+ * validateSyntax("user@example.com"); // true
+ * validateSyntax("user@@example.com"); // false
+ * ```
+ */
 declare const validateSyntax: (email: string) => boolean;
 export { validateSyntax as default, validateSyntax };

package/dist/checks/tag.d.ts

@@ -1,6 +1,6 @@
 /**
-* The result of sub-address (tag) detection.
-*/
+ * The result of sub-address (tag) detection.
+ */
 interface TagResult {
   /** The local part with the tag and separator removed (the "real" mailbox). */
   baseLocalPart: string;
@@ -12,20 +12,20 @@ interface TagResult {
   tag?: string;
 }
 /**
-* Detects plus-addressing / sub-addressing tags in an email address.
-*
-* Most providers (Gmail, Outlook, iCloud, Proton, …) delimit the tag with `+`;
-* a few (Fastmail, Yahoo) use `-`. The returned {@link TagResult.baseLocalPart}
-* is the canonical mailbox with the tag stripped.
-* @param email The email address to inspect.
-* @returns The tag detection result.
-* @example
-* ```ts
-* import { detectTag } from "@visulima/email-verifier/checks/tag";
-*
-* detectTag("user+newsletter@gmail.com");
-* // { hasTag: true, tag: "newsletter", separator: "+", baseLocalPart: "user" }
-* ```
-*/
+ * Detects plus-addressing / sub-addressing tags in an email address.
+ *
+ * Most providers (Gmail, Outlook, iCloud, Proton, …) delimit the tag with `+`;
+ * a few (Fastmail, Yahoo) use `-`. The returned {@link TagResult.baseLocalPart}
+ * is the canonical mailbox with the tag stripped.
+ * @param email The email address to inspect.
+ * @returns The tag detection result.
+ * @example
+ * ```ts
+ * import { detectTag } from "@visulima/email-verifier/checks/tag";
+ *
+ * detectTag("user+newsletter@gmail.com");
+ * // { hasTag: true, tag: "newsletter", separator: "+", baseLocalPart: "user" }
+ * ```
+ */
 declare const detectTag: (email: string) => TagResult;
 export { type TagResult, detectTag as default, detectTag };

package/dist/enrich/name.d.ts

@@ -1,6 +1,6 @@
 /**
-* A name parsed from an email's local part.
-*/
+ * A name parsed from an email's local part.
+ */
 interface NameResult {
   /** Confidence in the parse: `high` (clear separator), `medium` (camelCase), `low` (heuristic), `none`. */
   confidence: "high" | "low" | "medium" | "none";
@@ -12,21 +12,21 @@ interface NameResult {
   lastName?: string;
 }
 /**
-* Heuristically parses a person's name from the local part of an email address.
-*
-* Handles separator-delimited (`john.doe`), camelCase (`johnDoe`), and
-* single-token local parts, stripping trailing digits. This is best-effort name
-* parsing only — no gender detection — and confidence is reported so callers
-* can decide how much to trust it.
-* @param email The email address to parse.
-* @returns The parsed name and a confidence level.
-* @example
-* ```ts
-* import { parseName } from "@visulima/email-verifier/enrich/name";
-*
-* parseName("john.doe@example.com");
-* // { firstName: "John", lastName: "Doe", fullName: "John Doe", confidence: "high" }
-* ```
-*/
+ * Heuristically parses a person's name from the local part of an email address.
+ *
+ * Handles separator-delimited (`john.doe`), camelCase (`johnDoe`), and
+ * single-token local parts, stripping trailing digits. This is best-effort name
+ * parsing only — no gender detection — and confidence is reported so callers
+ * can decide how much to trust it.
+ * @param email The email address to parse.
+ * @returns The parsed name and a confidence level.
+ * @example
+ * ```ts
+ * import { parseName } from "@visulima/email-verifier/enrich/name";
+ *
+ * parseName("john.doe@example.com");
+ * // { firstName: "John", lastName: "Doe", fullName: "John Doe", confidence: "high" }
+ * ```
+ */
 declare const parseName: (email: string) => NameResult;
 export { type NameResult, parseName as default, parseName };

package/dist/enrich/provider.d.ts

@@ -1,9 +1,9 @@
 import { MxProviderInfo } from '@visulima/email-provider-mx';
 export { type MxProviderInfo, classifyMx, classifyMxRecords, isSecureEmailGateway } from '@visulima/email-provider-mx';
-import { c as MxRecord, b as MxCheckResult, C as Cache } from "../packem_shared/mx.d-NAesS5sg.js";
+import { c as MxRecord, b as MxCheckResult, C as Cache } from "../packem_shared/mx.d-HxIDdxvR.js";
 /**
-* The enriched provider details for an email address.
-*/
+ * The enriched provider details for an email address.
+ */
 interface ProviderDetails {
   /** True when the resolving MX is a Secure Email Gateway (Proofpoint, Mimecast, …). */
   isSecureEmailGateway: boolean;
@@ -13,28 +13,28 @@ interface ProviderDetails {
   provider?: MxProviderInfo;
 }
 /**
-* Options for provider enrichment.
-*/
+ * Options for provider enrichment.
+ */
 interface ProviderEnrichOptions {
   cache?: Cache<MxCheckResult>;
   ttl?: number;
 }
 /**
-* Resolves an email address's mailbox/SEG provider from its MX records.
-*
-* Looks up the domain's MX records, then classifies the highest-priority host
-* via `@visulima/email-provider-mx` — emailable's "SMTP Provider Details" plus
-* Secure-Email-Gateway detection.
-* @param email The email address to enrich.
-* @param options Caching options for the MX lookup.
-* @returns The provider details, including the MX records used.
-* @example
-* ```ts
-* import { enrichProvider } from "@visulima/email-verifier/enrich/provider";
-*
-* const details = await enrichProvider("user@gmail.com");
-* console.log(details.provider?.display); // "Google"
-* ```
-*/
+ * Resolves an email address's mailbox/SEG provider from its MX records.
+ *
+ * Looks up the domain's MX records, then classifies the highest-priority host
+ * via `@visulima/email-provider-mx` — emailable's "SMTP Provider Details" plus
+ * Secure-Email-Gateway detection.
+ * @param email The email address to enrich.
+ * @param options Caching options for the MX lookup.
+ * @returns The provider details, including the MX records used.
+ * @example
+ * ```ts
+ * import { enrichProvider } from "@visulima/email-verifier/enrich/provider";
+ *
+ * const details = await enrichProvider("user@gmail.com");
+ * console.log(details.provider?.display); // "Google"
+ * ```
+ */
 declare const enrichProvider: (email: string, options?: ProviderEnrichOptions) => Promise<ProviderDetails>;
 export { type ProviderDetails, type ProviderEnrichOptions, enrichProvider as default, enrichProvider };

package/dist/enrich/typo.d.ts

@@ -1,6 +1,6 @@
 /**
-* A suggested correction for a likely-misspelled email address.
-*/
+ * A suggested correction for a likely-misspelled email address.
+ */
 interface TypoSuggestion {
   /** The suggested corrected domain. */
   domain: string;
@@ -8,52 +8,52 @@ interface TypoSuggestion {
   full: string;
 }
 /**
-* Options for typo suggestion.
-*/
+ * Options for typo suggestion.
+ */
 interface TypoOptions {
   /** Popular full domains to match against (e.g. `gmail.com`). */
   domains?: string[];
   /**
-  * Distance threshold for the full-domain match.
-  * @default 2
-  */
+   * Distance threshold for the full-domain match.
+   * @default 2
+   */
   domainThreshold?: number;
   /** Popular second-level domains to match against (e.g. `gmail`). */
   secondLevelDomains?: string[];
   /**
-  * Distance threshold for the second-level match.
-  * @default 2
-  */
+   * Distance threshold for the second-level match.
+   * @default 2
+   */
   secondLevelThreshold?: number;
   /** Popular top-level domains to match against (e.g. `com`). */
   topLevelDomains?: string[];
   /**
-  * Distance threshold for the top-level match.
-  * @default 2
-  */
+   * Distance threshold for the top-level match.
+   * @default 2
+   */
   topLevelThreshold?: number;
 }
 declare const sift3Distance: (s1: string, s2: string) => number;
 /**
-* Suggests a corrected domain for a likely-misspelled one, using the mailcheck
-* algorithm (full-domain match, then second-level + top-level matching).
-* @param domain The domain to check.
-* @param options Override domain lists and thresholds.
-* @returns The suggested domain, or `undefined` when the domain looks fine.
-*/
+ * Suggests a corrected domain for a likely-misspelled one, using the mailcheck
+ * algorithm (full-domain match, then second-level + top-level matching).
+ * @param domain The domain to check.
+ * @param options Override domain lists and thresholds.
+ * @returns The suggested domain, or `undefined` when the domain looks fine.
+ */
 declare const suggestDomain: (domain: string, options?: TypoOptions) => string | undefined;
 /**
-* Suggests a corrected email address when the domain looks misspelled
-* (e.g. `user@gmial.com` → `user@gmail.com`).
-* @param email The email address to check.
-* @param options Override domain lists and thresholds.
-* @returns A {@link TypoSuggestion}, or `undefined` when nothing looks wrong.
-* @example
-* ```ts
-* import { suggestEmailTypo } from "@visulima/email-verifier/enrich/typo";
-*
-* suggestEmailTypo("user@gmial.com")?.full; // "user@gmail.com"
-* ```
-*/
+ * Suggests a corrected email address when the domain looks misspelled
+ * (e.g. `user@gmial.com` → `user@gmail.com`).
+ * @param email The email address to check.
+ * @param options Override domain lists and thresholds.
+ * @returns A {@link TypoSuggestion}, or `undefined` when nothing looks wrong.
+ * @example
+ * ```ts
+ * import { suggestEmailTypo } from "@visulima/email-verifier/enrich/typo";
+ *
+ * suggestEmailTypo("user@gmial.com")?.full; // "user@gmail.com"
+ * ```
+ */
 declare const suggestEmailTypo: (email: string, options?: TypoOptions) => TypoSuggestion | undefined;
 export { type TypoOptions, type TypoSuggestion, suggestEmailTypo as default, sift3Distance, suggestDomain, suggestEmailTypo };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { type CharacterResult, analyzeCharacters } from "./checks/character.js";
 export { type DisposableEmailOptions, areDisposableEmails, isDisposableDomain, isDisposableEmail } from '@visulima/disposable-email-domains';
 export { type FreeEmailOptions, areFreeEmails, isFreeDomain, isFreeEmail } from '@visulima/free-email-domains';
-export { type C as Cache, I as InMemoryCache, type a as InMemoryCacheOptions, type M as MxCheckOptions, type b as MxCheckResult, type c as MxRecord, type d as MxResolution, e as checkMxRecords } from "./packem_shared/mx.d-NAesS5sg.js";
+export { type C as Cache, I as InMemoryCache, type a as InMemoryCacheOptions, type M as MxCheckOptions, type b as MxCheckResult, type c as MxRecord, type d as MxResolution, e as checkMxRecords } from "./packem_shared/mx.d-HxIDdxvR.js";
 export { NO_REPLY_PREFIXES, ROLE_ACCOUNT_PREFIXES, isNoReply, default as isRoleAccount } from "./checks/role.js";
 export { type SmtpVerificationOptions, type SmtpVerificationResult, default as verifySmtp } from "./checks/smtp.js";
 export { type SymbolResult, analyzeSymbols } from "./checks/symbol.js";
@@ -10,12 +10,12 @@ export { type TagResult, default as detectTag } from "./checks/tag.js";
 export { type NameResult, default as parseName } from "./enrich/name.js";
 export { type ProviderDetails, type ProviderEnrichOptions, default as enrichProvider } from "./enrich/provider.js";
 export { type TypoOptions, type TypoSuggestion, sift3Distance, suggestDomain, default as suggestEmailTypo } from "./enrich/typo.js";
-export { D as DEFAULT_WEIGHTS, type a as DomainReport, type E as EmailVerificationReport, type S as ScoreInput, type b as ScoreResult, type c as ScoreWeights, type V as VerificationState, s as scoreReport } from "./packem_shared/score.d-BTcZnl2L.js";
+export { D as DEFAULT_WEIGHTS, type a as DomainReport, type E as EmailVerificationReport, type S as ScoreInput, type b as ScoreResult, type c as ScoreWeights, type V as VerificationState, s as scoreReport } from "./packem_shared/score.d-a6cl6fPu.js";
 export { type VerifyEmailOptions, default as verifyEmail } from "./verify-email.js";
 export { type MxProviderInfo, classifyMx, classifyMxRecords, isSecureEmailGateway } from '@visulima/email-provider-mx';
 /**
-* The split parts of an email address.
-*/
+ * The split parts of an email address.
+ */
 interface AddressParts {
   /** The full normalized (lowercased, trimmed) address. */
   address: string;
@@ -25,21 +25,21 @@ interface AddressParts {
   localPart: string;
 }
 /**
-* Splits an email address into its normalized local and domain parts.
-*
-* Uses the last `@` as the separator so quoted local parts containing `@` are
-* handled the same way the SMTP/MX probes treat them. Inputs containing
-* whitespace (after trimming) are rejected so a payload that embeds a CRLF
-* followed by a second SMTP command cannot be smuggled into the SMTP dialogue
-* by callers of the standalone probes.
-* @param email The email address to split.
-* @returns The normalized parts, or `undefined` if the address is structurally invalid.
-*/
+ * Splits an email address into its normalized local and domain parts.
+ *
+ * Uses the last `@` as the separator so quoted local parts containing `@` are
+ * handled the same way the SMTP/MX probes treat them. Inputs containing
+ * whitespace (after trimming) are rejected so a payload that embeds a CRLF
+ * followed by a second SMTP command cannot be smuggled into the SMTP dialogue
+ * by callers of the standalone probes.
+ * @param email The email address to split.
+ * @returns The normalized parts, or `undefined` if the address is structurally invalid.
+ */
 declare const splitAddress: (email: string) => AddressParts | undefined;
 /**
-* Extracts and normalizes just the domain from an email address.
-* @param email The email address to extract the domain from.
-* @returns The normalized domain, or `undefined` if invalid.
-*/
+ * Extracts and normalizes just the domain from an email address.
+ * @param email The email address to extract the domain from.
+ * @returns The normalized domain, or `undefined` if invalid.
+ */
 declare const extractDomain: (email: string) => string | undefined;
 export { type AddressParts, extractDomain, splitAddress };

package/dist/packem_shared/mx.d-HxIDdxvR.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Generic cache interface for caching any type of data.
+ * Implementations can use in-memory cache, LRU cache, Redis, etc.
+ */
+interface Cache<T = unknown> {
+  /**
+   * Clears all cached entries.
+   */
+  clear: () => Promise<void>;
+  /**
+   * Deletes a cached entry.
+   * @param key The cache key.
+   */
+  delete: (key: string) => Promise<void>;
+  /**
+   * Gets a cached value.
+   * @param key The cache key.
+   * @returns The cached value or undefined if not found or expired.
+   */
+  get: (key: string) => Promise<T | undefined>;
+  /**
+   * Sets a cached value.
+   * @param key The cache key.
+   * @param value The value to cache.
+   * @param ttl Time-to-live in milliseconds.
+   */
+  set: (key: string, value: T, ttl: number) => Promise<void>;
+}
+/**
+ * Options for creating an in-memory cache.
+ */
+interface InMemoryCacheOptions {
+  /**
+   * Maximum number of entries in the cache.
+   * @default 500
+   */
+  max?: number;
+  /**
+   * Default TTL in milliseconds for entries.
+   * @default 3600000 (1 hour)
+   */
+  ttl?: number;
+}
+/**
+ * Default in-memory cache implementation using LRU cache.
+ *
+ * Shared by the MX and SMTP probes so repeated lookups against the same domain
+ * (e.g. when verifying a list) avoid redundant DNS/socket work.
+ */
+declare class InMemoryCache<T extends object = Record<string, unknown>> implements Cache<T> {
+  private readonly cache;
+  constructor(options?: InMemoryCacheOptions);
+  clear: () => Promise<void>;
+  delete: (key: string) => Promise<void>;
+  get: (key: string) => Promise<T | undefined>;
+  set: (key: string, value: T, ttl: number) => Promise<void>;
+}
+/**
+ * MX record information.
+ */
+interface MxRecord {
+  exchange: string;
+  priority: number;
+}
+/**
+ * How the domain's mail-acceptance was established.
+ *
+ * - `mx`: the domain published MX records.
+ * - `address`: the domain has no MX but resolves to an A/AAAA record, so by RFC 5321 §5.1 the address itself is treated as an implicit MX.
+ * - `none`: neither MX nor address records exist.
+ */
+type MxResolution = "address" | "mx" | "none";
+/**
+ * Result of an MX/domain check.
+ */
+interface MxCheckResult {
+  /**
+   * True when the lookup was inconclusive because of a transient DNS failure
+   * (timeout, SERVFAIL, refused, …) rather than a definitive "no records"
+   * answer. Such a result is neither cached nor treated as undeliverable.
+   */
+  deferred?: boolean;
+  /** True when the domain itself resolves but publishes no MX records. */
+  domainResolves: boolean;
+  error?: string;
+  records?: MxRecord[];
+  resolvedVia: MxResolution;
+  /** True when the domain can accept mail (has MX or A/AAAA records). */
+  valid: boolean;
+}
+/**
+ * Options for MX record checking.
+ */
+interface MxCheckOptions {
+  cache?: Cache<MxCheckResult>;
+  /**
+   * When true (the default), a domain with no MX records but a resolvable
+   * A/AAAA record is still considered able to accept mail (implicit MX).
+   */
+  fallbackToAddress?: boolean;
+  ttl?: number;
+}
+declare const checkMxRecords: (domain: string, options?: MxCheckOptions) => Promise<MxCheckResult>;
+export { Cache as C, InMemoryCache as I, MxCheckOptions as M, InMemoryCacheOptions as a, MxCheckResult as b, MxRecord as c, MxResolution as d, checkMxRecords as e };

package/dist/packem_shared/{score.d-BTcZnl2L.d.ts → score.d-a6cl6fPu.d.ts}

@@ -1,23 +1,29 @@
 import { CharacterResult } from "../checks/character.js";
-import { c as MxRecord, d as MxResolution } from "./mx.d-NAesS5sg.js";
+import { c as MxRecord, d as MxResolution } from "./mx.d-HxIDdxvR.js";
 import { SmtpVerificationResult } from "../checks/smtp.js";
 import { SymbolResult } from "../checks/symbol.js";
 import { TagResult } from "../checks/tag.js";
 import { NameResult } from "../enrich/name.js";
 import { MxProviderInfo } from '@visulima/email-provider-mx';
 /**
-* The overall deliverability verdict for an address, mirroring emailable's states.
-*
-* - `deliverable`: the mailbox almost certainly exists and accepts mail.
-* - `risky`: deliverable but lower-quality (catch-all, role, disposable, full mailbox).
-* - `undeliverable`: syntax/domain/mailbox failure — do not send.
-* - `unknown`: could not be determined (SMTP blocked, greylisted, or not probed).
-*/
+ * The overall deliverability verdict for an address, mirroring emailable's states.
+ *
+ * - `deliverable`: the mailbox almost certainly exists and accepts mail.
+ * - `risky`: deliverable but lower-quality (catch-all, role, disposable, full mailbox).
+ * - `undeliverable`: syntax/domain/mailbox failure — do not send.
+ * - `unknown`: could not be determined (SMTP blocked, greylisted, or not probed).
+ */
 type VerificationState = "deliverable" | "risky" | "undeliverable" | "unknown";
 /**
-* The resolved domain portion of a verification report.
-*/
+ * The resolved domain portion of a verification report.
+ */
 interface DomainReport {
+  /**
+   * True when the domain lookup was inconclusive because of a transient DNS
+   * failure (timeout, SERVFAIL, refused). The domain is neither confirmed nor
+   * proven undeliverable — treat as `unknown`.
+   */
+  deferred?: boolean;
   /** The MX records found (empty when resolved via A/AAAA or not at all). */
   records: MxRecord[];
   /** How mail-acceptance was established (`unchecked` when DNS was skipped). */
@@ -26,11 +32,11 @@ interface DomainReport {
   valid: boolean;
 }
 /**
-* A complete email verification + enrichment report.
-*
-* Aggregates every check and enrichment into a single object whose shape reads
-* as a drop-in mental model for emailable's API response.
-*/
+ * A complete email verification + enrichment report.
+ *
+ * Aggregates every check and enrichment into a single object whose shape reads
+ * as a drop-in mental model for emailable's API response.
+ */
 interface EmailVerificationReport {
   /** True when the SMTP server accepts any recipient (catch-all / accept-all). */
   acceptAll: boolean;
@@ -76,16 +82,16 @@ interface EmailVerificationReport {
   tag: TagResult;
 }
 /**
-* The fields of a report the scorer consumes (everything except the derived
-* `score`, `state`, and `reason`).
-*/
+ * The fields of a report the scorer consumes (everything except the derived
+ * `score`, `state`, and `reason`).
+ */
 type ScoreInput = Omit<EmailVerificationReport, "reason" | "score" | "state">;
 /**
-* Overridable penalty/bonus weights for the quality score.
-*
-* Each value is points applied to a 100-point baseline. Penalties are positive
-* numbers that get subtracted; bonuses are added.
-*/
+ * Overridable penalty/bonus weights for the quality score.
+ *
+ * Each value is points applied to a 100-point baseline. Penalties are positive
+ * numbers that get subtracted; bonuses are added.
+ */
 interface ScoreWeights {
   acceptAll: number;
   character: number;
@@ -102,33 +108,33 @@ interface ScoreWeights {
   symbol: number;
 }
 /**
-* The default scoring rubric. Transparent and additive so callers can reason
-* about — and override — every weight.
-*/
+ * The default scoring rubric. Transparent and additive so callers can reason
+ * about — and override — every weight.
+ */
 declare const DEFAULT_WEIGHTS: ScoreWeights;
 /**
-* The outcome of scoring: the numeric score plus the derived state and reason.
-*/
+ * The outcome of scoring: the numeric score plus the derived state and reason.
+ */
 interface ScoreResult {
   reason: string;
   score: number;
   state: VerificationState;
 }
 /**
-* Computes a 0–100 quality score and the deliverability state for a report.
-*
-* The state is derived from hard signals (syntax, domain, SMTP verdict); the
-* score layers transparent penalties/bonuses on top so two `risky` addresses can
-* still be ranked against each other.
-* @param input The verification signals (a report without its derived fields).
-* @param weights Optional weight overrides.
-* @returns The score, state, and reason.
-* @example
-* ```ts
-* import { scoreReport } from "@visulima/email-verifier/score";
-*
-* const { score, state } = scoreReport(report);
-* ```
-*/
+ * Computes a 0–100 quality score and the deliverability state for a report.
+ *
+ * The state is derived from hard signals (syntax, domain, SMTP verdict); the
+ * score layers transparent penalties/bonuses on top so two `risky` addresses can
+ * still be ranked against each other.
+ * @param input The verification signals (a report without its derived fields).
+ * @param weights Optional weight overrides.
+ * @returns The score, state, and reason.
+ * @example
+ * ```ts
+ * import { scoreReport } from "@visulima/email-verifier/score";
+ *
+ * const { score, state } = scoreReport(report);
+ * ```
+ */
 declare const scoreReport: (input: ScoreInput, weights?: Partial<ScoreWeights>) => ScoreResult;
 export { DEFAULT_WEIGHTS as D, EmailVerificationReport as E, ScoreInput as S, VerificationState as V, DomainReport as a, ScoreResult as b, ScoreWeights as c, scoreReport as s };

package/dist/score.d.ts

@@ -1,6 +1,6 @@
-export { D as DEFAULT_WEIGHTS, type S as ScoreInput, type b as ScoreResult, type c as ScoreWeights, s as default, s as scoreReport } from "./packem_shared/score.d-BTcZnl2L.js";
+export { D as DEFAULT_WEIGHTS, type S as ScoreInput, type b as ScoreResult, type c as ScoreWeights, s as default, s as scoreReport } from "./packem_shared/score.d-a6cl6fPu.js";
 import "./checks/character.js";
-import "./packem_shared/mx.d-NAesS5sg.js";
+import "./packem_shared/mx.d-HxIDdxvR.js";
 import "./checks/smtp.js";
 import "./checks/symbol.js";
 import "./checks/tag.js";

package/dist/score.js

@@ -1 +1 @@
-const t={acceptAll:25,character:15,deferred:15,didYouMean:20,disposable:60,free:5,knownProvider:5,mailboxFull:40,mixedScripts:30,noReply:25,role:25,smtpUnverified:10,symbol:10},i=e=>Math.max(0,Math.min(100,Math.round(e))),n=e=>e.smtp!==void 0&&!e.smtp.valid&&!e.smtp.deferred&&!e.mailboxFull&&(e.smtp.code??0)>=500,d=e=>e.disposable?{reason:"disposable_mailbox",state:"risky"}:e.mailboxFull?{reason:"mailbox_full",state:"risky"}:e.acceptAll?{reason:"accept_all",state:"risky"}:e.noReply?{reason:"no_reply",state:"risky"}:e.role?{reason:"role_account",state:"risky"}:{reason:"accepted_email",state:"deliverable"},m=e=>n(e)?{reason:"rejected_email",state:"undeliverable"}:e.smtp?.valid?d(e):e.mailboxFull?{reason:"mailbox_full",state:"risky"}:e.smtp?.deferred?{reason:"greylisted",state:"unknown"}:{reason:"unknown",state:"unknown"},c=e=>e.syntaxValid?e.domain.resolvedVia!=="unchecked"&&!e.domain.valid?{reason:e.domain.resolvedVia==="none"?"no_mx_records":"invalid_domain",state:"undeliverable"}:e.smtp?m(e):e.disposable?{reason:"disposable_mailbox",state:"risky"}:{reason:"smtp_not_checked",state:"unknown"}:{reason:"invalid_syntax",state:"undeliverable"},p=(e,o={})=>{const s={...t,...o},{reason:l,state:r}=c(e);if(r==="undeliverable")return{reason:l,score:0,state:r};let a=100;return e.smtp?.valid!==!0&&(a-=s.smtpUnverified),e.deferred&&(a-=s.deferred),e.disposable&&(a-=s.disposable),e.acceptAll&&(a-=s.acceptAll),e.mailboxFull&&(a-=s.mailboxFull),e.role&&(a-=s.role),e.noReply&&(a-=s.noReply),e.free&&(a-=s.free),e.character.irregular&&(a-=s.character),e.symbol.hasMixedScripts?a-=s.mixedScripts:e.symbol.hasSymbols&&(a-=s.symbol),e.didYouMean&&(a-=s.didYouMean),e.provider&&(a+=s.knownProvider),{reason:l,score:i(a),state:r}};export{t as DEFAULT_WEIGHTS,p as default,p as scoreReport};
+const t={acceptAll:25,character:15,deferred:15,didYouMean:20,disposable:60,free:5,knownProvider:5,mailboxFull:40,mixedScripts:30,noReply:25,role:25,smtpUnverified:10,symbol:10},n=e=>Math.max(0,Math.min(100,Math.round(e))),i=e=>e.smtp!==void 0&&!e.smtp.valid&&!e.smtp.deferred&&!e.mailboxFull&&(e.smtp.code??0)>=500,d=e=>e.disposable?{reason:"disposable_mailbox",state:"risky"}:e.mailboxFull?{reason:"mailbox_full",state:"risky"}:e.acceptAll?{reason:"accept_all",state:"risky"}:e.noReply?{reason:"no_reply",state:"risky"}:e.role?{reason:"role_account",state:"risky"}:{reason:"accepted_email",state:"deliverable"},m=e=>i(e)?{reason:"rejected_email",state:"undeliverable"}:e.smtp?.valid?d(e):e.mailboxFull?{reason:"mailbox_full",state:"risky"}:e.smtp?.deferred?{reason:"greylisted",state:"unknown"}:{reason:"unknown",state:"unknown"},c=e=>e.syntaxValid?e.domain.resolvedVia!=="unchecked"&&!e.domain.valid?e.domain.deferred?{reason:"dns_error",state:"unknown"}:{reason:e.domain.resolvedVia==="none"?"no_mx_records":"invalid_domain",state:"undeliverable"}:e.smtp?m(e):e.disposable?{reason:"disposable_mailbox",state:"risky"}:{reason:"smtp_not_checked",state:"unknown"}:{reason:"invalid_syntax",state:"undeliverable"},p=(e,l={})=>{const s={...t,...l},{reason:o,state:r}=c(e);if(r==="undeliverable")return{reason:o,score:0,state:r};let a=100;return e.smtp?.valid!==!0&&(a-=s.smtpUnverified),e.deferred&&(a-=s.deferred),e.disposable&&(a-=s.disposable),e.acceptAll&&(a-=s.acceptAll),e.mailboxFull&&(a-=s.mailboxFull),e.role&&(a-=s.role),e.noReply&&(a-=s.noReply),e.free&&(a-=s.free),e.character.irregular&&(a-=s.character),e.symbol.hasMixedScripts?a-=s.mixedScripts:e.symbol.hasSymbols&&(a-=s.symbol),e.didYouMean&&(a-=s.didYouMean),e.provider&&(a+=s.knownProvider),{reason:o,score:n(a),state:r}};export{t as DEFAULT_WEIGHTS,p as default,p as scoreReport};

package/dist/verify-email.d.ts

@@ -1,35 +1,35 @@
 import { DisposableEmailOptions } from '@visulima/disposable-email-domains';
 import { FreeEmailOptions } from '@visulima/free-email-domains';
-import { b as MxCheckResult, C as Cache } from "./packem_shared/mx.d-NAesS5sg.js";
+import { b as MxCheckResult, C as Cache } from "./packem_shared/mx.d-HxIDdxvR.js";
 import { SmtpVerificationOptions } from "./checks/smtp.js";
 import { TypoOptions } from "./enrich/typo.js";
-import { c as ScoreWeights, E as EmailVerificationReport } from "./packem_shared/score.d-BTcZnl2L.js";
-export type { V as VerificationState } from "./packem_shared/score.d-BTcZnl2L.js";
+import { c as ScoreWeights, E as EmailVerificationReport } from "./packem_shared/score.d-a6cl6fPu.js";
+export type { V as VerificationState } from "./packem_shared/score.d-a6cl6fPu.js";
 import "./checks/character.js";
 import "./checks/symbol.js";
 import "./checks/tag.js";
 import "./enrich/name.js";
 import '@visulima/email-provider-mx';
 /**
-* Options for `verifyEmail`.
-*/
+ * Options for `verifyEmail`.
+ */
 interface VerifyEmailOptions {
   /** Shared cache for MX/SMTP lookups (dedupes work when verifying lists). */
   cache?: Cache<MxCheckResult>;
   /**
-  * Run live SMTP verification (catch-all, mailbox-full, greylist).
-  * @default true
-  */
+   * Run live SMTP verification (catch-all, mailbox-full, greylist).
+   * @default true
+   */
   checkSmtp?: boolean;
   /** Disposable-list overrides. */
   disposable?: DisposableEmailOptions;
   /** Free-list overrides. */
   free?: FreeEmailOptions;
   /**
-  * Skip all network checks (MX, SMTP, provider) and produce a syntax +
-  * heuristic-only report. Overrides `checkSmtp`.
-  * @default false
-  */
+   * Skip all network checks (MX, SMTP, provider) and produce a syntax +
+   * heuristic-only report. Overrides `checkSmtp`.
+   * @default false
+   */
   offline?: boolean;
   /** Additional role-account prefixes to recognize. */
   roleCustomPrefixes?: Iterable<string>;
@@ -41,22 +41,22 @@ interface VerifyEmailOptions {
   weights?: Partial<ScoreWeights>;
 }
 /**
-* Verifies and enriches a single email address end-to-end.
-*
-* Runs the offline checks (syntax, disposable, free, role, tag, character,
-* symbol, name, typo) immediately, then — unless `offline` is set — resolves the
-* domain's MX and runs the SMTP probe and provider classification concurrently.
-* Everything is aggregated into one {@link EmailVerificationReport} and scored.
-* @param email The email address to verify.
-* @param options Verification options.
-* @returns The complete verification report.
-* @example
-* ```ts
-* import { verifyEmail } from "@visulima/email-verifier";
-*
-* const report = await verifyEmail("user@gmail.com");
-* console.log(report.state, report.score); // "deliverable" 95
-* ```
-*/
+ * Verifies and enriches a single email address end-to-end.
+ *
+ * Runs the offline checks (syntax, disposable, free, role, tag, character,
+ * symbol, name, typo) immediately, then — unless `offline` is set — resolves the
+ * domain's MX and runs the SMTP probe and provider classification concurrently.
+ * Everything is aggregated into one {@link EmailVerificationReport} and scored.
+ * @param email The email address to verify.
+ * @param options Verification options.
+ * @returns The complete verification report.
+ * @example
+ * ```ts
+ * import { verifyEmail } from "@visulima/email-verifier";
+ *
+ * const report = await verifyEmail("user@gmail.com");
+ * console.log(report.state, report.score); // "deliverable" 95
+ * ```
+ */
 declare const verifyEmail: (email: string, options?: VerifyEmailOptions) => Promise<EmailVerificationReport>;
 export { type EmailVerificationReport, type VerifyEmailOptions, verifyEmail as default, verifyEmail };

package/dist/verify-email.js

@@ -1 +1 @@
-import{analyzeCharacters as h}from"./checks/character.js";import{checkMxRecords as v}from"./checks/mx.js";import x,{isNoReply as b}from"./checks/role.js";import g from"./checks/smtp.js";import{analyzeSymbols as w}from"./checks/symbol.js";import V from"./checks/syntax.js";import E from"./checks/tag.js";import R from"./enrich/name.js";import $ from"./enrich/typo.js";import{splitAddress as k}from"./packem_shared/extractDomain-CYJf1_0N.js";import f from"./score.js";import{classifyMxRecords as A}from"@visulima/email-provider-mx";import{isFreeEmail as F}from"@visulima/free-email-domains";import{isDisposableEmail as C}from"@visulima/disposable-email-domains";const p=(e,a)=>({character:h(e),didYouMean:$(e,a.typo)?.full,disposable:C(e,a.disposable),free:F(e,a.free),name:R(e),noReply:b(e),role:x(e,a.roleCustomPrefixes),symbol:w(e),tag:E(e)}),J=async(e,a={})=>{const{checkSmtp:n=!0,offline:y=!1}=a,o=k(e),t=o?.address??(typeof e=="string"?e.trim().toLowerCase():"");if(!V(e)||!o){const s={...p(t,a),acceptAll:!1,deferred:!1,domain:{records:[],resolvedVia:"unchecked",valid:!1},email:t,mailboxFull:!1,secureEmailGateway:!1,syntaxValid:!1};return{...s,...f(s,a.weights)}}const u=p(o.address,a);let m={records:[],resolvedVia:"unchecked",valid:!1},r,l,d=!1;if(!y){const s=await v(o.domain,{cache:a.cache});m={records:s.records??[],resolvedVia:s.resolvedVia,valid:s.valid};const i=s.records??[];s.valid&&i.length>0&&(l=A(i),d=l?.type==="seg",n&&(r=await g(o.address,{cache:a.cache,...a.smtp,mxRecords:i})))}const c={...u,acceptAll:r?.acceptAll??!1,deferred:r?.deferred??!1,domain:m,email:o.address,mailboxFull:r?.mailboxFull??!1,provider:l,secureEmailGateway:d,smtp:r,syntaxValid:!0};return{...c,...f(c,a.weights)}};export{J as default,J as verifyEmail};
+import{analyzeCharacters as h}from"./checks/character.js";import{checkMxRecords as v}from"./checks/mx.js";import x,{isNoReply as b}from"./checks/role.js";import g from"./checks/smtp.js";import{analyzeSymbols as w}from"./checks/symbol.js";import V from"./checks/syntax.js";import E from"./checks/tag.js";import R from"./enrich/name.js";import k from"./enrich/typo.js";import{splitAddress as A}from"./packem_shared/extractDomain-CYJf1_0N.js";import f from"./score.js";import{classifyMxRecords as F}from"@visulima/email-provider-mx";import{isFreeEmail as C}from"@visulima/free-email-domains";import{isDisposableEmail as M}from"@visulima/disposable-email-domains";const p=(e,a)=>({character:h(e),didYouMean:k(e,a.typo)?.full,disposable:M(e,a.disposable),free:C(e,a.free),name:R(e),noReply:b(e),role:x(e,a.roleCustomPrefixes),symbol:w(e),tag:E(e)}),J=async(e,a={})=>{const{checkSmtp:n=!0,offline:u=!1}=a,r=A(e),d=r?.address??(typeof e=="string"?e.trim().toLowerCase():"");if(!V(r?.address??e)||!r){const s={...p(d,a),acceptAll:!1,deferred:!1,domain:{records:[],resolvedVia:"unchecked",valid:!1},email:d,mailboxFull:!1,secureEmailGateway:!1,syntaxValid:!1};return{...s,...f(s,a.weights)}}const y=p(r.address,a);let t={records:[],resolvedVia:"unchecked",valid:!1},o,l,m=!1;if(!u){const s=await v(r.domain,{cache:a.cache});t={deferred:s.deferred,records:s.records??[],resolvedVia:s.resolvedVia,valid:s.valid};const i=s.records??[];s.valid&&i.length>0&&(l=F(i),m=l?.type==="seg",n&&(o=await g(r.address,{cache:a.cache,...a.smtp,mxRecords:i})))}const c={...y,acceptAll:o?.acceptAll??!1,deferred:o?.deferred??!1,domain:t,email:r.address,mailboxFull:o?.mailboxFull??!1,provider:l,secureEmailGateway:m,smtp:o,syntaxValid:!0};return{...c,...f(c,a.weights)}};export{J as default,J as verifyEmail};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/email-verifier",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Mailer-free email address verification and enrichment: syntax, MX/SMTP probing, disposable/free/role detection, catch-all, provider & secure-email-gateway classification, typo suggestions, and a 0–100 quality score.",
   "keywords": [
     "accept-all",
@@ -114,9 +114,9 @@
     "provenance": true
   },
   "dependencies": {
-    "@visulima/disposable-email-domains": "1.0.1",
-    "@visulima/email-provider-mx": "1.0.0",
-    "@visulima/free-email-domains": "1.0.0",
+    "@visulima/disposable-email-domains": "1.1.0",
+    "@visulima/email-provider-mx": "1.0.1",
+    "@visulima/free-email-domains": "1.0.1",
     "lru-cache": "11.5.1"
   },
   "engines": {

package/dist/packem_shared/mx.d-NAesS5sg.d.ts

@@ -1,117 +0,0 @@
-/**
-* Generic cache interface for caching any type of data.
-* Implementations can use in-memory cache, LRU cache, Redis, etc.
-*/
-interface Cache<T = unknown> {
-  /**
-  * Clears all cached entries.
-  */
-  clear: () => Promise<void>;
-  /**
-  * Deletes a cached entry.
-  * @param key The cache key.
-  */
-  delete: (key: string) => Promise<void>;
-  /**
-  * Gets a cached value.
-  * @param key The cache key.
-  * @returns The cached value or undefined if not found or expired.
-  */
-  get: (key: string) => Promise<T | undefined>;
-  /**
-  * Sets a cached value.
-  * @param key The cache key.
-  * @param value The value to cache.
-  * @param ttl Time-to-live in milliseconds.
-  */
-  set: (key: string, value: T, ttl: number) => Promise<void>;
-}
-/**
-* Options for creating an in-memory cache.
-*/
-interface InMemoryCacheOptions {
-  /**
-  * Maximum number of entries in the cache.
-  * @default 500
-  */
-  max?: number;
-  /**
-  * Default TTL in milliseconds for entries.
-  * @default 3600000 (1 hour)
-  */
-  ttl?: number;
-}
-/**
-* Default in-memory cache implementation using LRU cache.
-*
-* Shared by the MX and SMTP probes so repeated lookups against the same domain
-* (e.g. when verifying a list) avoid redundant DNS/socket work.
-*/
-declare class InMemoryCache<T extends object = Record<string, unknown>> implements Cache<T> {
-  private readonly cache;
-  constructor(options?: InMemoryCacheOptions);
-  clear: () => Promise<void>;
-  delete: (key: string) => Promise<void>;
-  get: (key: string) => Promise<T | undefined>;
-  set: (key: string, value: T, ttl: number) => Promise<void>;
-}
-/**
-* MX record information.
-*/
-interface MxRecord {
-  exchange: string;
-  priority: number;
-}
-/**
-* How the domain's mail-acceptance was established.
-*
-* - `mx`: the domain published MX records.
-* - `address`: the domain has no MX but resolves to an A/AAAA record, so by RFC 5321 §5.1 the address itself is treated as an implicit MX.
-* - `none`: neither MX nor address records exist.
-*/
-type MxResolution = "address" | "mx" | "none";
-/**
-* Result of an MX/domain check.
-*/
-interface MxCheckResult {
-  /** True when the domain itself resolves but publishes no MX records. */
-  domainResolves: boolean;
-  error?: string;
-  records?: MxRecord[];
-  resolvedVia: MxResolution;
-  /** True when the domain can accept mail (has MX or A/AAAA records). */
-  valid: boolean;
-}
-/**
-* Options for MX record checking.
-*/
-interface MxCheckOptions {
-  cache?: Cache<MxCheckResult>;
-  /**
-  * When true (the default), a domain with no MX records but a resolvable
-  * A/AAAA record is still considered able to accept mail (implicit MX).
-  */
-  fallbackToAddress?: boolean;
-  ttl?: number;
-}
-/**
-* Checks MX records for a domain, with an optional A/AAAA fallback.
-*
-* Distinguishes three states emailable separates as "MX Record Detection" and
-* "Domain Validation": records present (`mx`), no MX but the domain resolves
-* (`address`, implicit MX), and nothing resolves (`none`).
-* @param domain The domain to check.
-* @param options Options including caching and the address fallback toggle.
-* @returns The MX/domain check result.
-* @example
-* ```ts
-* import { checkMxRecords } from "@visulima/email-verifier/checks/mx";
-*
-* const result = await checkMxRecords("example.com");
-* if (result.valid) {
-*     console.log(result.resolvedVia, result.records);
-* }
-* ```
-*/
-declare const checkMxRecords: (domain: string, options?: MxCheckOptions) => Promise<MxCheckResult>;
-export { Cache as C, InMemoryCache as I, MxCheckOptions as M, InMemoryCacheOptions as a, MxCheckResult as b, MxRecord as c, MxResolution as d, checkMxRecords as e };