emdash-smtp-core 0.2.0

package/dist/index.mjs

@@ -0,0 +1,2153 @@
+//#region src/storage.ts
+const GLOBAL_SETTINGS_KEY = "settings:global";
+const SELECTED_PROVIDER_KEY = "state:selectedProviderId";
+const LAST_TEST_RESULT_KEY = "state:lastTestResult";
+function providerSettingsKey(providerId) {
+	return `settings:provider:${providerId}`;
+}
+function trimString(value) {
+	if (typeof value !== "string") return void 0;
+	const next = value.trim();
+	return next === "" ? void 0 : next;
+}
+function numberValue$2(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const next = Number(value);
+		if (Number.isFinite(next)) return next;
+	}
+}
+function booleanValue$1(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") return value === "true" || value === "1" || value === "on";
+	return Boolean(value);
+}
+function normalizeLogLevel(value) {
+	if (value === "errors" || value === "off") return value;
+	return "all";
+}
+function cleanRecord(record) {
+	return Object.fromEntries(Object.entries(record).filter(([, value]) => value !== void 0));
+}
+async function getGlobalSettings(ctx) {
+	const saved = await ctx.kv.get(GLOBAL_SETTINGS_KEY) ?? {};
+	return {
+		primaryProviderId: trimString(saved.primaryProviderId),
+		fallbackProviderId: trimString(saved.fallbackProviderId),
+		fromEmail: trimString(saved.fromEmail),
+		fromName: trimString(saved.fromName),
+		replyTo: trimString(saved.replyTo),
+		logLevel: normalizeLogLevel(saved.logLevel)
+	};
+}
+async function saveGlobalSettingsFromValues(ctx, values) {
+	const next = {
+		primaryProviderId: trimString(values.primaryProviderId),
+		fallbackProviderId: trimString(values.fallbackProviderId),
+		fromEmail: trimString(values.fromEmail),
+		fromName: trimString(values.fromName),
+		replyTo: trimString(values.replyTo),
+		logLevel: normalizeLogLevel(values.logLevel)
+	};
+	await ctx.kv.set(GLOBAL_SETTINGS_KEY, next);
+	return next;
+}
+async function getProviderSettings(ctx, providerId) {
+	return await ctx.kv.get(providerSettingsKey(providerId)) ?? {};
+}
+async function patchProviderSettings(ctx, providerId, patch) {
+	const cleaned = cleanRecord({
+		...await getProviderSettings(ctx, providerId),
+		...patch
+	});
+	await ctx.kv.set(providerSettingsKey(providerId), cleaned);
+	return cleaned;
+}
+async function saveProviderSettingsFromValues(ctx, provider, values) {
+	const existing = await getProviderSettings(ctx, provider.id);
+	const next = {};
+	for (const field of provider.fields) {
+		const raw = values[field.key];
+		if (field.type === "secret") {
+			const secret = trimString(raw);
+			if (secret !== void 0) next[field.key] = secret;
+			else if (existing[field.key] !== void 0) next[field.key] = existing[field.key];
+			continue;
+		}
+		if (field.type === "number") {
+			const numeric = numberValue$2(raw);
+			if (numeric !== void 0) next[field.key] = numeric;
+			continue;
+		}
+		if (field.type === "toggle") {
+			next[field.key] = booleanValue$1(raw);
+			continue;
+		}
+		const text = trimString(raw);
+		if (text !== void 0) next[field.key] = text;
+	}
+	const cleaned = cleanRecord(next);
+	await ctx.kv.set(providerSettingsKey(provider.id), cleaned);
+	return cleaned;
+}
+async function clearProviderSecret(ctx, providerId, fieldKey) {
+	const next = { ...await getProviderSettings(ctx, providerId) };
+	delete next[fieldKey];
+	await ctx.kv.set(providerSettingsKey(providerId), cleanRecord(next));
+}
+async function getSelectedProviderId(ctx) {
+	return trimString(await ctx.kv.get(SELECTED_PROVIDER_KEY));
+}
+async function setSelectedProviderId(ctx, providerId) {
+	await ctx.kv.set(SELECTED_PROVIDER_KEY, providerId);
+}
+async function getLastTestResult(ctx) {
+	return await ctx.kv.get(LAST_TEST_RESULT_KEY);
+}
+async function setLastTestResult(ctx, result) {
+	await ctx.kv.set(LAST_TEST_RESULT_KEY, result);
+}
+function createDeliveryLogRecord(input) {
+	return {
+		...input,
+		createdAt: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+function createLogId(record) {
+	const base = record.createdAt.replace(/[^0-9]/g, "").slice(0, 14);
+	const random = Math.random().toString(36).slice(2, 10);
+	return `${base}-${record.providerId}-${random}`;
+}
+async function writeDeliveryLog(ctx, record) {
+	const collection = ctx.storage?.deliveryLogs;
+	if (!collection?.put) return;
+	const logLevel = (await getGlobalSettings(ctx)).logLevel ?? "all";
+	if (logLevel === "off") return;
+	if (logLevel === "errors" && record.status !== "failed") return;
+	const id = record.id ?? createLogId(record);
+	await collection.put(id, {
+		...record,
+		id
+	});
+}
+async function queryRecentDeliveryLogs(ctx, limit = 25) {
+	const collection = ctx.storage?.deliveryLogs;
+	if (!collection?.query) return [];
+	return (await collection.query({
+		orderBy: { createdAt: "desc" },
+		limit
+	})).items ?? [];
+}
+async function countDeliveryLogs(ctx, status) {
+	const collection = ctx.storage?.deliveryLogs;
+	if (collection?.count) return collection.count({ status });
+	if (!collection?.query) return 0;
+	return (await collection.query({
+		where: { status },
+		limit: 1e3
+	})).items.length;
+}
+
+//#endregion
+//#region src/providers.ts
+function unique(values) {
+	return [...new Set(values.filter(Boolean))].sort();
+}
+function stringValue$1(settings, key) {
+	const value = settings[key];
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed === "" ? void 0 : trimmed;
+}
+function numberValue$1(settings, key, fallback) {
+	const value = settings[key];
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+	return fallback;
+}
+function requireString(settings, key, label) {
+	const value = stringValue$1(settings, key);
+	if (!value) throw new Error(`${label} is required.`);
+	return value;
+}
+function sanitizeHeaderText(value) {
+	return value.replace(/[\r\n]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function sanitizeEmailAddress(value, label) {
+	const trimmed = value.trim();
+	if (!trimmed) throw new Error(`${label} is required.`);
+	if (/[\r\n]/.test(trimmed)) throw new Error(`${label} contains invalid newline characters.`);
+	return trimmed;
+}
+function encodeHeaderValue(value) {
+	const sanitized = sanitizeHeaderText(value);
+	if (/^[\x20-\x7E]*$/.test(sanitized) && !/[",]/.test(sanitized)) return sanitized;
+	return `=?UTF-8?B?${toBase64(new TextEncoder().encode(sanitized))}?=`;
+}
+function formatAddress(email, name) {
+	const safeEmail = sanitizeEmailAddress(email, "Email address");
+	const safeName = name ? encodeHeaderValue(name) : void 0;
+	return safeName ? `${safeName} <${safeEmail}>` : safeEmail;
+}
+function ensureFetch(runtime) {
+	if (!runtime.fetch) throw new Error("This provider requires network fetch support in the current runtime.");
+	return runtime.fetch;
+}
+function ensureSmtp(runtime) {
+	if (!runtime.smtpSend) throw new Error("Custom SMTP is only available in the trusted package.");
+	return runtime.smtpSend;
+}
+function ensureSendmail(runtime) {
+	if (!runtime.sendmailSend) throw new Error("Local sendmail is only available in the trusted package.");
+	return runtime.sendmailSend;
+}
+async function readResponse(response) {
+	const text = await response.text();
+	try {
+		return {
+			text,
+			json: text ? JSON.parse(text) : void 0
+		};
+	} catch {
+		return { text };
+	}
+}
+function asRecord(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function asArray(value) {
+	return Array.isArray(value) ? value : void 0;
+}
+function asString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function getPath(value, ...path) {
+	let current = value;
+	for (const segment of path) {
+		if (typeof segment === "number") {
+			const items = asArray(current);
+			if (!items) return void 0;
+			current = items[segment];
+			continue;
+		}
+		const record = asRecord(current);
+		if (!record) return void 0;
+		current = record[segment];
+	}
+	return current;
+}
+var HttpError = class extends Error {
+	status;
+	bodyText;
+	bodyJson;
+	constructor(status, bodyText, bodyJson) {
+		super(bodyText || `HTTP ${status}`);
+		this.name = "HttpError";
+		this.status = status;
+		this.bodyText = bodyText;
+		this.bodyJson = bodyJson;
+	}
+};
+function hasAllSettings(settings, keys) {
+	return keys.every((key) => Boolean(stringValue$1(settings, key)));
+}
+function shouldRetryAfterRefresh(error) {
+	return error instanceof HttpError && (error.status === 401 || error.status === 403);
+}
+async function refreshProviderAccessToken(args, tokenUrl, body, label) {
+	const { json } = await requestJson({
+		url: tokenUrl,
+		runtime: args.runtime,
+		ok: [200],
+		init: {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/x-www-form-urlencoded"
+			},
+			body: body.toString()
+		}
+	});
+	const accessToken = asString(getPath(json, "access_token"));
+	if (!accessToken) throw new Error(`${label} refresh did not return an access token.`);
+	const refreshToken = asString(getPath(json, "refresh_token"));
+	await patchProviderSettings(args.ctx, args.providerId, {
+		accessToken,
+		...refreshToken ? { refreshToken } : {}
+	});
+	return accessToken;
+}
+async function requestJson(opts) {
+	const response = await ensureFetch(opts.runtime)(opts.url, opts.init);
+	const result = await readResponse(response);
+	if (!(opts.ok ?? [
+		200,
+		201,
+		202
+	]).includes(response.status)) throw new HttpError(response.status, result.text || `HTTP ${response.status}`, result.json);
+	return {
+		response,
+		...result
+	};
+}
+function toBase64(bytes) {
+	if (typeof Buffer !== "undefined") return Buffer.from(bytes).toString("base64");
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary);
+}
+function toBase64Url(text) {
+	return toBase64(new TextEncoder().encode(text)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function toHex(bytes) {
+	return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sha256Hex(payload) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(payload));
+	return toHex(new Uint8Array(digest));
+}
+async function hmacSha256Raw(key, data) {
+	const rawKey = typeof key === "string" ? new TextEncoder().encode(key) : Uint8Array.from(key);
+	const imported = await crypto.subtle.importKey("raw", rawKey.buffer, {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	const signature = await crypto.subtle.sign("HMAC", imported, new TextEncoder().encode(data));
+	return new Uint8Array(signature);
+}
+function stripHtml$1(html) {
+	return html.replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+function buildMimeMessage(message) {
+	const from = formatAddress(message.fromEmail || "", message.fromName);
+	const to = message.to.map((email) => sanitizeEmailAddress(email, "Recipient email address")).join(", ");
+	const replyTo = message.replyTo?.length ? message.replyTo.map((email) => sanitizeEmailAddress(email, "Reply-to email address")).join(", ") : void 0;
+	const subject = encodeHeaderValue(message.subject);
+	const headers = [
+		`From: ${from}`,
+		`To: ${to}`,
+		`Subject: ${subject}`,
+		...replyTo ? [`Reply-To: ${replyTo}`] : [],
+		"MIME-Version: 1.0"
+	];
+	if (message.html) {
+		const boundary = `emdash-${Math.random().toString(36).slice(2, 12)}`;
+		return [
+			...headers,
+			`Content-Type: multipart/alternative; boundary="${boundary}"`,
+			"",
+			`--${boundary}`,
+			"Content-Type: text/plain; charset=\"UTF-8\"",
+			"",
+			message.text,
+			"",
+			`--${boundary}`,
+			"Content-Type: text/html; charset=\"UTF-8\"",
+			"",
+			message.html,
+			"",
+			`--${boundary}--`,
+			""
+		].join("\r\n");
+	}
+	return [
+		...headers,
+		"Content-Type: text/plain; charset=\"UTF-8\"",
+		"",
+		message.text,
+		""
+	].join("\r\n");
+}
+async function signAwsRequest(opts) {
+	const amzDate = (/* @__PURE__ */ new Date()).toISOString().replace(/[:-]|\.\d{3}/g, "");
+	const dateStamp = amzDate.slice(0, 8);
+	const service = "ses";
+	const payloadHash = await sha256Hex(opts.payload);
+	const baseHeaders = {
+		"content-type": "application/x-www-form-urlencoded; charset=utf-8",
+		"host": opts.url.host,
+		"x-amz-content-sha256": payloadHash,
+		"x-amz-date": amzDate,
+		...opts.headers ?? {}
+	};
+	const sortedHeaderKeys = Object.keys(baseHeaders).sort();
+	const canonicalHeaders = sortedHeaderKeys.map((key) => `${key}:${(baseHeaders[key] ?? "").trim()}\n`).join("");
+	const signedHeaders = sortedHeaderKeys.join(";");
+	const canonicalRequest = [
+		opts.method,
+		opts.url.pathname || "/",
+		opts.url.search.startsWith("?") ? opts.url.search.slice(1) : opts.url.search,
+		canonicalHeaders,
+		signedHeaders,
+		payloadHash
+	].join("\n");
+	const credentialScope = `${dateStamp}/${opts.region}/${service}/aws4_request`;
+	const stringToSign = [
+		"AWS4-HMAC-SHA256",
+		amzDate,
+		credentialScope,
+		await sha256Hex(canonicalRequest)
+	].join("\n");
+	const signature = toHex(await hmacSha256Raw(await hmacSha256Raw(await hmacSha256Raw(await hmacSha256Raw(await hmacSha256Raw(`AWS4${opts.secretAccessKey}`, dateStamp), opts.region), service), "aws4_request"), stringToSign));
+	return {
+		...baseHeaders,
+		Authorization: `AWS4-HMAC-SHA256 Credential=${opts.accessKeyId}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`
+	};
+}
+function getMessageText(message) {
+	return message.text || (message.html ? stripHtml$1(message.html) : "");
+}
+async function sendViaAmazon(args) {
+	const accessKeyId = requireString(args.settings, "accessKeyId", "Access Key ID");
+	const secretAccessKey = requireString(args.settings, "secretAccessKey", "Secret Access Key");
+	const region = requireString(args.settings, "region", "Region");
+	const payload = new URLSearchParams({
+		Action: "SendRawEmail",
+		Version: "2010-12-01",
+		"RawMessage.Data": toBase64(new TextEncoder().encode(buildMimeMessage(args.message)))
+	}).toString();
+	const url = new URL(`https://email.${region}.amazonaws.com/`);
+	const headers = await signAwsRequest({
+		accessKeyId,
+		secretAccessKey,
+		region,
+		url,
+		method: "POST",
+		payload
+	});
+	const { text } = await requestJson({
+		url: url.toString(),
+		runtime: args.runtime,
+		ok: [200],
+		init: {
+			method: "POST",
+			headers,
+			body: payload
+		}
+	});
+	return { remoteMessageId: text.match(/<MessageId>([^<]+)<\/MessageId>/i)?.[1] };
+}
+async function sendViaBrevo(args) {
+	const apiKey = requireString(args.settings, "apiKey", "API Key");
+	const body = {
+		sender: {
+			email: args.message.fromEmail,
+			...args.message.fromName ? { name: args.message.fromName } : {}
+		},
+		to: args.message.to.map((email) => ({ email })),
+		subject: args.message.subject,
+		...args.message.html ? { htmlContent: args.message.html } : { textContent: args.message.text },
+		...args.message.replyTo?.[0] ? { replyTo: { email: args.message.replyTo[0] } } : {}
+	};
+	const { json } = await requestJson({
+		url: "https://api.brevo.com/v3/smtp/email",
+		runtime: args.runtime,
+		init: {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/json",
+				"api-key": apiKey
+			},
+			body: JSON.stringify(body)
+		}
+	});
+	return { remoteMessageId: asString(asRecord(json)?.messageId) };
+}
+async function sendViaElasticEmail(args) {
+	const apiKey = requireString(args.settings, "apiKey", "API Key");
+	const body = {
+		Recipients: { To: [...args.message.to] },
+		Content: {
+			From: formatAddress(args.message.fromEmail || "", args.message.fromName),
+			Subject: args.message.subject,
+			Body: [{
+				Charset: "utf-8",
+				Content: args.message.html || args.message.text,
+				ContentType: args.message.html ? "HTML" : "PlainText"
+			}],
+			...args.message.replyTo?.[0] ? { ReplyTo: args.message.replyTo[0] } : {}
+		}
+	};
+	const { json } = await requestJson({
+		url: "https://api.elasticemail.com/v4/emails/transactional",
+		runtime: args.runtime,
+		init: {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/json",
+				"X-ElasticEmail-ApiKey": apiKey
+			},
+			body: JSON.stringify(body)
+		}
+	});
+	const record = asRecord(json);
+	return { remoteMessageId: asString(record?.TransactionID) ?? asString(record?.MessageID) };
+}
+async function sendViaEmailit(args) {
+	const apiKey = requireString(args.settings, "apiKey", "API Key");
+	const body = {
+		to: args.message.to.join(", "),
+		from: formatAddress(args.message.fromEmail || "", args.message.fromName),
+		subject: args.message.subject,
+		headers: { ...args.message.replyTo?.[0] ? { "reply-to": args.message.replyTo[0] } : {} },
+		...args.message.html ? {
+			html: args.message.html,
+			text: getMessageText(args.message)
+		} : { text: args.message.text }
+	};
+	const { json } = await requestJson({
+		url: "https://api.emailit.com/v1/emails",
+		runtime: args.runtime,
+		init: {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			},
+			body: JSON.stringify(body)
+		}
+	});
+	const record = asRecord(json);
+	return { remoteMessageId: asString(record?.id) ?? asString(record?.message_id) };
+}
+async function sendViaGenericSmtp(args) {
+	return ensureSmtp(args.runtime)({
+		host: requireString(args.settings, "host", "SMTP Hostname"),
+		port: numberValue$1(args.settings, "port", 587) ?? 587,
+		secure: (stringValue$1(args.settings, "security") ?? "starttls") === "ssl",
+		username: stringValue$1(args.settings, "username"),
+		password: stringValue$1(args.settings, "password")
+	}, args.message);
+}
+async function resolveGoogleAccessToken(args, forceRefresh = false) {
+	const storedAccessToken = forceRefresh ? void 0 : stringValue$1(args.settings, "accessToken");
+	if (storedAccessToken) return storedAccessToken;
+	if (!hasAllSettings(args.settings, [
+		"clientId",
+		"clientSecret",
+		"refreshToken"
+	])) throw new Error("Google requires an access token or client ID, client secret, and refresh token.");
+	return refreshProviderAccessToken(args, "https://oauth2.googleapis.com/token", new URLSearchParams({
+		client_id: requireString(args.settings, "clientId", "Client ID"),
+		client_secret: requireString(args.settings, "clientSecret", "Client Secret"),
+		refresh_token: requireString(args.settings, "refreshToken", "Refresh Token"),
+		grant_type: "refresh_token"
+	}), "Google");
+}
+async function resolveMicrosoftAccessToken(args, forceRefresh = false) {
+	const storedAccessToken = forceRefresh ? void 0 : stringValue$1(args.settings, "accessToken");
+	if (storedAccessToken) return storedAccessToken;
+	if (!hasAllSettings(args.settings, [
+		"clientId",
+		"clientSecret",
+		"refreshToken"
+	])) throw new Error("Microsoft requires an access token or application ID, client secret, and refresh token.");
+	return refreshProviderAccessToken(args, `https://login.microsoftonline.com/${stringValue$1(args.settings, "tenantId") ?? "common"}/oauth2/v2.0/token`, new URLSearchParams({
+		client_id: requireString(args.settings, "clientId", "Application ID"),
+		client_secret: requireString(args.settings, "clientSecret", "Client Secret"),
+		refresh_token: requireString(args.settings, "refreshToken", "Refresh Token"),
+		grant_type: "refresh_token",
+		scope: "email Mail.Send User.Read profile openid offline_access"
+	}), "Microsoft");
+}
+async function resolveZohoAccessToken(args, forceRefresh = false) {
+	const storedAccessToken = forceRefresh ? void 0 : stringValue$1(args.settings, "accessToken");
+	if (storedAccessToken) return storedAccessToken;
+	if (!hasAllSettings(args.settings, [
+		"clientId",
+		"clientSecret",
+		"refreshToken"
+	])) throw new Error("Zoho requires an access token or client ID, client secret, and refresh token.");
+	const body = new URLSearchParams({
+		client_id: requireString(args.settings, "clientId", "Client ID"),
+		client_secret: requireString(args.settings, "clientSecret", "Client Secret"),
+		refresh_token: requireString(args.settings, "refreshToken", "Refresh Token"),
+		grant_type: "refresh_token"
+	});
+	const redirectUri = stringValue$1(args.settings, "redirectUri");
+	if (redirectUri) body.set("redirect_uri", redirectUri);
+	return refreshProviderAccessToken(args, "https://accounts.zoho.com/oauth/v2/token", body, "Zoho");
+}
+async function sendViaGoogle(args) {
+	const raw = toBase64Url(buildMimeMessage(args.message));
+	const sendRequest = async (accessToken) => {
+		const { json } = await requestJson({
+			url: "https://gmail.googleapis.com/gmail/v1/users/me/messages/send",
+			runtime: args.runtime,
+			init: {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${accessToken}`,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify({ raw })
+			},
+			ok: [200]
+		});
+		return { remoteMessageId: asString(asRecord(json)?.id) };
+	};
+	const canRefresh = hasAllSettings(args.settings, [
+		"clientId",
+		"clientSecret",
+		"refreshToken"
+	]);
+	try {
+		return await sendRequest(await resolveGoogleAccessToken(args));
+	} catch (error) {
+		if (!canRefresh || !shouldRetryAfterRefresh(error)) throw error;
+		return sendRequest(await resolveGoogleAccessToken(args, true));
+	}
+}
+async function sendViaMailchimp(args) {
+	const body = {
+		key: requireString(args.settings, "apiKey", "API Key"),
+		message: {
+			subject: args.message.subject,
+			from_email: args.message.fromEmail,
+			...args.message.fromName ? { from_name: args.message.fromName } : {},
+			to: args.message.to.map((email) => ({
+				email,
+				type: "to"
+			})),
+			...args.message.html ? {
+				html: args.message.html,
+				text: getMessageText(args.message)
+			} : { text: args.message.text },
+			...args.message.replyTo?.[0] ? { headers: { "reply-to": args.message.replyTo[0] } } : {}
+		}
+	};
+	const { json } = await requestJson({
+		url: "https://mandrillapp.com/api/1.0/messages/send",
+		runtime: args.runtime,
+		init: {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		}
+	});
+	const record = asRecord(Array.isArray(json) ? json[0] : json);
+	return { remoteMessageId: asString(record?._id) ?? asString(record?.id) };
+}
+async function sendViaMailerSend(args) {
+	const apiKey = requireString(args.settings, "apiKey", "API Key");
+	const body = {
+		subject: args.message.subject,
+		from: {
+			email: args.message.fromEmail,
+			...args.message.fromName ? { name: args.message.fromName } : {}
+		},
+		to: args.message.to.map((email) => ({ email })),
+		...args.message.html ? { html: args.message.html } : { text: args.message.text },
+		...args.message.replyTo?.[0] ? { reply_to: { email: args.message.replyTo[0] } } : {}
+	};
+	const { json } = await requestJson({
+		url: "https://api.mailersend.com/v1/email",
+		runtime: args.runtime,
+		init: {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			},
+			body: JSON.stringify(body)
+		}
+	});
+	const record = asRecord(json);
+	return { remoteMessageId: asString(record?.message_id) ?? asString(record?.id) };
+}
+async function sendViaMailgun(args) {
+	const apiKey = requireString(args.settings, "apiKey", "Mailgun API Key");
+	const domain = requireString(args.settings, "domain", "Sending Domain");
+	const base = (stringValue$1(args.settings, "region") ?? "us") === "eu" ? "https://api.eu.mailgun.net/v3" : "https://api.mailgun.net/v3";
+	const body = new URLSearchParams({
+		from: formatAddress(args.message.fromEmail || "", args.message.fromName),
+		to: args.message.to.join(", "),
+		subject: args.message.subject,
+		...args.message.html ? { html: args.message.html } : {},
+		text: getMessageText(args.message)
+	});
+	if (args.message.replyTo?.[0]) body.set("h:Reply-To", args.message.replyTo[0]);
+	const basic = toBase64(new TextEncoder().encode(`api:${apiKey}`));
+	const { json } = await requestJson({
+		url: `${base}/${domain}/messages`,
+		runtime: args.runtime,
+		init: {
+			method: "POST",
+			headers: { Authorization: `Basic ${basic}` },
+			body
+		},
+		ok: [200]
+	});
+	return { remoteMessageId: asString(asRecord(json)?.id) };
+}
+async function sendViaMailjet(args) {
+	const apiKey = requireString(args.settings, "apiKey", "API Key");
+	const apiSecret = requireString(args.settings, "apiSecret", "API Secret Key");
+	const body = { Messages: [{
+		To: args.message.to.map((email) => ({ Email: email })),
+		From: {
+			Email: args.message.fromEmail,
+			...args.message.fromName ? { Name: args.message.fromName } : {}
+		},
+		Subject: args.message.subject,
+		...args.message.html ? {
+			HTMLPart: args.message.html,
+			TextPart: getMessageText(args.message)
+		} : { TextPart: args.message.text },
+		...args.message.replyTo?.[0] ? { Headers: { "Reply-To": args.message.replyTo[0] } } : {}
+	}] };
+	const basic = toBase64(new TextEncoder().encode(`${apiKey}:${apiSecret}`));
+	const { json } = await requestJson({
+		url: "https://api.mailjet.com/v3.1/send",
+		runtime: args.runtime,
+		init: {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/json",
+				Authorization: `Basic ${basic}`
+			},
+			body: JSON.stringify(body)
+		}
+	});
+	return { remoteMessageId: asString(getPath(asRecord(json), "Messages", 0, "To", 0, "MessageUUID")) };
+}
+async function sendViaMicrosoft(args) {
+	const sendRequest = async (accessToken) => {
+		await requestJson({
+			url: "https://graph.microsoft.com/v1.0/me/sendMail",
+			runtime: args.runtime,
+			ok: [202],
+			init: {
+				method: "POST",
+				headers: {
+					Authorization: `Bearer ${accessToken}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify({
+					message: {
+						subject: args.message.subject,
+						body: {
+							contentType: args.message.html ? "HTML" : "Text",
+							content: args.message.html || args.message.text
+						},
+						toRecipients: args.message.to.map((email) => ({ emailAddress: { address: email } })),
+						...args.message.replyTo?.[0] ? { replyTo: [{ emailAddress: { address: args.message.replyTo[0] } }] } : {}
+					},
+					saveToSentItems: false
+				})
+			}
+		});
+		return {};
+	};
+	const canRefresh = hasAllSettings(args.settings, [
+		"clientId",
+		"clientSecret",
+		"refreshToken"
+	]);
+	try {
+		return await sendRequest(await resolveMicrosoftAccessToken(args));
+	} catch (error) {
+		if (!canRefresh || !shouldRetryAfterRefresh(error)) throw error;
+		return sendRequest(await resolveMicrosoftAccessToken(args, true));
+	}
+}
+async function sendViaPhpMail(args) {
+	return ensureSendmail(args.runtime)({
+		sendmailPath: stringValue$1(args.settings, "sendmailPath") ?? "sendmail",
+		fromEmail: args.message.fromEmail || "",
+		fromName: args.message.fromName
+	}, args.message);
+}
+async function sendViaPostmark(args) {
+	const serverApiToken = requireString(args.settings, "serverApiToken", "Server API Token");
+	const body = {
+		from: formatAddress(args.message.fromEmail || "", args.message.fromName),
+		to: args.message.to.join(","),
+		subject: args.message.subject,
+		textBody: getMessageText(args.message),
+		...args.message.html ? { htmlBody: args.message.html } : {},
+		...args.message.replyTo?.[0] ? { ReplyTo: args.message.replyTo[0] } : {}
+	};
+	const { json } = await requestJson({
+		url: "https://api.postmarkapp.com/email",
+		runtime: args.runtime,
+		ok: [200],
+		init: {
+			method: "POST",
+			headers: {
+				Accept: "application/json",
+				"Content-Type": "application/json",
+				"X-Postmark-Server-Token": serverApiToken
+			},
+			body: JSON.stringify(body)
+		}
+	});
+	return { remoteMessageId: asString(asRecord(json)?.MessageID) };
+}
+async function sendViaResend(args) {
+	const apiKey = requireString(args.settings, "apiKey", "API Key");
+	const body = {
+		to: [...args.message.to],
+		from: formatAddress(args.message.fromEmail || "", args.message.fromName),
+		subject: args.message.subject,
+		...args.message.html ? {
+			html: args.message.html,
+			text: getMessageText(args.message)
+		} : { text: args.message.text },
+		...args.message.replyTo?.[0] ? { reply_to: args.message.replyTo[0] } : {}
+	};
+	const { json } = await requestJson({
+		url: "https://api.resend.com/emails",
+		runtime: args.runtime,
+		init: {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/json",
+				Authorization: `Bearer ${apiKey}`
+			},
+			body: JSON.stringify(body)
+		}
+	});
+	return { remoteMessageId: asString(asRecord(json)?.id) };
+}
+async function sendViaSendgrid(args) {
+	const apiKey = requireString(args.settings, "apiKey", "SendGrid API Key");
+	await requestJson({
+		url: "https://api.sendgrid.com/v3/mail/send",
+		runtime: args.runtime,
+		ok: [202],
+		init: {
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${apiKey}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({
+				from: {
+					email: args.message.fromEmail,
+					...args.message.fromName ? { name: args.message.fromName } : {}
+				},
+				personalizations: [{ to: args.message.to.map((email) => ({ email })) }],
+				subject: args.message.subject,
+				content: [{
+					type: args.message.html ? "text/html" : "text/plain",
+					value: args.message.html || args.message.text
+				}],
+				...args.message.replyTo?.length ? { reply_to_list: args.message.replyTo.map((email) => ({ email })) } : {}
+			})
+		}
+	});
+	return {};
+}
+async function sendViaSmtp2go(args) {
+	const apiKey = requireString(args.settings, "apiKey", "API Key");
+	const body = {
+		sender: formatAddress(args.message.fromEmail || "", args.message.fromName),
+		subject: args.message.subject,
+		to: [...args.message.to],
+		...args.message.html ? { html_body: args.message.html } : { text_body: args.message.text }
+	};
+	if (args.message.replyTo?.[0]) body.custom_headers = [{
+		header: "Reply-To",
+		value: args.message.replyTo[0]
+	}];
+	const { json } = await requestJson({
+		url: "https://api.smtp2go.com/v3/email/send",
+		runtime: args.runtime,
+		init: {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/json",
+				"X-Smtp2go-Api-Key": apiKey
+			},
+			body: JSON.stringify(body)
+		}
+	});
+	const record = asRecord(json);
+	return { remoteMessageId: asString(getPath(record, "data", "email_id")) ?? asString(record?.request_id) };
+}
+async function sendViaSparkpost(args) {
+	const apiKey = requireString(args.settings, "apiKey", "API Key");
+	const base = (stringValue$1(args.settings, "accountLocation") ?? "us") === "eu" ? "https://api.eu.sparkpost.com/api/v1" : "https://api.sparkpost.com/api/v1";
+	const body = {
+		recipients: args.message.to.map((email) => ({ address: { email } })),
+		content: {
+			from: {
+				email: args.message.fromEmail,
+				...args.message.fromName ? { name: args.message.fromName } : {}
+			},
+			subject: args.message.subject,
+			...args.message.html ? { html: args.message.html } : { text: args.message.text },
+			...args.message.replyTo?.[0] ? { reply_to: args.message.replyTo[0] } : {}
+		},
+		options: { transactional: true }
+	};
+	const { json } = await requestJson({
+		url: `${base}/transmissions/`,
+		runtime: args.runtime,
+		init: {
+			method: "POST",
+			headers: {
+				accept: "application/json",
+				"content-type": "application/json",
+				Authorization: apiKey
+			},
+			body: JSON.stringify(body)
+		}
+	});
+	return { remoteMessageId: asString(getPath(asRecord(json), "results", "id")) };
+}
+function getZohoBaseUrl(region) {
+	switch (region) {
+		case "eu": return "https://mail.zoho.eu";
+		case "in": return "https://mail.zoho.in";
+		case "com.au": return "https://mail.zoho.com.au";
+		case "jp": return "https://mail.zoho.jp";
+		case "sa": return "https://mail.zoho.sa";
+		case "ca": return "https://mail.zohocloud.ca";
+		default: return "https://mail.zoho.com";
+	}
+}
+async function sendViaZoho(args) {
+	const accountId = requireString(args.settings, "accountId", "Account ID");
+	const region = stringValue$1(args.settings, "dataCenterRegion") ?? "us";
+	const body = {
+		fromAddress: args.message.fromEmail,
+		toAddress: args.message.to.join(","),
+		subject: args.message.subject,
+		content: args.message.html || args.message.text,
+		encoding: "UTF-8",
+		mailFormat: args.message.html ? "html" : "plaintext",
+		...args.message.replyTo?.[0] ? { replyToAddress: args.message.replyTo[0] } : {}
+	};
+	const sendRequest = async (accessToken) => {
+		const { json } = await requestJson({
+			url: `${getZohoBaseUrl(region)}/api/accounts/${accountId}/messages`,
+			runtime: args.runtime,
+			init: {
+				method: "POST",
+				headers: {
+					Authorization: `Zoho-oauthtoken ${accessToken}`,
+					"Content-Type": "application/json"
+				},
+				body: JSON.stringify(body)
+			}
+		});
+		const record = asRecord(json);
+		return { remoteMessageId: asString(getPath(record, "data", "messageId")) ?? asString(getPath(record, "data", "message_id")) };
+	};
+	const canRefresh = hasAllSettings(args.settings, [
+		"clientId",
+		"clientSecret",
+		"refreshToken"
+	]);
+	try {
+		return await sendRequest(await resolveZohoAccessToken(args));
+	} catch (error) {
+		if (!canRefresh || !shouldRetryAfterRefresh(error)) throw error;
+		return sendRequest(await resolveZohoAccessToken(args, true));
+	}
+}
+function option(label, value) {
+	return {
+		label,
+		value
+	};
+}
+function fields(...defs) {
+	return defs;
+}
+const SMTP_PROVIDER_DEFINITIONS = [
+	{
+		id: "amazon",
+		label: "Amazon SES",
+		description: "Amazon Simple Email Service using signed AWS API requests.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["*.amazonaws.com"],
+		fields: fields({
+			key: "accessKeyId",
+			label: "Access Key ID",
+			type: "secret",
+			required: true
+		}, {
+			key: "secretAccessKey",
+			label: "Secret Access Key",
+			type: "secret",
+			required: true
+		}, {
+			key: "region",
+			label: "Region",
+			type: "select",
+			required: true,
+			defaultValue: "us-east-1",
+			options: [
+				option("US East (N. Virginia)", "us-east-1"),
+				option("US East (Ohio)", "us-east-2"),
+				option("US West (N. California)", "us-west-1"),
+				option("US West (Oregon)", "us-west-2"),
+				option("Europe (Ireland)", "eu-west-1"),
+				option("Europe (Frankfurt)", "eu-central-1"),
+				option("Europe (London)", "eu-west-2"),
+				option("Asia Pacific (Sydney)", "ap-southeast-2"),
+				option("Asia Pacific (Singapore)", "ap-southeast-1")
+			]
+		}),
+		send: sendViaAmazon
+	},
+	{
+		id: "brevo",
+		label: "Brevo",
+		description: "Transactional email via the Brevo SMTP API.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.brevo.com"],
+		fields: fields({
+			key: "apiKey",
+			label: "API Key",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaBrevo
+	},
+	{
+		id: "elastic_email",
+		label: "Elastic Email",
+		description: "Transactional email via the Elastic Email v4 API.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.elasticemail.com"],
+		fields: fields({
+			key: "apiKey",
+			label: "API Key",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaElasticEmail
+	},
+	{
+		id: "emailit",
+		label: "Emailit",
+		description: "Transactional email via the Emailit API.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.emailit.com"],
+		fields: fields({
+			key: "apiKey",
+			label: "API Key",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaEmailit
+	},
+	{
+		id: "generic",
+		label: "Generic SMTP",
+		description: "Custom SMTP server using Nodemailer in the trusted package.",
+		availability: {
+			trusted: true,
+			marketplace: false
+		},
+		allowedHosts: [],
+		fields: fields({
+			key: "host",
+			label: "SMTP Hostname",
+			type: "text",
+			required: true,
+			placeholder: "smtp.example.com"
+		}, {
+			key: "port",
+			label: "SMTP Port",
+			type: "number",
+			required: true,
+			defaultValue: 587
+		}, {
+			key: "security",
+			label: "Encryption",
+			type: "select",
+			defaultValue: "starttls",
+			options: [
+				option("STARTTLS / Auto", "starttls"),
+				option("SSL/TLS", "ssl"),
+				option("None", "none")
+			]
+		}, {
+			key: "username",
+			label: "Authentication Username",
+			type: "text"
+		}, {
+			key: "password",
+			label: "Authentication Password",
+			type: "secret"
+		}),
+		send: sendViaGenericSmtp
+	},
+	{
+		id: "google",
+		label: "Google / Gmail",
+		description: "Gmail API delivery using an access token or refresh-token credentials.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["gmail.googleapis.com", "oauth2.googleapis.com"],
+		fields: fields({
+			key: "accessToken",
+			label: "Access Token",
+			type: "secret"
+		}, {
+			key: "refreshToken",
+			label: "Refresh Token",
+			type: "secret"
+		}, {
+			key: "clientId",
+			label: "Client ID",
+			type: "text"
+		}, {
+			key: "clientSecret",
+			label: "Client Secret",
+			type: "secret"
+		}),
+		isConfigured: (settings) => Boolean(stringValue$1(settings, "accessToken")) || hasAllSettings(settings, [
+			"clientId",
+			"clientSecret",
+			"refreshToken"
+		]),
+		send: sendViaGoogle
+	},
+	{
+		id: "mailchimp",
+		label: "Mailchimp Transactional",
+		description: "Mandrill/Mailchimp Transactional email delivery.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["mandrillapp.com"],
+		fields: fields({
+			key: "apiKey",
+			label: "API Key",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaMailchimp
+	},
+	{
+		id: "mailersend",
+		label: "MailerSend",
+		description: "Transactional email via the MailerSend API.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.mailersend.com"],
+		fields: fields({
+			key: "apiKey",
+			label: "API Key",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaMailerSend
+	},
+	{
+		id: "mailgun",
+		label: "Mailgun",
+		description: "Transactional email via the Mailgun Messages API.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.mailgun.net", "api.eu.mailgun.net"],
+		fields: fields({
+			key: "apiKey",
+			label: "Mailgun API Key",
+			type: "secret",
+			required: true
+		}, {
+			key: "domain",
+			label: "Sending Domain",
+			type: "text",
+			required: true,
+			placeholder: "mg.example.com"
+		}, {
+			key: "region",
+			label: "Region",
+			type: "select",
+			defaultValue: "us",
+			options: [option("US", "us"), option("EU", "eu")]
+		}),
+		send: sendViaMailgun
+	},
+	{
+		id: "mailjet",
+		label: "Mailjet",
+		description: "Transactional email via the Mailjet v3.1 API.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.mailjet.com"],
+		fields: fields({
+			key: "apiKey",
+			label: "API Key",
+			type: "secret",
+			required: true
+		}, {
+			key: "apiSecret",
+			label: "API Secret Key",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaMailjet
+	},
+	{
+		id: "microsoft",
+		label: "365 / Outlook",
+		description: "Microsoft Graph delivery using an access token or refresh-token credentials.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["graph.microsoft.com", "login.microsoftonline.com"],
+		fields: fields({
+			key: "accessToken",
+			label: "Access Token",
+			type: "secret"
+		}, {
+			key: "refreshToken",
+			label: "Refresh Token",
+			type: "secret"
+		}, {
+			key: "clientId",
+			label: "Application ID",
+			type: "text"
+		}, {
+			key: "clientSecret",
+			label: "Client Secret",
+			type: "secret"
+		}, {
+			key: "tenantId",
+			label: "Tenant ID",
+			type: "text",
+			defaultValue: "common",
+			placeholder: "common"
+		}),
+		isConfigured: (settings) => Boolean(stringValue$1(settings, "accessToken")) || hasAllSettings(settings, [
+			"clientId",
+			"clientSecret",
+			"refreshToken"
+		]),
+		send: sendViaMicrosoft
+	},
+	{
+		id: "phpmail",
+		label: "PHP Mail / local sendmail",
+		description: "Local sendmail transport for trusted installs.",
+		availability: {
+			trusted: true,
+			marketplace: false
+		},
+		allowedHosts: [],
+		fields: fields({
+			key: "sendmailPath",
+			label: "Sendmail Path",
+			type: "text",
+			defaultValue: "sendmail"
+		}),
+		send: sendViaPhpMail
+	},
+	{
+		id: "postmark",
+		label: "Postmark",
+		description: "Transactional email via the Postmark send email endpoint.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.postmarkapp.com"],
+		fields: fields({
+			key: "serverApiToken",
+			label: "Server API Token",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaPostmark
+	},
+	{
+		id: "resend",
+		label: "Resend",
+		description: "Transactional email via the Resend API.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.resend.com"],
+		fields: fields({
+			key: "apiKey",
+			label: "API Key",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaResend
+	},
+	{
+		id: "sendgrid",
+		label: "SendGrid",
+		description: "Transactional email via Twilio SendGrid.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.sendgrid.com"],
+		fields: fields({
+			key: "apiKey",
+			label: "SendGrid API Key",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaSendgrid
+	},
+	{
+		id: "smtp2go",
+		label: "SMTP2GO",
+		description: "Transactional email via SMTP2GO's HTTP API.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.smtp2go.com"],
+		fields: fields({
+			key: "apiKey",
+			label: "API Key",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaSmtp2go
+	},
+	{
+		id: "sparkpost",
+		label: "SparkPost",
+		description: "Transactional email via the SparkPost Transmissions API.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: ["api.sparkpost.com", "api.eu.sparkpost.com"],
+		fields: fields({
+			key: "accountLocation",
+			label: "Account Location",
+			type: "select",
+			defaultValue: "us",
+			options: [option("United States", "us"), option("Europe", "eu")]
+		}, {
+			key: "apiKey",
+			label: "API Key",
+			type: "secret",
+			required: true
+		}),
+		send: sendViaSparkpost
+	},
+	{
+		id: "zoho",
+		label: "Zoho Mail",
+		description: "Zoho Mail API delivery using an access token or refresh-token credentials.",
+		availability: {
+			trusted: true,
+			marketplace: true
+		},
+		allowedHosts: [
+			"mail.zoho.com",
+			"mail.zoho.eu",
+			"mail.zoho.in",
+			"mail.zoho.com.au",
+			"mail.zoho.jp",
+			"mail.zoho.sa",
+			"mail.zohocloud.ca",
+			"accounts.zoho.com"
+		],
+		fields: fields({
+			key: "dataCenterRegion",
+			label: "Datacenter Region",
+			type: "select",
+			defaultValue: "us",
+			options: [
+				option("United States", "us"),
+				option("Europe", "eu"),
+				option("India", "in"),
+				option("Australia", "com.au"),
+				option("Japan", "jp"),
+				option("Saudi Arabia", "sa"),
+				option("Canada", "ca")
+			]
+		}, {
+			key: "clientId",
+			label: "Client ID",
+			type: "text"
+		}, {
+			key: "clientSecret",
+			label: "Client Secret",
+			type: "secret"
+		}, {
+			key: "refreshToken",
+			label: "Refresh Token",
+			type: "secret"
+		}, {
+			key: "accessToken",
+			label: "Access Token",
+			type: "secret"
+		}, {
+			key: "redirectUri",
+			label: "Redirect URI",
+			type: "text",
+			placeholder: "Optional unless required by your token setup"
+		}, {
+			key: "accountId",
+			label: "Account ID",
+			type: "text",
+			required: true
+		}),
+		isConfigured: (settings) => Boolean(stringValue$1(settings, "accountId")) && (Boolean(stringValue$1(settings, "accessToken")) || hasAllSettings(settings, [
+			"clientId",
+			"clientSecret",
+			"refreshToken"
+		])),
+		send: sendViaZoho
+	}
+];
+function getProviderById(providerId) {
+	return SMTP_PROVIDER_DEFINITIONS.find((provider) => provider.id === providerId);
+}
+function isProviderAvailable(provider, variant) {
+	return provider.availability[variant];
+}
+function isProviderConfigured(provider, settings) {
+	if (provider.isConfigured) return provider.isConfigured(settings);
+	return provider.fields.every((field) => {
+		if (!field.required) return true;
+		if (field.type === "number") return numberValue$1(settings, field.key) !== void 0;
+		if (field.type === "toggle") return settings[field.key] !== void 0;
+		return Boolean(stringValue$1(settings, field.key));
+	});
+}
+function getProviderLabel(providerId) {
+	if (!providerId) return "Not configured";
+	return getProviderById(providerId)?.label ?? providerId;
+}
+function getAvailableProviderSelectOptions(variant) {
+	return SMTP_PROVIDER_DEFINITIONS.filter((provider) => isProviderAvailable(provider, variant)).map((provider) => ({
+		label: provider.label,
+		value: provider.id
+	}));
+}
+function getProviderPickerOptions(variant) {
+	return SMTP_PROVIDER_DEFINITIONS.map((provider) => ({
+		label: isProviderAvailable(provider, variant) ? provider.label : `${provider.label} (trusted-only)`,
+		value: provider.id
+	}));
+}
+function collectAllowedHosts(variant) {
+	return unique(SMTP_PROVIDER_DEFINITIONS.filter((provider) => isProviderAvailable(provider, variant)).flatMap((provider) => provider.allowedHosts));
+}
+
+//#endregion
+//#region src/delivery.ts
+function trimmed(value) {
+	if (!value) return void 0;
+	const next = value.trim();
+	return next === "" ? void 0 : next;
+}
+function stripHtml(html) {
+	return html.replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeMessageInput(message, settings) {
+	const to = (Array.isArray(message.to) ? message.to : String(message.to).split(",")).map((entry) => entry.trim()).filter(Boolean);
+	if (to.length === 0) throw new Error("At least one recipient email address is required.");
+	const fromEmail = trimmed(settings.fromEmail);
+	if (!fromEmail) throw new Error("A default from email must be configured before sending.");
+	const text = trimmed(message.text) ?? (message.html ? stripHtml(message.html) : "");
+	if (!text && !trimmed(message.html)) throw new Error("A message body is required.");
+	return {
+		to,
+		subject: message.subject,
+		text,
+		html: trimmed(message.html),
+		fromEmail,
+		fromName: trimmed(settings.fromName),
+		replyTo: trimmed(settings.replyTo) ? [settings.replyTo.trim()] : void 0
+	};
+}
+async function resolvePrimaryProvider(ctx, runtime, settings) {
+	const preferred = settings.primaryProviderId ? getProviderById(settings.primaryProviderId) : void 0;
+	if (preferred && isProviderAvailable(preferred, runtime.variant)) {
+		const providerSettings = await getProviderSettings(ctx, preferred.id);
+		if (isProviderConfigured(preferred, providerSettings)) return {
+			provider: preferred,
+			providerSettings
+		};
+	}
+	for (const provider of SMTP_PROVIDER_DEFINITIONS) {
+		if (!isProviderAvailable(provider, runtime.variant)) continue;
+		const providerSettings = await getProviderSettings(ctx, provider.id);
+		if (isProviderConfigured(provider, providerSettings)) return {
+			provider,
+			providerSettings
+		};
+	}
+	const variantLabel = runtime.variant === "marketplace" ? "marketplace-compatible" : "trusted";
+	throw new Error(`No configured ${variantLabel} SMTP provider is available.`);
+}
+async function resolveFallbackProvider(ctx, runtime, settings, primaryProviderId) {
+	if (!settings.fallbackProviderId || settings.fallbackProviderId === primaryProviderId) return void 0;
+	const provider = getProviderById(settings.fallbackProviderId);
+	if (!provider || !isProviderAvailable(provider, runtime.variant)) return void 0;
+	const providerSettings = await getProviderSettings(ctx, provider.id);
+	if (!isProviderConfigured(provider, providerSettings)) return void 0;
+	return {
+		provider,
+		providerSettings
+	};
+}
+async function sendWithProvider(ctx, provider, providerSettings, message, runtime) {
+	const start = Date.now();
+	const result = await provider.send({
+		ctx,
+		providerId: provider.id,
+		settings: providerSettings,
+		message,
+		runtime
+	});
+	return {
+		providerId: provider.id,
+		remoteMessageId: result.remoteMessageId,
+		durationMs: Date.now() - start
+	};
+}
+async function deliverWithConfiguredProvider(args) {
+	const settings = await getGlobalSettings(args.ctx);
+	const normalizedMessage = normalizeMessageInput(args.message, settings);
+	const primary = await resolvePrimaryProvider(args.ctx, args.runtime, settings);
+	const fallback = await resolveFallbackProvider(args.ctx, args.runtime, settings, primary.provider.id);
+	try {
+		return await sendWithProvider(args.ctx, primary.provider, primary.providerSettings, normalizedMessage, args.runtime);
+	} catch (primaryError) {
+		if (!fallback) throw primaryError;
+		args.ctx.log?.warn("Primary SMTP provider failed, attempting fallback provider.", {
+			primaryProviderId: primary.provider.id,
+			fallbackProviderId: fallback.provider.id,
+			error: primaryError instanceof Error ? primaryError.message : String(primaryError)
+		});
+		return sendWithProvider(args.ctx, fallback.provider, fallback.providerSettings, normalizedMessage, args.runtime);
+	}
+}
+async function isDeliveryReady(args) {
+	const settings = await getGlobalSettings(args.ctx);
+	if (!trimmed(settings.fromEmail)) return false;
+	try {
+		await resolvePrimaryProvider(args.ctx, args.runtime, settings);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/admin.ts
+const SMTP_PLUGIN_ID = "emdash-smtp";
+const SMTP_PLUGIN_VERSION = "0.2.0";
+const SMTP_ADMIN_PAGES = [{
+	path: "/providers",
+	label: "SMTP Providers",
+	icon: "mail"
+}, {
+	path: "/logs",
+	label: "SMTP Logs",
+	icon: "activity"
+}];
+const SMTP_ADMIN_WIDGETS = [{
+	id: "smtp-overview",
+	title: "SMTP",
+	size: "third"
+}];
+function header(text) {
+	return {
+		type: "header",
+		text
+	};
+}
+function divider() {
+	return { type: "divider" };
+}
+function context(text) {
+	return {
+		type: "context",
+		text
+	};
+}
+function banner(title, description, variant = "default") {
+	return {
+		type: "banner",
+		title,
+		description,
+		variant
+	};
+}
+function stats(summary) {
+	return {
+		type: "stats",
+		items: [
+			{
+				label: "Active provider",
+				value: summary.activeProviderLabel
+			},
+			{
+				label: "Sent",
+				value: summary.sentCount,
+				trend: summary.sentCount > 0 ? "up" : "neutral"
+			},
+			{
+				label: "Failed",
+				value: summary.failedCount,
+				trend: summary.failedCount > 0 ? "down" : "neutral"
+			}
+		]
+	};
+}
+function actions(elements) {
+	return {
+		type: "actions",
+		elements
+	};
+}
+function button(actionId, label, opts) {
+	return {
+		type: "button",
+		action_id: actionId,
+		label,
+		...opts?.style ? { style: opts.style } : {},
+		...opts?.value !== void 0 ? { value: opts.value } : {},
+		...opts?.confirm ? { confirm: opts.confirm } : {}
+	};
+}
+function textField(field, value) {
+	return {
+		type: "text_input",
+		action_id: field.key,
+		label: field.label,
+		...field.placeholder ? { placeholder: field.placeholder } : {},
+		...value !== void 0 ? { initial_value: value } : {},
+		...field.type === "textarea" || field.multiline ? { multiline: true } : {}
+	};
+}
+function secretField(field, hasValue) {
+	return {
+		type: "secret_input",
+		action_id: field.key,
+		label: field.label,
+		...field.placeholder ? { placeholder: field.placeholder } : {},
+		has_value: hasValue
+	};
+}
+function numberField(field, value) {
+	return {
+		type: "number_input",
+		action_id: field.key,
+		label: field.label,
+		...value !== void 0 ? { initial_value: value } : {}
+	};
+}
+function selectField(field, value, overrideOptions) {
+	return {
+		type: "select",
+		action_id: field.key,
+		label: field.label,
+		options: overrideOptions ?? field.options ?? [],
+		...value !== void 0 ? { initial_value: value } : {}
+	};
+}
+function toggleField(field, value) {
+	return {
+		type: "toggle",
+		action_id: field.key,
+		label: field.label,
+		...field.description ? { description: field.description } : {},
+		...value !== void 0 ? { initial_value: value } : {}
+	};
+}
+function stringValue(value) {
+	if (typeof value !== "string") return void 0;
+	const next = value.trim();
+	return next === "" ? void 0 : next;
+}
+function numberValue(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const parsed = Number(value);
+		if (Number.isFinite(parsed)) return parsed;
+	}
+}
+function booleanValue(value) {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") return value === "true" || value === "1" || value === "on";
+	return Boolean(value);
+}
+async function buildSummary(ctx) {
+	const settings = await getGlobalSettings(ctx);
+	const sentCount = await countDeliveryLogs(ctx, "sent");
+	const failedCount = await countDeliveryLogs(ctx, "failed");
+	return {
+		activeProviderLabel: getProviderLabel(settings.primaryProviderId),
+		sentCount,
+		failedCount
+	};
+}
+async function getCurrentProvider(ctx, variant) {
+	const selected = await getSelectedProviderId(ctx);
+	const preferred = selected ? getProviderById(selected) : void 0;
+	if (preferred) return preferred;
+	return SMTP_PROVIDER_DEFINITIONS.find((provider) => isProviderAvailable(provider, variant)) ?? SMTP_PROVIDER_DEFINITIONS[0];
+}
+function buildGlobalSettingsForm(settings, variant) {
+	const availableOptions = getAvailableProviderSelectOptions(variant);
+	const logLevelOptions = [
+		{
+			label: "All deliveries",
+			value: "all"
+		},
+		{
+			label: "Errors only",
+			value: "errors"
+		},
+		{
+			label: "Disabled",
+			value: "off"
+		}
+	];
+	return {
+		type: "form",
+		block_id: "global-settings",
+		fields: [
+			selectField({
+				key: "primaryProviderId",
+				label: "Primary Provider",
+				type: "select",
+				options: availableOptions
+			}, settings.primaryProviderId, availableOptions),
+			selectField({
+				key: "fallbackProviderId",
+				label: "Fallback Provider",
+				type: "select",
+				options: [{
+					label: "None",
+					value: ""
+				}, ...availableOptions]
+			}, settings.fallbackProviderId, [{
+				label: "None",
+				value: ""
+			}, ...availableOptions]),
+			textField({
+				key: "fromEmail",
+				label: "Default From Email",
+				type: "text",
+				required: true,
+				placeholder: "noreply@example.com"
+			}, settings.fromEmail),
+			textField({
+				key: "fromName",
+				label: "Default From Name",
+				type: "text",
+				placeholder: "Example Site"
+			}, settings.fromName),
+			textField({
+				key: "replyTo",
+				label: "Default Reply-To Email",
+				type: "text",
+				placeholder: "support@example.com"
+			}, settings.replyTo),
+			selectField({
+				key: "logLevel",
+				label: "Log Level",
+				type: "select",
+				options: logLevelOptions
+			}, settings.logLevel ?? "all", logLevelOptions)
+		],
+		submit: {
+			label: "Save Global Settings",
+			action_id: "save_global"
+		}
+	};
+}
+function buildProviderPickerForm(providerId, variant) {
+	const options = getProviderPickerOptions(variant);
+	return {
+		type: "form",
+		block_id: "provider-picker",
+		fields: [selectField({
+			key: "providerId",
+			label: "Provider",
+			type: "select",
+			options
+		}, providerId, options)],
+		submit: {
+			label: "Load Provider",
+			action_id: "select_provider"
+		}
+	};
+}
+function buildProviderDetails(provider, variant, configured) {
+	const available = isProviderAvailable(provider, variant);
+	return [{
+		type: "fields",
+		fields: [
+			{
+				label: "Provider",
+				value: provider.label
+			},
+			{
+				label: "Availability",
+				value: available ? "Available" : "Trusted-only"
+			},
+			{
+				label: "Configured",
+				value: configured ? "Yes" : "No"
+			},
+			{
+				label: "Allowed Hosts",
+				value: provider.allowedHosts.length ? provider.allowedHosts.join(", ") : "None"
+			}
+		]
+	}, context(provider.description)];
+}
+function buildProviderSettingsForm(provider, settings) {
+	return {
+		type: "form",
+		block_id: "provider-settings",
+		fields: provider.fields.map((field) => {
+			if (field.type === "secret") return secretField(field, Boolean(stringValue(settings[field.key])));
+			if (field.type === "number") return numberField(field, numberValue(settings[field.key]) ?? (typeof field.defaultValue === "number" ? field.defaultValue : void 0));
+			if (field.type === "select") return selectField(field, stringValue(settings[field.key]) ?? (typeof field.defaultValue === "string" ? field.defaultValue : void 0));
+			if (field.type === "toggle") return toggleField(field, typeof settings[field.key] === "boolean" ? booleanValue(settings[field.key]) : typeof field.defaultValue === "boolean" ? field.defaultValue : void 0);
+			return textField(field, stringValue(settings[field.key]) ?? (typeof field.defaultValue === "string" ? field.defaultValue : void 0));
+		}),
+		submit: {
+			label: "Save Provider Settings",
+			action_id: "save_provider"
+		}
+	};
+}
+function buildProviderSecretActions(provider, settings) {
+	const elements = provider.fields.filter((field) => field.type === "secret" && Boolean(stringValue(settings[field.key]))).map((field) => button(`clear_secret:${provider.id}:${field.key}`, `Clear ${field.label}`, {
+		style: "danger",
+		confirm: {
+			title: `Clear ${field.label}?`,
+			text: `This will remove the stored ${field.label.toLowerCase()} from ${provider.label}.`,
+			confirm: "Clear",
+			deny: "Cancel",
+			style: "danger"
+		}
+	}));
+	return elements.length ? actions(elements) : null;
+}
+function buildTestSendForm(lastResult) {
+	const blocks = [{
+		type: "form",
+		block_id: "test-send",
+		fields: [
+			{
+				type: "text_input",
+				action_id: "to",
+				label: "Recipient Email",
+				placeholder: "you@example.com"
+			},
+			{
+				type: "text_input",
+				action_id: "subject",
+				label: "Subject",
+				initial_value: "EmDash SMTP test email"
+			},
+			{
+				type: "text_input",
+				action_id: "text",
+				label: "Message",
+				multiline: true,
+				initial_value: "This is a test email sent from EmDash SMTP."
+			}
+		],
+		submit: {
+			label: "Send Test Email",
+			action_id: "send_test"
+		}
+	}];
+	if (lastResult) blocks.push(banner(lastResult.status === "sent" ? "Last test succeeded" : "Last test failed", `${lastResult.createdAt}: ${lastResult.message}`, lastResult.status === "sent" ? "default" : "error"));
+	return blocks;
+}
+async function buildLogsTable(ctx) {
+	return {
+		type: "table",
+		page_action_id: "go_logs",
+		empty_text: "No delivery logs yet.",
+		columns: [
+			{
+				key: "createdAt",
+				label: "Created",
+				format: "relative_time",
+				sortable: true
+			},
+			{
+				key: "status",
+				label: "Status",
+				format: "badge"
+			},
+			{
+				key: "provider",
+				label: "Provider"
+			},
+			{
+				key: "to",
+				label: "To"
+			},
+			{
+				key: "subject",
+				label: "Subject"
+			},
+			{
+				key: "source",
+				label: "Source"
+			},
+			{
+				key: "details",
+				label: "Details",
+				format: "code"
+			}
+		],
+		rows: (await queryRecentDeliveryLogs(ctx, 25)).map(({ data }) => ({
+			createdAt: data.createdAt,
+			status: data.status,
+			provider: getProviderLabel(data.providerId),
+			to: data.message.to,
+			subject: data.message.subject,
+			source: data.source,
+			details: data.errorMessage ?? data.remoteMessageId ?? "—"
+		}))
+	};
+}
+async function buildProvidersPage(ctx, variant, runtime, toast) {
+	const summary = await buildSummary(ctx);
+	const settings = await getGlobalSettings(ctx);
+	const currentProvider = await getCurrentProvider(ctx, variant);
+	const currentProviderSettings = await getProviderSettings(ctx, currentProvider.id);
+	const configured = isProviderConfigured(currentProvider, currentProviderSettings);
+	const lastTestResult = await getLastTestResult(ctx);
+	const secretActions = buildProviderSecretActions(currentProvider, currentProviderSettings);
+	const providerRows = await Promise.all(SMTP_PROVIDER_DEFINITIONS.map(async (provider) => {
+		const providerSettings = await getProviderSettings(ctx, provider.id);
+		return {
+			provider: provider.label,
+			id: provider.id,
+			availability: isProviderAvailable(provider, variant) ? "available" : "trusted-only",
+			configured: isProviderConfigured(provider, providerSettings) ? "yes" : "no",
+			selected: provider.id === currentProvider.id ? "current" : ""
+		};
+	}));
+	const blocks = [
+		header("SMTP Providers"),
+		banner(variant === "marketplace" ? "Marketplace-safe variant" : "Trusted variant", variant === "marketplace" ? "This install can use HTTP API providers. Generic SMTP and local sendmail remain visible for parity but are not available here." : `This install can use all providers, including Generic SMTP and local sendmail. Allowed hosts: ${collectAllowedHosts("trusted").join(", ")}`, variant === "marketplace" ? "alert" : "default"),
+		stats(summary),
+		actions([button("go_providers", "Providers", { style: "secondary" }), button("go_logs", "View Logs", { style: "primary" })]),
+		{
+			type: "table",
+			page_action_id: "go_providers",
+			empty_text: "No providers available.",
+			columns: [
+				{
+					key: "provider",
+					label: "Provider"
+				},
+				{
+					key: "id",
+					label: "ID",
+					format: "code"
+				},
+				{
+					key: "availability",
+					label: "Availability",
+					format: "badge"
+				},
+				{
+					key: "configured",
+					label: "Configured",
+					format: "badge"
+				},
+				{
+					key: "selected",
+					label: "Selected",
+					format: "badge"
+				}
+			],
+			rows: providerRows
+		},
+		divider(),
+		buildProviderPickerForm(currentProvider.id, variant),
+		...buildProviderDetails(currentProvider, variant, configured),
+		buildGlobalSettingsForm(settings, variant)
+	];
+	if (!isProviderAvailable(currentProvider, variant)) blocks.push(banner(`${currentProvider.label} is not available in the marketplace variant`, "Use the trusted emdash-smtp package in astro.config.mjs if you need this transport.", "alert"));
+	else {
+		blocks.push(buildProviderSettingsForm(currentProvider, currentProviderSettings));
+		if (secretActions) blocks.push(secretActions);
+		blocks.push(...buildTestSendForm(lastTestResult));
+	}
+	return {
+		blocks,
+		...toast ? { toast } : {}
+	};
+}
+async function buildLogsPage(ctx, toast) {
+	const summary = await buildSummary(ctx);
+	return {
+		blocks: [
+			header("SMTP Logs"),
+			stats(summary),
+			actions([button("go_providers", "Providers", { style: "primary" }), button("go_logs", "Refresh Logs", { style: "secondary" })]),
+			await buildLogsTable(ctx)
+		],
+		...toast ? { toast } : {}
+	};
+}
+async function buildWidgetPage(ctx) {
+	return { blocks: [stats(await buildSummary(ctx)), context("EmDash SMTP monitors the active provider and recent delivery outcomes.")] };
+}
+async function handleAdminInteraction(args) {
+	const { ctx, interaction, variant, runtime } = args;
+	if (interaction.type === "page_load") {
+		if (interaction.page === "/logs") return buildLogsPage(ctx);
+		if (interaction.page === "widget:smtp-overview") return buildWidgetPage(ctx);
+		return buildProvidersPage(ctx, variant, runtime);
+	}
+	if (interaction.type === "block_action" || interaction.type === "action") {
+		if (interaction.action_id === "go_logs") return buildLogsPage(ctx);
+		if (interaction.action_id === "go_providers") return buildProvidersPage(ctx, variant, runtime);
+		if (interaction.action_id.startsWith("clear_secret:")) {
+			const [, providerId, fieldKey] = interaction.action_id.split(":");
+			if (providerId && fieldKey) {
+				await clearProviderSecret(ctx, providerId, fieldKey);
+				return buildProvidersPage(ctx, variant, runtime, {
+					message: `Cleared stored secret for ${fieldKey}.`,
+					type: "success"
+				});
+			}
+		}
+		return buildProvidersPage(ctx, variant, runtime);
+	}
+	if (interaction.type === "form_submit") {
+		if (interaction.action_id === "save_global") {
+			await saveGlobalSettingsFromValues(ctx, interaction.values);
+			return buildProvidersPage(ctx, variant, runtime, {
+				message: "Global SMTP settings saved.",
+				type: "success"
+			});
+		}
+		if (interaction.action_id === "select_provider") {
+			const providerId = stringValue(interaction.values.providerId);
+			if (providerId) await setSelectedProviderId(ctx, providerId);
+			return buildProvidersPage(ctx, variant, runtime, {
+				message: "Provider selection updated.",
+				type: "info"
+			});
+		}
+		if (interaction.action_id === "save_provider") {
+			const provider = await getCurrentProvider(ctx, variant);
+			await saveProviderSettingsFromValues(ctx, provider, interaction.values);
+			return buildProvidersPage(ctx, variant, runtime, {
+				message: `${provider.label} settings saved.`,
+				type: "success"
+			});
+		}
+		if (interaction.action_id === "send_test") {
+			const to = stringValue(interaction.values.to);
+			const subject = stringValue(interaction.values.subject) ?? "EmDash SMTP test email";
+			const text = stringValue(interaction.values.text) ?? "This is a test email sent from EmDash SMTP.";
+			if (!to) return buildProvidersPage(ctx, variant, runtime, {
+				message: "A recipient email address is required for test sends.",
+				type: "error"
+			});
+			try {
+				const result = await deliverWithConfiguredProvider({
+					ctx,
+					runtime,
+					message: {
+						to,
+						subject,
+						text
+					},
+					source: `${ctx.plugin.id}:test`
+				});
+				await writeDeliveryLog(ctx, createDeliveryLogRecord({
+					providerId: result.providerId,
+					status: "sent",
+					source: `${ctx.plugin.id}:test`,
+					durationMs: result.durationMs,
+					message: {
+						to,
+						subject
+					},
+					remoteMessageId: result.remoteMessageId
+				}));
+				await setLastTestResult(ctx, {
+					status: "sent",
+					providerId: result.providerId,
+					message: `Sent with ${getProviderLabel(result.providerId)}${result.remoteMessageId ? ` (${result.remoteMessageId})` : ""}.`,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
+				return buildProvidersPage(ctx, variant, runtime, {
+					message: `Test email sent with ${getProviderLabel(result.providerId)}.`,
+					type: "success"
+				});
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				await writeDeliveryLog(ctx, createDeliveryLogRecord({
+					providerId: "unknown",
+					status: "failed",
+					source: `${ctx.plugin.id}:test`,
+					durationMs: 0,
+					message: {
+						to,
+						subject
+					},
+					errorMessage: message
+				}));
+				await setLastTestResult(ctx, {
+					status: "failed",
+					message,
+					createdAt: (/* @__PURE__ */ new Date()).toISOString()
+				});
+				return buildProvidersPage(ctx, variant, runtime, {
+					message,
+					type: "error"
+				});
+			}
+		}
+	}
+	return buildProvidersPage(ctx, variant, runtime);
+}
+
+//#endregion
+export { GLOBAL_SETTINGS_KEY, LAST_TEST_RESULT_KEY, SELECTED_PROVIDER_KEY, SMTP_ADMIN_PAGES, SMTP_ADMIN_WIDGETS, SMTP_PLUGIN_ID, SMTP_PLUGIN_VERSION, SMTP_PROVIDER_DEFINITIONS, clearProviderSecret, collectAllowedHosts, countDeliveryLogs, createDeliveryLogRecord, deliverWithConfiguredProvider, getAvailableProviderSelectOptions, getGlobalSettings, getLastTestResult, getProviderById, getProviderLabel, getProviderPickerOptions, getProviderSettings, getSelectedProviderId, handleAdminInteraction, isDeliveryReady, isProviderAvailable, isProviderConfigured, patchProviderSettings, queryRecentDeliveryLogs, saveGlobalSettingsFromValues, saveProviderSettingsFromValues, setLastTestResult, setSelectedProviderId, writeDeliveryLog };
+//# sourceMappingURL=index.mjs.map