@emailcheck/email-validator-js 2.14.2 → 3.0.1-beta.1

package/dist/index.esm.js

@@ -1,8 +1,9 @@
 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';
 
 class LRUAdapter {
   constructor(maxSize = 1e3, ttlMs = 36e5) {
@@ -43,28 +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: 864e5,
     domainSuggestion: 864e5,
-    // 24 hours
     whois: 36e5
-    // 1 hour
   },
   maxSize: {
-    mx: 500,
-    disposable: 1e3,
-    free: 1e3,
-    domainValid: 1e3,
-    smtp: 500,
-    domainSuggestion: 1e3,
-    whois: 200
+    mx: 1e4,
+    disposable: 1e4,
+    free: 1e4,
+    domainValid: 1e4,
+    smtp: 1e4,
+    smtpPort: 1e4,
+    domainSuggestion: 1e4,
+    whois: 1e4
   }
 };
 let defaultCacheInstance = null;
@@ -76,6 +72,7 @@ function getDefaultCache() {
       free: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.free, DEFAULT_CACHE_OPTIONS.ttl.free),
       domainValid: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.domainValid, DEFAULT_CACHE_OPTIONS.ttl.domainValid),
       smtp: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.smtp, DEFAULT_CACHE_OPTIONS.ttl.smtp),
+      smtpPort: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.smtpPort, DEFAULT_CACHE_OPTIONS.ttl.smtpPort),
       domainSuggestion: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.domainSuggestion, DEFAULT_CACHE_OPTIONS.ttl.domainSuggestion),
       whois: new LRUAdapter(DEFAULT_CACHE_OPTIONS.maxSize.whois, DEFAULT_CACHE_OPTIONS.ttl.whois)
     };
@@ -92,6 +89,7 @@ function clearDefaultCache() {
     defaultCacheInstance.free.clear();
     defaultCacheInstance.domainValid.clear();
     defaultCacheInstance.smtp.clear();
+    defaultCacheInstance.smtpPort.clear();
     defaultCacheInstance.domainSuggestion.clear();
     defaultCacheInstance.whois.clear();
   }
@@ -100,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",
@@ -219,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;
@@ -275,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");
@@ -371,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",
@@ -394,7 +450,7 @@ const COMMON_NAME_SUFFIXES = [
   "notifications",
   "alerts"
 ];
