void 0.10.12 → 0.20.0

package/dist/mime-BJD7d_qL.mjs

@@ -0,0 +1,1216 @@
+import { validate } from "email-validator";
+//#region src/runtime/email/mime.ts
+/**
+* Minimal RFC 5322 / 2047 / 2045 MIME builder for the void/email runtime.
+*
+* Scope is intentionally narrow — text/plain, text/html, multipart/alternative,
+* and multipart/mixed for attachments — covering >95% of transactional sends.
+* Inline images use multipart/related when both attachments and html are present.
+*/
+/** Cloudflare Email Workers reject messages larger than ~10 MB after base64 expansion. */
+const MAX_MESSAGE_BYTES = 10485760;
+/**
+* Upper bound on the TOTAL attachment bytes `normalizeEmail` will materialize.
+*
+* Base64 expands by `ceil(n / 3) * 4`, so an attachment set larger than three
+* quarters of `MAX_MESSAGE_BYTES` cannot fit in a message that passes the
+* check at the end of `buildMime` no matter how small everything else is.
+* `buildMime` remains the authority on the final size — this bound only stops
+* `normalizeEmail` from materializing, and then expanding, bytes already known
+* not to fit.
+*
+* It has to be charged here because that final check comes far too late to
+* help. Measured peak live memory is about 10x the attachment bytes (8 MiB in
+* gives 83 MiB live) once the normalized copy, the base64 binary string, the
+* 76-column slices, the joins, `rawText` and its `TextEncoder.encode` are all
+* resident at once. Against a 128 MB isolate ceiling, a set over roughly
+* 12 MiB terminates the isolate rather than returning the `MIME_ERROR` the
+* docs promise for an oversize payload.
+*
+* This is a developer-experience guardrail, NOT the security boundary.
+* Attachments come from the app's own code, never from a remote sender, and
+* the platform proxy already caps the base64 length before decoding and the
+* raw length after. What this buys is a precise, catchable failure at the call
+* that went wrong, instead of a dead isolate with nothing a caller could act
+* on.
+*/
+const MAX_ATTACHMENT_BYTES_TOTAL = Math.floor(MAX_MESSAGE_BYTES * 3 / 4);
+const CRLF = "\r\n";
+const ASCII_PRINTABLE = /^[\x20-\x7e]*$/;
+const HEADER_NAME = /^[!-9;-~]+$/;
+function rejectCRLF(field, value) {
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c === 13 || c === 10 || c === 0) throw new MimeError("MIME_ERROR", `${field}: must not contain CR, LF, or NUL.`);
+	}
+}
+/**
+* Refuse any other C0 control or DEL in a value that is rendered VERBATIM
+* into a header — an attachment's filename, media type and Content-ID.
+* `rejectCRLF` is enough for a value `encodeWord` renders (the subject, a
+* custom header value, a display name): anything outside printable ASCII
+* sends the whole value into base64, so a control never reaches the wire.
+* These three go through `quoteParam` or straight into the line, so
+* `invoice\x01.pdf` was written raw into `name="…"` and `filename="…"`,
+* captured as a success under `void dev` and by the test harness, and left
+* for the receiving MTA to refuse.
+*
+* RFC 5322 §3.2.4 `qtext` is printable US-ASCII less `"` and `\`; a
+* control inside a quoted-string is `obs-qtext`, which §4 says MUST NOT be
+* generated. HTAB is deliberately NOT refused: `quoted-string` is
+* `DQUOTE *([FWS] qcontent) [FWS] DQUOTE` and `FWS` is built from `WSP`
+* (SP / HTAB), so a tab between characters is folding white space exactly
+* as a space is — and `obs-NO-WS-CTL`, the RFC's own list of the controls
+* that used to be `qtext`, leaves %d9 out. The same set is illegal in an
+* RFC 2045 §5.1 `token` (no CTLs) and an RFC 5322 §3.6.4 `msg-id`
+* (`dot-atom-text`), so one rule serves the media type and the Content-ID.
+*
+* The message names the code point and never echoes the value, as
+* `validateAddressParts` does. Runs AFTER the filename's length bound, so
+* the scan is over a value already known to fit a line.
+*/
+function rejectControls(field, value) {
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c < 32 && c !== 9 || c === 127) throw new MimeError("MIME_ERROR", `${field} contains a control character (U+${c.toString(16).toUpperCase().padStart(4, "0")}).`);
+	}
+}
+/** RFC 2045 §5.1 `tspecials`: what a `token` may not contain besides SPACE and CTLs. */
+const TSPECIALS = "()<>@,;:\\\"/[]?=";
+/** RFC 2045 §5.1 `token` character: printable US-ASCII less SPACE and `tspecials`. */
+function isTokenChar(c) {
+	return c > 32 && c < 127 && !TSPECIALS.includes(String.fromCharCode(c));
+}
+/**
+* Refuse an attachment media type that does not parse as RFC 2045 §5.1
+* `type "/" subtype *(";" parameter)`.
+*
+* `rejectControls` answers only for CTLs, and `buildAttachmentPart` writes
+* the value verbatim ahead of its own `; name="…"`, so `text/plain; x="`
+* rendered `Content-Type: text/plain; x="; name="a.txt"` — captured as a
+* success under `void dev` and by the harness, while Python's `email`
+* reports `end of header inside quoted string` on that line and reads the
+* builder's `name` parameter as the VALUE of `x`. `text` (no subtype),
+* `text/plain; charset` (no value) and `text/plain;;` went the same way.
+*
+* The grammar is the RFC's, read as a generator: a `token` is printable
+* US-ASCII less SPACE and `tspecials`; a `value` is a `token` or a
+* quoted-string, whose content is anything but a bare `"` or `\` (the same
+* rule `quoteParam` renders `name="…"` by, so a caller's quoted value may
+* carry what the builder's own already does). Optional WSP is admitted on
+* either side of `;` — the RFC 822 implicit LWSP every parser accepts and
+* the form HTTP's `Content-Type` writes — and nowhere else: `text/ plain`,
+* a trailing `;`, and an RFC 822 comment are refused rather than repaired.
+* Two parameters are also refused on their meaning: a `name`, because the
+* builder appends `name="<filename>"` and RFC 6838 §4.3 makes it "an error
+* for a specific parameter to be specified more than once"; and by that
+* same sentence any attribute given twice, compared case-insensitively as
+* §5.1 says attributes match. Type and subtype are kept as given — matching
+* is case-insensitive, so `TEXT/PLAIN` is legal and renders unchanged.
+*
+* One pass, no backtracking, and the only allocation is one lower-cased
+* attribute per parameter for the duplicate check, which is why this runs
+* AFTER the value's length bound. The message names the rule and never
+* echoes the value.
+*/
+function validateMediaType(field, value) {
+	const syntax = () => new MimeError("MIME_ERROR", `${field} is not a valid media type (RFC 2045 §5.1: type/subtype, then ; attribute=value parameters).`);
+	const n = value.length;
+	let i = 0;
+	/** Advance over a `token`; the number of characters consumed. */
+	const token = () => {
+		const start = i;
+		while (i < n && isTokenChar(value.charCodeAt(i))) i++;
+		return i - start;
+	};
+	const wsp = () => {
+		while (i < n && (value[i] === " " || value[i] === "	")) i++;
+	};
+	if (token() === 0 || value[i] !== "/") throw syntax();
+	i++;
+	if (token() === 0) throw syntax();
+	const seen = /* @__PURE__ */ new Set();
+	while (i < n) {
+		wsp();
+		if (value[i] !== ";") throw syntax();
+		i++;
+		wsp();
+		const start = i;
+		if (token() === 0 || value[i] !== "=") throw syntax();
+		const attribute = value.slice(start, i).toLowerCase();
+		i++;
+		if (value[i] === "\"") {
+			i++;
+			for (;;) {
+				if (i >= n) throw syntax();
+				const ch = value[i++];
+				if (ch === "\"") break;
+				if (ch === "\\") {
+					if (i >= n) throw syntax();
+					i++;
+				}
+			}
+		} else if (token() === 0) throw syntax();
+		if (attribute === "name") throw new MimeError("MIME_ERROR", `${field} must not carry a name= parameter; the builder adds name="<filename>" itself.`);
+		if (seen.has(attribute)) throw new MimeError("MIME_ERROR", `${field} gives the same parameter twice; attribute names are case-insensitive and each may appear once (RFC 6838 §4.3).`);
+		seen.add(attribute);
+	}
+}
+/** RFC 5322 §3.2.3 `atext` besides ALPHA and DIGIT. */
+const ATEXT_SYMBOLS = "!#$%&'*+-/=?^_`{|}~";
+/** RFC 5322 §3.2.3 `atext` character. */
+function isAtext(c) {
+	return c >= 48 && c <= 57 || c >= 65 && c <= 90 || c >= 97 && c <= 122 || ATEXT_SYMBOLS.includes(String.fromCharCode(c));
+}
+/**
+* Refuse an attachment Content-ID that would not render as one RFC 5322
+* §3.6.4 `msg-id`.
+*
+* `rejectControls` answers only for CTLs, and `buildAttachmentPart` writes
+* the value verbatim — adding `<` and `>` unless the value already starts
+* with `<` — so `logo other` rendered `Content-ID: <logo other>`, `<logo`
+* rendered `Content-ID: <logo` and `logo>` rendered `Content-ID: <logo>>`:
+* captured as a success under `void dev` and by the harness, and left for
+* the receiver to refuse or to fail the `cid:` reference against.
+*
+* The grammar is the RFC's, read as a generator, with two deliberate
+* differences. An `msg-id` is `"<" id-left "@" id-right ">"`, each side a
+* `dot-atom-text` (§3.2.3: `1*atext *("." 1*atext)`, so no leading,
+* trailing or doubled dot — the strict form; `obs-id-left`/`obs-id-right`
+* are §4 obsolete syntax, which MUST NOT be generated); `no-fold-literal`
+* (`[…]` for `id-right`) is left out. First difference: the `@` and its
+* right side are OPTIONAL. RFC 2392 §2 resolves a `cid:` URL by wrapping
+* its body in `<` `>` and matching that against `Content-ID`, so an id
+* without `@` — the documented `contentId: 'logo'` + `cid:logo` — is what
+* every client already resolves, and the domain that would make it a
+* proper `msg-id` adds nothing a reference could use. Second: the angle
+* brackets are optional too, because the builder has always added them
+* around a bare id; given, they must be one pair around the whole value.
+*
+* Refused, then: whitespace of any kind, a second `@`, `<` or `>` anywhere
+* but as that one pair, `"`, `(`, `)`, `,`, `;`, `:`, `\`, `[`, `]`,
+* anything non-ASCII, and the empty string (which used to be validated
+* and then silently NOT rendered). Everything accepted renders exactly as
+* it did.
+*
+* One pass, no allocation, which is why this runs AFTER the value's length
+* bound. The message names the rule and never echoes the value.
+*/
+function validateContentId(field, value) {
+	const syntax = () => new MimeError("MIME_ERROR", `${field} is not a valid Content-ID (RFC 5322 §3.6.4 msg-id: an identifier of atext, "." and "@", optionally in one pair of angle brackets).`);
+	let i = 0;
+	let end = value.length;
+	if (value[0] === "<") {
+		if (end < 2 || value[end - 1] !== ">") throw syntax();
+		i = 1;
+		end--;
+	}
+	/** Advance over a `dot-atom-text`; false when there is none, or a dot is misplaced. */
+	const dotAtomText = () => {
+		let run = 0;
+		for (; i < end; i++) {
+			const c = value.charCodeAt(i);
+			if (isAtext(c)) run++;
+			else if (c === 46 && run > 0) run = 0;
+			else break;
+		}
+		return run > 0;
+	};
+	if (!dotAtomText()) throw syntax();
+	if (i < end) {
+		if (value[i] !== "@") throw syntax();
+		i++;
+		if (!dotAtomText()) throw syntax();
+	}
+	if (i !== end) throw syntax();
+}
+const COMMON_TYPES = {
+	txt: "text/plain",
+	html: "text/html",
+	htm: "text/html",
+	css: "text/css",
+	csv: "text/csv",
+	pdf: "application/pdf",
+	json: "application/json",
+	xml: "application/xml",
+	zip: "application/zip",
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	ico: "image/x-icon",
+	ics: "text/calendar",
+	eml: "message/rfc822"
+};
+function inferContentType(filename) {
+	const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+	return COMMON_TYPES[ext] ?? "application/octet-stream";
+}
+var MimeError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "MimeError";
+		this.code = code;
+	}
+};
+function fieldErrorCode(field) {
+	if (field === "from") return "INVALID_FROM";
+	if (field === "to") return "INVALID_TO";
+	return "MIME_ERROR";
+}
+/**
+* Validate one parsed address (and its display name, when there is one),
+* throwing a `MimeError` for `field` on anything undeliverable. Exported so
+* the inbound proxy's `forward(to)` and hand-built `reply()` refuse a bare
+* address by the same rule `sendEmail` applies to its `to`.
+*
+* The address rule is `email-validator`, and nothing else. It is also the
+* platform router's rule (`isValidEmailAddress` in the proxy's
+* `email-router.ts`), so there is exactly ONE address syntax in the tree:
+* an action the framework records is never dropped by the router for its
+* shape, and a test harness never captures as a success what the managed
+* deployment would lose. The hand-written predecessor grew one character
+* per review round — the exactly-one-`@` rule, then every C0 control and
+* DEL, then `:`, then a parity test against the router's own regex, which
+* had drifted on the dot in the domain — and still admitted `a..b@x.com`,
+* `.a@x.com` and `a@x..com`, which no dot-atom allows and every MTA
+* refuses. One maintained rule on both sides ends that series.
+*
+* What it enforces: at most 254 characters in total; an ASCII dot-atom
+* local part of at most 64 characters (RFC 5322 §3.2.3 `atext`, dots only
+* between atoms — no quoted local part, no whitespace, no control, no
+* special); a dotted domain of ASCII labels of at most 63 characters each,
+* with a TLD that starts with a letter and has at least two characters; so
+* `user@localhost`, `x@y` and a raw IDN or SMTPUTF8 address are refused
+* (an IDN domain is accepted as punycode, `xn--…`). ASCII-only makes
+* octets and characters the same thing, so the RFC 5321 §4.5.3.1 octet
+* limits are the package's length checks; the 64 is also what caps the
+* default `<slug>+noreply@` sender (`VALID_SLUG` in `runtime/email.ts`,
+* `MAX_SLUG_LENGTH` = `64 - 8` in `cli/project-slug.ts` and the API). One
+* known quirk, pinned in the tests rather than worked around: the FIRST
+* character of the local part may not be a backtick, while any later one
+* may.
+*
+* `MAX_ADDRESS_LENGTH` still runs first, on the raw string, so the scan is
+* bounded before anything reads the address; the package's own 254 check
+* runs before its regex for the same reason. The message never echoes the
+* address: it may hold a control character, and naming the rule is enough.
+*/
+function validateAddressParts(field, email, name) {
+	if (email.length > 320) throw new MimeError(fieldErrorCode(field), `${field}: address is ${email.length} characters, over the 320-character limit.`);
+	if (!validate(email)) throw new MimeError(fieldErrorCode(field), `${field}: address is not a valid email address (ASCII local part and dotted domain, RFC 5322 dot-atom; at most 64 characters before the '@' and 254 in total).`);
+	if (name !== void 0) {
+		rejectCRLF(`${field} display name`, name);
+		if (ASCII_PRINTABLE.test(name) && RFC5322_SPECIALS.test(name) && name.length + QUOTED_NAME_LINE_OVERHEAD > MAX_LINE_OCTETS) throw new MimeError(fieldErrorCode(field), `${field}: display name is ${name.length} characters and must be quoted, which cannot be folded, so its line would exceed the ${MAX_LINE_OCTETS}-octet limit in RFC 5322 §2.1.1. Shorten it.`);
+		if (name.includes("@")) throw new MimeError(fieldErrorCode(field), `${field}: display name '${name}' must not contain '@' (likely a malformed address).`);
+	}
+}
+/**
+* Undo the quoted-pairs in the content of a quoted display name: `\x` →
+* `x` for any `x` (RFC 5322 §3.2.4 — `qtext` excludes `"` and `\`, so a
+* quoted-string carries either only as a quoted-pair). The parsed name is
+* the RAW text `formatAddress` will quote and escape again, so leaving the
+* pairs in place rendered `"Smith \"Bob\"" <a@x.dev>` as
+* `"Smith \\\"Bob\\\""` and the recipient saw `Smith \"Bob\"`, while the
+* object form of the same name rendered correctly. Only the quoted branch
+* of `parseAddress` calls this; a backslash in an unquoted name is a
+* character like any other, as it is in the object form.
+*
+* NOT `text.replace(/\\(.)/g, '$1')`: a global-regex replacement holds one
+* part per match before it builds the result, about 60 bytes each, and
+* nothing bounds this name before it runs — the quoted-string line guard
+* in `validateAddressParts` needs the DECODED name, and a non-ASCII name is
+* never bounded at all. Measured, 10 MiB of `\"` pairs peaked at 307 MB of
+* heap that way and terminated a 128 MB isolate; this shape peaks at 49 MB.
+* Same discipline as `to7bitBody`: one counting pass, a buffer of exactly
+* the output size, one fill, and the 32K-chunk conversion `base64` uses.
+* The common case — no backslash at all — is one scan and no allocation.
+* The regex that admits the text guarantees every backslash is followed by
+* a character, so the fill never reads past the end.
+*/
+function unquotePairs(text) {
+	const first = text.indexOf("\\");
+	if (first === -1) return text;
+	let pairs = 0;
+	for (let i = first; i < text.length; i++) if (text.charCodeAt(i) === 92) {
+		pairs++;
+		i++;
+	}
+	const out = new Uint16Array(text.length - pairs);
+	let n = 0;
+	for (let i = 0; i < text.length; i++) {
+		let c = text.charCodeAt(i);
+		if (c === 92) c = text.charCodeAt(++i);
+		out[n++] = c;
+	}
+	let s = "";
+	const chunk = 32768;
+	for (let i = 0; i < n; i += chunk) s += String.fromCharCode(...out.subarray(i, i + chunk));
+	return s;
+}
+/**
+* Parse one address — a bare `email@domain` or `Display Name <email@domain>`
+* — into its parts, throwing a `MimeError` for `field` on anything else.
+* Exported so `void.json` `email.from` is validated by the same rules the
+* runtime applies to `from` at send time.
+*/
+function parseAddress(value, field) {
+	if (typeof value === "string") {
+		rejectCRLF(`${field} address`, value);
+		const quoted = value.match(/^\s*"((?:[^"\\]|\\.)*)"\s*<\s*([^>\s]+)\s*>\s*$/);
+		const angle = quoted ?? value.match(/^\s*(?:([^"<\s](?:[^"<]*[^"<\s])?)\s*)?<\s*([^>\s]+)\s*>\s*$/);
+		if (angle) {
+			const name = (quoted ? unquotePairs(angle[1] ?? "") : angle[1])?.trim();
+			const email = angle[2];
+			validateAddressParts(field, email, name);
+			return name ? {
+				email,
+				name
+			} : { email };
+		}
+		const trimmed = value.trim();
+		validateAddressParts(field, trimmed);
+		return { email: trimmed };
+	}
+	validateAddressParts(field, value.email ?? "", value.name);
+	return value.name ? {
+		email: value.email,
+		name: value.name
+	} : { email: value.email };
+}
+function parseAddresses(value, field) {
+	return (Array.isArray(value) ? value : [value]).map((entry) => parseAddress(entry, field));
+}
+/** Entries in one recipient field, counted the way `parseAddresses` will see them. */
+function countRecipients(value) {
+	if (!value) return 0;
+	return Array.isArray(value) ? value.length : 1;
+}
+/**
+* Keeps the `exceeds Cloudflare limit of <N> bytes` tail that `buildMime`'s
+* own size error already uses, so the documented shape — and any caller
+* matching on it — holds for both paths.
+*/
+function attachmentsTooLargeError(bytes) {
+	return new MimeError("MIME_ERROR", `email: attachment size ${bytes} bytes exceeds Cloudflare limit of ${MAX_ATTACHMENT_BYTES_TOTAL} bytes.`);
+}
+/**
+* Size of `content` WITHOUT materializing it.
+*
+* A string reports its UTF-16 `length`, which is a sound LOWER bound on its
+* UTF-8 byte length — every code unit encodes to at least one byte — so this
+* can never reject a string that would have fit; the exact length is charged
+* after the encode. Anything else reports 0 and is left to `toBytes` to reject
+* by type.
+*/
+function declaredSize(content) {
+	if (content instanceof Uint8Array) return content.byteLength;
+	if (content instanceof ArrayBuffer) return content.byteLength;
+	if (typeof Blob !== "undefined" && content instanceof Blob) return content.size;
+	if (typeof content === "string") return content.length;
+	return 0;
+}
+async function toBytes(content) {
+	if (content instanceof Uint8Array) return content;
+	if (content instanceof ArrayBuffer) return new Uint8Array(content);
+	if (typeof Blob !== "undefined" && content instanceof Blob) return new Uint8Array(await content.arrayBuffer());
+	if (typeof content === "string") return new TextEncoder().encode(content);
+	throw new MimeError("MIME_ERROR", "attachment content must be string, Uint8Array, ArrayBuffer, or Blob.");
+}
+async function normalizeAttachment(att) {
+	if (!att.filename) throw new MimeError("MIME_ERROR", "attachment: missing filename.");
+	rejectCRLF("attachment filename", att.filename);
+	if (att.filename.length + QUOTED_FILENAME_LINE_OVERHEAD > MAX_LINE_OCTETS) throw new MimeError("MIME_ERROR", `attachment filename is ${att.filename.length} characters; a quoted \`filename=\` parameter cannot be folded, so its line would exceed the ${MAX_LINE_OCTETS}-octet limit in RFC 5322 §2.1.1. Shorten the filename.`);
+	rejectControls("attachment filename", att.filename);
+	if (att.contentType !== void 0) {
+		rejectCRLF("attachment contentType", att.contentType);
+		if (att.contentType.length + CONTENT_TYPE_LINE_OVERHEAD > MAX_LINE_OCTETS) throw new MimeError("MIME_ERROR", `attachment contentType is ${att.contentType.length} characters; at most ${MAX_LINE_OCTETS - CONTENT_TYPE_LINE_OVERHEAD} fit on the Content-Type line under the ${MAX_LINE_OCTETS}-octet limit in RFC 5322 §2.1.1. Shorten it.`);
+		rejectControls("attachment contentType", att.contentType);
+		validateMediaType("attachment contentType", att.contentType);
+	}
+	if (att.contentId !== void 0) {
+		rejectCRLF("attachment contentId", att.contentId);
+		const brackets = att.contentId.startsWith("<") ? 0 : 2;
+		if (att.contentId.length + brackets + CONTENT_ID_LINE_OVERHEAD > MAX_LINE_OCTETS) throw new MimeError("MIME_ERROR", `attachment contentId is ${att.contentId.length} characters; at most ${MAX_LINE_OCTETS - CONTENT_ID_LINE_OVERHEAD - brackets} fit on the Content-ID line under the ${MAX_LINE_OCTETS}-octet limit in RFC 5322 §2.1.1. Shorten it.`);
+		rejectControls("attachment contentId", att.contentId);
+		validateContentId("attachment contentId", att.contentId);
+	}
+	if (att.disposition !== void 0 && att.disposition !== "attachment" && att.disposition !== "inline") throw new MimeError("MIME_ERROR", "attachment disposition must be 'attachment' or 'inline'.");
+	const bytes = await toBytes(att.content);
+	return {
+		filename: att.filename,
+		contentType: att.contentType ?? inferContentType(att.filename),
+		bytes,
+		contentId: att.contentId,
+		disposition: att.disposition ?? (att.contentId ? "inline" : "attachment")
+	};
+}
+/**
+* Validate inputs and produce a normalized email shape that can be handed to
+* the MIME builder, the dev inbox, or the test harness without re-parsing.
+*/
+async function normalizeEmail(opts) {
+	if (!opts.text && !opts.html) throw new MimeError("MIME_ERROR", "email: at least one of 'text' or 'html' is required.");
+	if (opts.subject !== void 0) rejectCRLF("subject", opts.subject);
+	if (opts.headers) for (const [name, value] of Object.entries(opts.headers)) {
+		if (!HEADER_NAME.test(name)) throw new MimeError("MIME_ERROR", `headers: '${name}' is not a valid RFC 5322 header name.`);
+		if (name.length + HEADER_NAME_LINE_OVERHEAD > MAX_LINE_OCTETS) throw new MimeError("MIME_ERROR", `headers: a header name is ${name.length} characters; a field name cannot be folded, so its line would exceed the ${MAX_LINE_OCTETS}-octet limit in RFC 5322 §2.1.1. Shorten the name.`);
+		rejectCRLF(`header '${name}'`, value);
+	}
+	const recipientCount = countRecipients(opts.to) + countRecipients(opts.cc) + countRecipients(opts.bcc);
+	if (recipientCount > 100) throw new MimeError("INVALID_TO", `email: too many recipients (max 100, got ${recipientCount}) across 'to', 'cc' and 'bcc'.`);
+	const from = parseAddress(opts.from, "from");
+	const to = parseAddresses(opts.to, "to");
+	if (to.length === 0) throw new MimeError("INVALID_TO", "email: 'to' must include at least one recipient.");
+	const cc = opts.cc ? parseAddresses(opts.cc, "cc") : [];
+	const bcc = opts.bcc ? parseAddresses(opts.bcc, "bcc") : [];
+	const replyTo = opts.replyTo ? parseAddress(opts.replyTo, "replyTo") : void 0;
+	const attachmentList = opts.attachments ?? [];
+	if (!Array.isArray(attachmentList)) throw new MimeError("MIME_ERROR", "email: attachments must be an array.");
+	if (attachmentList.length > MAX_ATTACHMENTS) throw new MimeError("MIME_ERROR", `email: too many attachments (max ${MAX_ATTACHMENTS}, got ${attachmentList.length}).`);
+	const attachments = [];
+	let attachmentBytes = 0;
+	for (const att of attachmentList) {
+		const declared = declaredSize(att.content);
+		if (attachmentBytes + declared > MAX_ATTACHMENT_BYTES_TOTAL) throw attachmentsTooLargeError(attachmentBytes + declared);
+		const normalized = await normalizeAttachment(att);
+		attachmentBytes += normalized.bytes.byteLength;
+		if (attachmentBytes > MAX_ATTACHMENT_BYTES_TOTAL) throw attachmentsTooLargeError(attachmentBytes);
+		attachments.push(normalized);
+	}
+	if (opts.threading?.inReplyTo) rejectCRLF("threading.inReplyTo", opts.threading.inReplyTo);
+	if (opts.threading?.references) rejectCRLF("threading.references", opts.threading.references);
+	return {
+		from,
+		to,
+		cc,
+		bcc,
+		replyTo,
+		subject: opts.subject ?? "",
+		text: opts.text,
+		html: opts.html,
+		headers: opts.headers ? { ...opts.headers } : {},
+		attachments,
+		threading: opts.threading
+	};
+}
+/**
+* RFC 2047 §2 caps an encoded-word at 75 characters *including* the
+* `=?UTF-8?B?` prefix (10) and the `?=` suffix (2). That leaves 63
+* characters of base64, and base64 spends 4 characters per 3 input
+* bytes, so 45 source bytes is the largest payload that fits — 48 would
+* need 64.
+*/
+const ENCODED_WORD_PAYLOAD_BYTES = 45;
+/**
+* RFC 2047 encoded-word for non-ASCII text in headers (UTF-8, base64).
+*
+* Text longer than one word's payload becomes several encoded-words
+* separated by a space, which `foldHeader` turns into CRLF + SPACE
+* wherever a line would otherwise overrun (RFC 2047 §6.2: whitespace
+* between adjacent encoded-words is dropped on decode either way). A
+* single unbounded word breached both §2's 75-character ceiling and —
+* for a long subject or display name — RFC 5322 §2.1.1's 998-octet hard
+* line limit, which nothing downstream repairs.
+*/
+function encodeWord(text) {
+	if (ASCII_PRINTABLE.test(text)) return text;
+	const encoder = new TextEncoder();
+	const pending = /* @__PURE__ */ new Uint8Array(49);
+	let length = 0;
+	const words = [];
+	const flush = () => {
+		if (length > 0) {
+			words.push(`=?UTF-8?B?${base64(pending.subarray(0, length))}?=`);
+			length = 0;
+		}
+	};
+	for (const char of text) {
+		const bytes = encoder.encode(char);
+		if (length > 0 && length + bytes.length > ENCODED_WORD_PAYLOAD_BYTES) flush();
+		pending.set(bytes, length);
+		length += bytes.length;
+	}
+	flush();
+	return words.join(" ");
+}
+/**
+* RFC 5322 §3.2.3, verbatim:
+*
+*     specials = "(" / ")" / "<" / ">" / "[" / "]" / ":" / ";" / "@" /
+*                "\" / "," / "." / DQUOTE
+*
+* A display name is a §3.2.5 `phrase = 1*word`, `word = atom /
+* quoted-string`, and `atext` is everything printable EXCEPT these, so an
+* ASCII name containing any of them must be rendered as one quoted-string.
+* The class below lists the thirteen in the RFC's order so it can be checked
+* against the production by eye. This check has been wrong twice: it once
+* sat inside a branch that had already excluded every special, so it was
+* unreachable and a comma in a name split the address list; then the list
+* itself lacked `.`, so `Dr. Smith <a@x.dev>` went out unquoted. That is
+* `obs-phrase` (§4.1, `word *(word / "." / CFWS)`), which §4 says MUST NOT
+* be generated, and a strict receiver flags it as obsolete syntax (Python's
+* `email` parser: "period in 'phrase'"). Every conforming generator —
+* Python's `email.headerregistry.Address`, for one — emits `"Dr. Smith"`.
+*/
+const RFC5322_SPECIALS = /[()<>[\]:;@\\,."]/;
+function formatAddress(addr) {
+	if (!addr.name) return addr.email;
+	if (!ASCII_PRINTABLE.test(addr.name)) return `${encodeWord(addr.name)} <${addr.email}>`;
+	if (RFC5322_SPECIALS.test(addr.name)) return `"${addr.name.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}" <${addr.email}>`;
+	return `${addr.name} <${addr.email}>`;
+}
+function formatAddressList(addrs) {
+	return addrs.map(formatAddress).join(", ");
+}
+/**
+* Soft-fold a long header line. Fold points, strongest first: address-list
+* separators (a `, ` outside any double-quoted string), then any remaining
+* unquoted whitespace inside a part. A naive `split(/, /)` would split
+* inside `"Smith, John"`, corrupting quoted display names, and folding only
+* between whole parts is not enough — one recipient carrying a long encoded
+* display name, or a `References:` run of message IDs, is a single part
+* that can blow past RFC 5322 §2.1.1's 998-octet hard limit on its own.
+*
+* RFC 2047 §2 limits any header line carrying an encoded-word to 76
+* characters; RFC 5322 §2.1.1 makes 78 a SHOULD and 998 a MUST. Folding at
+* 76 satisfies all three. A comma always stays on the line it terminates.
+* A token longer than the budget still gets its own line, which is the
+* best a WSP-only fold rule allows (§3.2.2 permits folding only at WSP).
+*
+* One pass, and the only thing kept per input character is the folded
+* output itself: each finished line is one flat string in `lines`. The
+* earlier shape — tokenize the whole value into an array of slices, wrap
+* each in a `{ text, comma }` object, then grow the result with `out +=`
+* per token — held about 130 bytes of heap per token for the length of the
+* fold (a slice, an object and a cons-string node each), so a legal 3 MB
+* subject of one-letter words terminated a 128 MB isolate. That was a
+* per-TOKEN cost, invisible to any size projection: the message fit.
+*/
+function foldHeader(name, value) {
+	const line = `${name}: ${value}`;
+	if (line.length <= 78) return line;
+	const MAX_LINE = 76;
+	const lines = [];
+	let current = [`${name}:`];
+	let lineLen = name.length + 1;
+	let chunks = 0;
+	const emit = (text, comma) => {
+		chunks++;
+		const piece = comma ? `${text},` : text;
+		if (piece.length > 0 && lineLen + 1 + piece.length > MAX_LINE) {
+			lines.push(current.join(" "));
+			current = ["", piece];
+			lineLen = 1 + piece.length;
+		} else {
+			current.push(piece);
+			lineLen += 1 + piece.length;
+		}
+	};
+	let tokenStart = -1;
+	let heldStart = -1;
+	let heldEnd = -1;
+	const endToken = (i) => {
+		if (tokenStart < 0) return;
+		if (heldStart >= 0) emit(value.slice(heldStart, heldEnd), false);
+		heldStart = tokenStart;
+		heldEnd = i;
+		tokenStart = -1;
+	};
+	const endPart = (isLast) => {
+		if (heldStart >= 0) {
+			emit(value.slice(heldStart, heldEnd), !isLast);
+			heldStart = -1;
+		} else emit("", !isLast);
+	};
+	let inQuotes = false;
+	let escape = false;
+	for (let i = 0; i < value.length; i++) {
+		const ch = value[i];
+		if (escape) {
+			escape = false;
+			if (tokenStart < 0) tokenStart = i;
+			continue;
+		}
+		if (ch === "\\" && inQuotes) {
+			escape = true;
+			if (tokenStart < 0) tokenStart = i;
+			continue;
+		}
+		if (ch === "\"") {
+			inQuotes = !inQuotes;
+			if (tokenStart < 0) tokenStart = i;
+			continue;
+		}
+		if (!inQuotes && ch === "," && value[i + 1] === " ") {
+			endToken(i);
+			endPart(false);
+			i++;
+			continue;
+		}
+		if (!inQuotes && (ch === " " || ch === "	")) {
+			endToken(i);
+			continue;
+		}
+		if (tokenStart < 0) tokenStart = i;
+	}
+	endToken(value.length);
+	endPart(true);
+	if (chunks <= 1) return line;
+	lines.push(current.join(" "));
+	return lines.join(CRLF);
+}
+/** RFC 5322 §2.1.1: each line MUST be at most 998 octets, excluding CRLF. */
+const MAX_LINE_OCTETS = 998;
+/** ` filename="` + `"`: the shortest line a quoted filename parameter can fold onto. */
+const QUOTED_FILENAME_LINE_OVERHEAD = 12;
+/**
+* ` ` + `;`: the shortest line an attachment's media type can fold onto,
+* the whole value taken as one token. `foldHeader` would split a value
+* of several parameters at their spaces, so this bound is exact for the
+* one-token media type every attachment carries in practice and
+* conservative for a run of parameters that together pass the line
+* limit; that is accepted, because the alternative — find the fold points
+* first — is the scan this bound exists to run ahead of.
+*/
+const CONTENT_TYPE_LINE_OVERHEAD = 2;
+/**
+* `Content-ID: `: the only line an attachment's Content-ID can sit on. The
+* value is one token — `<id>` — so `foldHeader` cannot fold it onto a
+* continuation line the way it can a media type, and the field name is
+* part of what the id must fit beside. Exact, not conservative: the `<`
+* and `>` the builder adds around a bare id are charged at the call.
+*/
+const CONTENT_ID_LINE_OVERHEAD = 12;
+/** ` "` + `"`: the shortest line a quoted display name can fold onto. */
+const QUOTED_NAME_LINE_OVERHEAD = 3;
+/** `:` alone: the shortest line a header name can sit on, its value folded onto the next. */
+const HEADER_NAME_LINE_OVERHEAD = 1;
+/**
+* First line of `text` that exceeds the octet limit, if any.
+*
+* Every line is scanned, not just the top header block: a multipart part's
+* own headers (`Content-Disposition: …; filename="…"`) live inside the body
+* and are just as unfoldable. Body content cannot trip this — text is
+* quoted-printable re-encoded above 990 octets and base64 is emitted at a
+* fixed width — so a hit is always a header.
+*
+* One pass over the string, counting UTF-8 octets per CRLF-delimited line,
+* with NO allocation. The earlier `text.split(CRLF)` held one array slot and
+* one substring per line for the whole scan, and a legal body of millions of
+* short lines — pasted logs, say — is millions of lines. Only a CRLF pair
+* ends a line, exactly as the split did; a bare CR or LF is content.
+*/
+function findOverlongLine(text) {
+	let index = 0;
+	let octets = 0;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c === 13 && text.charCodeAt(i + 1) === 10) {
+			if (octets > MAX_LINE_OCTETS) return {
+				index,
+				octets
+			};
+			index++;
+			octets = 0;
+			i++;
+		} else if (c < 128) octets += 1;
+		else if (c < 2048) octets += 2;
+		else if (c >= 55296 && c <= 56319 && i + 1 < text.length) {
+			const d = text.charCodeAt(i + 1);
+			if (d >= 56320 && d <= 57343) {
+				octets += 4;
+				i++;
+			} else octets += 3;
+		} else octets += 3;
+	}
+	return octets > MAX_LINE_OCTETS ? {
+		index,
+		octets
+	} : void 0;
+}
+/**
+* Escape a value for a quoted-string parameter (RFC 2045 §5.1 value, whose
+* quoted-string comes from RFC 5322 §3.2.4).
+*
+* `qtext` excludes both `\\` and `"`, so each may appear only as a
+* quoted-pair. Deleting the quotes and leaving backslashes raw — what this
+* did before — is wrong in two ways: a TRAILING backslash escapes the
+* closing quote and leaves the parameter unterminated, and every embedded
+* backslash is silently eaten by a conformant parser, so a Windows path
+* `C:\\Users\\bob\\report.pdf` arrived as `C:Usersbobreport.pdf`. Measured,
+* Python's `email.policy.default` and postal-mime both report
+* `InvalidHeaderDefect: end of header inside quoted string` on the first
+* case and disagree with a naive parser on the second.
+*
+* Backslash first, then quote — the other order would double-escape.
+*
+* Note this file's own `foldHeader` already tracks quoted-pairs when
+* folding, so the emitter was contradicting the folder.
+*/
+function quoteParam(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function base64(bytes) {
+	let binary = "";
+	const chunk = 32768;
+	for (let i = 0; i < bytes.length; i += chunk) binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+	return btoa(binary);
+}
+function base64Wrapped(bytes) {
+	const encoded = base64(bytes);
+	const lines = [];
+	for (let i = 0; i < encoded.length; i += 76) lines.push(encoded.slice(i, i + 76));
+	return lines.join(CRLF);
+}
+function quotedPrintable(text) {
+	const bytes = new TextEncoder().encode(text);
+	const out = new Uint8Array(Math.ceil(bytes.length * 3 * (76 / 73)) + 8);
+	let n = 0;
+	let lineLen = 0;
+	const HEX = "0123456789ABCDEF";
+	const put = (c) => {
+		out[n++] = c;
+	};
+	const flush = (c0, c1, c2) => {
+		const width = c2 !== void 0 ? 3 : c1 !== void 0 ? 2 : 1;
+		if (lineLen + width > 75) {
+			put(61);
+			put(13);
+			put(10);
+			lineLen = 0;
+		}
+		put(c0);
+		if (c1 !== void 0) put(c1);
+		if (c2 !== void 0) put(c2);
+		lineLen += width;
+	};
+	const quote = (b) => flush(61, HEX.charCodeAt(b >> 4), HEX.charCodeAt(b & 15));
+	for (let i = 0; i < bytes.length; i++) {
+		const b = bytes[i];
+		if (b === 10) {
+			put(13);
+			put(10);
+			lineLen = 0;
+			continue;
+		}
+		if (b === 13) {
+			if (bytes[i + 1] === 10) continue;
+			put(13);
+			put(10);
+			lineLen = 0;
+			continue;
+		}
+		if (b === 32 || b === 9) {
+			if (i === bytes.length - 1 || bytes[i + 1] === 10 || bytes[i + 1] === 13) quote(b);
+			else flush(b);
+			continue;
+		}
+		if (b === 61 || b < 32 || b > 126) {
+			quote(b);
+			continue;
+		}
+		flush(b);
+	}
+	return bytesToAsciiString(out.subarray(0, n));
+}
+/** Pure-ASCII bytes to a string, in the same 32K chunks `base64` uses. */
+function bytesToAsciiString(bytes) {
+	let s = "";
+	const chunk = 32768;
+	for (let i = 0; i < bytes.length; i += chunk) s += String.fromCharCode(...bytes.subarray(i, i + chunk));
+	return s;
+}
+/**
+* Whether a body must be quoted-printable encoded: anything outside
+* printable ASCII, or any line longer than 990 characters (RFC 5322 §2.1.1
+* makes 998 octets the hard limit). Only LF and CRLF end a line; a bare CR
+* is a control character like any other and forces the encoding.
+*
+* One pass over the string with NO allocation. The earlier shape — strip
+* every line break with a global `replace`, test the copy, then `split` the
+* text into an array of lines — was linear in the message but held a copy
+* of the body plus one array slot and one substring per line, and a legal
+* 6 MB body of millions of two-character lines needed 64 MB for the strip
+* and another 24-40 MB for the split. Those are per-LINE costs, invisible
+* to any size projection: the message fit.
+*/
+function needsQuotedPrintable(text) {
+	let lineLen = 0;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c === 10) {
+			lineLen = 0;
+			continue;
+		}
+		if (c === 13) {
+			if (text.charCodeAt(i + 1) === 10) continue;
+			return true;
+		}
+		if (c < 32 || c > 126) return true;
+		lineLen++;
+		if (lineLen > 990) return true;
+	}
+	return false;
+}
+/**
+* The 7bit body: `text` with every bare LF widened to CRLF, and every CRLF
+* kept. Only called once `needsQuotedPrintable` has returned false, so every
+* character is printable ASCII, LF, or the CR of a CRLF — one byte each —
+* and a byte buffer is exact.
+*
+* NOT `text.replace(/\r?\n/g, CRLF)`: V8 builds a global-regex replacement
+* from a parts array that holds two or three slots per match, grown by
+* doubling, so that one line cost 144 MB of heap on a legal 6 MB body of
+* 3M lines and terminated a 128 MB isolate — the largest single allocation
+* in the whole build, for a body that renders to 9 MB. The buffer here is
+* the output size, known up front from one counting pass. A body that is
+* already CRLF-only (or has no line breaks) is returned as-is.
+*/
+function to7bitBody(text) {
+	let bare = 0;
+	for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10 && (i === 0 || text.charCodeAt(i - 1) !== 13)) bare++;
+	if (bare === 0) return text;
+	const out = new Uint8Array(text.length + bare);
+	let n = 0;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c === 10 && (i === 0 || text.charCodeAt(i - 1) !== 13)) out[n++] = 13;
+		out[n++] = c;
+	}
+	return bytesToAsciiString(out);
+}
+/**
+* Lower bound on the octets `text` will occupy in the rendered message, in
+* one pass over the string and with NO allocation. Every UTF-8 byte yields at
+* least one octet on either body path — the 7bit path copies bytes and only
+* ever widens a bare LF to CRLF; the quoted-printable path emits each
+* non-ASCII byte as `=XX` (3 octets) and every other byte as itself, and its
+* soft breaks only add. So `ascii + 3 * nonAscii` can never overshoot the
+* real size, which keeps a false rejection impossible; `buildMime`'s final
+* check remains the authority. `TextEncoder.encode` would give the same count
+* but at the price of a full copy, which is exactly the allocation this
+* bound exists to avoid.
+*/
+function minBodyOctets(text) {
+	let octets = 0;
+	for (let i = 0; i < text.length; i++) {
+		const c = text.charCodeAt(i);
+		if (c < 128) octets += 1;
+		else if (c < 2048) octets += 6;
+		else if (c >= 55296 && c <= 56319 && i + 1 < text.length) {
+			const d = text.charCodeAt(i + 1);
+			if (d >= 56320 && d <= 57343) {
+				octets += 12;
+				i++;
+				continue;
+			}
+			octets += 9;
+		} else octets += 9;
+	}
+	return octets;
+}
+/** Octets a base64 body of `n` bytes occupies at 76 columns, excluding CRLF. */
+function base64Octets(n) {
+	return Math.ceil(n / 3) * 4;
+}
+function renderPart(part) {
+	return part.headers.map(([k, v]) => foldHeader(k, v)).join(CRLF) + "\r\n\r\n" + part.body;
+}
+function buildBodyPart(contentType, body) {
+	const useQp = needsQuotedPrintable(body);
+	return {
+		headers: [["Content-Type", `${contentType}; charset=UTF-8`], ["Content-Transfer-Encoding", useQp ? "quoted-printable" : "7bit"]],
+		body: useQp ? quotedPrintable(body) : to7bitBody(body)
+	};
+}
+function buildAttachmentPart(att) {
+	const headers = [
+		["Content-Type", `${att.contentType}; name="${quoteParam(att.filename)}"`],
+		["Content-Transfer-Encoding", "base64"],
+		["Content-Disposition", `${att.disposition}; filename="${quoteParam(att.filename)}"`]
+	];
+	if (att.contentId) {
+		const cid = att.contentId.startsWith("<") ? att.contentId : `<${att.contentId}>`;
+		headers.push(["Content-ID", cid]);
+	}
+	return {
+		headers,
+		body: base64Wrapped(att.bytes)
+	};
+}
+function makeBoundary(prefix) {
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	crypto.getRandomValues(bytes);
+	return `=_void_${prefix}_${base64(bytes).replace(/[+/=]/g, "")}`;
+}
+function wrapMultipart(type, parts, extra = {}) {
+	const boundary = makeBoundary(type);
+	const headerEntries = [["Content-Type", `multipart/${type}; boundary="${boundary}"`]];
+	for (const [k, v] of Object.entries(extra)) headerEntries.push([k, v]);
+	return {
+		headers: headerEntries,
+		body: parts.map((p) => `--${boundary}${CRLF}${renderPart(p)}`).join(CRLF) + `${CRLF}--${boundary}--${CRLF}`
+	};
+}
+const RESERVED_HEADERS = new Set([
+	"from",
+	"to",
+	"cc",
+	"bcc",
+	"subject",
+	"reply-to",
+	"date",
+	"message-id",
+	"in-reply-to",
+	"references",
+	"mime-version",
+	"content-type",
+	"content-transfer-encoding",
+	"content-disposition"
+].map((h) => h.toLowerCase()));
+/**
+* Lower bound on the octets one header VALUE occupies once `encodeWord` (or
+* `formatAddress`, for a display name) and `foldHeader` have rendered it, in
+* one pass over the string and with NO allocation.
+*
+* `encodeWord` leaves a value alone when every character is printable ASCII
+* and otherwise B-encodes ALL of it, so the two paths need different terms:
+*
+* - Plain: every character is at least one octet, EXCEPT whitespace.
+*   `foldHeader` re-joins a long value from its non-WSP tokens, so a run of
+*   spaces or tabs collapses to one, and a bound that charged them could
+*   reject a message that fits. Only the non-WSP characters count.
+* - Encoded: each RFC 2047 word carries at most `ENCODED_WORD_PAYLOAD_BYTES`
+*   (45) UTF-8 bytes as base64 — `ceil(n / 3) * 4 >= 4n / 3` octets — inside
+*   12 octets of `=?UTF-8?B?` and `?=`, so there are at least `floor(n / 45)`
+*   words' worth of framing. Whitespace inside the value is base64 like any
+*   other byte; only the single separators between words fold.
+*
+* Folding (`foldHeader`) can only ADD octets beyond that — a `CRLF SP` per
+* line — and quoting a display name (`formatAddress`) adds the quotes and
+* escapes, so neither path can render fewer octets than this returns.
+* Measured, the encoded bound is 96% of the rendered size for CJK, where the
+* real cost is 5 octets per character; a UTF-16 `length` would have counted
+* 1 and let the isolate die on a header five times over the limit.
+*/
+function minHeaderValueOctets(value) {
+	let utf8 = 0;
+	let visible = 0;
+	let encoded = false;
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c < 128) {
+			utf8 += 1;
+			if (c === 32 || c === 9) continue;
+			if (c < 32 || c === 127) encoded = true;
+			visible += 1;
+		} else {
+			encoded = true;
+			if (c < 2048) utf8 += 2;
+			else if (c >= 55296 && c <= 56319 && i + 1 < value.length) {
+				const d = value.charCodeAt(i + 1);
+				if (d >= 56320 && d <= 57343) {
+					utf8 += 4;
+					i++;
+					continue;
+				}
+				utf8 += 3;
+			} else utf8 += 3;
+		}
+	}
+	if (!encoded) return visible;
+	return Math.floor(utf8 * 4 / 3) + 12 * Math.floor(utf8 / ENCODED_WORD_PAYLOAD_BYTES);
+}
+/** Lower bound on one rendered address: its display name, plus the address itself verbatim. */
+function minAddressOctets(addr) {
+	return addr.email.length + (addr.name ? minHeaderValueOctets(addr.name) : 0);
+}
+/**
+* Lower bound on the octets of a value rendered VERBATIM — never through
+* `encodeWord` — into a header `foldHeader` may still fold: `In-Reply-To`,
+* `References`, and an attachment part's `Content-Type` media type and
+* `Content-ID`. Every non-WSP UTF-16 code unit is at least one octet of
+* UTF-8; a WSP run may collapse to a single space when the line folds, so
+* none is charged. The `<>` around a Content-ID and the fold's `CRLF SP`
+* only add.
+*
+* `minHeaderValueOctets` cannot stand in here: a non-ASCII value sends it
+* down the encoded-word formula (4.8 octets per CJK character) while these
+* values render as raw UTF-8 (3), so it would overshoot and could reject a
+* message that fits.
+*/
+function minVerbatimOctets(value) {
+	let octets = 0;
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c !== 32 && c !== 9) octets += 1;
+	}
+	return octets;
+}
+/**
+* Octets every attachment part costs before any of its values: what
+* `wrapMultipart`, `renderPart` and `buildAttachmentPart` emit for a part
+* whose filename, media type, disposition and content are all empty. Each
+* term is emitted verbatim on every path — `foldHeader` returns a short
+* line as-is and re-joins a long one from its tokens with at least one
+* space between them, so the space after `Name:` and the one after `;` are
+* floors, not counts — and a fold's `CRLF SP` only adds. The boundary's
+* random suffix is left out: `makeBoundary` strips `+`, `/` and `=`, so it
+* has no provable minimum, and `mixed` is the shortest prefix an attachment
+* part can sit under.
+*/
+const ATTACHMENT_PART_MIN_OCTETS = 117;
+/**
+* Cap on the attachment COUNT, checked against the raw list in
+* `normalizeEmail` before a single entry is normalized.
+*
+* Every part costs at least `ATTACHMENT_PART_MIN_OCTETS` of framing plus
+* its filename twice, and `normalizeAttachment` refuses an empty filename,
+* so the size projection in `buildMime` charges a part at least 119 octets
+* and refuses one more part than this whatever else the message holds.
+* That projection runs only after `normalizeEmail` has normalized EVERY
+* entry, and `MAX_ATTACHMENT_BYTES_TOTAL` cannot bound that loop for a
+* zero-byte attachment — its running total never advances — while the
+* normalized copy (the object, a fresh `Uint8Array`, the `TextEncoder`
+* that made it) costs about 275 bytes of live heap per entry. Measured, 2M
+* empty attachments terminated a 128 MB isolate in 0.3 s instead of
+* returning `MIME_ERROR`; this many normalize in 24 MB and are then refused
+* by the post-render size check under the same ceiling.
+*
+* Derived, not chosen: it is exactly the largest count the projection can
+* admit, so this cannot reject a message that would have been accepted, and
+* `buildMime` remains the authority on the final size. Same class as
+* `MAX_ATTACHMENT_BYTES_TOTAL` — a developer-experience guardrail on the
+* app's own input, not the security boundary.
+*/
+const MAX_ATTACHMENTS = Math.floor(MAX_MESSAGE_BYTES / 119);
+/**
+* Octets every custom header costs around its value: the `: ` after the
+* name and the CRLF that ends its line. Exact, not a floor, once the name
+* is counted: `buildMime` renders each non-reserved custom header through
+* `foldHeader`, which emits the name verbatim, then `: ` — or, when the
+* value's first token does not fit beside the name, `:` CRLF SP, which is
+* more — and `join(CRLF)` ends every header line, a custom header never
+* being the last of the block (the body part's own headers follow it).
+*/
+const CUSTOM_HEADER_FRAMING_OCTETS = 4;
+/**
+* Lower bound on the octets of every header `buildMime` renders from
+* caller-supplied values: `Subject`, the custom headers, the addresses in
+* `From`, `To`, `Cc` and `Reply-To`, the `In-Reply-To` / `References` pair
+* `replyEmail` threads through (remote-sender controlled, up to the whole
+* inbound message), and each attachment part's `Content-Type`, `Content-ID`
+* and — twice, once per header it is rendered into — filename. `Bcc` is
+* never rendered and a reserved custom header is dropped, so neither is
+* counted — charging either could reject a message that fits. The fixed
+* `Name: ` and `CRLF` of the headers `buildMime` itself names — `Subject`,
+* the address lists, the threading pair — are omitted for the same reason
+* a lower bound may omit any term. They are NOT omitted where the caller
+* controls the name or the count, because there they can be the whole
+* message:
+*
+* - A custom header's name is rendered verbatim, and `normalizeEmail`
+*   bounds ONE name at under a kilobyte, not the sum, nor the count. With
+*   empty values the names and the `: ` CRLF around each are the entire
+*   size, and the framing is exact once the name is counted (see
+*   `CUSTOM_HEADER_FRAMING_OCTETS`), so charging both cannot reject a
+*   message that fits. Measured before the name was charged, 60k empty
+*   headers with 500-character names — a 30 MB message — projected to
+*   zero, rendered in full and peaked at 121 MB of a 128 MB isolate; 100k
+*   of them (50 MB) went to 169 MB.
+* - An attachment part: `normalizeAttachment` bounds ONE filename at under
+*   a kilobyte, not the sum, and a message is free to carry any number of
+*   parts, so the filename and the framing every part is wrapped in are
+*   the whole size of a message of empty attachments. Measured, 50k
+*   zero-byte attachments with legal 986-character filenames rendered to
+*   106 MB — held three to four times over between the parts, their join,
+*   `rawText` and `raw` — and terminated a 128 MB isolate before the final
+*   size check could return `MIME_ERROR`.
+*
+* The header COUNT is deliberately not bounded here. Each header now costs
+* at least five octets (a one-character name, `: `, CRLF), so the count
+* the projection can admit is finite, and past a few hundred thousand keys
+* the caller's own object — measured at about 74 bytes per key, before
+* `sendEmail` is called — is the dominant cost, which no check inside this
+* module can pre-empt. Rendering does add live heap per header (about
+* 150 bytes: two `Object.entries`, the `topHeaders` pair, the folded line),
+* so a legal message of 500k four-character headers still does not fit a
+* 128 MB isolate while one of 400k does; a bound on that would be the
+* framework's own number — the platform proxy bounds bytes, not headers —
+* and is left as a product decision rather than invented here.
+*/
+function minHeaderOctets(email) {
+	let octets = minHeaderValueOctets(email.subject);
+	for (const [name, value] of Object.entries(email.headers)) if (!RESERVED_HEADERS.has(name.toLowerCase())) octets += name.length + CUSTOM_HEADER_FRAMING_OCTETS + minHeaderValueOctets(value);
+	octets += minAddressOctets(email.from);
+	for (const addr of email.to) octets += minAddressOctets(addr);
+	for (const addr of email.cc) octets += minAddressOctets(addr);
+	if (email.replyTo) octets += minAddressOctets(email.replyTo);
+	if (email.threading?.inReplyTo) octets += minVerbatimOctets(email.threading.inReplyTo);
+	if (email.threading?.references) octets += minVerbatimOctets(email.threading.references);
+	for (const att of email.attachments) {
+		octets += ATTACHMENT_PART_MIN_OCTETS + 2 * att.filename.length;
+		octets += minVerbatimOctets(att.contentType);
+		if (att.contentId) octets += minVerbatimOctets(att.contentId);
+	}
+	return octets;
+}
+function generateMessageId(fromEmail) {
+	const domain = fromEmail.split("@")[1] ?? "localhost";
+	const bytes = /* @__PURE__ */ new Uint8Array(12);
+	crypto.getRandomValues(bytes);
+	return `<${base64(bytes).replace(/[+/=]/g, "")}@${domain}>`;
+}
+/**
+* Build the raw RFC 5322 message body. Returns the message bytes plus the
+* generated Message-ID header so callers can surface it in the result.
+*/
+function buildMime(email) {
+	const projected = minHeaderOctets(email) + (email.text ? minBodyOctets(email.text) : 0) + (email.html ? minBodyOctets(email.html) : 0) + email.attachments.reduce((sum, a) => sum + base64Octets(a.bytes.byteLength), 0);
+	if (projected > 10485760) throw new MimeError("MIME_ERROR", `email: message is at least ${projected} bytes once encoded, which exceeds Cloudflare limit of ${MAX_MESSAGE_BYTES} bytes.`);
+	const messageId = generateMessageId(email.from.email);
+	const topHeaders = [
+		["Date", (/* @__PURE__ */ new Date()).toUTCString().replace("GMT", "+0000")],
+		["From", formatAddress(email.from)],
+		["To", formatAddressList(email.to)]
+	];
+	if (email.cc.length > 0) topHeaders.push(["Cc", formatAddressList(email.cc)]);
+	if (email.replyTo) topHeaders.push(["Reply-To", formatAddress(email.replyTo)]);
+	topHeaders.push(["Subject", encodeWord(email.subject)]);
+	topHeaders.push(["Message-ID", messageId]);
+	if (email.threading?.inReplyTo) topHeaders.push(["In-Reply-To", email.threading.inReplyTo]);
+	if (email.threading?.references) topHeaders.push(["References", email.threading.references]);
+	topHeaders.push(["MIME-Version", "1.0"]);
+	for (const [name, value] of Object.entries(email.headers)) {
+		if (RESERVED_HEADERS.has(name.toLowerCase())) continue;
+		topHeaders.push([name, encodeWord(value)]);
+	}
+	const textPart = email.text ? buildBodyPart("text/plain", email.text) : void 0;
+	const htmlPart = email.html ? buildBodyPart("text/html", email.html) : void 0;
+	let bodyPart;
+	if (textPart && htmlPart) bodyPart = wrapMultipart("alternative", [textPart, htmlPart]);
+	else bodyPart = textPart ?? htmlPart;
+	if (email.attachments.length > 0) {
+		const inlineAttachments = email.attachments.filter((a) => a.disposition === "inline");
+		const fileAttachments = email.attachments.filter((a) => a.disposition !== "inline");
+		if (inlineAttachments.length > 0 && htmlPart) bodyPart = wrapMultipart("related", [bodyPart, ...inlineAttachments.map(buildAttachmentPart)]);
+		else fileAttachments.push(...inlineAttachments);
+		if (fileAttachments.length > 0) bodyPart = wrapMultipart("mixed", [bodyPart, ...fileAttachments.map(buildAttachmentPart)]);
+	}
+	for (const [k, v] of bodyPart.headers) topHeaders.push([k, v]);
+	const rawText = topHeaders.map(([k, v]) => foldHeader(k, v)).join(CRLF) + "\r\n\r\n" + bodyPart.body;
+	const raw = new TextEncoder().encode(rawText);
+	const overlong = findOverlongLine(rawText);
+	if (overlong !== void 0) throw new MimeError("MIME_ERROR", `email: header line ${overlong.index + 1} is ${overlong.octets} octets, over the ${MAX_LINE_OCTETS}-octet limit in RFC 5322 §2.1.1. A value with no whitespace cannot be folded — shorten it, or move it into the body.`);
+	if (raw.byteLength > 10485760) throw new MimeError("MIME_ERROR", `email: message size ${raw.byteLength} bytes exceeds Cloudflare limit of ${MAX_MESSAGE_BYTES} bytes.`);
+	return {
+		raw,
+		messageId
+	};
+}
+//#endregion
+export { parseAddress as a, normalizeEmail as i, MimeError as n, validateAddressParts as o, buildMime as r, MAX_MESSAGE_BYTES as t };