apple-mail-mcp 2.20.23 → 2.20.25

package/build/cli.js

@@ -48,7 +48,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/punycode/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/punycode/index.js
 function error(type) {
   throw new RangeError(errors[type]);
 }
@@ -94,7 +94,7 @@ function ucs2decode(string) {
 }
 var maxInt, base, tMin, tMax, skew, damp, initialBias, initialN, delimiter, regexPunycode, regexNonASCII, regexSeparators, errors, baseMinusTMin, floor, stringFromCharCode, basicToDigit, digitToBasic, adapt, decode, encode, toUnicode, toASCII;
 var init_punycode = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/punycode/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/punycode/index.js"() {
     maxInt = 2147483647;
     base = 36;
     tMin = 1;
@@ -265,7 +265,7 @@ var init_punycode = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/shared/url.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/shared/url.js
 import net from "node:net";
 import urllib from "node:url";
 function invalidUrl(input) {
@@ -318,7 +318,7 @@ function normalizeHostname(raw, href) {
 }
 var SLASHLESS_AUTHORITY, SURROUNDING_WHITESPACE, LEGACY_TRIM, AUTHORITY, FORBIDDEN_HOST_CHARS, CONTROL_CHARS, parse, resolve;
 var init_url = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/shared/url.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/shared/url.js"() {
     init_punycode();
     SLASHLESS_AUTHORITY = /^([a-zA-Z][a-zA-Z0-9+.-]*:)(?!\/\/)([\s\S]+)$/;
     SURROUNDING_WHITESPACE = /^[\x00-\x20]+|[\x00-\x20]+$/g;
@@ -394,11 +394,11 @@ var init_url = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/fetch/cookies.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/fetch/cookies.js
 import net2 from "node:net";
 var SESSION_TIMEOUT, Cookies, cookies_default;
 var init_cookies = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/fetch/cookies.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/fetch/cookies.js"() {
     init_url();
     SESSION_TIMEOUT = 1800;
     Cookies = class {
@@ -612,21 +612,26 @@ var init_cookies = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/package-info.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/package-info.js
 var name, version, homepage;
 var init_package_info = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/package-info.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/package-info.js"() {
     name = "nodemailer";
-    version = "10.0.16";
+    version = "10.1.1";
     homepage = "https://nodemailer.com/";
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/errors.js
-var ECONNECTION, ENOAUTH, EOAUTH2, EMAXLIMIT, EMAXRECIPIENTS, ESENDMAIL, ESES, ECONFIG, EPROXY, EFILEACCESS, EURLACCESS, EFETCH;
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/errors.js
+var ECONNECTION, ETIMEDOUT, ESOCKET, EENVELOPE, EMESSAGE, ESTREAM, ENOAUTH, EOAUTH2, EMAXLIMIT, EMAXRECIPIENTS, ESENDMAIL, ESES, ECONFIG, EPROXY, EFILEACCESS, EURLACCESS, EFETCH, isTransientError, ERR_ACCESS_DENIED;
 var init_errors = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/errors.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/errors.js"() {
     ECONNECTION = "ECONNECTION";
+    ETIMEDOUT = "ETIMEDOUT";
+    ESOCKET = "ESOCKET";
+    EENVELOPE = "EENVELOPE";
+    EMESSAGE = "EMESSAGE";
+    ESTREAM = "ESTREAM";
     ENOAUTH = "ENOAUTH";
     EOAUTH2 = "EOAUTH2";
     EMAXLIMIT = "EMAXLIMIT";
@@ -638,13 +643,15 @@ var init_errors = __esm({
     EFILEACCESS = "EFILEACCESS";
     EURLACCESS = "EURLACCESS";
     EFETCH = "EFETCH";
+    isTransientError = (err) => err.responseCode === 421 || err.code === ECONNECTION || err.code === ESOCKET || err.code === ETIMEDOUT;
+    ERR_ACCESS_DENIED = "ERR_ACCESS_DENIED";
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/shared/objects.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/shared/objects.js
 var isProtoKey, copyOwnKeys;
 var init_objects = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/shared/objects.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/shared/objects.js"() {
     isProtoKey = (key) => key === "__proto__";
     copyOwnKeys = (target, source, skip) => {
       Object.keys(source || {}).forEach((key) => {
@@ -658,12 +665,17 @@ var init_objects = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/fetch/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/fetch/index.js
 import http from "node:http";
 import https from "node:https";
 import zlib from "node:zlib";
 import { PassThrough } from "node:stream";
 import net3 from "node:net";
+function setFetchCode(err) {
+  if (err.code !== ERR_ACCESS_DENIED) {
+    err.code = EFETCH;
+  }
+}
 function parseFetchUrl(url) {
   let parsed;
   try {
@@ -676,6 +688,9 @@ function parseFetchUrl(url) {
   }
   return parsed;
 }
+function fetchPort(parsed) {
+  return parsed.port ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80;
+}
 function nmfetch(url, options) {
   options = options || {};
   options.fetchRes = options.fetchRes || new PassThrough();
@@ -704,7 +719,7 @@ function nmfetch(url, options) {
     options.cookie = false;
   }
   let method = (options.method || "").toString().trim().toUpperCase() || "GET";
-  let finished = false;
+  let finished3 = false;
   let cookies;
   let body;
   const handler = parsed.protocol === "https:" ? https : http;
@@ -735,11 +750,11 @@ function nmfetch(url, options) {
       headers["Transfer-Encoding"] = "chunked";
       body = options.body;
       body.on("error", (err) => {
-        if (finished) {
+        if (finished3) {
           return;
         }
-        finished = true;
-        err.code = EFETCH;
+        finished3 = true;
+        setFetchCode(err);
         err.sourceUrl = url;
         fetchRes.emit("error", err);
       });
@@ -753,7 +768,7 @@ function nmfetch(url, options) {
             return encodeURIComponent(key) + "=" + encodeURIComponent(value);
           }).join("&"));
         } catch (E) {
-          finished = true;
+          finished3 = true;
           E.code = EFETCH;
           E.sourceUrl = url;
           setImmediate(() => fetchRes.emit("error", E));
@@ -772,7 +787,7 @@ function nmfetch(url, options) {
     method,
     host: parsed.hostname,
     path: parsed.path,
-    port: parsed.port ? parsed.port : parsed.protocol === "https:" ? 443 : 80,
+    port: fetchPort(parsed),
     headers,
     // Validate TLS certificates by default. Callers that genuinely need to
     // reach a self-signed/internal host opt out explicitly with
@@ -793,20 +808,20 @@ function nmfetch(url, options) {
   try {
     req = handler.request(reqOptions);
   } catch (E) {
-    finished = true;
+    finished3 = true;
     setImmediate(() => {
-      E.code = EFETCH;
+      setFetchCode(E);
       E.sourceUrl = url;
       fetchRes.emit("error", E);
     });
     return fetchRes;
   }
   const fail = (err, sourceUrl = url) => {
-    if (finished) {
+    if (finished3) {
       return;
     }
-    finished = true;
-    err.code = EFETCH;
+    finished3 = true;
+    setFetchCode(err);
     err.sourceUrl = sourceUrl;
     fetchRes.emit("error", err);
     req.abort();
@@ -816,9 +831,16 @@ function nmfetch(url, options) {
     req.setTimeout(timeout, () => fail(new Error("Request Timeout")));
   }
   req.on("error", (err) => fail(err));
+  fetchRes.once("close", () => {
+    if (finished3 || fetchRes.readableEnded) {
+      return;
+    }
+    finished3 = true;
+    req.destroy();
+  });
   req.on("response", (res) => {
     let inflate;
-    if (finished) {
+    if (finished3) {
       return;
     }
     switch (res.headers["content-encoding"]) {
@@ -849,17 +871,16 @@ function nmfetch(url, options) {
       if (!redirectParsed) {
         return fail(new Error("Unsupported protocol for URL " + redirectUrl), redirectUrl);
       }
-      const crossHost = redirectParsed.hostname !== parsed.hostname;
-      const downgrade = parsed.protocol === "https:" && redirectParsed.protocol === "http:";
-      if (options.headers && (crossHost || downgrade)) {
+      const crossOrigin = redirectParsed.protocol !== parsed.protocol || redirectParsed.hostname !== parsed.hostname || fetchPort(redirectParsed) !== fetchPort(parsed);
+      if (options.headers && crossOrigin) {
         const sensitive = ["authorization", "cookie", "proxy-authorization"];
         Object.keys(options.headers).forEach((key) => {
-          if (sensitive.includes(key.toLowerCase())) {
+          if (sensitive.includes(key.toLowerCase().trim())) {
             delete options.headers[key];
           }
         });
       }
-      finished = true;
+      finished3 = true;
       res.resume();
       req.abort();
       return nmfetch(redirectUrl, options);
@@ -875,7 +896,7 @@ function nmfetch(url, options) {
     let received = 0;
     source.on("data", (chunk) => {
       received += chunk.length;
-      if (received <= maxBytes || finished) {
+      if (received <= maxBytes || finished3) {
         return;
       }
       source.unpipe(fetchRes);
@@ -905,7 +926,7 @@ function nmfetch(url, options) {
 }
 var MAX_REDIRECTS, DEFAULT_TIMEOUT, DEFAULT_MAX_BYTES, TLS_OPTION_KEYS, fetch_default;
 var init_fetch = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/fetch/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/fetch/index.js"() {
     init_url();
     init_cookies();
     init_package_info();
@@ -943,12 +964,13 @@ var init_fetch = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/shared/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/shared/index.js
 import util from "node:util";
 import fs from "node:fs";
 import dns from "node:dns";
 import net4 from "node:net";
 import os from "node:os";
+import { finished } from "node:stream";
 function resolveContent(data, key, options, callback) {
   if (!callback && typeof options === "function") {
     callback = options;
@@ -1014,36 +1036,66 @@ function resolveContentValue(data, key, options, callback) {
   }
   setImmediate(() => callback(null, content));
 }
+function recordStreamErrors(stream) {
+  stream.on("error", (err) => {
+    if (!streamErrors.has(stream)) {
+      streamErrors.set(stream, err);
+    }
+  });
+}
+function destroyStream(value) {
+  const stream = value;
+  if (stream && typeof stream.pipe === "function" && typeof stream.destroy === "function" && !stream.destroyed) {
+    stream.destroy();
+  }
+}
+function unreadableStreamError(stream) {
+  const err = streamErrors.get(stream) || stream.errored;
+  if (err) {
+    return err;
+  }
+  if (stream.readableEnded || stream.destroyed) {
+    const unreadable = new Error("Content stream was already read or destroyed");
+    unreadable.code = ESTREAM;
+    return unreadable;
+  }
+  return null;
+}
 function resolveStream(stream, callback) {
   let responded = false;
-  const chunks = [];
-  let chunklen = 0;
-  stream.on("error", (err) => {
+  const respond = (err, value) => {
     if (responded) {
       return;
     }
     responded = true;
-    callback(err);
-  });
-  stream.on("readable", () => {
-    let chunk;
-    while ((chunk = stream.read()) !== null) {
-      chunks.push(chunk);
-      chunklen += chunk.length;
+    callback(err, value);
+  };
+  const unreadable = unreadableStreamError(stream);
+  if (unreadable) {
+    stream.on("error", () => false);
+    setImmediate(() => respond(unreadable));
+    return;
+  }
+  const chunks = [];
+  let chunklen = 0;
+  stream.on("data", (chunk) => {
+    if (typeof chunk === "string") {
+      chunk = Buffer.from(chunk);
     }
+    chunks.push(chunk);
+    chunklen += chunk.length;
   });
-  stream.on("end", () => {
-    if (responded) {
-      return;
+  finished(stream, { writable: false }, (err) => {
+    if (err) {
+      return respond(err);
     }
-    responded = true;
     let value;
     try {
       value = Buffer.concat(chunks, chunklen);
     } catch (E) {
-      return callback(E);
+      return respond(E);
     }
-    callback(null, value);
+    respond(null, value);
   });
 }
 function createDefaultLogger(levels) {
@@ -1082,9 +1134,9 @@ function createDefaultLogger(levels) {
   });
   return logger;
 }
-var DNS_TTL, CACHE_CLEANUP_INTERVAL, MAX_CACHE_SIZE, lastCacheCleanup, networkInterfaces, isFamilySupported, resolve2, dnsCache, formatDNSValue, resolveHostname, parseConnectionUrl, _logFunc, getLogger, callbackPromise, parseDataURI, assign, encodeXText;
+var DNS_TTL, CACHE_CLEANUP_INTERVAL, MAX_CACHE_SIZE, lastCacheCleanup, networkInterfaces, networkInterfacesRead, _readNetworkInterfaces, isFamilySupported, resolve2, dnsCache, formatDNSValue, resolveHostname, parseConnectionUrl, _logFunc, getLogger, callbackPromise, parseDataURI, assign, encodeXText, streamErrors;
 var init_shared = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/shared/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/shared/index.js"() {
     init_url();
     init_fetch();
     init_errors();
@@ -1093,12 +1145,19 @@ var init_shared = __esm({
     CACHE_CLEANUP_INTERVAL = 30 * 1e3;
     MAX_CACHE_SIZE = 1e3;
     lastCacheCleanup = 0;
-    try {
-      networkInterfaces = os.networkInterfaces();
-    } catch (_err) {
-    }
+    networkInterfacesRead = false;
+    _readNetworkInterfaces = () => {
+      if (!networkInterfacesRead) {
+        networkInterfacesRead = true;
+        try {
+          networkInterfaces = os.networkInterfaces();
+        } catch (_err) {
+        }
+      }
+      return networkInterfaces;
+    };
     isFamilySupported = (family, allowInternal) => {
-      const addresses = Object.values(networkInterfaces || {}).flat();
+      const addresses = Object.values(_readNetworkInterfaces() || {}).flat();
       if (!addresses.length) {
         return true;
       }
@@ -1107,7 +1166,8 @@ var init_shared = __esm({
     resolve2 = (family, hostname, options, callback) => {
       options = options || {};
       if (!isFamilySupported(family, options.allowInternalNetworkInterfaces)) {
-        return callback(null, []);
+        callback(null, []);
+        return null;
       }
       const dnsResolver = dns.Resolver ? new dns.Resolver(options) : dns;
       dnsResolver["resolve" + family](hostname, (err, addresses) => {
@@ -1126,6 +1186,7 @@ var init_shared = __esm({
         }
         return callback(null, Array.isArray(addresses) ? addresses : [].concat(addresses || []));
       });
+      return dns.Resolver ? dnsResolver : null;
     };
     dnsCache = /* @__PURE__ */ new Map();
     formatDNSValue = (value, extra) => {
@@ -1180,103 +1241,125 @@ var init_shared = __esm({
           }));
         }
       }
+      let responded = false;
+      let deadline;
+      const respond = (err, result) => {
+        if (responded) {
+          return;
+        }
+        responded = true;
+        clearTimeout(deadline);
+        callback(err, result);
+      };
+      const respondCached = (error2) => {
+        if (!cached) {
+          return false;
+        }
+        dnsCache.set(host, {
+          value: cached.value,
+          expires: Date.now() + (options.dnsTtl || DNS_TTL)
+        });
+        respond(null, formatDNSValue(cached.value, {
+          servername,
+          cached: true,
+          error: error2
+        }));
+        return true;
+      };
+      const resolvers = [];
+      const timeout = Number(options.timeout) || 0;
+      if (timeout > 0) {
+        deadline = setTimeout(() => {
+          for (const resolver of resolvers) {
+            if (typeof resolver.cancel === "function") {
+              resolver.cancel();
+            }
+          }
+          const err = new Error("DNS lookup for " + host + " timed out");
+          err.code = dns.TIMEOUT;
+          if (!respondCached(err)) {
+            respond(err);
+          }
+        }, timeout);
+      }
       let ipv4Addresses = [];
       let ipv6Addresses = [];
       let ipv4Error = null;
       let ipv6Error = null;
-      resolve2(4, options.host, options, (err, addresses) => {
-        if (err) {
-          ipv4Error = err;
-        } else {
-          ipv4Addresses = addresses || [];
+      let pending = 2;
+      const onResolved = () => {
+        if (--pending || responded) {
+          return;
         }
-        resolve2(6, host, options, (err2, addresses2) => {
-          if (err2) {
-            ipv6Error = err2;
-          } else {
-            ipv6Addresses = addresses2 || [];
-          }
-          const allAddresses = ipv4Addresses.concat(ipv6Addresses);
-          if (allAddresses.length) {
+        const allAddresses = ipv4Addresses.concat(ipv6Addresses);
+        if (allAddresses.length) {
+          const value = {
+            addresses: allAddresses
+          };
+          dnsCache.set(host, {
+            value,
+            expires: Date.now() + (options.dnsTtl || DNS_TTL)
+          });
+          return respond(null, formatDNSValue(value, {
+            servername,
+            cached: false
+          }));
+        }
+        if (ipv4Error && ipv6Error && respondCached(ipv4Error)) {
+          return;
+        }
+        try {
+          dns.lookup(host, { all: true }, (err, addresses) => {
+            if (err) {
+              if (respondCached(err)) {
+                return;
+              }
+              return respond(err);
+            }
+            const supportedAddresses = addresses ? addresses.filter((addr) => isFamilySupported(addr.family)).map((addr) => addr.address) : [];
+            if (addresses && addresses.length && !supportedAddresses.length) {
+              console.warn(`Failed to resolve IPv${addresses[0].family} addresses with current network`);
+            }
+            if (!supportedAddresses.length && cached) {
+              return respond(null, formatDNSValue(cached.value, {
+                servername,
+                cached: true
+              }));
+            }
             const value = {
-              addresses: allAddresses
+              addresses: supportedAddresses.length ? supportedAddresses : [host]
             };
             dnsCache.set(host, {
               value,
               expires: Date.now() + (options.dnsTtl || DNS_TTL)
             });
-            return callback(null, formatDNSValue(value, {
+            return respond(null, formatDNSValue(value, {
               servername,
               cached: false
             }));
+          });
+        } catch (lookupErr) {
+          if (respondCached(lookupErr)) {
+            return;
           }
-          if (ipv4Error && ipv6Error) {
-            if (cached) {
-              dnsCache.set(host, {
-                value: cached.value,
-                expires: Date.now() + (options.dnsTtl || DNS_TTL)
-              });
-              return callback(null, formatDNSValue(cached.value, {
-                servername,
-                cached: true,
-                error: ipv4Error
-              }));
-            }
-          }
-          try {
-            dns.lookup(host, { all: true }, (err3, addresses3) => {
-              if (err3) {
-                if (cached) {
-                  dnsCache.set(host, {
-                    value: cached.value,
-                    expires: Date.now() + (options.dnsTtl || DNS_TTL)
-                  });
-                  return callback(null, formatDNSValue(cached.value, {
-                    servername,
-                    cached: true,
-                    error: err3
-                  }));
-                }
-                return callback(err3);
-              }
-              const supportedAddresses = addresses3 ? addresses3.filter((addr) => isFamilySupported(addr.family)).map((addr) => addr.address) : [];
-              if (addresses3 && addresses3.length && !supportedAddresses.length) {
-                console.warn(`Failed to resolve IPv${addresses3[0].family} addresses with current network`);
-              }
-              if (!supportedAddresses.length && cached) {
-                return callback(null, formatDNSValue(cached.value, {
-                  servername,
-                  cached: true
-                }));
-              }
-              const value = {
-                addresses: supportedAddresses.length ? supportedAddresses : [host]
-              };
-              dnsCache.set(host, {
-                value,
-                expires: Date.now() + (options.dnsTtl || DNS_TTL)
-              });
-              return callback(null, formatDNSValue(value, {
-                servername,
-                cached: false
-              }));
-            });
-          } catch (lookupErr) {
-            if (cached) {
-              dnsCache.set(host, {
-                value: cached.value,
-                expires: Date.now() + (options.dnsTtl || DNS_TTL)
-              });
-              return callback(null, formatDNSValue(cached.value, {
-                servername,
-                cached: true,
-                error: lookupErr
-              }));
-            }
-            return callback(ipv4Error || ipv6Error || lookupErr);
+          return respond(ipv4Error || ipv6Error || lookupErr);
+        }
+      };
+      for (const family of [4, 6]) {
+        const resolver = resolve2(family, host, options, (err, addresses) => {
+          if (family === 4) {
+            ipv4Error = err;
+            ipv4Addresses = addresses || [];
+          } else {
+            ipv6Error = err;
+            ipv6Addresses = addresses || [];
           }
+          onResolved();
         });
-      });
+        if (resolver) {
+          resolvers.push(resolver);
+        }
+      }
     };
     parseConnectionUrl = (str2) => {
       str2 = str2 || "";
@@ -1461,10 +1544,11 @@ var init_shared = __esm({
       }
       return result;
     };
+    streamErrors = /* @__PURE__ */ new WeakMap();
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-funcs/mime-types.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-funcs/mime-types.js
 import path from "node:path";
 function detectMimeType(filename) {
   if (!filename) {
@@ -1501,7 +1585,7 @@ function detectExtension(mimeType) {
 }
 var defaultMimeType, defaultExtension, mimeTypes, extensions;
 var init_mime_types = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-funcs/mime-types.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-funcs/mime-types.js"() {
     defaultMimeType = "application/octet-stream";
     defaultExtension = "bin";
     mimeTypes = /* @__PURE__ */ new Map([
@@ -3566,13 +3650,7 @@ var init_mime_types = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/base64/index.js
-var base64_exports = {};
-__export(base64_exports, {
-  Encoder: () => Encoder,
-  encode: () => encode2,
-  wrap: () => wrap
-});
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/base64/index.js
 import { Transform } from "node:stream";
 function encode2(buffer) {
   if (typeof buffer === "string") {
@@ -3580,118 +3658,123 @@ function encode2(buffer) {
   }
   return buffer.toString("base64");
 }
-function wrap(str2, lineLength) {
-  str2 = (str2 || "").toString();
-  lineLength = Math.max(Number(lineLength) || 76, 1);
-  if (str2.length <= lineLength) {
-    return str2;
-  }
-  const result = [];
-  let pos = 0;
-  const chunkLength = lineLength * 1024;
-  const wrapRegex = new RegExp(".{" + lineLength + "}", "g");
-  while (pos < str2.length) {
-    const wrappedLines = str2.substr(pos, chunkLength).replace(wrapRegex, "$&\r\n").trim();
-    result.push(wrappedLines);
-    pos += chunkLength;
-  }
-  return result.join("\r\n").trim();
+function normalizeLineLength(lineLength) {
+  const length = Math.floor(Number(lineLength));
+  return Number.isFinite(length) && length >= 1 ? length : 76;
+}
+function wrapBuffer(src, lineLength, final) {
+  const lines = Math.ceil(src.length / lineLength);
+  const complete = Math.max(lines - 1, 0);
+  let rest = src.length - complete * lineLength;
+  const output = Buffer.allocUnsafe(complete * (lineLength + 2) + (final ? rest : 0));
+  let to = 0;
+  for (let from = 0; from < complete * lineLength; from += lineLength) {
+    src.copy(output, to, from, from + lineLength);
+    to += lineLength;
+    output[to++] = 13;
+    output[to++] = 10;
+  }
+  if (final) {
+    to += src.copy(output, to, complete * lineLength);
+    rest = 0;
+  }
+  if (to !== output.length) {
+    throw new Error("Unexpected wrapped length");
+  }
+  return { output, rest };
 }
 var Encoder;
 var init_base64 = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/base64/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/base64/index.js"() {
     Encoder = class extends Transform {
       constructor(options) {
         super();
         this.options = options || {};
         if (this.options.lineLength !== false) {
-          this.options.lineLength = this.options.lineLength || 76;
+          this.options.lineLength = normalizeLineLength(this.options.lineLength);
         }
         this._curLine = "";
         this._remainingBytes = false;
         this.inputBytes = 0;
         this.outputBytes = 0;
       }
+      /**
+       * Emits the encoded characters `b64` that follow the current line, keeping what can not be
+       * emitted yet as the new current line
+       *
+       * @internal
+       */
+      _emit(b64, final) {
+        const src = Buffer.from(this._curLine + b64, "latin1");
+        if (!src.length) {
+          return;
+        }
+        let output = src;
+        if (this.options.lineLength) {
+          const wrapped = wrapBuffer(src, this.options.lineLength, final);
+          output = wrapped.output;
+          this._curLine = wrapped.rest ? src.toString("latin1", src.length - wrapped.rest) : "";
+        } else {
+          this._curLine = "";
+        }
+        if (output.length) {
+          this.outputBytes += output.length;
+          this.push(output);
+        }
+      }
       /** @internal */
       _transform(chunk, encoding, done) {
         let buf = encoding !== "buffer" ? Buffer.from(chunk, encoding) : chunk;
         if (!buf || !buf.length) {
-          setImmediate(done);
-          return;
+          return done();
         }
         this.inputBytes += buf.length;
-        if (this._remainingBytes && this._remainingBytes.length) {
+        if (this._remainingBytes) {
           buf = Buffer.concat([this._remainingBytes, buf], this._remainingBytes.length + buf.length);
           this._remainingBytes = false;
         }
-        if (buf.length % 3) {
-          this._remainingBytes = buf.slice(buf.length - buf.length % 3);
-          buf = buf.slice(0, buf.length - buf.length % 3);
-        } else {
-          this._remainingBytes = false;
-        }
-        let b64 = this._curLine + encode2(buf);
-        if (this.options.lineLength) {
-          b64 = wrap(b64, this.options.lineLength);
-          const lastLF = b64.lastIndexOf("\n");
-          if (lastLF < 0) {
-            this._curLine = b64;
-            b64 = "";
-          } else if (lastLF === b64.length - 1) {
-            this._curLine = "";
-          } else {
-            this._curLine = b64.substring(lastLF + 1);
-            b64 = b64.substring(0, lastLF + 1);
-          }
+        const extra = buf.length % 3;
+        if (extra) {
+          this._remainingBytes = buf.subarray(buf.length - extra);
+          buf = buf.subarray(0, buf.length - extra);
         }
-        if (b64) {
-          this.outputBytes += b64.length;
-          this.push(Buffer.from(b64, "ascii"));
-        }
-        setImmediate(done);
+        this._emit(encode2(buf), false);
+        done();
       }
       /** @internal */
       _flush(done) {
-        if (this._remainingBytes && this._remainingBytes.length) {
-          this._curLine += encode2(this._remainingBytes);
-        }
-        if (this._curLine) {
-          this._curLine = wrap(this._curLine, this.options.lineLength);
-          this.outputBytes += this._curLine.length;
-          this.push(Buffer.from(this._curLine, "ascii"));
-          this._curLine = "";
-        }
+        this._emit(this._remainingBytes ? encode2(this._remainingBytes) : "", true);
+        this._remainingBytes = false;
         done();
       }
     };
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/qp/index.js
-var qp_exports = {};
-__export(qp_exports, {
-  Encoder: () => Encoder2,
-  encode: () => encode3,
-  wrap: () => wrap2
-});
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/qp/index.js
 import { Transform as Transform2 } from "node:stream";
 function encode3(buffer) {
-  if (typeof buffer === "string") {
-    buffer = Buffer.from(buffer, "utf-8");
-  }
-  let result = "";
-  let ord;
-  for (let i = 0, len = buffer.length; i < len; i++) {
-    ord = buffer[i];
-    if (checkRanges(ord, QP_RANGES) && !((ord === 32 || ord === 9) && (i === len - 1 || buffer[i + 1] === 10 || buffer[i + 1] === 13))) {
-      result += String.fromCharCode(ord);
+  return encodeBytes(typeof buffer === "string" ? Buffer.from(buffer, "utf-8") : buffer);
+}
+function encodeBytes(buffer, next, binary, previous) {
+  const len = buffer.length;
+  const output = Buffer.allocUnsafe(len * 3);
+  let pos = 0;
+  for (let i = 0; i < len; i++) {
+    const ord = buffer[i];
+    const following = i + 1 < len ? buffer[i + 1] : next;
+    const lineBreakByte = binary && (ord === 13 || ord === 10) ? ord === 13 ? following === 10 : (i > 0 ? buffer[i - 1] : previous) === 13 : true;
+    if (QP_LITERAL[ord] && lineBreakByte && !(isWhitespace(ord) && (following === void 0 || following === 10 || following === 13))) {
+      output[pos++] = ord;
       continue;
     }
-    result += "=" + (ord < 16 ? "0" : "") + ord.toString(16).toUpperCase();
+    output[pos++] = 61;
+    output[pos++] = HEX_DIGITS[Math.floor(ord / 16)];
+    output[pos++] = HEX_DIGITS[ord % 16];
   }
-  return result;
+  return output.toString("latin1", 0, pos);
 }
-function wrap2(str2, lineLength) {
+function wrap(str2, lineLength) {
   str2 = (str2 || "").toString();
   lineLength = Math.max(Number(lineLength) || 76, MIN_LINE_LENGTH);
   if (str2.length <= lineLength) {
@@ -3771,9 +3854,9 @@ function checkRanges(nr, ranges) {
   }
   return false;
 }
-var MIN_LINE_LENGTH, QP_RANGES, Encoder2;
+var MIN_LINE_LENGTH, QP_RANGES, QP_LITERAL, HEX_DIGITS, isWhitespace, ENCODE_SLICE_SIZE, Encoder2;
 var init_qp = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/qp/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/qp/index.js"() {
     MIN_LINE_LENGTH = 4;
     QP_RANGES = [
       [9],
@@ -3787,6 +3870,13 @@ var init_qp = __esm({
       [62, 126]
       // >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}
     ];
+    QP_LITERAL = new Uint8Array(256);
+    for (let i = 0; i < 256; i++) {
+      QP_LITERAL[i] = checkRanges(i, QP_RANGES) ? 1 : 0;
+    }
+    HEX_DIGITS = Buffer.from("0123456789ABCDEF", "latin1");
+    isWhitespace = (c) => c === 32 || c === 9;
+    ENCODE_SLICE_SIZE = 64 * 1024;
     Encoder2 = class extends Transform2 {
       constructor(options) {
         super();
@@ -3795,50 +3885,82 @@ var init_qp = __esm({
           this.options.lineLength = this.options.lineLength || 76;
         }
         this._curLine = "";
+        this._remainingBytes = false;
+        this._lastByte = void 0;
         this.inputBytes = 0;
         this.outputBytes = 0;
       }
       /** @internal */
       _transform(chunk, encoding, done) {
-        let qp;
-        if (encoding !== "buffer") {
-          chunk = Buffer.from(chunk, encoding);
-        }
-        if (!chunk || !chunk.length) {
+        let buf = encoding !== "buffer" ? Buffer.from(chunk, encoding) : chunk;
+        if (!buf || !buf.length) {
           return done();
         }
-        this.inputBytes += chunk.length;
-        if (this.options.lineLength) {
-          qp = this._curLine + encode3(chunk);
-          qp = wrap2(qp, this.options.lineLength);
-          qp = qp.replace(/(^|\n)([^\n]*)$/, (match, lineBreak, lastLine) => {
-            this._curLine = lastLine;
-            return lineBreak;
-          });
-          if (qp) {
-            this.outputBytes += qp.length;
-            this.push(qp);
-          }
-        } else {
-          qp = encode3(chunk);
-          this.outputBytes += qp.length;
-          this.push(qp, "ascii");
+        this.inputBytes += buf.length;
+        if (this._remainingBytes) {
+          buf = Buffer.concat([this._remainingBytes, buf], this._remainingBytes.length + buf.length);
+          this._remainingBytes = false;
         }
+        let end = buf.length;
+        while (end > 0 && (isWhitespace(buf[end - 1]) || this.options.binary && buf[end - 1] === 13)) {
+          end--;
+        }
+        if (buf.length - end <= ENCODE_SLICE_SIZE) {
+          this._remainingBytes = end < buf.length ? Buffer.from(buf.subarray(end)) : false;
+          buf = buf.subarray(0, end);
+        }
+        this._encodeSlices(buf);
         done();
       }
       /** @internal */
       _flush(done) {
+        if (this._remainingBytes) {
+          this._encodeSlices(this._remainingBytes);
+          this._remainingBytes = false;
+        }
         if (this._curLine) {
           this.outputBytes += this._curLine.length;
           this.push(this._curLine, "ascii");
+          this._curLine = "";
         }
         done();
       }
+      /**
+       * Encodes the input in slices of ENCODE_SLICE_SIZE bytes. Each slice is told the byte that
+       * follows it, so a slice that ends in whitespace is encoded as if it was not split
+       *
+       * @internal
+       */
+      _encodeSlices(buf) {
+        for (let start = 0; start < buf.length; start += ENCODE_SLICE_SIZE) {
+          const end = Math.min(start + ENCODE_SLICE_SIZE, buf.length);
+          this._encodeSlice(buf.subarray(start, end), end < buf.length ? buf[end] : void 0);
+          this._lastByte = buf[end - 1];
+        }
+      }
+      /** @internal */
+      _encodeSlice(buf, next) {
+        let qp;
+        if (this.options.lineLength) {
+          qp = wrap(this._curLine + encodeBytes(buf, next, this.options.binary, this._lastByte), this.options.lineLength);
+          const lastLF = qp.lastIndexOf("\n");
+          this._curLine = qp.substring(lastLF + 1);
+          qp = qp.substring(0, lastLF + 1);
+          if (qp) {
+            this.outputBytes += qp.length;
+            this.push(qp, "ascii");
+          }
+        } else {
+          qp = encodeBytes(buf, next, this.options.binary, this._lastByte);
+          this.outputBytes += qp.length;
+          this.push(qp, "ascii");
+        }
+      }
     };
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-funcs/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-funcs/index.js
 function isPlainText(value, isParam) {
   const re = isParam ? /[\x00-\x1f\x7f"\u0080-\uFFFF]/ : /[\x00-\x08\x0b\x0c\x0e-\x1f\u0080-\uFFFF]/;
   return typeof value === "string" && !re.test(value);
@@ -4280,7 +4402,7 @@ function safeEncodeURIComponent(str2) {
 }
 var TOKEN;
 var init_mime_funcs = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-funcs/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-funcs/index.js"() {
     init_base64();
     init_qp();
     init_mime_types();
@@ -4289,7 +4411,7 @@ var init_mime_funcs = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/addressparser/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/addressparser/index.js
 function _quoteLocalPart(address) {
   const lastAt = address.lastIndexOf("@");
   if (lastAt < 0) {
@@ -4677,7 +4799,7 @@ function addressparser(str2, options) {
 }
 var HAS_WHITESPACE, QUOTED_LOCAL_ADDR, ADDR_SPEC, LOOSE_ADDR_SPEC, LOOSE_TEXT_ADDR, Tokenizer, MAX_NESTED_GROUP_DEPTH, addressparser_default;
 var init_addressparser = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/addressparser/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/addressparser/index.js"() {
     HAS_WHITESPACE = /\s/;
     QUOTED_LOCAL_ADDR = /^("(?:[^"\\]|\\[\s\S])*"@\S+)(?:\s+([\s\S]+))?$/;
     ADDR_SPEC = /^[^@\s]+@[^@\s]+$/;
@@ -4800,11 +4922,11 @@ var init_addressparser = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-node/last-newline.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-node/last-newline.js
 import { Transform as Transform3 } from "node:stream";
 var LastNewline;
 var init_last_newline = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-node/last-newline.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-node/last-newline.js"() {
     LastNewline = class extends Transform3 {
       constructor() {
         super();
@@ -4834,11 +4956,11 @@ var init_last_newline = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-node/le-windows.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-node/le-windows.js
 import { Transform as Transform4 } from "node:stream";
 var LeWindows;
 var init_le_windows = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-node/le-windows.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-node/le-windows.js"() {
     LeWindows = class extends Transform4 {
       constructor(options) {
         super(options);
@@ -4876,11 +4998,11 @@ var init_le_windows = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-node/le-unix.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-node/le-unix.js
 import { Transform as Transform5 } from "node:stream";
 var LeUnix;
 var init_le_unix = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-node/le-unix.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-node/le-unix.js"() {
     LeUnix = class extends Transform5 {
       constructor(options) {
         super(options);
@@ -4911,15 +5033,20 @@ var init_le_unix = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-node/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-node/index.js
 import crypto from "node:crypto";
 import fs2 from "node:fs";
-import { PassThrough as PassThrough2 } from "node:stream";
+import { PassThrough as PassThrough2, finished as finished2, pipeline } from "node:stream";
 import urlModule from "node:url";
+function abortedError() {
+  const err = new Error("Message stream was closed before the message was generated");
+  err.code = ESTREAM;
+  return err;
+}
 function normalizeDomain(domain, toUnicode2) {
-  const mapper = toUnicode2 ? urlModule.domainToUnicode : urlModule.domainToASCII;
-  if (typeof mapper === "function" && !URL_PARSER_UNSAFE.test(domain)) {
-    const mapped = mapper(domain);
+  if (typeof urlModule.domainToASCII === "function" && typeof urlModule.domainToUnicode === "function" && !URL_PARSER_UNSAFE.test(domain)) {
+    const ascii = urlModule.domainToASCII(domain);
+    const mapped = ascii && toUnicode2 ? urlModule.domainToUnicode(ascii) : ascii;
     if (mapped) {
       return mapped;
     }
@@ -4929,9 +5056,9 @@ function normalizeDomain(domain, toUnicode2) {
 function _stripBoundaryControls(value) {
   return value.replace(/[\x00-\x1f\x7f]+/g, "");
 }
-var FORMATTED_HEADERS, ATEXT, DOT_ATOM, QUOTED_STRING, PLAIN_ADDRESS, URL_PARSER_UNSAFE, MimeNode, mime_node_default;
+var FORMATTED_HEADERS, ATEXT, DOT_ATOM, QUOTED_STRING, PLAIN_ADDRESS, URL_PARSER_UNSAFE, PIPELINE_NOOP, MimeNode, mime_node_default;
 var init_mime_node = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mime-node/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mime-node/index.js"() {
     init_punycode();
     init_shared();
     init_mime_funcs();
@@ -4949,6 +5076,7 @@ var init_mime_node = __esm({
     QUOTED_STRING = /^"(?:[^"\\]|\\[\s\S])*"$/;
     PLAIN_ADDRESS = /^[^\s"(),:;<>@[\\\]]+@[^\s"(),:;<>@[\\\]]+$/;
     URL_PARSER_UNSAFE = /[/\\?#%\x00-\x20\x7F]/;
+    PIPELINE_NOOP = () => false;
     MimeNode = class _MimeNode {
       constructor(contentType, options) {
         this.nodeCounter = 0;
@@ -5168,11 +5296,7 @@ var init_mime_node = __esm({
       setContent(content) {
         this.content = content;
         if (typeof this.content.pipe === "function") {
-          this._contentErrorHandler = (err) => {
-            this.content.removeListener("error", this._contentErrorHandler);
-            this.content = err;
-          };
-          this.content.once("error", this._contentErrorHandler);
+          recordStreamErrors(this.content);
         } else if (typeof this.content === "string") {
           this._isPlainText = isPlainText(this.content);
           if (this._isPlainText && hasLongerLines(this.content, 76)) {
@@ -5347,37 +5471,38 @@ var init_mime_node = __esm({
       createReadStream(options) {
         options = options || {};
         const stream = new PassThrough2(options);
-        let outputStream = stream;
-        let transform;
         this.stream(stream, options, (err) => {
           if (err) {
-            outputStream.emit("error", err);
+            stream.destroy(err);
             return;
           }
           stream.end();
         });
-        for (let i = 0, len = this._transforms.length; i < len; i++) {
-          transform = typeof this._transforms[i] === "function" ? this._transforms[i]() : this._transforms[i];
-          outputStream.once("error", (err) => {
-            transform.emit("error", err);
-          });
-          outputStream = outputStream.pipe(transform);
-        }
-        transform = new LastNewline();
-        outputStream.once("error", (err) => {
-          transform.emit("error", err);
+        stream.once("close", () => {
+          if (!stream.writableFinished) {
+            this._destroyContentStreams();
+          }
         });
-        outputStream = outputStream.pipe(transform);
-        for (let i = 0, len = this._processFuncs.length; i < len; i++) {
-          transform = this._processFuncs[i];
-          outputStream = transform(outputStream);
+        const stages = [stream];
+        for (const transform of this._transforms) {
+          stages.push(typeof transform === "function" ? transform() : transform);
+        }
+        stages.push(new LastNewline());
+        let outputStream = pipeline(stages, PIPELINE_NOOP);
+        for (const processFunc of this._processFuncs) {
+          const input = outputStream;
+          outputStream = processFunc(input);
+          if (outputStream !== input) {
+            finished2(outputStream, (err) => {
+              if (err) {
+                input.destroy();
+              }
+            });
+          }
         }
         if (this.newline) {
           const winbreak = ["win", "windows", "dos", "\r\n"].includes(this.newline.toString().toLowerCase());
-          const newlineTransform = winbreak ? new LeWindows() : new LeUnix();
-          const stream2 = outputStream.pipe(newlineTransform);
-          outputStream.on("error", (err) => stream2.emit("error", err));
-          return stream2;
+          outputStream = pipeline(outputStream, winbreak ? new LeWindows() : new LeUnix(), PIPELINE_NOOP);
         }
         return outputStream;
       }
@@ -5403,19 +5528,41 @@ var init_mime_node = __esm({
       }
       stream(outputStream, options, done) {
         const transferEncoding = this.getTransferEncoding();
-        let contentStream;
-        let localStream;
+        let activeStreams = [];
         let returned = false;
         const callback = (err) => {
           if (returned) {
             return;
           }
           returned = true;
+          outputStream.removeListener("close", onOutputClose);
           done(err);
         };
+        function onOutputClose() {
+          for (const stream of activeStreams) {
+            stream.destroy();
+          }
+          return callback(abortedError());
+        }
+        const readInto = (...streams) => {
+          if (!activeStreams.length) {
+            outputStream.once("close", onOutputClose);
+          }
+          activeStreams = streams;
+        };
+        const aborted = () => {
+          if (outputStream.destroyed) {
+            callback(abortedError());
+            return true;
+          }
+          return false;
+        };
         const finalize = () => {
           let childId = 0;
           const processChildNode = () => {
+            if (aborted()) {
+              return;
+            }
             if (childId >= this.childNodes.length) {
               outputStream.write("\r\n--" + this.boundary + "--\r\n");
               return callback();
@@ -5436,83 +5583,74 @@ var init_mime_node = __esm({
           }
         };
         const sendContent = () => {
-          if (this.content) {
-            if (Object.prototype.toString.call(this.content) === "[object Error]") {
-              return callback(this.content);
-            }
-            if (typeof this.content.pipe === "function") {
-              this.content.removeListener("error", this._contentErrorHandler);
-              this._contentErrorHandler = (err) => callback(err);
-              this.content.once("error", this._contentErrorHandler);
-            }
-            const createStream = () => {
-              if (["quoted-printable", "base64"].includes(transferEncoding)) {
-                contentStream = new (transferEncoding === "base64" ? base64_exports : qp_exports).Encoder(options);
-                contentStream.pipe(outputStream, {
-                  end: false
-                });
-                contentStream.once("end", finalize);
-                contentStream.once("error", (err) => callback(err));
-                localStream = this._getStream(this.content);
-                localStream.pipe(contentStream);
-              } else {
-                localStream = this._getStream(this.content);
-                localStream.pipe(outputStream, {
-                  end: false
-                });
-                localStream.once("end", finalize);
-              }
-              localStream.once("error", (err) => callback(err));
-            };
-            if (this.content._resolve) {
-              const chunks = [];
-              let chunklen = 0;
-              let returned2 = false;
-              const sourceStream = this._getStream(this.content);
-              sourceStream.on("error", (err) => {
-                if (returned2) {
-                  return;
-                }
-                returned2 = true;
-                callback(err);
-              });
-              sourceStream.on("readable", () => {
-                let chunk;
-                while ((chunk = sourceStream.read()) !== null) {
-                  chunks.push(chunk);
-                  chunklen += chunk.length;
-                }
-              });
-              sourceStream.on("end", () => {
-                if (returned2) {
-                  return;
-                }
-                returned2 = true;
-                this.content._resolve = false;
-                this.content._resolvedValue = Buffer.concat(chunks, chunklen);
-                setImmediate(createStream);
+          if (aborted()) {
+            return;
+          }
+          if (!this.content) {
+            return setImmediate(finalize);
+          }
+          const createStream = () => {
+            if (aborted()) {
+              return;
+            }
+            const contentError = this._takeStreamContent(this.content);
+            if (contentError) {
+              return callback(contentError);
+            }
+            const localStream = this._getStream(this.content);
+            if (["quoted-printable", "base64"].includes(transferEncoding)) {
+              const contentStream = transferEncoding === "base64" ? new Encoder(options) : (
+                // outside of text a lone CR or LF is data, encoding it keeps it from being
+                // turned into a line break by a newline transform or the receiving side
+                new Encoder2(Object.assign({}, options, { binary: !/^text\//i.test(this.contentType || "") }))
+              );
+              readInto(localStream, contentStream);
+              contentStream.pipe(outputStream, {
+                end: false
               });
+              pipeline(localStream, contentStream, (err) => err && callback(err));
+              finished2(contentStream, { writable: false }, (err) => err ? callback(err) : finalize());
             } else {
-              setImmediate(createStream);
+              readInto(localStream);
+              localStream.pipe(outputStream, {
+                end: false
+              });
+              finished2(localStream, { writable: false }, (err) => err ? callback(err) : finalize());
             }
-            return;
+          };
+          if (this.content._resolve) {
+            const sourceStream = this._getStream(this.content);
+            readInto(sourceStream);
+            resolveStream(sourceStream, (err, value) => {
+              if (err) {
+                return callback(err);
+              }
+              if (returned) {
+                return;
+              }
+              this.content._resolve = false;
+              this.content._resolvedValue = value;
+              setImmediate(createStream);
+            });
+          } else {
+            setImmediate(createStream);
           }
-          return setImmediate(finalize);
         };
         if (this._raw) {
           setImmediate(() => {
-            if (Object.prototype.toString.call(this._raw) === "[object Error]") {
-              return callback(this._raw);
+            if (aborted()) {
+              return;
             }
-            if (typeof this._raw.pipe === "function") {
-              this._raw.removeListener("error", this._contentErrorHandler);
+            const rawError = this._takeStreamContent(this._raw);
+            if (rawError) {
+              return callback(rawError);
             }
             const raw = this._getStream(this._raw);
+            readInto(raw);
             raw.pipe(outputStream, {
               end: false
             });
-            raw.on("error", (err) => outputStream.emit("error", err));
-            raw.on("end", finalize);
+            finished2(raw, { writable: false }, (err) => err ? callback(err) : finalize());
           });
         } else {
           outputStream.write(this.buildHeaders() + "\r\n\r\n");
@@ -5620,11 +5758,7 @@ var init_mime_node = __esm({
       setRaw(raw) {
         this._raw = raw;
         if (this._raw && typeof this._raw.pipe === "function") {
-          this._contentErrorHandler = (err) => {
-            this._raw.removeListener("error", this._contentErrorHandler);
-            this._raw = err;
-          };
-          this._raw.once("error", this._contentErrorHandler);
+          recordStreamErrors(this._raw);
         }
         return this;
       }
@@ -5649,6 +5783,36 @@ var init_mime_node = __esm({
         }
         return false;
       }
+      /**
+       * Destroys the content streams of this node and of every node below it
+       *
+       * @internal
+       */
+      _destroyContentStreams() {
+        destroyStream(this.content);
+        destroyStream(this._raw);
+        for (const child of this.childNodes) {
+          child._destroyContentStreams();
+        }
+      }
+      /**
+       * Checks that a content value can still be read before the node streams it. A stream is
+       * refused once it errored, ended or was destroyed: piping it would either never finish or
+       * produce an empty body without any error
+       *
+       * @param content Node content or raw value
+       * @returns The error to stop with, or null when the content can be read
+       * @internal
+       */
+      _takeStreamContent(content) {
+        if (Object.prototype.toString.call(content) === "[object Error]") {
+          return content;
+        }
+        if (!content || typeof content.pipe !== "function" || content._resolvedValue) {
+          return null;
+        }
+        return unreadableStreamError(content);
+      }
       /**
        * Detects and returns handle to a stream related with the content.
        *
@@ -6059,14 +6223,14 @@ var init_mime_node = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mail-composer/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mail-composer/index.js
 function isContentObject(value) {
   const content = value;
   return typeof value === "object" && !!(content.content || content.path || content.href || content.raw);
 }
 var MailComposer, mail_composer_default;
 var init_mail_composer = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mail-composer/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mail-composer/index.js"() {
     init_mime_node();
     init_mime_funcs();
     init_shared();
@@ -6553,7 +6717,7 @@ var init_mail_composer = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/dkim/message-parser.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/dkim/message-parser.js
 import { Transform as Transform6 } from "node:stream";
 function _trimFieldName(str2) {
   let start = 0;
@@ -6568,7 +6732,7 @@ function _trimFieldName(str2) {
 }
 var MessageParser, message_parser_default;
 var init_message_parser = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/dkim/message-parser.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/dkim/message-parser.js"() {
     MessageParser = class extends Transform6 {
       constructor(options) {
         super(options);
@@ -6638,7 +6802,7 @@ var init_message_parser = __esm({
           if (data.length > headerPos) {
             const chunk = data.slice(headerPos);
             this.bodySize += chunk.length;
-            setImmediate(() => this.push(chunk));
+            this.push(chunk);
           }
           return false;
         }
@@ -6665,7 +6829,7 @@ var init_message_parser = __esm({
           this.bodySize += chunk.length;
           this.push(chunk);
         }
-        setImmediate(callback);
+        callback();
       }
       /** @internal */
       _flush(callback) {
@@ -6696,12 +6860,12 @@ var init_message_parser = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/dkim/relaxed-body.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/dkim/relaxed-body.js
 import { Transform as Transform7 } from "node:stream";
 import crypto2 from "node:crypto";
 var CHAR_CR, CHAR_LF, CHAR_SPACE, CHAR_TAB, CRLF, EMPTY_LINES, RelaxedBody, relaxed_body_default;
 var init_relaxed_body = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/dkim/relaxed-body.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/dkim/relaxed-body.js"() {
     CHAR_CR = 13;
     CHAR_LF = 10;
     CHAR_SPACE = 32;
@@ -6823,7 +6987,7 @@ var init_relaxed_body = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/dkim/sign.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/dkim/sign.js
 import crypto3 from "node:crypto";
 function unsupportedHashAlgoError(hashAlgo) {
   const err = new Error('Unsupported DKIM hash algorithm "' + hashAlgo + '"');
@@ -6900,7 +7064,7 @@ function relaxedHeaderLine(line) {
 }
 var sign_default;
 var init_sign = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/dkim/sign.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/dkim/sign.js"() {
     init_punycode();
     init_mime_funcs();
     init_errors();
@@ -6910,14 +7074,14 @@ var init_sign = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/dkim/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/dkim/index.js
 import { PassThrough as PassThrough3 } from "node:stream";
 import fs3 from "node:fs";
 import path2 from "node:path";
 import crypto4 from "node:crypto";
 var DKIM_ALGO, MAX_MESSAGE_SIZE, DKIMSigner, DKIM, dkim_default;
 var init_dkim = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/dkim/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/dkim/index.js"() {
     init_message_parser();
     init_relaxed_body();
     init_sign();
@@ -6944,50 +7108,64 @@ var init_dkim = __esm({
         this.output = output;
         this.output.usingCache = false;
         this.hasErrored = false;
-        this.input.on("error", (err) => {
+        this.input.on("error", (err) => this.fail(err));
+        this.output.once("close", () => {
+          if (this.output.writableFinished) {
+            return;
+          }
           this.hasErrored = true;
+          this.input.unpipe();
+          this.input.destroy();
           this.cleanup();
-          output.emit("error", err);
         });
       }
+      /**
+       * Ends the output with an error and releases the cache file
+       */
+      fail(err) {
+        this.hasErrored = true;
+        this.cleanup();
+        this.output.destroy(err);
+      }
       cleanup() {
         if (!this.cache || !this.cachePath) {
           return;
         }
+        const cache = this.cache;
+        this.cache = false;
+        cache.destroy();
         fs3.unlink(this.cachePath, () => false);
       }
       createReadCache() {
         this.cache = fs3.createReadStream(this.cachePath);
-        this.cache.once("error", (err) => {
-          this.cleanup();
-          this.output.emit("error", err);
-        });
+        this.cache.once("error", (err) => this.fail(err));
         this.cache.once("close", () => {
           this.cleanup();
         });
         this.cache.pipe(this.output);
       }
       sendNextChunk() {
-        if (this.hasErrored) {
-          return;
-        }
-        if (this.readPos >= this.chunks.length) {
-          if (!this.cache) {
-            this.output.end();
+        while (!this.hasErrored) {
+          if (this.readPos >= this.chunks.length) {
+            if (!this.cache) {
+              this.output.end();
+              return;
+            }
+            return this.createReadCache();
+          }
+          const chunk = this.chunks[this.readPos++];
+          if (this.output.write(chunk) === false) {
+            this.output.once("drain", () => {
+              this.sendNextChunk();
+            });
             return;
           }
-          return this.createReadCache();
         }
-        const chunk = this.chunks[this.readPos++];
-        if (this.output.write(chunk) === false) {
-          this.output.once("drain", () => {
-            this.sendNextChunk();
-          });
-          return;
-        }
-        setImmediate(() => this.sendNextChunk());
       }
       sendSignedOutput() {
+        if (this.hasErrored) {
+          return;
+        }
         let keyPos = 0;
         const signNextKey = () => {
           if (keyPos >= this.keys.length) {
@@ -7006,9 +7184,7 @@ var init_dkim = __esm({
               skipFields: this.options.skipFields
             });
           } catch (err) {
-            this.hasErrored = true;
-            this.cleanup();
-            this.output.emit("error", err);
+            this.fail(err);
             return;
           }
           if (dkimField) {
@@ -7026,16 +7202,17 @@ var init_dkim = __esm({
         this.output.usingCache = true;
         this.cache = fs3.createWriteStream(this.cachePath);
         this.cache.once("error", (err) => {
-          this.cleanup();
           this.relaxedBody.unpipe(this.cache);
           this.relaxedBody.on("readable", () => {
             while (this.relaxedBody.read() !== null) {
             }
           });
-          this.hasErrored = true;
-          this.output.emit("error", err);
+          this.fail(err);
         });
         this.cache.once("close", () => {
+          if (this.hasErrored) {
+            return;
+          }
           this.sendSignedOutput();
         });
         this.relaxedBody.removeAllListeners("readable");
@@ -7105,7 +7282,7 @@ var init_dkim = __esm({
           try {
             signer.signStream();
           } catch (_E) {
-            output.emit("error", sign_default.unsupportedHashAlgoError(signer.hashAlgo));
+            signer.fail(sign_default.unsupportedHashAlgoError(signer.hashAlgo));
             return;
           }
           if (writeValue) {
@@ -7121,7 +7298,7 @@ var init_dkim = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-connection/http-proxy-client.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-connection/http-proxy-client.js
 import net5 from "node:net";
 import tls from "node:tls";
 function httpProxyClient(proxyUrl, destinationPort, destinationHost, tlsOptions, callback) {
@@ -7139,6 +7316,7 @@ function httpProxyClient(proxyUrl, destinationPort, destinationHost, tlsOptions,
     return;
   }
   const proxy = parse(proxyUrl);
+  const authority = (net5.isIPv6(unbracket(destinationHost)) ? "[" + unbracket(destinationHost) + "]" : destinationHost) + ":" + destinationPort;
   const connectOptions = {
     host: proxy.hostname,
     port: Number(proxy.port) ? Number(proxy.port) : proxy.protocol === "https:" ? 443 : 80
@@ -7150,30 +7328,83 @@ function httpProxyClient(proxyUrl, destinationPort, destinationHost, tlsOptions,
   } else {
     connect = net5.connect.bind(net5);
   }
+  const timeout = Number(tlsOptions.timeout) || httpProxyClient.timeout || 30 * 1e3;
   let socket;
-  let finished = false;
-  const tempSocketErr = (err) => {
-    if (finished) {
+  let finished3 = false;
+  let timer;
+  const cleanup = () => {
+    clearTimeout(timer);
+    socket.removeListener("data", onSocketData);
+    socket.removeListener("error", fail);
+    socket.removeListener("close", onEarlyClose);
+  };
+  function fail(err) {
+    if (finished3) {
       return;
     }
-    finished = true;
+    finished3 = true;
+    cleanup();
     try {
       socket.destroy();
     } catch (_E) {
     }
     done(err);
-  };
-  const timeoutErr = () => {
-    const err = new Error("Proxy socket timed out");
-    err.code = "ETIMEDOUT";
-    tempSocketErr(err);
-  };
+  }
+  function onEarlyClose() {
+    const err = new Error("Proxy closed the connection before the tunnel was established");
+    err.code = EPROXY;
+    fail(err);
+  }
+  const chunks = [];
+  let received = 0;
+  let tail = "";
+  function onSocketData(chunk) {
+    if (finished3) {
+      return;
+    }
+    const window = tail + chunk.toString("binary");
+    const windowEnd = window.indexOf("\r\n\r\n");
+    chunks.push(chunk);
+    received += chunk.length;
+    tail = window.slice(-3);
+    if (windowEnd < 0) {
+      if (received > MAX_RESPONSE_HEADER_BYTES) {
+        const err = new Error("Proxy response headers too large");
+        err.code = EPROXY;
+        fail(err);
+      }
+      return;
+    }
+    socket.removeListener("data", onSocketData);
+    socket.pause();
+    const headerEnd = received - window.length + windowEnd;
+    const response = Buffer.concat(chunks, received);
+    if (response.length > headerEnd + 4) {
+      socket.unshift(response.subarray(headerEnd + 4));
+    }
+    const match = response.toString("binary", 0, headerEnd).match(/^HTTP\/\d+\.\d+ (\d+)/i);
+    if (!match || (match[1] || "").charAt(0) !== "2") {
+      const err = new Error("Invalid response from proxy" + (match && ": " + match[1] || ""));
+      err.code = EPROXY;
+      return fail(err);
+    }
+    finished3 = true;
+    cleanup();
+    const resumeOnData = (event) => {
+      if (event === "data") {
+        socket.removeListener("newListener", resumeOnData);
+        socket.resume();
+      }
+    };
+    socket.on("newListener", resumeOnData);
+    return done(null, socket);
+  }
   socket = connect(connectOptions, () => {
-    if (finished) {
+    if (finished3) {
       return;
     }
     const reqHeaders = {
-      Host: destinationHost + ":" + destinationPort,
+      Host: authority,
       Connection: "close"
     };
     if (proxy.auth) {
@@ -7181,75 +7412,35 @@ function httpProxyClient(proxyUrl, destinationPort, destinationHost, tlsOptions,
     }
     socket.write(
       // HTTP method
-      "CONNECT " + destinationHost + ":" + destinationPort + " HTTP/1.1\r\n" + // HTTP request headers
+      "CONNECT " + authority + " HTTP/1.1\r\n" + // HTTP request headers
       Object.keys(reqHeaders).map((key) => key + ": " + reqHeaders[key]).join("\r\n") + // End request
       "\r\n\r\n"
     );
-    const chunks = [];
-    let received = 0;
-    let tail = "";
-    const onSocketData = (chunk) => {
-      let match;
-      if (finished) {
-        return;
-      }
-      const window = tail + chunk.toString("binary");
-      const windowEnd = window.indexOf("\r\n\r\n");
-      chunks.push(chunk);
-      received += chunk.length;
-      tail = window.slice(-3);
-      if (windowEnd >= 0) {
-        socket.removeListener("data", onSocketData);
-        const headerEnd = received - window.length + windowEnd;
-        const response = Buffer.concat(chunks, received).toString("binary");
-        const headers = response.substr(0, headerEnd);
-        const remainder = response.substr(headerEnd + 4);
-        if (remainder) {
-          socket.unshift(Buffer.from(remainder, "binary"));
-        }
-        finished = true;
-        match = headers.match(/^HTTP\/\d+\.\d+ (\d+)/i);
-        if (!match || (match[1] || "").charAt(0) !== "2") {
-          try {
-            socket.destroy();
-          } catch (_E) {
-          }
-          const err = new Error("Invalid response from proxy" + (match && ": " + match[1] || ""));
-          err.code = EPROXY;
-          return done(err);
-        }
-        socket.removeListener("error", tempSocketErr);
-        socket.removeListener("timeout", timeoutErr);
-        socket.setTimeout(0);
-        return done(null, socket);
-      }
-      if (received > MAX_RESPONSE_HEADER_BYTES) {
-        socket.removeListener("data", onSocketData);
-        const err = new Error("Proxy response headers too large");
-        err.code = EPROXY;
-        return tempSocketErr(err);
-      }
-    };
     socket.on("data", onSocketData);
   });
-  socket.setTimeout(httpProxyClient.timeout || 30 * 1e3);
-  socket.on("timeout", timeoutErr);
-  socket.once("error", tempSocketErr);
+  timer = setTimeout(() => {
+    const err = new Error("Proxy socket timed out");
+    err.code = ETIMEDOUT;
+    fail(err);
+  }, timeout);
+  socket.once("error", fail);
+  socket.once("close", onEarlyClose);
 }
-var MAX_RESPONSE_HEADER_BYTES, http_proxy_client_default;
+var MAX_RESPONSE_HEADER_BYTES, unbracket, http_proxy_client_default;
 var init_http_proxy_client = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-connection/http-proxy-client.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-connection/http-proxy-client.js"() {
     init_url();
     init_errors();
     MAX_RESPONSE_HEADER_BYTES = 64 * 1024;
+    unbracket = (host) => typeof host === "string" && host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
     http_proxy_client_default = httpProxyClient;
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mailer/mail-message.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mailer/mail-message.js
 var hasOwn, MailMessage;
 var init_mail_message = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mailer/mail-message.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mailer/mail-message.js"() {
     init_shared();
     init_mime_node();
     init_mime_funcs();
@@ -7362,6 +7553,26 @@ var init_mail_message = __esm({
         };
         setImmediate(() => resolveNext());
       }
+      /**
+       * Destroys the content streams of the message once sending failed. A stream that was not
+       * read to the end would otherwise keep the file or the socket behind it open
+       */
+      releaseStreams() {
+        const data = this.data;
+        const values = [data.html, data.text, data.watchHtml, data.amp, data.raw, data.icalEvent];
+        for (const key of ["attachments", "alternatives"]) {
+          if (Array.isArray(data[key])) {
+            values.push(...data[key]);
+          }
+        }
+        for (const value of values) {
+          if (value && typeof value === "object") {
+            destroyStream(value);
+            destroyStream(value.content);
+            destroyStream(value.raw);
+          }
+        }
+      }
       normalize(callback) {
         const envelope = this.message.getEnvelope();
         const messageId = this.message.messageId();
@@ -7506,7 +7717,7 @@ var init_mail_message = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mailer/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mailer/index.js
 import { EventEmitter } from "node:events";
 import util2 from "node:util";
 import net6 from "node:net";
@@ -7514,7 +7725,7 @@ import dns2 from "node:dns";
 import crypto5 from "node:crypto";
 var DEFAULT_MAX_RECIPIENTS, Mail, mailer_default;
 var init_mailer = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/mailer/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/mailer/index.js"() {
     init_shared();
     init_mime_types();
     init_mail_composer();
@@ -7610,6 +7821,10 @@ var init_mailer = __esm({
           this.getSocket = false;
         }
         const mail = new MailMessage(this, data);
+        const fail = (err) => {
+          mail.releaseStreams();
+          done(err);
+        };
         this.logger.debug({
           tnx: "transport",
           name: this.transporter.name,
@@ -7623,7 +7838,7 @@ var init_mailer = __esm({
               tnx: "plugin",
               action: "compile"
             }, "PluginCompile Error: %s", err.message);
-            return done(err);
+            return fail(err);
           }
           let recipientCount;
           try {
@@ -7638,7 +7853,7 @@ var init_mailer = __esm({
               tnx: "transport",
               action: "send"
             }, "Compile Error: %s", err2.message);
-            return done(err2);
+            return fail(err2);
           }
           const maxRecipients = mail.data.maxRecipients === void 0 ? DEFAULT_MAX_RECIPIENTS : mail.data.maxRecipients;
           if (maxRecipients && recipientCount > maxRecipients) {
@@ -7649,7 +7864,7 @@ var init_mailer = __esm({
               tnx: "transport",
               action: "send"
             }, "Send Error: %s", err2.message);
-            return done(err2);
+            return fail(err2);
           }
           this._processPlugins("stream", mail, (err2) => {
             if (err2) {
@@ -7658,7 +7873,7 @@ var init_mailer = __esm({
                 tnx: "plugin",
                 action: "stream"
               }, "PluginStream Error: %s", err2.message);
-              return done(err2);
+              return fail(err2);
             }
             if (mail.data.dkim || this.dkim) {
               mail.message.processFunc((input) => {
@@ -7673,6 +7888,7 @@ var init_mailer = __esm({
             }
             this.transporter.send(mail, (...args) => {
               if (args[0]) {
+                mail.releaseStreams();
                 this.logger.error({
                   err: args[0],
                   tnx: "transport",
@@ -7738,6 +7954,9 @@ var init_mailer = __esm({
         const proxy = parse(proxyUrl);
         this.getSocket = (options, callback) => {
           const protocol = proxy.protocol.replace(/:$/, "").toLowerCase();
+          const configuredTimeout = Number(this.options.connectionTimeout) || 0;
+          const connectStartedAt = Number(options.connectStartedAt) || Date.now();
+          const connectionTimeout = configuredTimeout ? Math.max(connectStartedAt + configuredTimeout - Date.now(), 1) : void 0;
           if (this.meta.has("proxy_handler_" + protocol)) {
             return this.meta.get("proxy_handler_" + protocol)(proxy, options, callback);
           }
@@ -7745,7 +7964,7 @@ var init_mailer = __esm({
             // Connect using a HTTP CONNECT method
             case "http":
             case "https":
-              http_proxy_client_default(proxy.href, options.port, options.host, this.options.tls || {}, (err2, socket) => {
+              http_proxy_client_default(proxy.href, options.port, options.host, connectionTimeout ? Object.assign({}, this.options.tls, { timeout: connectionTimeout }) : this.options.tls || {}, (err2, socket) => {
                 if (err2) {
                   return callback(err2);
                 }
@@ -7779,6 +7998,9 @@ var init_mailer = __esm({
                   },
                   command: "connect"
                 };
+                if (connectionTimeout) {
+                  connectionOpts.timeout = connectionTimeout;
+                }
                 if (proxy.username || proxy.password) {
                   const username = proxy.username || "";
                   const password = proxy.password || "";
@@ -7806,11 +8028,11 @@ var init_mailer = __esm({
               if (net6.isIP(proxy.hostname)) {
                 return connect(proxy.hostname);
               }
-              return dns2.resolve(proxy.hostname, (err2, address) => {
+              return dns2.lookup(proxy.hostname, (err2, address) => {
                 if (err2) {
                   return callback(err2);
                 }
-                connect(Array.isArray(address) ? address[0] : address);
+                connect(address);
               });
             }
           }
@@ -7859,11 +8081,11 @@ var init_mailer = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-connection/data-stream.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-connection/data-stream.js
 import { Transform as Transform8 } from "node:stream";
 var INSERT_LF, INSERT_LF_DOT, INSERT_CR, INSERT_DOT, DataStream;
 var init_data_stream = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-connection/data-stream.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-connection/data-stream.js"() {
     INSERT_LF = Buffer.from("\n");
     INSERT_LF_DOT = Buffer.from("\n.");
     INSERT_CR = Buffer.from("\r");
@@ -7950,13 +8172,26 @@ var init_data_stream = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-connection/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-connection/index.js
 import { EventEmitter as EventEmitter2 } from "node:events";
 import net7 from "node:net";
 import tls2 from "node:tls";
 import os2 from "node:os";
 import crypto6 from "node:crypto";
 import { PassThrough as PassThrough4 } from "node:stream";
+function shuffle(list) {
+  const result = list.slice();
+  for (let i = result.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [result[i], result[j]] = [result[j], result[i]];
+  }
+  return result;
+}
+function timeoutError(message, timeoutType) {
+  const err = new Error(message);
+  err.timeoutType = timeoutType;
+  return err;
+}
 function decodeServerResponse(str2) {
   if (!str2) {
     return str2;
@@ -7970,16 +8205,19 @@ function isPartialResponse(str2) {
 function isPartialLine(line) {
   return /^\d+-/.test(line);
 }
-var CONNECTION_TIMEOUT, SOCKET_TIMEOUT, GREETING_TIMEOUT, DNS_TIMEOUT, TEARDOWN_NOOP, MAX_RESPONSE_SIZE, SMTPConnection, smtp_connection_default;
+var CONNECTION_TIMEOUT, SOCKET_TIMEOUT, GREETING_TIMEOUT, DNS_TIMEOUT, CLOSE_TIMEOUT, KEEPALIVE_DELAY, TEARDOWN_NOOP, MAX_RESPONSE_SIZE, SMTPConnection, smtp_connection_default;
 var init_smtp_connection = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-connection/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-connection/index.js"() {
     init_package_info();
     init_data_stream();
     init_shared();
+    init_errors();
     CONNECTION_TIMEOUT = 2 * 60 * 1e3;
     SOCKET_TIMEOUT = 10 * 60 * 1e3;
     GREETING_TIMEOUT = 30 * 1e3;
     DNS_TIMEOUT = 30 * 1e3;
+    CLOSE_TIMEOUT = 5 * 1e3;
+    KEEPALIVE_DELAY = 30 * 1e3;
     TEARDOWN_NOOP = () => {
     };
     MAX_RESPONSE_SIZE = 1024 * 1024;
@@ -8029,8 +8267,8 @@ var init_smtp_connection = __esm({
         this._maxAllowedSize = 0;
         this._responseActions = [];
         this._recipientQueue = [];
-        this._greetingTimeout = false;
-        this._connectionTimeout = false;
+        this._phaseTimer = false;
+        this._plaintextEhlo = false;
         this._destroyed = false;
         this._closing = false;
         this._currentDataStream = false;
@@ -8041,14 +8279,23 @@ var init_smtp_connection = __esm({
         this._onSocketClose = () => this._onClose();
         this._onSocketEnd = () => this._onEnd();
         this._onSocketTimeout = () => this._onTimeout();
-        this._onConnectionSocketError = (err) => this._onConnectionError(err, "ESOCKET");
-        this._connectionAttemptId = 0;
+        this._onConnectionSocketError = (err) => this._onError(err, "ESOCKET", false, "CONN");
       }
       /**
        * Creates a connection to a SMTP server and sets up connection
        * listener
        */
       connect(connectCallback) {
+        if (this._connectCalled && !this._destroyed) {
+          const err = this._formatError("Cannot connect - connect() was already called for this connection", "ECONNECTION", false, "API");
+          if (typeof connectCallback === "function") {
+            setImmediate(() => connectCallback(err));
+            return;
+          }
+          this.logger.warn({ tnx: "smtp" }, "%s", err.message);
+          return;
+        }
+        this._connectCalled = true;
         if (typeof connectCallback === "function") {
           this._connectCallback = connectCallback;
           this.once("connect", () => {
@@ -8063,11 +8310,13 @@ var init_smtp_connection = __esm({
             return connectCallback(this._formatError(isDestroyedMessage, "ECONNECTION", false, "CONN"));
           }
         }
+        const connectionTimeout = this.options.connectionTimeout || CONNECTION_TIMEOUT;
+        this._connectionDeadline = (this._connectStartedAt || Date.now()) + connectionTimeout;
         let opts = {
           port: this.port,
           host: this.host,
           allowInternalNetworkInterfaces: this.allowInternalNetworkInterfaces,
-          timeout: this.options.dnsTimeout || DNS_TIMEOUT
+          timeout: Math.min(this.options.dnsTimeout || DNS_TIMEOUT, connectionTimeout)
         };
         if (this.options.localAddress) {
           opts.localAddress = this.options.localAddress;
@@ -8092,7 +8341,6 @@ var init_smtp_connection = __esm({
           return this._resolveAndConnect(opts, (_resolved) => {
             try {
               this._socket.connect(this.port, this.host, () => {
-                this._socket.setKeepAlive(true);
                 if (this.secureConnection && !this.alreadySecured) {
                   return this._upgradeConnection((err) => {
                     if (err) {
@@ -8118,8 +8366,32 @@ var init_smtp_connection = __esm({
             }
           }
           return this._resolveAndConnect(opts, (resolved) => {
-            this._fallbackAddresses = (resolved._addresses || []).filter((addr) => addr !== opts.host);
-            this._connectOpts = Object.assign({}, opts);
+            let addresses = resolved._addresses || [];
+            if (opts.localAddress) {
+              const localFamily = net7.isIPv6(opts.localAddress) ? 6 : 4;
+              const sameFamily = addresses.filter((addr) => net7.isIP(addr) === localFamily);
+              addresses = sameFamily.length ? sameFamily : addresses;
+            }
+            if (addresses.length > 1) {
+              const ipv6 = addresses.filter((addr) => net7.isIPv6(addr));
+              const ipv4 = addresses.filter((addr) => !net7.isIPv6(addr));
+              const ordered = shuffle(ipv6).concat(shuffle(ipv4));
+              opts.host = this.host;
+              opts.autoSelectFamily = true;
+              if (!ipv6.length || !ipv4.length) {
+                const remaining = this._connectionDeadline - Date.now();
+                opts.autoSelectFamilyAttemptTimeout = Math.max(Math.floor(remaining / ordered.length), 10);
+              }
+              opts.lookup = ((hostname, lookupOptions, callback) => {
+                if (lookupOptions && lookupOptions.all) {
+                  const all = ordered.map((address) => ({ address, family: net7.isIPv6(address) ? 6 : 4 }));
+                  return setImmediate(() => callback(null, all));
+                }
+                setImmediate(() => callback(null, ordered[0], net7.isIPv6(ordered[0]) ? 6 : 4));
+              });
+            } else if (addresses.length) {
+              opts.host = addresses[0];
+            }
             this._connectToHost(opts, this.secureConnection);
           });
         }
@@ -8162,17 +8434,9 @@ var init_smtp_connection = __esm({
         if (this._destroyed || this._closing) {
           return;
         }
-        this._connectionAttemptId++;
-        const currentAttemptId = this._connectionAttemptId;
         const connectFn = secure ? tls2.connect : net7.connect;
         try {
-          this._socket = connectFn(opts, () => {
-            if (this._connectionAttemptId !== currentAttemptId) {
-              return;
-            }
-            this._socket.setKeepAlive(true);
-            this._onConnect();
-          });
+          this._socket = connectFn(opts, () => this._onConnect());
           this._setupConnectionHandlers();
         } catch (E) {
           setImmediate(() => this._onError(E, "ECONNECTION", false, "CONN"));
@@ -8184,43 +8448,37 @@ var init_smtp_connection = __esm({
        * @internal
        */
       _setupConnectionHandlers() {
-        this._connectionTimeout = setTimeout(() => {
-          this._onConnectionError("Connection timeout", "ETIMEDOUT");
-        }, this.options.connectionTimeout || CONNECTION_TIMEOUT);
+        this._startPhase(Math.max((this._connectionDeadline || Date.now()) - Date.now(), 0), timeoutError("Connection timeout", "CONNECT_TIMEOUT"));
         this._socket.on("error", this._onConnectionSocketError);
       }
       /**
-       * Handles connection errors with fallback to alternative addresses
+       * Starts the timer of a connection phase: connecting, waiting for the greeting or a TLS
+       * upgrade. The phases follow one another, so starting one ends the one before
        *
-       * @param err Error object or message
-       * @param code Error code
+       * @param timeout Time the phase may take
+       * @param err Error to fail with when it takes longer
        * @internal
        */
-      _onConnectionError(err, code) {
-        clearTimeout(this._connectionTimeout);
-        const canFallback = this._fallbackAddresses && this._fallbackAddresses.length && this.stage === "init" && !this._destroyed;
-        if (!canFallback) {
-          this._onError(err, code, false, "CONN");
-          return;
-        }
-        const nextHost = this._fallbackAddresses.shift();
-        this.logger.info({
-          tnx: "network",
-          failedHost: this._connectOpts.host,
-          nextHost,
-          error: err.message || err
-        }, "Connection to %s failed, trying %s", this._connectOpts.host, nextHost);
-        if (this._socket) {
-          try {
-            this._socket.removeListener("error", this._onConnectionSocketError);
-            this._socket.on("error", TEARDOWN_NOOP);
-            this._socket.destroy();
-          } catch (_E) {
-          }
-          this._socket = null;
-        }
-        this._connectOpts.host = nextHost;
-        this._connectToHost(this._connectOpts, this.secureConnection);
+      _startPhase(timeout, err) {
+        this._clearPhase();
+        this._phaseTimer = setTimeout(() => {
+          this._phaseTimer = false;
+          this._onError(err, "ETIMEDOUT", false, "CONN");
+        }, timeout);
+      }
+      /**
+       * Time the greeting or a STARTTLS upgrade may take: greetingTimeout, cut short by what is left
+       * of connectionTimeout
+       *
+       * @internal
+       */
+      _remainingSetupTime() {
+        return Math.min(this.options.greetingTimeout || GREETING_TIMEOUT, Math.max((this._connectionDeadline || Infinity) - Date.now(), 1));
+      }
+      /** @internal */
+      _clearPhase() {
+        clearTimeout(this._phaseTimer);
+        this._phaseTimer = false;
       }
       /**
        * Sends QUIT
@@ -8233,8 +8491,7 @@ var init_smtp_connection = __esm({
        * Closes the connection to the server
        */
       close() {
-        clearTimeout(this._connectionTimeout);
-        clearTimeout(this._greetingTimeout);
+        this._clearPhase();
         this._responseActions = [];
         if (this._closing) {
           return;
@@ -8257,6 +8514,7 @@ var init_smtp_connection = __esm({
           if (stream) {
             stream.removeListener("error", onStreamError);
             stream.on("error", TEARDOWN_NOOP);
+            stream.destroy();
           }
           this._pendingSend = false;
         }
@@ -8271,6 +8529,13 @@ var init_smtp_connection = __esm({
             socket.removeListener("error", this._onConnectionSocketError);
             socket.on("error", TEARDOWN_NOOP);
             socket[closeMethod]();
+            if (closeMethod === "end") {
+              const closeTimer = setTimeout(() => socket.destroy(), CLOSE_TIMEOUT);
+              if (typeof closeTimer.unref === "function") {
+                closeTimer.unref();
+              }
+              socket.once("close", () => clearTimeout(closeTimer));
+            }
           } catch (_E) {
           }
         }
@@ -8457,12 +8722,8 @@ var init_smtp_connection = __esm({
         const startTime = Date.now();
         this._setEnvelope(envelope, (err, info) => {
           if (err) {
-            const stream2 = new PassThrough4();
-            if (typeof message.pipe === "function") {
-              message.pipe(stream2);
-            } else {
-              stream2.write(message);
-              stream2.end();
+            if (typeof message.destroy === "function") {
+              message.destroy();
             }
             return callback(err);
           }
@@ -8514,7 +8775,7 @@ var init_smtp_connection = __esm({
        */
       _onConnect() {
         const socket = this._socket;
-        clearTimeout(this._connectionTimeout);
+        this._clearPhase();
         this.logger.info({
           tnx: "network",
           localAddress: socket.localAddress,
@@ -8539,14 +8800,35 @@ var init_smtp_connection = __esm({
         socket.once("end", this._onSocketEnd);
         socket.setTimeout(this.options.socketTimeout || SOCKET_TIMEOUT);
         socket.on("timeout", this._onSocketTimeout);
-        this._greetingTimeout = setTimeout(() => {
-          if (this._socket && !this._destroyed && this._responseActions[0] === this._actionGreeting) {
-            this._onError("Greeting never received", "ETIMEDOUT", false, "CONN");
-          }
-        }, this.options.greetingTimeout || GREETING_TIMEOUT);
+        if (typeof socket.setKeepAlive === "function") {
+          socket.setKeepAlive(true, KEEPALIVE_DELAY);
+        }
+        if (typeof socket.setNoDelay === "function") {
+          socket.setNoDelay(true);
+        }
+        this._startPhase(this._remainingSetupTime(), timeoutError("Greeting never received", "GREETING_TIMEOUT"));
         this._responseActions.push(this._actionGreeting);
         socket.resume();
       }
+      /**
+       * Ends the session after a 421 reply. The replies queued for commands sent along with the
+       * answered one are not going to come, so the message in flight is failed here
+       *
+       * @param str The 421 reply
+       * @internal
+       */
+      _onServerClosing(str2) {
+        if (this._destroyed) {
+          return;
+        }
+        const pendingSend = this._pendingSend;
+        const envelope = this._envelope;
+        this._responseActions = [];
+        this.close();
+        if (pendingSend) {
+          pendingSend.callback(envelope && envelope.mailError || this._formatError("Server closed the connection", "ECONNECTION", str2, "CONN"));
+        }
+      }
       /**
        * 'data' listener for data coming from the server
        *
@@ -8610,17 +8892,15 @@ var init_smtp_connection = __esm({
        * @internal
        */
       _onError(err, type, data, command) {
-        clearTimeout(this._connectionTimeout);
-        clearTimeout(this._greetingTimeout);
+        this._clearPhase();
         if (this._destroyed) {
           return;
         }
         err = this._formatError(err, type, data, command);
-        const transientCodes = ["ETIMEDOUT", "ESOCKET", "ECONNECTION"];
-        if (transientCodes.includes(err.code)) {
-          this.logger.warn(data, err.message);
+        if (isTransientError(err)) {
+          this.logger.warn({ tnx: "smtp", err }, "%s", err.message);
         } else {
-          this.logger.error(data, err.message);
+          this.logger.error({ tnx: "smtp", err }, "%s", err.message);
         }
         const pendingSend = this._pendingSend;
         this.emit("error", err);
@@ -8637,7 +8917,10 @@ var init_smtp_connection = __esm({
         } else {
           err = new Error(message);
         }
-        if (type && type !== "Error") {
+        if (type && type !== "Error" && err.code !== ERR_ACCESS_DENIED) {
+          if (err.code && err.code !== type && !err.originalCode) {
+            err.originalCode = err.code;
+          }
           err.code = type;
         }
         if (response) {
@@ -8685,6 +8968,12 @@ var init_smtp_connection = __esm({
           this.close();
           return;
         }
+        if (!failureResponse && this.stage === "connected" && !this._responseActions.length && !this._pendingSend && !this._destroyed && !this._closing) {
+          this.logger.info({
+            tnx: "network"
+          }, "Server closed the idle connection");
+          return this._destroy();
+        }
         if (failureResponse || this._responseActions[0] !== this.close && !this._destroyed) {
           return this._onError(new Error("Connection closed unexpectedly"), "ECONNECTION", failureResponse, "CONN");
         }
@@ -8708,7 +8997,7 @@ var init_smtp_connection = __esm({
        * @internal
        */
       _onTimeout() {
-        return this._onError(new Error("Timeout"), "ETIMEDOUT", false, "CONN");
+        return this._onError(timeoutError("Timeout", "SOCKET_TIMEOUT"), "ETIMEDOUT", false, "CONN");
       }
       /**
        * Destroys the client, emits 'end'
@@ -8720,10 +9009,7 @@ var init_smtp_connection = __esm({
         }
         this._destroyed = true;
         this.destroyed = true;
-        clearTimeout(this._connectionTimeout);
-        clearTimeout(this._greetingTimeout);
-        this._connectionTimeout = false;
-        this._greetingTimeout = false;
+        this._clearPhase();
         this.emit("end");
       }
       /**
@@ -8734,12 +9020,21 @@ var init_smtp_connection = __esm({
        * @internal
        */
       _upgradeConnection(callback) {
+        const discarded = this._remainder.length + this._responseQueue.reduce((total, response) => total + response.length, 0);
+        if (discarded) {
+          this.logger.warn({
+            tnx: "smtp",
+            discarded
+          }, "Discarded %s bytes received in plaintext after the STARTTLS response", discarded);
+        }
+        this._plaintextEhlo = false;
         this._remainder = "";
         this._responseQueue = [];
         this._responsePartial = false;
         const socketPlain = this._socket;
         socketPlain.removeListener("data", this._onSocketData);
         socketPlain.removeListener("timeout", this._onSocketTimeout);
+        socketPlain.setTimeout(0);
         const opts = Object.assign({
           socket: socketPlain,
           host: this.host
@@ -8754,8 +9049,10 @@ var init_smtp_connection = __esm({
           socketPlain.removeListener("error", this._onConnectionSocketError);
         };
         this.upgrading = true;
+        this._startPhase(this._remainingSetupTime(), timeoutError("TLS handshake timed out", "UPGRADE_TIMEOUT"));
         try {
           this._socket = tls2.connect(opts, () => {
+            this._clearPhase();
             this.secure = true;
             this.upgrading = false;
             this._socket.on("data", this._onSocketData);
@@ -8763,6 +9060,7 @@ var init_smtp_connection = __esm({
             return callback(null, true);
           });
         } catch (err) {
+          this._clearPhase();
           removePlainSocketListeners();
           return callback(err);
         }
@@ -8797,9 +9095,18 @@ var init_smtp_connection = __esm({
           }, str2.replace(/\r?\n$/, ""));
         }
         const action = this._responseActions.shift();
+        const closing = /^421[ -]/.test(str2);
         if (typeof action === "function") {
           action.call(this, str2);
+          if (closing) {
+            return this._onServerClosing(str2);
+          }
           setImmediate(() => this._processResponse());
+        } else if (closing && !this._pendingSend && this.stage === "connected") {
+          this.logger.info({
+            tnx: "smtp"
+          }, "Server closed the idle connection: %s", str2);
+          this.close();
         } else {
           return this._onError(new Error("Unexpected Response"), "EPROTOCOL", str2, "CONN");
         }
@@ -8879,6 +9186,7 @@ var init_smtp_connection = __esm({
             return callback(this._formatError("Server does not support REQUIRETLS extension (RFC 8689)", "EREQUIRETLS", false, "MAIL FROM"));
           }
         }
+        this._envelope.pipelined = this._supportedExtensions.includes("PIPELINING");
         this._responseActions.push((str2) => {
           this._actionMAIL(str2, callback);
         });
@@ -8907,7 +9215,37 @@ var init_smtp_connection = __esm({
         if (this._envelope.requireTLSExtensionEnabled) {
           args.push("REQUIRETLS");
         }
-        this._sendCommand("MAIL FROM:<" + this._envelope.from + ">" + (args.length ? " " + args.join(" ") : ""));
+        const mailFrom = "MAIL FROM:<" + this._envelope.from + ">" + (args.length ? " " + args.join(" ") : "");
+        this._recipientQueue = [];
+        if (!this._envelope.pipelined) {
+          this._sendCommand(mailFrom);
+          return;
+        }
+        const socket = this._socket;
+        socket.cork();
+        this._sendCommand(mailFrom);
+        while (this._envelope.rcptQueue.length) {
+          this._sendRcpt(this._envelope.rcptQueue.shift(), callback);
+        }
+        this._responseActions.push((str2) => {
+          this._actionDATA(str2, callback);
+        });
+        this._sendCommand("DATA");
+        socket.uncork();
+      }
+      /**
+       * Sends RCPT TO for a recipient and queues the handler for the reply
+       *
+       * @param recipient Recipient address
+       * @param callback Callback to run once the envelope is processed
+       * @internal
+       */
+      _sendRcpt(recipient, callback) {
+        this._recipientQueue.push(recipient);
+        this._responseActions.push((str2) => {
+          this._actionRCPT(str2, callback);
+        });
+        this._sendCommand("RCPT TO:<" + recipient + ">" + this._getDsnRcptToArgs());
       }
       /** @internal */
       _setDsnEnvelope(params) {
@@ -9020,7 +9358,7 @@ var init_smtp_connection = __esm({
        * @internal
        */
       _actionGreeting(str2) {
-        clearTimeout(this._greetingTimeout);
+        this._clearPhase();
         if (str2.substr(0, 3) !== "220") {
           this._onError(new Error("Invalid greeting. response=" + str2), "EPROTOCOL", str2, "CONN");
           return;
@@ -9057,7 +9395,6 @@ var init_smtp_connection = __esm({
        * @internal
        */
       _actionEHLO(str2) {
-        let match;
         if (str2.substr(0, 3) === "421") {
           this._onError(new Error("Server terminates connection. response=" + str2), "ECONNECTION", str2, "EHLO");
           return;
@@ -9071,12 +9408,24 @@ var init_smtp_connection = __esm({
           this._sendCommand("HELO " + this.name);
           return;
         }
-        this._ehloLines = str2.split(/\r?\n/).map((line) => line.replace(/^\d+[ -]/, "").trim()).filter((line) => line).slice(1);
         if (!this.secure && !this.options.ignoreTLS && (/[ -]STARTTLS\b/im.test(str2) || this.options.requireTLS)) {
+          this._plaintextEhlo = str2;
           this._sendCommand("STARTTLS");
           this._responseActions.push(this._actionSTARTTLS);
           return;
         }
+        this._parseEhloExtensions(str2);
+        this.emit("connect");
+      }
+      /**
+       * Reads the extensions and the authentication mechanisms out of an EHLO response
+       *
+       * @param str EHLO response from the server
+       * @internal
+       */
+      _parseEhloExtensions(str2) {
+        let match;
+        this._ehloLines = str2.split(/\r?\n/).map((line) => line.replace(/^\d+[ -]/, "").trim()).filter((line) => line).slice(1);
         if (/[ -]SMTPUTF8\b/im.test(str2)) {
           this._supportedExtensions.push("SMTPUTF8");
         }
@@ -9113,7 +9462,6 @@ var init_smtp_connection = __esm({
           this._supportedExtensions.push("SIZE");
           this._maxAllowedSize = Number(match[1]) || 0;
         }
-        this.emit("connect");
       }
       /**
        * Handles server response for HELO command. If it yielded in
@@ -9144,6 +9492,12 @@ var init_smtp_connection = __esm({
             this.logger.info({
               tnx: "smtp"
             }, "Failed STARTTLS upgrade, continuing unencrypted");
+            if (this._plaintextEhlo) {
+              this._parseEhloExtensions(this._plaintextEhlo);
+              this._plaintextEhlo = false;
+              this.allowsAuth = false;
+              this._supportedAuth = [];
+            }
             this.emit("connect");
             return;
           }
@@ -9318,21 +9672,9 @@ var init_smtp_connection = __esm({
         const envelope = this._envelope;
         if (Number(str2.charAt(0)) !== 2) {
           const message = this._usingSmtpUtf8 && /^550 /.test(str2) && /[\x80-\uFFFF]/.test(envelope.from) ? "Internationalized mailbox name not allowed" : "Mail command failed";
-          return callback(this._formatError(message, "EENVELOPE", str2, "MAIL FROM"));
+          envelope.mailError = this._formatError(message, "EENVELOPE", str2, "MAIL FROM");
         }
-        if (!envelope.rcptQueue.length) {
-          return callback(this._formatError("Can't send mail - no recipients defined", "EENVELOPE", false, "API"));
-        }
-        this._recipientQueue = [];
-        const usePipelining = this._supportedExtensions.includes("PIPELINING");
-        do {
-          const curRecipient = envelope.rcptQueue.shift();
-          this._recipientQueue.push(curRecipient);
-          this._responseActions.push((str3) => {
-            this._actionRCPT(str3, callback);
-          });
-          this._sendCommand("RCPT TO:<" + curRecipient + ">" + this._getDsnRcptToArgs());
-        } while (usePipelining && envelope.rcptQueue.length);
+        this._advanceEnvelope(str2, callback);
       }
       /**
        * Handle response for a RCPT TO: command
@@ -9354,28 +9696,63 @@ var init_smtp_connection = __esm({
         } else {
           envelope.accepted.push(curRecipient);
         }
-        if (!envelope.rcptQueue.length && !this._recipientQueue.length) {
-          if (envelope.rejected.length < envelope.to.length) {
-            this._responseActions.push((str3) => {
-              this._actionDATA(str3, callback);
-            });
-            this._sendCommand("DATA");
-          } else {
-            const deferred = envelope.rejectedErrors.find((rejectedErr) => rejectedErr.responseCode && rejectedErr.responseCode < 500);
-            const reply = deferred?.response ?? str2;
-            err = this._formatError("Can't send mail - all recipients were rejected", "EENVELOPE", reply, "RCPT TO");
-            err.rejected = envelope.rejected;
-            err.rejectedErrors = envelope.rejectedErrors;
-            return callback(err);
-          }
-        } else if (envelope.rcptQueue.length) {
-          const nextRecipient = envelope.rcptQueue.shift();
-          this._recipientQueue.push(nextRecipient);
-          this._responseActions.push((str3) => {
-            this._actionRCPT(str3, callback);
-          });
-          this._sendCommand("RCPT TO:<" + nextRecipient + ">" + this._getDsnRcptToArgs());
+        this._advanceEnvelope(str2, callback);
+      }
+      /**
+       * Moves the envelope on after a reply to MAIL FROM or RCPT TO. A pipelined envelope sent every
+       * command at once and is decided by the reply to DATA. Otherwise the commands go one at a
+       * time: the next recipient, or once every reply is in, DATA or the error that ends the message
+       *
+       * @param str The reply that was handled
+       * @param callback Callback to run once the envelope is processed
+       * @internal
+       */
+      _advanceEnvelope(str2, callback) {
+        const envelope = this._envelope;
+        if (envelope.pipelined) {
+          return;
+        }
+        if (envelope.mailError) {
+          return callback(envelope.mailError);
+        }
+        if (envelope.rcptQueue.length) {
+          return this._sendRcpt(envelope.rcptQueue.shift(), callback);
+        }
+        if (this._recipientQueue.length) {
+          return;
+        }
+        const err = this._envelopeError(str2);
+        if (err) {
+          return callback(err);
+        }
+        this._responseActions.push((str3) => {
+          this._actionDATA(str3, callback);
+        });
+        this._sendCommand("DATA");
+      }
+      /**
+       * Decides how the envelope went once every reply to MAIL FROM and RCPT TO is in. Called after
+       * the last RCPT TO reply, or with PIPELINING on the reply to the DATA command sent along
+       *
+       * @param str The reply being handled
+       * @returns The error to fail the message with, or null when DATA can go ahead
+       * @internal
+       */
+      _envelopeError(str2) {
+        const envelope = this._envelope;
+        if (envelope.mailError) {
+          return envelope.mailError;
+        }
+        if (envelope.accepted.length) {
+          return null;
         }
+        const deferred = envelope.rejectedErrors.find((rejectedErr) => rejectedErr.responseCode && rejectedErr.responseCode < 500);
+        const lastRejected = envelope.rejectedErrors[envelope.rejectedErrors.length - 1];
+        const reply = deferred?.response ?? (envelope.pipelined && lastRejected ? lastRejected.response : str2);
+        const err = this._formatError("Can't send mail - all recipients were rejected", "EENVELOPE", reply, "RCPT TO");
+        err.rejected = envelope.rejected;
+        err.rejectedErrors = envelope.rejectedErrors;
+        return err;
       }
       /**
        * Handle response for a DATA command
@@ -9386,6 +9763,21 @@ var init_smtp_connection = __esm({
        */
       _actionDATA(str2, callback) {
         const envelope = this._envelope;
+        if (envelope.pipelined) {
+          const err = this._envelopeError(str2);
+          if (err) {
+            if (/^3/.test(str2)) {
+              if (envelope.mailError) {
+                this.close();
+                return callback(err);
+              }
+              this._responseActions.push(() => callback(err));
+              this._sendCommand(".");
+              return;
+            }
+            return callback(err);
+          }
+        }
         if (!/^[23]/.test(str2)) {
           return callback(this._formatError("Data command failed", "EENVELOPE", str2, "DATA"));
         }
@@ -9505,12 +9897,12 @@ var init_smtp_connection = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/xoauth2/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/xoauth2/index.js
 import { Stream } from "node:stream";
 import crypto7 from "node:crypto";
 var XOAuth2, xoauth2_default;
 var init_xoauth2 = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/xoauth2/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/xoauth2/index.js"() {
     init_fetch();
     init_shared();
     init_errors();
@@ -9840,11 +10232,11 @@ var init_xoauth2 = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-pool/pool-resource.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-pool/pool-resource.js
 import { EventEmitter as EventEmitter3 } from "node:events";
 var PoolResource;
 var init_pool_resource = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-pool/pool-resource.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-pool/pool-resource.js"() {
     init_smtp_connection();
     init_shared();
     init_xoauth2();
@@ -9891,6 +10283,8 @@ var init_pool_resource = __esm({
         this.messages = 0;
         this.available = true;
         this._failed = false;
+        this._sending = false;
+        this._idleTimer = false;
       }
       /**
        * Emits 'error' for the first failure only. A dead resource can report the same failure more
@@ -9910,7 +10304,8 @@ var init_pool_resource = __esm({
        * @param callback Callback function to run once the connection is established or failed
        */
       connect(callback) {
-        this.pool.getSocket(this.options, (err, socketOptions) => {
+        const connectStartedAt = Date.now();
+        this.pool.getSocket(Object.assign({}, this.options, { connectStartedAt }), (err, socketOptions) => {
           if (err) {
             this._fail(err);
             return callback(err);
@@ -9929,7 +10324,18 @@ var init_pool_resource = __esm({
             options = Object.assign(assign(false, options), socketOptions);
           }
           this.connection = new smtp_connection_default(options);
+          this.connection._connectStartedAt = connectStartedAt;
           this.connection.on("error", (err2) => {
+            if (this._sending) {
+              return;
+            }
+            if (this._connected && isTransientError(err2)) {
+              this.logger.info({
+                tnx: "pool",
+                cid: this.id
+              }, "Connection #%s was closed by the server: %s", this.id, err2.message);
+              return;
+            }
             this._fail(err2);
             if (returned) {
               return;
@@ -10003,9 +10409,32 @@ var init_pool_resource = __esm({
         if (mail.data.requireTLSExtensionEnabled) {
           envelope.requireTLSExtensionEnabled = mail.data.requireTLSExtensionEnabled;
         }
-        this.connection.send(envelope, mail.message.createReadStream(), (err, info) => {
+        this._sending = true;
+        const reused = this.messages > 0;
+        const messageStream = mail.message.createReadStream();
+        this.connection.send(envelope, messageStream, (err, info) => {
+          this._sending = false;
           this.messages++;
           if (err) {
+            if (reused && messageStream.readableDidRead === false && isTransientError(err)) {
+              this.logger.info({
+                tnx: "pool",
+                cid: this.id,
+                messageId
+              }, "Connection #%s was closed by the server before message %s was sent: %s", this.id, messageId, err.message);
+              this.connection.close();
+              return;
+            }
+            if ((err.code === EENVELOPE || err.code === EMESSAGE) && err.responseCode !== 421 && !this.connection._destroyed) {
+              this.connection.reset((resetErr) => {
+                if (resetErr) {
+                  this.connection.close();
+                  return;
+                }
+                this._release();
+              });
+              return callback(err);
+            }
             this.connection.close();
             this._fail(err);
             return callback(err);
@@ -10015,27 +10444,66 @@ var init_pool_resource = __esm({
             to: envelope.to
           };
           info.messageId = messageId;
-          setImmediate(() => {
-            if (this.messages >= this.options.maxMessages) {
-              const err2 = new Error("Resource exhausted");
-              err2.code = EMAXLIMIT;
-              this.connection.close();
-              this._fail(err2);
-            } else {
-              this.pool._checkRateLimit(() => {
-                this.available = true;
-                this.emit("available");
-              });
-            }
-          });
+          setImmediate(() => this._release());
           callback(null, info);
         });
       }
+      /**
+       * Makes the connection available for the next message, or closes it once it has sent
+       * maxMessages messages
+       *
+       * @internal
+       */
+      _release() {
+        if (this.messages >= this.options.maxMessages) {
+          const err = new Error("Resource exhausted");
+          err.code = EMAXLIMIT;
+          this.connection.close();
+          this._fail(err);
+          return;
+        }
+        this.pool._checkRateLimit(() => {
+          this.available = true;
+          this._startIdleTimer();
+          this.emit("available");
+        });
+      }
+      /** @internal */
+      _startIdleTimer() {
+        if (!this.options.idleTimeout || this.options.idleTimeout < 0) {
+          return;
+        }
+        if (this._idleTimer && typeof this._idleTimer.refresh === "function") {
+          this._idleTimer.refresh();
+          return;
+        }
+        clearTimeout(this._idleTimer);
+        this._idleTimer = setTimeout(() => {
+          if (!this.available) {
+            return;
+          }
+          this.logger.debug({
+            tnx: "pool",
+            cid: this.id
+          }, "Closing connection #%s after it was idle for %sms", this.id, this.options.idleTimeout);
+          this.available = false;
+          this.connection.quit();
+        }, this.options.idleTimeout);
+        if (typeof this._idleTimer.unref === "function") {
+          this._idleTimer.unref();
+        }
+      }
+      /** @internal */
+      _stopIdleTimer() {
+        clearTimeout(this._idleTimer);
+        this._idleTimer = false;
+      }
       /**
        * Closes the connection
        */
       close() {
         this._connected = false;
+        this._stopIdleTimer();
         if (this.auth && this.auth.oauth2) {
           this.auth.oauth2.removeAllListeners();
         }
@@ -10048,10 +10516,10 @@ var init_pool_resource = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/well-known/services.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/well-known/services.js
 var services;
 var init_services = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/well-known/services.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/well-known/services.js"() {
     services = {
       "126": {
         "description": "126 Mail (NetEase)",
@@ -10725,7 +11193,7 @@ var init_services = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/well-known/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/well-known/index.js
 function normalizeKey(key) {
   return key.replace(/[^a-zA-Z0-9.-]/g, "").toLowerCase();
 }
@@ -10744,7 +11212,7 @@ function wellKnown(key) {
 }
 var normalized;
 var init_well_known = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/well-known/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/well-known/index.js"() {
     init_services();
     normalized = {};
     Object.keys(services).forEach((key) => {
@@ -10761,11 +11229,11 @@ var init_well_known = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-pool/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-pool/index.js
 import { EventEmitter as EventEmitter4 } from "node:events";
 var REQUEUE_BASE_DELAY, REQUEUE_MAX_DELAY, SMTPPool, smtp_pool_default;
 var init_smtp_pool = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-pool/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-pool/index.js"() {
     init_pool_resource();
     init_smtp_connection();
     init_well_known();
@@ -10805,6 +11273,7 @@ var init_smtp_pool = __esm({
         this.options.maxConnections = this.options.maxConnections || 5;
         this.options.maxMessages = this.options.maxMessages || 100;
         this.options.maxRequeues = typeof this.options.maxRequeues === "number" ? this.options.maxRequeues : 5;
+        this.options.idleTimeout = typeof this.options.idleTimeout === "number" ? this.options.idleTimeout : 4 * 60 * 1e3;
         this.logger = getLogger(this.options, {
           component: this.options.component || "smtp-pool"
         });
@@ -11174,7 +11643,8 @@ var init_smtp_pool = __esm({
         }
         const done = callback;
         const auth = new PoolResource(this).auth;
-        this.getSocket(this.options, (err, socketOptions) => {
+        const connectStartedAt = Date.now();
+        this.getSocket(Object.assign({}, this.options, { connectStartedAt }), (err, socketOptions) => {
           if (err) {
             return done(err);
           }
@@ -11191,6 +11661,7 @@ var init_smtp_pool = __esm({
             options = Object.assign(assign(false, options), socketOptions);
           }
           const connection = new smtp_connection_default(options);
+          connection._connectStartedAt = connectStartedAt;
           let returned = false;
           connection.once("error", (err2) => {
             if (returned) {
@@ -11254,11 +11725,11 @@ var init_smtp_pool = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-transport/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-transport/index.js
 import { EventEmitter as EventEmitter5 } from "node:events";
 var SMTPTransport, smtp_transport_default;
 var init_smtp_transport = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/smtp-transport/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/smtp-transport/index.js"() {
     init_smtp_connection();
     init_well_known();
     init_shared();
@@ -11359,7 +11830,8 @@ var init_smtp_transport = __esm({
        * @param callback Callback function
        */
       send(mail, callback) {
-        this.getSocket(this.options, (err, socketOptions) => {
+        const connectStartedAt = Date.now();
+        this.getSocket(Object.assign({}, this.options, { connectStartedAt }), (err, socketOptions) => {
           if (err) {
             return callback(err);
           }
@@ -11377,6 +11849,7 @@ var init_smtp_transport = __esm({
             options = Object.assign(assign(false, options), socketOptions);
           }
           const connection = new smtp_connection_default(options);
+          connection._connectStartedAt = connectStartedAt;
           let perCallAuth;
           const cleanupPerCallAuth = () => {
             if (perCallAuth && perCallAuth !== this.auth && perCallAuth.oauth2) {
@@ -11476,7 +11949,8 @@ var init_smtp_transport = __esm({
           });
         }
         const done = callback;
-        this.getSocket(this.options, (err, socketOptions) => {
+        const connectStartedAt = Date.now();
+        this.getSocket(Object.assign({}, this.options, { connectStartedAt }), (err, socketOptions) => {
           if (err) {
             return done(err);
           }
@@ -11493,6 +11967,7 @@ var init_smtp_transport = __esm({
             options = Object.assign(assign(false, options), socketOptions);
           }
           const connection = new smtp_connection_default(options);
+          connection._connectStartedAt = connectStartedAt;
           let returned = false;
           let perCallAuth;
           const cleanupPerCallAuth = () => {
@@ -11578,16 +12053,18 @@ var init_smtp_transport = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/sendmail-transport/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/sendmail-transport/index.js
 import { spawn } from "node:child_process";
-var SendmailTransport, sendmail_transport_default;
+import { pipeline as pipeline2 } from "node:stream";
+var STDIN_ERROR_EXIT_WAIT, SendmailTransport, sendmail_transport_default;
 var init_sendmail_transport = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/sendmail-transport/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/sendmail-transport/index.js"() {
     init_package_info();
     init_shared();
     init_errors();
     init_le_windows();
     init_le_unix();
+    STDIN_ERROR_EXIT_WAIT = 1e3;
     SendmailTransport = class {
       constructor(options) {
         options = options || {};
@@ -11658,35 +12135,63 @@ var init_sendmail_transport = __esm({
           return callback(E);
         }
         if (sendmail) {
+          let stream;
+          const messageWritten = () => !!stream && stream.readableEnded;
+          let stdinError = null;
+          const release = () => {
+            if (stream && !messageWritten()) {
+              stream.destroy();
+            }
+          };
+          const fail = (err) => {
+            release();
+            callback(err);
+          };
           sendmail.on("error", (err) => {
             this.logger.error({
               err,
               tnx: "spawn",
               messageId
             }, "Error occurred when sending message %s. %s", messageId, err.message);
-            callback(err);
+            fail(err);
           });
-          sendmail.once("exit", (code) => {
-            if (!code) {
+          const onExit = (code, signal) => {
+            let err = null;
+            if (code) {
+              err = new Error(code === 127 ? "Sendmail command not found, process exited with code " + code : "Sendmail exited with code " + code);
+            } else if (signal) {
+              err = new Error("Sendmail was terminated by " + signal);
+            } else if (!messageWritten()) {
+              err = new Error("Sendmail exited before the message was written");
+            } else if (stdinError) {
+              err = stdinError;
+            }
+            if (!err) {
               return callback();
             }
-            const err = new Error(code === 127 ? "Sendmail command not found, process exited with code " + code : "Sendmail exited with code " + code);
-            err.code = ESENDMAIL;
+            err.code = err.code || ESENDMAIL;
             this.logger.error({
               err,
               tnx: "stdin",
               messageId
             }, "Error sending message %s to sendmail. %s", messageId, err.message);
-            callback(err);
-          });
-          sendmail.once("close", callback);
+            fail(err);
+          };
+          sendmail.once("exit", onExit);
+          sendmail.once("close", onExit);
           sendmail.stdin.on("error", (err) => {
             this.logger.error({
               err,
               tnx: "stdin",
               messageId
             }, "Error occurred when piping message %s to sendmail. %s", messageId, err.message);
-            callback(err);
+            if (stdinError) {
+              return;
+            }
+            stdinError = err;
+            release();
+            const exitTimer = setTimeout(() => fail(err), STDIN_ERROR_EXIT_WAIT);
+            sendmail.once("exit", () => clearTimeout(exitTimer));
           });
           const recipients = [].concat(envelope.to || []);
           if (recipients.length > 3) {
@@ -11697,10 +12202,9 @@ var init_sendmail_transport = __esm({
             messageId
           }, "Sending message %s to <%s>", messageId, recipients.join(", "));
           const sourceStream = mail.message.createReadStream();
-          let stream = sourceStream;
+          stream = sourceStream;
           if (this.options.newline) {
-            stream = sourceStream.pipe(this.winbreak ? new LeWindows() : new LeUnix());
-            sourceStream.once("error", (err) => stream.emit("error", err));
+            stream = pipeline2(sourceStream, this.winbreak ? new LeWindows() : new LeUnix(), () => false);
           }
           stream.once("error", (err) => {
             this.logger.error({
@@ -11723,10 +12227,10 @@ var init_sendmail_transport = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/stream-transport/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/stream-transport/index.js
 var StreamTransport, stream_transport_default;
 var init_stream_transport = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/stream-transport/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/stream-transport/index.js"() {
     init_package_info();
     init_shared();
     init_le_windows();
@@ -11820,10 +12324,10 @@ var init_stream_transport = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/json-transport/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/json-transport/index.js
 var JSONTransport, json_transport_default;
 var init_json_transport = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/json-transport/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/json-transport/index.js"() {
     init_package_info();
     init_shared();
     JSONTransport = class {
@@ -11879,7 +12383,7 @@ var init_json_transport = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/ses-transport/index.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/ses-transport/index.js
 import EventEmitter6 from "node:events";
 function tagSesError(err) {
   if (err && typeof err === "object" && !err.code) {
@@ -11889,7 +12393,7 @@ function tagSesError(err) {
 }
 var SESTransport, ses_transport_default;
 var init_ses_transport = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/ses-transport/index.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/ses-transport/index.js"() {
     init_package_info();
     init_shared();
     init_errors();
@@ -12071,7 +12575,7 @@ var init_ses_transport = __esm({
   }
 });
 
-// node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/nodemailer.js
+// node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/nodemailer.js
 function createTransport(transporter, defaults) {
   let options;
   if (
@@ -12120,11 +12624,11 @@ function createTestAccount(apiUrl, callback) {
     });
   }
   const done = callback;
-  if (ETHEREAL_CACHE && testAccount) {
+  if (etherealCache() && testAccount) {
     setImmediate(() => done(null, testAccount));
     return promise;
   }
-  apiUrl = apiUrl || ETHEREAL_API;
+  apiUrl = apiUrl || etherealApi();
   const chunks = [];
   let chunklen = 0;
   const requestHeaders = {};
@@ -12132,8 +12636,9 @@ function createTestAccount(apiUrl, callback) {
     requestor: name,
     version
   };
-  if (ETHEREAL_API_KEY) {
-    requestHeaders.Authorization = "Bearer " + ETHEREAL_API_KEY;
+  const apiKey = etherealApiKey();
+  if (apiKey) {
+    requestHeaders.Authorization = "Bearer " + apiKey;
   }
   const fetchOptions = {
     contentType: "application/json",
@@ -12187,13 +12692,13 @@ function getTestMessageUrl(info) {
     }
   }
   if (infoProps.has("STATUS") && infoProps.has("MSGID")) {
-    return (testAccount && testAccount.web || ETHEREAL_WEB) + "/message/" + infoProps.get("MSGID");
+    return (testAccount && testAccount.web || etherealWeb()) + "/message/" + infoProps.get("MSGID");
   }
   return false;
 }
-var ETHEREAL_API, ETHEREAL_WEB, ETHEREAL_API_KEY, ETHEREAL_CACHE, testAccount, nodemailer, nodemailer_default;
+var etherealApi, etherealWeb, etherealApiKey, etherealCache, testAccount, nodemailer, nodemailer_default;
 var init_nodemailer = __esm({
-  "node_modules/.pnpm/nodemailer@10.0.16/node_modules/nodemailer/dist/esm/nodemailer.js"() {
+  "node_modules/.pnpm/nodemailer@10.1.1/node_modules/nodemailer/dist/esm/nodemailer.js"() {
     init_mailer();
     init_shared();
     init_smtp_pool();
@@ -12205,10 +12710,10 @@ var init_nodemailer = __esm({
     init_errors();
     init_fetch();
     init_package_info();
-    ETHEREAL_API = (process.env.ETHEREAL_API || "https://api.nodemailer.com").replace(/\/+$/, "");
-    ETHEREAL_WEB = (process.env.ETHEREAL_WEB || "https://ethereal.email").replace(/\/+$/, "");
-    ETHEREAL_API_KEY = (process.env.ETHEREAL_API_KEY || "").replace(/\s*/g, "") || null;
-    ETHEREAL_CACHE = ["true", "yes", "y", "1"].includes((process.env.ETHEREAL_CACHE || "yes").toString().trim().toLowerCase());
+    etherealApi = () => (process.env.ETHEREAL_API || "https://api.nodemailer.com").replace(/\/+$/, "");
+    etherealWeb = () => (process.env.ETHEREAL_WEB || "https://ethereal.email").replace(/\/+$/, "");
+    etherealApiKey = () => (process.env.ETHEREAL_API_KEY || "").replace(/\s*/g, "") || null;
+    etherealCache = () => ["true", "yes", "y", "1"].includes((process.env.ETHEREAL_CACHE || "yes").toString().trim().toLowerCase());
     testAccount = false;
     nodemailer = {
       createTransport,
@@ -15090,7 +15595,7 @@ var require_transport = __commonJS({
       stream.flushSync();
     }
     function transport(fullOptions) {
-      const { pipeline, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions;
+      const { pipeline: pipeline3, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions;
       const options = {
         ...fullOptions.options
       };
@@ -15118,9 +15623,9 @@ var require_transport = __commonJS({
             };
           });
         });
-      } else if (pipeline) {
+      } else if (pipeline3) {
         target = bundlerOverrides["pino-worker"] || join2(__dirname, "worker.js");
-        options.pipelines = [pipeline.map((dest) => {
+        options.pipelines = [pipeline3.map((dest) => {
           return {
             ...dest,
             target: fixTarget(dest.target)
@@ -15134,7 +15639,7 @@ var require_transport = __commonJS({
         options.dedupe = dedupe;
       }
       options.pinoWillSendConfig = true;
-      const name2 = targets || pipeline ? "pino.transport" : target;
+      const name2 = targets || pipeline3 ? "pino.transport" : target;
       return buildStream(fixTarget(target), options, worker, sync, name2);
       function fixTarget(origin) {
         origin = bundlerOverrides[origin] || origin;
@@ -37613,7 +38118,7 @@ var require_libbase64 = __commonJS({
       str2 = str2 || "";
       return Buffer2.from(str2, "base64");
     }
-    function wrap3(str2, lineLength) {
+    function wrap2(str2, lineLength) {
       str2 = (str2 || "").toString();
       lineLength = lineLength || 76;
       if (str2.length <= lineLength) {
@@ -37664,7 +38169,7 @@ var require_libbase64 = __commonJS({
         this.push(chunk);
       }
       _getWrapped(str2, isFinal) {
-        str2 = wrap3(str2, this.options.lineLength);
+        str2 = wrap2(str2, this.options.lineLength);
         if (!isFinal && str2.length === this.options.lineLength) {
           str2 += "\r\n";
         }
@@ -37764,7 +38269,7 @@ var require_libbase64 = __commonJS({
     module.exports = {
       encode: encode4,
       decode: decode2,
-      wrap: wrap3,
+      wrap: wrap2,
       Encoder: Encoder3,
       Decoder
     };
@@ -37821,7 +38326,7 @@ var require_libqp = __commonJS({
       }
       return buffer;
     }
-    function wrap3(str2, lineLength) {
+    function wrap2(str2, lineLength) {
       str2 = (str2 || "").toString();
       lineLength = lineLength || 76;
       if (str2.length <= lineLength) {
@@ -37914,7 +38419,7 @@ var require_libqp = __commonJS({
         this.inputBytes += chunk.length;
         if (this.options.lineLength) {
           qp = this._curLine + encode4(chunk);
-          qp = wrap3(qp, this.options.lineLength);
+          qp = wrap2(qp, this.options.lineLength);
           qp = qp.replace(/(^|\n)([^\n]*)$/, (match, lineBreak, lastLine) => {
             this._curLine = lastLine;
             return lineBreak;
@@ -37971,7 +38476,7 @@ var require_libqp = __commonJS({
     module.exports = {
       encode: encode4,
       decode: decode2,
-      wrap: wrap3,
+      wrap: wrap2,
       Encoder: Encoder3,
       Decoder
     };
@@ -56879,7 +57384,7 @@ var require_imap_flow = __commonJS({
         if (!range) {
           return false;
         }
-        let finished = false;
+        let finished3 = false;
         let aborted = false;
         let push = false;
         let rowQueue = [];
@@ -56892,7 +57397,7 @@ var require_imap_flow = __commonJS({
               }
               return resolve4(entry.value);
             }
-            if (finished) {
+            if (finished3) {
               return resolve4(null);
             }
             push = () => {
@@ -56922,7 +57427,7 @@ var require_imap_flow = __commonJS({
             }
           }
         }).then(() => {
-          finished = true;
+          finished3 = true;
           if (typeof push === "function") {
             push();
           }