@lunora/mail 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/address-fkXxLKza.mjs

@@ -0,0 +1,62 @@
+const MAX_EMAIL_LENGTH = 320;
+const MAX_NAME_LENGTH = 256;
+const ADDRESS_PATTERN = /^([^<]*)<([^>]*)>\s*$/;
+const assertSafeAddressField = (field, value) => {
+  if (value.includes("\r") || value.includes("\n") || value.includes(",")) {
+    throw new Error(`@lunora/mail: address ${field} must not contain CR, LF, or comma`);
+  }
+};
+const assertSafeHeaderValue = (label, value) => {
+  if (value.includes("\r") || value.includes("\n")) {
+    throw new Error(`@lunora/mail: ${label} must not contain CR or LF`);
+  }
+};
+const toBracketedAddress = (name, email) => {
+  if (name.length > MAX_NAME_LENGTH) {
+    throw new Error(`@lunora/mail: address name must be <= ${String(MAX_NAME_LENGTH)} characters`);
+  }
+  if (email.length > MAX_EMAIL_LENGTH) {
+    throw new Error(`@lunora/mail: address email must be <= ${String(MAX_EMAIL_LENGTH)} characters`);
+  }
+  if (name) {
+    assertSafeAddressField("name", name);
+  }
+  assertSafeAddressField("email", email);
+  return name ? { email, name } : { email };
+};
+const toBareAddress = (input) => {
+  const email = input.trim();
+  if (email.length > MAX_EMAIL_LENGTH) {
+    throw new Error(`@lunora/mail: address email must be <= ${String(MAX_EMAIL_LENGTH)} characters`);
+  }
+  assertSafeAddressField("email", email);
+  return { email };
+};
+const toAddress = (input) => {
+  const match = ADDRESS_PATTERN.exec(input);
+  const email = (match?.[2] ?? "").trim();
+  if (match && email) {
+    return toBracketedAddress((match[1] ?? "").trim(), email);
+  }
+  return toBareAddress(input);
+};
+const toAddressList = (input) => {
+  if (input === void 0) {
+    return void 0;
+  }
+  const list = Array.isArray(input) ? input : [input];
+  return list.map((entry) => toAddress(entry));
+};
+const assertSafeAddresses = (payload) => {
+  toAddressList(payload.to);
+  toAddressList(payload.cc);
+  toAddressList(payload.bcc);
+  if (payload.from !== void 0) {
+    toAddress(payload.from);
+  }
+  if (payload.replyTo !== void 0) {
+    toAddress(payload.replyTo);
+  }
+};
+
+export { assertSafeHeaderValue as a, assertSafeAddresses as b, toAddress as c, toAddressList as t };

package/dist/packem_shared/capture-transport.d-ChnhdPO2.d.mts

