@lunora/mail 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/createInboundEmailHandler-BW_s0-Vc.mjs

@@ -0,0 +1,84 @@
+import { LunoraError } from '@lunora/errors';
+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 LunoraError("INTERNAL", "@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 LunoraError("INTERNAL", "@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 LunoraError("INTERNAL", `@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 LunoraError("INTERNAL", `@lunora/mail/inbound: dispatch to \`${options.functionPath}\` returned an error: ${JSON.stringify(error)}`);
+      }
+    }
+  };
+};
+
+export { createInboundEmailHandler, dispatchToLunoraFunction };

package/dist/packem_shared/createMailer-B4Z_Cgiu.mjs

@@ -0,0 +1,81 @@
+import { LunoraError } from '@lunora/errors';
+import { a as assertSafeHeaderValue, b as assertSafeAddresses } from './address-vSUAVU2T.mjs';
+import { isCaptureTransport } from './createCaptureTransport-Crz_8822.mjs';
+import { createCloudflareTransport } from './createCloudflareTransport-DXh1nUNi.mjs';
+import { toQueuedPayload } from './consumeQueuedSend-B9hTDOZ6.mjs';
+import renderEmail from './renderEmail-hyS1bpVP.mjs';
+import createResendTransport from './createResendTransport-CMQWjZoi.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 LunoraError(
+    "INTERNAL",
+    "@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 LunoraError("INTERNAL", "@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 LunoraError("INTERNAL", "@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-CMQWjZoi.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-C0xHi3oy.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 };

package/dist/packem_shared/parseInboundEmail-6lafQBT1.mjs

@@ -0,0 +1,72 @@
+import PostalMime from 'postal-mime';
+import { a as assertSafeHeaderValue } from './address-vSUAVU2T.mjs';
+
+const safe = (label, value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  assertSafeHeaderValue(`inbound ${label}`, value);
+  return value;
+};
+const formatAddress = (entry) => {
+  if (entry.address !== void 0 && entry.address !== "") {
+    return entry.name ? `${entry.name} <${entry.address}>` : entry.address;
+  }
+  if (entry.group) {
+    return entry.group.map((member) => member.address ?? "").filter((address) => address !== "").join(", ");
+  }
+  return entry.name ?? "";
+};
+const authVerdict = (authResults, method) => {
+  const match = new RegExp(String.raw`\b${method}=([a-zA-Z]+)`, "i").exec(authResults);
+  return match?.[1]?.toLowerCase() ?? null;
+};
+const parseAuthentication = (authResults) => {
+  if (authResults === void 0 || authResults === "") {
+    return { dkim: null, dmarc: null, spf: null };
+  }
+  return {
+    dkim: authVerdict(authResults, "dkim"),
+    dmarc: authVerdict(authResults, "dmarc"),
+    spf: authVerdict(authResults, "spf")
+  };
+};
+const parseInboundEmail = async (raw) => {
+  const parsed = await PostalMime.parse(raw);
+  const headers = {};
+  for (const header of parsed.headers) {
+    assertSafeHeaderValue(`inbound header \`${header.key}\``, header.value);
+    headers[header.key] = header.value;
+  }
+  const to = (parsed.to ?? []).map((entry) => {
+    const formatted = formatAddress(entry);
+    assertSafeHeaderValue("inbound to", formatted);
+    return formatted;
+  });
+  const from = parsed.from ? formatAddress(parsed.from) : "";
+  assertSafeHeaderValue("inbound from", from);
+  const attachments = parsed.attachments.map((attachment) => {
+    return {
+      content: attachment.content,
+      disposition: attachment.disposition,
+      ...attachment.encoding === void 0 ? {} : { encoding: attachment.encoding },
+      filename: attachment.filename,
+      mimeType: attachment.mimeType
+    };
+  });
+  return {
+    attachments,
+    authentication: parseAuthentication(headers["authentication-results"]),
+    from,
+    headers,
+    ...parsed.html === void 0 ? {} : { html: parsed.html },
+    ...safe("inReplyTo", parsed.inReplyTo) === void 0 ? {} : { inReplyTo: parsed.inReplyTo },
+    ...safe("messageId", parsed.messageId) === void 0 ? {} : { messageId: parsed.messageId },
+    ...safe("references", parsed.references) === void 0 ? {} : { references: parsed.references },
+    ...safe("subject", parsed.subject) === void 0 ? {} : { subject: parsed.subject },
+    ...parsed.text === void 0 ? {} : { text: parsed.text },
+    to
+  };
+};
+
+export { parseInboundEmail };

package/dist/packem_shared/provider-transport-C0xHi3oy.mjs

@@ -0,0 +1,48 @@
+import { LunoraError } from '@lunora/errors';
+import { t as toAddressList, c as toAddress } from './address-vSUAVU2T.mjs';
+
+const reasonOf = (rawError) => {
+  if (rawError instanceof Error) {
+    return rawError.message;
+  }
+  if (rawError === null || rawError === void 0) {
+    return "send failed";
+  }
+  if (typeof rawError === "string") {
+    return rawError;
+  }
+  if (typeof rawError === "number" || typeof rawError === "boolean" || typeof rawError === "bigint") {
+    return rawError.toString();
+  }
+  return JSON.stringify(rawError) ?? "send failed";
+};
+const requireRecipients = (to) => {
+  const list = toAddressList(to);
+  const [first] = list ?? [];
+  if (!list || first === void 0) {
+    throw new LunoraError("INTERNAL", "@lunora/mail: at least one recipient is required");
+  }
+  return { first, list };
+};
+const toProviderEmail = (payload, defaultFrom, to) => {
+  return {
+    bcc: toAddressList(payload.bcc),
+    cc: toAddressList(payload.cc),
+    from: toAddress(payload.from ?? defaultFrom),
+    headers: payload.headers,
+    html: payload.html,
+    replyTo: payload.replyTo ? toAddress(payload.replyTo) : void 0,
+    subject: payload.subject,
+    text: payload.text,
+    to
+  };
+};
+const interpretSendResult = (result) => {
+  if (!result.success || !result.data) {
+    console.error(`@lunora/mail: send failed: ${reasonOf(result.error)}`);
+    throw new LunoraError("INTERNAL", "@lunora/mail: send failed");
+  }
+  return { id: result.data.messageId };
+};
+
+export { interpretSendResult as i, requireRecipients as r, toProviderEmail as t };

package/dist/packem_shared/renderEmail-hyS1bpVP.mjs

@@ -0,0 +1,8 @@
+import { render } from '@react-email/render';
+
+const renderEmail = async (element) => {
+  const [html, text] = await Promise.all([render(element, { pretty: false }), render(element, { plainText: true })]);
+  return { html, text };
+};
+
+export { renderEmail as default };

package/dist/packem_shared/shard-CJ-TvmfT.mjs

@@ -0,0 +1,13 @@
+const applyJurisdiction = (namespace, jurisdiction) => {
+  if (jurisdiction === void 0) {
+    return namespace;
+  }
+  if (typeof namespace.jurisdiction !== "function") {
+    throw new TypeError(
+      `@lunora/mail: Durable Object namespace does not support jurisdiction("${jurisdiction}") — update @cloudflare/workers-types or remove the jurisdiction option`
+    );
+  }
+  return namespace.jurisdiction(jurisdiction);
+};
+
+export { applyJurisdiction as a };

package/dist/packem_shared/shard.d-CL2Lmliv.d.mts

@@ -0,0 +1,39 @@
+/**
+* Structural projections of the `SHARD` Durable Object namespace + one shard
+* stub, shared by the inbound dispatcher. Mirrors the shapes the outbound dev
+* capture sink uses (`packages/mail/src/from-env.ts`) so inbound dispatch routes
+* a parsed message into a Lunora function over the exact same admin-RPC-over-shard
+* path — without importing any Cloudflare types into `@lunora/mail`.
+*/
+/** Structural projection of one shard stub — only `fetch` returning something with `.json()`. */
+interface ShardStubLike {
+  fetch: (input: string, init?: {
+    body?: string;
+    headers?: Record<string, string>;
+    method?: string;
+  }) => Promise<{
+    json: () => Promise<unknown>;
+  }>;
+}
+/**
+* Cloudflare Durable Object data-residency jurisdiction. Widening union —
+* Cloudflare adds values over time.
+* @see https://developers.cloudflare.com/durable-objects/reference/data-location/
+*/
+type DurableObjectJurisdiction = "eu" | "fedramp" | "us";
+/** Structural projection of the `SHARD` Durable Object namespace. */
+interface ShardNamespaceLike {
+  get: (id: unknown) => ShardStubLike;
+  idFromName: (name: string) => unknown;
+  /**
+  * Derive a jurisdiction-restricted subnamespace. Optional because older
+  * workers-types releases (and test doubles) may not expose it.
+  */
+  jurisdiction?: (jurisdiction: DurableObjectJurisdiction) => ShardNamespaceLike;
+}
+/**
+* Return a jurisdiction-restricted view of `namespace`, or `namespace`
+* unchanged when no jurisdiction is configured. Fail-closed when the binding
+* lacks `.jurisdiction()` so a residency constraint is never silently dropped.
+*/
+export { DurableObjectJurisdiction as D, ShardNamespaceLike as S, ShardStubLike as a };

package/dist/packem_shared/shard.d-CL2Lmliv.d.ts

@@ -0,0 +1,39 @@
+/**
+* Structural projections of the `SHARD` Durable Object namespace + one shard
+* stub, shared by the inbound dispatcher. Mirrors the shapes the outbound dev
+* capture sink uses (`packages/mail/src/from-env.ts`) so inbound dispatch routes
+* a parsed message into a Lunora function over the exact same admin-RPC-over-shard
+* path — without importing any Cloudflare types into `@lunora/mail`.
+*/
+/** Structural projection of one shard stub — only `fetch` returning something with `.json()`. */
+interface ShardStubLike {
+  fetch: (input: string, init?: {
+    body?: string;
+    headers?: Record<string, string>;
+    method?: string;
+  }) => Promise<{
+    json: () => Promise<unknown>;
+  }>;
+}
+/**
+* Cloudflare Durable Object data-residency jurisdiction. Widening union —
+* Cloudflare adds values over time.
+* @see https://developers.cloudflare.com/durable-objects/reference/data-location/
+*/
+type DurableObjectJurisdiction = "eu" | "fedramp" | "us";
+/** Structural projection of the `SHARD` Durable Object namespace. */
+interface ShardNamespaceLike {
+  get: (id: unknown) => ShardStubLike;
+  idFromName: (name: string) => unknown;
+  /**
+  * Derive a jurisdiction-restricted subnamespace. Optional because older
+  * workers-types releases (and test doubles) may not expose it.
+  */
+  jurisdiction?: (jurisdiction: DurableObjectJurisdiction) => ShardNamespaceLike;
+}
+/**
+* Return a jurisdiction-restricted view of `namespace`, or `namespace`
+* unchanged when no jurisdiction is configured. Fail-closed when the binding
+* lacks `.jurisdiction()` so a residency constraint is never silently dropped.
+*/
+export { DurableObjectJurisdiction as D, ShardNamespaceLike as S, ShardStubLike as a };

package/dist/testing.d.mts

@@ -0,0 +1,49 @@
+import { C as CapturedMail } from "./packem_shared/capture-transport.d-ChnhdPO2.mjs";
+import 'react';
+/** Minimal `fetch` projection so a test can inject a stub. */
+type FetchLike = (input: string, init?: {
+  body?: string;
+  headers?: Record<string, string>;
+  method?: string;
+}) => Promise<{
+  json: () => Promise<unknown>;
+  ok: boolean;
+  status: number;
+}>;
+interface InboxOptions {
+  /** Admin bearer token (`LUNORA_ADMIN_TOKEN`) the worker gates introspection behind. */
+  adminToken: string;
+  /** App base URL, e.g. `http://localhost:8787`. */
+  baseUrl: string;
+  /** Inject a `fetch` implementation (defaults to the global). */
+  fetch?: FetchLike;
+  /** Newest-N to read (default 50). */
+  limit?: number;
+}
+interface WaitForMailOptions extends InboxOptions {
+  /** Poll interval in ms (default 250). */
+  pollMs?: number;
+  /** Only match a message whose subject contains this substring. */
+  subjectMatch?: string;
+  /** Give up after this many ms (default 10000). */
+  timeoutMs?: number;
+  /** Recipient address the message must be addressed to. */
+  to: string;
+}
+/** Read the captured-mail inbox (newest first). */
+declare const listCapturedMail: (options: InboxOptions) => Promise<CapturedMail[]>;
+/**
+* Poll the captured-mail inbox until a message addressed to `to` (optionally
+* matching `subjectMatch`) appears, then return it. Throws on timeout. Entries
+* are newest-first, so the most recent matching message wins.
+*/
+declare const waitForMail: (options: WaitForMailOptions) => Promise<CapturedMail>;
+/**
+* Pull the first link out of a captured message — html first, then text. Pass
+* `match` to require the URL contain a substring (e.g. `"/reset-password"`),
+* which disambiguates the action link from a logo/footer URL.
+*/
+declare const extractLink: (mail: CapturedMail, options?: {
+  match?: string;
+}) => string;
+export { type InboxOptions, type WaitForMailOptions, extractLink, listCapturedMail, waitForMail };

package/dist/testing.d.ts

@@ -0,0 +1,49 @@
+import { C as CapturedMail } from "./packem_shared/capture-transport.d-ChnhdPO2.js";
+import 'react';
+/** Minimal `fetch` projection so a test can inject a stub. */
+type FetchLike = (input: string, init?: {
+  body?: string;
+  headers?: Record<string, string>;
+  method?: string;
+}) => Promise<{
+  json: () => Promise<unknown>;
+  ok: boolean;
+  status: number;
+}>;
+interface InboxOptions {
+  /** Admin bearer token (`LUNORA_ADMIN_TOKEN`) the worker gates introspection behind. */
+  adminToken: string;
+  /** App base URL, e.g. `http://localhost:8787`. */
+  baseUrl: string;
+  /** Inject a `fetch` implementation (defaults to the global). */
+  fetch?: FetchLike;
+  /** Newest-N to read (default 50). */
+  limit?: number;
+}
+interface WaitForMailOptions extends InboxOptions {
+  /** Poll interval in ms (default 250). */
+  pollMs?: number;
+  /** Only match a message whose subject contains this substring. */
+  subjectMatch?: string;
+  /** Give up after this many ms (default 10000). */
+  timeoutMs?: number;
+  /** Recipient address the message must be addressed to. */
+  to: string;
+}
+/** Read the captured-mail inbox (newest first). */
+declare const listCapturedMail: (options: InboxOptions) => Promise<CapturedMail[]>;
+/**
+* Poll the captured-mail inbox until a message addressed to `to` (optionally
+* matching `subjectMatch`) appears, then return it. Throws on timeout. Entries
+* are newest-first, so the most recent matching message wins.
+*/
+declare const waitForMail: (options: WaitForMailOptions) => Promise<CapturedMail>;
+/**
+* Pull the first link out of a captured message — html first, then text. Pass
+* `match` to require the URL contain a substring (e.g. `"/reset-password"`),
+* which disambiguates the action link from a logo/footer URL.
+*/
+declare const extractLink: (mail: CapturedMail, options?: {
+  match?: string;
+}) => string;
+export { type InboxOptions, type WaitForMailOptions, extractLink, listCapturedMail, waitForMail };

package/dist/testing.mjs

@@ -0,0 +1,63 @@
+import { LunoraError } from '@lunora/errors';
+
+const GET_CAPTURED_MAIL_OP = "__lunora_admin__:getCapturedMail";
+const DEFAULT_RPC_PATH = "/_lunora/rpc";
+const TRAILING_SLASH = /\/$/;
+const sleep = async (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+const recipients = (mail) => Array.isArray(mail.to) ? mail.to : [mail.to];
+const listCapturedMail = async (options) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const endpoint = `${options.baseUrl.replace(TRAILING_SLASH, "")}${DEFAULT_RPC_PATH}`;
+  const response = await fetchImpl(endpoint, {
+    body: JSON.stringify({ args: { limit: options.limit ?? 50 }, functionPath: GET_CAPTURED_MAIL_OP }),
+    headers: { authorization: `Bearer ${options.adminToken}`, "content-type": "application/json" },
+    method: "POST"
+  });
+  if (!response.ok) {
+    throw new LunoraError("INTERNAL", `@lunora/mail/testing: getCapturedMail failed (HTTP ${String(response.status)})`);
+  }
+  const body = await response.json();
+  return body.result?.entries ?? [];
+};
+const waitForMail = async (options) => {
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  const pollMs = options.pollMs ?? 250;
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const entries = await listCapturedMail(options);
+    const match = entries.find(
+      (mail) => recipients(mail).includes(options.to) && (options.subjectMatch === void 0 || mail.subject.includes(options.subjectMatch))
+    );
+    if (match) {
+      return match;
+    }
+    if (Date.now() >= deadline) {
+      throw new LunoraError(
+        "INTERNAL",
+        `@lunora/mail/testing: no mail to "${options.to}"${options.subjectMatch === void 0 ? "" : ` matching "${options.subjectMatch}"`} within ${String(timeoutMs)}ms`
+      );
+    }
+    await sleep(pollMs);
+  }
+};
+const URL_PATTERN = /https?:\/\/[^\s"'<>)]+/g;
+const extractLink = (mail, options = {}) => {
+  for (const source of [mail.html, mail.text]) {
+    if (source === void 0) {
+      continue;
+    }
+    const matches = source.match(URL_PATTERN) ?? [];
+    const link = matches.find((candidate) => options.match === void 0 || candidate.includes(options.match));
+    if (link !== void 0) {
+      return link;
+    }
+  }
+  throw new LunoraError(
+    "INTERNAL",
+    `@lunora/mail/testing: no link${options.match === void 0 ? "" : ` containing "${options.match}"`} found in the captured message`
+  );
+};
+
+export { extractLink, listCapturedMail, waitForMail };

package/package.json

@@ -1,31 +1,73 @@
 {
   "name": "@lunora/mail",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.10",
   "description": "Email for Lunora: Resend adapter, TSX templates, and queue-backed sends",
-  "license": "FSL-1.1-Apache-2.0",
-  "homepage": "https://lunora.sh",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/anolilab/lunora.git",
-    "directory": "packages/mail"
-  },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
-  },
   "keywords": [
-    "lunora",
     "cloudflare",
-    "workers",
     "durable-objects",
     "email",
+    "lunora",
     "mail",
+    "react-email",
     "resend",
-    "react-email"
+    "workers"
   ],
+  "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anolilab/lunora.git",
+    "directory": "packages/mail"
+  },
+  "files": [
+    "./dist",
+    "__assets__",
+    "README.md",
+    "LICENSE.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./inbound": {
+      "types": "./dist/inbound/index.d.ts",
+      "import": "./dist/inbound/index.mjs"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "@lunora/errors": "1.0.0-alpha.1",
+    "@react-email/render": "2.0.10",
+    "@visulima/email": "1.0.0-alpha.41",
+    "postal-mime": "2.7.5"
+  },
+  "peerDependencies": {
+    "react": "^19.2.7"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }