@dbx-tools/shared-email-template 0.6.51 → 0.6.53

package/README.md

@@ -40,6 +40,36 @@ import { EmailDocument } from "@dbx-tools/shared-email-template";
 Node runtimes should pass this component to `@react-email/render`.
 `@dbx-tools/email` does that automatically for SMTP and local outbox delivery.
 
+## Bind A One-Time Code To Your Domain
+
+Apple's AutoFill can tie a code to a specific website, so the keyboard offers it
+only on the matching domain - which is what stops a code phished from one site
+being autofilled into another. The format is `@<domain> #<code>` and iOS honours
+it only as the message's **final** line, so it is a document-level `trailer` prop
+rather than something a caller appends to `body` (the branded footer renders after
+the body).
+
+```tsx
+import { autofillTrailer, EmailDocument } from "@dbx-tools/shared-email-template";
+
+<EmailDocument
+  subject="Your verification code"
+  body={"Your verification code is:\n\n## 123456"}
+  trailer={autofillTrailer("demo.apps.dbx.tools", "123456")}
+/>;
+```
+
+`autofillTrailer()` normalizes a configured URL down to the bare host iOS matches
+on (scheme, `www.`, port, path, and trailing dot are stripped) and returns
+`undefined` when there is nothing to match - no domain, no code, or a hostless
+value like `localhost`. Passing `undefined` renders no trailer, so a deployment
+without a public domain simply omits it.
+
+This is a strict upgrade on top of the conventional layout, never a replacement:
+a prompt line followed by the bare code alone is what iOS, Gmail, Outlook, and
+Android already detect heuristically. `@dbx-tools/email` accepts the built string
+as a delivery option (`sendEmail(message, from, signal, { trailer })`).
+
 ## Reuse The Body Preview
 
 ```tsx
@@ -74,8 +104,8 @@ font, name, tagline, website, and fetchable logo URL.
 
 ## Modules
 
-- `.` - `EmailDocument`, `EmailCard`, `EmailBody`, brand types/defaults, and
-  content normalization.
+- `.` - `EmailDocument`, `EmailCard`, `EmailBody`, `autofillTrailer()`, brand
+  types/defaults, and content normalization.
 
 Pair this package with [`@dbx-tools/shared-email`](../email) for wire schemas,
 [`@dbx-tools/email`](../../node/email) for delivery, and

package/index.ts

@@ -3,5 +3,5 @@
 // Hand edits are overwritten on the next watch; this file is read-only.
 
 export * as template from "./src/template.tsx";
-export { emailBrandFromContext, defaultEmailBrand, resolveEmailBrand, normalizeEmailMarkdown, EmailBody, EmailCard, EmailDocument } from "./src/template.tsx";
+export { emailBrandFromContext, defaultEmailBrand, resolveEmailBrand, normalizeEmailMarkdown, EmailBody, autofillTrailer, EmailCard, EmailDocument } from "./src/template.tsx";
 export type { EmailBrand, ResolvedEmailBrand, EmailBodyProps, EmailDocumentProps } from "./src/template.tsx";

package/lib/index.d.ts

@@ -1,3 +1,3 @@
 export * as template from "./src/template.tsx";
-export { emailBrandFromContext, defaultEmailBrand, resolveEmailBrand, normalizeEmailMarkdown, EmailBody, EmailCard, EmailDocument } from "./src/template.tsx";
+export { emailBrandFromContext, defaultEmailBrand, resolveEmailBrand, normalizeEmailMarkdown, EmailBody, autofillTrailer, EmailCard, EmailDocument } from "./src/template.tsx";
 export type { EmailBrand, ResolvedEmailBrand, EmailBodyProps, EmailDocumentProps } from "./src/template.tsx";

package/lib/index.js

@@ -2,5 +2,5 @@
 // Regenerated from the exporting modules in ./src.
 // Hand edits are overwritten on the next watch; this file is read-only.
 export * as template from "./src/template.js";
-export { emailBrandFromContext, defaultEmailBrand, resolveEmailBrand, normalizeEmailMarkdown, EmailBody, EmailCard, EmailDocument } from "./src/template.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssUUFBUSxNQUFNLG1CQUFvQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxpQkFBaUIsRUFBRSxpQkFBaUIsRUFBRSxzQkFBc0IsRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLGFBQWEsRUFBRSxNQUFNLG1CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR0VORVJBVEVEIGJ5IHByb2plbiB3YXRjaCAtIERPIE5PVCBFRElULlxuLy8gUmVnZW5lcmF0ZWQgZnJvbSB0aGUgZXhwb3J0aW5nIG1vZHVsZXMgaW4gLi9zcmMuXG4vLyBIYW5kIGVkaXRzIGFyZSBvdmVyd3JpdHRlbiBvbiB0aGUgbmV4dCB3YXRjaDsgdGhpcyBmaWxlIGlzIHJlYWQtb25seS5cblxuZXhwb3J0ICogYXMgdGVtcGxhdGUgZnJvbSBcIi4vc3JjL3RlbXBsYXRlLnRzeFwiO1xuZXhwb3J0IHsgZW1haWxCcmFuZEZyb21Db250ZXh0LCBkZWZhdWx0RW1haWxCcmFuZCwgcmVzb2x2ZUVtYWlsQnJhbmQsIG5vcm1hbGl6ZUVtYWlsTWFya2Rvd24sIEVtYWlsQm9keSwgRW1haWxDYXJkLCBFbWFpbERvY3VtZW50IH0gZnJvbSBcIi4vc3JjL3RlbXBsYXRlLnRzeFwiO1xuZXhwb3J0IHR5cGUgeyBFbWFpbEJyYW5kLCBSZXNvbHZlZEVtYWlsQnJhbmQsIEVtYWlsQm9keVByb3BzLCBFbWFpbERvY3VtZW50UHJvcHMgfSBmcm9tIFwiLi9zcmMvdGVtcGxhdGUudHN4XCI7XG4iXX0=
+export { emailBrandFromContext, defaultEmailBrand, resolveEmailBrand, normalizeEmailMarkdown, EmailBody, autofillTrailer, EmailCard, EmailDocument } from "./src/template.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQ0FBMkM7QUFDM0MsbURBQW1EO0FBQ25ELHdFQUF3RTtBQUV4RSxPQUFPLEtBQUssUUFBUSxNQUFNLG1CQUFvQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxpQkFBaUIsRUFBRSxpQkFBaUIsRUFBRSxzQkFBc0IsRUFBRSxTQUFTLEVBQUUsZUFBZSxFQUFFLFNBQVMsRUFBRSxhQUFhLEVBQUUsTUFBTSxtQkFBb0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdFTkVSQVRFRCBieSBwcm9qZW4gd2F0Y2ggLSBETyBOT1QgRURJVC5cbi8vIFJlZ2VuZXJhdGVkIGZyb20gdGhlIGV4cG9ydGluZyBtb2R1bGVzIGluIC4vc3JjLlxuLy8gSGFuZCBlZGl0cyBhcmUgb3ZlcndyaXR0ZW4gb24gdGhlIG5leHQgd2F0Y2g7IHRoaXMgZmlsZSBpcyByZWFkLW9ubHkuXG5cbmV4cG9ydCAqIGFzIHRlbXBsYXRlIGZyb20gXCIuL3NyYy90ZW1wbGF0ZS50c3hcIjtcbmV4cG9ydCB7IGVtYWlsQnJhbmRGcm9tQ29udGV4dCwgZGVmYXVsdEVtYWlsQnJhbmQsIHJlc29sdmVFbWFpbEJyYW5kLCBub3JtYWxpemVFbWFpbE1hcmtkb3duLCBFbWFpbEJvZHksIGF1dG9maWxsVHJhaWxlciwgRW1haWxDYXJkLCBFbWFpbERvY3VtZW50IH0gZnJvbSBcIi4vc3JjL3RlbXBsYXRlLnRzeFwiO1xuZXhwb3J0IHR5cGUgeyBFbWFpbEJyYW5kLCBSZXNvbHZlZEVtYWlsQnJhbmQsIEVtYWlsQm9keVByb3BzLCBFbWFpbERvY3VtZW50UHJvcHMgfSBmcm9tIFwiLi9zcmMvdGVtcGxhdGUudHN4XCI7XG4iXX0=

package/lib/src/template.d.ts

@@ -5,6 +5,11 @@
  * the body component is reused directly by browser approval and compose views.
  * Both default to the repository brand while accepting a consumer override.
  *
+ * {@link autofillTrailer} + the document's `trailer` prop cover Apple's
+ * domain-bound one-time-code AutoFill, which requires `@<domain> #<code>` to be
+ * the message's final line - hence a document-level prop rather than something a
+ * caller can append to `body`.
+ *
  * @module
  */
 import { type BrandContext } from "@dbx-tools/shared-core";