@@ -0,0 +1,117 @@
+import { ReactElement } from 'react';
+/**
+* Minimal projection of a Cloudflare Queue binding — accepts a JSON payload
+* via `.send()`. Declared structurally so callers can pass either the real
+* `Queue` binding or a unit-test double.
+*/
+interface QueueLike {
+  send: (payload: unknown, options?: Record<string, unknown>) => Promise<void>;
+}
+/**
+* Minimal projection of a transport adapter. Returning `{ id }` follows
+* Resend's response shape; the real `@visulima/email` `MailManager` flattens
+* provider responses to the same field for us.
+*/
+interface MailTransport {
+  send: (payload: SendPayload) => Promise<{
+    id: string;
+  }>;
+}
+interface SendPayload {
+  bcc?: string[];
+  cc?: string[];
+  from?: string;
+  headers?: Record<string, string>;
+  html?: string;
+  replyTo?: string;
+  subject: string;
+  text?: string;
+  to: string | string[];
+}
+interface SendOptions {
+  bcc?: string[];
+  cc?: string[];
+  from?: string;
+  headers?: Record<string, string>;
+  html?: string;
+  react?: ReactElement;
+  replyTo?: string;
+  subject: string;
+  text?: string;
+  to: string | string[];
+}
+interface LunoraMailOptions {
+  /** API key for the Resend transport (bring-your-own-provider). Ignored when `transport` or `cloudflareSend` is set. */
+  apiKey?: string;
+  /**
+  * RFC 822 send callback bound to the Worker's `send_email` binding. When set
+  * (and no explicit `transport` is supplied) the default transport is
+  * Cloudflare Email Workers — Lunora's default provider. Ignored when
+  * `transport` is set.
+  */
+  cloudflareSend?: (from: string, to: string, raw: string) => Promise<void>;
+  /** Default sender (`Name &lt;addr@host>` or bare email). */
+  from: string;
+  /** Default queue binding for `mailer.queue()`. */
+  queue?: QueueLike;
+  /** Override the underlying transport. Useful for tests, the dev capture transport, + multi-provider setups. */
+  transport?: MailTransport;
+}
+interface Mailer {
+  queue: (options: SendOptions) => Promise<{
+    queued: true;
+  }>;
+  send: (options: SendOptions) => Promise<{
+    id: string;
+  }>;
+}
+/**
+* One captured outbound message as persisted by the dev mail catcher. Extends
+* the rendered, validated {@link SendPayload} with an `id` and a capture
+* timestamp assigned by the sink (the root-shard mailbox), so the studio inbox
+* can list and open it.
+*
+* **Canonical captured-mail wire type — single source of truth.** Every other
+* representation of a captured message mirrors this shape; consumers import it
+* directly wherever the package dependency direction allows.
+*
+* `@lunora/studio`'s `CapturedMail` re-exports this (type-only dep on
+* `@lunora/mail`). `@lunora/do`'s `CapturedMailRow` / `RecordMailInput` are
+* documented mirrors — the DO runtime stays free of any `@lunora/mail` *runtime*
+* dep — guarded by a compile-time structural assertion against this type, so a
+* field added here that isn't mirrored fails the `@lunora/do` build.
+*
+* Add or change a captured-mail field here first; the guards will point at the
+* mirrors that need the matching change.
+*/
+interface CapturedMail extends SendPayload {
+  /** Epoch-ms the message was captured. */
+  capturedAt: number;
+  /** Stable id assigned to the captured message. */
+  id: string;
+}
+/**
+* Minimal projection of the persistence target the capture transport writes to
+* (the studio's root-shard mailbox). Declared structurally — like
+* {@link import("./types").QueueLike} — so `@lunora/mail` stays free of any
+* Durable Object / runtime dependency. The registry scaffold supplies the
+* concrete sink that POSTs to the root shard's `__lunora_admin__:recordMail` RPC.
+*/
+interface MailboxSink {
+  record: (mail: SendPayload) => Promise<{
+    id: string;
+  }>;
+}
+/**
+* Build a capture {@link MailTransport}: instead of delivering, it persists the
+* fully rendered + validated payload to `sink` and returns the assigned id.
+*
+* Wired in dev by the mail registry scaffold so `lunora dev` shows every send in
+* the studio's Mail inbox — including `@lunora/auth`'s verification and
+* forgot-password mail — with no provider credentials and nothing leaving the
+* machine. Address/header validation already ran in `createMailer.buildPayload`
+* before the payload reaches here, so the captured message is the same one a
+* real transport would have sent.
+*/
+declare const createCaptureTransport: (sink: MailboxSink) => MailTransport;
+export { CapturedMail as C, LunoraMailOptions as L, MailTransport as M, QueueLike as Q, SendOptions as S, Mailer as a, MailboxSink as b, SendPayload as c, createCaptureTransport as d };

package/dist/packem_shared/capture-transport.d-ChnhdPO2.d.ts

