@dbx-tools/email 0.3.44 → 0.4.0

package/lib/src/transport.js

@@ -0,0 +1,303 @@
+/**
+ * The email runtime: a lazily-built, process-wide dispatcher plus its
+ * resolved config, and {@link sendEmail} which sends one
+ * {@link EmailMessage} through it. In SMTP mode the runtime holds a
+ * memoized nodemailer transport (shared by the plugin's setup and the
+ * agent tool, so they reuse one connection pool); in file/outbox mode it
+ * holds no transport and {@link sendEmail} writes HTML to disk instead.
+ * The first caller (normally the plugin at setup) primes it with the
+ * plugin's config; later callers reuse it.
+ *
+ * The runtime also carries the {@link EmailExecutor} every outbound send runs
+ * through. The plugin installs its own `execute()` there at setup, which is
+ * how the Mastra tool - a plain function with no plugin instance in scope -
+ * still gets AppKit's retry / timeout / telemetry chain. Without a registered
+ * plugin (a direct call from a script or a test) the send still runs, just
+ * without interceptors.
+ *
+ * Every entry point takes an optional {@link AbortSignal} so the plugin's
+ * `execute()` timeout and a client disconnect both stop the caller waiting
+ * on SMTP.
+ *
+ * @module
+ */
+import { AppKitError, ConfigurationError, ExecutionError, ValidationError, } from "@databricks/appkit";
+import { async, error, log } from "@dbx-tools/shared-core";
+import nodemailer from "nodemailer";
+import { resolveEmailConfig } from "./config.js";
+import { EMAIL_SEND_SETTINGS, MAX_ATTACHMENT_BYTES, MAX_ATTACHMENT_COUNT, MAX_ATTACHMENTS_TOTAL_BYTES, MAX_BODY_CHARS, } from "./defaults.js";
+import { renderEmailHtml } from "./email-html.js";
+import { writeOutboxEmail } from "./outbox.js";
+import { assertSenderAllowed } from "./sender.js";
+const logger = log.logger("email/transport");
+/**
+ * Executor used until (or unless) the plugin installs its own: run the send
+ * directly, mapping a throw onto the same {@link ExecutionResult} shape so
+ * call sites branch on `ok` either way.
+ */
+const directExecute = async (fn) => {
+    try {
+        return { ok: true, data: await fn() };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            status: err instanceof AppKitError ? err.statusCode : 500,
+            message: error.errorMessage(err),
+        };
+    }
+};
+let runtime;
+/**
+ * Return the shared runtime, building it on first use by resolving
+ * `overrides` over the environment (`SMTP_HOST`, `SMTP_PORT`,
+ * `SMTP_SECURE`, `SMTP_USER`, `SMTP_PASSWORD`, `EMAIL_DOMAIN`,
+ * `EMAIL_FROM`, `EMAIL_ALLOWED_SENDERS`, `EMAIL_SENDER_POLICY`,
+ * `EMAIL_OUTBOX_MODE`, `EMAIL_OUTBOX_DIR`) through
+ * {@link resolveEmailConfig}. With SMTP credentials present it holds a
+ * nodemailer transport and its connection pool; otherwise it is in
+ * file/outbox mode and holds none.
+ *
+ * `overrides` is read only on the call that builds the runtime, so prime it
+ * from the plugin's config at setup; later callers (the tool's `execute`,
+ * the sender-options route) pass nothing and get the same instance. Throws
+ * whatever {@link resolveEmailConfig} throws for an unusable configuration.
+ */
+export function getEmailRuntime(overrides) {
+    if (!runtime) {
+        const config = resolveEmailConfig(overrides);
+        runtime = {
+            config,
+            execute: directExecute,
+            ...(config.mode === "smtp"
+                ? {
+                    transporter: nodemailer.createTransport({
+                        host: config.host,
+                        port: config.port,
+                        secure: config.secure,
+                        auth: config.auth,
+                    }),
+                }
+                : {}),
+        };
+    }
+    return runtime;
+}
+/**
+ * Install the executor outbound sends run through. The plugin calls this at
+ * setup with its own `execute()`; a second call replaces the previous one, so
+ * a re-registered plugin does not leave the tools bound to a dead instance.
+ */
+export function setEmailExecutor(execute) {
+    getEmailRuntime().execute = execute;
+}
+/**
+ * Drop the memoized runtime, closing the SMTP connection pool, so the next
+ * {@link getEmailRuntime} rebuilds it from fresh config and stops calling
+ * through a torn-down plugin's `execute()`. Idempotent, and the plugin's
+ * `shutdown()` hook.
+ */
+export function resetEmailRuntime() {
+    runtime?.transporter?.close();
+    runtime = undefined;
+}
+/**
+ * Run one non-idempotent write through the shared executor and unwrap it.
+ *
+ * `execute()` never throws, so a failed send arrives as `{ ok: false }` with a
+ * status the interceptors already sanitized; it is logged here and re-raised
+ * as a stable {@link ExecutionError} so an upstream message never becomes the
+ * caller's error text. `signal` is the caller's own cancellation (an agent
+ * run, a request teardown); it is merged with the signal the timeout
+ * interceptor supplies so either one unwinds the I/O.
+ */
+export async function executeWrite(operation, settings, fn, signal) {
+    const { execute } = getEmailRuntime();
+    const result = await execute((executeSignal) => fn(async.combineAbortSignals(executeSignal, signal)), settings);
+    if (result.ok)
+        return result.data;
+    // A caller that cancelled is not a failure worth reporting as one.
+    if (signal?.aborted)
+        throw ExecutionError.canceled();
+    logger.warn("execution-failed", {
+        operation,
+        status: result.status,
+        error: result.message,
+    });
+    throw new ExecutionError(`email: ${operation} failed`, {
+        context: { operation, status: result.status },
+    });
+}
+/**
+ * Open and tear down one SMTP connection to prove the host, port, and
+ * credentials work. Called at plugin setup so a bad relay shows up in the
+ * boot logs rather than on the first approved send.
+ */
+export async function verifyEmailTransport(transporter, signal) {
+    if (!transporter) {
+        throw ConfigurationError.invalidConnection("SMTP", "The runtime resolved to outbox mode, so there is no transport to verify.");
+    }
+    await abortable(transporter.verify(), signal);
+}
+/**
+ * Stop awaiting `promise` as soon as `signal` aborts. nodemailer exposes no
+ * cancellation hook, so the SMTP conversation itself finishes on its own
+ * connection; what unwinds is the caller and everything downstream of it.
+ */
+function abortable(promise, signal) {
+    if (!signal)
+        return promise;
+    signal.throwIfAborted();
+    // The listener is detached once the race settles so a long-lived run signal
+    // does not accumulate one per send.
+    const listener = new AbortController();
+    const aborted = new Promise((_, reject) => {
+        signal.addEventListener("abort", () => reject(signal.reason), {
+            once: true,
+            signal: listener.signal,
+        });
+    });
+    return Promise.race([promise, aborted]).finally(() => listener.abort());
+}
+/** The comma-joined recipient string echoed back in {@link EmailResult}. */
+function recipientEcho(to) {
+    return to.join(", ");
+}
+/**
+ * Node buffer encodings a wire attachment may name for its inline `content`.
+ * Anything else is measured as UTF-8, which over-counts rather than letting
+ * an unrecognized encoding slip past the size cap.
+ */
+const CONTENT_ENCODINGS = new Set([
+    "ascii",
+    "base64",
+    "base64url",
+    "binary",
+    "hex",
+    "latin1",
+    "ucs2",
+    "ucs-2",
+    "utf8",
+    "utf-8",
+    "utf16le",
+    "utf-16le",
+]);
+/**
+ * Decoded byte size of one attachment's inline content. A `path` attachment
+ * contributes nothing: nodemailer streams it, so its bytes never sit in this
+ * process and cannot be measured here.
+ */
+function attachmentBytes(attachment) {
+    const { content, encoding } = attachment;
+    if (content === undefined)
+        return 0;
+    const declared = encoding?.toLowerCase();
+    const resolved = declared && CONTENT_ENCODINGS.has(declared) ? declared : "utf8";
+    return Buffer.byteLength(content, resolved);
+}
+/**
+ * Reject a message whose body or attachments exceed the plugin's caps. The
+ * body and attachment list arrive from a model, so they are unbounded until
+ * something bounds them; most SMTP relays also reject an oversized message
+ * only after the whole payload has been uploaded.
+ */
+function assertMessageWithinCaps(message) {
+    if (message.body.length > MAX_BODY_CHARS) {
+        throw ValidationError.invalidValue("body", message.body.length, `at most ${MAX_BODY_CHARS} characters`);
+    }
+    const attachments = message.attachments ?? [];
+    if (attachments.length > MAX_ATTACHMENT_COUNT) {
+        throw ValidationError.invalidValue("attachments", attachments.length, `at most ${MAX_ATTACHMENT_COUNT} files`);
+    }
+    let total = 0;
+    for (const attachment of attachments) {
+        const bytes = attachmentBytes(attachment);
+        if (bytes > MAX_ATTACHMENT_BYTES) {
+            throw ValidationError.invalidValue("attachments[].content", bytes, `at most ${MAX_ATTACHMENT_BYTES} bytes per file`);
+        }
+        total += bytes;
+    }
+    if (total > MAX_ATTACHMENTS_TOTAL_BYTES) {
+        throw ValidationError.invalidValue("attachments", total, `at most ${MAX_ATTACHMENTS_TOTAL_BYTES} bytes across all files`);
+    }
+}
+/**
+ * Map the wire-format {@link EmailAttachment}s onto nodemailer's
+ * attachment shape, dropping unset optional keys so nodemailer applies
+ * its own defaults (utf-8 encoding, filename-inferred content type). The
+ * wire fields are a deliberate subset of nodemailer's, so this is a
+ * straight structural pass-through.
+ */
+function toMailAttachments(attachments) {
+    if (!attachments || attachments.length === 0)
+        return undefined;
+    return attachments.map((att) => ({
+        filename: att.filename,
+        ...(att.content !== undefined ? { content: att.content } : {}),
+        ...(att.encoding !== undefined ? { encoding: att.encoding } : {}),
+        ...(att.path !== undefined ? { path: att.path } : {}),
+        ...(att.contentType !== undefined ? { contentType: att.contentType } : {}),
+    }));
+}
+/**
+ * Hand one already-validated message to SMTP, or write it to the outbox when
+ * no credentials are configured. The half of a send that performs I/O, so it
+ * is what runs inside the interceptor chain.
+ */
+async function dispatch(message, from, signal) {
+    const { config, transporter } = getEmailRuntime();
+    const recipient = recipientEcho(message.to);
+    signal?.throwIfAborted();
+    if (config.mode === "file") {
+        const path = await writeOutboxEmail(message, from, config.outDir, config.brand);
+        return { sent: true, recipient, from, messageId: path };
+    }
+    if (!transporter) {
+        throw ConfigurationError.invalidConnection("SMTP", "No transport was built for the resolved configuration.");
+    }
+    const attachments = toMailAttachments(message.attachments);
+    const info = await abortable(transporter.sendMail({
+        from,
+        to: message.to,
+        subject: message.subject,
+        text: message.body,
+        html: renderEmailHtml({
+            subject: message.subject,
+            body: message.body,
+            ...(config.brand ? { brand: config.brand } : {}),
+        }),
+        ...(message.cc && message.cc.length > 0 ? { cc: message.cc } : {}),
+        ...(message.bcc && message.bcc.length > 0 ? { bcc: message.bcc } : {}),
+        ...(attachments ? { attachments } : {}),
+    }), signal);
+    return {
+        sent: true,
+        recipient,
+        from,
+        ...(info.messageId ? { messageId: info.messageId } : {}),
+    };
+}
+/**
+ * Send (SMTP mode) or persist (file/outbox mode) one message from the
+ * resolved `from` address. `to` (and optional `cc` / `bcc`) each accept
+ * one or more addresses, and `attachments` are forwarded as files. The
+ * body is markdown: SMTP sends it as both a plain-text part (the raw
+ * source) and an HTML part (rendered), and the outbox embeds the
+ * rendered HTML in a document. In file mode the returned `messageId` is
+ * the path written. Throws when `to` carries no recipient, when the body
+ * or attachments exceed the plugin's caps, or when `from` is not permitted
+ * by the effective sender allow-list.
+ *
+ * The recipient, cap, and sender checks run before the interceptor chain so
+ * their specific status and actionable message reach the caller instead of
+ * the chain's stable failure text. `signal` cancels the send.
+ */
+export async function sendEmail(message, from, signal) {
+    if (message.to.length === 0) {
+        throw ValidationError.missingField("to");
+    }
+    assertMessageWithinCaps(message);
+    assertSenderAllowed(from, getEmailRuntime().config.allowedSenders);
+    return executeWrite("send", EMAIL_SEND_SETTINGS, (executeSignal) => dispatch(message, from, executeSignal), signal);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The email runtime: a lazily-built, process-wide dispatcher plus its\n * resolved config, and {@link sendEmail} which sends one\n * {@link EmailMessage} through it. In SMTP mode the runtime holds a\n * memoized nodemailer transport (shared by the plugin's setup and the\n * agent tool, so they reuse one connection pool); in file/outbox mode it\n * holds no transport and {@link sendEmail} writes HTML to disk instead.\n * The first caller (normally the plugin at setup) primes it with the\n * plugin's config; later callers reuse it.\n *\n * The runtime also carries the {@link EmailExecutor} every outbound send runs\n * through. The plugin installs its own `execute()` there at setup, which is\n * how the Mastra tool - a plain function with no plugin instance in scope -\n * still gets AppKit's retry / timeout / telemetry chain. Without a registered\n * plugin (a direct call from a script or a test) the send still runs, just\n * without interceptors.\n *\n * Every entry point takes an optional {@link AbortSignal} so the plugin's\n * `execute()` timeout and a client disconnect both stop the caller waiting\n * on SMTP.\n *\n * @module\n */\n\nimport {\n  AppKitError,\n  ConfigurationError,\n  ExecutionError,\n  ValidationError,\n  type ExecutionResult,\n} from \"@databricks/appkit\";\nimport { async, error, log } from \"@dbx-tools/shared-core\";\nimport type { EmailAttachment, EmailMessage, EmailResult } from \"@dbx-tools/shared-email\";\nimport nodemailer, { type SendMailOptions, type Transporter } from \"nodemailer\";\nimport { resolveEmailConfig, type EmailPluginConfig, type ResolvedEmailConfig } from \"./config\";\nimport {\n  EMAIL_SEND_SETTINGS,\n  MAX_ATTACHMENT_BYTES,\n  MAX_ATTACHMENT_COUNT,\n  MAX_ATTACHMENTS_TOTAL_BYTES,\n  MAX_BODY_CHARS,\n  type EmailExecutionSettings,\n} from \"./defaults\";\nimport { renderEmailHtml } from \"./email-html\";\nimport { writeOutboxEmail } from \"./outbox\";\nimport { assertSenderAllowed } from \"./sender\";\n\nconst logger = log.logger(\"email/transport\");\n\n/**\n * Runs one outbound send through AppKit's interceptor chain. Matches\n * `Plugin.execute()`, which never throws: a failure comes back as\n * `{ ok: false }`.\n */\nexport type EmailExecutor = <T>(\n  fn: (signal?: AbortSignal) => Promise<T>,\n  settings: EmailExecutionSettings,\n) => Promise<ExecutionResult<T>>;\n\n/** The shared dispatcher, its resolved config, and the send executor. */\nexport interface EmailRuntime {\n  /** Present only in SMTP mode. */\n  transporter?: Transporter;\n  config: ResolvedEmailConfig;\n  execute: EmailExecutor;\n}\n\n/**\n * Executor used until (or unless) the plugin installs its own: run the send\n * directly, mapping a throw onto the same {@link ExecutionResult} shape so\n * call sites branch on `ok` either way.\n */\nconst directExecute: EmailExecutor = async (fn) => {\n  try {\n    return { ok: true, data: await fn() };\n  } catch (err) {\n    return {\n      ok: false,\n      status: err instanceof AppKitError ? err.statusCode : 500,\n      message: error.errorMessage(err),\n    };\n  }\n};\n\nlet runtime: EmailRuntime | undefined;\n\n/**\n * Return the shared runtime, building it on first use by resolving\n * `overrides` over the environment (`SMTP_HOST`, `SMTP_PORT`,\n * `SMTP_SECURE`, `SMTP_USER`, `SMTP_PASSWORD`, `EMAIL_DOMAIN`,\n * `EMAIL_FROM`, `EMAIL_ALLOWED_SENDERS`, `EMAIL_SENDER_POLICY`,\n * `EMAIL_OUTBOX_MODE`, `EMAIL_OUTBOX_DIR`) through\n * {@link resolveEmailConfig}. With SMTP credentials present it holds a\n * nodemailer transport and its connection pool; otherwise it is in\n * file/outbox mode and holds none.\n *\n * `overrides` is read only on the call that builds the runtime, so prime it\n * from the plugin's config at setup; later callers (the tool's `execute`,\n * the sender-options route) pass nothing and get the same instance. Throws\n * whatever {@link resolveEmailConfig} throws for an unusable configuration.\n */\nexport function getEmailRuntime(overrides?: EmailPluginConfig): EmailRuntime {\n  if (!runtime) {\n    const config = resolveEmailConfig(overrides);\n    runtime = {\n      config,\n      execute: directExecute,\n      ...(config.mode === \"smtp\"\n        ? {\n            transporter: nodemailer.createTransport({\n              host: config.host,\n              port: config.port,\n              secure: config.secure,\n              auth: config.auth,\n            }),\n          }\n        : {}),\n    };\n  }\n  return runtime;\n}\n\n/**\n * Install the executor outbound sends run through. The plugin calls this at\n * setup with its own `execute()`; a second call replaces the previous one, so\n * a re-registered plugin does not leave the tools bound to a dead instance.\n */\nexport function setEmailExecutor(execute: EmailExecutor): void {\n  getEmailRuntime().execute = execute;\n}\n\n/**\n * Drop the memoized runtime, closing the SMTP connection pool, so the next\n * {@link getEmailRuntime} rebuilds it from fresh config and stops calling\n * through a torn-down plugin's `execute()`. Idempotent, and the plugin's\n * `shutdown()` hook.\n */\nexport function resetEmailRuntime(): void {\n  runtime?.transporter?.close();\n  runtime = undefined;\n}\n\n/**\n * Run one non-idempotent write through the shared executor and unwrap it.\n *\n * `execute()` never throws, so a failed send arrives as `{ ok: false }` with a\n * status the interceptors already sanitized; it is logged here and re-raised\n * as a stable {@link ExecutionError} so an upstream message never becomes the\n * caller's error text. `signal` is the caller's own cancellation (an agent\n * run, a request teardown); it is merged with the signal the timeout\n * interceptor supplies so either one unwinds the I/O.\n */\nexport async function executeWrite<T>(\n  operation: string,\n  settings: EmailExecutionSettings,\n  fn: (signal?: AbortSignal) => Promise<T>,\n  signal?: AbortSignal,\n): Promise<T> {\n  const { execute } = getEmailRuntime();\n  const result = await execute(\n    (executeSignal) => fn(async.combineAbortSignals(executeSignal, signal)),\n    settings,\n  );\n  if (result.ok) return result.data;\n  // A caller that cancelled is not a failure worth reporting as one.\n  if (signal?.aborted) throw ExecutionError.canceled();\n  logger.warn(\"execution-failed\", {\n    operation,\n    status: result.status,\n    error: result.message,\n  });\n  throw new ExecutionError(`email: ${operation} failed`, {\n    context: { operation, status: result.status },\n  });\n}\n\n/**\n * Open and tear down one SMTP connection to prove the host, port, and\n * credentials work. Called at plugin setup so a bad relay shows up in the\n * boot logs rather than on the first approved send.\n */\nexport async function verifyEmailTransport(\n  transporter: Transporter | undefined,\n  signal?: AbortSignal,\n): Promise<void> {\n  if (!transporter) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      \"The runtime resolved to outbox mode, so there is no transport to verify.\",\n    );\n  }\n  await abortable(transporter.verify(), signal);\n}\n\n/**\n * Stop awaiting `promise` as soon as `signal` aborts. nodemailer exposes no\n * cancellation hook, so the SMTP conversation itself finishes on its own\n * connection; what unwinds is the caller and everything downstream of it.\n */\nfunction abortable<T>(promise: Promise<T>, signal: AbortSignal | undefined): Promise<T> {\n  if (!signal) return promise;\n  signal.throwIfAborted();\n  // The listener is detached once the race settles so a long-lived run signal\n  // does not accumulate one per send.\n  const listener = new AbortController();\n  const aborted = new Promise<never>((_, reject) => {\n    signal.addEventListener(\"abort\", () => reject(signal.reason), {\n      once: true,\n      signal: listener.signal,\n    });\n  });\n  return Promise.race([promise, aborted]).finally(() => listener.abort());\n}\n\n/** The comma-joined recipient string echoed back in {@link EmailResult}. */\nfunction recipientEcho(to: string[]): string {\n  return to.join(\", \");\n}\n\n/**\n * Node buffer encodings a wire attachment may name for its inline `content`.\n * Anything else is measured as UTF-8, which over-counts rather than letting\n * an unrecognized encoding slip past the size cap.\n */\nconst CONTENT_ENCODINGS: ReadonlySet<string> = new Set([\n  \"ascii\",\n  \"base64\",\n  \"base64url\",\n  \"binary\",\n  \"hex\",\n  \"latin1\",\n  \"ucs2\",\n  \"ucs-2\",\n  \"utf8\",\n  \"utf-8\",\n  \"utf16le\",\n  \"utf-16le\",\n]);\n\n/**\n * Decoded byte size of one attachment's inline content. A `path` attachment\n * contributes nothing: nodemailer streams it, so its bytes never sit in this\n * process and cannot be measured here.\n */\nfunction attachmentBytes(attachment: EmailAttachment): number {\n  const { content, encoding } = attachment;\n  if (content === undefined) return 0;\n  const declared = encoding?.toLowerCase();\n  const resolved =\n    declared && CONTENT_ENCODINGS.has(declared) ? (declared as BufferEncoding) : \"utf8\";\n  return Buffer.byteLength(content, resolved);\n}\n\n/**\n * Reject a message whose body or attachments exceed the plugin's caps. The\n * body and attachment list arrive from a model, so they are unbounded until\n * something bounds them; most SMTP relays also reject an oversized message\n * only after the whole payload has been uploaded.\n */\nfunction assertMessageWithinCaps(message: EmailMessage): void {\n  if (message.body.length > MAX_BODY_CHARS) {\n    throw ValidationError.invalidValue(\n      \"body\",\n      message.body.length,\n      `at most ${MAX_BODY_CHARS} characters`,\n    );\n  }\n  const attachments = message.attachments ?? [];\n  if (attachments.length > MAX_ATTACHMENT_COUNT) {\n    throw ValidationError.invalidValue(\n      \"attachments\",\n      attachments.length,\n      `at most ${MAX_ATTACHMENT_COUNT} files`,\n    );\n  }\n  let total = 0;\n  for (const attachment of attachments) {\n    const bytes = attachmentBytes(attachment);\n    if (bytes > MAX_ATTACHMENT_BYTES) {\n      throw ValidationError.invalidValue(\n        \"attachments[].content\",\n        bytes,\n        `at most ${MAX_ATTACHMENT_BYTES} bytes per file`,\n      );\n    }\n    total += bytes;\n  }\n  if (total > MAX_ATTACHMENTS_TOTAL_BYTES) {\n    throw ValidationError.invalidValue(\n      \"attachments\",\n      total,\n      `at most ${MAX_ATTACHMENTS_TOTAL_BYTES} bytes across all files`,\n    );\n  }\n}\n\n/**\n * Map the wire-format {@link EmailAttachment}s onto nodemailer's\n * attachment shape, dropping unset optional keys so nodemailer applies\n * its own defaults (utf-8 encoding, filename-inferred content type). The\n * wire fields are a deliberate subset of nodemailer's, so this is a\n * straight structural pass-through.\n */\nfunction toMailAttachments(\n  attachments: EmailAttachment[] | undefined,\n): SendMailOptions[\"attachments\"] {\n  if (!attachments || attachments.length === 0) return undefined;\n  return attachments.map((att) => ({\n    filename: att.filename,\n    ...(att.content !== undefined ? { content: att.content } : {}),\n    ...(att.encoding !== undefined ? { encoding: att.encoding } : {}),\n    ...(att.path !== undefined ? { path: att.path } : {}),\n    ...(att.contentType !== undefined ? { contentType: att.contentType } : {}),\n  }));\n}\n\n/**\n * Hand one already-validated message to SMTP, or write it to the outbox when\n * no credentials are configured. The half of a send that performs I/O, so it\n * is what runs inside the interceptor chain.\n */\nasync function dispatch(\n  message: EmailMessage,\n  from: string,\n  signal?: AbortSignal,\n): Promise<EmailResult> {\n  const { config, transporter } = getEmailRuntime();\n  const recipient = recipientEcho(message.to);\n  signal?.throwIfAborted();\n\n  if (config.mode === \"file\") {\n    const path = await writeOutboxEmail(message, from, config.outDir, config.brand);\n    return { sent: true, recipient, from, messageId: path };\n  }\n\n  if (!transporter) {\n    throw ConfigurationError.invalidConnection(\n      \"SMTP\",\n      \"No transport was built for the resolved configuration.\",\n    );\n  }\n  const attachments = toMailAttachments(message.attachments);\n  const info = await abortable(\n    transporter.sendMail({\n      from,\n      to: message.to,\n      subject: message.subject,\n      text: message.body,\n      html: renderEmailHtml({\n        subject: message.subject,\n        body: message.body,\n        ...(config.brand ? { brand: config.brand } : {}),\n      }),\n      ...(message.cc && message.cc.length > 0 ? { cc: message.cc } : {}),\n      ...(message.bcc && message.bcc.length > 0 ? { bcc: message.bcc } : {}),\n      ...(attachments ? { attachments } : {}),\n    }),\n    signal,\n  );\n  return {\n    sent: true,\n    recipient,\n    from,\n    ...(info.messageId ? { messageId: info.messageId } : {}),\n  };\n}\n\n/**\n * Send (SMTP mode) or persist (file/outbox mode) one message from the\n * resolved `from` address. `to` (and optional `cc` / `bcc`) each accept\n * one or more addresses, and `attachments` are forwarded as files. The\n * body is markdown: SMTP sends it as both a plain-text part (the raw\n * source) and an HTML part (rendered), and the outbox embeds the\n * rendered HTML in a document. In file mode the returned `messageId` is\n * the path written. Throws when `to` carries no recipient, when the body\n * or attachments exceed the plugin's caps, or when `from` is not permitted\n * by the effective sender allow-list.\n *\n * The recipient, cap, and sender checks run before the interceptor chain so\n * their specific status and actionable message reach the caller instead of\n * the chain's stable failure text. `signal` cancels the send.\n */\nexport async function sendEmail(\n  message: EmailMessage,\n  from: string,\n  signal?: AbortSignal,\n): Promise<EmailResult> {\n  if (message.to.length === 0) {\n    throw ValidationError.missingField(\"to\");\n  }\n  assertMessageWithinCaps(message);\n  assertSenderAllowed(from, getEmailRuntime().config.allowedSenders);\n  return executeWrite(\n    \"send\",\n    EMAIL_SEND_SETTINGS,\n    (executeSignal) => dispatch(message, from, executeSignal),\n    signal,\n  );\n}\n"]}

package/lib/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["../src/brand.ts","../src/config.ts","../src/defaults.ts","../src/email-html.ts","../src/juice.d.ts","../src/markdown.ts","../src/outbox.ts","../src/plugin.ts","../src/sender.ts","../src/tool.ts","../src/transport.ts","../index.ts"],"version":"5.9.3"}

package/package.json

@@ -19,24 +19,28 @@
     "juice": "^12.1.1",
     "marked": "^18.0.5",
     "nodemailer": "^7.0.13",
-    "@dbx-tools/shared-core": "0.3.44",
-    "@dbx-tools/shared-email": "0.3.44"
+    "@dbx-tools/shared-core": "0.4.0",
+    "@dbx-tools/shared-email": "0.4.0"
   },
-  "main": "index.ts",
+  "main": "./lib/index.js",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.44",
-  "types": "index.ts",
+  "version": "0.4.0",
+  "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.ts",
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "index.ts",
-    "src"
+    "src",
+    "lib"
   ],
   "dbxToolsConfig": {
     "tags": [