@@ -46,7 +51,43 @@ export interface EmailDocumentProps extends EmailBodyProps {
     subject?: string;
     headers?: ReadonlyArray<readonly [string, string]>;
     footer?: string;
+    /**
+     * A machine-read line emitted as the very LAST line of both MIME parts, after
+     * the branded footer and outside the card.
+     *
+     * This exists for Apple's domain-bound one-time-code AutoFill, whose format is
+     * `@<domain> #<code>` and which iOS only honours when it is the final line of
+     * the message - so it cannot be appended to `body`, which the branded footer
+     * would then follow. Rendered as visible-but-quiet text rather than hidden
+     * (`display: none` content is a spam signal, and a client that ignores the
+     * convention should show something innocuous rather than nothing).
+     *
+     * See {@link autofillTrailer}, which builds the string.
+     */
+    trailer?: string;
 }
+/**
+ * Apple's domain-bound AutoFill trailer, `@<domain> #<code>`, or `undefined`
+ * when either part is missing.
+ *
+ * iOS reads this to bind a code to a specific WEBSITE: with it, the keyboard
+ * offers the code only for the matching domain, which is what stops a code
+ * phished from one site being autofilled into another. Without it, iOS still
+ * detects a code heuristically from the conventional layout (prompt line, bare
+ * code alone on the next line), as do Gmail, Outlook, and Android - so this is a
+ * strict upgrade on top of that baseline, never a replacement for it.
+ *
+ * The domain is normalized to bare host form: a scheme, a `www.` prefix, any
+ * path, and a trailing dot are stripped, since iOS matches the host the site is
+ * served from. A domain with no dot (`localhost`) is rejected - it cannot be the
+ * public host of a real deployment, and a trailer iOS will never match is just a
+ * confusing line in the email.
+ *
+ * @example
+ * autofillTrailer("demo.apps.dbx.tools", "123456"); // "@demo.apps.dbx.tools #123456"
+ * autofillTrailer("https://www.example.com/app", "123456"); // "@example.com #123456"
+ */
+export declare const autofillTrailer: (domain: string | undefined, code: string | undefined) => string | undefined;
 /** Branded message card shared by the full document and browser previews. */
 export declare const EmailCard: ({ body, subject, headers, footer, brand: brandInput, }: EmailDocumentProps) => React.JSX.Element;
 /** Complete responsive, branded React Email document. */

package/lib/src/template.js

@@ -6,6 +6,11 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * the body component is reused directly by browser approval and compose views.
  * Both default to the repository brand while accepting a consumer override.
  *
+ * {@link autofillTrailer} + the document's `trailer` prop cover Apple's
+ * domain-bound one-time-code AutoFill, which requires `@<domain> #<code>` to be
+ * the message's final line - hence a document-level prop rather than something a
+ * caller can append to `body`.
+ *
  * @module
  */
 import { brand } from "@dbx-tools/shared-core";
@@ -124,6 +129,42 @@ export const EmailBody = ({ body, brand: brandInput }) => {
             },
         }, children: normalizeEmailMarkdown(body) }));
 };
+/**
+ * Apple's domain-bound AutoFill trailer, `@<domain> #<code>`, or `undefined`
+ * when either part is missing.
+ *
+ * iOS reads this to bind a code to a specific WEBSITE: with it, the keyboard
+ * offers the code only for the matching domain, which is what stops a code
+ * phished from one site being autofilled into another. Without it, iOS still
+ * detects a code heuristically from the conventional layout (prompt line, bare
+ * code alone on the next line), as do Gmail, Outlook, and Android - so this is a
+ * strict upgrade on top of that baseline, never a replacement for it.
+ *
+ * The domain is normalized to bare host form: a scheme, a `www.` prefix, any
+ * path, and a trailing dot are stripped, since iOS matches the host the site is
+ * served from. A domain with no dot (`localhost`) is rejected - it cannot be the
+ * public host of a real deployment, and a trailer iOS will never match is just a
+ * confusing line in the email.
+ *
+ * @example
+ * autofillTrailer("demo.apps.dbx.tools", "123456"); // "@demo.apps.dbx.tools #123456"
+ * autofillTrailer("https://www.example.com/app", "123456"); // "@example.com #123456"
+ */
+export const autofillTrailer = (domain, code) => {
+    if (!domain || !code)
+        return undefined;
+    const host = domain
+        .trim()
+        .toLowerCase()
+        .replace(/^[a-z][a-z\d+.-]*:\/\//, "")
+        .replace(/^www\./, "")
+        .replace(/[/?#].*$/, "")
+        .replace(/\.$/, "")
+        .replace(/:\d+$/, "");
+    if (!host.includes("."))
+        return undefined;
+    return `@${host} #${code.trim()}`;
+};
 function BrandMark({ theme }) {
     if (theme.logoUrl) {
         return (_jsx(Img, { src: theme.logoUrl, alt: theme.name, height: "34", style: { display: "block", height: "34px", width: "auto" } }));
@@ -180,6 +221,26 @@ export const EmailCard = ({ body, subject = "Message", headers, footer, brand: b
                                 textDecoration: "none",
                             }, children: theme.name })) : null] }) })] }));
 };