@@ -0,0 +1,117 @@
+import { ReactElement } from 'react';
+/**
+* Minimal projection of a Cloudflare Queue binding — accepts a JSON payload
+* via `.send()`. Declared structurally so callers can pass either the real
+* `Queue` binding or a unit-test double.
+*/
+interface QueueLike {
+  send: (payload: unknown, options?: Record<string, unknown>) => Promise<void>;
+}
+/**
+* Minimal projection of a transport adapter. Returning `{ id }` follows
+* Resend's response shape; the real `@visulima/email` `MailManager` flattens
+* provider responses to the same field for us.
+*/
+interface MailTransport {
+  send: (payload: SendPayload) => Promise<{
+    id: string;
+  }>;
+}
+interface SendPayload {
+  bcc?: string[];
+  cc?: string[];
+  from?: string;
+  headers?: Record<string, string>;
+  html?: string;
+  replyTo?: string;
+  subject: string;
+  text?: string;
+  to: string | string[];
+}
+interface SendOptions {
+  bcc?: string[];
+  cc?: string[];
+  from?: string;
+  headers?: Record<string, string>;
+  html?: string;
+  react?: ReactElement;
+  replyTo?: string;
+  subject: string;
+  text?: string;
+  to: string | string[];
+}
+interface LunoraMailOptions {
+  /** API key for the Resend transport (bring-your-own-provider). Ignored when `transport` or `cloudflareSend` is set. */
+  apiKey?: string;
+  /**
+  * RFC 822 send callback bound to the Worker's `send_email` binding. When set
+  * (and no explicit `transport` is supplied) the default transport is
+  * Cloudflare Email Workers — Lunora's default provider. Ignored when
+  * `transport` is set.
+  */
+  cloudflareSend?: (from: string, to: string, raw: string) => Promise<void>;
+  /** Default sender (`Name &lt;addr@host>` or bare email). */
+  from: string;
+  /** Default queue binding for `mailer.queue()`. */
+  queue?: QueueLike;
+  /** Override the underlying transport. Useful for tests, the dev capture transport, + multi-provider setups. */
+  transport?: MailTransport;
+}
+interface Mailer {
+  queue: (options: SendOptions) => Promise<{
+    queued: true;
+  }>;
+  send: (options: SendOptions) => Promise<{
+    id: string;
+  }>;
+}
+/**
+* One captured outbound message as persisted by the dev mail catcher. Extends
+* the rendered, validated {@link SendPayload} with an `id` and a capture
+* timestamp assigned by the sink (the root-shard mailbox), so the studio inbox
+* can list and open it.
+*
+* **Canonical captured-mail wire type — single source of truth.** Every other
+* representation of a captured message mirrors this shape; consumers import it
+* directly wherever the package dependency direction allows.
+*
+* `@lunora/studio`'s `CapturedMail` re-exports this (type-only dep on
+* `@lunora/mail`). `@lunora/do`'s `CapturedMailRow` / `RecordMailInput` are
+* documented mirrors — the DO runtime stays free of any `@lunora/mail` *runtime*
+* dep — guarded by a compile-time structural assertion against this type, so a
+* field added here that isn't mirrored fails the `@lunora/do` build.
+*
+* Add or change a captured-mail field here first; the guards will point at the
+* mirrors that need the matching change.
+*/
+interface CapturedMail extends SendPayload {
+  /** Epoch-ms the message was captured. */
+  capturedAt: number;
+  /** Stable id assigned to the captured message. */
+  id: string;
+}
+/**
+* Minimal projection of the persistence target the capture transport writes to
+* (the studio's root-shard mailbox). Declared structurally — like
+* {@link import("./types").QueueLike} — so `@lunora/mail` stays free of any
+* Durable Object / runtime dependency. The registry scaffold supplies the
+* concrete sink that POSTs to the root shard's `__lunora_admin__:recordMail` RPC.
+*/
+interface MailboxSink {
+  record: (mail: SendPayload) => Promise<{
+    id: string;
+  }>;
+}
+/**
+* Build a capture {@link MailTransport}: instead of delivering, it persists the
+* fully rendered + validated payload to `sink` and returns the assigned id.
+*
+* Wired in dev by the mail registry scaffold so `lunora dev` shows every send in
+* the studio's Mail inbox — including `@lunora/auth`'s verification and
+* forgot-password mail — with no provider credentials and nothing leaving the
+* machine. Address/header validation already ran in `createMailer.buildPayload`
+* before the payload reaches here, so the captured message is the same one a
+* real transport would have sent.
+*/
+declare const createCaptureTransport: (sink: MailboxSink) => MailTransport;
+export { CapturedMail as C, LunoraMailOptions as L, MailTransport as M, QueueLike as Q, SendOptions as S, Mailer as a, MailboxSink as b, SendPayload as c, createCaptureTransport as d };

