@dbx-tools/email 0.3.43 → 0.4.0

package/lib/src/defaults.js

@@ -0,0 +1,64 @@
+/**
+ * Interceptor defaults and hard payload caps for the email plugin.
+ *
+ * The execution settings are what the runtime's executor hands
+ * `Plugin.execute()`, kept here rather than at the call sites so the
+ * caching / retry / timeout posture of every outbound operation is
+ * reviewable in one place. The caps bound the one unbounded input the
+ * plugin accepts: a model-drafted message with attachments.
+ *
+ * @module
+ */
+/** Ceiling on how long a single SMTP conversation may take. */
+export const SEND_TIMEOUT_MS = 30_000;
+/** Ceiling on the SMTP handshake performed at plugin setup. */
+export const VERIFY_TIMEOUT_MS = 15_000;
+/** Attempts allowed for the setup-time SMTP handshake, including the first. */
+export const VERIFY_ATTEMPTS = 3;
+/** Largest single attachment accepted, in decoded bytes (10 MiB). */
+export const MAX_ATTACHMENT_BYTES = 10_485_760;
+/** Largest combined attachment payload accepted, in decoded bytes (20 MiB). */
+export const MAX_ATTACHMENTS_TOTAL_BYTES = 20_971_520;
+/** Largest number of attachments accepted on one message. */
+export const MAX_ATTACHMENT_COUNT = 20;
+/** Largest markdown body accepted, in characters. */
+export const MAX_BODY_CHARS = 200_000;
+/** Execution settings for a send (SMTP dispatch or an outbox write). */
+export const EMAIL_SEND_SETTINGS = {
+    default: {
+        // Cache disabled: a send is a side effect, not a value. Replaying a
+        // cached result would report success for a message never handed to SMTP.
+        cache: { enabled: false },
+        // Retry disabled: SMTP delivery is not idempotent. A `sendMail` that
+        // times out may already have queued the message, so a second attempt
+        // risks delivering the mail twice.
+        retry: { enabled: false },
+        timeout: SEND_TIMEOUT_MS,
+    },
+};
+/** Execution settings for the setup-time SMTP connectivity check. */
+export const EMAIL_VERIFY_SETTINGS = {
+    default: {
+        // Cache disabled: connectivity is a point-in-time fact about the server,
+        // and this runs once per boot, so there is nothing to reuse.
+        cache: { enabled: false },
+        // Retry enabled: the handshake has no side effect, and a cold SMTP relay
+        // or a slow DNS answer at boot is exactly the transient failure that
+        // should not take the app down.
+        retry: { enabled: true, attempts: VERIFY_ATTEMPTS },
+        timeout: VERIFY_TIMEOUT_MS,
+    },
+};
+/** Execution settings for the sender-options lookup. */
+export const EMAIL_SENDERS_SETTINGS = {
+    default: {
+        // Cache disabled: the options are computed from already-resolved config
+        // and the caller's own address, so a cache would add a cross-identity
+        // leak risk for no measurable saving.
+        cache: { enabled: false },
+        // Retry disabled: the lookup performs no I/O, so a failure is
+        // deterministic and a second attempt would fail identically.
+        retry: { enabled: false },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/email-html.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Email HTML assembly: render a markdown body into a branded, responsive
+ * email layout and inline the stylesheet with `juice`.
+ *
+ * The layout is the classic email-safe pattern (a centered 600px
+ * table-based container with a header band, content card, and optional
+ * footer) - the same shape MJML emits, hand-built here because MJML's
+ * toolchain pulls fast-moving browser-data deps (caniuse-lite,
+ * baseline-browser-mapping) that are awkward to install behind a
+ * locked-down registry. Inlining matters because real clients (Gmail,
+ * Outlook) strip `<style>` blocks and ignore class selectors; the same
+ * renderer feeds both the local outbox preview and the SMTP HTML part,
+ * so a browser and an inbox show the same thing.
+ *
+ * Brand styling (accent color, font, header logo) is optional: pass an
+ * {@link EmailBrand} to color the layout, or omit it for the neutral
+ * default. Branding is inlined here because the browser UI's `[data-brand]`
+ * CSS bridge can't reach an inbox (see `./brand`).
+ *
+ * @module
+ */
+import { string } from "@dbx-tools/shared-core";
+import type { EmailBrand } from "./brand.js";
+/** Escape HTML-significant characters (re-exported from `@dbx-tools/shared-core`). */
+export declare const escapeHtml: typeof string.escapeHtml;
+/** Options for {@link renderEmailHtml}. */
+export interface EmailHtmlOptions {
+    /** Markdown body. Rendered to HTML, then wrapped in the layout. */
+    body: string;
+    /** Header-band title and document `<title>`. Defaults to "Message". */
+    subject?: string;
+    /**
+     * Optional `[label, value]` envelope rows shown above the body (used
+     * by the outbox preview; omitted for SMTP sends, where the mail client
+     * shows the envelope itself).
+     */
+    headers?: ReadonlyArray<readonly [string, string]>;
+    /** Optional small-print footer line. Omitted when unset. */
+    footer?: string;
+    /**
+     * Optional brand styling for the layout (accent, font, header logo).
+     * Omit for the neutral default palette.
+     */
+    brand?: EmailBrand;
+}
+/**
+ * Render `body` (markdown) into a complete, style-inlined email document
+ * using the responsive layout. When `opts.brand` is set its accent, font,
+ * and logo style the layout; otherwise a neutral default palette is used.
+ */
+export declare function renderEmailHtml(opts: EmailHtmlOptions): string;

package/lib/src/email-html.js

@@ -0,0 +1,146 @@
+/**
+ * Email HTML assembly: render a markdown body into a branded, responsive
+ * email layout and inline the stylesheet with `juice`.
+ *
+ * The layout is the classic email-safe pattern (a centered 600px
+ * table-based container with a header band, content card, and optional
+ * footer) - the same shape MJML emits, hand-built here because MJML's
+ * toolchain pulls fast-moving browser-data deps (caniuse-lite,
+ * baseline-browser-mapping) that are awkward to install behind a
+ * locked-down registry. Inlining matters because real clients (Gmail,
+ * Outlook) strip `<style>` blocks and ignore class selectors; the same
+ * renderer feeds both the local outbox preview and the SMTP HTML part,
+ * so a browser and an inbox show the same thing.
+ *
+ * Brand styling (accent color, font, header logo) is optional: pass an
+ * {@link EmailBrand} to color the layout, or omit it for the neutral
+ * default. Branding is inlined here because the browser UI's `[data-brand]`
+ * CSS bridge can't reach an inbox (see `./brand`).
+ *
+ * @module
+ */
+import { string } from "@dbx-tools/shared-core";
+import juice from "juice";
+import { markdownToHtml } from "./markdown.js";
+/**
+ * Rendered height of the header logo. Fixed rather than intrinsic because
+ * mail clients ignore CSS sizing on an image without an `height` attribute.
+ */
+const LOGO_HEIGHT_PX = 28;
+/** Neutral fallback styling when no brand is supplied. */
+const DEFAULT_BRAND = {
+    accent: "#0b6bcb",
+    onAccent: "#ffffff",
+    fontFamily: "-apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif",
+};
+/** Escape HTML-significant characters (re-exported from `@dbx-tools/shared-core`). */
+export const escapeHtml = string.escapeHtml;
+/**
+ * Content stylesheet inlined onto the markdown body (juice maps these
+ * onto elements). Outer layout styling is written inline directly so it
+ * survives even if inlining is skipped; the `@media` rule is preserved
+ * by juice for clients that honor it. Parameterized by the resolved accent
+ * so body links match the brand.
+ */
+function contentCss(accent) {
+    return `
+    .email-body { font-size: 15px; line-height: 1.55; color: #1a1a1a; }
+    .email-body p { margin: 0 0 1rem; }
+    .email-body a { color: ${accent}; }
+    .email-body h1, .email-body h2, .email-body h3 { margin: 1.4rem 0 0.6rem; line-height: 1.25; }
+    .email-body ul, .email-body ol { margin: 0 0 1rem; padding-left: 1.4rem; }
+    .email-body table { border-collapse: collapse; margin: 1rem 0; width: 100%; font-size: 14px; }
+    .email-body th, .email-body td { border: 1px solid #d0d7de; padding: 6px 10px; text-align: left; }
+    .email-body th { background: #f6f8fa; font-weight: 600; }
+    .email-body code { background: #f1f3f5; padding: 2px 5px; border-radius: 4px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0.9em; }
+    .email-body pre { background: #f1f3f5; padding: 12px; border-radius: 6px; overflow-x: auto; }
+    .email-body pre code { background: none; padding: 0; }
+    .email-body blockquote { margin: 1rem 0; padding: 0 1rem; color: #57606a; border-left: 3px solid #d0d7de; }
+    .email-body img { max-width: 100%; height: auto; }
+    .meta { border-collapse: collapse; font-size: 13px; margin-bottom: 4px; }
+    .meta th { text-align: left; padding: 2px 12px 2px 0; vertical-align: top; color: #6b7280; font-weight: 600; white-space: nowrap; }
+    .meta td { padding: 2px 0; color: #374151; }
+    @media only screen and (max-width: 620px) {
+      .container { width: 100% !important; }
+      .gutter { padding-left: 20px !important; padding-right: 20px !important; }
+    }`;
+}
+/** Render the optional envelope-header table block. */
+function metaBlock(headers) {
+    if (!headers || headers.length === 0)
+        return "";
+    const rows = headers
+        .map(([label, value]) => `<tr><th>${escapeHtml(label)}</th><td>${escapeHtml(value)}</td></tr>`)
+        .join("");
+    return `<table role="presentation" class="meta"><tbody>${rows}</tbody></table>`;
+}
+/** Render the optional footer row. */
+function footerRow(footer) {
+    if (!footer)
+        return "";
+    return `
+          <tr>
+            <td class="gutter" style="padding: 16px 32px; border-top: 1px solid #eaecef; color: #9aa0a6; font-size: 12px; line-height: 1.5;">
+              ${escapeHtml(footer)}
+            </td>
+          </tr>`;
+}
+/**
+ * Render the header-band content: the brand logo (when the brand supplies a
+ * renderable image) above the title, or just the title. The logo is capped
+ * at {@link LOGO_HEIGHT_PX} and tinted implicitly by its own artwork; the
+ * title always shows so the band is never empty.
+ */
+function headerBand(title, brand, onAccent) {
+    const logo = brand.logoUrl
+        ? `<img src="${escapeHtml(brand.logoUrl)}" alt="${escapeHtml(brand.name ?? title)}" height="${LOGO_HEIGHT_PX}" style="height: ${LOGO_HEIGHT_PX}px; width: auto; display: block; margin-bottom: 8px;" />`
+        : "";
+    return `${logo}<span style="color: ${onAccent}; font-size: 18px; font-weight: 700; line-height: 1.3;">${escapeHtml(title)}</span>`;
+}
+/**
+ * Render `body` (markdown) into a complete, style-inlined email document
+ * using the responsive layout. When `opts.brand` is set its accent, font,
+ * and logo style the layout; otherwise a neutral default palette is used.
+ */
+export function renderEmailHtml(opts) {
+    const title = opts.subject?.trim() || "Message";
+    const accent = opts.brand?.accent ?? DEFAULT_BRAND.accent;
+    const onAccent = opts.brand?.onAccent ?? DEFAULT_BRAND.onAccent;
+    const fontFamily = opts.brand?.fontFamily ?? DEFAULT_BRAND.fontFamily;
+    const brand = opts.brand ?? { accent, onAccent, fontFamily };
+    const doc = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="color-scheme" content="light only" />
+    <title>${escapeHtml(title)}</title>
+    <style>${contentCss(accent)}
+    </style>
+  </head>
+  <body style="margin: 0; padding: 0; background-color: #f4f5f7; -webkit-text-size-adjust: 100%;">
+    <table role="presentation" width="100%" cellpadding="0" cellspacing="0" style="background-color: #f4f5f7;">
+      <tr>
+        <td align="center" style="padding: 24px 12px;">
+          <table role="presentation" class="container" width="600" cellpadding="0" cellspacing="0" style="width: 600px; max-width: 100%; background-color: #ffffff; border-radius: 10px; overflow: hidden; box-shadow: 0 1px 3px rgba(0,0,0,0.08); font-family: ${fontFamily};">
+            <tr>
+              <td class="gutter" style="padding: 20px 32px; background-color: ${accent};">
+                ${headerBand(title, brand, onAccent)}
+              </td>
+            </tr>
+            <tr>
+              <td class="gutter" style="padding: 24px 32px 8px;">
+                ${metaBlock(opts.headers)}
+                <div class="email-body">${markdownToHtml(opts.body)}</div>
+              </td>
+            </tr>${footerRow(opts.footer)}
+          </table>
+        </td>
+      </tr>
+    </table>
+  </body>
+</html>
+`;
+    return juice(doc);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"email-html.js","sourceRoot":"","sources":["../../src/email-html.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAChD,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;;GAGG;AACH,MAAM,cAAc,GAAG,EAAE,CAAC;AAE1B,0DAA0D;AAC1D,MAAM,aAAa,GAAqE;IACtF,MAAM,EAAE,SAAS;IACjB,QAAQ,EAAE,SAAS;IACnB,UAAU,EAAE,6EAA6E;CAC1F,CAAC;AAEF,sFAAsF;AACtF,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;AAE5C;;;;;;GAMG;AACH,SAAS,UAAU,CAAC,MAAc;IAChC,OAAO;;;6BAGoB,MAAM;;;;;;;;;;;;;;;;;MAiB7B,CAAC;AACP,CAAC;AAuBD,uDAAuD;AACvD,SAAS,SAAS,CAAC,OAAoC;IACrD,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAC;IAChD,MAAM,IAAI,GAAG,OAAO;SACjB,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,WAAW,UAAU,CAAC,KAAK,CAAC,YAAY,UAAU,CAAC,KAAK,CAAC,YAAY,CAAC;SAC9F,IAAI,CAAC,EAAE,CAAC,CAAC;IACZ,OAAO,kDAAkD,IAAI,kBAAkB,CAAC;AAClF,CAAC;AAED,sCAAsC;AACtC,SAAS,SAAS,CAAC,MAA0B;IAC3C,IAAI,CAAC,MAAM;QAAE,OAAO,EAAE,CAAC;IACvB,OAAO;;;gBAGO,UAAU,CAAC,MAAM,CAAC;;gBAElB,CAAC;AACjB,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAAC,KAAa,EAAE,KAAiB,EAAE,QAAgB;IACpE,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO;QACxB,CAAC,CAAC,aAAa,UAAU,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,UAAU,CAAC,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,aAAa,cAAc,oBAAoB,cAAc,0DAA0D;QACxM,CAAC,CAAC,EAAE,CAAC;IACP,OAAO,GAAG,IAAI,uBAAuB,QAAQ,2DAA2D,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC;AACrI,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,IAAsB;IACpD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,SAAS,CAAC;IAChD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,EAAE,MAAM,IAAI,aAAa,CAAC,MAAM,CAAC;IAC1D,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,EAAE,QAAQ,IAAI,aAAa,CAAC,QAAQ,CAAC;IAChE,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,EAAE,UAAU,IAAI,aAAa,CAAC,UAAU,CAAC;IACtE,MAAM,KAAK,GAAe,IAAI,CAAC,KAAK,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC;IACzE,MAAM,GAAG,GAAG;;;;;;aAMD,UAAU,CAAC,KAAK,CAAC;aACjB,UAAU,CAAC,MAAM,CAAC;;;;;;;kQAOmO,UAAU;;gFAE5L,MAAM;kBACpE,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;;;;;kBAKlC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC;0CACC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC;;mBAEhD,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC;;;;;;;CAOxC,CAAC;IACA,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC;AACpB,CAAC","sourcesContent":["/**\n * Email HTML assembly: render a markdown body into a branded, responsive\n * email layout and inline the stylesheet with `juice`.\n *\n * The layout is the classic email-safe pattern (a centered 600px\n * table-based container with a header band, content card, and optional\n * footer) - the same shape MJML emits, hand-built here because MJML's\n * toolchain pulls fast-moving browser-data deps (caniuse-lite,\n * baseline-browser-mapping) that are awkward to install behind a\n * locked-down registry. Inlining matters because real clients (Gmail,\n * Outlook) strip `<style>` blocks and ignore class selectors; the same\n * renderer feeds both the local outbox preview and the SMTP HTML part,\n * so a browser and an inbox show the same thing.\n *\n * Brand styling (accent color, font, header logo) is optional: pass an\n * {@link EmailBrand} to color the layout, or omit it for the neutral\n * default. Branding is inlined here because the browser UI's `[data-brand]`\n * CSS bridge can't reach an inbox (see `./brand`).\n *\n * @module\n */\n\nimport { string } from \"@dbx-tools/shared-core\";\nimport juice from \"juice\";\nimport type { EmailBrand } from \"./brand\";\nimport { markdownToHtml } from \"./markdown\";\n\n/**\n * Rendered height of the header logo. Fixed rather than intrinsic because\n * mail clients ignore CSS sizing on an image without an `height` attribute.\n */\nconst LOGO_HEIGHT_PX = 28;\n\n/** Neutral fallback styling when no brand is supplied. */\nconst DEFAULT_BRAND: Required<Pick<EmailBrand, \"accent\" | \"onAccent\" | \"fontFamily\">> = {\n  accent: \"#0b6bcb\",\n  onAccent: \"#ffffff\",\n  fontFamily: \"-apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif\",\n};\n\n/** Escape HTML-significant characters (re-exported from `@dbx-tools/shared-core`). */\nexport const escapeHtml = string.escapeHtml;\n\n/**\n * Content stylesheet inlined onto the markdown body (juice maps these\n * onto elements). Outer layout styling is written inline directly so it\n * survives even if inlining is skipped; the `@media` rule is preserved\n * by juice for clients that honor it. Parameterized by the resolved accent\n * so body links match the brand.\n */\nfunction contentCss(accent: string): string {\n  return `\n    .email-body { font-size: 15px; line-height: 1.55; color: #1a1a1a; }\n    .email-body p { margin: 0 0 1rem; }\n    .email-body a { color: ${accent}; }\n    .email-body h1, .email-body h2, .email-body h3 { margin: 1.4rem 0 0.6rem; line-height: 1.25; }\n    .email-body ul, .email-body ol { margin: 0 0 1rem; padding-left: 1.4rem; }\n    .email-body table { border-collapse: collapse; margin: 1rem 0; width: 100%; font-size: 14px; }\n    .email-body th, .email-body td { border: 1px solid #d0d7de; padding: 6px 10px; text-align: left; }\n    .email-body th { background: #f6f8fa; font-weight: 600; }\n    .email-body code { background: #f1f3f5; padding: 2px 5px; border-radius: 4px; font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0.9em; }\n    .email-body pre { background: #f1f3f5; padding: 12px; border-radius: 6px; overflow-x: auto; }\n    .email-body pre code { background: none; padding: 0; }\n    .email-body blockquote { margin: 1rem 0; padding: 0 1rem; color: #57606a; border-left: 3px solid #d0d7de; }\n    .email-body img { max-width: 100%; height: auto; }\n    .meta { border-collapse: collapse; font-size: 13px; margin-bottom: 4px; }\n    .meta th { text-align: left; padding: 2px 12px 2px 0; vertical-align: top; color: #6b7280; font-weight: 600; white-space: nowrap; }\n    .meta td { padding: 2px 0; color: #374151; }\n    @media only screen and (max-width: 620px) {\n      .container { width: 100% !important; }\n      .gutter { padding-left: 20px !important; padding-right: 20px !important; }\n    }`;\n}\n\n/** Options for {@link renderEmailHtml}. */\nexport interface EmailHtmlOptions {\n  /** Markdown body. Rendered to HTML, then wrapped in the layout. */\n  body: string;\n  /** Header-band title and document `<title>`. Defaults to \"Message\". */\n  subject?: string;\n  /**\n   * Optional `[label, value]` envelope rows shown above the body (used\n   * by the outbox preview; omitted for SMTP sends, where the mail client\n   * shows the envelope itself).\n   */\n  headers?: ReadonlyArray<readonly [string, string]>;\n  /** Optional small-print footer line. Omitted when unset. */\n  footer?: string;\n  /**\n   * Optional brand styling for the layout (accent, font, header logo).\n   * Omit for the neutral default palette.\n   */\n  brand?: EmailBrand;\n}\n\n/** Render the optional envelope-header table block. */\nfunction metaBlock(headers: EmailHtmlOptions[\"headers\"]): string {\n  if (!headers || headers.length === 0) return \"\";\n  const rows = headers\n    .map(([label, value]) => `<tr><th>${escapeHtml(label)}</th><td>${escapeHtml(value)}</td></tr>`)\n    .join(\"\");\n  return `<table role=\"presentation\" class=\"meta\"><tbody>${rows}</tbody></table>`;\n}\n\n/** Render the optional footer row. */\nfunction footerRow(footer: string | undefined): string {\n  if (!footer) return \"\";\n  return `\n          <tr>\n            <td class=\"gutter\" style=\"padding: 16px 32px; border-top: 1px solid #eaecef; color: #9aa0a6; font-size: 12px; line-height: 1.5;\">\n              ${escapeHtml(footer)}\n            </td>\n          </tr>`;\n}\n\n/**\n * Render the header-band content: the brand logo (when the brand supplies a\n * renderable image) above the title, or just the title. The logo is capped\n * at {@link LOGO_HEIGHT_PX} and tinted implicitly by its own artwork; the\n * title always shows so the band is never empty.\n */\nfunction headerBand(title: string, brand: EmailBrand, onAccent: string): string {\n  const logo = brand.logoUrl\n    ? `<img src=\"${escapeHtml(brand.logoUrl)}\" alt=\"${escapeHtml(brand.name ?? title)}\" height=\"${LOGO_HEIGHT_PX}\" style=\"height: ${LOGO_HEIGHT_PX}px; width: auto; display: block; margin-bottom: 8px;\" />`\n    : \"\";\n  return `${logo}<span style=\"color: ${onAccent}; font-size: 18px; font-weight: 700; line-height: 1.3;\">${escapeHtml(title)}</span>`;\n}\n\n/**\n * Render `body` (markdown) into a complete, style-inlined email document\n * using the responsive layout. When `opts.brand` is set its accent, font,\n * and logo style the layout; otherwise a neutral default palette is used.\n */\nexport function renderEmailHtml(opts: EmailHtmlOptions): string {\n  const title = opts.subject?.trim() || \"Message\";\n  const accent = opts.brand?.accent ?? DEFAULT_BRAND.accent;\n  const onAccent = opts.brand?.onAccent ?? DEFAULT_BRAND.onAccent;\n  const fontFamily = opts.brand?.fontFamily ?? DEFAULT_BRAND.fontFamily;\n  const brand: EmailBrand = opts.brand ?? { accent, onAccent, fontFamily };\n  const doc = `<!doctype html>\n<html lang=\"en\">\n  <head>\n    <meta charset=\"utf-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />\n    <meta name=\"color-scheme\" content=\"light only\" />\n    <title>${escapeHtml(title)}</title>\n    <style>${contentCss(accent)}\n    </style>\n  </head>\n  <body style=\"margin: 0; padding: 0; background-color: #f4f5f7; -webkit-text-size-adjust: 100%;\">\n    <table role=\"presentation\" width=\"100%\" cellpadding=\"0\" cellspacing=\"0\" style=\"background-color: #f4f5f7;\">\n      <tr>\n        <td align=\"center\" style=\"padding: 24px 12px;\">\n          <table role=\"presentation\" class=\"container\" width=\"600\" cellpadding=\"0\" cellspacing=\"0\" style=\"width: 600px; max-width: 100%; background-color: #ffffff; border-radius: 10px; overflow: hidden; box-shadow: 0 1px 3px rgba(0,0,0,0.08); font-family: ${fontFamily};\">\n            <tr>\n              <td class=\"gutter\" style=\"padding: 20px 32px; background-color: ${accent};\">\n                ${headerBand(title, brand, onAccent)}\n              </td>\n            </tr>\n            <tr>\n              <td class=\"gutter\" style=\"padding: 24px 32px 8px;\">\n                ${metaBlock(opts.headers)}\n                <div class=\"email-body\">${markdownToHtml(opts.body)}</div>\n              </td>\n            </tr>${footerRow(opts.footer)}\n          </table>\n        </td>\n      </tr>\n    </table>\n  </body>\n</html>\n`;\n  return juice(doc);\n}\n"]}

package/lib/src/markdown.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Server-side markdown -> HTML rendering for email bodies. The model
+ * drafts bodies in markdown; this turns them into real HTML (GFM tables,
+ * lists, code, links). {@link normalizeMarkdown} first repairs the two
+ * structures LLMs most often emit as plain text instead of markdown -
+ * `=====` divider rules and pipe tables missing their `| --- |`
+ * separator row - so they render as a `<hr>` / `<table>` rather than
+ * literal text. The prompt steers the model away from ASCII art; this is
+ * the belt-and-suspenders fallback.
+ *
+ * @module
+ */
+/**
+ * Repair common LLM "looks-like-markdown-but-isn't" output: convert
+ * standalone `=====` / `_____` rules to a `---` thematic break (leaving
+ * genuine setext-heading underlines intact), and insert a `| --- |`
+ * separator after the first row of a pipe block that lacks one so GFM
+ * renders it as a table.
+ */
+export declare function normalizeMarkdown(src: string): string;
+/** Render a markdown body to an HTML fragment (GFM tables enabled). */
+export declare function markdownToHtml(body: string): string;

package/lib/src/markdown.js

@@ -0,0 +1,81 @@
+/**
+ * Server-side markdown -> HTML rendering for email bodies. The model
+ * drafts bodies in markdown; this turns them into real HTML (GFM tables,
+ * lists, code, links). {@link normalizeMarkdown} first repairs the two
+ * structures LLMs most often emit as plain text instead of markdown -
+ * `=====` divider rules and pipe tables missing their `| --- |`
+ * separator row - so they render as a `<hr>` / `<table>` rather than
+ * literal text. The prompt steers the model away from ASCII art; this is
+ * the belt-and-suspenders fallback.
+ *
+ * @module
+ */
+import { marked } from "marked";
+/** A line of only `=` or `_` (length >= 3): an ASCII divider rule. */
+function isAsciiRule(line) {
+    return /^[ \t]*[=_]{3,}[ \t]*$/.test(line);
+}
+/** A line that participates in a markdown pipe table (has a `|`). */
+function isPipeRow(line) {
+    return line.includes("|") && line.trim().length > 0;
+}
+/** A markdown table separator row, e.g. `| --- | :--: |`. */
+function isSeparatorRow(line) {
+    return /^[ \t]*\|?[ \t]*:?-{2,}:?[ \t]*(\|[ \t]*:?-{2,}:?[ \t]*)+\|?[ \t]*$/.test(line);
+}
+/** Column count of a pipe row (outer pipes optional). */
+function pipeColumns(line) {
+    return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").length;
+}
+/** A GFM separator row with `columns` cells. */
+function separatorRow(columns) {
+    return `| ${Array.from({ length: columns }, () => "---").join(" | ")} |`;
+}
+/**
+ * Repair common LLM "looks-like-markdown-but-isn't" output: convert
+ * standalone `=====` / `_____` rules to a `---` thematic break (leaving
+ * genuine setext-heading underlines intact), and insert a `| --- |`
+ * separator after the first row of a pipe block that lacks one so GFM
+ * renders it as a table.
+ */
+export function normalizeMarkdown(src) {
+    const lines = src.split("\n");
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const prev = i > 0 ? lines[i - 1] : "";
+        const next = i + 1 < lines.length ? lines[i + 1] : "";
+        if (isAsciiRule(line)) {
+            // A run of `=` directly under a non-blank text line is a setext H1
+            // underline - keep it. Anything else is a decorative divider.
+            const isSetextUnderline = /^[ \t]*={3,}[ \t]*$/.test(line) && prev.trim() !== "" && !isPipeRow(prev);
+            out.push(isSetextUnderline ? line : "---");
+            continue;
+        }
+        // First row of a pipe block (prev is not itself a pipe row) followed
+        // by another aligned pipe row, with no separator and no `###` bar-
+        // chart fill: treat as a table header and inject the separator.
+        const startsPipeBlock = isPipeRow(line) && !isPipeRow(prev);
+        if (startsPipeBlock &&
+            isPipeRow(next) &&
+            !isSeparatorRow(next) &&
+            !/#{3,}/.test(line) &&
+            pipeColumns(line) >= 2 &&
+            pipeColumns(line) === pipeColumns(next)) {
+            out.push(line);
+            out.push(separatorRow(pipeColumns(line)));
+            continue;
+        }
+        out.push(line);
+    }
+    return out.join("\n");
+}
+/** Render a markdown body to an HTML fragment (GFM tables enabled). */
+export function markdownToHtml(body) {
+    return marked.parse(normalizeMarkdown(body), {
+        async: false,
+        gfm: true,
+        breaks: true,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/outbox.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Filesystem outbox for the no-SMTP fallback: {@link writeOutboxEmail}
+ * persists one drafted message as a standalone HTML file under
+ * `<dir>/<from>/<timestamp>-<subject-slug>.html` instead of sending it.
+ * This lets the approval flow and agents be exercised end-to-end with
+ * zero email configuration - open the file in a browser to see exactly
+ * what would have gone out (the HTML matches the SMTP send, headers
+ * table aside). The body is rendered + style-inlined by
+ * {@link renderEmailHtml}. Attachments are listed by filename in the
+ * header table but not written to disk - the outbox previews the
+ * envelope, it doesn't reproduce the wire payload.
+ *
+ * @module
+ */
+import type { EmailMessage } from "@dbx-tools/shared-email";
+import type { EmailBrand } from "./brand.js";
+/**
+ * Write one message as HTML under `<dir>/<from>/` and return the
+ * absolute path. The per-sender folder mirrors the SMTP `From`, so test
+ * output groups by who the message would have been sent as.
+ */
+export declare function writeOutboxEmail(message: EmailMessage, from: string, dir: string, brand?: EmailBrand): Promise<string>;

package/lib/src/outbox.js

@@ -0,0 +1,60 @@
+/**
+ * Filesystem outbox for the no-SMTP fallback: {@link writeOutboxEmail}
+ * persists one drafted message as a standalone HTML file under
+ * `<dir>/<from>/<timestamp>-<subject-slug>.html` instead of sending it.
+ * This lets the approval flow and agents be exercised end-to-end with
+ * zero email configuration - open the file in a browser to see exactly
+ * what would have gone out (the HTML matches the SMTP send, headers
+ * table aside). The body is rendered + style-inlined by
+ * {@link renderEmailHtml}. Attachments are listed by filename in the
+ * header table but not written to disk - the outbox previews the
+ * envelope, it doesn't reproduce the wire payload.
+ *
+ * @module
+ */
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { string } from "@dbx-tools/shared-core";
+import { renderEmailHtml } from "./email-html.js";
+/**
+ * Longest subject slug kept in an outbox file name, leaving room for the
+ * timestamp prefix and extension inside common filesystem name limits.
+ */
+const SUBJECT_SLUG_MAX_LENGTH = 48;
+/** Filesystem-safe slug of the subject for the file name. */
+function subjectSlug(subject) {
+    return string.toSlugWithOptions({ maxLength: SUBJECT_SLUG_MAX_LENGTH }, subject) || "email";
+}
+/** The envelope rows shown above the body in the preview file. */
+function headerRows(message, from) {
+    const rows = [
+        ["From", from],
+        ["To", message.to.join(", ")],
+        ["Cc", message.cc?.join(", ")],
+        ["Bcc", message.bcc?.join(", ")],
+        ["Subject", message.subject],
+        ["Attachments", message.attachments?.map((att) => att.filename).join(", ")],
+        ["Date", new Date().toISOString()],
+    ];
+    return rows.filter((row) => Boolean(row[1]));
+}
+/**
+ * Write one message as HTML under `<dir>/<from>/` and return the
+ * absolute path. The per-sender folder mirrors the SMTP `From`, so test
+ * output groups by who the message would have been sent as.
+ */
+export async function writeOutboxEmail(message, from, dir, brand) {
+    const folder = resolve(dir, from);
+    await mkdir(folder, { recursive: true });
+    const path = join(folder, `${Date.now()}-${subjectSlug(message.subject)}.html`);
+    const html = renderEmailHtml({
+        subject: message.subject,
+        headers: headerRows(message, from),
+        body: message.body,
+        footer: "Local outbox preview - written to disk, not sent (no SMTP credentials configured).",
+        ...(brand ? { brand } : {}),
+    });
+    await writeFile(path, html, "utf8");
+    return path;
+}
+//# sourceMappingURL=data:application/json;base64,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