+/**
+ * The machine-read trailer line, rendered LAST and outside the card.
+ *
+ * Deliberately the final element of `<Body>`: iOS only binds a code to a domain
+ * when `@<domain> #<code>` is the last line of the message, so nothing - not even
+ * the branded footer - may follow it. Styled small and muted rather than hidden,
+ * because `display: none` text is a spam-filter signal.
+ */
+function AutofillTrailer({ trailer, theme, }) {
+    if (!trailer)
+        return null;
+    return (_jsx(Text, { style: {
+            color: theme.muted,
+            fontFamily: theme.fontFamily,
+            fontSize: "11px",
+            margin: "16px auto 0",
+            maxWidth: "620px",
+            textAlign: "center",
+        }, children: trailer }));
+}
 /** Complete responsive, branded React Email document. */
 export const EmailDocument = (props) => {
     const theme = resolveEmailBrand(props.brand);
@@ -189,6 +250,6 @@ export const EmailDocument = (props) => {
         margin: 0,
         padding: "28px 12px",
     };
-    return (_jsxs(Html, { lang: "en", children: [_jsx(Head, {}), _jsx(Preview, { children: props.subject ?? "Message" }), _jsx(Body, { style: pageStyle, children: _jsx(EmailCard, { ...props }) })] }));
+    return (_jsxs(Html, { lang: "en", children: [_jsx(Head, {}), _jsx(Preview, { children: props.subject ?? "Message" }), _jsxs(Body, { style: pageStyle, children: [_jsx(EmailCard, { ...props }), _jsx(AutofillTrailer, { trailer: props.trailer, theme: theme })] })] }));
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template.js","sourceRoot":"","sources":["../../src/template.tsx"],"names":[],"mappings":"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","sourcesContent":["/**\n * Universal React Email presentation for dbx-tools email flows.\n *\n * The document component renders on the server through `@react-email/render`;\n * the body component is reused directly by browser approval and compose views.\n * Both default to the repository brand while accepting a consumer override.\n *\n * @module\n */\nimport { brand, type BrandContext } from \"@dbx-tools/shared-core\";\nimport {\n  Body,\n  Column,\n  Container,\n  Head,\n  Heading,\n  Hr,\n  Html,\n  Img,\n  Link,\n  Markdown,\n  Preview,\n  Row,\n  Section,\n  Text,\n} from \"@react-email/components\";\nimport * as React from \"react\";\n\n/** Email-safe brand values used by the React Email template. */\nexport interface EmailBrand {\n  accent: string;\n  onAccent?: string;\n  fontFamily: string;\n  name?: string;\n  logoUrl?: string;\n  background?: string;\n  surface?: string;\n  foreground?: string;\n  muted?: string;\n  border?: string;\n  tagline?: string;\n  website?: string;\n}\n\n/** Complete values after applying the dbx-tools default brand. */\nexport type ResolvedEmailBrand = Required<\n  Pick<\n    EmailBrand,\n    | \"accent\"\n    | \"onAccent\"\n    | \"fontFamily\"\n    | \"name\"\n    | \"background\"\n    | \"surface\"\n    | \"foreground\"\n    | \"muted\"\n    | \"border\"\n    | \"tagline\"\n  >\n> &\n  Pick<EmailBrand, \"logoUrl\" | \"website\">;\n\nfunction isRenderableImageUrl(value: string | undefined): value is string {\n  return typeof value === \"string\" && /^(?:https?:|data:|cid:)/i.test(value);\n}\n\n/** Project a portable brand context into email-safe values. */\nexport const emailBrandFromContext = (context: BrandContext): EmailBrand => {\n  const logo = context.assets.logo.dark ?? context.assets.logo.light;\n  return {\n    accent: context.colors.primary,\n    onAccent: \"#ffffff\",\n    fontFamily: context.typography.sans,\n    name: context.name,\n    background: context.colors.surface,\n    surface: context.colors.background,\n    foreground: context.colors.foreground,\n    muted: context.colors.muted,\n    border: context.colors.border,\n    tagline: context.tagline,\n    website: context.links.website,\n    ...(isRenderableImageUrl(logo) ? { logoUrl: logo } : {}),\n  };\n};\n\n/** The repository brand used by every email unless explicitly overridden. */\nexport const defaultEmailBrand: EmailBrand = emailBrandFromContext(brand.defaultBrandContext);\n\n/** Merge a partial consumer brand over the repository default. */\nexport const resolveEmailBrand = (input?: EmailBrand): ResolvedEmailBrand => {\n  const merged = { ...defaultEmailBrand, ...input };\n  return {\n    accent: merged.accent,\n    onAccent: merged.onAccent ?? \"#ffffff\",\n    fontFamily: merged.fontFamily,\n    name: merged.name ?? brand.defaultBrandContext.name,\n    background: merged.background ?? brand.defaultBrandContext.colors.surface,\n    surface: merged.surface ?? brand.defaultBrandContext.colors.background,\n    foreground: merged.foreground ?? brand.defaultBrandContext.colors.foreground,\n    muted: merged.muted ?? brand.defaultBrandContext.colors.muted,\n    border: merged.border ?? brand.defaultBrandContext.colors.border,\n    tagline: merged.tagline ?? brand.defaultBrandContext.tagline,\n    ...(merged.logoUrl ? { logoUrl: merged.logoUrl } : {}),\n    ...(merged.website ? { website: merged.website } : {}),\n  };\n};\n\n/** Normalize indentation in authored content without constraining its structure. */\nexport const normalizeEmailMarkdown = (value: string): string => {\n  const lines = value.replace(/\\r\\n?/g, \"\\n\").split(\"\\n\");\n  while (lines[0]?.trim() === \"\") lines.shift();\n  while (lines.at(-1)?.trim() === \"\") lines.pop();\n  const nonBlank = lines.filter((line) => line.trim().length > 0);\n  const indent = nonBlank.reduce((minimum, line) => {\n    const width = line.match(/^\\s*/)?.[0].length ?? 0;\n    return Math.min(minimum, width);\n  }, Number.POSITIVE_INFINITY);\n  if (!Number.isFinite(indent) || indent === 0) return lines.join(\"\\n\");\n  return lines.map((line) => line.slice(Math.min(indent, line.length))).join(\"\\n\");\n};\n\n/** Props for the reusable message-body component. */\nexport interface EmailBodyProps {\n  body: string;\n  brand?: EmailBrand;\n}\n\n/** Render rich message content with email-client-safe inline styles. */\nexport const EmailBody = ({ body, brand: brandInput }: EmailBodyProps) => {\n  const theme = resolveEmailBrand(brandInput);\n  return (\n    <Markdown\n      markdownContainerStyles={{\n        color: theme.foreground,\n        fontFamily: theme.fontFamily,\n        fontSize: \"15px\",\n        lineHeight: \"1.65\",\n      }}\n      markdownCustomStyles={{\n        h1: { color: theme.foreground, fontSize: \"30px\", lineHeight: \"1.2\", margin: \"0 0 20px\" },\n        h2: { color: theme.foreground, fontSize: \"23px\", lineHeight: \"1.3\", margin: \"28px 0 12px\" },\n        h3: { color: theme.foreground, fontSize: \"18px\", lineHeight: \"1.4\", margin: \"24px 0 10px\" },\n        p: { margin: \"0 0 16px\" },\n        link: { color: theme.accent, fontWeight: 600, textDecoration: \"underline\" },\n        blockQuote: {\n          backgroundColor: theme.background,\n          borderLeft: `4px solid ${theme.accent}`,\n          borderRadius: \"0 10px 10px 0\",\n          color: theme.foreground,\n          margin: \"20px 0\",\n          padding: \"14px 18px\",\n        },\n        codeInline: {\n          backgroundColor: theme.background,\n          borderRadius: \"5px\",\n          color: theme.foreground,\n          fontFamily: brand.defaultBrandContext.typography.mono,\n          fontSize: \"13px\",\n          padding: \"2px 5px\",\n        },\n        codeBlock: {\n          backgroundColor: theme.foreground,\n          borderRadius: \"10px\",\n          color: theme.surface,\n          fontFamily: brand.defaultBrandContext.typography.mono,\n          fontSize: \"13px\",\n          lineHeight: \"1.55\",\n          margin: \"20px 0\",\n          padding: \"16px\",\n        },\n        hr: { borderColor: theme.border, margin: \"28px 0\" },\n        image: { borderRadius: \"10px\", height: \"auto\", maxWidth: \"100%\" },\n        li: { margin: \"6px 0\" },\n        table: { borderCollapse: \"collapse\", margin: \"20px 0\", width: \"100%\" },\n        th: {\n          backgroundColor: theme.background,\n          border: `1px solid ${theme.border}`,\n          padding: \"9px 12px\",\n          textAlign: \"left\",\n        },\n        td: {\n          border: `1px solid ${theme.border}`,\n          padding: \"9px 12px\",\n          textAlign: \"left\",\n        },\n      }}\n    >\n      {normalizeEmailMarkdown(body)}\n    </Markdown>\n  );\n};\n\n/** Props for the complete React Email document. */\nexport interface EmailDocumentProps extends EmailBodyProps {\n  subject?: string;\n  headers?: ReadonlyArray<readonly [string, string]>;\n  footer?: string;\n}\n\nfunction BrandMark({ theme }: { theme: ResolvedEmailBrand }): React.ReactNode {\n  if (theme.logoUrl) {\n    return (\n      <Img\n        src={theme.logoUrl}\n        alt={theme.name}\n        height=\"34\"\n        style={{ display: \"block\", height: \"34px\", width: \"auto\" }}\n      />\n    );\n  }\n  return (\n    <Text\n      style={{\n        color: theme.onAccent,\n        fontSize: \"20px\",\n        fontWeight: 800,\n        letterSpacing: \"-0.3px\",\n        margin: 0,\n      }}\n    >\n      {theme.name}\n    </Text>\n  );\n}\n\nfunction EnvelopeHeaders({\n  headers,\n  theme,\n}: {\n  headers: EmailDocumentProps[\"headers\"];\n  theme: ResolvedEmailBrand;\n}) {\n  if (!headers?.length) return null;\n  return (\n    <Section\n      style={{\n        backgroundColor: theme.background,\n        borderRadius: \"10px\",\n        margin: \"0 0 24px\",\n        padding: \"14px 16px\",\n      }}\n    >\n      {headers.map(([label, value]) => (\n        <Row key={`${label}:${value}`}>\n          <Column\n            style={{\n              color: theme.muted,\n              fontSize: \"12px\",\n              fontWeight: 700,\n              padding: \"3px 12px 3px 0\",\n              width: \"70px\",\n            }}\n          >\n            {label}\n          </Column>\n          <Column style={{ color: theme.foreground, fontSize: \"13px\", padding: \"3px 0\" }}>\n            {value}\n          </Column>\n        </Row>\n      ))}\n    </Section>\n  );\n}\n\n/** Branded message card shared by the full document and browser previews. */\nexport const EmailCard = ({\n  body,\n  subject = \"Message\",\n  headers,\n  footer,\n  brand: brandInput,\n}: EmailDocumentProps) => {\n  const theme = resolveEmailBrand(brandInput);\n  return (\n    <Container\n      style={{\n        backgroundColor: theme.surface,\n        border: `1px solid ${theme.border}`,\n        borderRadius: \"16px\",\n        boxShadow: \"0 8px 30px rgba(27,49,57,0.08)\",\n        fontFamily: theme.fontFamily,\n        margin: \"0 auto\",\n        maxWidth: \"620px\",\n        overflow: \"hidden\",\n      }}\n    >\n      <Section style={{ backgroundColor: theme.accent, padding: \"22px 30px\" }}>\n        <BrandMark theme={theme} />\n      </Section>\n      <Section style={{ padding: \"34px 34px 24px\" }}>\n        <Heading\n          style={{\n            color: theme.foreground,\n            fontSize: \"28px\",\n            letterSpacing: \"-0.5px\",\n            lineHeight: \"1.2\",\n            margin: \"0 0 24px\",\n          }}\n        >\n          {subject}\n        </Heading>\n        <EnvelopeHeaders headers={headers} theme={theme} />\n        <EmailBody body={body} brand={theme} />\n      </Section>\n      <Hr style={{ borderColor: theme.border, margin: 0 }} />\n      <Section style={{ padding: \"20px 34px 26px\" }}>\n        <Text\n          style={{\n            color: theme.muted,\n            fontSize: \"12px\",\n            lineHeight: \"1.55\",\n            margin: 0,\n          }}\n        >\n          {footer ?? theme.tagline}{\" \"}\n          {theme.website ? (\n            <Link\n              href={theme.website}\n              style={{\n                color: theme.accent,\n                textDecoration: \"none\",\n              }}\n            >\n              {theme.name}\n            </Link>\n          ) : null}\n        </Text>\n      </Section>\n    </Container>\n  );\n};\n\n/** Complete responsive, branded React Email document. */\nexport const EmailDocument = (props: EmailDocumentProps) => {\n  const theme = resolveEmailBrand(props.brand);\n  const pageStyle: React.CSSProperties = {\n    backgroundColor: theme.background,\n    fontFamily: theme.fontFamily,\n    margin: 0,\n    padding: \"28px 12px\",\n  };\n  return (\n    <Html lang=\"en\">\n      <Head />\n      <Preview>{props.subject ?? \"Message\"}</Preview>\n      <Body style={pageStyle}>\n        <EmailCard {...props} />\n      </Body>\n    </Html>\n  );\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"template.js","sourceRoot":"","sources":["../../src/template.tsx"],"names":[],"mappings":"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","sourcesContent":["/**\n * Universal React Email presentation for dbx-tools email flows.\n *\n * The document component renders on the server through `@react-email/render`;\n * the body component is reused directly by browser approval and compose views.\n * Both default to the repository brand while accepting a consumer override.\n *\n * {@link autofillTrailer} + the document's `trailer` prop cover Apple's\n * domain-bound one-time-code AutoFill, which requires `@<domain> #<code>` to be\n * the message's final line - hence a document-level prop rather than something a\n * caller can append to `body`.\n *\n * @module\n */\nimport { brand, type BrandContext } from \"@dbx-tools/shared-core\";\nimport {\n  Body,\n  Column,\n  Container,\n  Head,\n  Heading,\n  Hr,\n  Html,\n  Img,\n  Link,\n  Markdown,\n  Preview,\n  Row,\n  Section,\n  Text,\n} from \"@react-email/components\";\nimport * as React from \"react\";\n\n/** Email-safe brand values used by the React Email template. */\nexport interface EmailBrand {\n  accent: string;\n  onAccent?: string;\n  fontFamily: string;\n  name?: string;\n  logoUrl?: string;\n  background?: string;\n  surface?: string;\n  foreground?: string;\n  muted?: string;\n  border?: string;\n  tagline?: string;\n  website?: string;\n}\n\n/** Complete values after applying the dbx-tools default brand. */\nexport type ResolvedEmailBrand = Required<\n  Pick<\n    EmailBrand,\n    | \"accent\"\n    | \"onAccent\"\n    | \"fontFamily\"\n    | \"name\"\n    | \"background\"\n    | \"surface\"\n    | \"foreground\"\n    | \"muted\"\n    | \"border\"\n    | \"tagline\"\n  >\n> &\n  Pick<EmailBrand, \"logoUrl\" | \"website\">;\n\nfunction isRenderableImageUrl(value: string | undefined): value is string {\n  return typeof value === \"string\" && /^(?:https?:|data:|cid:)/i.test(value);\n}\n\n/** Project a portable brand context into email-safe values. */\nexport const emailBrandFromContext = (context: BrandContext): EmailBrand => {\n  const logo = context.assets.logo.dark ?? context.assets.logo.light;\n  return {\n    accent: context.colors.primary,\n    onAccent: \"#ffffff\",\n    fontFamily: context.typography.sans,\n    name: context.name,\n    background: context.colors.surface,\n    surface: context.colors.background,\n    foreground: context.colors.foreground,\n    muted: context.colors.muted,\n    border: context.colors.border,\n    tagline: context.tagline,\n    website: context.links.website,\n    ...(isRenderableImageUrl(logo) ? { logoUrl: logo } : {}),\n  };\n};\n\n/** The repository brand used by every email unless explicitly overridden. */\nexport const defaultEmailBrand: EmailBrand = emailBrandFromContext(brand.defaultBrandContext);\n\n/** Merge a partial consumer brand over the repository default. */\nexport const resolveEmailBrand = (input?: EmailBrand): ResolvedEmailBrand => {\n  const merged = { ...defaultEmailBrand, ...input };\n  return {\n    accent: merged.accent,\n    onAccent: merged.onAccent ?? \"#ffffff\",\n    fontFamily: merged.fontFamily,\n    name: merged.name ?? brand.defaultBrandContext.name,\n    background: merged.background ?? brand.defaultBrandContext.colors.surface,\n    surface: merged.surface ?? brand.defaultBrandContext.colors.background,\n    foreground: merged.foreground ?? brand.defaultBrandContext.colors.foreground,\n    muted: merged.muted ?? brand.defaultBrandContext.colors.muted,\n    border: merged.border ?? brand.defaultBrandContext.colors.border,\n    tagline: merged.tagline ?? brand.defaultBrandContext.tagline,\n    ...(merged.logoUrl ? { logoUrl: merged.logoUrl } : {}),\n    ...(merged.website ? { website: merged.website } : {}),\n  };\n};\n\n/** Normalize indentation in authored content without constraining its structure. */\nexport const normalizeEmailMarkdown = (value: string): string => {\n  const lines = value.replace(/\\r\\n?/g, \"\\n\").split(\"\\n\");\n  while (lines[0]?.trim() === \"\") lines.shift();\n  while (lines.at(-1)?.trim() === \"\") lines.pop();\n  const nonBlank = lines.filter((line) => line.trim().length > 0);\n  const indent = nonBlank.reduce((minimum, line) => {\n    const width = line.match(/^\\s*/)?.[0].length ?? 0;\n    return Math.min(minimum, width);\n  }, Number.POSITIVE_INFINITY);\n  if (!Number.isFinite(indent) || indent === 0) return lines.join(\"\\n\");\n  return lines.map((line) => line.slice(Math.min(indent, line.length))).join(\"\\n\");\n};\n\n/** Props for the reusable message-body component. */\nexport interface EmailBodyProps {\n  body: string;\n  brand?: EmailBrand;\n}\n\n/** Render rich message content with email-client-safe inline styles. */\nexport const EmailBody = ({ body, brand: brandInput }: EmailBodyProps) => {\n  const theme = resolveEmailBrand(brandInput);\n  return (\n    <Markdown\n      markdownContainerStyles={{\n        color: theme.foreground,\n        fontFamily: theme.fontFamily,\n        fontSize: \"15px\",\n        lineHeight: \"1.65\",\n      }}\n      markdownCustomStyles={{\n        h1: { color: theme.foreground, fontSize: \"30px\", lineHeight: \"1.2\", margin: \"0 0 20px\" },\n        h2: { color: theme.foreground, fontSize: \"23px\", lineHeight: \"1.3\", margin: \"28px 0 12px\" },\n        h3: { color: theme.foreground, fontSize: \"18px\", lineHeight: \"1.4\", margin: \"24px 0 10px\" },\n        p: { margin: \"0 0 16px\" },\n        link: { color: theme.accent, fontWeight: 600, textDecoration: \"underline\" },\n        blockQuote: {\n          backgroundColor: theme.background,\n          borderLeft: `4px solid ${theme.accent}`,\n          borderRadius: \"0 10px 10px 0\",\n          color: theme.foreground,\n          margin: \"20px 0\",\n          padding: \"14px 18px\",\n        },\n        codeInline: {\n          backgroundColor: theme.background,\n          borderRadius: \"5px\",\n          color: theme.foreground,\n          fontFamily: brand.defaultBrandContext.typography.mono,\n          fontSize: \"13px\",\n          padding: \"2px 5px\",\n        },\n        codeBlock: {\n          backgroundColor: theme.foreground,\n          borderRadius: \"10px\",\n          color: theme.surface,\n          fontFamily: brand.defaultBrandContext.typography.mono,\n          fontSize: \"13px\",\n          lineHeight: \"1.55\",\n          margin: \"20px 0\",\n          padding: \"16px\",\n        },\n        hr: { borderColor: theme.border, margin: \"28px 0\" },\n        image: { borderRadius: \"10px\", height: \"auto\", maxWidth: \"100%\" },\n        li: { margin: \"6px 0\" },\n        table: { borderCollapse: \"collapse\", margin: \"20px 0\", width: \"100%\" },\n        th: {\n          backgroundColor: theme.background,\n          border: `1px solid ${theme.border}`,\n          padding: \"9px 12px\",\n          textAlign: \"left\",\n        },\n        td: {\n          border: `1px solid ${theme.border}`,\n          padding: \"9px 12px\",\n          textAlign: \"left\",\n        },\n      }}\n    >\n      {normalizeEmailMarkdown(body)}\n    </Markdown>\n  );\n};\n\n/** Props for the complete React Email document. */\nexport interface EmailDocumentProps extends EmailBodyProps {\n  subject?: string;\n  headers?: ReadonlyArray<readonly [string, string]>;\n  footer?: string;\n  /**\n   * A machine-read line emitted as the very LAST line of both MIME parts, after\n   * the branded footer and outside the card.\n   *\n   * This exists for Apple's domain-bound one-time-code AutoFill, whose format is\n   * `@<domain> #<code>` and which iOS only honours when it is the final line of\n   * the message - so it cannot be appended to `body`, which the branded footer\n   * would then follow. Rendered as visible-but-quiet text rather than hidden\n   * (`display: none` content is a spam signal, and a client that ignores the\n   * convention should show something innocuous rather than nothing).\n   *\n   * See {@link autofillTrailer}, which builds the string.\n   */\n  trailer?: string;\n}\n\n/**\n * Apple's domain-bound AutoFill trailer, `@<domain> #<code>`, or `undefined`\n * when either part is missing.\n *\n * iOS reads this to bind a code to a specific WEBSITE: with it, the keyboard\n * offers the code only for the matching domain, which is what stops a code\n * phished from one site being autofilled into another. Without it, iOS still\n * detects a code heuristically from the conventional layout (prompt line, bare\n * code alone on the next line), as do Gmail, Outlook, and Android - so this is a\n * strict upgrade on top of that baseline, never a replacement for it.\n *\n * The domain is normalized to bare host form: a scheme, a `www.` prefix, any\n * path, and a trailing dot are stripped, since iOS matches the host the site is\n * served from. A domain with no dot (`localhost`) is rejected - it cannot be the\n * public host of a real deployment, and a trailer iOS will never match is just a\n * confusing line in the email.\n *\n * @example\n * autofillTrailer(\"demo.apps.dbx.tools\", \"123456\"); // \"@demo.apps.dbx.tools #123456\"\n * autofillTrailer(\"https://www.example.com/app\", \"123456\"); // \"@example.com #123456\"\n */\nexport const autofillTrailer = (\n  domain: string | undefined,\n  code: string | undefined,\n): string | undefined => {\n  if (!domain || !code) return undefined;\n  const host = domain\n    .trim()\n    .toLowerCase()\n    .replace(/^[a-z][a-z\\d+.-]*:\\/\\//, \"\")\n    .replace(/^www\\./, \"\")\n    .replace(/[/?#].*$/, \"\")\n    .replace(/\\.$/, \"\")\n    .replace(/:\\d+$/, \"\");\n  if (!host.includes(\".\")) return undefined;\n  return `@${host} #${code.trim()}`;\n};\n\nfunction BrandMark({ theme }: { theme: ResolvedEmailBrand }): React.ReactNode {\n  if (theme.logoUrl) {\n    return (\n      <Img\n        src={theme.logoUrl}\n        alt={theme.name}\n        height=\"34\"\n        style={{ display: \"block\", height: \"34px\", width: \"auto\" }}\n      />\n    );\n  }\n  return (\n    <Text\n      style={{\n        color: theme.onAccent,\n        fontSize: \"20px\",\n        fontWeight: 800,\n        letterSpacing: \"-0.3px\",\n        margin: 0,\n      }}\n    >\n      {theme.name}\n    </Text>\n  );\n}\n\nfunction EnvelopeHeaders({\n  headers,\n  theme,\n}: {\n  headers: EmailDocumentProps[\"headers\"];\n  theme: ResolvedEmailBrand;\n}) {\n  if (!headers?.length) return null;\n  return (\n    <Section\n      style={{\n        backgroundColor: theme.background,\n        borderRadius: \"10px\",\n        margin: \"0 0 24px\",\n        padding: \"14px 16px\",\n      }}\n    >\n      {headers.map(([label, value]) => (\n        <Row key={`${label}:${value}`}>\n          <Column\n            style={{\n              color: theme.muted,\n              fontSize: \"12px\",\n              fontWeight: 700,\n              padding: \"3px 12px 3px 0\",\n              width: \"70px\",\n            }}\n          >\n            {label}\n          </Column>\n          <Column style={{ color: theme.foreground, fontSize: \"13px\", padding: \"3px 0\" }}>\n            {value}\n          </Column>\n        </Row>\n      ))}\n    </Section>\n  );\n}\n\n/** Branded message card shared by the full document and browser previews. */\nexport const EmailCard = ({\n  body,\n  subject = \"Message\",\n  headers,\n  footer,\n  brand: brandInput,\n}: EmailDocumentProps) => {\n  const theme = resolveEmailBrand(brandInput);\n  return (\n    <Container\n      style={{\n        backgroundColor: theme.surface,\n        border: `1px solid ${theme.border}`,\n        borderRadius: \"16px\",\n        boxShadow: \"0 8px 30px rgba(27,49,57,0.08)\",\n        fontFamily: theme.fontFamily,\n        margin: \"0 auto\",\n        maxWidth: \"620px\",\n        overflow: \"hidden\",\n      }}\n    >\n      <Section style={{ backgroundColor: theme.accent, padding: \"22px 30px\" }}>\n        <BrandMark theme={theme} />\n      </Section>\n      <Section style={{ padding: \"34px 34px 24px\" }}>\n        <Heading\n          style={{\n            color: theme.foreground,\n            fontSize: \"28px\",\n            letterSpacing: \"-0.5px\",\n            lineHeight: \"1.2\",\n            margin: \"0 0 24px\",\n          }}\n        >\n          {subject}\n        </Heading>\n        <EnvelopeHeaders headers={headers} theme={theme} />\n        <EmailBody body={body} brand={theme} />\n      </Section>\n      <Hr style={{ borderColor: theme.border, margin: 0 }} />\n      <Section style={{ padding: \"20px 34px 26px\" }}>\n        <Text\n          style={{\n            color: theme.muted,\n            fontSize: \"12px\",\n            lineHeight: \"1.55\",\n            margin: 0,\n          }}\n        >\n          {footer ?? theme.tagline}{\" \"}\n          {theme.website ? (\n            <Link\n              href={theme.website}\n              style={{\n                color: theme.accent,\n                textDecoration: \"none\",\n              }}\n            >\n              {theme.name}\n            </Link>\n          ) : null}\n        </Text>\n      </Section>\n    </Container>\n  );\n};\n\n/**\n * The machine-read trailer line, rendered LAST and outside the card.\n *\n * Deliberately the final element of `<Body>`: iOS only binds a code to a domain\n * when `@<domain> #<code>` is the last line of the message, so nothing - not even\n * the branded footer - may follow it. Styled small and muted rather than hidden,\n * because `display: none` text is a spam-filter signal.\n */\nfunction AutofillTrailer({\n  trailer,\n  theme,\n}: {\n  trailer?: string;\n  theme: ResolvedEmailBrand;\n}): React.ReactNode {\n  if (!trailer) return null;\n  return (\n    <Text\n      style={{\n        color: theme.muted,\n        fontFamily: theme.fontFamily,\n        fontSize: \"11px\",\n        margin: \"16px auto 0\",\n        maxWidth: \"620px\",\n        textAlign: \"center\",\n      }}\n    >\n      {trailer}\n    </Text>\n  );\n}\n\n/** Complete responsive, branded React Email document. */\nexport const EmailDocument = (props: EmailDocumentProps) => {\n  const theme = resolveEmailBrand(props.brand);\n  const pageStyle: React.CSSProperties = {\n    backgroundColor: theme.background,\n    fontFamily: theme.fontFamily,\n    margin: 0,\n    padding: \"28px 12px\",\n  };\n  return (\n    <Html lang=\"en\">\n      <Head />\n      <Preview>{props.subject ?? \"Message\"}</Preview>\n      <Body style={pageStyle}>\n        <EmailCard {...props} />\n        <AutofillTrailer trailer={props.trailer} theme={theme} />\n      </Body>\n    </Html>\n  );\n};\n"]}

