@emailcheck/email-validator-js 3.0.1-beta.0 → 3.0.1-beta.2

package/dist/index.esm.js

@@ -1,7 +1,7 @@
 import { isValid, parse } from 'psl';
 import { lru } from 'tiny-lru';
-import { promises } from 'node:dns';
 import { stringSimilarity } from 'string-similarity-js';
+import { promises } from 'node:dns';
 import * as net from 'node:net';
 import * as tls from 'node:tls';
 
@@ -44,31 +44,23 @@ class LRUAdapter {
 const DEFAULT_CACHE_OPTIONS = {
   ttl: {
     mx: 36e5,
-    // 1 hour
     disposable: 864e5,
-    // 24 hours
     free: 864e5,
-    // 24 hours
     domainValid: 864e5,
-    // 24 hours
     smtp: 18e5,
-    // 30 minutes
-    smtpPort: 36e5,
-    // 1 hour
+    smtpPort: 864e5,
     domainSuggestion: 864e5,
-    // 24 hours
     whois: 36e5
-    // 1 hour
   },
   maxSize: {
-    mx: 500,
-    disposable: 1e3,
-    free: 1e3,
-    domainValid: 1e3,
-    smtp: 500,
-    smtpPort: 500,
-    domainSuggestion: 1e3,
-    whois: 200
+    mx: 1e4,
+    disposable: 1e4,
+    free: 1e4,
+    domainValid: 1e4,
+    smtp: 1e4,
+    smtpPort: 1e4,
+    domainSuggestion: 1e4,
+    whois: 1e4
   }
 };
 let defaultCacheInstance = null;
@@ -106,41 +98,7 @@ function resetDefaultCache() {
   defaultCacheInstance = null;
 }
 
-async function resolveMxRecords(params) {
-  const { domain, cache, logger } = params;
-  const log = logger || (() => {
-  });
-  const cacheStore = getCacheStore(cache, "mx");
-  const cached = await cacheStore.get(domain);
-  if (cached !== null && cached !== void 0) {
-    log(`[resolveMxRecords] Cache hit for ${domain}: ${cached.length} MX records`);
-    return cached;
-  }
-  log(`[resolveMxRecords] Performing DNS MX lookup for ${domain}`);
-  try {
-    const records = await promises.resolveMx(domain);
-    records.sort((a, b) => {
-      if (a.priority < b.priority) {
-        return -1;
-      }
-      if (a.priority > b.priority) {
-        return 1;
-      }
-      return 0;
-    });
-    const exchanges = records.map((record) => record.exchange);
-    log(`[resolveMxRecords] Found ${exchanges.length} MX records for ${domain}: [${exchanges.join(", ")}]`);
-    await cacheStore.set(domain, exchanges);
-    log(`[resolveMxRecords] Cached ${exchanges.length} MX records for ${domain}`);
-    return exchanges;
-  } catch (error) {
-    log(`[resolveMxRecords] MX lookup failed for ${domain}, caching empty result`);
-    await cacheStore.set(domain, []);
-    throw error;
-  }
-}
-
-const COMMON_EMAIL_DOMAINS = [
+const commonEmailDomains = [
   // Popular free email providers
   "gmail.com",
   "yahoo.com",
@@ -225,7 +183,7 @@ function getSimilarityThreshold(domain) {
   return 0.75;
 }
 function defaultDomainSuggestionMethod(domain, commonDomains) {
-  const domainsToCheck = commonDomains || COMMON_EMAIL_DOMAINS;
+  const domainsToCheck = commonDomains || commonEmailDomains;
   const lowerDomain = domain.toLowerCase();
   if (domainsToCheck.includes(lowerDomain)) {
     return null;
@@ -281,7 +239,7 @@ async function defaultDomainSuggestionMethodImpl(domain, commonDomains, cache) {
   if (!domain || domain.length < 3) {
     return null;
   }
-  const domainsToCheck = commonDomains || COMMON_EMAIL_DOMAINS;
+  const domainsToCheck = commonDomains || commonEmailDomains;
   const lowerDomain = domain.toLowerCase();
   const cacheKey = `${lowerDomain}:${domainsToCheck.length}`;
   const cacheStore = getCacheStore(cache, "domainSuggestion");
@@ -377,15 +335,107 @@ async function suggestEmailDomain(email, commonDomains, cache) {
   return null;
 }
 function isCommonDomain(domain, commonDomains) {
-  const domainsToCheck = commonDomains || COMMON_EMAIL_DOMAINS;
+  const domainsToCheck = commonDomains || commonEmailDomains;
   return domainsToCheck.includes(domain.toLowerCase());
 }
 function getDomainSimilarity(domain1, domain2) {
   return stringSimilarity(domain1.toLowerCase(), domain2.toLowerCase());
 }
 
-const NAME_SEPARATORS = [".", "_", "-"];
-const COMMON_NAME_SUFFIXES = [
+async function isValidEmailDomain(emailOrDomain, cache) {
+  let [localPart, emailDomain] = (emailOrDomain === null || emailOrDomain === void 0 ? void 0 : emailOrDomain.split("@")) || [];
+  if (!emailDomain) {
+    emailDomain = localPart;
+  }
+  if (!emailDomain) {
+    return false;
+  }
+  const cacheStore = getCacheStore(cache, "domainValid");
+  const cached = await cacheStore.get(emailDomain);
+  if (cached !== null && cached !== void 0) {
+    return cached.isValid;
+  }
+  try {
+    const isValidResult = isValid(emailDomain) || false;
+    const richResult = {
+      isValid: isValidResult,
+      hasMX: false,
+      // MX not checked in this function
+      checkedAt: Date.now()
+    };
+    await cacheStore.set(emailDomain, richResult);
+    return isValidResult;
+  } catch (validationError) {
+    const errorResult = {
+      isValid: false,
+      hasMX: false,
+      checkedAt: Date.now()
+    };
+    await cacheStore.set(emailDomain, errorResult);
+    return false;
+  }
+}
+function isValidEmail(emailAddress) {
+  if (!emailAddress || typeof emailAddress !== "string") {
+    return false;
+  }
+  const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
+  const emailLower = emailAddress.toLowerCase();
+  if (emailLower.indexOf(".+") !== -1)
+    return false;
+  if (emailLower.indexOf("..") !== -1)
+    return false;
+  if (emailLower.startsWith(".") || emailLower.endsWith("."))
+    return false;
+  const parts = emailAddress.split("@");
+  if (parts.length !== 2)
+    return false;
+  const [localPart, domain] = parts;
+  if (!localPart || !domain)
+    return false;
+  if (localPart.length > 64)
+    return false;
+  if (domain.length > 253)
+    return false;
+  return re.test(emailLower);
+}
+
+async function resolveMxRecords(params) {
+  const { domain, cache, logger } = params;
+  const log = logger || (() => {
+  });
+  const cacheStore = getCacheStore(cache, "mx");
+  const cached = await cacheStore.get(domain);
+  if (cached !== null && cached !== void 0) {
+    log(`[resolveMxRecords] Cache hit for ${domain}: ${cached === null || cached === void 0 ? void 0 : cached.length} MX records`);
+    return cached;
+  }
+  log(`[resolveMxRecords] Performing DNS MX lookup for ${domain}`);
+  try {
+    const records = await promises.resolveMx(domain);
+    records === null || records === void 0 ? void 0 : records.sort((a, b) => {
+      if (a.priority < b.priority) {
+        return -1;
+      }
+      if (a.priority > b.priority) {
+        return 1;
+      }
+      return 0;
+    });
+    const exchanges = records === null || records === void 0 ? void 0 : records.map((record) => record.exchange);
+    log(`[resolveMxRecords] Found ${exchanges === null || exchanges === void 0 ? void 0 : exchanges.length} MX records for ${domain}: [${exchanges === null || exchanges === void 0 ? void 0 : exchanges.join(", ")}]`);
+    await cacheStore.set(domain, exchanges);
+    log(`[resolveMxRecords] Cached ${exchanges === null || exchanges === void 0 ? void 0 : exchanges.length} MX records for ${domain}`);
+    return exchanges;
+  } catch (error) {
+    log(`[resolveMxRecords] MX lookup failed for ${domain}, caching empty result`);
+    await cacheStore.set(domain, []);
+    throw error;
+  }
+}
+
+const nameSeparator = [".", "_", "-"];
+const commonNameSuffixes = [
   "mail",
   "email",
   "contact",
@@ -400,7 +450,7 @@ const COMMON_NAME_SUFFIXES = [
   "notifications",
   "alerts"
 ];
-const CONTEXTUAL_SUFFIXES = [
+const contextualSuffixes = [
   "dev",
   "company",
   "team",
@@ -432,7 +482,7 @@ const COMMON_TITLES = [
   "father",
   "sister"
 ];
-const COMMON_FIRST_NAMES = /* @__PURE__ */ new Set([
+const commonFirstName = /* @__PURE__ */ new Set([
   // English names
   "james",
   "john",
@@ -610,7 +660,7 @@ const COMMON_FIRST_NAMES = /* @__PURE__ */ new Set([
   "sekou",
   "mariama"
 ]);
-const COMMON_LAST_NAMES = /* @__PURE__ */ new Set([
+const commonLastName = /* @__PURE__ */ new Set([
   // English surnames
   "smith",
   "johnson",
@@ -730,19 +780,19 @@ function isYearLike(str) {
   return /^(19|20)\d{2}$/.test(str);
 }
 function isKnownFirstName(str) {
-  return COMMON_FIRST_NAMES.has(str.toLowerCase());
+  return commonFirstName.has(str.toLowerCase());
 }
 function isKnownLastName(str) {
-  return COMMON_LAST_NAMES.has(str.toLowerCase());
+  return commonLastName.has(str.toLowerCase());
 }
 function isTitle(str) {
   return COMMON_TITLES.includes(str.toLowerCase().replace(".", ""));
 }
 function getFirstNameScore(str) {
   const lower = str.toLowerCase();
-  if (COMMON_FIRST_NAMES.has(lower))
+  if (commonFirstName.has(lower))
     return 1;
-  if (COMMON_LAST_NAMES.has(lower))
+  if (commonLastName.has(lower))
     return 0.3;
   if (str.length >= 2 && str.length <= 15 && /^[a-zA-Z]+$/.test(str))
     return 0.5;
@@ -750,9 +800,9 @@ function getFirstNameScore(str) {
 }
 function getLastNameScore(str) {
   const lower = str.toLowerCase();
-  if (COMMON_LAST_NAMES.has(lower))
+  if (commonLastName.has(lower))
     return 1;
-  if (COMMON_FIRST_NAMES.has(lower))
+  if (commonFirstName.has(lower))
     return 0.3;
   if (str.length >= 2 && str.length <= 20 && /^[a-zA-Z]+$/.test(str))
     return 0.5;
@@ -861,7 +911,7 @@ function isLikelyName(str, allowNumbers = false, allowSingleLetter = false) {
     return false;
   if (str.length === 1 && allowSingleLetter && /^[a-zA-Z]$/.test(str))
     return true;
-  if (COMMON_NAME_SUFFIXES.includes(str.toLowerCase()))
+  if (commonNameSuffixes.includes(str.toLowerCase()))
     return false;
   if (allowNumbers) {
     if (/^\d+$/.test(str))
@@ -923,7 +973,7 @@ function defaultNameDetectionMethod(email) {
     }
   }
   if (!firstName && !lastName) {
-    for (const separator of NAME_SEPARATORS) {
+    for (const separator of nameSeparator) {
       if (cleanedLocal.includes(separator)) {
         const parts = cleanedLocal.split(separator).filter((p) => p.length > 0);
         if (parts.length === 2) {
@@ -985,7 +1035,7 @@ function defaultNameDetectionMethod(email) {
           const firstParsed = parseCompositeNamePart(first);
           const middleParsed = parseCompositeNamePart(middle);
           const lastParsed = parseCompositeNamePart(last);
-          const isLastSuffix = COMMON_NAME_SUFFIXES.includes(last.toLowerCase()) || CONTEXTUAL_SUFFIXES.includes(last.toLowerCase()) || isYearLike(last);
+          const isLastSuffix = commonNameSuffixes.includes(last.toLowerCase()) || contextualSuffixes.includes(last.toLowerCase()) || isYearLike(last);
           if (isLastSuffix) {
             if (isLikelyName(first, true, true) && isLikelyName(middle, true, true)) {
               const cleanedFirst = firstParsed.hasNumbers ? firstParsed.cleaned : first;
@@ -1018,7 +1068,7 @@ function defaultNameDetectionMethod(email) {
         } else if (parts.length > 3) {
           const firstPart = parts[0];
           const lastPartLower = parts[parts.length - 1].toLowerCase();
-          const isLastPartSuffix = COMMON_NAME_SUFFIXES.includes(lastPartLower) || CONTEXTUAL_SUFFIXES.includes(lastPartLower) || isYearLike(parts[parts.length - 1]);
+          const isLastPartSuffix = commonNameSuffixes.includes(lastPartLower) || contextualSuffixes.includes(lastPartLower) || isYearLike(parts[parts.length - 1]);
           const effectiveLastIndex = isLastPartSuffix ? parts.length - 2 : parts.length - 1;
           const lastToUse = effectiveLastIndex >= 0 ? parts[effectiveLastIndex] : null;
           if (lastToUse && isLikelyName(firstPart, true, true) && isLikelyName(lastToUse, true, true)) {
@@ -1101,7 +1151,7 @@ function detectNameFromEmail(params) {
   }
   return defaultNameDetectionMethod(email);
 }
-function cleanNameForAlgrothin(name) {
+function cleanNameForAlgorithm(name) {
   if (!name)
     return "";
   let cleaned = name.replace(/[._*]/g, "");
@@ -1111,13 +1161,13 @@ function cleanNameForAlgrothin(name) {
   }
   return cleaned;
 }
-function detectNameForAlgrothin(email) {
+function detectNameForAlgorithm(email) {
   const detectedName = detectName(email);
   if (!detectedName) {
     return null;
   }
-  const cleanedFirstName = detectedName.firstName ? cleanNameForAlgrothin(detectedName.firstName) : void 0;
-  const cleanedLastName = detectedName.lastName ? cleanNameForAlgrothin(detectedName.lastName) : void 0;
+  const cleanedFirstName = detectedName.firstName ? cleanNameForAlgorithm(detectedName.firstName) : void 0;
+  const cleanedLastName = detectedName.lastName ? cleanNameForAlgorithm(detectedName.lastName) : void 0;
   if (!cleanedFirstName && !cleanedLastName) {
     return null;
   }
@@ -1134,27 +1184,143 @@ function detectName(email) {
 
 var VerificationErrorCode;
 (function(VerificationErrorCode2) {
-  VerificationErrorCode2["INVALID_FORMAT"] = "INVALID_FORMAT";
-  VerificationErrorCode2["INVALID_DOMAIN"] = "INVALID_DOMAIN";
-  VerificationErrorCode2["NO_MX_RECORDS"] = "NO_MX_RECORDS";
-  VerificationErrorCode2["SMTP_CONNECTION_FAILED"] = "SMTP_CONNECTION_FAILED";
-  VerificationErrorCode2["SMTP_TIMEOUT"] = "SMTP_TIMEOUT";
-  VerificationErrorCode2["MAILBOX_NOT_FOUND"] = "MAILBOX_NOT_FOUND";
-  VerificationErrorCode2["MAILBOX_FULL"] = "MAILBOX_FULL";
-  VerificationErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
-  VerificationErrorCode2["DISPOSABLE_EMAIL"] = "DISPOSABLE_EMAIL";
-  VerificationErrorCode2["FREE_EMAIL_PROVIDER"] = "FREE_EMAIL_PROVIDER";
+  VerificationErrorCode2["invalidFormat"] = "INVALID_FORMAT";
+  VerificationErrorCode2["invalidDomain"] = "INVALID_DOMAIN";
+  VerificationErrorCode2["noMxRecords"] = "NO_MX_RECORDS";
+  VerificationErrorCode2["smtpConnectionFailed"] = "SMTP_CONNECTION_FAILED";
+  VerificationErrorCode2["smtpTimeout"] = "SMTP_TIMEOUT";
+  VerificationErrorCode2["mailboxNotFound"] = "MAILBOX_NOT_FOUND";
+  VerificationErrorCode2["mailboxFull"] = "MAILBOX_FULL";
+  VerificationErrorCode2["networkError"] = "NETWORK_ERROR";
+  VerificationErrorCode2["disposableEmail"] = "DISPOSABLE_EMAIL";
+  VerificationErrorCode2["freeEmailProvider"] = "FREE_EMAIL_PROVIDER";
 })(VerificationErrorCode || (VerificationErrorCode = {}));
+var EmailProvider;
+(function(EmailProvider2) {
+  EmailProvider2["gmail"] = "gmail";
+  EmailProvider2["hotmailB2b"] = "hotmail_b2b";
+  EmailProvider2["hotmailB2c"] = "hotmail_b2c";
+  EmailProvider2["proofpoint"] = "proofpoint";
+  EmailProvider2["mimecast"] = "mimecast";
+  EmailProvider2["yahoo"] = "yahoo";
+  EmailProvider2["everythingElse"] = "everything_else";
+})(EmailProvider || (EmailProvider = {}));
+function parseSmtpError(errorMessage) {
+  const lowerError = errorMessage.toLowerCase();
+  const networkErrorPatterns = [
+    "etimedout",
+    "econnrefused",
+    "enotfound",
+    "econnreset",
+    "socket hang up",
+    "connection_timeout",
+    "socket_timeout",
+    "connection_error",
+    "connection_closed"
+  ];
+  const isNetworkError = networkErrorPatterns.some((pattern) => lowerError.includes(pattern));
+  if (isNetworkError) {
+    return {
+      isDisabled: false,
+      hasFullInbox: false,
+      isInvalid: true,
+      isCatchAll: false
+    };
+  }
+  const disabledPatterns = [
+    "account disabled",
+    "account is disabled",
+    "user disabled",
+    "user is disabled",
+    "account locked",
+    "account is locked",
+    "user blocked",
+    "user is blocked",
+    "mailbox disabled",
+    "delivery not authorized",
+    "message rejected",
+    "access denied",
+    "permission denied",
+    "recipient unknown",
+    "recipient address rejected",
+    "user unknown",
+    "address unknown",
+    "invalid recipient",
+    "not a valid recipient",
+    "recipient does not exist",
+    "no such user",
+    "user does not exist",
+    "mailbox unavailable",
+    "recipient unavailable",
+    "address rejected",
+    "550",
+    "551",
+    "553",
+    "not_found",
+    "ambiguous"
+  ];
+  const fullInboxPatterns = [
+    "mailbox full",
+    "inbox full",
+    "quota exceeded",
+    "over quota",
+    "storage limit exceeded",
+    "message too large",
+    "insufficient storage",
+    "mailbox over quota",
+    "over the quota",
+    "mailbox size limit exceeded",
+    "account over quota",
+    "storage space",
+    "overquota",
+    "452",
+    "552",
+    "over_quota"
+  ];
+  const catchAllPatterns = [
+    "accept all mail",
+    "catch-all",
+    "catchall",
+    "wildcard",
+    "accepts any recipient",
+    "recipient address accepted"
+  ];
+  const rateLimitPatterns = [
+    "receiving mail at a rate that",
+    "rate limit",
+    "too many messages",
+    "temporarily rejected",
+    "try again later",
+    "greylisted",
+    "greylist",
+    "deferring",
+    "temporarily deferred",
+    "421",
+    "450",
+    "451",
+    "temporary_failure"
+  ];
+  const isDisabled = disabledPatterns.some((pattern) => lowerError.includes(pattern)) || lowerError.startsWith("550") || lowerError.startsWith("551") || lowerError.startsWith("553");
+  const hasFullInbox = fullInboxPatterns.some((pattern) => lowerError.includes(pattern)) || lowerError.startsWith("452") || lowerError.startsWith("552");
+  const isCatchAll = catchAllPatterns.some((pattern) => lowerError.includes(pattern));
+  const isInvalid = !isDisabled && !hasFullInbox && !isCatchAll && !rateLimitPatterns.some((pattern) => lowerError.includes(pattern)) && !lowerError.startsWith("421") && !lowerError.startsWith("450") && !lowerError.startsWith("451");
+  return {
+    isDisabled,
+    hasFullInbox,
+    isInvalid,
+    isCatchAll
+  };
+}
 var SMTPStep;
 (function(SMTPStep2) {
-  SMTPStep2["GREETING"] = "GREETING";
-  SMTPStep2["EHLO"] = "EHLO";
-  SMTPStep2["HELO"] = "HELO";
-  SMTPStep2["STARTTLS"] = "STARTTLS";
-  SMTPStep2["MAIL_FROM"] = "MAIL_FROM";
-  SMTPStep2["RCPT_TO"] = "RCPT_TO";
-  SMTPStep2["VRFY"] = "VRFY";
-  SMTPStep2["QUIT"] = "QUIT";
+  SMTPStep2["greeting"] = "GREETING";
+  SMTPStep2["ehlo"] = "EHLO";
+  SMTPStep2["helo"] = "HELO";
+  SMTPStep2["startTls"] = "STARTTLS";
+  SMTPStep2["mailFrom"] = "MAIL_FROM";
+  SMTPStep2["rcptTo"] = "RCPT_TO";
+  SMTPStep2["vrfy"] = "VRFY";
+  SMTPStep2["quit"] = "QUIT";
 })(SMTPStep || (SMTPStep = {}));
 
 function isIPAddress(host) {
@@ -1167,6 +1333,10 @@ function isIPAddress(host) {
   return ipv6Regex.test(host);
 }
 function isOverQuota(smtpReply) {
+  var _a;
+  if ((_a = smtpReply === null || smtpReply === void 0 ? void 0 : smtpReply.toLowerCase()) === null || _a === void 0 ? void 0 : _a.includes("excessively high number of invalid recipients")) {
+    return true;
+  }
   return Boolean(smtpReply && /(over quota)/gi.test(smtpReply));
 }
 function isInvalidMailboxError(smtpReply) {
@@ -1188,9 +1358,38 @@ async function verifyMailboxSMTP(params) {
   const { ports = DEFAULT_PORTS, timeout = DEFAULT_TIMEOUT, maxRetries = DEFAULT_MAX_RETRIES, tls: tlsConfig = true, hostname = "localhost", useVRFY = true, cache, debug = false, sequence } = options;
   const log = debug ? (...args) => console.log("[SMTP]", ...args) : () => {
   };
+  const createSmtpResult = (result, port, tlsUsed, mxHost2) => {
+    const reason = result === true ? "valid" : result === null ? "ambiguous" : "not_found";
+    const parsedError = parseSmtpError(reason);
+    return {
+      canConnectSmtp: result !== null,
+      hasFullInbox: parsedError.hasFullInbox,
+      isCatchAll: parsedError.isCatchAll,
+      isDeliverable: result === true,
+      isDisabled: result === false && parsedError.isDisabled,
+      error: result === null ? reason : result === false ? reason : void 0,
+      providerUsed: EmailProvider.everythingElse,
+      checkedAt: Date.now()
+    };
+  };
+  const createFailureResult = (error) => ({
+    canConnectSmtp: false,
+    hasFullInbox: false,
+    isCatchAll: false,
+    isDeliverable: false,
+    isDisabled: false,
+    error,
+    providerUsed: EmailProvider.everythingElse,
+    checkedAt: Date.now()
+  });
   if (!mxRecords || mxRecords.length === 0) {
     log("No MX records found");
-    return { result: false, cached: false, port: 0, portCached: false };
+    return {
+      smtpResult: createFailureResult("No MX records found"),
+      cached: false,
+      port: 0,
+      portCached: false
+    };
   }
   const mxHost = mxRecords[0];
   log(`Verifying ${local}@${domain} via ${mxHost}`);
@@ -1199,16 +1398,16 @@ async function verifyMailboxSMTP(params) {
     let cachedResult;
     try {
       cachedResult = await smtpCacheStore.get(`${mxHost}:${local}@${domain}`);
-      if (cachedResult !== void 0) {
-        log(`Using cached SMTP result: ${cachedResult}`);
+      if (cachedResult !== void 0 && cachedResult !== null) {
+        log(`Using cached SMTP result: ${cachedResult.isDeliverable}`);
         return {
-          result: typeof cachedResult === "boolean" ? cachedResult : null,
+          smtpResult: cachedResult,
           cached: true,
           port: 0,
           portCached: false
         };
       }
-    } catch (_error) {
+    } catch (ignoredError) {
       cachedResult = void 0;
     }
   }
@@ -1217,7 +1416,7 @@ async function verifyMailboxSMTP(params) {
     let cachedPort;
     try {
       cachedPort = await smtpPortCacheStore.get(mxHost);
-    } catch (_error) {
+    } catch (ignoredError) {
       cachedPort = null;
     }
     if (cachedPort) {
@@ -1234,21 +1433,22 @@ async function verifyMailboxSMTP(params) {
         sequence,
         log
       });
-      if (smtpCacheStore && result !== void 0) {
+      const smtpResult = createSmtpResult(result);
+      if (smtpCacheStore) {
         try {
-          await smtpCacheStore.set(`${mxHost}:${local}@${domain}`, result);
+          await smtpCacheStore.set(`${mxHost}:${local}@${domain}`, smtpResult);
           log(`Cached SMTP result ${result} for ${local}@${domain} via ${mxHost}`);
-        } catch (_error) {
+        } catch (ignoredError) {
         }
       }
-      return { result, cached: false, port: cachedPort, portCached: true };
+      return { smtpResult, cached: false, port: cachedPort, portCached: true };
     }
   }
   for (const port of ports) {
     log(`Testing port ${port}`);
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       if (attempt > 0) {
-        const delay = Math.min(1e3 * 2 ** (attempt - 1), 5e3);
+        const delay = Math.min(200 * 2 ** (attempt - 1), 800);
         log(`Retry ${attempt + 1}, waiting ${delay}ms`);
         await new Promise((resolve) => setTimeout(resolve, delay));
       }
@@ -1264,11 +1464,12 @@ async function verifyMailboxSMTP(params) {
         sequence,
         log
       });
-      if (smtpCacheStore && result !== void 0) {
+      const smtpResult = createSmtpResult(result);
+      if (smtpCacheStore) {
         try {
-          await smtpCacheStore.set(`${mxHost}:${local}@${domain}`, result);
+          await smtpCacheStore.set(`${mxHost}:${local}@${domain}`, smtpResult);
           log(`Cached SMTP result ${result} for ${local}@${domain} via ${mxHost}`);
-        } catch (_error) {
+        } catch (ignoredError) {
         }
       }
       if (result !== null) {
@@ -1276,15 +1477,20 @@ async function verifyMailboxSMTP(params) {
           try {
             await smtpPortCacheStore.set(mxHost, port);
             log(`Cached port ${port} for ${mxHost}`);
-          } catch (_error) {
+          } catch (ignoredError) {
           }
         }
-        return { result, cached: false, port, portCached: false };
+        return { smtpResult, cached: false, port, portCached: false };
       }
     }
   }
   log("All ports failed");
-  return { result: null, cached: false, port: 0, portCached: false };
+  return {
+    smtpResult: createFailureResult("All SMTP connection attempts failed"),
+    cached: false,
+    port: 0,
+    portCached: false
+  };
 }
 async function testSMTPConnection(params) {
   const { mxHost, port, local, domain, timeout, tlsConfig, hostname, useVRFY, sequence, log } = params;
@@ -1292,11 +1498,11 @@ async function testSMTPConnection(params) {
   const useTLS = tlsConfig !== false && (portConfig.tls || portConfig.starttls);
   const implicitTLS = portConfig.tls;
   const defaultSequence = {
-    steps: [SMTPStep.GREETING, SMTPStep.EHLO, SMTPStep.MAIL_FROM, SMTPStep.RCPT_TO]
+    steps: [SMTPStep.greeting, SMTPStep.ehlo, SMTPStep.mailFrom, SMTPStep.rcptTo]
   };
   const activeSequence = sequence || defaultSequence;
   if (port === 25) {
-    activeSequence.steps = activeSequence.steps.map((step) => step === SMTPStep.EHLO ? SMTPStep.HELO : step);
+    activeSequence.steps = activeSequence.steps.map((step) => step === SMTPStep.ehlo ? SMTPStep.helo : step);
   }
   const tlsOptions = {
     host: mxHost,
@@ -1314,7 +1520,7 @@ async function testSMTPConnection(params) {
     let resolved = false;
     let supportsSTARTTLS = false;
     let supportsVRFY = false;
-    const cleanup = () => {
+    let cleanup = () => {
       if (resolved)
         return;
       resolved = true;
@@ -1350,31 +1556,31 @@ async function testSMTPConnection(params) {
       if (resolved)
         return;
       switch (step) {
-        case SMTPStep.EHLO:
+        case SMTPStep.ehlo:
           sendCommand(`EHLO ${hostname}`);
           break;
-        case SMTPStep.HELO:
+        case SMTPStep.helo:
           sendCommand(`HELO ${domain}`);
           break;
-        case SMTPStep.GREETING:
+        case SMTPStep.greeting:
           break;
-        case SMTPStep.STARTTLS:
+        case SMTPStep.startTls:
           sendCommand("STARTTLS");
           break;
-        case SMTPStep.MAIL_FROM: {
+        case SMTPStep.mailFrom: {
           const from = activeSequence.from || "<>";
           sendCommand(`MAIL FROM:${from}`);
           break;
         }
-        case SMTPStep.RCPT_TO:
+        case SMTPStep.rcptTo:
           sendCommand(`RCPT TO:<${local}@${domain}>`);
           break;
-        case SMTPStep.VRFY: {
+        case SMTPStep.vrfy: {
           const vrfyTarget = activeSequence.vrfyTarget || local;
           sendCommand(`VRFY ${vrfyTarget}`);
           break;
         }
-        case SMTPStep.QUIT:
+        case SMTPStep.quit:
           sendCommand("QUIT");
           break;
       }
@@ -1398,14 +1604,14 @@ async function testSMTPConnection(params) {
       }
       if (isMultiline) {
         const currentStep2 = activeSequence.steps[currentStepIndex];
-        if (currentStep2 === SMTPStep.EHLO && code === "250") {
+        if (currentStep2 === SMTPStep.ehlo && code === "250") {
           const upper = response.toUpperCase();
           if (upper.includes("STARTTLS"))
             supportsSTARTTLS = true;
           if (upper.includes("VRFY"))
             supportsVRFY = true;
         }
-        if (currentStep2 === SMTPStep.HELO && code === "250") {
+        if (currentStep2 === SMTPStep.helo && code === "250") {
           const upper = response.toUpperCase();
           if (upper.includes("VRFY"))
             supportsVRFY = true;
@@ -1418,19 +1624,19 @@ async function testSMTPConnection(params) {
       }
       const currentStep = activeSequence.steps[currentStepIndex];
       switch (currentStep) {
-        case SMTPStep.GREETING:
+        case SMTPStep.greeting:
           if (code.startsWith("220")) {
             nextStep();
           } else {
             finish(null, "no_greeting");
           }
           break;
-        case SMTPStep.EHLO:
+        case SMTPStep.ehlo:
           if (code.startsWith("250")) {
-            const hasSTARTTLS = activeSequence.steps.includes(SMTPStep.STARTTLS);
+            const hasSTARTTLS = activeSequence.steps.includes(SMTPStep.startTls);
             if (!isTLS && useTLS && supportsSTARTTLS && !implicitTLS && hasSTARTTLS) {
-              currentStepIndex = activeSequence.steps.indexOf(SMTPStep.STARTTLS);
-              executeStep(SMTPStep.STARTTLS);
+              currentStepIndex = activeSequence.steps.indexOf(SMTPStep.startTls);
+              executeStep(SMTPStep.startTls);
             } else {
               nextStep();
             }
@@ -1438,14 +1644,14 @@ async function testSMTPConnection(params) {
             finish(null, "ehlo_failed");
           }
           break;
-        case SMTPStep.HELO:
+        case SMTPStep.helo:
           if (code.startsWith("250")) {
             nextStep();
           } else {
             finish(null, "helo_failed");
           }
           break;
-        case SMTPStep.STARTTLS:
+        case SMTPStep.startTls:
           if (code.startsWith("220")) {
             const plainSocket = socket;
             socket = tls.connect({
@@ -1456,7 +1662,7 @@ async function testSMTPConnection(params) {
               isTLS = true;
               log("TLS upgraded");
               buffer = "";
-              const starttlsIndex = activeSequence.steps.indexOf(SMTPStep.STARTTLS);
+              const starttlsIndex = activeSequence.steps.indexOf(SMTPStep.startTls);
               currentStepIndex = starttlsIndex;
               nextStep();
             });
@@ -1466,28 +1672,28 @@ async function testSMTPConnection(params) {
             nextStep();
           }
           break;
-        case SMTPStep.MAIL_FROM:
+        case SMTPStep.mailFrom:
           if (code.startsWith("250")) {
             nextStep();
           } else {
             finish(null, "mail_from_rejected");
           }
           break;
-        case SMTPStep.RCPT_TO:
+        case SMTPStep.rcptTo:
           if (code.startsWith("250") || code.startsWith("251")) {
             finish(true, "valid");
           } else if (code.startsWith("552") || code.startsWith("452")) {
             finish(false, "over_quota");
           } else if (code.startsWith("4")) {
             finish(null, "temporary_failure");
-          } else if (useVRFY && supportsVRFY && code.startsWith("5") && activeSequence.steps.includes(SMTPStep.VRFY)) {
-            currentStepIndex = activeSequence.steps.indexOf(SMTPStep.VRFY);
-            executeStep(SMTPStep.VRFY);
+          } else if (useVRFY && supportsVRFY && code.startsWith("5") && activeSequence.steps.includes(SMTPStep.vrfy)) {
+            currentStepIndex = activeSequence.steps.indexOf(SMTPStep.vrfy);
+            executeStep(SMTPStep.vrfy);
           } else {
             finish(null, "ambiguous");
           }
           break;
-        case SMTPStep.VRFY:
+        case SMTPStep.vrfy:
           if (code.startsWith("250") || code.startsWith("252")) {
             finish(true, "vrfy_valid");
           } else if (code.startsWith("550")) {
@@ -1496,14 +1702,14 @@ async function testSMTPConnection(params) {
             finish(null, "vrfy_failed");
           }
           break;
-        case SMTPStep.QUIT:
+        case SMTPStep.quit:
           if (code.startsWith("221")) {
             finish(null, "quit_received");
           }
           break;
       }
     };
-    const handleData = (data) => {
+    let handleData = (data) => {
       if (resolved)
         return;
       buffer += data.toString();
@@ -1539,65 +1745,69 @@ async function testSMTPConnection(params) {
       return;
     }
     const firstStep = activeSequence.steps[0];
-    if (firstStep !== SMTPStep.GREETING) {
+    let connectionTimeout;
+    let stepTimeout;
+    const resetActivityTimeout = () => {
+      if (stepTimeout) {
+        clearTimeout(stepTimeout);
+      }
+      stepTimeout = setTimeout(() => {
+        if (!resolved) {
+          log(`Step timeout after ${timeout}ms of inactivity`);
+          finish(null, "step_timeout");
+        }
+      }, timeout);
+    };
+    connectionTimeout = setTimeout(() => {
+      if (!resolved) {
+        log(`Connection timeout after ${timeout}ms`);
+        finish(null, "connection_timeout");
+      }
+    }, timeout);
+    if (firstStep !== SMTPStep.greeting) {
       executeStep(firstStep);
     }
-    socket.setTimeout(timeout, () => finish(null, "timeout"));
-    socket.on("error", () => finish(null, "connection_error"));
-    socket.on("close", () => {
+    socket.setTimeout(timeout, () => {
+      if (!resolved) {
+        log(`Socket timeout after ${timeout}ms`);
+        finish(null, "socket_timeout");
+      }
+    });
+    socket.on("error", (error) => {
+      log(`Socket error: ${error.message}`);
       if (!resolved)
+        finish(null, "connection_error");
+    });
+    socket.on("close", () => {
+      if (!resolved) {
+        log("Socket closed unexpectedly");
         finish(null, "connection_closed");
+      }
     });
+    const originalHandleData = handleData;
+    handleData = (data) => {
+      resetActivityTimeout();
+      originalHandleData(data);
+    };
+    const enhancedCleanup = () => {
+      if (resolved)
+        return;
+      resolved = true;
+      if (connectionTimeout)
+        clearTimeout(connectionTimeout);
+      if (stepTimeout)
+        clearTimeout(stepTimeout);
+      socket.setTimeout(0);
+      try {
+        socket === null || socket === void 0 ? void 0 : socket.write("QUIT\r\n");
+      } catch {
+      }
+      setTimeout(() => socket === null || socket === void 0 ? void 0 : socket.destroy(), 100);
+    };
+    cleanup = enhancedCleanup;
   });
 }
 
-async function isValidEmailDomain(emailOrDomain, cache) {
-  let [_, emailDomain] = (emailOrDomain === null || emailOrDomain === void 0 ? void 0 : emailOrDomain.split("@")) || [];
-  if (!emailDomain) {
-    emailDomain = _;
-  }
-  if (!emailDomain) {
-    return false;
-  }
-  const cacheStore = getCacheStore(cache, "domainValid");
-  const cached = await cacheStore.get(emailDomain);
-  if (cached !== null && cached !== void 0) {
-    return cached;
-  }
-  try {
-    const result = isValid(emailDomain) || false;
-    await cacheStore.set(emailDomain, result);
-    return result;
-  } catch (_e) {
-    await cacheStore.set(emailDomain, false);
-    return false;
-  }
-}
-function isValidEmail(emailAddress) {
-  if (!emailAddress || typeof emailAddress !== "string") {
-    return false;
-  }
-  const re = /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
-  const emailLower = emailAddress.toLowerCase();
-  if (emailLower.indexOf(".+") !== -1)
-    return false;
-  if (emailLower.indexOf("..") !== -1)
-    return false;
-  if (emailLower.startsWith(".") || emailLower.endsWith("."))
-    return false;
-  const parts = emailAddress.split("@");
-  if (parts.length !== 2)
-    return false;
-  const [localPart, domain] = parts;
-  if (!localPart || !domain)
-    return false;
-  if (localPart.length > 64)
-    return false;
-  if (domain.length > 253)
-    return false;
-  return re.test(emailLower);
-}
-
 const defaultRegex = {
   domainName: "Domain Name: *([^\\s]+)",
   registrar: "Registrar: *(.+)",
@@ -2015,7 +2225,7 @@ function parseWhoisData({ rawData, domain }) {
   return result;
 }
 
-const WHOIS_SERVERS = {
+const whoisServers = {
   com: "whois.verisign-grs.com",
   net: "whois.verisign-grs.com",
   org: "whois.pir.org",
@@ -2115,7 +2325,7 @@ async function getWhoisData(domain, timeout = 5e3, debug = false, cache) {
       throw new Error("Invalid domain");
     }
     log(`[whois] extracted TLD: ${tld} for domain: ${domain}`);
-    const whoisServer = WHOIS_SERVERS[tld];
+    const whoisServer = whoisServers[tld];
     if (!whoisServer) {
       log(`[whois] no specific server for TLD ${tld}, trying IANA`);
       const defaultServer = "whois.iana.org";
@@ -2141,8 +2351,8 @@ async function getWhoisData(domain, timeout = 5e3, debug = false, cache) {
     await cacheStore.set(cacheKey, whoisData);
     log(`[whois] successfully retrieved and cached WHOIS data for ${domain}`);
     return whoisData;
-  } catch (_error) {
-    log(`[whois] failed to get WHOIS data for ${domain}: ${_error instanceof Error ? _error.message : "Unknown error"}`);
+  } catch (ignoredError) {
+    log(`[whois] failed to get WHOIS data for ${domain}: ${ignoredError instanceof Error ? ignoredError.message : "Unknown error"}`);
     return null;
   }
 }
@@ -2179,8 +2389,8 @@ async function getDomainAge(domain, timeout = 5e3, debug = false, cache) {
       expirationDate: whoisData.expirationDate ? new Date(whoisData.expirationDate) : null,
       updatedDate: whoisData.updatedDate ? new Date(whoisData.updatedDate) : null
     };
-  } catch (_error) {
-    log(`[whois] error getting domain age for ${domain}: ${_error instanceof Error ? _error.message : "Unknown error"}`);
+  } catch (ignoredError) {
+    log(`[whois] error getting domain age for ${domain}: ${ignoredError instanceof Error ? ignoredError.message : "Unknown error"}`);
     return null;
   }
 }
@@ -2251,8 +2461,8 @@ async function getDomainRegistrationStatus(domain, timeout = 5e3, debug = false,
       isPendingDelete,
       isLocked
     };
-  } catch (_error) {
-    log(`[whois] error getting domain registration status for ${domain}: ${_error instanceof Error ? _error.message : "Unknown error"}`);
+  } catch (ignoredError) {
+    log(`[whois] error getting domain registration status for ${domain}: ${ignoredError instanceof Error ? ignoredError.message : "Unknown error"}`);
     return null;
   }
 }
@@ -2428,7 +2638,7 @@ function createErrorResult(email, _error) {
     metadata: {
       verificationTime: 0,
       cached: false,
-      error: VerificationErrorCode.SMTP_CONNECTION_FAILED
+      error: VerificationErrorCode.smtpConnectionFailed
     }
   };
 }
@@ -2448,25 +2658,31 @@ async function isDisposableEmail(params) {
   let cached;
   try {
     cached = await cacheStore.get(emailDomain);
-  } catch (_error) {
+  } catch (ignoredError) {
     cached = null;
   }
   if (cached !== null && cached !== void 0) {
-    log(`[isDisposableEmail] Cache hit for ${emailDomain}: ${cached}`);
-    return cached;
+    log(`[isDisposableEmail] Cache hit for ${emailDomain}: ${cached.isDisposable}`);
+    return cached.isDisposable;
   }
   if (!disposableEmailProviders) {
     disposableEmailProviders = new Set(require("./disposable-email-providers.json"));
   }
-  const result = disposableEmailProviders.has(emailDomain);
+  const isDisposable = disposableEmailProviders.has(emailDomain);
+  const richResult = {
+    isDisposable,
+    source: "disposable-email-providers.json",
+    category: isDisposable ? "disposable" : void 0,
+    checkedAt: Date.now()
+  };
   try {
-    await cacheStore.set(emailDomain, result);
-    log(`[isDisposableEmail] Cached result for ${emailDomain}: ${result}`);
-  } catch (_error) {
+    await cacheStore.set(emailDomain, richResult);
+    log(`[isDisposableEmail] Cached result for ${emailDomain}: ${isDisposable}`);
+  } catch (ignoredError) {
     log(`[isDisposableEmail] Cache write error for ${emailDomain}`);
   }
-  log(`[isDisposableEmail] Check result for ${emailDomain}: ${result}`);
-  return result;
+  log(`[isDisposableEmail] Check result for ${emailDomain}: ${isDisposable}`);
+  return isDisposable;
 }
 async function isFreeEmail(params) {
   const { emailOrDomain, cache, logger } = params;
@@ -2481,25 +2697,30 @@ async function isFreeEmail(params) {
   let cached;
   try {
     cached = await cacheStore.get(emailDomain);
-  } catch (_error) {
+  } catch (ignoredError) {
     cached = null;
   }
   if (cached !== null && cached !== void 0) {
-    log(`[isFreeEmail] Cache hit for ${emailDomain}: ${cached}`);
-    return cached;
+    log(`[isFreeEmail] Cache hit for ${emailDomain}: ${cached.isFree}`);
+    return cached.isFree;
   }
   if (!freeEmailProviders) {
     freeEmailProviders = new Set(require("./free-email-providers.json"));
   }
-  const result = freeEmailProviders.has(emailDomain);
+  const isFree = freeEmailProviders.has(emailDomain);
+  const richResult = {
+    isFree,
+    provider: isFree ? emailDomain : void 0,
+    checkedAt: Date.now()
+  };
   try {
-    await cacheStore.set(emailDomain, result);
-    log(`[isFreeEmail] Cached result for ${emailDomain}: ${result}`);
-  } catch (_error) {
+    await cacheStore.set(emailDomain, richResult);
+    log(`[isFreeEmail] Cached result for ${emailDomain}: ${isFree}`);
+  } catch (ignoredError) {
     log(`[isFreeEmail] Cache write error for ${emailDomain}`);
   }
-  log(`[isFreeEmail] Check result for ${emailDomain}: ${result}`);
-  return result;
+  log(`[isFreeEmail] Check result for ${emailDomain}: ${isFree}`);
+  return isFree;
 }
 const domainPorts = {
   // 465 or 587
@@ -2507,7 +2728,7 @@ const domainPorts = {
   "ovh.net": 465
 };
 async function verifyEmail(params) {
-  var _a;
+  var _a, _b;
   const { emailAddress, timeout = 4e3, verifyMx = true, verifySmtp = false, debug = false, checkDisposable = true, checkFree = true, detectName: detectName2 = false, nameDetectionMethod, suggestDomain: suggestDomain2 = true, domainSuggestionMethod, commonDomains, checkDomainAge = false, checkDomainRegistration = false, whoisTimeout = 5e3, skipMxForDisposable = false, skipDomainWhoisForDisposable = false } = params;
   const startTime = Date.now();
   const log = debug ? console.debug : (..._args) => {
@@ -2527,7 +2748,7 @@ async function verifyEmail(params) {
   if (!isValidEmail(emailAddress)) {
     if (result.metadata) {
       result.metadata.verificationTime = Date.now() - startTime;
-      result.metadata.error = VerificationErrorCode.INVALID_FORMAT;
+      result.metadata.error = VerificationErrorCode.invalidFormat;
     }
     return result;
   }
@@ -2553,14 +2774,14 @@ async function verifyEmail(params) {
   if (!domain || !local) {
     if (result.metadata) {
       result.metadata.verificationTime = Date.now() - startTime;
-      result.metadata.error = VerificationErrorCode.INVALID_FORMAT;
+      result.metadata.error = VerificationErrorCode.invalidFormat;
     }
     return result;
   }
   if (!await isValidEmailDomain(domain, params.cache)) {
     if (result.metadata) {
       result.metadata.verificationTime = Date.now() - startTime;
-      result.metadata.error = VerificationErrorCode.INVALID_DOMAIN;
+      result.metadata.error = VerificationErrorCode.invalidDomain;
     }
     return result;
   }
@@ -2569,7 +2790,7 @@ async function verifyEmail(params) {
     result.isDisposable = await isDisposableEmail({ emailOrDomain: emailAddress, cache: params.cache, logger: log });
     log(`[verifyEmail] Disposable check result: ${result.isDisposable}`);
     if (result.isDisposable && result.metadata) {
-      result.metadata.error = VerificationErrorCode.DISPOSABLE_EMAIL;
+      result.metadata.error = VerificationErrorCode.disposableEmail;
     }
   }
   if (checkFree) {
@@ -2590,8 +2811,8 @@ async function verifyEmail(params) {
     try {
       result.domainAge = await getDomainAge(domain, whoisTimeout, debug, params.cache);
       log(`[verifyEmail] Domain age result:`, result.domainAge ? `${result.domainAge.ageInDays} days` : "null");
-    } catch (err) {
-      log("[verifyEmail] Failed to get domain age", err);
+    } catch (error) {
+      log("[verifyEmail] Failed to get domain age", error);
       result.domainAge = null;
     }
   } else if (checkDomainAge && shouldSkipDomainWhois) {
@@ -2602,8 +2823,8 @@ async function verifyEmail(params) {
     try {
       result.domainRegistration = await getDomainRegistrationStatus(domain, whoisTimeout, debug, params.cache);
       log(`[verifyEmail] Domain registration result:`, ((_a = result.domainRegistration) === null || _a === void 0 ? void 0 : _a.isRegistered) ? "registered" : "not registered");
-    } catch (err) {
-      log("[verifyEmail] Failed to get domain registration status", err);
+    } catch (error) {
+      log("[verifyEmail] Failed to get domain registration status", error);
       result.domainRegistration = null;
     }
   } else if (checkDomainRegistration && shouldSkipDomainWhois) {
@@ -2616,14 +2837,19 @@ async function verifyEmail(params) {
       result.validMx = mxRecords.length > 0;
       log(`[verifyEmail] MX records found: ${mxRecords.length}, valid: ${result.validMx}`);
       if (!result.validMx && result.metadata) {
-        result.metadata.error = VerificationErrorCode.NO_MX_RECORDS;
+        result.metadata.error = VerificationErrorCode.noMxRecords;
       }
       if (verifySmtp && mxRecords.length > 0) {
         const cacheKey = `${emailAddress}:smtp`;
         const smtpCacheInstance = getCacheStore(params.cache, "smtp");
         const cachedSmtp = await smtpCacheInstance.get(cacheKey);
         if (cachedSmtp !== null && cachedSmtp !== void 0) {
-          result.validSmtp = cachedSmtp;
+          result.canConnectSmtp = cachedSmtp.canConnectSmtp;
+          result.hasFullInbox = cachedSmtp.hasFullInbox;
+          result.isCatchAll = cachedSmtp.isCatchAll;
+          result.isDeliverable = cachedSmtp.isDeliverable;
+          result.isDisabled = cachedSmtp.isDisabled;
+          result.validSmtp = (_b = cachedSmtp.isDeliverable) !== null && _b !== void 0 ? _b : null;
           log(`[verifyEmail] SMTP result from cache: ${result.validSmtp} for ${emailAddress}`);
           if (result.metadata) {
             result.metadata.cached = true;
@@ -2643,7 +2869,7 @@ async function verifyEmail(params) {
               domainPort = domainPorts[mxDomain.domain];
             }
           }
-          const { result: smtpResult, cached, portCached, port } = await verifyMailboxSMTP({
+          const { smtpResult, cached, port } = await verifyMailboxSMTP({
             local,
             domain,
             mxRecords,
@@ -2656,22 +2882,31 @@ async function verifyEmail(params) {
             }
           });
           await smtpCacheInstance.set(cacheKey, smtpResult);
-          result.validSmtp = smtpResult;
+          result.canConnectSmtp = smtpResult === null || smtpResult === void 0 ? void 0 : smtpResult.canConnectSmtp;
+          result.hasFullInbox = smtpResult === null || smtpResult === void 0 ? void 0 : smtpResult.hasFullInbox;
+          result.isCatchAll = smtpResult === null || smtpResult === void 0 ? void 0 : smtpResult.isCatchAll;
+          result.isDeliverable = smtpResult === null || smtpResult === void 0 ? void 0 : smtpResult.isDeliverable;
+          result.isDisabled = smtpResult === null || smtpResult === void 0 ? void 0 : smtpResult.isDisabled;
+          if (!smtpResult.canConnectSmtp) {
+            result.validSmtp = null;
+          } else {
+            result.validSmtp = smtpResult.isDeliverable;
+          }
           if (result.metadata)
             result.metadata.cached = cached;
           log(`[verifyEmail] SMTP verification result: ${result.validSmtp} for ${emailAddress} (cached for future use)`);
         }
         if (result.validSmtp === false && result.metadata) {
-          result.metadata.error = VerificationErrorCode.MAILBOX_NOT_FOUND;
+          result.metadata.error = VerificationErrorCode.mailboxNotFound;
         } else if (result.validSmtp === null && result.metadata) {
-          result.metadata.error = VerificationErrorCode.SMTP_CONNECTION_FAILED;
+          result.metadata.error = VerificationErrorCode.smtpConnectionFailed;
         }
       }
-    } catch (err) {
-      log("[verifyEmail] Failed to resolve MX records", err);
+    } catch (error) {
+      log("[verifyEmail] Failed to resolve MX records", error);
       result.validMx = false;
       if (result.metadata) {
-        result.metadata.error = VerificationErrorCode.NO_MX_RECORDS;
+        result.metadata.error = VerificationErrorCode.noMxRecords;
       }
     }
   } else if ((verifyMx || verifySmtp) && shouldSkipMx) {
@@ -2683,5 +2918,5 @@ async function verifyEmail(params) {
   return result;
 }
 
-export { COMMON_EMAIL_DOMAINS, DEFAULT_CACHE_OPTIONS, LRUAdapter, RedisAdapter, SMTPStep, VerificationErrorCode, cleanNameForAlgrothin, clearDefaultCache, defaultDomainSuggestionMethod, defaultNameDetectionMethod, detectName, detectNameForAlgrothin, detectNameFromEmail, domainPorts, getCacheStore, getDefaultCache, getDomainAge, getDomainRegistrationStatus, getDomainSimilarity, isCommonDomain, isDisposableEmail, isFreeEmail, isValidEmail, isValidEmailDomain, resetDefaultCache, suggestDomain, suggestEmailDomain, verifyEmail, verifyEmailBatch };
+export { DEFAULT_CACHE_OPTIONS, EmailProvider, LRUAdapter, RedisAdapter, SMTPStep, VerificationErrorCode, cleanNameForAlgorithm, clearDefaultCache, commonEmailDomains, defaultDomainSuggestionMethod, defaultNameDetectionMethod, detectName, detectNameForAlgorithm, detectNameFromEmail, domainPorts, getCacheStore, getDefaultCache, getDomainAge, getDomainRegistrationStatus, getDomainSimilarity, isCommonDomain, isDisposableEmail, isFreeEmail, isValidEmail, isValidEmailDomain, parseSmtpError, resetDefaultCache, suggestDomain, suggestEmailDomain, verifyEmail, verifyEmailBatch };
 //# sourceMappingURL=index.esm.js.map