nodemailer 10.0.9 → 10.0.11

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # CHANGELOG
 
+## [10.0.11](https://github.com/nodemailer/nodemailer/compare/v10.0.10...v10.0.11) (2026-09-27)
+
+
+### Bug Fixes
+
+* **fetch:** report a form body that can not be encoded through the returned stream ([74d40bf](https://github.com/nodemailer/nodemailer/commit/74d40bf1e4553bc0568b471250a9251bcb569b00))
+* keep the CommonJS entry point and the services subpath compatible with the pre-TypeScript build ([52901ef](https://github.com/nodemailer/nodemailer/commit/52901ef3725ad179aa56276495a60f53b2c83516))
+* **qp:** keep wrap() terminating for short line lengths and a trailing incomplete escape ([8fa140b](https://github.com/nodemailer/nodemailer/commit/8fa140b11c62cb1202eac84d35bb3ba28bc3b1a1))
+* **smtp-connection:** fail a password login cleanly when the server offers only XOAUTH2 ([90abf7d](https://github.com/nodemailer/nodemailer/commit/90abf7d11db5ebfeb4292b62c1fff969741c7d33))
+* **types:** restore the layout of @types/nodemailer in the bundled declarations ([ac2e40f](https://github.com/nodemailer/nodemailer/commit/ac2e40ffc69427e0eb33ce3945fae76c4c828c8d))
+
+## [10.0.10](https://github.com/nodemailer/nodemailer/compare/v10.0.9...v10.0.10) (2026-09-14)
+
+
+### Bug Fixes
+
+* derive the attachment filename from the basename of a Windows path ([c7cc7ce](https://github.com/nodemailer/nodemailer/commit/c7cc7ce41a3602441747476a2a2c4a8ff466a83e))
+* **dkim:** unfold folded header lines in linear time ([28a5909](https://github.com/nodemailer/nodemailer/commit/28a5909cec27646cb001dc7e97a8f5d26c973078))
+* **smtp-connection:** reassemble multiline replies in linear time ([f2d82fa](https://github.com/nodemailer/nodemailer/commit/f2d82fa84d47015a7bbb4253da61eeb778c658b1))
+
 ## [10.0.9](https://github.com/nodemailer/nodemailer/compare/v10.0.8...v10.0.9) (2026-09-12)
 
 

package/README.md

@@ -72,7 +72,7 @@ let configOptions = {
 
 #### I have an issue with TypeScript types
 
-Nodemailer 10 and later are written in TypeScript and ship their own type definitions, so `@types/nodemailer` is no longer needed and should be removed from your project to avoid conflicting declarations. The type names follow the layout of the old definitions, so references such as `Mail.Options`, `SMTPTransport.Options` or `Transporter<SMTPTransport.SentMessageInfo>` keep compiling, and the most used types (`SendMailOptions`, `Transporter`, `SentMessageInfo`, `Attachment`, `Address`) are exported from the package root. For older Nodemailer versions, the community maintained [type definitions](https://www.npmjs.com/package/@types/nodemailer) still apply.
+Nodemailer 10 and later are written in TypeScript and ship their own type definitions, so `@types/nodemailer` is no longer needed and should be removed from your project to avoid conflicting declarations. The type names follow the layout of the old definitions, so references such as `Mail.Options`, `SMTPTransport.Options` or `Transporter<SMTPTransport.SentMessageInfo>` keep compiling, and the most used types (`SendMailOptions`, `Transporter`, `SentMessageInfo`, `Attachment`, `Address`) are exported from the package root. The modules under `nodemailer/lib/` are declared with a default export, so import a class as `import SMTPTransport from 'nodemailer/lib/smtp-transport'` (with `esModuleInterop` in a CommonJS project). The `import SMTPTransport = require(...)` and `import * as SMTPTransport from ...` forms still resolve the type aliases such as `SMTPTransport.Options`, but they refer to the module rather than to the class, so the class itself has to be imported with a default import. For older Nodemailer versions, the community maintained [type definitions](https://www.npmjs.com/package/@types/nodemailer) still apply.
 
 #### I have a different problem
 

package/dist/cjs/addressparser/index.d.ts

@@ -42,4 +42,19 @@ export type Address = MailboxAddress | GroupAddress;
  * @param options._depth Internal recursion depth counter (do not set manually)
  * @return An array of address objects
  */
-export default function addressparser(str?: string | null, options?: AddressParserOptions): Address[];
+declare function addressparser(str: string | null | undefined, options: AddressParserOptions & {
+    flatten: true;
+}): MailboxAddress[];
+declare function addressparser(str?: string | null, options?: AddressParserOptions): Address[];
+/**
+ * Type aliases in the layout of @types/nodemailer, so `addressparser.Address` style references keep working
+ */
+type AddressEntry = Address;
+declare namespace addressparser {
+    type Address = MailboxAddress;
+    type Group = GroupAddress;
+    type AddressOrGroup = AddressEntry;
+}
+/** The names @types/nodemailer used for the group entry and for the union of both entry types */
+export type { GroupAddress as Group, Address as AddressOrGroup };
+export default addressparser;

package/dist/cjs/addressparser/index.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = addressparser;
 /**
  * Restores the quoting of a local part that was read out of a quoted string.
  *
@@ -583,22 +582,6 @@ class Tokenizer {
  * malicious input that could cause stack overflow.
  */
 const MAX_NESTED_GROUP_DEPTH = 50;
-/**
- * Parses structured e-mail addresses from an address field
- *
- * Example:
- *
- *    'Name <address@domain>'
- *
- * will be converted to
- *
- *     [{name: 'Name', address: 'address@domain'}]
- *
- * @param str Address field
- * @param options Optional options object
- * @param options._depth Internal recursion depth counter (do not set manually)
- * @return An array of address objects
- */
 function addressparser(str, options) {
     options = options || {};
     const depth = options._depth || 0;
@@ -667,5 +650,6 @@ function addressparser(str, options) {
     }
     return parsedAddresses;
 }
+exports.default = addressparser;
 module.exports = exports.default;
 Object.defineProperty(module.exports, 'default', { value: exports.default, enumerable: false, writable: true, configurable: true });

package/dist/cjs/base64/index.js

@@ -25,7 +25,8 @@ function encode(buffer) {
  */
 function wrap(str, lineLength) {
     str = (str || '').toString();
-    lineLength = lineLength || 76;
+    // a negative length would step backwards through the input and never finish
+    lineLength = Math.max(Number(lineLength) || 76, 1);
     if (str.length <= lineLength) {
         return str;
     }

package/dist/cjs/dkim/index.d.ts

@@ -30,11 +30,23 @@ declare class DKIM {
     constructor(options: DKIMOptions);
     sign(input: Readable | Buffer | string, extraOptions?: DKIMOptions): DKIMSignedStream;
 }
+/** The signer options without any key material */
+export type DKIMOptionalOptions = Omit<DKIMOptions, 'keys' | 'domainName' | 'keySelector' | 'privateKey'>;
+/** The signer options for a single key given as domainName, keySelector and privateKey */
+export type DKIMSingleKeyOptions = Omit<DKIMOptions, 'keys'>;
+/** The signer options for one or more keys given through `keys` */
+export type DKIMMultipleKeysOptions = DKIMOptionalOptions & {
+    keys: DKIMKey | DKIMKey[];
+};
 /**
  * Type aliases in the layout of @types/nodemailer, so `DKIM.Options` style references keep working
  */
 declare namespace DKIM {
     type Options = DKIMOptions;
-    type SingleKeyOptions = Omit<DKIMOptions, 'keys'>;
+    type OptionalOptions = DKIMOptionalOptions;
+    type SingleKeyOptions = DKIMSingleKeyOptions;
+    type MultipleKeysOptions = DKIMMultipleKeysOptions;
 }
+/** The same aliases as module level exports, for `import * as DKIM` and `import DKIM = require()` */
+export type { DKIMOptions as Options, DKIMOptionalOptions as OptionalOptions, DKIMSingleKeyOptions as SingleKeyOptions, DKIMMultipleKeysOptions as MultipleKeysOptions };
 export default DKIM;

package/dist/cjs/dkim/message-parser.d.ts

@@ -13,7 +13,7 @@ export interface MessageParserHeaderLine {
  * from the rest of the body. Headers are emitted with the 'headers' event. Message
  * body is passed on as the resulting stream.
  */
-export default class MessageParser extends Transform {
+declare class MessageParser extends Transform {
     lastBytes: Buffer;
     headersParsed: boolean;
     headerBytes: number;
@@ -37,3 +37,12 @@ export default class MessageParser extends Transform {
     checkHeaders(data: Buffer): boolean;
     parseHeaders(): MessageParserHeaderLine[];
 }
+/**
+ * Type aliases in the layout of @types/nodemailer, so `MessageParser.Header` style references keep working
+ */
+declare namespace MessageParser {
+    type Header = MessageParserHeaderLine;
+}
+/** The same alias as a module level export, for `import * as MessageParser` and `import MessageParser = require()` */
+export type { MessageParserHeaderLine as Header };
+export default MessageParser;

package/dist/cjs/dkim/message-parser.js

@@ -126,11 +126,18 @@ class MessageParser extends node_stream_1.Transform {
         // signature covers exactly the bytes the receiving side canonicalizes
         // Only SP and HTAB fold a line, and only they are trimmed from the field name, the
         // same whitespace the relaxed canonicalization in sign.ts works with
-        const lines = (this.rawHeaders || Buffer.alloc(0)).toString('binary').split(/\r?\n/);
-        for (let i = lines.length - 1; i > 0; i--) {
-            if (/^[ \t]/.test(lines[i])) {
-                lines[i - 1] += '\n' + lines[i];
-                lines.splice(i, 1);
+        const rawLines = (this.rawHeaders || Buffer.alloc(0)).toString('binary').split(/\r?\n/);
+        // Unfold in a single forward pass and only ever test a freshly split line for the
+        // continuation prefix. Testing an already merged line instead would rescan a string
+        // that grows with every continuation line, so a header folded into many continuation
+        // lines (a large recipient list, for example) would take quadratic time to unfold
+        const lines = [];
+        for (const rawLine of rawLines) {
+            if (lines.length && /^[ \t]/.test(rawLine)) {
+                lines[lines.length - 1] += '\n' + rawLine;
+            }
+            else {
+                lines.push(rawLine);
             }
         }
         return lines

package/dist/cjs/dkim/relaxed-body.d.ts

@@ -17,7 +17,7 @@ export interface RelaxedBodyOptions {
  * a non-empty body always ends with CRLF. Bytes are canonicalized as they arrive,
  * so a line of any length costs constant memory.
  */
-export default class RelaxedBody extends Transform {
+declare class RelaxedBody extends Transform {
     bodyHash: crypto.Hash;
     /** Bytes of the original body seen so far */
     byteLength: number;
@@ -25,3 +25,12 @@ export default class RelaxedBody extends Transform {
     constructor(options?: RelaxedBodyOptions);
     updateHash(chunk: Buffer, final?: boolean): void;
 }
+/**
+ * Type aliases in the layout of @types/nodemailer, so `RelaxedBody.Options` style references keep working
+ */
+declare namespace RelaxedBody {
+    type Options = RelaxedBodyOptions;
+}
+/** The same alias as a module level export, for `import * as RelaxedBody` and `import RelaxedBody = require()` */
+export type { RelaxedBodyOptions as Options };
+export default RelaxedBody;

package/dist/cjs/errors.d.ts

@@ -64,9 +64,10 @@ export declare const EFETCH = "EFETCH";
 /**
  * An Error together with the properties Nodemailer attaches to the errors it
  * hands to callers. Every property is optional, the set that is present
- * depends on where the error originated.
+ * depends on where the error originated. Socket level errors keep the errno
+ * and syscall fields Node.js sets on them.
  */
-export interface NodemailerError extends Error {
+export interface NodemailerError extends NodeJS.ErrnoException {
     /** Nodemailer error code, see ERROR_CODES */
     code?: string | undefined;
     /** SMTP command that was in flight when the server replied with an error */

package/dist/cjs/fetch/cookies.d.ts

@@ -17,13 +17,14 @@ export interface Cookie {
     secure?: boolean | undefined;
     httponly?: boolean | undefined;
 }
+type CookieEntry = Cookie;
 /**
  * Creates a biskviit cookie jar for managing cookie values in memory
  *
  * @constructor
  * @param [options] Optional options object
  */
-export default class Cookies {
+declare class Cookies {
     options: CookiesOptions;
     cookies: Cookie[];
     constructor(options?: CookiesOptions);
@@ -94,3 +95,13 @@ export default class Cookies {
      */
     getPath(pathname?: string | null): string;
 }
+/**
+ * Type aliases in the layout of @types/nodemailer, so `Cookies.Cookie` style references keep working
+ */
+declare namespace Cookies {
+    type Options = CookiesOptions;
+    type Cookie = CookieEntry;
+}
+/** The same alias as a module level export, for `import * as Cookies` and `import Cookies = require()` */
+export type { CookiesOptions as Options };
+export default Cookies;

package/dist/cjs/fetch/index.d.ts

@@ -48,4 +48,15 @@ declare function nmfetch(url: string, options?: FetchOptions): FetchResponse;
 declare namespace nmfetch {
     var Cookies: typeof import("./cookies.js").default;
 }
+type CookiesJar = Cookies;
+/**
+ * Type aliases in the layout of @types/nodemailer, so `fetch.Options` style references keep working
+ */
+declare namespace nmfetch {
+    type Options = FetchOptions;
+    type WritableResponse = FetchResponse;
+    type Cookies = CookiesJar;
+}
+/** The same aliases as module level exports, for `import * as fetch` and `import fetch = require()` */
+export type { FetchOptions as Options, FetchResponse as WritableResponse, Cookies };
 export default nmfetch;

package/dist/cjs/fetch/index.js

@@ -193,14 +193,14 @@ function nmfetch(url, options) {
                         .join('&'));
                 }
                 catch (E) {
-                    if (finished) {
-                        return undefined;
-                    }
+                    // the caller attaches its error listener once nmfetch has returned, so
+                    // the error is emitted on the next tick and the stream is handed back
+                    // the way every other failure is reported
                     finished = true;
                     E.code = errors.EFETCH;
                     E.sourceUrl = url;
-                    fetchRes.emit('error', E);
-                    return undefined;
+                    setImmediate(() => fetchRes.emit('error', E));
+                    return fetchRes;
                 }
             }
             else {

package/dist/cjs/json-transport/index.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from '../shared/index.js';
 import type { MimeNodeEnvelope } from '../mime-node/index.js';
-import type { default as MailMessage, MailMessageData } from '../mailer/mail-message.js';
+import type MailMessage from '../mailer/mail-message.js';
 import type { default as Mail, SentMessageInfo, SendMailOptions, TransportOptions } from '../mailer/index.js';
 /**
  * Options for the JSON transport
@@ -12,16 +12,23 @@ export interface JSONTransportOptions extends TransportOptions {
     skipEncoding?: boolean | undefined;
 }
 /**
- * The value the JSON transport hands to the send callback
+ * The value the JSON transport hands to the send callback. M is the type of the message
+ * field: a JSON string by default, the message object itself when skipEncoding is set
  */
-export interface JSONSentMessageInfo extends SentMessageInfo {
+export interface JSONSentMessageInfo<M = string> extends SentMessageInfo {
     /** The envelope the message was generated with */
     envelope: MimeNodeEnvelope;
     /** Message-ID value of the message */
     messageId: string;
     /** The normalized message as a JSON string, or as the object itself when skipEncoding is set */
-    message: string | MailMessageData;
+    message: M;
 }
+/**
+ * The value the JSON transport hands to the send callback when skipEncoding is set: the
+ * message field holds the message object. Typed loosely so that a transporter created with
+ * skipEncoding still fits a variable declared with the plain result type
+ */
+export type JSONSentMessageObjectInfo = JSONSentMessageInfo<any>;
 /**
  * Generates a Transport object to generate JSON output
  *
@@ -50,5 +57,8 @@ declare namespace JSONTransport {
     type Options = JSONTransportOptions;
     type MailOptions = SendMailOptions;
     type SentMessageInfo = JSONSentMessageInfo;
+    type SentMessageObjectInfo = JSONSentMessageObjectInfo;
 }
+/** The same aliases as module level exports, for `import * as JSONTransport` and `import JSONTransport = require()` */
+export type { JSONTransportOptions as Options, SendMailOptions as MailOptions, JSONSentMessageInfo as SentMessageInfo, JSONSentMessageObjectInfo as SentMessageObjectInfo };
 export default JSONTransport;

package/dist/cjs/json-transport/index.js

@@ -83,6 +83,8 @@ class JSONTransport {
                 }
                 delete data.envelope;
                 delete data.normalizedHeaders;
+                // the message field is the object itself with skipEncoding, the
+                // createTransport overload for that option types the result accordingly
                 return done(null, {
                     envelope,
                     messageId,

package/dist/cjs/mail-composer/index.d.ts

@@ -72,6 +72,11 @@ export type MailComposerListHeaderEntry = string | {
 export interface MailComposerListHeaders {
     [key: string]: MailComposerListHeaderEntry | (MailComposerListHeaderEntry | MailComposerListHeaderEntry[])[];
 }
+/**
+ * Encoding for the non-ascii header values: quoted-printable ('Q', the default) or base64
+ * ('B'). Only the first letter is read, so the short forms work as well
+ */
+export type MailComposerTextEncoding = 'quoted-printable' | 'base64' | 'Q' | 'B';
 /**
  * Mail options, the message data MailComposer builds the MIME tree from. The address
  * fields, subject, messageId, date, inReplyTo and references become headers of the root
@@ -114,7 +119,7 @@ export interface MailComposerOptions {
     /** Content-Transfer-Encoding to force for the text/* nodes that do not set their own */
     encoding?: string | undefined;
     /** Header string encoding, 'Q' (the default) or 'B', 'quoted-printable' and 'base64' are accepted as well */
-    textEncoding?: string | undefined;
+    textEncoding?: MailComposerTextEncoding | undefined;
     /** Pregenerated rfc822 message, used as is instead of building one */
     raw?: MimeNodeContent | undefined;
     /** Reject content that points to a URL */
@@ -129,8 +134,6 @@ export interface MailComposerOptions {
     baseBoundary?: string | undefined;
     /** 'win' for CRLF and 'linux' for LF line breaks in the generated message, kept as is when not set */
     newline?: string | undefined;
-    /** Keep the Bcc header in the generated message, listed for completeness, the transports set it on the message directly */
-    keepBcc?: boolean | undefined;
     /** Method to normalize header keys for custom caseing */
     normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;
     /** 'high', 'normal' or 'low', sets the priority headers, read by the mailer */
@@ -166,4 +169,6 @@ declare class MailComposer {
 declare namespace MailComposer {
     type Options = MailComposerOptions;
 }
+/** The same alias as a module level export, for `import * as MailComposer` and `import MailComposer = require()` */
+export type { MailComposerOptions as Options };
 export default MailComposer;

package/dist/cjs/mail-composer/index.js

@@ -151,8 +151,10 @@ class MailComposer {
                 data.filename = attachment.filename;
             }
             else if (!isMessageNode && attachment.filename !== false) {
+                // a backslash separates as well, so a Windows path does not put the sender's directories in the headers
                 data.filename =
-                    (attachment.path || attachment.href || '').split('/').pop().split('?').shift() || 'attachment-' + (i + 1);
+                    (attachment.path || attachment.href || '').split(/[/\\]/).pop().split('?').shift() ||
+                        'attachment-' + (i + 1);
                 if (data.filename.indexOf('.') < 0) {
                     data.filename += '.' + mimeFuncs.detectExtension(data.contentType);
                 }

package/dist/cjs/mailer/index.d.ts

@@ -4,8 +4,8 @@ import DKIM, { type DKIMOptions } from '../dkim/index.js';
 import MailMessage, { type MailDefaults, type SendMailOptions } from './mail-message.js';
 import net from 'node:net';
 import type { ConnectionOptions } from 'node:tls';
-import type { MailComposerAlternative, MailComposerAttachment, MailComposerIcalEvent, MailComposerListHeaderEntry, MailComposerListHeaders } from '../mail-composer/index.js';
-import type { NodemailerError, ResultCallback } from '../errors.js';
+import type { MailComposerAlternative, MailComposerAttachment, MailComposerIcalEvent, MailComposerListHeaderEntry, MailComposerListHeaders, MailComposerTextEncoding } from '../mail-composer/index.js';
+import type { Callback, NodemailerError, ResultCallback } from '../errors.js';
 import type { ParsedUrl } from '../shared/url.js';
 import type { MimeNodeAddress, MimeNodeEnvelope, MimeNodeEnvelopeInput, MimeNodeHeaders, MimeNodeOptions } from '../mime-node/index.js';
 import type { XOAuth2ProvisionCallback } from '../xoauth2/index.js';
@@ -15,9 +15,10 @@ export type { default as MailMessage } from './mail-message.js';
  * The base shape of the object a transport hands back for a sent message. Every bundled
  * transport sets the envelope and the Message-ID, the rest depends on the transport.
  *
- * The index signature keeps a transport specific field readable through this type, and it
- * is also what a result type has to inherit to stay assignable to it, so the result type
- * of a transport outside this package has to extend this interface rather than restate it
+ * The index signature keeps a transport specific field readable through this type, the way
+ * the `any` typed result of @types/nodemailer was, and it is also what a result type has
+ * to inherit to stay assignable to it, so the result type of a transport outside this
+ * package has to extend this interface rather than restate it
  */
 export interface SentMessageInfo {
     /** The envelope the message was sent with */
@@ -33,9 +34,9 @@ export interface SentMessageInfo {
     /** Last response from the server */
     response?: string | undefined;
     /** The generated message, for the transports that hand it back instead of sending it */
-    message?: unknown;
+    message?: any;
     /** Transport specific fields */
-    [key: string]: unknown;
+    [key: string]: any;
 }
 /**
  * Callback for sendMail, receives the transport result once the transport has taken the
@@ -43,9 +44,11 @@ export interface SentMessageInfo {
  */
 export type SendMailCallback<T = SentMessageInfo> = (err: NodemailerError | null, info: T) => void;
 /**
- * Callback for verify(), success is true once the transport accepted the configuration
+ * Callback for verify(), success is true once the transport accepted the configuration.
+ * Declared with a required success value, the way @types/nodemailer declared it, the
+ * error path hands over the error alone
  */
-export type VerifyCallback = (err: NodemailerError | null, success?: true) => void;
+export type VerifyCallback = Callback<true>;
 /**
  * Callback a plugin calls once it is done, an error aborts the send
  */
@@ -60,21 +63,23 @@ export type PluginFunction<T = SentMessageInfo> = (mail: MailMessage<T>, callbac
  */
 export interface GetSocketOptions {
     host?: string | undefined;
-    port?: number | string | undefined;
+    port?: number | undefined;
     [key: string]: any;
 }
 /**
- * The result of a getSocket handler, the socket to use for the connection
+ * The result of a getSocket handler, the socket to use for the connection. The object is
+ * merged into the connection options, so it may carry any of those as well
  */
 export interface SocketOptions {
     /** An established socket, the proxied connection */
     connection?: net.Socket | undefined;
+    [key: string]: any;
 }
 /**
- * Receives the socket options from a getSocket handler, or the error that prevented the
- * connection
+ * Receives the socket options from a getSocket handler, false when a new socket should be
+ * opened, or the error that prevented the connection
  */
-export type GetSocketCallback = (err: NodemailerError | null, socketOptions?: SocketOptions) => void;
+export type GetSocketCallback = (err: Error | null, socketOptions?: SocketOptions | false) => void;
 /**
  * A socket handler. Mail sets one on the transport as getSocket when a proxy is configured,
  * the SMTP transports call it to get a proxied socket instead of connecting directly
@@ -101,9 +106,12 @@ export interface MailMeta {
 /**
  * A transport as consumed by Mail: any object with a name, a version and a send method
  * works, the rest is optional. Mail forwards its close, isIdle and verify calls to the
- * methods of the same name as they are, so their arguments are up to the transport
+ * methods of the same name as they are, so their arguments are up to the transport.
+ *
+ * D is the options type of the transport, the second type parameter @types/nodemailer
+ * declared on Transport, Transporter and Mail
  */
-export interface Transport<T = SentMessageInfo> {
+export interface Transport<T = SentMessageInfo, D extends TransportOptions = TransportOptions> {
     /** Transport name, used for logging */
     name: string;
     /** Transport version, used for logging */
@@ -119,7 +127,7 @@ export interface Transport<T = SentMessageInfo> {
     /** Registers an event listener, the transport may emit 'log', 'error', 'idle' and 'clear' */
     on?(event: string | symbol, listener: (...args: any[]) => void): this;
     /** The Mail object the transport belongs to, set by Mail */
-    mailer?: Mail<T> | undefined;
+    mailer?: Mail<T, D> | undefined;
     /** Socket handler for a proxied connection, set by Mail when a proxy is configured */
     getSocket?: GetSocketHandler | undefined;
 }
@@ -150,22 +158,23 @@ export interface TransportOptions {
     attachDataUrls?: boolean | undefined;
 }
 /**
- * The transporter object createTransport returns, a Mail instance wrapping a transport
+ * The transporter object createTransport returns, a Mail instance wrapping a transport. D
+ * is the options type of the transport, it types the options field of the transporter
  */
-export type Transporter<T = SentMessageInfo> = Mail<T>;
+export type Transporter<T = SentMessageInfo, D extends TransportOptions = TransportOptions> = Mail<T, D>;
 /**
  * Creates an object for exposing the Mail API
  *
  * @constructor
  * @param transporter Transport object instance to pass the mails to
  */
-declare class Mail<out T = SentMessageInfo> extends EventEmitter {
-    options: TransportOptions;
+declare class Mail<out T = SentMessageInfo, out D extends TransportOptions = TransportOptions> extends EventEmitter {
+    options: D;
     /** Message defaults given to createTransport, kept public because the DefinitelyTyped typings declared it */
     _defaults: MailDefaults;
     meta: Map<string, any>;
     dkim: DKIM | false;
-    transporter: Transport<T>;
+    transporter: Transport<T, D>;
     logger: shared.Logger;
     /** Closes the transport, the pooled SMTP transport closes its connections */
     close: () => void;
@@ -178,7 +187,7 @@ declare class Mail<out T = SentMessageInfo> extends EventEmitter {
     };
     /** Socket handler for a proxied connection, set by setupProxy and handed to the transport on the next send */
     getSocket?: GetSocketHandler | false | undefined;
-    constructor(transporter: Transport<T>, options?: TransportOptions, defaults?: MailDefaults);
+    constructor(transporter: Transport<T, D>, options?: D, defaults?: MailDefaults);
     use(step: string, plugin: PluginFunction<T>): this;
     /**
      * Sends an email using the preselected transport object
@@ -213,7 +222,10 @@ declare namespace Mail {
     type ListHeader = MailComposerListHeaderEntry;
     type ListHeaders = MailComposerListHeaders;
     type Envelope = MimeNodeEnvelopeInput;
-    type TextEncoding = NonNullable<SendMailOptions['textEncoding']>;
+    type Connection = SocketOptions;
+    type TextEncoding = MailComposerTextEncoding;
     type PluginFunction<T = SentMessageInfo> = MailPluginFunction<T>;
 }
+/** The same aliases as module level exports, for `import * as Mail` and `import Mail = require()` */
+export type { SendMailOptions as Options, MimeNodeAddress as Address, MailComposerAttachment as Attachment, MailComposerAlternative as AttachmentLike, MailComposerAlternative as AmpAttachment, MailComposerIcalEvent as IcalAttachment, MimeNodeHeaders as Headers, MailComposerListHeaderEntry as ListHeader, MailComposerListHeaders as ListHeaders, MimeNodeEnvelopeInput as Envelope, SocketOptions as Connection, MailComposerTextEncoding as TextEncoding };
 export default Mail;

package/dist/cjs/mailer/mail-message.d.ts

@@ -3,6 +3,7 @@ import type { MailComposerOptions } from '../mail-composer/index.js';
 import type { DKIMOptions } from '../dkim/index.js';
 import type { SMTPEnvelopeDsn } from '../smtp-connection/index.js';
 import type { SMTPTransportAuthOptions } from '../smtp-transport/index.js';
+import type { SESSendEmailRequest } from '../ses-transport/index.js';
 import type { NodemailerError } from '../errors.js';
 import type { ResolveContentOptions } from '../shared/index.js';
 import type Mail from './index.js';
@@ -14,6 +15,8 @@ import type { SentMessageInfo } from './index.js';
 export interface SendMailOptions extends MailComposerOptions {
     /** DKIM signing options for this message, used instead of the ones of the transporter */
     dkim?: DKIMOptions | undefined;
+    /** Extra DKIM options for this message, merged over the options of the signer. The SES transport sets skipFields here, the option is not meant for callers */
+    _dkim?: DKIMOptions | undefined;
     /** Recipients allowed on this message, 0 disables the limit, defaults to 100000 */
     maxRecipients?: number | undefined;
     /** SMTP transports: DSN parameters for the envelope, sent when the server supports the DSN extension */
@@ -23,9 +26,7 @@ export interface SendMailOptions extends MailComposerOptions {
     /** SMTP transports: per-message authentication settings, used instead of the transport level auth */
     auth?: SMTPTransportAuthOptions | undefined;
     /** SES transport: extra SendEmailCommand parameters merged into the API call */
-    ses?: {
-        [key: string]: unknown;
-    } | undefined;
+    ses?: SESSendEmailRequest | undefined;
 }
 /**
  * Default message fields, the third argument of createTransport. Applied to every message
@@ -71,7 +72,13 @@ export interface MailMessageListHeader {
 export default class MailMessage<T = SentMessageInfo> {
     mailer: Mail<T>;
     data: MailMessageData;
-    message: MimeNode | null;
+    /**
+     * The compiled MIME tree. Set once the compile step is done, so it is null while the
+     * 'compile' plugins run and set by the time the 'stream' plugins and the transport see
+     * the message. Declared as always set, the way @types/nodemailer declared it, since the
+     * plugins that read it are the ones that run after it is set
+     */
+    message: MimeNode;
     constructor(mailer: Mail<T>, data?: SendMailOptions);
     resolveContent(data: {
         [key: string]: any;

package/dist/cjs/mailer/mail-message.js

@@ -107,8 +107,9 @@ class MailMessage {
         if (this.data.attachments && this.data.attachments.length) {
             this.data.attachments.forEach((attachment, i) => {
                 if (!attachment.filename) {
+                    // a backslash separates as well, so a Windows path does not put the sender's directories in the headers
                     attachment.filename =
-                        (attachment.path || attachment.href || '').split('/').pop().split('?').shift() ||
+                        (attachment.path || attachment.href || '').split(/[/\\]/).pop().split('?').shift() ||
                             'attachment-' + (i + 1);
                     if (attachment.filename.indexOf('.') < 0) {
                         attachment.filename += '.' + mimeFuncs.detectExtension(attachment.contentType);

package/dist/cjs/mime-funcs/index.d.ts

@@ -2,8 +2,8 @@
  * A header value split into the value token and its parameters, the result of parseHeaderValue
  */
 export interface ParsedHeaderValue {
-    /** The value ahead of the parameters, for example the content type */
-    value: string | false;
+    /** The value ahead of the parameters, for example the content type, an empty string when there is none */
+    value: string;
     /** Parameter values keyed by lowercase parameter name */
     params: Record<string, string>;
 }
@@ -25,6 +25,9 @@ export interface EncodedHeaderParam {
     /** Parameter value of this part */
     value: string;
 }
+/** The names @types/nodemailer used for the two types above */
+export type HeaderValue = StructuredHeaderValue;
+export type ParsedHeaderParam = EncodedHeaderParam;
 /**
  * Checks if a value is plaintext string (uses only printable 7bit chars)
  *

package/dist/cjs/mime-funcs/index.js

@@ -402,7 +402,7 @@ function buildHeaderParam(key, data, maxLength) {
  */
 function parseHeaderValue(str) {
     const response = {
-        value: false,
+        value: '',
         params: {}
     };
     // Parameter names come from a caller supplied contentType/contentDisposition. A