package/package.json

@@ -24,7 +24,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/shared-core": "0.6.51",
+    "@dbx-tools/shared-core": "0.6.53",
     "@react-email/components": "^1.0.12",
     "react": "^19.2.4"
   },
@@ -42,7 +42,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.51",
+  "version": "0.6.53",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/template.tsx

@@ -5,6 +5,11 @@
  * the body component is reused directly by browser approval and compose views.
  * Both default to the repository brand while accepting a consumer override.
  *
+ * {@link autofillTrailer} + the document's `trailer` prop cover Apple's
+ * domain-bound one-time-code AutoFill, which requires `@<domain> #<code>` to be
+ * the message's final line - hence a document-level prop rather than something a
+ * caller can append to `body`.
+ *
  * @module
  */
 import { brand, type BrandContext } from "@dbx-tools/shared-core";
@@ -195,8 +200,60 @@ export interface EmailDocumentProps extends EmailBodyProps {
   subject?: string;
   headers?: ReadonlyArray<readonly [string, string]>;
   footer?: string;
+  /**
+   * A machine-read line emitted as the very LAST line of both MIME parts, after
+   * the branded footer and outside the card.
+   *
+   * This exists for Apple's domain-bound one-time-code AutoFill, whose format is
+   * `@<domain> #<code>` and which iOS only honours when it is the final line of
+   * the message - so it cannot be appended to `body`, which the branded footer
+   * would then follow. Rendered as visible-but-quiet text rather than hidden
+   * (`display: none` content is a spam signal, and a client that ignores the
+   * convention should show something innocuous rather than nothing).
+   *
+   * See {@link autofillTrailer}, which builds the string.
+   */
+  trailer?: string;
 }
 