package/dist/packem_shared/consumeQueuedSend-BEKOdaxU.mjs

@@ -0,0 +1,75 @@
+const toQueuedPayload = (options) => {
+  return {
+    bcc: options.bcc,
+    cc: options.cc,
+    from: options.from,
+    headers: options.headers,
+    html: options.html,
+    replyTo: options.replyTo,
+    subject: options.subject,
+    text: options.text,
+    to: options.to
+  };
+};
+const consumeQueuedSend = async (mailer, payload) => {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("@lunora/mail: queue message body must be an object");
+  }
+  const candidate = payload;
+  if (typeof candidate.subject !== "string") {
+    throw new TypeError("@lunora/mail: queue message must have a string `subject`");
+  }
+  const recipientIsString = typeof candidate.to === "string";
+  const recipientIsStringArray = Array.isArray(candidate.to) && candidate.to.every((value) => typeof value === "string");
+  if (!recipientIsString && !recipientIsStringArray) {
+    throw new Error("@lunora/mail: queue message `to` must be a string or string[]");
+  }
+  const assertOptionalString = (field, value) => {
+    if (value === void 0) {
+      return void 0;
+    }
+    if (typeof value !== "string") {
+      throw new TypeError(`@lunora/mail: queue message \`${field}\` must be a string`);
+    }
+    return value;
+  };
+  const assertOptionalStringList = (field, value) => {
+    if (value === void 0) {
+      return void 0;
+    }
+    if (typeof value === "string") {
+      return [value];
+    }
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+      return value;
+    }
+    throw new TypeError(`@lunora/mail: queue message \`${field}\` must be a string or string[]`);
+  };
+  let headers;
+  if (candidate.headers !== void 0) {
+    if (!candidate.headers || typeof candidate.headers !== "object" || Array.isArray(candidate.headers)) {
+      throw new TypeError("@lunora/mail: queue message `headers` must be an object of string values");
+    }
+    const entries = Object.entries(candidate.headers);
+    for (const [key, value] of entries) {
+      if (typeof value !== "string") {
+        throw new TypeError(`@lunora/mail: queue message header "${key}" must be a string`);
+      }
+    }
+    headers = candidate.headers;
+  }
+  const options = {
+    bcc: assertOptionalStringList("bcc", candidate.bcc),
+    cc: assertOptionalStringList("cc", candidate.cc),
+    from: assertOptionalString("from", candidate.from),
+    headers,
+    html: assertOptionalString("html", candidate.html),
+    replyTo: assertOptionalString("replyTo", candidate.replyTo),
+    subject: candidate.subject,
+    text: assertOptionalString("text", candidate.text),
+    to: candidate.to
+  };
+  return mailer.send(options);
+};
+
+export { consumeQueuedSend, toQueuedPayload };

package/dist/packem_shared/createCaptureSink-DeihS4LH.mjs

