@c9up/rover 0.1.9 → 0.1.10

package/src/Mail.ts

@@ -4,6 +4,7 @@ import { BaseMail } from "./BaseMail.js";
 import {
 	type MailAttachment,
 	type MailMessage,
+	type MessageBodyTemplates,
 	MessageBuilder,
 } from "./MessageBuilder.js";
 import {
@@ -75,24 +76,40 @@ export interface EmitterLike {
 }
 
 /**
- * Emitted (`mail:sending`) right before the transport `send` runs — no
- * `messageId` yet, since the provider hasn't accepted the message.
+ * What every mail lifecycle event carries, matching `@adonisjs/mail`:
+ * the mailer that handled it, the message itself, and the templates it was
+ * rendered from. A listener migrating over reads `message.to` / `views.html`.
+ *
+ * `transportName` and the flattened recipient lists are rover's own and stay:
+ * the transport name is the same string as `mailerName` under the name rover
+ * used first, and a listener that only wants the addresses should not have to
+ * reach into the message for them.
  */
-export interface MailSendingEvent {
+export type { MessageBodyTemplates };
+
+export interface MailEventBase {
+	/** AdonisJS name for the mailer that handled the message. */
+	mailerName: string;
+	/** The built message. */
+	message: MailMessage;
+	/** Templates the message was rendered from, empty when it carried none. */
+	views: MessageBodyTemplates;
 	to: string[];
 	cc: string[];
 	bcc: string[];
+	/** rover's original name for {@link MailEventBase.mailerName}. */
 	transportName: string;
 	timestamp: number;
 }
 
-export interface MailSentEvent {
+/**
+ * Emitted (`mail:sending`) right before the transport `send` runs — no
+ * `messageId` yet, since the provider hasn't accepted the message.
+ */
+export interface MailSendingEvent extends MailEventBase {}
+
+export interface MailSentEvent extends MailEventBase {
 	messageId: string;
-	to: string[];
-	cc: string[];
-	bcc: string[];
-	transportName: string;
-	timestamp: number;
 }
 
 /**
@@ -100,22 +117,13 @@ export interface MailSentEvent {
  * only present on `mail:queued` (once the job has been accepted by the queue /
  * in-memory messenger).
  */
-export interface MailQueueEvent {
-	to: string[];
-	cc: string[];
-	bcc: string[];
-	transportName: string;
+export interface MailQueueEvent extends MailEventBase {
 	queue: string;
 	jobId?: string;
-	timestamp: number;
 }
 
-export interface MailFailedEvent {
+export interface MailFailedEvent extends MailEventBase {
 	messageId: string;
-	to: string[];
-	cc: string[];
-	bcc: string[];
-	transportName: string;
 	error: {
 		code: string;
 		message: string;
@@ -123,7 +131,6 @@ export interface MailFailedEvent {
 		upstreamStatusRaw?: string;
 		attempts: number;
 	};
-	timestamp: number;
 }
 
 export interface MailConfig {
@@ -250,6 +257,10 @@ export class SmtpTransport implements MailTransport {
 				subject: message.subject,
 				html: message.html,
 				text: message.text,
+				// nodemailer reads `watchHtml`; there is no bare `watch` field in
+				// its mail composer, so writing one — as AdonisJS does — never
+				// reaches the wire.
+				watchHtml: message.watchHtml,
 				priority: message.priority,
 				messageId: message.messageId,
 				inReplyTo: message.inReplyTo,
@@ -428,11 +439,53 @@ export class Mail {
 		}
 
 		if (options?.queue) {
-			this.#queue = options.queue;
-			this.#queue.register(this.#queueName, new MailJobHandler(this));
+			this.setMessenger(options.queue);
 		}
 	}
 
+	/**
+	 * Send a message that is already built (AdonisJS `sendCompiled`).
+	 *
+	 * What a queue worker calls: the message was composed and serialised
+	 * elsewhere, so there is nothing left to render. An alias of
+	 * {@link dispatchMessage}, which is the name ream used first.
+	 */
+	async sendCompiled(message: MailMessage, transport?: string): Promise<void> {
+		await this.dispatchMessage(message, transport);
+	}
+
+	/**
+	 * Queue a message that is already built (AdonisJS `sendLaterCompiled`).
+	 *
+	 * Returns the job id, like {@link sendLater}.
+	 */
+	async sendLaterCompiled(
+		message: MailMessage,
+		options?: { transport?: string; queue?: string },
+	): Promise<string> {
+		// No views: a compiled message was rendered elsewhere, and the templates
+		// that produced it did not travel with it.
+		return this.#enqueue({ message, views: {} }, options);
+	}
+
+	/**
+	 * Hand `sendLater()` a queue after construction (AdonisJS `setMessenger`).
+	 *
+	 * The constructor takes one too, but a queue is often resolved later than
+	 * the mailer — a provider that boots after this one, a test that swaps it.
+	 * Without this the only way in was the constructor, so an app migrating
+	 * from `mail.setMessenger(queue)` stopped at a TypeError.
+	 *
+	 * "Messenger" is upstream's word for what rover's config calls `queue`;
+	 * they are the same thing, and the method keeps the upstream name so a
+	 * migrated call site resolves.
+	 */
+	setMessenger(messenger: BayQueueLike): this {
+		this.#queue = messenger;
+		this.#queue.register(this.#queueName, new MailJobHandler(this));
+		return this;
+	}
+
 	/** Send an email using the fluent message builder. */
 	async send(
 		callback: (message: MessageBuilder) => void,
@@ -449,15 +502,9 @@ export class Mail {
 		// BaseMail, for constructor-based assertions) instead of touching a
 		// transport. Still fire the send lifecycle so event wiring stays testable.
 		if (this.#fake !== null) {
-			const message = await this.#buildMessage(arg);
+			const { message, views } = await this.#buildMessageWithViews(arg);
 			this.#fake.trackSent(message, arg instanceof BaseMail ? arg : undefined);
-			const base = {
-				to: message.to.slice(),
-				cc: message.cc.slice(),
-				bcc: message.bcc.slice(),
-				transportName,
-				timestamp: Date.now(),
-			};
+			const base = this.#eventBase(message, views, transportName);
 			this.#fireSending(base);
 			this.#fireSent({ ...base, messageId: randomBytes(16).toString("hex") });
 			return;
@@ -467,8 +514,8 @@ export class Mail {
 			throw new Error(`Mail transport '${transportName}' not configured`);
 		}
 
-		const message = await this.#buildMessage(arg);
-		await this.dispatchMessage(message, transportName);
+		const { message, views } = await this.#buildMessageWithViews(arg);
+		await this.dispatchMessage(message, transportName, undefined, views);
 	}
 
 	/**
@@ -481,24 +528,34 @@ export class Mail {
 		arg: ((message: MessageBuilder) => void) | BaseMail,
 		options?: { transport?: string; queue?: string },
 	): Promise<string> {
-		const message = await this.#buildMessage(arg);
+		const built = await this.#buildMessageWithViews(arg);
+		return this.#enqueue(
+			{ ...built, source: arg instanceof BaseMail ? arg : undefined },
+			options,
+		);
+	}
+
+	/** The queueing half, shared with {@link sendLaterCompiled}. */
+	async #enqueue(
+		built: {
+			message: MailMessage;
+			views: MessageBodyTemplates;
+			/** The BaseMail it came from, for `assertQueued(WelcomeMail)`. */
+			source?: BaseMail;
+		},
+		options?: { transport?: string; queue?: string },
+	): Promise<string> {
+		const { message, views } = built;
 		const queueName = options?.queue ?? this.#queueName;
 		const transportName = options?.transport ?? this.#defaultTransport;
 		const base: MailQueueEvent = {
-			to: message.to.slice(),
-			cc: message.cc.slice(),
-			bcc: message.bcc.slice(),
-			transportName,
+			...this.#eventBase(message, views, transportName),
 			queue: queueName,
-			timestamp: Date.now(),
 		};
 
 		// Fake mode: capture into the queued bucket, don't dispatch.
 		if (this.#fake !== null) {
-			this.#fake.trackQueued(
-				message,
-				arg instanceof BaseMail ? arg : undefined,
-			);
+			this.#fake.trackQueued(message, built.source);
 			const jobId = `fake_${randomBytes(12).toString("hex")}`;
 			this.#fireQueueing(base);
 			this.#fireQueued({ ...base, jobId });
@@ -530,6 +587,11 @@ export class Mail {
 		message: MailMessage,
 		transportName?: string,
 		overrideRetry?: RetryConfig,
+		// The templates the message came from, when the caller still knows them.
+		// A message revived from a queue payload does not: the rendered bodies
+		// were serialised, the templates that produced them were not. Empty is
+		// the honest answer there rather than a guess.
+		views: MessageBodyTemplates = {},
 	): Promise<void> {
 		// Defense-in-depth: queue payloads bypass `#buildMessage`, so a
 		// malformed message deserialised from storage would otherwise reach
@@ -550,13 +612,7 @@ export class Mail {
 
 		// Fire once before the first attempt — `mail:sending` signals intent, not
 		// per-retry, matching @adonisjs/mail.
-		this.#fireSending({
-			to: message.to.slice(),
-			cc: message.cc.slice(),
-			bcc: message.bcc.slice(),
-			transportName: name,
-			timestamp: Date.now(),
-		});
+		this.#fireSending(this.#eventBase(message, views, name));
 
 		for (let attempt = 1; attempt <= retry.maxAttempts; attempt += 1) {
 			let sendResult: MailSendOutcome;
@@ -568,13 +624,9 @@ export class Mail {
 				if (!retryable || attempt === retry.maxAttempts) {
 					const annotated = this.#withAttempts(err, attempt);
 					this.#fireFailed({
+						...this.#eventBase(message, views, name),
 						messageId: generatedId,
-						to: message.to.slice(),
-						cc: message.cc.slice(),
-						bcc: message.bcc.slice(),
-						transportName: name,
 						error: errorDescriptor(annotated, attempt),
-						timestamp: Date.now(),
 					});
 					throw annotated;
 				}
@@ -596,12 +648,8 @@ export class Mail {
 			const providerId =
 				providerIdRaw && providerIdRaw.length > 0 ? providerIdRaw : undefined;
 			this.#fireSent({
+				...this.#eventBase(message, views, name),
 				messageId: providerId ?? generatedId,
-				to: message.to.slice(),
-				cc: message.cc.slice(),
-				bcc: message.bcc.slice(),
-				transportName: name,
-				timestamp: Date.now(),
 			});
 			return;
 		}
@@ -674,21 +722,49 @@ export class Mail {
 		}
 	}
 
-	async #buildMessage(
+	/**
+	 * Build the message AND report which templates it was rendered from, since
+	 * every lifecycle event carries both (AdonisJS `message` + `views`).
+	 */
+	async #buildMessageWithViews(
 		arg: ((message: MessageBuilder) => void) | BaseMail,
-	): Promise<MailMessage> {
+	): Promise<{ message: MailMessage; views: MessageBodyTemplates }> {
 		let result: MailMessage;
+		let views: MessageBodyTemplates;
 		if (arg instanceof BaseMail) {
 			const built = await arg.build(this.#viewsRoot);
 			result = built.from ? built : { ...built, from: this.#defaultFrom };
+			views = arg.message.views;
 		} else {
 			const builder = new MessageBuilder();
 			builder.from(this.#defaultFrom);
 			arg(builder);
 			result = await builder.build(this.#viewsRoot);
+			views = builder.views;
 		}
 		validateMailMessage(result);
-		return result;
+		return { message: result, views };
+	}
+
+	/**
+	 * The fields every lifecycle event shares. One place, so `mail:sending` and
+	 * `mail:sent` cannot describe the same message differently.
+	 */
+	#eventBase(
+		message: MailMessage,
+		views: MessageBodyTemplates,
+		mailerName: string,
+	): MailEventBase {
+		return {
+			mailerName,
+			message,
+			views,
+			to: message.to.slice(),
+			cc: message.cc.slice(),
+			bcc: message.bcc.slice(),
+			transportName: mailerName,
+			timestamp: Date.now(),
+		};
 	}
 
 	/**

package/src/MessageBuilder.ts

@@ -5,6 +5,33 @@ import { formatAddress } from "./format.js";
 import { RoverError } from "./RoverError.js";
 import { renderFile as renderTemplateFile } from "./templating/SimpleTemplate.js";
 
+/**
+ * A header nodemailer must pass through untouched (`{ prepared: true }`).
+ *
+ * Normal headers get re-encoded — folded, MIME-encoded when non-ASCII. A value
+ * that is already exactly what must go on the wire (a signature, a
+ * pre-encoded id) has to say so, or the encoding corrupts it.
+ */
+export interface PreparedHeader {
+	prepared: true;
+	value: string;
+}
+
+/**
+ * A header value as a plain string, for the HTTP-API transports.
+ *
+ * "Prepared" is a nodemailer notion — it tells its MIME encoder to leave the
+ * value alone. A provider REST API takes a JSON string and does no MIME
+ * encoding, so the flag has nothing to say there; sending the wrapper object
+ * would put `[object Object]` on the wire.
+ */
+export function headerValue(
+	value: string | string[] | PreparedHeader,
+): string | string[] {
+	if (Array.isArray(value) || typeof value === "string") return value;
+	return value.value;
+}
+
 export interface MailMessage {
 	from: string;
 	to: string[];
@@ -14,8 +41,13 @@ export interface MailMessage {
 	subject: string;
 	html?: string;
 	text?: string;
+	/**
+	 * The Apple Watch body (nodemailer `watchHtml`). A stripped-down HTML part
+	 * a watch renders instead of the full one.
+	 */
+	watchHtml?: string;
 	attachments: MailAttachment[];
-	headers: Record<string, string | string[]>;
+	headers: Record<string, string | string[] | PreparedHeader>;
 	/** Email priority hint (nodemailer `priority`). */
 	priority?: "low" | "normal" | "high";
 	/** Custom `Message-ID` header (threading / idempotency). */
@@ -115,8 +147,19 @@ export interface RecipientObject {
 export type Recipient = string | RecipientObject;
 
 /** Whether `list` holds `address`, or anything at all when it is omitted. */
-function contains(list: readonly string[], address?: string): boolean {
+function contains(
+	list: readonly string[],
+	address?: string,
+	name?: string,
+): boolean {
 	if (address === undefined) return list.length > 0;
+	// With a name, both halves must match — the entry was stored through
+	// `formatAddress`, so rebuilding it is the exact comparison (AdonisJS
+	// checks address AND name the same way).
+	if (name !== undefined) {
+		const formatted = formatAddress(address, name);
+		return list.some((entry) => entry === formatted);
+	}
 	// Addresses are stored formatted (`"Name" <a@b.c>`), so an assertion on the
 	// bare address has to match inside the display form too.
 	return list.some(
@@ -208,6 +251,16 @@ function expect(passed: boolean, expectation: string, actual: unknown): void {
 	);
 }
 
+/**
+ * Which templates a message was rendered from — AdonisJS
+ * `MessageBodyTemplates`, carried on every mail lifecycle event.
+ */
+export interface MessageBodyTemplates {
+	html?: { template: string; data: Record<string, unknown> };
+	text?: { template: string; data: Record<string, unknown> };
+	watch?: { template: string; data: Record<string, unknown> };
+}
+
 export class MessageBuilder {
 	#msg: MailMessage = {
 		from: "",
@@ -219,6 +272,15 @@ export class MessageBuilder {
 		headers: {},
 	};
 	#pendingView: { path: string; data: Record<string, unknown> } | null = null;
+	/**
+	 * The templates {@link build} actually rendered. Recorded because `build()`
+	 * clears the pending views once they are rendered, and the lifecycle events
+	 * carry them (AdonisJS `views`, the third field of every mail event) — an
+	 * app logging a send wants to know which template produced it.
+	 */
+	#renderedViews: MessageBodyTemplates = {};
+	#pendingWatchView: { path: string; data: Record<string, unknown> } | null =
+		null;
 	#pendingTextView: { path: string; data: Record<string, unknown> } | null =
 		null;
 
@@ -265,20 +327,24 @@ export class MessageBuilder {
 	// `has*` answers, `assert*` throws. Both exist because a test reads better
 	// as an assertion and a conditional reads better as a question.
 
-	hasTo(address?: string): boolean {
-		return contains(this.#msg.to, address);
+	hasTo(address?: string, name?: string): boolean {
+		return contains(this.#msg.to, address, name);
 	}
-	hasCc(address?: string): boolean {
-		return contains(this.#msg.cc, address);
+	hasCc(address?: string, name?: string): boolean {
+		return contains(this.#msg.cc, address, name);
 	}
-	hasBcc(address?: string): boolean {
-		return contains(this.#msg.bcc, address);
+	hasBcc(address?: string, name?: string): boolean {
+		return contains(this.#msg.bcc, address, name);
 	}
-	hasFrom(address?: string): boolean {
-		return contains(this.#msg.from ? [this.#msg.from] : [], address);
+	hasFrom(address?: string, name?: string): boolean {
+		return contains(this.#msg.from ? [this.#msg.from] : [], address, name);
 	}
-	hasReplyTo(address?: string): boolean {
-		return contains(this.#msg.replyTo ? [this.#msg.replyTo] : [], address);
+	hasReplyTo(address?: string, name?: string): boolean {
+		return contains(
+			this.#msg.replyTo ? [this.#msg.replyTo] : [],
+			address,
+			name,
+		);
 	}
 	hasSubject(subject?: string): boolean {
 		if (subject === undefined) return this.#msg.subject !== "";
@@ -301,11 +367,42 @@ export class MessageBuilder {
 	}
 
 	/**
-	 * Whether `address` is a recipient in ANY field (AdonisJS `hasRecipient`).
-	 * Without one, whether the message has a recipient at all.
+	 * Whether `address` appears in ONE named field (AdonisJS `hasRecipient`).
+	 *
+	 * The field comes first, as upstream: `hasRecipient('to', 'a@b.c')`. It used
+	 * to take the address alone and search every field, so a migrated
+	 * `hasRecipient('to', addr)` asked whether `'to'` was a recipient and quietly
+	 * answered false — the worst possible outcome inside a test assertion.
+	 * {@link hasAnyRecipient} is the any-field question under a name that says so.
 	 */
-	hasRecipient(address?: string): boolean {
-		return this.hasTo(address) || this.hasCc(address) || this.hasBcc(address);
+	hasRecipient(
+		property: "to" | "cc" | "bcc" | "replyTo",
+		address: string,
+		name?: string,
+	): boolean {
+		switch (property) {
+			case "to":
+				return this.hasTo(address, name);
+			case "cc":
+				return this.hasCc(address, name);
+			case "bcc":
+				return this.hasBcc(address, name);
+			case "replyTo":
+				return this.hasReplyTo(address, name);
+		}
+	}
+
+	/**
+	 * Whether `address` is a recipient in any of `to` / `cc` / `bcc`. Without
+	 * one, whether the message has a recipient at all. Ream's own, since
+	 * "does this reach them" is the question an assertion usually asks.
+	 */
+	hasAnyRecipient(address?: string, name?: string): boolean {
+		return (
+			this.hasTo(address, name) ||
+			this.hasCc(address, name) ||
+			this.hasBcc(address, name)
+		);
 	}
 
 	/**
@@ -374,7 +471,7 @@ export class MessageBuilder {
 
 	/** `address` is a recipient in some field (AdonisJS `assertRecipient`). */
 	assertRecipient(address: string): void {
-		expect(this.hasRecipient(address), `to reach "${address}"`, {
+		expect(this.hasAnyRecipient(address), `to reach "${address}"`, {
 			to: this.#msg.to,
 			cc: this.#msg.cc,
 			bcc: this.#msg.bcc,
@@ -410,6 +507,22 @@ export class MessageBuilder {
 		);
 	}
 
+	/**
+	 * The Apple Watch body contains `substring` (AdonisJS
+	 * `assertWatchIncludes`).
+	 *
+	 * Takes a RegExp as well as a string, as upstream does — a rendered body
+	 * rarely matches a fixed substring exactly.
+	 */
+	assertWatchIncludes(substring: string | RegExp): void {
+		const body = this.#msg.watchHtml ?? "";
+		const hit =
+			typeof substring === "string"
+				? body.includes(substring)
+				: substring.test(body);
+		expect(hit, `watch body to include "${String(substring)}"`, body);
+	}
+
 	from(address: string, name?: string): this {
 		this.#msg.from = formatAddress(address, name);
 		return this;
@@ -449,6 +562,35 @@ export class MessageBuilder {
 		this.#msg.html = content;
 		return this;
 	}
+
+	/**
+	 * The Apple Watch body (AdonisJS `watch`).
+	 *
+	 * NAMED DEVIATION — this writes nodemailer's `watchHtml`. AdonisJS writes a
+	 * bare `watch` field, which nodemailer's mail composer never reads
+	 * (lib/mail-composer/index.js only looks at `watchHtml`), so upstream's
+	 * watch body never reaches the wire. {@link watchHtml} is the same method
+	 * under the field's own name.
+	 */
+	watch(content: string): this {
+		return this.watchHtml(content);
+	}
+
+	watchHtml(content: string): this {
+		this.#msg.watchHtml = content;
+		return this;
+	}
+
+	/**
+	 * Render a template as the Apple Watch body (AdonisJS `watchView`).
+	 *
+	 * The counterpart of {@link htmlView} and {@link textView}: the render
+	 * happens lazily at `build()` time so the fluent chain stays synchronous.
+	 */
+	watchView(viewPath: string, data?: Record<string, unknown>): this {
+		this.#pendingWatchView = { path: viewPath, data: data ?? {} };
+		return this;
+	}
 	text(content: string): this {
 		this.#msg.text = content;
 		return this;
@@ -565,6 +707,17 @@ export class MessageBuilder {
 		return this;
 	}
 
+	/**
+	 * A header nodemailer passes through untouched (AdonisJS `preparedHeader`).
+	 *
+	 * Use it when the value IS what must appear on the wire and re-encoding
+	 * would corrupt it — a signature, an already-encoded message id.
+	 */
+	preparedHeader(key: string, value: string): this {
+		this.#msg.headers[key] = { prepared: true, value };
+		return this;
+	}
+
 	/**
 	 * Body transfer encoding (AdonisJS `encoding`) — `7bit`, `base64`,
 	 * `quoted-printable`… SMTP only: the provider HTTP APIs encode the payload
@@ -674,6 +827,26 @@ export class MessageBuilder {
 		return this;
 	}
 
+	/** The templates {@link build} rendered, for the lifecycle events. */
+	get views(): MessageBodyTemplates {
+		return { ...this.#renderedViews };
+	}
+
+	/** AdonisJS' name for {@link views}. */
+	get contentViews(): MessageBodyTemplates {
+		return this.views;
+	}
+
+	/**
+	 * The message as a plain object (AdonisJS `nodeMailerMessage`).
+	 *
+	 * A live reference, as upstream's is — this is the object the transports
+	 * read, not a snapshot. {@link build} is what finalises it.
+	 */
+	get nodeMailerMessage(): MailMessage {
+		return this.#msg;
+	}
+
 	/**
 	 * Finalise the message. `viewsRoot`, when provided by the owning `Mail`,
 	 * scopes template resolution to that instance's configured root instead of
@@ -682,6 +855,10 @@ export class MessageBuilder {
 	 */
 	async build(viewsRoot?: string): Promise<MailMessage> {
 		if (this.#pendingView !== null) {
+			this.#renderedViews.html = {
+				template: this.#pendingView.path,
+				data: this.#pendingView.data,
+			};
 			this.#msg.html = await renderTemplateFile(
 				this.#pendingView.path,
 				this.#pendingView.data,
@@ -690,7 +867,24 @@ export class MessageBuilder {
 			);
 			this.#pendingView = null;
 		}
+		if (this.#pendingWatchView !== null) {
+			this.#renderedViews.watch = {
+				template: this.#pendingWatchView.path,
+				data: this.#pendingWatchView.data,
+			};
+			this.#msg.watchHtml = await renderTemplateFile(
+				this.#pendingWatchView.path,
+				this.#pendingWatchView.data,
+				undefined,
+				viewsRoot,
+			);
+			this.#pendingWatchView = null;
+		}
 		if (this.#pendingTextView !== null) {
+			this.#renderedViews.text = {
+				template: this.#pendingTextView.path,
+				data: this.#pendingTextView.data,
+			};
 			this.#msg.text = await renderTemplateFile(
 				this.#pendingTextView.path,
 				this.#pendingTextView.data,

package/src/index.ts

@@ -15,6 +15,7 @@ export type {
 	EmitterLike,
 	MailAttachment,
 	MailConfig,
+	MailEventBase,
 	MailFailedEvent,
 	MailHooks,
 	MailMessage,
@@ -25,6 +26,7 @@ export type {
 	MailSentEvent,
 	MailTransport,
 	MailTransportFactory,
+	MessageBodyTemplates,
 } from "./Mail.js";
 export {
 	LogTransport,
@@ -41,10 +43,11 @@ export type {
 	CalendarEventOptions,
 	ListHeader,
 	MailEnvelope,
+	PreparedHeader,
 	Recipient,
 	RecipientObject,
 } from "./MessageBuilder.js";
-export { attachmentsFor } from "./MessageBuilder.js";
+export { attachmentsFor, headerValue } from "./MessageBuilder.js";
 export { RoverError } from "./RoverError.js";
 export { default as RoverProvider } from "./RoverProvider.js";
 export {