@mxraven/mail 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2708 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_buffer = require("node:buffer");
+let node_net = require("node:net");
+let node_tls = require("node:tls");
+let node_crypto = require("node:crypto");
+//#region src/errors.ts
+/**
+* An SMTP reply that rejected a submission.
+*
+* It is thrown when the server refuses a command, for example when the sender
+* domain is not authorized or a recipient is rejected. Inspect {@link SMTPError.code}
+* or {@link SMTPError.enhancedCode} to make a delivery decision; the `message`
+* is intended for humans and is not stable.
+*
+* @public
+*/
+var SMTPError = class extends Error {
+	/** The three-digit SMTP reply code. */
+	code;
+	/** The RFC 3463 enhanced status code, when the server supplied one. */
+	enhancedCode;
+	/** @param options - The reply code, optional enhanced code, and reply text. */
+	constructor(options) {
+		super(options.message);
+		this.name = "SMTPError";
+		this.code = options.code;
+		this.enhancedCode = options.enhancedCode;
+	}
+	/** Reports whether the failure is permanent (5xx). Retrying is unlikely to succeed. */
+	get permanent() {
+		return this.code >= 500 && this.code < 600;
+	}
+	/** Reports whether the failure is transient (4xx). The message may be retried later. */
+	get transient() {
+		return this.code >= 400 && this.code < 500;
+	}
+};
+/**
+* A submission the server rejected after per-recipient results were collected.
+*
+* It is thrown when every envelope recipient was rejected. The per-recipient
+* detail remains available in {@link SMTPTransactionError.result}.
+*
+* @public
+*/
+var SMTPTransactionError = class extends Error {
+	/** The per-recipient results collected before the failure. */
+	result;
+	/**
+	* @param message - A human-readable description.
+	* @param result - The partial submission result.
+	*/
+	constructor(message, result) {
+		super(message);
+		this.name = "SMTPTransactionError";
+		this.result = result;
+	}
+};
+//#endregion
+//#region src/internal/address.ts
+/**
+* RFC 5322 mailbox parsing and formatting.
+*
+* This module is internal to the SDK. It implements the RFC 5322 mailbox
+* grammar, including comments and folding whitespace (`CFWS`), quoted strings,
+* quoted local parts, domain literals, and internationalized addresses.
+*
+* Group syntax (`display-name: mailbox-list;`) is not supported.
+*
+* @internal
+*/
+/** Reports whether a string contains a non-ASCII code unit. */
+function containsNonAscii(value) {
+	for (let index = 0; index < value.length; index += 1) if (value.charCodeAt(index) >= 128) return true;
+	return false;
+}
+/** Returns the bare `local@domain` form of an address. */
+function mailboxToString(address) {
+	if (address.localPart === "" && address.domain === "") return "";
+	return `${needsQuoting(address.localPart) ? `"${address.localPart.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"` : address.localPart}@${address.domain}`;
+}
+/**
+* Parses a single mailbox address.
+*
+* Accepts the RFC 5322 `mailbox` productions — `addr-spec`,
+* `[display-name] angle-addr` — with comments and folding whitespace anywhere
+* the grammar permits them. Comments are discarded except for a trailing
+* comment after a bare `addr-spec`, which is used as the display name.
+*
+* @param input - The address text.
+* @returns The parsed mailbox.
+* @throws `Error` When the input contains a line break, is empty, or is not a
+* valid mailbox.
+*
+* @internal
+*/
+function parseAddress(input) {
+	return new AddressParser(input).parse();
+}
+/** Formats one address for use in a header field. */
+function formatAddress(address) {
+	const email = mailboxToString(address);
+	const name = address.displayName;
+	if (name === void 0 || name === "") return email;
+	if (containsNonAscii(name)) return `${encodeRfc2047(name)} <${email}>`;
+	if (/[!"(),.:;<>@[\\\]]/.test(name)) return `"${name.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}" <${email}>`;
+	return `${name} <${email}>`;
+}
+/** Formats several addresses as a comma-separated header value. */
+function formatAddressList(addresses) {
+	return addresses.map(formatAddress).join(", ");
+}
+/** Encodes a string using RFC 2047 Base64 (`=?UTF-8?B?...?=`). */
+function encodeRfc2047(value) {
+	return `=?UTF-8?B?${node_buffer.Buffer.from(value, "utf8").toString("base64")}?=`;
+}
+/** Reports whether a local part must be quoted when serialized. */
+function needsQuoting(localPart) {
+	if (containsNonAscii(localPart)) return false;
+	if (localPart.startsWith(".") || localPart.endsWith(".") || localPart.includes("..")) return true;
+	return /[^A-Za-z0-9!#$%&'*+/=?^_`{|}~.-]/.test(localPart);
+}
+/** Reports whether a code point is an RFC 5322 `atext` character. */
+function isAtext(char) {
+	const code = char.charCodeAt(0);
+	if (code >= 65 && code <= 90 || code >= 97 && code <= 122 || code >= 48 && code <= 57) return true;
+	switch (char) {
+		case "!":
+		case "#":
+		case "$":
+		case "%":
+		case "&":
+		case "'":
+		case "*":
+		case "+":
+		case "-":
+		case "/":
+		case "=":
+		case "?":
+		case "^":
+		case "_":
+		case "`":
+		case "{":
+		case "|":
+		case "}":
+		case "~": return true;
+		default: return false;
+	}
+}
+/** Joins phrase words, attaching stray dots without a preceding space. */
+function joinPhrase(words) {
+	let result = "";
+	for (const word of words) if (word === ".") result += ".";
+	else if (result === "") result = word;
+	else result += ` ${word}`;
+	return result;
+}
+/** A recursive-descent parser for one RFC 5322 mailbox. */
+var AddressParser = class {
+	source;
+	chars;
+	pos = 0;
+	constructor(source) {
+		this.source = source;
+		this.chars = [...source];
+	}
+	parse() {
+		const start = this.pos;
+		this.skipCfws();
+		if (this.peek() === "<") {
+			const angle = this.parseAngleAddr();
+			this.skipCfws();
+			this.requireEnd();
+			return angle;
+		}
+		this.pos = start;
+		this.skipCfws();
+		const spec = this.tryAddrSpec();
+		if (spec !== void 0) {
+			const name = this.consumeTrailingComment();
+			if (this.atEnd()) return name === void 0 ? spec : {
+				localPart: spec.localPart,
+				domain: spec.domain,
+				displayName: name
+			};
+		}
+		this.pos = start;
+		this.skipCfws();
+		const displayName = this.parsePhrase();
+		this.skipCfws();
+		if (this.peek() !== "<") this.fail(`invalid address ${JSON.stringify(this.source)}`);
+		const angle = this.parseAngleAddr();
+		this.skipCfws();
+		this.requireEnd();
+		return displayName === "" ? angle : {
+			localPart: angle.localPart,
+			domain: angle.domain,
+			displayName
+		};
+	}
+	tryAddrSpec() {
+		const save = this.pos;
+		try {
+			return this.parseAddrSpec();
+		} catch {
+			this.pos = save;
+			return;
+		}
+	}
+	parseAddrSpec() {
+		const localPart = this.parseLocalPart();
+		this.skipCfws();
+		this.expect("@");
+		this.skipCfws();
+		return {
+			localPart,
+			domain: this.parseDomain()
+		};
+	}
+	parseLocalPart() {
+		if (this.peek() === "\"") return this.parseQuotedString();
+		return this.parseDotAtomText(true);
+	}
+	parseDomain() {
+		if (this.peek() === "[") return this.parseDomainLiteral();
+		return this.parseDotAtomText(true);
+	}
+	parseAngleAddr() {
+		this.skipCfws();
+		this.expect("<");
+		this.skipCfws();
+		const spec = this.parseAddrSpec();
+		this.skipCfws();
+		this.expect(">");
+		return spec;
+	}
+	parsePhrase() {
+		const words = [];
+		for (;;) {
+			this.skipCfws();
+			const char = this.peek();
+			if (char === void 0 || char === "<" || char === ":" || char === "@" || char === ",") break;
+			if (char === ".") {
+				words.push(".");
+				this.pos += 1;
+				continue;
+			}
+			if (char === "\"") {
+				words.push(this.parseQuotedString());
+				continue;
+			}
+			words.push(this.parseAtom(true));
+		}
+		return joinPhrase(words);
+	}
+	parseAtom(allowUtf8) {
+		const start = this.pos;
+		for (;;) {
+			const char = this.peek();
+			if (char === void 0) break;
+			if (isAtext(char) || allowUtf8 && (char.codePointAt(0) ?? 0) >= 128) {
+				this.pos += 1;
+				continue;
+			}
+			break;
+		}
+		if (this.pos === start) this.fail(`expected an atom in ${JSON.stringify(this.source)}`);
+		return this.chars.slice(start, this.pos).join("");
+	}
+	parseDotAtomText(allowUtf8) {
+		let value = this.parseAtom(allowUtf8);
+		while (this.peek() === ".") {
+			this.pos += 1;
+			value += `.${this.parseAtom(allowUtf8)}`;
+		}
+		return value;
+	}
+	parseQuotedString() {
+		this.expect("\"");
+		let value = "";
+		for (;;) {
+			const char = this.peek();
+			if (char === void 0) this.fail(`unterminated quoted string in ${JSON.stringify(this.source)}`);
+			if (char === "\"") {
+				this.pos += 1;
+				return value;
+			}
+			if (char === "\\") {
+				this.pos += 1;
+				const escaped = this.peek();
+				if (escaped === void 0 || escaped === "\r" || escaped === "\n" || escaped === "\0") this.fail(`invalid quoted pair in ${JSON.stringify(this.source)}`);
+				value += escaped;
+				this.pos += 1;
+				continue;
+			}
+			if (char === "\r" || char === "\n") {
+				value += this.consumeFoldedWhitespace();
+				continue;
+			}
+			if ((char.codePointAt(0) ?? 0) < 32 && char !== "	") this.fail(`invalid character in quoted string ${JSON.stringify(this.source)}`);
+			value += char;
+			this.pos += 1;
+		}
+	}
+	parseDomainLiteral() {
+		this.expect("[");
+		let value = "";
+		for (;;) {
+			const char = this.peek();
+			if (char === void 0) this.fail(`unterminated domain literal in ${JSON.stringify(this.source)}`);
+			if (char === "]") {
+				this.pos += 1;
+				return `[${value}]`;
+			}
+			if (char === "\\") {
+				this.pos += 1;
+				const escaped = this.peek();
+				if (escaped === void 0 || escaped === "\r" || escaped === "\n") this.fail(`invalid quoted pair in domain literal`);
+				value += escaped;
+				this.pos += 1;
+				continue;
+			}
+			const code = char.codePointAt(0) ?? 0;
+			if (code < 33 || code > 126 || char === "[") this.fail(`invalid character in domain literal ${JSON.stringify(this.source)}`);
+			value += char;
+			this.pos += 1;
+		}
+	}
+	consumeTrailingComment() {
+		let name;
+		for (;;) {
+			this.skipFws();
+			if (this.peek() !== "(") break;
+			const text = this.consumeComment();
+			if (name === void 0 && text !== "") name = text;
+		}
+		return name;
+	}
+	consumeComment() {
+		this.expect("(");
+		let depth = 1;
+		let text = "";
+		for (;;) {
+			const char = this.peek();
+			if (char === void 0) this.fail(`unterminated comment in ${JSON.stringify(this.source)}`);
+			if (char === "(") {
+				depth += 1;
+				this.pos += 1;
+				text = appendWordSeparator(text);
+				continue;
+			}
+			if (char === ")") {
+				depth -= 1;
+				this.pos += 1;
+				if (depth === 0) return text.trim();
+				text = appendWordSeparator(text);
+				continue;
+			}
+			if (char === "\\") {
+				this.pos += 1;
+				const escaped = this.peek();
+				if (escaped === void 0 || escaped === "\r" || escaped === "\n" || escaped === "\0") this.fail(`invalid quoted pair in comment`);
+				text += escaped;
+				this.pos += 1;
+				continue;
+			}
+			if (char === "\r" || char === "\n") {
+				text += this.consumeFoldedWhitespace();
+				continue;
+			}
+			if ((char.codePointAt(0) ?? 0) < 32 && char !== "	") this.fail(`invalid character in comment ${JSON.stringify(this.source)}`);
+			text += char;
+			this.pos += 1;
+		}
+	}
+	skipCfws() {
+		for (;;) {
+			this.skipFws();
+			if (this.peek() === "(") {
+				this.consumeComment();
+				continue;
+			}
+			break;
+		}
+	}
+	skipFws() {
+		for (;;) {
+			const char = this.peek();
+			if (char === " " || char === "	") {
+				this.pos += 1;
+				continue;
+			}
+			if (char === "\r" || char === "\n") {
+				this.consumeFoldedWhitespace();
+				continue;
+			}
+			break;
+		}
+	}
+	consumeFoldedWhitespace() {
+		if (this.peek() === "\r") {
+			if (this.lookahead(1) !== "\n") this.fail("bare carriage return");
+			if (this.lookahead(2) !== " " && this.lookahead(2) !== "	") this.fail("folding without trailing whitespace");
+			this.pos += 3;
+		} else this.fail("bare line feed");
+		while (this.peek() === " " || this.peek() === "	") this.pos += 1;
+		return " ";
+	}
+	expect(char) {
+		if (this.peek() !== char) this.fail(`expected ${JSON.stringify(char)} in ${JSON.stringify(this.source)}`);
+		this.pos += 1;
+	}
+	requireEnd() {
+		if (!this.atEnd()) this.fail(`unexpected text after address in ${JSON.stringify(this.source)}`);
+	}
+	atEnd() {
+		return this.pos >= this.chars.length;
+	}
+	peek() {
+		return this.chars[this.pos];
+	}
+	lookahead(offset) {
+		return this.chars[this.pos + offset];
+	}
+	fail(message) {
+		throw new Error(`mail: ${message}`);
+	}
+};
+/** Ensures a comment word separator between accumulated fragments. */
+function appendWordSeparator(text) {
+	return text === "" || text.endsWith(" ") ? text : `${text} `;
+}
+//#endregion
+//#region src/internal/smtp/errors.ts
+/** The category of an {@link SmtpSessionError}. */
+const smtpSessionErrorKind = {
+	/** The session has already been closed. */
+	clientClosed: "client-closed",
+	/** No connection has been established. */
+	noConnection: "no-connection",
+	/** The connection was closed by the peer. */
+	connectionClosed: "connection-closed",
+	/** The server did not advertise a required extension. */
+	extensionNotSupported: "extension-not-supported",
+	/** Authentication failed. */
+	authFailed: "auth-failed",
+	/** No credentials were configured for authentication. */
+	noCredentials: "no-credentials",
+	/** The requested authentication mechanism is not supported. */
+	unsupportedMechanism: "unsupported-mechanism",
+	/** The envelope has no recipients. */
+	noRecipients: "no-recipients",
+	/** The transaction failed because every recipient was rejected. */
+	transactionFailed: "transaction-failed",
+	/** The server refused the DATA command. */
+	dataFailed: "data-failed",
+	/** The server does not support the requested DELIVERBY extension. */
+	deliveryByNotSupported: "delivery-by-not-supported",
+	/** The connection is already protected by TLS. */
+	tlsAlreadyActive: "tls-already-active",
+	/** The server does not support STARTTLS. */
+	tlsNotSupported: "tls-not-supported",
+	/** The server sent a malformed response. */
+	unexpectedResponse: "unexpected-response"
+};
+/** Reports a connection or session state failure. */
+var SmtpSessionError = class extends Error {
+	/** The failure category. */
+	kind;
+	/**
+	* @param kind - The failure category.
+	* @param message - A human-readable description.
+	* @param options - An optional cause.
+	*/
+	constructor(kind, message, options) {
+		super(message, options);
+		this.name = "SmtpSessionError";
+		this.kind = kind;
+	}
+};
+/** Reports that an SMTP operation exceeded its deadline. */
+var SmtpTimeoutError = class extends Error {
+	/**
+	* @param operation - The operation that timed out.
+	*/
+	constructor(operation) {
+		super(`smtp: ${operation} timed out`);
+		this.name = "SmtpTimeoutError";
+	}
+};
+/** Reports an aborted SMTP operation. */
+var SmtpAbortError = class extends Error {
+	/**
+	* @param options - The abort cause.
+	*/
+	constructor(options) {
+		super("smtp: operation aborted", options);
+		this.name = "SmtpAbortError";
+	}
+};
+/** Reports a transaction failure that still has per-recipient results. */
+var SmtpTransactionError = class extends SmtpSessionError {
+	/** The per-recipient results collected before the failure. */
+	result;
+	/**
+	* @param message - A human-readable description.
+	* @param result - The partial transaction result.
+	*/
+	constructor(message, result) {
+		super(smtpSessionErrorKind.transactionFailed, message);
+		this.name = "SmtpTransactionError";
+		this.result = result;
+	}
+};
+//#endregion
+//#region src/internal/smtp/extensions.ts
+/**
+* SMTP extension parsing and capability inspection.
+*
+* @internal
+*/
+/** Extension names advertised in an EHLO reply. */
+const smtpExtension = {
+	/** `SIZE`, with the maximum message size as its parameter. */
+	size: "SIZE",
+	/** `PIPELINING`. */
+	pipelining: "PIPELINING",
+	/** `8BITMIME`. */
+	eightBitMime: "8BITMIME",
+	/** `AUTH`, with the supported mechanisms as its parameter. */
+	auth: "AUTH",
+	/** `STARTTLS`. */
+	startTls: "STARTTLS",
+	/** `ENHANCEDSTATUSCODES`. */
+	enhancedStatusCodes: "ENHANCEDSTATUSCODES",
+	/** `SMTPUTF8`. */
+	smtpUtf8: "SMTPUTF8",
+	/** `DSN`. */
+	dsn: "DSN",
+	/** `CHUNKING`. */
+	chunking: "CHUNKING",
+	/** `BINARYMIME`. */
+	binaryMime: "BINARYMIME",
+	/** `DELIVERBY`, with the minimum interval in seconds as its parameter. */
+	deliverBy: "DELIVERBY",
+	/** `REQUIRETLS` (RFC 8689). */
+	requireTls: "REQUIRETLS"
+};
+/**
+* Parses EHLO reply lines into an extension map.
+*
+* The first line carries the server greeting and is ignored; each subsequent
+* line is `NAME` or `NAME params`.
+*
+* @param lines - The EHLO reply text lines.
+* @returns The advertised extensions keyed by uppercase name.
+*/
+function parseExtensions(lines) {
+	const extensions = /* @__PURE__ */ new Map();
+	for (const line of lines.slice(1)) {
+		const separator = line.indexOf(" ");
+		if (separator === -1) extensions.set(line.toUpperCase(), "");
+		else extensions.set(line.slice(0, separator).toUpperCase(), line.slice(separator + 1));
+	}
+	return extensions;
+}
+/**
+* Builds a capability view over an extension map.
+*
+* @param extensions - The extensions keyed by uppercase name.
+* @param isEsmtp - Whether EHLO succeeded.
+* @param hostname - The server hostname from the EHLO reply.
+* @returns A read-only capability view.
+*/
+function capabilitiesFrom(extensions, isEsmtp, hostname) {
+	const getExtensionParam = (name) => extensions.get(name.toUpperCase()) ?? "";
+	const hasExtension = (name) => extensions.has(name.toUpperCase());
+	const auth = getExtensionParam(smtpExtension.auth).split(/\s+/).filter((value) => value !== "");
+	return {
+		isEsmtp,
+		hostname,
+		tls: hasExtension(smtpExtension.startTls),
+		pipelining: hasExtension(smtpExtension.pipelining),
+		eightBitMime: hasExtension(smtpExtension.eightBitMime),
+		smtpUtf8: hasExtension(smtpExtension.smtpUtf8),
+		dsn: hasExtension(smtpExtension.dsn),
+		chunking: hasExtension(smtpExtension.chunking),
+		binaryMime: hasExtension(smtpExtension.binaryMime),
+		enhancedStatusCodes: hasExtension(smtpExtension.enhancedStatusCodes),
+		deliveryBy: hasExtension(smtpExtension.deliverBy),
+		deliveryByMinSeconds: parsePositiveInt(getExtensionParam(smtpExtension.deliverBy)),
+		maxSize: parsePositiveInt(getExtensionParam(smtpExtension.size)),
+		auth,
+		hasExtension,
+		getExtensionParam,
+		supportsAuth: (mechanism) => auth.some((advertised) => advertised.toLowerCase() === mechanism.toLowerCase())
+	};
+}
+/** Parses a non-negative decimal integer, returning 0 when invalid. */
+function parsePositiveInt(value) {
+	if (!/^\d+$/.test(value.trim())) return 0;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isSafeInteger(parsed) ? parsed : 0;
+}
+//#endregion
+//#region src/internal/smtp/auth.ts
+/**
+* SASL mechanism selection and encoding.
+*
+* Only `PLAIN` and `LOGIN` are supported, matching the submission service.
+*
+* @internal
+*/
+/**
+* Selects an authentication mechanism the server also advertises.
+*
+* When the caller provides preferred mechanisms they are tried in order;
+* otherwise `PLAIN` is preferred over `LOGIN`, matching the server's own
+* capability ordering.
+*
+* @param preferred - Client-preferred mechanisms, in order.
+* @param serverMechanisms - Mechanisms advertised by the server.
+* @returns The selected mechanism in uppercase, or an empty string.
+*/
+function selectAuthMechanism(preferred, serverMechanisms) {
+	if (preferred.length > 0) {
+		for (const candidate of preferred) if (serverMechanisms.some((server) => server.toLowerCase() === candidate.toLowerCase())) return candidate.toUpperCase();
+		return "";
+	}
+	for (const candidate of ["PLAIN", "LOGIN"]) if (serverMechanisms.some((server) => server.toLowerCase() === candidate.toLowerCase())) return candidate;
+	return "";
+}
+/**
+* Encodes `PLAIN` credentials as `\0username\0password`.
+*
+* @param username - The submission key username.
+* @param password - The submission key secret.
+* @returns The Base64-encoded SASL payload.
+*/
+function encodePlainAuth(username, password) {
+	return node_buffer.Buffer.from(`\u0000${username}\u0000${password}`, "utf8").toString("base64");
+}
+/**
+* Encodes one `LOGIN` step.
+*
+* @param value - The username or password.
+* @returns The Base64-encoded value.
+*/
+function encodeLoginAuth(value) {
+	return node_buffer.Buffer.from(value, "utf8").toString("base64");
+}
+//#endregion
+//#region src/internal/smtp/connection.ts
+/**
+* A CRLF line-oriented socket connection used by the SMTP session.
+*
+* The connection owns a single TCP or TLS socket, buffers incoming bytes, and
+* resolves one line at a time. Reads and writes are sequential, as SMTP
+* requires; a connection is never used concurrently.
+*
+* @internal
+*/
+/** A line-oriented connection over TCP or TLS. */
+var LineConnection = class LineConnection {
+	socket;
+	buffer = node_buffer.Buffer.alloc(0);
+	pending;
+	failure;
+	closed = false;
+	constructor(socket) {
+		this.socket = socket;
+		this.attach();
+	}
+	/** Opens a plain TCP connection. */
+	static async openTcp(options, signal) {
+		const socket = (0, node_net.connect)({
+			host: options.host,
+			port: options.port,
+			localAddress: options.localAddress
+		});
+		try {
+			await waitForReady(socket, "connect", options.connectTimeout, signal, "connect");
+		} catch (error) {
+			socket.destroy();
+			throw error;
+		}
+		return new LineConnection(socket);
+	}
+	/** Opens a connection using implicit TLS. */
+	static async openTls(options, signal) {
+		const raw = (0, node_net.connect)({
+			host: options.host,
+			port: options.port,
+			localAddress: options.localAddress
+		});
+		await waitForReady(raw, "connect", options.connectTimeout, signal, "connect");
+		const socket = (0, node_tls.connect)({
+			...options.tls,
+			socket: raw
+		});
+		try {
+			await waitForReady(socket, "secureConnect", options.connectTimeout, signal, "start TLS");
+		} catch (error) {
+			raw.destroy();
+			throw error;
+		}
+		return new LineConnection(socket);
+	}
+	/** Reports whether the connection is protected by TLS. */
+	get isTls() {
+		return this.socket instanceof node_tls.TLSSocket;
+	}
+	/** Reads one CRLF-terminated line, including its terminator. */
+	readLine(options) {
+		if (this.failure !== void 0) return Promise.reject(this.failure);
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			let timer;
+			let onAbort;
+			const cleanup = () => {
+				if (timer !== void 0) clearTimeout(timer);
+				if (onAbort !== void 0) options.signal?.removeEventListener("abort", onAbort);
+			};
+			const settle = (settleWith) => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				if (this.pending === pending) this.pending = void 0;
+				settleWith();
+			};
+			const pending = {
+				resolve: (line) => settle(() => resolve(line)),
+				reject: (error) => settle(() => reject(error))
+			};
+			if (options.signal?.aborted === true) {
+				settle(() => reject(abortError(options.signal)));
+				return;
+			}
+			timer = setTimeout(() => settle(() => reject(new SmtpTimeoutError(options.operation))), options.timeout);
+			onAbort = () => settle(() => reject(abortError(options.signal)));
+			options.signal?.addEventListener("abort", onAbort, { once: true });
+			this.pending = pending;
+			this.drain();
+		});
+	}
+	/** Writes bytes to the connection. */
+	write(data, options) {
+		if (this.failure !== void 0) return Promise.reject(this.failure);
+		return new Promise((resolve, reject) => {
+			let settled = false;
+			let timer;
+			let onAbort;
+			const cleanup = () => {
+				if (timer !== void 0) clearTimeout(timer);
+				if (onAbort !== void 0) options.signal?.removeEventListener("abort", onAbort);
+			};
+			const settle = (settleWith) => {
+				if (settled) return;
+				settled = true;
+				cleanup();
+				settleWith();
+			};
+			if (options.signal?.aborted === true) {
+				settle(() => reject(abortError(options.signal)));
+				return;
+			}
+			timer = setTimeout(() => settle(() => reject(new SmtpTimeoutError(options.operation))), options.timeout);
+			onAbort = () => settle(() => reject(abortError(options.signal)));
+			options.signal?.addEventListener("abort", onAbort, { once: true });
+			this.socket.write(data, (error) => {
+				if (error !== void 0 && error !== null) settle(() => reject(error));
+				else settle(resolve);
+			});
+		});
+	}
+	/** Upgrades the connection to TLS after a successful STARTTLS reply. */
+	async upgradeToTls(options, timeout, signal) {
+		if (this.failure !== void 0) throw this.failure;
+		this.detach();
+		const secure = (0, node_tls.connect)({
+			...options,
+			socket: this.socket
+		});
+		this.socket = secure;
+		this.attach();
+		try {
+			await waitForReady(secure, "secureConnect", timeout, signal, "start TLS");
+		} catch (error) {
+			secure.destroy();
+			throw error;
+		}
+	}
+	/** Closes the connection. It is safe to call more than once. */
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.detach();
+		this.socket.destroy();
+	}
+	attach() {
+		this.socket.on("data", this.handleData);
+		this.socket.on("error", this.handleError);
+		this.socket.on("close", this.handleClose);
+	}
+	detach() {
+		this.socket.off("data", this.handleData);
+		this.socket.off("error", this.handleError);
+		this.socket.off("close", this.handleClose);
+	}
+	handleData = (chunk) => {
+		this.buffer = this.buffer.length === 0 ? chunk : node_buffer.Buffer.concat([this.buffer, chunk]);
+		this.drain();
+	};
+	handleError = (error) => {
+		this.fail(error);
+	};
+	handleClose = () => {
+		this.fail(new SmtpSessionError(smtpSessionErrorKind.connectionClosed, "smtp: connection closed"));
+	};
+	drain() {
+		const pending = this.pending;
+		if (pending === void 0) return;
+		const index = this.buffer.indexOf(10);
+		if (index < 0) return;
+		const line = this.buffer.subarray(0, index + 1).toString("utf8");
+		this.buffer = this.buffer.subarray(index + 1);
+		this.pending = void 0;
+		pending.resolve(line);
+	}
+	fail(error) {
+		if (this.closed) return;
+		this.failure = error;
+		const pending = this.pending;
+		this.pending = void 0;
+		pending?.reject(error);
+	}
+};
+/** Waits for a socket to finish connecting or handshaking. */
+function waitForReady(socket, event, timeout, signal, operation) {
+	return new Promise((resolve, reject) => {
+		let settled = false;
+		let timer;
+		let onAbort;
+		const cleanup = () => {
+			socket.off(event, onReady);
+			socket.off("error", onError);
+			socket.off("close", onClose);
+			if (timer !== void 0) clearTimeout(timer);
+			if (onAbort !== void 0) signal?.removeEventListener("abort", onAbort);
+		};
+		const settle = (settleWith) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			settleWith();
+		};
+		const onReady = () => settle(resolve);
+		const onError = (error) => settle(() => reject(error));
+		const onClose = () => settle(() => reject(new SmtpSessionError(smtpSessionErrorKind.connectionClosed, "smtp: connection closed before it was ready")));
+		if (signal?.aborted === true) {
+			settle(() => reject(abortError(signal)));
+			return;
+		}
+		socket.once(event, onReady);
+		socket.once("error", onError);
+		socket.once("close", onClose);
+		timer = setTimeout(() => settle(() => reject(new SmtpTimeoutError(operation))), timeout);
+		onAbort = () => settle(() => reject(abortError(signal)));
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+/** Builds the error used when an operation observes an aborted signal. */
+function abortError(signal) {
+	return new SmtpAbortError({ cause: signal?.reason });
+}
+//#endregion
+//#region src/internal/smtp/response.ts
+/**
+* SMTP reply parsing.
+*
+* @internal
+*/
+/** Reports whether a reply code indicates success (2xx). */
+function isSuccess(code) {
+	return code >= 200 && code < 300;
+}
+/** Reports whether a reply code indicates an intermediate reply (3xx). */
+function isIntermediate(code) {
+	return code >= 300 && code < 400;
+}
+/**
+* Converts a non-success reply into an {@link SMTPError}.
+*
+* @param response - The reply to inspect.
+* @returns An error for 4xx and 5xx replies, or `undefined` for 2xx and 3xx.
+*/
+function responseError(response) {
+	if (isSuccess(response.code) || isIntermediate(response.code)) return;
+	return new SMTPError({
+		code: response.code,
+		enhancedCode: response.enhancedCode === "" ? void 0 : response.enhancedCode,
+		message: response.message
+	});
+}
+/**
+* Extracts an RFC 3463 enhanced status code from the start of a reply text.
+*
+* @param message - The first line of a reply.
+* @returns The `X.Y.Z` code, or an empty string when the text does not start
+* with a valid code.
+*/
+function parseEnhancedCode(message) {
+	if (message.length < 5) return "";
+	const token = message.split(" ", 1)[0] ?? "";
+	const parts = token.split(".");
+	if (parts.length !== 3) return "";
+	for (const part of parts) if (!/^\d+$/.test(part)) return "";
+	return token;
+}
+//#endregion
+//#region src/internal/smtp/dsn.ts
+/**
+* RFC 3461 Delivery Status Notification parameter formatting.
+*
+* Only the encoding direction is needed when building commands, but xtext
+* parsing is included for symmetry and testing.
+*
+* @internal
+*/
+/** The maximum length of an `ENVID=` parameter, including the keyword. */
+const MAX_ENVELOPE_ID_LENGTH = 100;
+/** The maximum length of an `ORCPT=` parameter, including the keyword. */
+const MAX_ORIGINAL_RECIPIENT_LENGTH = 500;
+/**
+* Encodes a value as RFC 3461 xtext.
+*
+* @param decoded - The value to encode.
+* @returns The encoded value.
+*/
+function encodeXtext(decoded) {
+	let encoded = "";
+	for (let index = 0; index < decoded.length; index += 1) {
+		const code = decoded.charCodeAt(index);
+		if (code >= 33 && code <= 126 && code !== 43 && code !== 61) {
+			encoded += decoded[index];
+			continue;
+		}
+		encoded += `+${toHex(code >> 4)}${toHex(code & 15)}`;
+	}
+	return encoded;
+}
+/**
+* Validates and upper-cases a `RET` value.
+*
+* @param value - `FULL` or `HDRS`, case-insensitively.
+* @returns The canonical value.
+* @throws `Error` When the value is not `FULL` or `HDRS`.
+*/
+function normalizeDsnReturn(value) {
+	if (/[\r\n]/.test(value)) throw new Error("dsn: RET contains a line break");
+	const normalized = value.toUpperCase();
+	if (normalized !== "FULL" && normalized !== "HDRS") throw new Error("dsn: RET must be FULL or HDRS");
+	return normalized;
+}
+/**
+* Validates and upper-cases `NOTIFY` values.
+*
+* `NEVER` is valid only as the sole value.
+*
+* @param values - The values to normalize.
+* @returns The canonical values.
+* @throws `Error` When a value is invalid or `NEVER` is combined.
+*/
+function normalizeDsnNotify(values) {
+	if (values.length === 0) throw new Error("dsn: NOTIFY value is empty");
+	const normalized = [];
+	for (const value of values) {
+		if (value === "" || /[\r\n]/.test(value)) throw new Error("dsn: invalid NOTIFY value");
+		const upper = value.toUpperCase();
+		if (upper !== "NEVER" && upper !== "SUCCESS" && upper !== "FAILURE" && upper !== "DELAY") throw new Error(`dsn: invalid NOTIFY value ${JSON.stringify(value)}`);
+		normalized.push(upper);
+	}
+	if (normalized.includes("NEVER") && normalized.length !== 1) throw new Error("dsn: NOTIFY NEVER must appear alone");
+	return normalized;
+}
+/**
+* Encodes a decoded envelope identifier as its `ENVID` wire value.
+*
+* @param decoded - The printable-ASCII envelope identifier.
+* @returns The encoded value, without the `ENVID=` prefix.
+* @throws `Error` When the value is empty, non-printable, or too long.
+*/
+function formatDsnEnvelopeId(decoded) {
+	if (decoded === "" || !isPrintableAscii(decoded)) throw new Error("dsn: invalid ENVID decoded value");
+	const wire = encodeXtext(decoded);
+	if (wire.length + 6 > MAX_ENVELOPE_ID_LENGTH) throw new Error(`dsn: ENVID exceeds ${MAX_ENVELOPE_ID_LENGTH} characters`);
+	return wire;
+}
+/**
+* Encodes a decoded original recipient as its `ORCPT` wire value.
+*
+* @param addressType - The address type, for example `rfc822` or `utf-8`.
+* @param decoded - The decoded original recipient.
+* @param smtpUtf8 - Whether the session negotiated SMTPUTF8.
+* @returns The `address-type;encoded-address` value.
+* @throws `Error` When the address type or value is invalid.
+*/
+function formatDsnOriginalRecipient(addressType, decoded, smtpUtf8) {
+	if (!isAtom(addressType)) throw new Error("dsn: invalid ORCPT address type");
+	let encoded;
+	if (addressType.toLowerCase() === "utf-8") encoded = encodeUtf8Orcpt(decoded, smtpUtf8);
+	else {
+		if (decoded === "" || !isPrintableAscii(decoded)) throw new Error("dsn: invalid ORCPT decoded address");
+		encoded = encodeXtext(decoded);
+	}
+	const wire = `${addressType};${encoded}`;
+	if (wire.length + 6 > MAX_ORIGINAL_RECIPIENT_LENGTH) throw new Error(`dsn: ORCPT exceeds ${MAX_ORIGINAL_RECIPIENT_LENGTH} characters`);
+	return wire;
+}
+/** Encodes a UTF-8 original recipient using `\x{...}` escapes when needed. */
+function encodeUtf8Orcpt(address, smtpUtf8) {
+	if (address === "" || /[\r\n]/.test(address)) throw new Error("dsn: invalid UTF-8 ORCPT address");
+	let encoded = "";
+	for (const char of address) {
+		const code = char.codePointAt(0) ?? 0;
+		if (code < 128 && isQChar(code)) {
+			encoded += char;
+			continue;
+		}
+		if (code >= 128 && smtpUtf8) {
+			encoded += char;
+			continue;
+		}
+		encoded += `\\x{${code.toString(16).toUpperCase()}}`;
+	}
+	return encoded;
+}
+/** Reports whether a string is non-empty printable US-ASCII. */
+function isPrintableAscii(value) {
+	if (value === "") return false;
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code !== 9 && (code < 32 || code > 126)) return false;
+	}
+	return true;
+}
+/** Reports whether a string is a valid RFC 3461 `atom`. */
+function isAtom(value) {
+	if (value === "") return false;
+	for (const char of value) {
+		if (/[A-Za-z0-9]/.test(char) || "!#$%&'*+-/?^_`{|}~".includes(char)) continue;
+		return false;
+	}
+	return true;
+}
+/** Reports whether a code point may appear literally in a UTF-8 ORCPT. */
+function isQChar(code) {
+	return code >= 33 && code <= 126 && code !== 92 && code !== 43 && code !== 61;
+}
+/** Converts one hexadecimal nibble to its uppercase character. */
+function toHex(nibble) {
+	return nibble.toString(16).toUpperCase();
+}
+/**
+* Builds the `MAIL FROM` command for an envelope.
+*
+* @param context - The server capabilities.
+* @param envelope - The envelope.
+* @returns The command without a terminating CRLF.
+* @throws {@link SMTPError} When `REQUIRETLS` is requested but unavailable.
+* @throws {@link SmtpSessionError} When `DELIVERBY` is requested but unsupported.
+*/
+function buildMailFromCommand(context, envelope) {
+	const params = [];
+	if (context.hasExtension(smtpExtension.size) && envelope.size !== void 0 && envelope.size > 0) params.push(`SIZE=${envelope.size}`);
+	if (envelope.bodyType === "8BITMIME" && context.hasExtension(smtpExtension.eightBitMime)) params.push("BODY=8BITMIME");
+	if (envelope.bodyType === "BINARYMIME" && context.hasExtension(smtpExtension.binaryMime)) params.push("BODY=BINARYMIME");
+	if (envelope.smtpUtf8 === true && context.hasExtension(smtpExtension.smtpUtf8)) params.push("SMTPUTF8");
+	if (envelope.requireTls === true) {
+		if (!context.isTls) throw new SMTPError({
+			code: 550,
+			enhancedCode: "5.7.30",
+			message: "REQUIRETLS requires an active TLS session"
+		});
+		if (!context.hasExtension(smtpExtension.requireTls)) throw new SMTPError({
+			code: 550,
+			enhancedCode: "5.7.30",
+			message: "REQUIRETLS support required"
+		});
+		params.push("REQUIRETLS");
+	}
+	if (envelope.deliveryBy !== void 0) {
+		if (!context.hasExtension(smtpExtension.deliverBy)) throw new SmtpSessionError(smtpSessionErrorKind.deliveryByNotSupported, "smtp: server does not support DELIVERBY");
+		const value = formatDeliveryBy(envelope.deliveryBy);
+		if (envelope.deliveryBy.mode === "R") {
+			const minimum = parseDeliveryByMinimum(context.getExtensionParam(smtpExtension.deliverBy));
+			if (minimum > 0 && envelope.deliveryBy.seconds < minimum) throw new Error(`smtp: DELIVERYBY BY time ${envelope.deliveryBy.seconds} is below server minimum ${minimum}`);
+		}
+		params.push(`BY=${value}`);
+	}
+	if (envelope.auth !== void 0 && envelope.auth !== "") params.push(`AUTH=<${envelope.auth}>`);
+	if (envelope.dsnRet !== void 0 && envelope.dsnRet !== "" && context.hasExtension(smtpExtension.dsn)) params.push(`RET=${normalizeDsnReturn(envelope.dsnRet)}`);
+	if (envelope.envid !== void 0 && envelope.envid !== "" && context.hasExtension(smtpExtension.dsn)) params.push(`ENVID=${formatDsnEnvelopeId(envelope.envid)}`);
+	for (const [name, value] of envelope.extensionParams ?? []) {
+		if (name.toUpperCase() === "BY" && envelope.deliveryBy !== void 0) continue;
+		params.push(value === "" ? name.toUpperCase() : `${name.toUpperCase()}=${value}`);
+	}
+	const command = `MAIL FROM:${envelope.from === void 0 ? "<>" : `<${mailboxToString(envelope.from)}>`}`;
+	return params.length > 0 ? `${command} ${params.join(" ")}` : command;
+}
+/**
+* Builds the `RCPT TO` command for one recipient.
+*
+* @param context - The server capabilities.
+* @param recipient - The recipient.
+* @param smtpUtf8 - Whether the envelope negotiated SMTPUTF8.
+* @returns The command without a terminating CRLF.
+* @throws `Error` When a DSN parameter is malformed.
+*/
+function buildRcptToCommand(context, recipient, smtpUtf8) {
+	const params = [];
+	if (context.hasExtension(smtpExtension.dsn)) {
+		if (recipient.dsnNotify !== void 0 && recipient.dsnNotify.length > 0) params.push(`NOTIFY=${normalizeDsnNotify(recipient.dsnNotify).join(",")}`);
+		if (recipient.dsnOrcpt !== void 0 && recipient.dsnOrcpt !== "") {
+			const separator = recipient.dsnOrcpt.indexOf(";");
+			if (separator < 0) throw new Error("smtp: invalid DSN ORCPT: expected address-type;address");
+			const addressType = recipient.dsnOrcpt.slice(0, separator);
+			const address = recipient.dsnOrcpt.slice(separator + 1);
+			params.push(`ORCPT=${formatDsnOriginalRecipient(addressType, address, smtpUtf8)}`);
+		}
+	}
+	const command = `RCPT TO:<${mailboxToString(recipient.address)}>`;
+	return params.length > 0 ? `${command} ${params.join(" ")}` : command;
+}
+/** Builds the per-recipient outcome from a reply. */
+function recipientOutcome(recipient, response) {
+	const address = mailboxToString(recipient.address);
+	if (isSuccess(response.code)) return {
+		address,
+		accepted: true,
+		response
+	};
+	return {
+		address,
+		accepted: false,
+		response,
+		error: new SMTPError({
+			code: response.code,
+			enhancedCode: response.enhancedCode === "" ? void 0 : response.enhancedCode,
+			message: response.message
+		})
+	};
+}
+/** Formats a DELIVERBY value. */
+function formatDeliveryBy(deliveryBy) {
+	const mode = deliveryBy.mode.toUpperCase();
+	if (mode !== "N" && mode !== "R") throw new Error(`smtp: invalid DELIVERYBY mode ${JSON.stringify(deliveryBy.mode)}`);
+	if (mode === "R" && deliveryBy.seconds <= 0) throw new Error("smtp: DELIVERYBY mode R requires seconds > 0");
+	return `${deliveryBy.seconds};${mode}${deliveryBy.trace === true ? "T" : ""}`;
+}
+/** Parses a DELIVERBY minimum interval, returning 0 when absent or invalid. */
+function parseDeliveryByMinimum(value) {
+	const trimmed = value.trim();
+	if (!/^\d+$/.test(trimmed)) return 0;
+	const parsed = Number.parseInt(trimmed, 10);
+	return Number.isSafeInteger(parsed) ? parsed : 0;
+}
+/**
+* Applies dot-stuffing to one chunk, carrying line-start state across chunks.
+*
+* @param chunk - The chunk to stuff.
+* @param atLineStart - Whether the chunk starts a line.
+* @returns The stuffed chunk and the next line-start state.
+*/
+function dotStuffChunk(chunk, atLineStart) {
+	let output;
+	let state = atLineStart;
+	for (let index = 0; index < chunk.length; index += 1) {
+		const byte = chunk[index] ?? 0;
+		if (state && byte === 46) {
+			output ??= Array.from(chunk.subarray(0, index));
+			output.push(46);
+		}
+		output?.push(byte);
+		state = byte === 10;
+	}
+	return {
+		data: output === void 0 ? chunk : Uint8Array.from(output),
+		atLineStart: state
+	};
+}
+/**
+* Extracts a message identifier from a final reply.
+*
+* Recognizes angle-bracketed identifiers, `queued as <id>`, and `id=<id>`.
+*
+* @param message - The reply text.
+* @returns The identifier, or an empty string.
+*/
+function extractMessageId(message) {
+	const trimmed = message.trim();
+	const start = trimmed.indexOf("<");
+	if (start !== -1) {
+		const end = trimmed.indexOf(">", start);
+		if (end !== -1) return trimmed.slice(start, end + 1);
+	}
+	const lower = trimmed.toLowerCase();
+	const queued = lower.indexOf("queued as ");
+	if (queued !== -1) {
+		const parts = trimmed.slice(queued + 10).trim().split(/\s+/);
+		if ((parts[0] ?? "") !== "") return parts[0] ?? "";
+	}
+	const id = lower.indexOf("id=");
+	if (id !== -1) {
+		const parts = trimmed.slice(id + 3).trim().split(/\s+/);
+		if ((parts[0] ?? "") !== "") return parts[0] ?? "";
+	}
+	return "";
+}
+//#endregion
+//#region src/internal/smtp/session.ts
+/**
+* The SMTP session: connect, EHLO, STARTTLS, AUTH, and the stateless commands.
+*
+* A session is bound to a single connection and is not safe for concurrent use.
+* Higher layers (the dialer and pool) own session lifecycle.
+*
+* @internal
+*/
+const DEFAULT_LOCAL_NAME$1 = "localhost";
+const DEFAULT_CONNECT_TIMEOUT$1 = 3e4;
+const DEFAULT_READ_TIMEOUT = 3e5;
+const DEFAULT_WRITE_TIMEOUT = 3e5;
+/** An SMTP session over one connection. */
+var SmtpSession = class {
+	options;
+	connection;
+	extensions = /* @__PURE__ */ new Map();
+	esmtp = false;
+	authenticated = false;
+	closed = false;
+	greetingText = "";
+	hostnameText = "";
+	serverNameText = "";
+	lastResponseValue;
+	constructor(options) {
+		this.options = {
+			...options,
+			localName: options.localName ?? DEFAULT_LOCAL_NAME$1,
+			connectTimeout: options.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT$1,
+			readTimeout: options.readTimeout ?? DEFAULT_READ_TIMEOUT,
+			writeTimeout: options.writeTimeout ?? DEFAULT_WRITE_TIMEOUT
+		};
+	}
+	/** The server hostname reported in the greeting. */
+	get greeting() {
+		return this.greetingText;
+	}
+	/** The server host as configured. */
+	get serverName() {
+		return this.serverNameText;
+	}
+	/** The most recent reply, or `undefined` before the first reply. */
+	get lastResponse() {
+		return this.lastResponseValue;
+	}
+	/** Whether the connection is protected by TLS. */
+	get isTls() {
+		return this.connection?.isTls ?? false;
+	}
+	/** Whether EHLO was accepted. */
+	get isEsmtp() {
+		return this.esmtp;
+	}
+	/** Whether authentication succeeded. */
+	get isAuthenticated() {
+		return this.authenticated;
+	}
+	/** Returns a copy of the advertised extensions. */
+	extensionsSnapshot() {
+		return new Map(this.extensions);
+	}
+	/** Reports whether the server advertised an extension. */
+	hasExtension(name) {
+		return this.extensions.has(name.toUpperCase());
+	}
+	/** Returns an extension's parameter, or an empty string. */
+	getExtensionParam(name) {
+		return this.extensions.get(name.toUpperCase()) ?? "";
+	}
+	/** Returns a read-only view of the server capabilities. */
+	capabilities() {
+		return capabilitiesFrom(this.extensions, this.esmtp, this.hostnameText);
+	}
+	/** Returns the maximum message size advertised via `SIZE`, or 0. */
+	maxSize() {
+		return this.capabilities().maxSize;
+	}
+	/** Connects over plain TCP and reads the greeting. */
+	async connect(signal) {
+		await this.open(false, signal);
+	}
+	/** Connects using implicit TLS and reads the greeting. */
+	async connectTls(signal) {
+		await this.open(true, signal);
+	}
+	/** Sends EHLO, falling back to HELO when EHLO is rejected. */
+	async hello(signal) {
+		this.requireConnection();
+		this.ensureNotClosed();
+		const response = await this.command(`EHLO ${this.options.localName}`, signal);
+		if (isSuccess(response.code)) {
+			this.esmtp = true;
+			this.extensions = parseExtensions(response.lines);
+			this.hostnameText = (response.lines[0] ?? "").split(" ")[0] ?? "";
+			return;
+		}
+		const fallback = await this.command(`HELO ${this.options.localName}`, signal);
+		if (!isSuccess(fallback.code)) throw this.requireReplyError(fallback);
+		this.esmtp = false;
+		this.extensions = /* @__PURE__ */ new Map();
+		this.hostnameText = "";
+	}
+	/** Upgrades the connection with STARTTLS. */
+	async startTls(signal) {
+		const connection = this.requireConnection();
+		if (connection.isTls) throw new SmtpSessionError(smtpSessionErrorKind.tlsAlreadyActive, "smtp: TLS is already active");
+		if (!this.hasExtension(smtpExtension.startTls)) throw new SmtpSessionError(smtpSessionErrorKind.tlsNotSupported, "smtp: server does not support STARTTLS");
+		const response = await this.command("STARTTLS", signal);
+		if (!isSuccess(response.code)) throw this.requireReplyError(response);
+		await connection.upgradeToTls(this.tlsOptions(), this.options.connectTimeout, signal);
+		this.extensions = /* @__PURE__ */ new Map();
+		this.esmtp = false;
+		this.hostnameText = "";
+	}
+	/** Authenticates using a mechanism advertised by the server. */
+	async auth(signal) {
+		this.requireConnection();
+		const auth = this.options.auth;
+		if (auth === void 0) throw new SmtpSessionError(smtpSessionErrorKind.noCredentials, "smtp: no authentication credentials configured");
+		if (!this.hasExtension(smtpExtension.auth)) throw new SmtpSessionError(smtpSessionErrorKind.extensionNotSupported, "smtp: server does not support the AUTH extension");
+		const mechanisms = this.getExtensionParam(smtpExtension.auth).split(/\s+/).filter((value) => value !== "");
+		const mechanism = selectAuthMechanism(auth.mechanisms ?? [], mechanisms);
+		if (mechanism === "") throw new SmtpSessionError(smtpSessionErrorKind.authFailed, "smtp: no supported authentication mechanism available");
+		await this.authWithMechanism(mechanism, signal);
+	}
+	/** Authenticates using an explicit mechanism. */
+	async authWithMechanism(mechanism, signal) {
+		this.requireConnection();
+		const auth = this.options.auth;
+		if (auth === void 0) throw new SmtpSessionError(smtpSessionErrorKind.noCredentials, "smtp: no authentication credentials configured");
+		switch (mechanism.toUpperCase()) {
+			case "PLAIN":
+				await this.authPlain(auth, signal);
+				return;
+			case "LOGIN":
+				await this.authLogin(auth, signal);
+				return;
+			default: throw new SmtpSessionError(smtpSessionErrorKind.unsupportedMechanism, `smtp: unsupported authentication mechanism: ${mechanism}`);
+		}
+	}
+	/** Sends RSET. */
+	async reset(signal) {
+		const response = await this.command("RSET", signal);
+		if (!isSuccess(response.code)) throw this.requireReplyError(response);
+	}
+	/** Sends NOOP. */
+	async noop(signal) {
+		const response = await this.command("NOOP", signal);
+		if (!isSuccess(response.code)) throw this.requireReplyError(response);
+	}
+	/** Sends QUIT and closes the connection, ignoring reply failures. */
+	async quit(signal) {
+		const connection = this.requireConnection();
+		try {
+			await this.writeCommand("QUIT", signal);
+			await this.readReply(signal);
+		} catch {} finally {
+			connection.close();
+			this.connection = void 0;
+			this.authenticated = false;
+		}
+	}
+	/** Closes the connection. It is safe to call more than once. */
+	close() {
+		this.closed = true;
+		this.connection?.close();
+		this.connection = void 0;
+		this.authenticated = false;
+	}
+	async open(implicitTls, signal) {
+		this.ensureNotClosed();
+		if (this.connection !== void 0) {
+			this.connection.close();
+			this.connection = void 0;
+		}
+		const options = this.connectionOptions();
+		this.connection = implicitTls ? await LineConnection.openTls(options, signal) : await LineConnection.openTcp(options, signal);
+		this.serverNameText = this.options.host;
+		const response = await this.readReply(signal);
+		if (!isSuccess(response.code)) {
+			this.connection.close();
+			this.connection = void 0;
+			throw this.requireReplyError(response);
+		}
+		this.greetingText = response.message;
+	}
+	async authPlain(auth, signal) {
+		const response = await this.command(`AUTH PLAIN ${encodePlainAuth(auth.username, auth.password)}`, signal);
+		if (!isSuccess(response.code)) throw new SmtpSessionError(smtpSessionErrorKind.authFailed, `smtp: authentication failed: ${response.message}`);
+		this.authenticated = true;
+	}
+	async authLogin(auth, signal) {
+		const challenge = await this.command("AUTH LOGIN", signal);
+		if (challenge.code !== 334) throw new SmtpSessionError(smtpSessionErrorKind.authFailed, `smtp: authentication failed: unexpected response ${challenge.code}`);
+		const passwordChallenge = await this.command(encodeLoginAuth(auth.username), signal);
+		if (passwordChallenge.code !== 334) throw new SmtpSessionError(smtpSessionErrorKind.authFailed, `smtp: authentication failed: unexpected response ${passwordChallenge.code}`);
+		const response = await this.command(encodeLoginAuth(auth.password), signal);
+		if (!isSuccess(response.code)) throw new SmtpSessionError(smtpSessionErrorKind.authFailed, `smtp: authentication failed: ${response.message}`);
+		this.authenticated = true;
+	}
+	async command(command, signal) {
+		await this.writeCommand(command, signal);
+		return this.readReply(signal);
+	}
+	async writeCommand(command, signal) {
+		const connection = this.requireConnection();
+		this.options.debug?.("client", command);
+		const verb = command.split(" ", 1)[0] ?? command;
+		await connection.write(`${command}\r\n`, {
+			signal,
+			timeout: this.options.writeTimeout,
+			operation: `write ${verb}`
+		});
+	}
+	async readReply(signal) {
+		const connection = this.requireConnection();
+		const lines = [];
+		let code = 0;
+		for (;;) {
+			const line = (await connection.readLine({
+				signal,
+				timeout: this.options.readTimeout,
+				operation: "read reply"
+			})).replace(/\r?\n$/, "");
+			this.options.debug?.("server", line);
+			if (line.length < 4) throw new SmtpSessionError(smtpSessionErrorKind.unexpectedResponse, `smtp: malformed reply line ${JSON.stringify(line)}`);
+			if (!/^\d{3}$/.test(line.slice(0, 3))) throw new SmtpSessionError(smtpSessionErrorKind.unexpectedResponse, `smtp: invalid reply code in ${JSON.stringify(line)}`);
+			const lineCode = Number.parseInt(line.slice(0, 3), 10);
+			if (code === 0) code = lineCode;
+			else if (lineCode !== code) throw new SmtpSessionError(smtpSessionErrorKind.unexpectedResponse, "smtp: reply used inconsistent status codes");
+			lines.push(line.length > 4 ? line.slice(4) : "");
+			if (line[3] === " ") break;
+		}
+		const response = {
+			code,
+			message: lines.join("\n"),
+			lines,
+			enhancedCode: parseEnhancedCode(lines[0] ?? "")
+		};
+		this.lastResponseValue = response;
+		return response;
+	}
+	/**
+	* Runs a mail transaction for an already-serialized message.
+	*
+	* When the message is a single buffer larger than 1 MiB and the server
+	* advertises `CHUNKING`, a single BDAT transfer is used; otherwise the
+	* payload is streamed with DATA and dot-stuffing.
+	*/
+	async send(envelope, data, options = {}, signal) {
+		return this.runTransaction(envelope, data, options, true, signal);
+	}
+	/**
+	* Runs a mail transaction for a raw message stream.
+	*
+	* Unlike {@link SmtpSession.send}, a large payload is not automatically sent
+	* with BDAT; chunked BDAT is used only when `options.preferBdat` is set.
+	*/
+	async sendRaw(envelope, data, options = {}, signal) {
+		return this.runTransaction(envelope, data, options, false, signal);
+	}
+	/** Sends RSET when a transaction fails, ignoring any further error. */
+	async bestEffortReset(signal) {
+		try {
+			await this.writeCommand("RSET", signal);
+			await this.readReply(signal);
+		} catch {}
+	}
+	/** Writes raw bytes with the configured write deadline. */
+	async writeBlock(data, signal) {
+		await this.requireConnection().write(data, {
+			signal,
+			timeout: this.options.writeTimeout,
+			operation: "write data"
+		});
+	}
+	async runTransaction(envelope, data, options, autoBdat, signal) {
+		this.requireConnection();
+		if (envelope.recipients.length === 0) throw new SmtpSessionError(smtpSessionErrorKind.noRecipients, "smtp: no recipients specified");
+		const [result, accepted] = await this.sendEnvelope(envelope, options, signal);
+		if (accepted === 0) {
+			await this.bestEffortReset(signal);
+			throw new SmtpTransactionError("smtp: transaction failed: all recipients rejected", result);
+		}
+		const chunks = toAsyncChunks(data);
+		const knownSize = data instanceof Uint8Array ? data.byteLength : void 0;
+		if (options.preferBdat === true && this.hasExtension(smtpExtension.chunking)) await this.sendBdatChunked(chunks, options.chunkSize ?? 65536, signal);
+		else if (autoBdat && this.hasExtension(smtpExtension.chunking) && knownSize !== void 0 && knownSize > 1048576) await this.sendBdatSingle(data, signal);
+		else {
+			const response = await this.sendData(chunks, signal);
+			result.response = response;
+			result.messageId = extractMessageId(response.message);
+		}
+		result.success = true;
+		return result;
+	}
+	async sendEnvelope(envelope, options, signal) {
+		const smtpUtf8 = envelope.smtpUtf8 === true;
+		buildMailFromCommand(this, envelope);
+		for (const recipient of envelope.recipients) buildRcptToCommand(this, recipient, smtpUtf8);
+		if (this.hasExtension(smtpExtension.pipelining)) return this.sendEnvelopePipelined(envelope, options, signal);
+		return this.sendEnvelopeSequential(envelope, options, signal);
+	}
+	async sendEnvelopeSequential(envelope, options, signal) {
+		const result = {
+			success: false,
+			messageId: "",
+			recipients: []
+		};
+		const smtpUtf8 = envelope.smtpUtf8 === true;
+		await this.writeCommand(buildMailFromCommand(this, envelope), signal);
+		const mailResponse = await this.readReply(signal);
+		if (!isSuccess(mailResponse.code)) throw this.requireReplyError(mailResponse);
+		let accepted = 0;
+		for (const recipient of envelope.recipients) {
+			const outcome = await this.sendRcptTo(recipient, smtpUtf8, signal);
+			result.recipients.push(outcome);
+			if (outcome.accepted) accepted += 1;
+			else if (options.requireAllRecipients === true) {
+				await this.bestEffortReset(signal);
+				throw new SmtpTransactionError(`smtp: transaction failed: recipient ${outcome.address} rejected`, result);
+			}
+		}
+		return [result, accepted];
+	}
+	async sendEnvelopePipelined(envelope, options, signal) {
+		const smtpUtf8 = envelope.smtpUtf8 === true;
+		const commands = [buildMailFromCommand(this, envelope), ...envelope.recipients.map((recipient) => buildRcptToCommand(this, recipient, smtpUtf8))];
+		await this.writePipeline(commands, signal);
+		const mailResponse = await this.readReply(signal);
+		const result = {
+			success: false,
+			messageId: "",
+			recipients: []
+		};
+		let accepted = 0;
+		let firstRejected = "";
+		for (const recipient of envelope.recipients) {
+			let response;
+			try {
+				response = await this.readReply(signal);
+			} catch (error) {
+				result.recipients.push({
+					address: mailboxToString(recipient.address),
+					accepted: false,
+					error: error instanceof Error ? error : new Error(String(error))
+				});
+				return [result, accepted];
+			}
+			const outcome = recipientOutcome(recipient, response);
+			result.recipients.push(outcome);
+			if (outcome.accepted) accepted += 1;
+			else if (firstRejected === "") firstRejected = outcome.address;
+		}
+		if (!isSuccess(mailResponse.code)) throw this.requireReplyError(mailResponse);
+		if (options.requireAllRecipients === true && firstRejected !== "") {
+			await this.bestEffortReset(signal);
+			throw new SmtpTransactionError(`smtp: transaction failed: recipient ${firstRejected} rejected`, result);
+		}
+		return [result, accepted];
+	}
+	async sendRcptTo(recipient, smtpUtf8, signal) {
+		const address = mailboxToString(recipient.address);
+		try {
+			await this.writeCommand(buildRcptToCommand(this, recipient, smtpUtf8), signal);
+		} catch (error) {
+			return {
+				address,
+				accepted: false,
+				error: contextError(error, `write RCPT TO for ${address}`)
+			};
+		}
+		try {
+			return recipientOutcome(recipient, await this.readReply(signal));
+		} catch (error) {
+			return {
+				address,
+				accepted: false,
+				error: contextError(error, `read RCPT TO for ${address}`)
+			};
+		}
+	}
+	async sendData(chunks, signal) {
+		await this.writeCommand("DATA", signal);
+		const intermediate = await this.readReply(signal);
+		if (!isIntermediate(intermediate.code)) throw new SmtpSessionError(smtpSessionErrorKind.dataFailed, `smtp: DATA command failed: expected 354, got ${intermediate.code}`);
+		let atLineStart = true;
+		let previous = 0;
+		let last = 0;
+		let wrote = false;
+		for await (const chunk of chunks) {
+			const stuffed = dotStuffChunk(chunk, atLineStart);
+			atLineStart = stuffed.atLineStart;
+			if (chunk.length > 0) {
+				if (chunk.length >= 2) previous = chunk[chunk.length - 2] ?? 0;
+				else previous = last;
+				last = chunk[chunk.length - 1] ?? 0;
+				wrote = true;
+			}
+			await this.writeBlock(stuffed.data, signal);
+		}
+		if (wrote && (previous !== 13 || last !== 10)) await this.writeBlock("\r\n", signal);
+		await this.writeBlock(".\r\n", signal);
+		const final = await this.readReply(signal);
+		if (!isSuccess(final.code)) throw this.requireReplyError(final);
+		return final;
+	}
+	async sendBdatSingle(data, signal) {
+		await this.writeCommand(`BDAT ${data.byteLength} LAST`, signal);
+		await this.writeBlock(data, signal);
+		const response = await this.readReply(signal);
+		if (!isSuccess(response.code)) throw this.requireReplyError(response);
+	}
+	async sendBdatChunked(chunks, chunkSize, signal) {
+		if (!Number.isInteger(chunkSize) || chunkSize <= 0) throw new Error("smtp: BDAT chunk size must be positive");
+		const iterator = rechunk(chunks, chunkSize);
+		const first = await iterator.next();
+		if (first.done) {
+			await this.writeCommand("BDAT 0 LAST", signal);
+			const response = await this.readReply(signal);
+			if (!isSuccess(response.code)) throw this.requireReplyError(response);
+			return;
+		}
+		let current = first.value;
+		for (;;) {
+			const next = await iterator.next();
+			const isLast = next.done;
+			await this.writeCommand(`BDAT ${current.byteLength}${isLast ? " LAST" : ""}`, signal);
+			await this.writeBlock(current, signal);
+			const response = await this.readReply(signal);
+			if (!isSuccess(response.code)) throw this.requireReplyError(response);
+			if (isLast) return;
+			current = next.value;
+		}
+	}
+	async writePipeline(commands, signal) {
+		let payload = "";
+		for (const command of commands) {
+			this.options.debug?.("client", command);
+			payload += `${command}\r\n`;
+		}
+		await this.writeBlock(payload, signal);
+	}
+	requireConnection() {
+		if (this.connection === void 0) throw new SmtpSessionError(smtpSessionErrorKind.noConnection, "smtp: no connection established");
+		return this.connection;
+	}
+	ensureNotClosed() {
+		if (this.closed) throw new SmtpSessionError(smtpSessionErrorKind.clientClosed, "smtp: client is closed");
+	}
+	requireReplyError(response) {
+		return responseError(response) ?? new SmtpSessionError(smtpSessionErrorKind.unexpectedResponse, `smtp: unexpected reply ${response.code}`);
+	}
+	connectionOptions() {
+		return {
+			host: this.options.host,
+			port: this.options.port,
+			connectTimeout: this.options.connectTimeout,
+			readTimeout: this.options.readTimeout,
+			localAddress: this.options.localAddress,
+			tls: this.tlsOptions()
+		};
+	}
+	tlsOptions() {
+		const tls = { ...this.options.tls };
+		if (tls.servername === void 0 && (0, node_net.isIP)(this.options.host) === 0) tls.servername = this.options.host;
+		return tls;
+	}
+};
+/** Normalizes a buffer or async iterable into an async iterable of chunks. */
+async function* toAsyncChunks(data) {
+	if (data instanceof Uint8Array) {
+		yield data;
+		return;
+	}
+	yield* data;
+}
+/** Splits an async chunk stream into pieces no larger than `chunkSize`. */
+async function* rechunk(source, chunkSize) {
+	for await (const chunk of source) for (let offset = 0; offset < chunk.length; offset += chunkSize) yield chunk.subarray(offset, Math.min(offset + chunkSize, chunk.length));
+}
+/** Adds a short context label to an unknown thrown value. */
+function contextError(error, label) {
+	const message = error instanceof Error ? error.message : String(error);
+	return new Error(`smtp: ${label}: ${message}`, { cause: error });
+}
+//#endregion
+//#region src/internal/smtp/dialer.ts
+const DEFAULT_LOCAL_NAME = "localhost";
+const DEFAULT_CONNECT_TIMEOUT = 3e4;
+const DEFAULT_IO_TIMEOUT = 3e5;
+/** Opens and initializes SMTP sessions. */
+var SmtpDialer = class {
+	/** The configured host. */
+	host;
+	/** The configured port. */
+	port;
+	/** The EHLO name. */
+	localName;
+	/** The TCP connect deadline in milliseconds. */
+	connectTimeout;
+	/** The per-read deadline in milliseconds. */
+	readTimeout;
+	/** The per-write deadline in milliseconds. */
+	writeTimeout;
+	options;
+	constructor(options) {
+		this.options = options;
+		this.host = options.host;
+		this.port = options.port;
+		this.localName = options.localName ?? DEFAULT_LOCAL_NAME;
+		this.connectTimeout = options.connectTimeout ?? DEFAULT_CONNECT_TIMEOUT;
+		this.readTimeout = options.readTimeout ?? DEFAULT_IO_TIMEOUT;
+		this.writeTimeout = options.writeTimeout ?? DEFAULT_IO_TIMEOUT;
+	}
+	/**
+	* Opens and initializes a session.
+	*
+	* On any failure the partially established session is closed before the
+	* error is rethrown.
+	*
+	* @param signal - Cancels the dial.
+	* @returns A connected, greeted, and optionally authenticated session.
+	*/
+	async dial(signal) {
+		const session = new SmtpSession(this.sessionOptions());
+		try {
+			if (this.options.implicitTls === true) await session.connectTls(signal);
+			else await session.connect(signal);
+			await session.hello(signal);
+			if (this.options.startTls === true && this.options.implicitTls !== true) {
+				if (session.hasExtension(smtpExtension.startTls)) {
+					await session.startTls(signal);
+					await session.hello(signal);
+				} else if (this.options.requireTls === true) throw new SmtpSessionError(smtpSessionErrorKind.tlsNotSupported, "smtp: server does not support STARTTLS");
+			}
+			if (this.options.auth !== void 0) await session.auth(signal);
+			return session;
+		} catch (error) {
+			session.close();
+			throw error;
+		}
+	}
+	sessionOptions() {
+		return {
+			host: this.host,
+			port: this.port,
+			localName: this.localName,
+			localAddress: this.options.localAddress,
+			connectTimeout: this.connectTimeout,
+			readTimeout: this.readTimeout,
+			writeTimeout: this.writeTimeout,
+			tls: this.options.tls,
+			auth: this.options.auth,
+			debug: this.options.debug
+		};
+	}
+};
+//#endregion
+//#region src/internal/smtp/pool.ts
+const DEFAULT_POOL_SIZE$1 = 5;
+/** A bounded pool of SMTP sessions. */
+var SmtpPool = class {
+	/** The maximum number of live sessions. */
+	size;
+	dialer;
+	healthCheck;
+	idle = [];
+	owned = /* @__PURE__ */ new Set();
+	waiters = [];
+	live = 0;
+	closed = false;
+	constructor(options) {
+		this.dialer = options.dialer;
+		this.size = options.size !== void 0 && options.size > 0 ? options.size : DEFAULT_POOL_SIZE$1;
+		this.healthCheck = options.healthCheck !== false;
+	}
+	/** Whether the pool has been closed. */
+	get isClosed() {
+		return this.closed;
+	}
+	/**
+	* Acquires an initialized session, waiting for capacity when necessary.
+	*
+	* @param signal - Cancels capacity waiting and dialing.
+	* @returns A session that is checked out to the caller.
+	* @throws {@link SmtpSessionError} With kind `client-closed` when the pool is
+	* closed.
+	*/
+	async acquire(signal) {
+		for (;;) {
+			if (signal?.aborted === true) throw new SmtpAbortError({ cause: signal.reason });
+			const idle = this.idle.pop();
+			if (idle !== void 0) {
+				if (!this.healthCheck) return idle;
+				try {
+					await idle.noop(signal);
+					return idle;
+				} catch {
+					this.destroy(idle);
+					continue;
+				}
+			}
+			if (this.closed) throw this.closedError();
+			if (this.live < this.size) {
+				this.live += 1;
+				try {
+					const session = await this.dialer.dial(signal);
+					if (this.closed) {
+						this.live -= 1;
+						session.close();
+						this.wake();
+						throw this.closedError();
+					}
+					this.owned.add(session);
+					return session;
+				} catch (error) {
+					this.live -= 1;
+					this.wake();
+					throw error;
+				}
+			}
+			await this.waitForSlot(signal);
+		}
+	}
+	/**
+	* Returns a session to the pool.
+	*
+	* A session not owned by this pool is closed and never admitted.
+	*
+	* @param session - The session to return.
+	*/
+	release(session) {
+		if (!this.owned.has(session)) {
+			session.close();
+			return;
+		}
+		if (this.closed) {
+			this.destroy(session);
+			return;
+		}
+		this.idle.push(session);
+		this.wake();
+	}
+	/** Closes idle sessions and rejects callers waiting for capacity. */
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		for (const session of this.idle.splice(0)) {
+			this.owned.delete(session);
+			this.live -= 1;
+			try {
+				await session.quit();
+			} catch {
+				session.close();
+			}
+		}
+		for (const waiter of this.waiters.splice(0)) {
+			this.detachAbort(waiter);
+			waiter.reject(this.closedError());
+		}
+	}
+	/** Sends a composed message using a pooled session. */
+	async send(envelope, data, options = {}, signal) {
+		const session = await this.acquire(signal);
+		try {
+			const result = await session.send(envelope, data, options, signal);
+			this.release(session);
+			return result;
+		} catch (error) {
+			this.destroy(session);
+			throw error;
+		}
+	}
+	/** Sends a raw message using a pooled session. */
+	async sendRaw(envelope, data, options = {}, signal) {
+		const session = await this.acquire(signal);
+		try {
+			const result = await session.sendRaw(envelope, data, options, signal);
+			this.release(session);
+			return result;
+		} catch (error) {
+			this.destroy(session);
+			throw error;
+		}
+	}
+	destroy(session) {
+		if (!this.owned.delete(session)) {
+			session.close();
+			return;
+		}
+		this.live -= 1;
+		session.close();
+		this.wake();
+	}
+	waitForSlot(signal) {
+		return new Promise((resolve, reject) => {
+			const waiter = {
+				resolve,
+				reject,
+				signal
+			};
+			if (signal !== void 0) {
+				if (signal.aborted) {
+					reject(new SmtpAbortError({ cause: signal.reason }));
+					return;
+				}
+				waiter.onAbort = () => {
+					const index = this.waiters.indexOf(waiter);
+					if (index >= 0) this.waiters.splice(index, 1);
+					reject(new SmtpAbortError({ cause: signal.reason }));
+				};
+				signal.addEventListener("abort", waiter.onAbort, { once: true });
+			}
+			this.waiters.push(waiter);
+		});
+	}
+	wake() {
+		for (const waiter of this.waiters.splice(0)) {
+			this.detachAbort(waiter);
+			waiter.resolve();
+		}
+	}
+	detachAbort(waiter) {
+		if (waiter.onAbort !== void 0) waiter.signal?.removeEventListener("abort", waiter.onAbort);
+	}
+	closedError() {
+		return new SmtpSessionError(smtpSessionErrorKind.clientClosed, "smtp: pool is closed");
+	}
+};
+//#endregion
+//#region src/internal/headers.ts
+/** The recommended maximum line length for header fields. */
+const RECOMMENDED_LINE_LENGTH = 78;
+/**
+* Validates a header field name.
+*
+* @throws `Error` when the name is empty or contains characters outside the `ftext` set defined by
+*   RFC 5322.
+* @internal
+*/
+function validateHeaderName(name) {
+	if (!/^[!-9;-~]+$/.test(name)) throw new Error(`mail: invalid header name: ${JSON.stringify(name)}`);
+}
+/**
+* Validates a header field value.
+*
+* @throws `Error` when the value contains a line break or a control character.
+* @internal
+*/
+function validateHeaderValue(value) {
+	if (/[\r\n]/.test(value)) throw new Error("mail: header value contains a line break");
+	if (hasControlCharacter(value)) throw new Error("mail: header value contains a control character");
+}
+/** Reports whether a value contains a control character other than tab. */
+function hasControlCharacter(value) {
+	for (let index = 0; index < value.length; index += 1) {
+		const code = value.charCodeAt(index);
+		if (code < 32 && code !== 9 || code === 127) return true;
+	}
+	return false;
+}
+/**
+* Validates a header field.
+*
+* @throws `Error` when the name or value is invalid.
+* @internal
+*/
+function validateHeader(name, value) {
+	validateHeaderName(name);
+	validateHeaderValue(value);
+}
+/** Returns the first value for a header name, compared case-insensitively. */
+function getHeader(headers, name) {
+	const lower = name.toLowerCase();
+	for (const header of headers) if (header.name.toLowerCase() === lower) return header.value;
+}
+/**
+* Serializes header fields into a CRLF-terminated header block.
+*
+* Long values are folded at whitespace near the recommended line length. A value that contains no
+* whitespace is never split, so encodings such as RFC 2047 encoded words survive intact.
+*
+* @internal
+*/
+function serializeHeaders(headers) {
+	let output = "";
+	for (const header of headers) output += foldHeader(header.name, header.value);
+	return output;
+}
+/** Folds a single header field at whitespace near the recommended line length. */
+function foldHeader(name, value) {
+	const prefix = `${name}: `;
+	if (prefix.length + value.length <= RECOMMENDED_LINE_LENGTH) return `${prefix}${value}\r\n`;
+	const words = value.split(/[ \t]+/).filter((word) => word !== "");
+	const lines = [];
+	let current = `${name}:`;
+	let hasWord = false;
+	for (const word of words) {
+		const candidate = `${current} ${word}`;
+		if (hasWord && candidate.length > RECOMMENDED_LINE_LENGTH) {
+			lines.push(current);
+			current = ` ${word}`;
+		} else {
+			current = candidate;
+			hasWord = true;
+		}
+	}
+	lines.push(current);
+	return `${lines.join("\r\n")}\r\n`;
+}
+//#endregion
+//#region src/internal/mime.ts
+/**
+* MIME serialization helpers.
+*
+* This module is internal to the SDK. It builds the `multipart/alternative` and `multipart/mixed`
+* bodies that the {@link Message} builder emits, and formats attachment parts with Base64 transfer
+* encoding.
+*
+* @internal
+*/
+/** Converts LF and bare CR line endings to CRLF. */
+function normalizeLineEndings(value) {
+	return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n/g, "\r\n");
+}
+/** Appends a trailing CRLF when the value does not already end with one. */
+function ensureTrailingCrlf(value) {
+	return value.endsWith("\r\n") ? value : `${value}\r\n`;
+}
+/** Encodes bytes as Base64 wrapped at 76 characters with CRLF line endings. */
+function encodeBase64Lines(data) {
+	if (data.length === 0) return "";
+	const encoded = node_buffer.Buffer.from(data).toString("base64");
+	const lines = [];
+	for (let index = 0; index < encoded.length; index += 76) lines.push(encoded.slice(index, index + 76));
+	return `${lines.join("\r\n")}\r\n`;
+}
+/** Builds a `multipart/alternative` body from plain-text and HTML sources. */
+function buildMultipartAlternative(text, html) {
+	const encoding = containsNonAscii(text) || containsNonAscii(html) ? "8bit" : "7bit";
+	const boundary = generateBoundary();
+	const parts = [];
+	parts.push(renderTextPart(boundary, "text/plain; charset=utf-8", encoding, text));
+	parts.push(renderTextPart(boundary, "text/html; charset=utf-8", encoding, html));
+	parts.push(`--${boundary}--\r\n`);
+	return {
+		contentType: `multipart/alternative; boundary="${boundary}"`,
+		contentTransferEncoding: encoding,
+		data: parts.join("")
+	};
+}
+/**
+* Wraps a body and its attachments into a `multipart/mixed` body.
+*
+* The body part is emitted first, followed by one part per attachment. The caller is responsible
+* for removing the original body-level content headers, as required by MIME.
+*/
+function wrapAttachments(body, attachments) {
+	const boundary = generateBoundary();
+	const parts = [];
+	parts.push(`--${boundary}\r\n`);
+	parts.push(`Content-Type: ${body.contentType}\r\n`);
+	parts.push(`Content-Transfer-Encoding: ${body.contentTransferEncoding}\r\n`);
+	parts.push("\r\n");
+	parts.push(ensureTrailingCrlf(body.data));
+	for (const attachment of attachments) {
+		parts.push(`--${boundary}\r\n`);
+		parts.push(`Content-Type: ${attachment.contentType}\r\n`);
+		parts.push("Content-Transfer-Encoding: base64\r\n");
+		const disposition = attachment.inline === true ? "inline" : "attachment";
+		parts.push(`Content-Disposition: ${formatDisposition(disposition, attachment.filename)}\r\n`);
+		if (attachment.contentId !== void 0 && attachment.contentId !== "") parts.push(`Content-ID: <${attachment.contentId}>\r\n`);
+		parts.push("\r\n");
+		parts.push(encodeBase64Lines(attachment.data));
+	}
+	parts.push(`--${boundary}--\r\n`);
+	return {
+		contentType: `multipart/mixed; boundary="${boundary}"`,
+		contentTransferEncoding: "7bit",
+		data: parts.join("")
+	};
+}
+/** Renders one text part of a multipart body. */
+function renderTextPart(boundary, contentType, encoding, body) {
+	return `--${boundary}\r\nContent-Type: ${contentType}\r\nContent-Transfer-Encoding: ${encoding}\r\n\r
+` + ensureTrailingCrlf(normalizeLineEndings(body));
+}
+/** Formats a `Content-Disposition` value with an optional filename. */
+function formatDisposition(disposition, filename) {
+	if (filename === void 0 || filename === "") return disposition;
+	if (containsNonAscii(filename)) return `${disposition}; filename*=utf-8''${encodeRfc2231(filename)}`;
+	return `${disposition}; filename="${filename.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+/** Percent-encodes a value for an RFC 2231 extended parameter. */
+function encodeRfc2231(value) {
+	let output = "";
+	for (const byte of node_buffer.Buffer.from(value, "utf8")) {
+		const char = String.fromCharCode(byte);
+		if (/[A-Za-z0-9!#$&+\-.^_`|~]/.test(char)) output += char;
+		else output += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+	}
+	return output;
+}
+/** Generates a random MIME boundary. */
+function generateBoundary() {
+	return `----=_mxraven_${(0, node_crypto.randomBytes)(16).toString("hex")}`;
+}
+//#endregion
+//#region src/message.ts
+/**
+* A mutable, chainable builder for an email message.
+*
+* Chained methods return the receiver, so a message is normally composed in a single expression. A
+* `Message` is not safe for concurrent use. It can be sent repeatedly; each send serializes the
+* current state.
+*
+* @example
+* ```ts
+* const message = new Message()
+*   .from("Acme <noreply@acme.example>")
+*   .to("customer@example.com")
+*   .subject("Your receipt")
+*   .text("Thanks for your order.")
+*   .html("<p>Thanks for your order.</p>");
+* ```
+*
+* @public
+*/
+var Message = class {
+	fromAddress = "";
+	isNullSender = false;
+	senderAddress = "";
+	replyToAddress = "";
+	toAddresses = [];
+	ccAddresses = [];
+	bccAddresses = [];
+	subjectText = "";
+	textBody;
+	htmlBody;
+	customHeaders = [];
+	attachments = [];
+	messageIdValue = "";
+	inReplyToValue = "";
+	referencesValue = [];
+	dateValue;
+	/** Sets the envelope sender and the `From` header. */
+	from(address) {
+		this.fromAddress = address;
+		return this;
+	}
+	/**
+	* Uses a null reverse-path while keeping the `From` header.
+	*
+	* It is intended for bounce and other auto-generated messages. A `From` header is still required
+	* for a valid message.
+	*/
+	nullSender() {
+		this.isNullSender = true;
+		return this;
+	}
+	/** Sets the `Sender` header, required when `From` contains more than one mailbox. */
+	sender(address) {
+		this.senderAddress = address;
+		return this;
+	}
+	/** Sets the `Reply-To` header. */
+	replyTo(address) {
+		this.replyToAddress = address;
+		return this;
+	}
+	/** Adds envelope and `To` header recipients. */
+	to(addresses) {
+		this.toAddresses.push(...toArray(addresses));
+		return this;
+	}
+	/** Adds envelope and `Cc` header recipients. */
+	cc(addresses) {
+		this.ccAddresses.push(...toArray(addresses));
+		return this;
+	}
+	/** Adds envelope recipients without a visible `Bcc` header. */
+	bcc(addresses) {
+		this.bccAddresses.push(...toArray(addresses));
+		return this;
+	}
+	/** Sets the `Subject` header. Non-ASCII subjects are RFC 2047 encoded. */
+	subject(subject) {
+		this.subjectText = subject;
+		return this;
+	}
+	/** Sets the `Message-ID` header. The value is wrapped in angle brackets when needed. */
+	messageId(id) {
+		this.messageIdValue = id;
+		return this;
+	}
+	/** Sets the `In-Reply-To` header for threading. */
+	inReplyTo(id) {
+		this.inReplyToValue = id;
+		return this;
+	}
+	/** Sets the `References` header for threading. */
+	references(ids) {
+		this.referencesValue.push(...toArray(ids));
+		return this;
+	}
+	/** Sets the `Date` header. When unset, the time of sending is used. */
+	date(date) {
+		this.dateValue = date;
+		return this;
+	}
+	/**
+	* Sets the plain-text body.
+	*
+	* When both a text and an HTML body are set, the message is sent as `multipart/alternative`.
+	*/
+	text(body) {
+		this.textBody = body;
+		return this;
+	}
+	/**
+	* Sets the HTML body.
+	*
+	* When both a text and an HTML body are set, the message is sent as `multipart/alternative`.
+	*/
+	html(body) {
+		this.htmlBody = body;
+		return this;
+	}
+	/** Appends a custom header. */
+	header(name, value) {
+		this.customHeaders.push({
+			name,
+			value
+		});
+		return this;
+	}
+	/**
+	* Appends an attachment.
+	*
+	* The data is retained by reference until the message is built. Callers must not mutate it in the
+	* meantime.
+	*/
+	attach(attachment) {
+		this.attachments.push(attachment);
+		return this;
+	}
+	/** Appends a file attachment with an `application/octet-stream` content type. */
+	attachFile(filename, data) {
+		return this.attach({
+			filename,
+			data
+		});
+	}
+	/** Appends an inline attachment referenced by `contentId`, for example from `cid:` HTML. */
+	attachInline(filename, contentId, data) {
+		return this.attach({
+			filename,
+			contentId,
+			data,
+			inline: true
+		});
+	}
+	/**
+	* Serializes the current state into a transmittable message.
+	*
+	* The returned value is a snapshot: later mutations of this builder do not affect it. The caller
+	* owns the returned object.
+	*
+	* @returns The built message and its envelope.
+	* @throws `AggregateError` When one or more addresses or headers are invalid, or when required
+	*   fields are missing.
+	* @internal
+	*/
+	build() {
+		const problems = [];
+		const from = this.parseOptional(this.fromAddress, "from", problems);
+		const sender = this.parseOptional(this.senderAddress, "sender", problems);
+		const replyTo = this.parseOptional(this.replyToAddress, "reply-to", problems);
+		const to = this.parseMany(this.toAddresses, "to", problems);
+		const cc = this.parseMany(this.ccAddresses, "cc", problems);
+		const bcc = this.parseMany(this.bccAddresses, "bcc", problems);
+		const recipients = [
+			...to,
+			...cc,
+			...bcc
+		];
+		if (from === void 0 && !this.isNullSender && getHeader(this.customHeaders, "From") === void 0) problems.push(/* @__PURE__ */ new Error("mail: from address is required"));
+		if (recipients.length === 0) problems.push(/* @__PURE__ */ new Error("mail: at least one recipient is required"));
+		const headers = [];
+		if (from !== void 0) headers.push({
+			name: "From",
+			value: formatAddress(from)
+		});
+		if (sender !== void 0) headers.push({
+			name: "Sender",
+			value: formatAddress(sender)
+		});
+		if (replyTo !== void 0) headers.push({
+			name: "Reply-To",
+			value: formatAddress(replyTo)
+		});
+		if (to.length > 0) headers.push({
+			name: "To",
+			value: formatAddressList(to)
+		});
+		if (cc.length > 0) headers.push({
+			name: "Cc",
+			value: formatAddressList(cc)
+		});
+		if (this.subjectText !== "") headers.push({
+			name: "Subject",
+			value: encodeHeaderValue(this.subjectText)
+		});
+		if (this.messageIdValue !== "") headers.push({
+			name: "Message-ID",
+			value: wrapAngle(this.messageIdValue)
+		});
+		if (this.inReplyToValue !== "") headers.push({
+			name: "In-Reply-To",
+			value: wrapAngle(this.inReplyToValue)
+		});
+		if (this.referencesValue.length > 0) headers.push({
+			name: "References",
+			value: this.referencesValue.map(wrapAngle).join(" ")
+		});
+		for (const header of this.customHeaders) try {
+			validateHeader(header.name, header.value);
+			headers.push({
+				name: header.name,
+				value: header.value
+			});
+		} catch (error) {
+			problems.push(toError(error, `header ${header.name}`));
+		}
+		if (getHeader(headers, "Date") === void 0) headers.push({
+			name: "Date",
+			value: formatDate(this.dateValue ?? /* @__PURE__ */ new Date())
+		});
+		if (getHeader(headers, "Message-ID") === void 0) {
+			const domain = from?.domain ?? recipients[0]?.domain ?? "localhost";
+			headers.push({
+				name: "Message-ID",
+				value: `<${Date.now()}.${(0, node_crypto.randomUUID)()}@${domain}>`
+			});
+		}
+		const rendered = this.renderBody(problems);
+		if (rendered !== void 0) {
+			headers.push({
+				name: "MIME-Version",
+				value: "1.0"
+			});
+			headers.push({
+				name: "Content-Type",
+				value: rendered.contentType
+			});
+			headers.push({
+				name: "Content-Transfer-Encoding",
+				value: rendered.contentTransferEncoding
+			});
+		}
+		if (problems.length > 0) throw new AggregateError(problems, "mail: build message");
+		const headerBlock = serializeHeaders(headers);
+		const data = node_buffer.Buffer.from(`${headerBlock}\r\n${rendered?.data ?? ""}`, "utf8");
+		return {
+			from: this.isNullSender ? void 0 : from,
+			recipients,
+			headerBlock,
+			body: rendered?.data ?? "",
+			data,
+			smtpUtf8: requiresSmtpUtf8(from, recipients, headers),
+			size: data.byteLength,
+			builtAt: /* @__PURE__ */ new Date()
+		};
+	}
+	/** Renders the body, wrapping attachments in `multipart/mixed` when present. */
+	renderBody(problems) {
+		let bodyPart;
+		if (this.textBody !== void 0 && this.htmlBody !== void 0) {
+			const alternative = buildMultipartAlternative(this.textBody, this.htmlBody);
+			bodyPart = {
+				contentType: alternative.contentType,
+				contentTransferEncoding: alternative.contentTransferEncoding,
+				data: alternative.data
+			};
+		} else if (this.htmlBody !== void 0) bodyPart = renderTextBody("text/html; charset=utf-8", this.htmlBody);
+		else if (this.textBody !== void 0) bodyPart = renderTextBody("text/plain; charset=utf-8", this.textBody);
+		if (this.attachments.length === 0) return bodyPart;
+		for (const attachment of this.attachments) {
+			if (attachment.data.length === 0 && attachment.filename === void 0) problems.push(/* @__PURE__ */ new Error("mail: attachment requires data or a filename"));
+			try {
+				if (attachment.filename !== void 0) validateHeaderValue(attachment.filename);
+				if (attachment.contentType !== void 0) validateHeaderValue(attachment.contentType);
+				if (attachment.contentId !== void 0) validateHeaderValue(attachment.contentId);
+			} catch (error) {
+				problems.push(toError(error, `attachment ${attachment.filename ?? ""}`.trimEnd()));
+			}
+		}
+		const attachments = this.attachments.map(toMimeAttachment);
+		if (bodyPart === void 0) bodyPart = {
+			contentType: "text/plain; charset=utf-8",
+			contentTransferEncoding: "7bit",
+			data: ""
+		};
+		const mixed = wrapAttachments(bodyPart, attachments);
+		return {
+			contentType: mixed.contentType,
+			contentTransferEncoding: mixed.contentTransferEncoding,
+			data: mixed.data
+		};
+	}
+	/** Parses an optional address, recording a problem when invalid. */
+	parseOptional(value, label, problems) {
+		if (value.trim() === "") return;
+		try {
+			return parseAddress(value);
+		} catch (error) {
+			problems.push(toError(error, label));
+			return;
+		}
+	}
+	/** Parses a list of addresses, recording problems for invalid entries. */
+	parseMany(values, label, problems) {
+		const parsed = [];
+		for (const value of values) try {
+			parsed.push(parseAddress(value));
+		} catch (error) {
+			problems.push(toError(error, label));
+		}
+		return parsed;
+	}
+};
+/** Normalizes a single address or array into an array. */
+function toArray(value) {
+	return typeof value === "string" ? [value] : value;
+}
+/** Renders a simple text or HTML body. */
+function renderTextBody(contentType, body) {
+	const normalized = normalizeLineEndings(body);
+	return {
+		contentType,
+		contentTransferEncoding: containsNonAscii(normalized) ? "8bit" : "7bit",
+		data: normalized
+	};
+}
+/** Renders a header value, RFC 2047-encoding it when it contains non-ASCII. */
+function encodeHeaderValue(value) {
+	return containsNonAscii(value) ? encodeRfc2047(value) : value;
+}
+/** Wraps a message identifier in angle brackets when it is not already. */
+function wrapAngle(value) {
+	return value.startsWith("<") ? value : `<${value}>`;
+}
+/** Converts an attachment into its MIME representation. */
+function toMimeAttachment(attachment) {
+	return {
+		filename: attachment.filename,
+		contentType: attachment.contentType ?? "application/octet-stream",
+		data: attachment.data,
+		inline: attachment.inline,
+		contentId: attachment.contentId
+	};
+}
+/** Reports whether the envelope requires the `SMTPUTF8` extension. */
+function requiresSmtpUtf8(from, recipients, headers) {
+	const addresses = from === void 0 ? recipients : [from, ...recipients];
+	for (const address of addresses) if (containsNonAscii(address.localPart) || containsNonAscii(address.domain)) return true;
+	return headers.some((header) => containsNonAscii(header.value));
+}
+/** Formats a date using the RFC 5322 date-time syntax. */
+function formatDate(date) {
+	const days = [
+		"Sun",
+		"Mon",
+		"Tue",
+		"Wed",
+		"Thu",
+		"Fri",
+		"Sat"
+	];
+	const months = [
+		"Jan",
+		"Feb",
+		"Mar",
+		"Apr",
+		"May",
+		"Jun",
+		"Jul",
+		"Aug",
+		"Sep",
+		"Oct",
+		"Nov",
+		"Dec"
+	];
+	const offset = -date.getTimezoneOffset();
+	const sign = offset >= 0 ? "+" : "-";
+	const absolute = Math.abs(offset);
+	const zone = `${sign}${pad2(Math.floor(absolute / 60))}${pad2(absolute % 60)}`;
+	const day = days[date.getDay()] ?? "Sun";
+	const month = months[date.getMonth()] ?? "Jan";
+	return `${day}, ${pad2(date.getDate())} ${month} ${date.getFullYear()} ${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())} ${zone}`;
+}
+/** Pads a number to two digits. */
+function pad2(value) {
+	return String(value).padStart(2, "0");
+}
+/** Adds context to an unknown thrown value. */
+function toError(error, label) {
+	const message = error instanceof Error ? error.message : String(error);
+	return new Error(`mail: invalid ${label}: ${message}`, { cause: error });
+}
+//#endregion
+//#region src/result.ts
+/**
+* Extracts the mxRaven message reference from a final `DATA` reply.
+*
+* The submission service appends a message reference to its reply, for example
+* `250 2.0.0 accepted; message_ref=<uuid>`.
+*
+* @param message - The final reply text.
+* @returns The message reference, or an empty string when the reply has none.
+* @internal
+*/
+function parseMessageRef(message) {
+	const index = message.indexOf("message_ref=");
+	if (index < 0) return "";
+	let value = message.slice(index + 12).trim();
+	value = value.replace(/^</, "");
+	const end = value.search(/[>;\s]/);
+	if (end >= 0) value = value.slice(0, end);
+	return value;
+}
+//#endregion
+//#region src/client.ts
+/** The default mxRaven SMTP submission port. */
+const defaultAddressPort = 587;
+const DEFAULT_POOL_SIZE = 5;
+/**
+* Submits mail to the mxRaven SMTP submission service.
+*
+* A client maintains a bounded pool of authenticated connections and is safe
+* for concurrent use. The submission service requires STARTTLS and SMTP AUTH,
+* so both are always used.
+*
+* @example
+* ```ts
+* const secret = process.env.MXRAVEN_SECRET;
+* if (secret === undefined || secret === "") {
+*   throw new Error("MXRAVEN_SECRET is required");
+* }
+*
+* const client = new Client({
+*   host: "smtp.mxraven.com",
+*   username: "mxr_tx_ab12cd34ef56",
+*   secret,
+* });
+* const result = await client.send(
+*   new Message().from("noreply@acme.example").to("customer@example.com").text("Hi"),
+* );
+* await client.close();
+* ```
+*
+* @public
+*/
+var Client = class {
+	pool;
+	/**
+	* @param options - The server address, credentials, and tuning options.
+	* @throws `Error` When required options are missing or invalid.
+	*/
+	constructor(options) {
+		const port = options.port ?? 587;
+		if (options.host.trim() === "") throw new Error("mail: server host is required");
+		if (!Number.isInteger(port) || port <= 0 || port > 65535) throw new Error(`mail: invalid server port ${port}`);
+		if (options.username.trim() === "") throw new Error("mail: username must not be empty");
+		if (options.secret === "") throw new Error("mail: secret must not be empty");
+		if (options.poolSize !== void 0 && (!Number.isInteger(options.poolSize) || options.poolSize <= 0)) throw new Error(`mail: invalid pool size ${options.poolSize}`);
+		const dialer = new SmtpDialer({
+			host: options.host,
+			port,
+			localName: options.localName,
+			connectTimeout: options.connectTimeout,
+			readTimeout: options.readTimeout,
+			writeTimeout: options.writeTimeout,
+			tls: options.tls,
+			auth: {
+				username: options.username,
+				password: options.secret
+			},
+			startTls: true,
+			requireTls: true
+		});
+		this.pool = new SmtpPool({
+			dialer,
+			size: options.poolSize ?? DEFAULT_POOL_SIZE
+		});
+	}
+	/**
+	* Sends a composed message.
+	*
+	* @param message - The message to submit. It may be sent more than once.
+	* @param options - An optional cancellation signal.
+	* @returns The server's result for the submission.
+	* @throws {@link SMTPError} When the server rejects a command.
+	* @throws {@link SMTPTransactionError} When every recipient is rejected; the
+	* per-recipient detail is on {@link SMTPTransactionError.result}.
+	*
+	* @public
+	*/
+	async send(message, options = {}) {
+		if (!(message instanceof Message)) throw new Error("mail: message is required");
+		const built = message.build();
+		return this.transact((signal) => this.pool.send(this.toEnvelope(built), built.data, {}, signal), options.signal);
+	}
+	/**
+	* Streams an already serialized RFC 5322 message with an explicit envelope.
+	*
+	* The message is not parsed, so the caller is responsible for RFC 5322
+	* correctness. Prefer this for large or pre-rendered messages.
+	*
+	* @param envelope - The SMTP envelope, independent of the message headers.
+	* @param data - The raw message bytes, or an async stream of chunks.
+	* @param options - An optional cancellation signal.
+	* @returns The server's result for the submission.
+	* @throws {@link SMTPError} When the server rejects a command.
+	* @throws {@link SMTPTransactionError} When every recipient is rejected.
+	*
+	* @public
+	*/
+	async sendRaw(envelope, data, options = {}) {
+		const smtpEnvelope = this.envelopeFromPublic(envelope);
+		return this.transact((signal) => this.pool.sendRaw(smtpEnvelope, data, {}, signal), options.signal);
+	}
+	/** Releases the pooled connections. It is safe to call more than once. */
+	async close() {
+		await this.pool.close();
+	}
+	async transact(run, signal) {
+		try {
+			return toResult(await run(signal));
+		} catch (error) {
+			throw translateError(error);
+		}
+	}
+	toEnvelope(built) {
+		return {
+			from: built.from,
+			recipients: built.recipients.map((address) => ({ address })),
+			size: built.size,
+			smtpUtf8: built.smtpUtf8
+		};
+	}
+	envelopeFromPublic(envelope) {
+		return {
+			from: envelope.from === void 0 || envelope.from.trim() === "" ? void 0 : parseAddress(envelope.from),
+			recipients: envelope.to.map((address) => ({ address: parseAddress(address) }))
+		};
+	}
+};
+/** Converts an internal transaction result into the public result. */
+function toResult(transaction) {
+	const response = transaction.response;
+	return {
+		messageRef: response === void 0 ? "" : parseMessageRef(response.message),
+		code: response?.code ?? 0,
+		message: response?.message ?? "",
+		recipients: transaction.recipients.map((recipient) => ({
+			address: recipient.address,
+			accepted: recipient.accepted,
+			error: recipient.error
+		}))
+	};
+}
+/** Maps internal failures onto the public error surface. */
+function translateError(error) {
+	if (error instanceof SmtpTransactionError) return new SMTPTransactionError(error.message, toResult(error.result));
+	if (error instanceof Error) return error;
+	return new Error(String(error));
+}
+//#endregion
+exports.Client = Client;
+exports.Message = Message;
+exports.SMTPError = SMTPError;
+exports.SMTPTransactionError = SMTPTransactionError;
+exports.defaultAddressPort = defaultAddressPort;
+
+//# sourceMappingURL=index.cjs.map