@@ -0,0 +1,63 @@
+import { createCaptureTransport } from './createCaptureTransport-Crz_8822.mjs';
+import createMailer from './createMailer-oEKPAd4J.mjs';
+import { a as applyJurisdiction } from './shard-CJ-TvmfT.mjs';
+
+const RECORD_MAIL_OP = "__lunora_admin__:recordMail";
+const DEFAULT_ROOT_SHARD = "__root__";
+const DEV_ENVIRONMENT_PATTERN = /^(?:dev(?:elopment)?|local(?:host)?|test)$/iu;
+const ENVIRONMENT_VARS = ["CF_ENV", "ENVIRONMENT", "NODE_ENV", "WORKER_ENV"];
+const requireStringEnv = (env, name) => {
+  const value = env[name];
+  if (typeof value !== "string" || value === "") {
+    throw new Error(`@lunora/mail: missing env var \`${name}\` — set it in .dev.vars (and \`wrangler secret put ${name}\` for secrets).`);
+  }
+  return value;
+};
+const shouldCaptureMail = (env) => {
+  const flag = env["LUNORA_MAIL_CAPTURE"];
+  if (typeof flag === "string") {
+    return flag === "1" || flag.toLowerCase() === "true";
+  }
+  return ENVIRONMENT_VARS.some((key) => {
+    const value = env[key];
+    return typeof value === "string" && DEV_ENVIRONMENT_PATTERN.test(value);
+  });
+};
+const createCaptureSink = (env, rootShard = DEFAULT_ROOT_SHARD, jurisdiction) => {
+  return {
+    record: async (mail) => {
+      const binding = env["SHARD"];
+      const adminToken = typeof env["LUNORA_ADMIN_TOKEN"] === "string" ? env["LUNORA_ADMIN_TOKEN"] : void 0;
+      if (binding === void 0 || adminToken === void 0) {
+        return { id: "uncaptured" };
+      }
+      const namespace = applyJurisdiction(binding, jurisdiction);
+      const stub = namespace.get(namespace.idFromName(rootShard));
+      const response = await stub.fetch("https://shard.internal/rpc", {
+        body: JSON.stringify({ args: mail, functionPath: RECORD_MAIL_OP }),
+        headers: { authorization: `Bearer ${adminToken}`, "content-type": "application/json" },
+        method: "POST"
+      });
+      const body = await response.json();
+      return { id: body.result?.id ?? "captured" };
+    }
+  };
+};
+const createMailerFromEnv = (env, options = {}) => {
+  const from = requireStringEnv(env, "MAIL_FROM");
+  if (shouldCaptureMail(env)) {
+    return createMailer({ from, transport: createCaptureTransport(createCaptureSink(env, options.rootShard, options.jurisdiction)) });
+  }
+  if (options.cloudflareSend) {
+    return createMailer({ cloudflareSend: options.cloudflareSend, from });
+  }
+  const apiKey = typeof env["RESEND_API_KEY"] === "string" ? env["RESEND_API_KEY"] : void 0;
+  if (apiKey !== void 0 && apiKey !== "") {
+    return createMailer({ apiKey, from });
+  }
+  throw new Error(
+    "@lunora/mail: no transport configured — provide `cloudflareSend` (a SEND_EMAIL binding) or RESEND_API_KEY, or run in a dev environment to capture."
+  );
+};
+
+export { createCaptureSink, createMailerFromEnv, shouldCaptureMail };

package/dist/packem_shared/createCaptureTransport-Crz_8822.mjs

@@ -0,0 +1,11 @@
+const CAPTURE_TRANSPORT_BRAND = /* @__PURE__ */ Symbol.for("@lunora/mail.captureTransport");
+const isCaptureTransport = (transport) => transport[CAPTURE_TRANSPORT_BRAND] === true;
+const createCaptureTransport = (sink) => {
+  const transport = {
+    [CAPTURE_TRANSPORT_BRAND]: true,
+    send: async (payload) => sink.record(payload)
+  };
+  return transport;
+};
+
+export { CAPTURE_TRANSPORT_BRAND, createCaptureTransport, isCaptureTransport };

package/dist/packem_shared/createCloudflareTransport-yHOVEsZv.mjs