-const CONTEXTUAL_SUFFIXES = [
+const contextualSuffixes = [
   "dev",
   "company",
   "team",
@@ -426,7 +482,7 @@ const COMMON_TITLES = [
   "father",
   "sister"
 ];
-const COMMON_FIRST_NAMES = /* @__PURE__ */ new Set([
+const commonFirstName = /* @__PURE__ */ new Set([
   // English names
   "james",
   "john",
@@ -604,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",
@@ -724,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;
@@ -744,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;
@@ -855,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))
@@ -917,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) {
@@ -979,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;
@@ -1012,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)) {
@@ -1095,7 +1151,7 @@ function detectNameFromEmail(params) {
   }
   return defaultNameDetectionMethod(email);
 }
-function cleanNameForAlgrothin(name) {
+function cleanNameForAlgorithm(name) {
   if (!name)
     return "";
   let cleaned = name.replace(/[._*]/g, "");
@@ -1105,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;
   }
@@ -1126,6 +1182,156 @@ function detectName(email) {
   return detectNameFromEmail({ email });
 }
 
+var VerificationErrorCode;
+(function(VerificationErrorCode2) {
+  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["mailFrom"] = "MAIL_FROM";
+  SMTPStep2["rcptTo"] = "RCPT_TO";
+  SMTPStep2["vrfy"] = "VRFY";
+  SMTPStep2["quit"] = "QUIT";
+})(SMTPStep || (SMTPStep = {}));
+
+function isIPAddress(host) {
+  const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+  if (ipv4Regex.test(host)) {
+    const octets = host.split(".");
+    return octets.every((octet) => parseInt(octet, 10) <= 255);
+  }
+  const ipv6Regex = /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,7}:$|^(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}$|^(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}$|^(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}$|^(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}$|^[0-9a-fA-F]{1,4}:(?:(?::[0-9a-fA-F]{1,4}){1,6})$|^::1(?::(?::[0-9a-fA-F]{1,4}){1,7})|$|:(?:(?::[0-9a-fA-F]{1,4}){1,7}:)$/;
+  return ipv6Regex.test(host);
+}
 function isOverQuota(smtpReply) {
   return Boolean(smtpReply && /(over quota)/gi.test(smtpReply));
 }
@@ -1135,182 +1341,469 @@ function isInvalidMailboxError(smtpReply) {
 function isMultilineGreet(smtpReply) {
   return Boolean(smtpReply && /^(250|220)-/.test(smtpReply));
 }
+const DEFAULT_PORTS = [25, 587, 465];
+const DEFAULT_TIMEOUT = 3e3;
+const DEFAULT_MAX_RETRIES = 1;
+const PORT_CONFIGS = {
+  25: { tls: false, starttls: true },
+  587: { tls: false, starttls: true },
+  465: { tls: true, starttls: false }
+};
 async function verifyMailboxSMTP(params) {
-  const { local, domain, mxRecords = [], timeout, debug, port = 25, retryAttempts = 1 } = params;
-  const log = debug ? console.debug : (..._args) => {
+  const { local, domain, mxRecords = [], options = {} } = 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) {
-    return false;
+    log("No MX records found");
+    return {
+      smtpResult: createFailureResult("No MX records found"),
+      cached: false,
+      port: 0,
+      portCached: false
+    };
   }
-  const mxIndex = 0;
-  const mxRecord = mxRecords[mxIndex];
-  for (let attempt = 0; attempt < retryAttempts; attempt++) {
-    const result = await attemptVerification({
-      mxRecord,
-      local,
-      domain,
-      port,
-      timeout,
-      log,
-      attempt
-    });
-    if (result !== null) {
-      return result;
+  const mxHost = mxRecords[0];
+  log(`Verifying ${local}@${domain} via ${mxHost}`);
+  const smtpCacheStore = cache ? getCacheStore(cache, "smtp") : null;
+  if (smtpCacheStore) {
+    let cachedResult;
+    try {
+      cachedResult = await smtpCacheStore.get(`${mxHost}:${local}@${domain}`);
+      if (cachedResult !== void 0 && cachedResult !== null) {
+        log(`Using cached SMTP result: ${cachedResult.isDeliverable}`);
+        return {
+          smtpResult: cachedResult,
+          cached: true,
+          port: 0,
+          portCached: false
+        };
+      }
+    } catch (ignoredError) {
+      cachedResult = void 0;
+    }
+  }
+  const smtpPortCacheStore = cache ? getCacheStore(cache, "smtpPort") : null;
+  if (smtpPortCacheStore) {
+    let cachedPort;
+    try {
+      cachedPort = await smtpPortCacheStore.get(mxHost);
+    } catch (ignoredError) {
+      cachedPort = null;
     }
-    if (attempt < retryAttempts - 1) {
-      await new Promise((resolve) => setTimeout(resolve, Math.min(1e3 * (attempt + 1), 3e3)));
+    if (cachedPort) {
+      log(`Using cached port: ${cachedPort}`);
+      const result = await testSMTPConnection({
+        mxHost,
+        port: cachedPort,
+        local,
+        domain,
+        timeout,
+        tlsConfig,
+        hostname,
+        useVRFY,
+        sequence,
+        log
+      });
+      const smtpResult = createSmtpResult(result);
+      if (smtpCacheStore) {
+        try {
+          await smtpCacheStore.set(`${mxHost}:${local}@${domain}`, smtpResult);
+          log(`Cached SMTP result ${result} for ${local}@${domain} via ${mxHost}`);
+        } catch (ignoredError) {
+        }
+      }
+      return { smtpResult, cached: false, port: cachedPort, portCached: true };
     }
   }
-  return null;
+  for (const port of ports) {
+    log(`Testing port ${port}`);
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      if (attempt > 0) {
+        const delay = Math.min(200 * 2 ** (attempt - 1), 800);
+        log(`Retry ${attempt + 1}, waiting ${delay}ms`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+      const result = await testSMTPConnection({
+        mxHost,
+        port,
+        local,
+        domain,
+        timeout,
+        tlsConfig,
+        hostname,
+        useVRFY,
+        sequence,
+        log
+      });
+      const smtpResult = createSmtpResult(result);
+      if (smtpCacheStore) {
+        try {
+          await smtpCacheStore.set(`${mxHost}:${local}@${domain}`, smtpResult);
+          log(`Cached SMTP result ${result} for ${local}@${domain} via ${mxHost}`);
+        } catch (ignoredError) {
+        }
+      }
+      if (result !== null) {
+        if (smtpPortCacheStore) {
+          try {
+            await smtpPortCacheStore.set(mxHost, port);
+            log(`Cached port ${port} for ${mxHost}`);
+          } catch (ignoredError) {
+          }
+        }
+        return { smtpResult, cached: false, port, portCached: false };
+      }
+    }
+  }
+  log("All ports failed");
+  return {
+    smtpResult: createFailureResult("All SMTP connection attempts failed"),
+    cached: false,
+    port: 0,
+    portCached: false
+  };
 }
-async function attemptVerification(params) {
-  const { mxRecord, local, domain, port, timeout, log, attempt } = params;
+async function testSMTPConnection(params) {
+  const { mxHost, port, local, domain, timeout, tlsConfig, hostname, useVRFY, sequence, log } = params;
+  const portConfig = PORT_CONFIGS[port] || { tls: false, starttls: false };
+  const useTLS = tlsConfig !== false && (portConfig.tls || portConfig.starttls);
+  const implicitTLS = portConfig.tls;
+  const defaultSequence = {
+    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);
+  }
+  const tlsOptions = {
+    host: mxHost,
+    servername: isIPAddress(mxHost) ? void 0 : mxHost,
+    // Don't set servername for IP addresses
+    rejectUnauthorized: false,
+    minVersion: "TLSv1.2",
+    ...typeof tlsConfig === "object" ? tlsConfig : {}
+  };
   return new Promise((resolve) => {
-    log(`[verifyMailboxSMTP] connecting to ${mxRecord}:${port} (attempt ${attempt + 1})`);
-    const socket = net.connect({
-      host: mxRecord,
-      port
-    });
-    let resTimeout = null;
+    let socket;
+    let buffer = "";
+    let isTLS = implicitTLS;
+    let currentStepIndex = 0;
     let resolved = false;
-    let cleaned = false;
-    const cleanup = () => {
-      if (cleaned)
-        return;
-      cleaned = true;
-      if (resTimeout) {
-        clearTimeout(resTimeout);
-        resTimeout = null;
-      }
-      if (socket && !socket.destroyed) {
-        socket.removeAllListeners();
-        socket.destroy();
-      }
-    };
-    const ret = (result) => {
+    let supportsSTARTTLS = false;
+    let supportsVRFY = false;
+    let cleanup = () => {
       if (resolved)
         return;
       resolved = true;
-      if (!(socket === null || socket === void 0 ? void 0 : socket.destroyed)) {
-        log("[verifyMailboxSMTP] closing socket");
+      try {
         socket === null || socket === void 0 ? void 0 : socket.write("QUIT\r\n");
-        socket === null || socket === void 0 ? void 0 : socket.end();
+      } catch {
       }
+      setTimeout(() => socket === null || socket === void 0 ? void 0 : socket.destroy(), 100);
+    };
+    const finish = (result, reason) => {
+      if (resolved)
+        return;
+      log(`${port}: ${reason || (result ? "valid" : "invalid")}`);
       cleanup();
       resolve(result);
     };
-    const messages = [`HELO ${domain}`, `MAIL FROM: <>`, `RCPT TO: <${local}@${domain}>`];
-    log("[verifyMailboxSMTP] writing messages", messages);
-    socket.on("data", (data) => {
-      const dataString = String(data);
-      log("[verifyMailboxSMTP] got data", dataString);
-      if (isInvalidMailboxError(dataString)) {
-        log("[verifyMailboxSMTP] invalid mailbox error detected");
-        return ret(false);
+    const sendCommand = (cmd) => {
+      if (resolved)
+        return;
+      log(`\u2192 ${cmd}`);
+      socket === null || socket === void 0 ? void 0 : socket.write(`${cmd}\r
+`);
+    };
+    const nextStep = () => {
+      currentStepIndex++;
+      if (currentStepIndex >= activeSequence.steps.length) {
+        finish(true, "sequence_complete");
+        return;
       }
-      if (isOverQuota(dataString)) {
-        log("[verifyMailboxSMTP] mailbox over quota");
-        return ret(false);
+      executeStep(activeSequence.steps[currentStepIndex]);
+    };
+    const executeStep = (step) => {
+      if (resolved)
+        return;
+      switch (step) {
+        case SMTPStep.ehlo:
+          sendCommand(`EHLO ${hostname}`);
+          break;
+        case SMTPStep.helo:
+          sendCommand(`HELO ${domain}`);
+          break;
+        case SMTPStep.greeting:
+          break;
+        case SMTPStep.startTls:
+          sendCommand("STARTTLS");
+          break;
+        case SMTPStep.mailFrom: {
+          const from = activeSequence.from || "<>";
+          sendCommand(`MAIL FROM:${from}`);
+          break;
+        }
+        case SMTPStep.rcptTo:
+          sendCommand(`RCPT TO:<${local}@${domain}>`);
+          break;
+        case SMTPStep.vrfy: {
+          const vrfyTarget = activeSequence.vrfyTarget || local;
+          sendCommand(`VRFY ${vrfyTarget}`);
+          break;
+        }
+        case SMTPStep.quit:
+          sendCommand("QUIT");
+          break;
       }
-      if (!dataString.includes("220") && !dataString.includes("250")) {
-        log("[verifyMailboxSMTP] unrecognized response, returning null");
-        return ret(null);
+    };
+    const processResponse = (response) => {
+      if (resolved)
+        return;
+      const code = response.substring(0, 3);
+      const isMultiline = response.length > 3 && response[3] === "-";
+      log(`\u2190 ${response}`);
+      if (isMultilineGreet(response)) {
+        return;
       }
-      if (isMultilineGreet(dataString))
+      if (isOverQuota(response)) {
+        finish(false, "over_quota");
         return;
-      if (messages.length > 0) {
-        const message = messages.shift();
-        log("[verifyMailboxSMTP] writing message", message);
-        return socket.write(`${message}\r
-`);
       }
-      ret(true);
-    });
-    socket.on("error", (err) => {
-      log("[verifyMailboxSMTP] error in socket", err);
-      ret(null);
-    });
-    socket.on("close", (err) => {
+      if (isInvalidMailboxError(response)) {
+        finish(false, "not_found");
+        return;
+      }
+      if (isMultiline) {
+        const currentStep2 = activeSequence.steps[currentStepIndex];
+        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") {
+          const upper = response.toUpperCase();
+          if (upper.includes("VRFY"))
+            supportsVRFY = true;
+        }
+        return;
+      }
+      if (!response.includes("220") && !response.includes("250") && !response.includes("550") && !response.includes("552")) {
+        finish(null, "unrecognized_response");
+        return;
+      }
+      const currentStep = activeSequence.steps[currentStepIndex];
+      switch (currentStep) {
+        case SMTPStep.greeting:
+          if (code.startsWith("220")) {
+            nextStep();
+          } else {
+            finish(null, "no_greeting");
+          }
+          break;
+        case SMTPStep.ehlo:
+          if (code.startsWith("250")) {
+            const hasSTARTTLS = activeSequence.steps.includes(SMTPStep.startTls);
+            if (!isTLS && useTLS && supportsSTARTTLS && !implicitTLS && hasSTARTTLS) {
+              currentStepIndex = activeSequence.steps.indexOf(SMTPStep.startTls);
+              executeStep(SMTPStep.startTls);
+            } else {
+              nextStep();
+            }
+          } else {
+            finish(null, "ehlo_failed");
+          }
+          break;
+        case SMTPStep.helo:
+          if (code.startsWith("250")) {
+            nextStep();
+          } else {
+            finish(null, "helo_failed");
+          }
+          break;
+        case SMTPStep.startTls:
+          if (code.startsWith("220")) {
+            const plainSocket = socket;
+            socket = tls.connect({
+              ...tlsOptions,
+              socket: plainSocket,
+              servername: isIPAddress(mxHost) ? void 0 : mxHost
+            }, () => {
+              isTLS = true;
+              log("TLS upgraded");
+              buffer = "";
+              const starttlsIndex = activeSequence.steps.indexOf(SMTPStep.startTls);
+              currentStepIndex = starttlsIndex;
+              nextStep();
+            });
+            socket.on("data", handleData);
+            socket.on("error", () => finish(null, "tls_error"));
+          } else {
+            nextStep();
+          }
+          break;
+        case SMTPStep.mailFrom:
+          if (code.startsWith("250")) {
+            nextStep();
+          } else {
+            finish(null, "mail_from_rejected");
+          }
+          break;
+        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 {
+            finish(null, "ambiguous");
+          }
+          break;
+        case SMTPStep.vrfy:
+          if (code.startsWith("250") || code.startsWith("252")) {
+            finish(true, "vrfy_valid");
+          } else if (code.startsWith("550")) {
+            finish(false, "vrfy_invalid");
+          } else {
+            finish(null, "vrfy_failed");
+          }
+          break;
+        case SMTPStep.quit:
+          if (code.startsWith("221")) {
+            finish(null, "quit_received");
+          }
+          break;
+      }
+    };
+    let handleData = (data) => {
+      if (resolved)
+        return;
+      buffer += data.toString();
+      let pos;
+      while ((pos = buffer.indexOf("\r\n")) !== -1) {
+        const line = buffer.substring(0, pos);
+        buffer = buffer.substring(pos + 2);
+        processResponse(line.trim());
+      }
+    };
+    if (port < 0 || port > 65535 || !Number.isInteger(port)) {
+      finish(null, "invalid_port");
+      return;
+    }
+    if (implicitTLS) {
+      const connectOptions = {
+        ...tlsOptions,
+        port,
+        servername: isIPAddress(mxHost) ? void 0 : mxHost
+      };
+      socket = tls.connect(connectOptions, () => {
+        log(`Connected to ${mxHost}:${port} with TLS`);
+        socket.on("data", handleData);
+      });
+    } else {
+      socket = net.connect({ host: mxHost, port }, () => {
+        log(`Connected to ${mxHost}:${port}`);
+        socket.on("data", handleData);
+      });
+    }
+    if (activeSequence.steps.length === 0) {
+      finish(true, "sequence_complete");
+      return;
+    }
+    const firstStep = activeSequence.steps[0];
+    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, () => {
       if (!resolved) {
-        log("[verifyMailboxSMTP] close socket", err);
-        ret(null);
+        log(`Socket timeout after ${timeout}ms`);
+        finish(null, "socket_timeout");
       }
     });
-    socket.on("timeout", () => {
-      log("[verifyMailboxSMTP] timeout socket");
-      ret(null);
+    socket.on("error", (error) => {
+      log(`Socket error: ${error.message}`);
+      if (!resolved)
+        finish(null, "connection_error");
     });
-    resTimeout = setTimeout(() => {
-      log(`[verifyMailboxSMTP] timed out (${timeout} ms)`);
+    socket.on("close", () => {
       if (!resolved) {
-        socket.destroy();
-        ret(null);
+        log("Socket closed unexpectedly");
+        finish(null, "connection_closed");
       }
-    }, timeout);
+    });
+    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;
   });
 }
 
-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";
-})(VerificationErrorCode || (VerificationErrorCode = {}));
-
-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: *(.+)",
@@ -1728,7 +2221,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",
@@ -1828,7 +2321,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";
@@ -1854,8 +2347,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;
   }
 }
@@ -1892,8 +2385,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;
   }
 }
@@ -1964,8 +2457,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;
   }
 }
@@ -2141,7 +2634,7 @@ function createErrorResult(email, _error) {
     metadata: {
       verificationTime: 0,
       cached: false,
-      error: VerificationErrorCode.SMTP_CONNECTION_FAILED
+      error: VerificationErrorCode.smtpConnectionFailed
     }
   };
 }
@@ -2161,25 +2654,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;
@@ -2194,25 +2693,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
@@ -2220,7 +2724,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) => {
@@ -2240,7 +2744,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;
   }
@@ -2266,14 +2770,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;
   }
@@ -2282,7 +2786,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) {
@@ -2303,8 +2807,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) {
@@ -2315,8 +2819,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) {
@@ -2329,14 +2833,14 @@ 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.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;
@@ -2356,30 +2860,39 @@ async function verifyEmail(params) {
               domainPort = domainPorts[mxDomain.domain];
             }
           }
-          const smtpResult = await verifyMailboxSMTP({
+          const { smtpResult, cached, port } = await verifyMailboxSMTP({
             local,
             domain,
             mxRecords,
-            timeout,
-            debug,
-            port: domainPort,
-            retryAttempts: params.retryAttempts
+            options: {
+              cache: params.cache,
+              ports: domainPort ? [domainPort] : void 0,
+              timeout,
+              debug,
+              maxRetries: params.retryAttempts
+            }
           });
           await smtpCacheInstance.set(cacheKey, smtpResult);
-          result.validSmtp = smtpResult;
+          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) {
@@ -2391,5 +2904,5 @@ async function verifyEmail(params) {
   return result;
 }
 
-export { COMMON_EMAIL_DOMAINS, DEFAULT_CACHE_OPTIONS, LRUAdapter, RedisAdapter, 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