void 0.10.12 → 0.20.0

package/dist/inbound-CNKxb3FY.mjs

@@ -0,0 +1,694 @@
+import { i as normalizeEmail, n as MimeError, o as validateAddressParts, r as buildMime, t as MAX_MESSAGE_BYTES } from "./mime-BJD7d_qL.mjs";
+import { a as getRawRuntimeEnv } from "./env-raw-Cx8ElDdj.mjs";
+//#region src/runtime/email/inbound.ts
+const VALID_SLUG = /^[a-z0-9](?:[a-z0-9-]{0,54}[a-z0-9])?$/;
+/**
+* Guardrails on what one handler may queue.
+*
+* These are NOT the security boundary. Recording happens inside the tenant's
+* own worker, and on the platform a Workers-for-Platforms tenant can ship any
+* `WorkerEntrypoint` whose `email()` returns any array at all, bypassing this
+* file entirely — so the load-bearing caps are the matching ones in the
+* platform router (`MAX_ACTIONS` / `MAX_ACTION_ADDRESS_LENGTH` in
+* `email-router.ts`). What these buy is a fast, precise failure at the call
+* that went wrong, instead of a whole action list silently dropped at the
+* router with only a platform-side log to show for it.
+*/
+const MAX_ACTIONS = 100;
+const MAX_ACTION_ADDRESS_LENGTH = 320;
+const MAX_FORWARD_HEADER_LENGTH = 1024;
+/**
+* Cap on a reject reason, restated from the router's
+* `MAX_REJECT_REASON_LENGTH` in `email-router.ts` for the same reason as
+* above, and pinned by the same test. See `normalizeRejectReason`.
+*/
+const MAX_REJECT_REASON_LENGTH = 1e3;
+/**
+* The router's ADMISSION bounds — what it refuses BEFORE the handler runs
+* (`MAX_INBOUND_BYTES` / `MAX_INBOUND_HEADERS` in `email-router.ts`,
+* restated for the same reason as above and pinned by the same test).
+* `routeInbound` rejects a message over either one and never dispatches it,
+* so a handler's behaviour on such a message is unreachable after a managed
+* deploy; the test harness applies both before it invokes the handler.
+*
+* `MAX_INBOUND_BYTES` is NOT `MAX_MESSAGE_BYTES`, though the numbers agree
+* today. That one is Cloudflare's cap on an OUTBOUND message (and the
+* `parseEmail` guard); this one is the router's own heap headroom on an
+* inbound one, set well under Cloudflare's ~25 MB inbound ceiling, and the
+* two can move independently.
+*/
+const MAX_INBOUND_BYTES = 10485760;
+const MAX_INBOUND_HEADERS = 1024;
+/**
+* Cumulative reply-byte budget for ONE dispatch.
+*
+* `MAX_MESSAGE_BYTES` bounds a single `reply()` call, not the queue: N replies
+* at the cap is N x 10 MiB of `Uint8Array` riding one RPC response. workerd
+* caps a serialized RPC payload at 32 MiB, so the queue that clears our
+* per-reply check still fails at the boundary — opaquely. The router cannot
+* tell that failure from any other dispatch error, so the whole message comes
+* back to the sender as a generic "project handler error" reject with nothing
+* in it a handler author could act on. Two full-size replies is already well
+* past any legitimate use, and failing here names the exact call that
+* overran.
+*/
+const MAX_REPLY_BYTES_TOTAL = 2 * MAX_MESSAGE_BYTES;
+function readRawProjectSlug() {
+	let raw;
+	try {
+		raw = getRawRuntimeEnv()?.__VOID_PROJECT_SLUG;
+	} catch {
+		return;
+	}
+	return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+function tryReadProjectSlug() {
+	const raw = readRawProjectSlug();
+	return raw !== void 0 && VALID_SLUG.test(raw) ? raw : void 0;
+}
+function tryReadEmailDomain() {
+	let raw;
+	try {
+		raw = getRawRuntimeEnv()?.__VOID_EMAIL_DOMAIN;
+	} catch {
+		return;
+	}
+	return typeof raw === "string" && raw.length > 0 ? raw : void 0;
+}
+/**
+* Identity helper that types the inbound email handler. Use as the default
+* export of `email/<address>.ts` or `email/_default.ts`.
+*/
+function defineEmail(handler) {
+	return handler;
+}
+/**
+* Typed error thrown by `parseEmail`. Lets handler authors distinguish
+* "too big" from "malformed body" without string-matching error messages.
+*/
+var ParseEmailError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "ParseEmailError";
+		this.code = code;
+	}
+};
+/**
+* Parse a `ForwardableEmailMessage` into structured fields. postal-mime is
+* loaded lazily so workers that never call this don't bundle it.
+*
+* For proxy messages (built via `createMessageProxy`) the raw bytes are
+* cached on first read so subsequent `parseEmail`/`message.raw` accesses
+* still work. For real CF `ForwardableEmailMessage`s the raw stream is
+* one-shot.
+*/
+async function parseEmail(message) {
+	if (message.rawSize > 10485760) throw new ParseEmailError("INBOUND_TOO_LARGE", `parseEmail: message size ${message.rawSize} bytes exceeds maximum of ${MAX_MESSAGE_BYTES} bytes.`);
+	const { default: PostalMime } = await import("postal-mime");
+	const cached = proxyRawCache.get(message);
+	try {
+		const source = cached ? await cached.read() : message.raw;
+		return await PostalMime.parse(source);
+	} catch (cause) {
+		throw new ParseEmailError("PARSE_FAILED", `parseEmail: could not parse the message body. ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+	}
+}
+const proxyRawCache = /* @__PURE__ */ new WeakMap();
+/**
+* Remove the platform-injected `<slug>+` prefix from a recipient address.
+* The platform's shared sender (e.g. `mail.void.cloud`) rewrites every recipient to
+* `<slug>+<tag>@<domain>`; user handlers expect `<tag>@<domain>`. If the
+* slug is unknown, missing, or doesn't match the local-part prefix, the
+* address is returned unchanged so callers without slug context (e.g. the
+* test harness when no slug is set) don't accidentally mangle the address.
+*/
+function stripSlugFromAddress(address, slug) {
+	if (!slug) return address;
+	const atIdx = address.indexOf("@");
+	if (atIdx <= 0) return address;
+	const localPart = address.slice(0, atIdx);
+	const domain = address.slice(atIdx);
+	const prefix = `${slug.toLowerCase()}+`;
+	if (localPart.toLowerCase().startsWith(prefix)) return localPart.slice(prefix.length) + domain;
+	return address;
+}
+function replyTooLarge(size) {
+	return new MimeError("MIME_ERROR", `reply: message size ${size} bytes exceeds Cloudflare limit of ${MAX_MESSAGE_BYTES} bytes.`);
+}
+function replyBudgetExhausted(size) {
+	return new MimeError("MIME_ERROR", `reply: cumulative reply size ${size} bytes exceeds this delivery's budget of ${MAX_REPLY_BYTES_TOTAL} bytes.`);
+}
+function queueFull() {
+	return new MimeError("MIME_ERROR", `email: handler queued more than ${MAX_ACTIONS} actions for one message.`);
+}
+function addressTooLong(field, length) {
+	return new MimeError(field === "from" ? "INVALID_FROM" : "INVALID_TO", `${field} address is ${length} characters, over the ${MAX_ACTION_ADDRESS_LENGTH}-character limit.`);
+}
+function invalidForwardHeaders(cause) {
+	const detail = cause instanceof Error ? cause.message.slice(0, 320) : "not a valid header set";
+	return new MimeError("MIME_ERROR", `forward: invalid header — ${detail}`);
+}
+/**
+* The router's `forwardHeadersWithinBounds`, as a throw. It runs on the
+* record about to be recorded — the very object the router receives, so the
+* count is the router's count: a `Headers` folded its duplicate names before
+* it got here, and a record keeps `X-A` and `x-a` as two, both there and
+* here. Runs after the `new Headers()` validity check, so every name is a
+* token and every value is header-safe; what is left is size. The router
+* drops the WHOLE list on any of these — a handler that passed here and
+* failed there deployed as one whose managed delivery performed no actions.
+*/
+function assertForwardHeadersWithinBounds(headers) {
+	const names = Object.keys(headers);
+	if (names.length > 32) throw new MimeError("MIME_ERROR", `forward: ${names.length} headers, over the 32-header limit.`);
+	for (const name of names) {
+		if (name.length > 1024) throw new MimeError("MIME_ERROR", `forward: header name is ${name.length} characters, over the ${MAX_FORWARD_HEADER_LENGTH}-character limit.`);
+		const value = headers[name];
+		if (typeof value !== "string") throw new MimeError("MIME_ERROR", `forward: header "${name.slice(0, 64)}" value is not a string.`);
+		if (value.length > 1024) throw new MimeError("MIME_ERROR", `forward: header "${name.slice(0, 64)}" value is ${value.length} characters, over the ${MAX_FORWARD_HEADER_LENGTH}-character limit.`);
+	}
+}
+/**
+* The router's rule for a reject reason (`validateActions` in
+* `email-router.ts`: `sanitize(raw, MAX_REJECT_REASON_LENGTH)`, and
+* `'rejected by handler'` for an empty one), applied when the reason is
+* RECORDED so the native replay carries the string the managed one does.
+*
+* The reason goes into the SMTP reply to the connecting client, and a
+* handler may build it from the inbound message: a remote sender's CRLF is
+* then a line injected into that reply, and a multi-megabyte reason is a
+* transient-heap amplifier. The router already refuses both, but on your
+* own account `enactEmailActions` handed the recorded string to the native
+* `setReject()` untouched, so the same handler injected there and was
+* clean here. NORMALIZED rather than refused, unlike the forward bounds
+* above: a reject is the handler's terminal decision, and throwing out of
+* it would drop that decision and bounce the message as a dispatch error
+* (see the `MAX_ACTIONS` note in `setReject`). Slice FIRST, then replace: a
+* global replace materializes ~66 bytes per match, so the slice is what
+* bounds the work (see `prefixReplySubject`). The result can be SHORTER
+* than the cap: a run of controls inside the window collapses to one space
+* and the window is not refilled from beyond it — the router's own trade,
+* and it is DSN text.
+*/
+function normalizeRejectReason(reason) {
+	const raw = typeof reason === "string" ? reason : "";
+	if (raw.length === 0) return "rejected by handler";
+	return raw.slice(0, MAX_REJECT_REASON_LENGTH).replace(/[\x00-\x1f\x7f]+/g, " ");
+}
+async function readStreamToBytes(stream, limit = Infinity, onOverflow = replyTooLarge) {
+	const reader = stream.getReader();
+	const chunks = [];
+	let total = 0;
+	for (;;) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		total += value.byteLength;
+		if (total > limit) {
+			await reader.cancel().catch(() => {});
+			throw onOverflow(total);
+		}
+		chunks.push(value);
+	}
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const c of chunks) {
+		out.set(c, offset);
+		offset += c.byteLength;
+	}
+	return out;
+}
+function bytesToReadableStream(bytes) {
+	return new ReadableStream({ start(controller) {
+		controller.enqueue(bytes);
+		controller.close();
+	} });
+}
+/**
+* Build a proxy `ForwardableEmailMessage` from an envelope. The proxy's
+* `setReject` / `forward` / `reply` methods don't dispatch directly — they
+* record `EmailAction` entries that the router (which holds the real
+* message) enacts after the handler returns.
+*
+* `reply()` accepts a duck-typed `{ from, to, raw }` with `raw` a
+* `Uint8Array` or `ReadableStream` — what `replyEmail()` passes. It does NOT
+* accept a native `EmailMessage` from `cloudflare:email`: that class exposes
+* only `from` and `to` (workers-types declares nothing else, and the body
+* has no public accessor), so its bytes cannot be recorded here, and nothing
+* could carry them over RPC to the platform router. The reply MIME bytes are
+* buffered before being recorded so the action is fully self-contained.
+*
+* When `opts.slug` is provided, `message.to` is rewritten to remove the
+* platform-injected `<slug>+` prefix so handlers see `<tag>@<domain>`
+* instead of `<slug>+<tag>@<domain>`. The original wire-form recipient is
+* preserved on a non-enumerable `__voidPlatformTo` property.
+*/
+function createMessageProxy(envelope, opts = {}) {
+	const actions = [];
+	const headers = new Headers(envelope.headers);
+	const userVisibleTo = stripSlugFromAddress(envelope.to, opts.slug);
+	let cachedRaw;
+	let bufferingPromise;
+	function readRawOnce() {
+		if (cachedRaw) return Promise.resolve(cachedRaw);
+		if (bufferingPromise) return bufferingPromise;
+		const source = envelope.raw;
+		if (source instanceof Uint8Array) {
+			cachedRaw = source;
+			return Promise.resolve(cachedRaw);
+		}
+		bufferingPromise = readStreamToBytes(source).then((bytes) => {
+			cachedRaw = bytes;
+			return bytes;
+		});
+		return bufferingPromise;
+	}
+	if (envelope.raw instanceof Uint8Array) cachedRaw = envelope.raw;
+	let rejected = false;
+	let replyBytesUsed = 0;
+	function assertQueueHasRoom() {
+		if (actions.length >= MAX_ACTIONS) throw queueFull();
+	}
+	const message = {
+		from: envelope.from,
+		to: userVisibleTo,
+		headers,
+		get raw() {
+			if (cachedRaw) return bytesToReadableStream(cachedRaw);
+			const pending = readRawOnce();
+			return new ReadableStream({ async start(controller) {
+				const bytes = await pending;
+				controller.enqueue(bytes);
+				controller.close();
+			} });
+		},
+		rawSize: envelope.rawSize,
+		setReject(reason) {
+			if (rejected) return;
+			rejected = true;
+			let dropped = 0;
+			for (let i = actions.length - 1; i >= 0; i--) {
+				const a = actions[i];
+				if (a.type === "forward" || a.type === "reply") {
+					actions.splice(i, 1);
+					dropped++;
+				}
+			}
+			if (dropped > 0) console.warn(`[void/email] setReject() after ${dropped} forward/reply call(s) — those actions were dropped. CF rejects are terminal: anything queued before setReject() never runs. Move the reject earlier in the handler.`);
+			actions.push({
+				type: "reject",
+				reason: normalizeRejectReason(reason)
+			});
+		},
+		async forward(to, fwdHeaders) {
+			if (rejected) {
+				console.warn("[void/email] forward() called after setReject() — ignored. CF rejects are terminal: nothing else runs once setReject fires.");
+				return;
+			}
+			assertQueueHasRoom();
+			if (to.length > MAX_ACTION_ADDRESS_LENGTH) throw addressTooLong("to", to.length);
+			validateAddressParts("to", to);
+			let headersObj;
+			if (fwdHeaders instanceof Headers) headersObj = Object.fromEntries(fwdHeaders.entries());
+			else if (fwdHeaders) {
+				try {
+					new Headers(fwdHeaders);
+				} catch (e) {
+					throw invalidForwardHeaders(e);
+				}
+				headersObj = { ...fwdHeaders };
+			}
+			if (headersObj) assertForwardHeadersWithinBounds(headersObj);
+			actions.push({
+				type: "forward",
+				to,
+				...headersObj ? { headers: headersObj } : {}
+			});
+		},
+		async reply(reply) {
+			if (rejected) {
+				console.warn("[void/email] reply() called after setReject() — ignored. CF rejects are terminal: nothing else runs once setReject fires.");
+				return;
+			}
+			assertQueueHasRoom();
+			if (reply.from.length > MAX_ACTION_ADDRESS_LENGTH) throw addressTooLong("from", reply.from.length);
+			if (reply.to.length > MAX_ACTION_ADDRESS_LENGTH) throw addressTooLong("to", reply.to.length);
+			validateAddressParts("from", reply.from);
+			validateAddressParts("to", reply.to);
+			const remaining = MAX_REPLY_BYTES_TOTAL - replyBytesUsed;
+			let rawBytes;
+			if (reply.raw instanceof Uint8Array) {
+				if (reply.raw.byteLength > 10485760) throw replyTooLarge(reply.raw.byteLength);
+				if (reply.raw.byteLength > remaining) throw replyBudgetExhausted(replyBytesUsed + reply.raw.byteLength);
+				rawBytes = reply.raw;
+			} else {
+				const raw = reply.raw;
+				if (typeof raw !== "object" || raw === null || typeof raw.getReader !== "function") throw new MimeError("MIME_ERROR", "reply: expected { from, to, raw } with raw as a Uint8Array or ReadableStream. A native EmailMessage cannot be replayed from a Void handler — its body has no public accessor. Use replyEmail() from void/email, or pass the MIME bytes as raw.");
+				const limit = Math.min(MAX_MESSAGE_BYTES, remaining);
+				rawBytes = await readStreamToBytes(reply.raw, limit, (total) => limit === 10485760 ? replyTooLarge(total) : replyBudgetExhausted(replyBytesUsed + total));
+			}
+			replyBytesUsed += rawBytes.byteLength;
+			actions.push({
+				type: "reply",
+				from: reply.from,
+				to: reply.to,
+				raw: rawBytes
+			});
+		}
+	};
+	if (envelope.to !== userVisibleTo) Object.defineProperty(message, "__voidPlatformTo", {
+		value: envelope.to,
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	proxyRawCache.set(message, { read: readRawOnce });
+	return {
+		message,
+		getActions: () => [...actions]
+	};
+}
+/**
+* Whether `Name: value` can be emitted without breaking RFC 5322 §2.1.1.
+*
+* Folding only happens at whitespace (§3.2.2), so the widest unbreakable run
+* is what decides it — a `References` chain of ordinary ids folds fine however
+* long, while one oversized id inside it does not.
+*/
+function fitsHeaderLine(name, value) {
+	if (!value) return false;
+	const budget = 998 - (name.length + 2);
+	let run = 0;
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c === 32 || c === 9) {
+			run = 0;
+			continue;
+		}
+		if (c < 128) run += 1;
+		else if (c < 2048) run += 2;
+		else if (c >= 55296 && c <= 56319 && i + 1 < value.length && (value.charCodeAt(i + 1) & 64512) === 56320) {
+			run += 4;
+			i++;
+		} else run += 3;
+		if (run > budget) return false;
+	}
+	return true;
+}
+/**
+* Whether `value` carries a C0 control other than HTAB, or DEL. The
+* sibling of `fitsHeaderLine` for the other way a remote-controlled id can
+* be unrepresentable: a threading value is emitted verbatim, so a control
+* inside it reached the reply's `In-Reply-To` / `References` line raw —
+* `\x01` and DEL pass a WHATWG `Headers`, which refuses only CR, LF and
+* NUL — and an RFC 5322 §3.6.4 `msg-id` is `dot-atom-text`, which admits no
+* control at all. HTAB is not one here: it is the whitespace that separates
+* ids (§3.2.2 FWS), the same break `fitsHeaderLine` and `replyReferences`
+* cut at. One pass, no allocation, so it costs nothing a hostile header can
+* multiply; never a throw, for the same reason as the line guard.
+*/
+function hasControl(value) {
+	for (let i = 0; i < value.length; i++) {
+		const c = value.charCodeAt(i);
+		if (c < 32 && c !== 9 || c === 127) return true;
+	}
+	return false;
+}
+/**
+* `chain` without any id that `hasControl` refuses, the rest in their order
+* and joined by single spaces; the chain itself when there is nothing to
+* drop, without allocating. Only ONE id is lost — the others still thread —
+* whereas an id no line can carry drops the whole chain for the parent's id
+* (`replyReferences`), because that guard is about the rendered line and
+* this one is about one token. Called only on a chain already cut to
+* `MAX_REPLY_REFERENCES_CHARS`, so the per-id slices in the rare bad case
+* are bounded by that budget, not by the header a remote sender delivered.
+*/
+function dropControlIds(chain) {
+	if (!hasControl(chain)) return chain;
+	const kept = [];
+	let start = -1;
+	let tainted = false;
+	for (let i = 0; i <= chain.length; i++) {
+		const c = i < chain.length ? chain.charCodeAt(i) : 32;
+		if (c === 32 || c === 9) {
+			if (start >= 0 && !tainted) kept.push(chain.slice(start, i));
+			start = -1;
+			tainted = false;
+		} else {
+			if (start < 0) start = i;
+			if (c < 32 || c === 127) tainted = true;
+		}
+	}
+	return kept.join(" ");
+}
+/**
+* Longest decoded inbound `Subject` the default reply subject is built from;
+* anything longer falls back to a bare `Re:`.
+*
+* RFC 5322 §2.1.1 caps a header LINE at 998 octets, and only folding lets a
+* header run past it — so a subject is something that fits on a line or
+* two. Real ones are tens to hundreds of characters; the longest automated
+* ones (a ticket title under a stack of list tags) reach a few hundred, and
+* Exchange rejects past 255. Four thousand keeps every one of those with an
+* order of magnitude to spare and refuses the shape that is only a subject
+* in name. What the bound buys is proportional cost: the control-character
+* replacements below cost 66 bytes of heap per match, so at this size they
+* cost at most 135 KB, and the reply's own `Subject` line is at most ~20 KB
+* — 4096 code units x 3 UTF-8 octets, base64'd in 45-octet encoded-words
+* with their framing — against a `MAX_MESSAGE_BYTES` of 10 MiB, so the
+* subject alone can never push the reply over the limit.
+*/
+const MAX_REPLY_SUBJECT_CHARS = 4096;
+function prefixReplySubject(original) {
+	const decoded = decodeRfc2047(original);
+	if (decoded.length > MAX_REPLY_SUBJECT_CHARS) return "Re:";
+	const cleaned = decoded.replace(/[\x00-\x1f\x7f]+/g, " ").replace(/ {2,}/g, " ").trim();
+	if (!cleaned) return "Re:";
+	const prefixed = /^re:/i.test(cleaned) ? cleaned : `Re: ${cleaned}`;
+	if (/^[\x20-\x7e]*$/.test(prefixed) && !fitsHeaderLine("Subject", prefixed)) return "Re:";
+	return prefixed;
+}
+/**
+* Longest `References` value a reply carries, in UTF-16 code units — the
+* measure `MAX_REPLY_SUBJECT_CHARS` uses. It is checked on `length` alone,
+* so a chain the size of the inbound message costs one property read before
+* anything is scanned or sliced.
+*
+* RFC 5322 puts no limit on the field, but everything downstream does. RFC
+* 5537 §3.4.4 has a followup agent trim it to 998 characters, and Postfix's
+* `header_size_limit` discards header bytes past 100 KiB. A message-id is
+* tens of characters, so 8 KiB carries a chain over a hundred replies deep
+* with every id intact — an order of magnitude past any conversation — and
+* a value this size, folded and encoded, is at most ~25 KB of a 10 MiB
+* reply, so the chain alone can never push the reply over the limit.
+* Unbounded, it could: the inbound header can be the whole 10 MiB message,
+* and 10 MiB of short ids passes the line guard — every id folds — yet
+* `foldHeader`'s continuations put the rendered reply over
+* `MAX_MESSAGE_BYTES`, and `buildMime` threw (measured: 10,777,129 bytes
+* from a 10,485,557-character chain) for a reply the guide promises is sent.
+*
+* Past the bound the NEWEST ids are kept, whole, and the parent's id still
+* ends the chain. That is what a mail client threads on: it links the reply
+* under any id it recognises, and the parent is also `In-Reply-To`. The
+* root id RFC 5537 keeps is a Netnews convention (a newsreader identifies a
+* thread by it); in mail it would spend the budget on an id older than
+* every client in the conversation.
+*/
+const MAX_REPLY_REFERENCES_CHARS = 8192;
+/**
+* The `References` value a reply carries, or `''` when nothing can be
+* threaded. In order: the whole inbound chain continued by the parent's
+* `messageId` when it fits `MAX_REPLY_REFERENCES_CHARS`; otherwise the
+* newest ids of the chain that fit, none of them split; and the parent's id
+* alone (which may be empty) when even those hold an id no line can carry.
+*/
+function replyReferences(originalReferences, messageId) {
+	const parent = messageId ? ` ${messageId}` : "";
+	let chain = originalReferences;
+	const budget = MAX_REPLY_REFERENCES_CHARS - parent.length;
+	if (chain.length > budget) {
+		let cut = chain.length - budget;
+		while (cut < chain.length) {
+			const c = chain.charCodeAt(cut);
+			if (c === 32 || c === 9) break;
+			cut++;
+		}
+		chain = chain.slice(cut);
+	}
+	chain = dropControlIds(chain);
+	chain = `${chain}${parent}`.trim();
+	return fitsHeaderLine("References", chain) ? chain : messageId;
+}
+/**
+* Minimal RFC 2047 encoded-word decoder. Handles `=?charset?B?base64?=`
+* and `=?charset?Q?quoted-printable?=` segments separated by optional
+* whitespace. Unknown charsets pass through (best-effort UTF-8 decode);
+* malformed inputs return the original.
+*
+* Scope is intentionally narrow — used only for cosmetic subject
+* normalization in `prefixReplySubject`. Anything that needs robust
+* decoding (e.g. searching subject text) should use postal-mime's
+* parsed view via `parseEmail`.
+*/
+function decodeRfc2047(value) {
+	if (!value.includes("=?")) return value;
+	try {
+		const parts = [];
+		let last = 0;
+		for (const m of value.matchAll(/=\?([\w-]+)\?([BbQq])\?([^?]*)\?=(?:\s+(?==\?))?/g)) {
+			const [match, charset, enc, payload] = m;
+			const bytes = enc.toUpperCase() === "B" ? base64Decode(payload) : quotedPrintableDecode(payload);
+			let decoder;
+			try {
+				decoder = new TextDecoder(charset || "utf-8", { fatal: false });
+			} catch {
+				decoder = new TextDecoder("utf-8", { fatal: false });
+			}
+			parts.push(value.slice(last, m.index), decoder.decode(bytes));
+			last = m.index + match.length;
+		}
+		parts.push(value.slice(last));
+		return parts.join("");
+	} catch {
+		return value;
+	}
+}
+function base64Decode(b64) {
+	const binary = atob(b64);
+	const out = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+	return out;
+}
+function quotedPrintableDecode(qp) {
+	const out = new Uint8Array(qp.length);
+	let kept = 0;
+	for (let i = 0; i < qp.length; i++) {
+		const ch = qp.charCodeAt(i);
+		if (ch === 95) out[kept++] = 32;
+		else if (ch === 61 && i + 2 < qp.length) {
+			const hex = qp.slice(i + 1, i + 3);
+			if (/^[0-9A-Fa-f]{2}$/.test(hex)) {
+				out[kept++] = parseInt(hex, 16);
+				i += 2;
+			} else out[kept++] = ch;
+		} else out[kept++] = ch;
+	}
+	return out.subarray(0, kept);
+}
+/**
+* Pure helper: build the reply MIME from an inbound message + reply opts,
+* with `Subject: Re: …` (no double-prefix), `In-Reply-To`, and `References`
+* threaded from the original. Threading is best-effort (the inbound values
+* are remote-sender controlled): an id no header line can carry is dropped,
+* and a `References` chain over `MAX_REPLY_REFERENCES_CHARS` is trimmed to
+* its newest ids. Exposed separately so the dispatch step (`message.reply`)
+* can be tested without `cloudflare:email`.
+*/
+async function buildReplyMessage(message, opts) {
+	const headers = message.headers;
+	const originalSubject = headers.get("Subject") ?? "";
+	const originalMessageId = headers.get("Message-ID") ?? "";
+	const originalReferences = headers.get("References") ?? "";
+	let fromAddr;
+	if (opts.from !== void 0) fromAddr = opts.from;
+	else {
+		const slug = tryReadProjectSlug();
+		if (slug) {
+			const domain = tryReadEmailDomain();
+			if (!domain) throw new Error("replyEmail: 'from' is required when __VOID_PROJECT_SLUG is set but __VOID_EMAIL_DOMAIN is not. Set `from` explicitly, or deploy via Void so the platform-injected __VOID_PROJECT_SLUG and __VOID_EMAIL_DOMAIN can default it to <slug>+noreply@<domain>.");
+			fromAddr = `${slug}+noreply@${domain}`;
+		} else if (readRawProjectSlug() !== void 0) throw new Error("replyEmail: 'from' is required — this project's slug cannot build a default reply sender (`<slug>+noreply@<domain>` must stay within the 64-octet local part, so the slug must be at most 56 characters). Set `from` explicitly.");
+		else fromAddr = message.to;
+	}
+	const toAddr = opts.to ?? message.from;
+	const subject = opts.subject ?? prefixReplySubject(originalSubject);
+	const threading = {};
+	const messageId = fitsHeaderLine("In-Reply-To", originalMessageId) && !hasControl(originalMessageId) ? originalMessageId : "";
+	if (messageId) threading.inReplyTo = messageId;
+	const references = replyReferences(originalReferences, messageId);
+	if (references) threading.references = references;
+	const normalized = await normalizeEmail({
+		from: fromAddr,
+		to: toAddr,
+		subject,
+		text: opts.text,
+		html: opts.html,
+		headers: opts.headers,
+		attachments: opts.attachments,
+		threading: threading.inReplyTo || threading.references ? threading : void 0
+	});
+	const { raw } = buildMime(normalized);
+	return {
+		from: normalized.from.email,
+		to: normalized.to[0].email,
+		raw,
+		subject
+	};
+}
+/**
+* Send a threading-aware reply to an inbound message. Builds the reply MIME
+* (correct `In-Reply-To` / `References` / `Subject: Re: …`) and records a
+* reply intent on the message proxy. The platform router enacts the reply
+* via the real `ForwardableEmailMessage.reply()` once the handler returns.
+*
+* The threading headers are best-effort, since the inbound values they are
+* built from are remote-sender controlled: an id no header line can carry
+* is dropped, and a `References` chain over 8 KiB keeps only its newest
+* ids. The reply is sent either way.
+*/
+async function replyEmail(message, opts) {
+	const { from, to, raw } = await buildReplyMessage(message, opts);
+	await message.reply({
+		from,
+		to,
+		raw
+	});
+}
+/**
+* Whether `value` is a real `ForwardableEmailMessage` — one Cloudflare
+* delivered to this worker's `email()` directly — rather than an
+* `EmailEnvelope` from the platform router. Functions do not survive RPC,
+* so their presence is the discriminator.
+*/
+function isForwardableEmailMessage(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const m = value;
+	return typeof m.setReject === "function" && typeof m.forward === "function" && typeof m.reply === "function";
+}
+/**
+* Replay recorded `EmailAction`s on a real `ForwardableEmailMessage`, in
+* order. The proxy already made `setReject` terminal (earlier forward/reply
+* entries are purged, later ones dropped), so a reject is never followed by
+* anything. `reply` needs a genuine `EmailMessage` — Cloudflare rejects a
+* duck-typed object — so `cloudflare:email` is loaded here, and only when
+* a reply was recorded.
+*
+* The `new Headers()` below is the one step this loop constructs from
+* handler input, and it cannot fail on a recorded action: the proxy's
+* `forward()` already ran the record through that constructor, so a bad
+* record failed inside the handler, before any replay. (`EmailMessage`
+* construction neither validates nor reads its stream — measured under
+* workerd.) A reject's reason reaches the native `setReject()` as the proxy
+* recorded it — already sliced and stripped the way the platform router
+* would (`normalizeRejectReason`), so the SMTP reply is the same in both
+* deployments. What Cloudflare itself refuses at `forward()` / `reply()`
+* still throws out of the loop, as any native call would.
+*/
+async function enactEmailActions(message, actions) {
+	for (const action of actions) switch (action.type) {
+		case "reject":
+			message.setReject(action.reason);
+			break;
+		case "forward":
+			await message.forward(action.to, action.headers ? new Headers(action.headers) : void 0);
+			break;
+		case "reply": {
+			const { EmailMessage } = await import("cloudflare:email");
+			await message.reply(new EmailMessage(action.from, action.to, bytesToReadableStream(action.raw)));
+			break;
+		}
+	}
+}
+//#endregion
+export { defineEmail as a, parseEmail as c, createMessageProxy as i, replyEmail as l, MAX_INBOUND_HEADERS as n, enactEmailActions as o, ParseEmailError as r, isForwardableEmailMessage as s, MAX_INBOUND_BYTES as t };