+/**
+ * Apple's domain-bound AutoFill trailer, `@<domain> #<code>`, or `undefined`
+ * when either part is missing.
+ *
+ * iOS reads this to bind a code to a specific WEBSITE: with it, the keyboard
+ * offers the code only for the matching domain, which is what stops a code
+ * phished from one site being autofilled into another. Without it, iOS still
+ * detects a code heuristically from the conventional layout (prompt line, bare
+ * code alone on the next line), as do Gmail, Outlook, and Android - so this is a
+ * strict upgrade on top of that baseline, never a replacement for it.
+ *
+ * The domain is normalized to bare host form: a scheme, a `www.` prefix, any
+ * path, and a trailing dot are stripped, since iOS matches the host the site is
+ * served from. A domain with no dot (`localhost`) is rejected - it cannot be the
+ * public host of a real deployment, and a trailer iOS will never match is just a
+ * confusing line in the email.
+ *
+ * @example
+ * autofillTrailer("demo.apps.dbx.tools", "123456"); // "@demo.apps.dbx.tools #123456"
+ * autofillTrailer("https://www.example.com/app", "123456"); // "@example.com #123456"
+ */
+export const autofillTrailer = (
+  domain: string | undefined,
+  code: string | undefined,
+): string | undefined => {
+  if (!domain || !code) return undefined;
+  const host = domain
+    .trim()
+    .toLowerCase()
+    .replace(/^[a-z][a-z\d+.-]*:\/\//, "")
+    .replace(/^www\./, "")
+    .replace(/[/?#].*$/, "")
+    .replace(/\.$/, "")
+    .replace(/:\d+$/, "");
+  if (!host.includes(".")) return undefined;
+  return `@${host} #${code.trim()}`;
+};
+
 function BrandMark({ theme }: { theme: ResolvedEmailBrand }): React.ReactNode {
   if (theme.logoUrl) {
     return (
@@ -330,6 +387,38 @@ export const EmailCard = ({
   );
 };
 
+/**
+ * The machine-read trailer line, rendered LAST and outside the card.
+ *
+ * Deliberately the final element of `<Body>`: iOS only binds a code to a domain
+ * when `@<domain> #<code>` is the last line of the message, so nothing - not even
+ * the branded footer - may follow it. Styled small and muted rather than hidden,
+ * because `display: none` text is a spam-filter signal.
+ */
+function AutofillTrailer({
+  trailer,
+  theme,
+}: {
+  trailer?: string;
+  theme: ResolvedEmailBrand;
+}): React.ReactNode {
+  if (!trailer) return null;
+  return (
+    <Text
+      style={{
+        color: theme.muted,
+        fontFamily: theme.fontFamily,
+        fontSize: "11px",
+        margin: "16px auto 0",
+        maxWidth: "620px",
+        textAlign: "center",
+      }}
+    >
+      {trailer}
+    </Text>
+  );
+}
+
 /** Complete responsive, branded React Email document. */
 export const EmailDocument = (props: EmailDocumentProps) => {
   const theme = resolveEmailBrand(props.brand);
@@ -345,6 +434,7 @@ export const EmailDocument = (props: EmailDocumentProps) => {
       <Preview>{props.subject ?? "Message"}</Preview>
       <Body style={pageStyle}>
         <EmailCard {...props} />
+        <AutofillTrailer trailer={props.trailer} theme={theme} />
       </Body>
     </Html>
   );