@@ -0,0 +1,26 @@
+import { cloudflareEmailProvider } from '@visulima/email/providers/cloudflare-email';
+import { r as requireRecipients, t as toProviderEmail, i as interpretSendResult } from './provider-transport-C5CVbjRF.mjs';
+
+const createCloudflareTransport = (options) => {
+  const provider = cloudflareEmailProvider({ send: options.send });
+  return {
+    send: async (payload) => {
+      await provider.initialize();
+      const hasCc = payload.cc !== void 0 && payload.cc.length > 0;
+      const hasBcc = payload.bcc !== void 0 && payload.bcc.length > 0;
+      if (hasCc || hasBcc) {
+        throw new Error("@lunora/mail: Cloudflare Email Workers does not support cc/bcc — fan out one send per recipient instead");
+      }
+      const { first, list } = requireRecipients(payload.to);
+      if (list.length > 1) {
+        throw new Error(
+          `@lunora/mail: Cloudflare Email Workers is single-recipient but received ${String(list.length)} \`to\` addresses — fan out one send per recipient instead`
+        );
+      }
+      const result = await provider.sendEmail(toProviderEmail(payload, options.from, first));
+      return interpretSendResult(result);
+    }
+  };
+};
+
+export { createCloudflareTransport };

package/dist/packem_shared/createInboundEmailHandler-D0uCOrU-.mjs

@@ -0,0 +1,83 @@
+import { a as applyJurisdiction } from './shard-CJ-TvmfT.mjs';
+
+const GENERIC_REJECT_REASON = "message could not be processed";
+const rejectOnError = (error, context) => {
+  console.error("@lunora/mail/inbound: dropping message —", error);
+  context.message.setReject(GENERIC_REJECT_REASON);
+};
+const createInboundEmailHandler = (options) => {
+  const onError = options.onError ?? rejectOnError;
+  return async (message, env, context_) => {
+    const context = { ctx: context_, env, message };
+    try {
+      const parsed = await options.parse(message.raw);
+      if (options.verify) {
+        const verified = await options.verify(parsed, context);
+        if (verified === false) {
+          throw new Error("@lunora/mail/inbound: sender verification rejected the message");
+        }
+      }
+      await options.dispatch(parsed, context);
+    } catch (error) {
+      await onError(error, context);
+    }
+  };
+};
+const DEFAULT_ROOT_SHARD = "__root__";
+const toBase64 = (bytes) => {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCodePoint(byte);
+  }
+  return btoa(binary);
+};
+const toJsonSafeEmail = (email) => {
+  if (email.attachments.length === 0) {
+    return email;
+  }
+  return {
+    ...email,
+    attachments: email.attachments.map((attachment) => {
+      const { content } = attachment;
+      if (typeof content === "string") {
+        return attachment;
+      }
+      const bytes = content instanceof Uint8Array ? content : new Uint8Array(content);
+      return { ...attachment, content: toBase64(bytes), encoding: "base64" };
+    })
+  };
+};
+const dispatchToLunoraFunction = (options) => {
+  const shardKey = options.shardKey ?? DEFAULT_ROOT_SHARD;
+  const resolveArgs = options.resolveArgs ?? ((email) => toJsonSafeEmail(email));
+  return async (email, context) => {
+    const adminToken = options.adminToken ?? (typeof context.env["LUNORA_ADMIN_TOKEN"] === "string" ? context.env["LUNORA_ADMIN_TOKEN"] : void 0);
+    if (adminToken === void 0 || adminToken === "") {
+      throw new Error("@lunora/mail/inbound: missing LUNORA_ADMIN_TOKEN — cannot authorize inbound dispatch to the shard RPC.");
+    }
+    const envelope = {
+      args: resolveArgs(email, context),
+      functionPath: options.functionPath,
+      shardKey
+    };
+    const namespace = applyJurisdiction(options.shard, options.jurisdiction);
+    const stub = namespace.get(namespace.idFromName(shardKey));
+    const response = await stub.fetch("https://shard.internal/rpc", {
+      body: JSON.stringify(envelope),
+      headers: { authorization: `Bearer ${adminToken}`, "content-type": "application/json" },
+      method: "POST"
+    });
+    if (response.ok === false) {
+      throw new Error(`@lunora/mail/inbound: dispatch to \`${options.functionPath}\` failed (HTTP ${String(response.status ?? "?")}).`);
+    }
+    const body = await response.json();
+    if (typeof body === "object" && body !== null && "error" in body) {
+      const { error } = body;
+      if (error !== void 0 && error !== null) {
+        throw new Error(`@lunora/mail/inbound: dispatch to \`${options.functionPath}\` returned an error: ${JSON.stringify(error)}`);
+      }
+    }
+  };
+};
+
+export { createInboundEmailHandler, dispatchToLunoraFunction };

package/dist/packem_shared/createMailer-oEKPAd4J.mjs

@@ -0,0 +1,77 @@
+import { a as assertSafeHeaderValue, b as assertSafeAddresses } from './address-fkXxLKza.mjs';
+import { isCaptureTransport } from './createCaptureTransport-Crz_8822.mjs';
+import { createCloudflareTransport } from './createCloudflareTransport-yHOVEsZv.mjs';
+import { toQueuedPayload } from './consumeQueuedSend-BEKOdaxU.mjs';
+import renderEmail from './renderEmail-hyS1bpVP.mjs';
+import createResendTransport from './createResendTransport-oNIorpzv.mjs';
+
+const buildDefaultTransport = (options) => {
+  if (options.cloudflareSend) {
+    return createCloudflareTransport({ from: options.from, send: options.cloudflareSend });
+  }
+  if (options.apiKey) {
+    return createResendTransport(options.apiKey, options.from);
+  }
+  throw new Error("@lunora/mail: a transport is required — pass `transport`, `cloudflareSend` (Cloudflare Email Workers, the default), or `apiKey` (Resend)");
+};
+const createMailer = (options) => {
+  if (!options.from) {
+    throw new Error("@lunora/mail: `from` is required");
+  }
+  const transport = options.transport ?? buildDefaultTransport(options);
+  const buildPayload = async (options_) => {
+    let { html } = options_;
+    let { text } = options_;
+    if (options_.react) {
+      const rendered = await renderEmail(options_.react);
+      html = html ?? rendered.html;
+      text = text ?? rendered.text;
+    }
+    assertSafeHeaderValue("subject", options_.subject);
+    if (options_.headers) {
+      for (const [name, value] of Object.entries(options_.headers)) {
+        assertSafeHeaderValue(`header name "${name}"`, name);
+        assertSafeHeaderValue(`header "${name}" value`, value);
+      }
+    }
+    const from = options_.from ?? options.from;
+    assertSafeAddresses({
+      bcc: options_.bcc,
+      cc: options_.cc,
+      from,
+      replyTo: options_.replyTo,
+      to: options_.to
+    });
+    return {
+      bcc: options_.bcc,
+      cc: options_.cc,
+      from,
+      headers: options_.headers,
+      html,
+      replyTo: options_.replyTo,
+      subject: options_.subject,
+      text,
+      to: options_.to
+    };
+  };
+  const send = async (options_) => {
+    const payload = await buildPayload(options_);
+    return transport.send(payload);
+  };
+  const queue = async (options_) => {
+    if (!options.queue) {
+      if (isCaptureTransport(transport)) {
+        const captured = await buildPayload(options_);
+        await transport.send(captured);
+        return { queued: true };
+      }
+      throw new Error("@lunora/mail: `queue` binding is required for mailer.queue()");
+    }
+    const payload = await buildPayload(options_);
+    await options.queue.send(toQueuedPayload(payload));
+    return { queued: true };
+  };
+  return { queue, send };
+};
+
+export { createMailer as default };

package/dist/packem_shared/createResendTransport-oNIorpzv.mjs

@@ -0,0 +1,16 @@
+import { resendProvider } from '@visulima/email/providers/resend';
+import { r as requireRecipients, t as toProviderEmail, i as interpretSendResult } from './provider-transport-C5CVbjRF.mjs';
+
+const createResendTransport = (apiKey, defaultFrom) => {
+  const provider = resendProvider({ apiKey });
+  return {
+    send: async (payload) => {
+      await provider.initialize();
+      const { first, list } = requireRecipients(payload.to);
+      const result = await provider.sendEmail(toProviderEmail(payload, defaultFrom, list.length === 1 ? first : list));
+      return interpretSendResult(result);
+    }
+  };
+};
+
+export { createResendTransport as default };