@samva/markup 0.8.0 → 0.10.0

package/dist/render-BQmfh94k.js

@@ -0,0 +1,257 @@
+import { P as emailElement, f as preheaderNode, v as serializeEmailHtml } from "./components-BZCqegS8.js";
+import { i as drainEmailDiagnostics, t as EmailNode } from "./jsx-runtime-CBlexoeR.js";
+import { n as applyStylesheet } from "./ir-CLhlklKV.js";
+import { r as hasBlockingDiagnostic, t as EmailCompileError } from "./diagnostics-CnKFefKz.js";
+//#region src/email/text.ts
+const PARAGRAPH = "\n\n";
+const LINE = "\n";
+const INVISIBLE = /\u200b|\u200c|\u200d|\u200e|\u200f|\u2060|\ufeff/g;
+const isLayoutTable = (props) => props.role === "presentation" || props.role === "none";
+/**
+* A data-table cell that reads as nothing and holds only imagery with empty alt text carries no
+* column of its own; an empty cell without such an image is a positional placeholder.
+*/
+const isDecorativeCell = (cell, context) => {
+	const images = collect(cell.children, (tag) => tag === "img", () => true);
+	return images.length > 0 && images.every((image) => image.props.alt === "") && childText(cell, context).trim() === "";
+};
+/** Wrap a block's content in separators; empty blocks contribute nothing. */
+const block = (inner, separator) => {
+	const trimmed = inner.replace(/^\s+/, "").replace(/\s+$/, "");
+	return trimmed === "" ? "" : `${separator}${trimmed}${separator}`;
+};
+const collect = (nodes, keep, descend) => nodes.flatMap((child) => {
+	if (child.type === "Fragment") return collect(child.children, keep, descend);
+	if (child.type !== "Element") return [];
+	if (keep(child.tag)) return [child];
+	return descend(child.tag) ? collect(child.children, keep, descend) : [];
+});
+const TABLE_SECTIONS = /* @__PURE__ */ new Set([
+	"thead",
+	"tbody",
+	"tfoot"
+]);
+const childText = (node, context) => node.children.map((child) => derive(child, context)).join("");
+const derive = (node, context) => {
+	switch (node.type) {
+		case "Text": return context.preformatted ? node.value : node.value.replace(INVISIBLE, "").replace(/[^\S\n]+/g, " ");
+		case "Raw": return node.text;
+		case "Fragment": return node.children.map((child) => derive(child, context)).join("");
+		case "Element": {
+			const spec = emailElement(node.tag);
+			if (spec === void 0) return childText(node, context);
+			switch (spec.layout) {
+				case "metadata": return "";
+				case "document":
+				case "inline":
+				case "list-item": return childText(node, context);
+				case "break": return LINE;
+				case "rule": return `${PARAGRAPH}---${PARAGRAPH}`;
+				case "image": {
+					const alt = typeof node.props.alt === "string" ? node.props.alt.trim() : "";
+					return alt === "" ? "" : `[${alt}]`;
+				}
+				case "link": {
+					const label = childText(node, context).replace(/\s+/g, " ").trim();
+					const href = typeof node.props.href === "string" ? node.props.href : "";
+					if (href === "" || href === label) return label;
+					return label === "" ? href : `${label} (${href})`;
+				}
+				case "list": {
+					const indent = "  ".repeat(context.listDepth);
+					const start = Number(node.props.start ?? 1);
+					const first = Number.isFinite(start) ? start : 1;
+					const nested = {
+						...context,
+						listDepth: context.listDepth + 1
+					};
+					const lines = collect(node.children, (tag) => tag === "li", () => false).map((item, index) => {
+						const marker = node.tag === "ol" ? `${first + index}.` : "-";
+						const continuation = `${indent}${" ".repeat(marker.length + 1)}`;
+						const [head = "", ...rest] = derive(item, nested).replace(/^\s+/, "").replace(/\s+$/, "").replace(/\n{2,}/g, LINE).split("\n");
+						return [`${indent}${marker} ${head}`, ...rest.map((line) => line.trim() === "" ? "" : /^\s/.test(line) ? line : `${continuation}${line}`)].join(LINE);
+					});
+					return block(lines.join(LINE), PARAGRAPH);
+				}
+				case "table": {
+					if (isLayoutTable(node.props)) return childText(node, context);
+					const rows = collect(node.children, (tag) => tag === "tr", (tag) => TABLE_SECTIONS.has(tag)).map((row) => collect(row.children, (tag) => tag === "td" || tag === "th", () => false).filter((cell) => !isDecorativeCell(cell, context)).map((cell) => childText(cell, context).replace(/\s+/g, " ").trim()).join(" | "));
+					return block(rows.join(LINE), PARAGRAPH);
+				}
+				case "row": return block(collect(node.children, (tag) => tag === "td" || tag === "th", () => false).map((cell) => childText(cell, context).replace(/^\s+|\s+$/g, "")).filter((cell) => cell !== "").join(LINE), LINE);
+				case "table-section":
+				case "cell": return block(childText(node, context), LINE);
+				case "preformatted": return block(childText(node, {
+					...context,
+					preformatted: true
+				}), PARAGRAPH);
+				case "block": return block(childText(node, context), PARAGRAPH);
+			}
+		}
+	}
+};
+/** Collapse the separators the walk emits into readable plain text. */
+const normalize = (value) => value.replace(/\r\n?/g, "\n").split("\n").map((line) => line.replace(/[^\S\n]+$/, "")).join("\n").replace(/\n{3,}/g, PARAGRAPH).trim();
+/** Derive the plain-text alternative from the semantic tree in reading order. */
+const deriveEmailText = (node) => normalize(derive(node, {
+	preformatted: false,
+	listDepth: 0
+}));
+//#endregion
+//#region src/email/render.ts
+/** Classic Outlook lays a document out correctly only under a transitional doctype. */
+const EMAIL_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
+const settle = (diagnostics) => {
+	if (hasBlockingDiagnostic(diagnostics)) throw new EmailCompileError({ diagnostics });
+	return diagnostics;
+};
+/** Lower the derived tree to HTML and its plain-text alternative. */
+const compileEmail = (node, options = {}) => {
+	const serialized = serializeEmailHtml(node, options);
+	const diagnostics = settle([...drainEmailDiagnostics(), ...serialized.diagnostics]);
+	return {
+		html: serialized.html,
+		text: deriveEmailText(node),
+		diagnostics,
+		positions: serialized.positions
+	};
+};
+/** Put the hidden preview block first inside `<body>`, or first overall when there is no shell. */
+const withPreheader = (node, text) => {
+	const insert = (current) => {
+		if (current.type === "Fragment") {
+			for (const [index, child] of current.children.entries()) {
+				const replaced = insert(child);
+				if (replaced !== void 0) return EmailNode.Fragment({ children: current.children.with(index, replaced) });
+			}
+			return;
+		}
+		if (current.type !== "Element") return void 0;
+		if (current.tag === "body") return EmailNode.Element({
+			...current,
+			children: [preheaderNode(text), ...current.children]
+		});
+		for (const [index, child] of current.children.entries()) {
+			const replaced = insert(child);
+			if (replaced !== void 0) return EmailNode.Element({
+				...current,
+				children: current.children.with(index, replaced)
+			});
+		}
+	};
+	return insert(node) ?? EmailNode.Fragment({ children: [preheaderNode(text), node] });
+};
+const headStyle = (css, origins) => EmailNode.Element({
+	tag: "style",
+	props: {},
+	children: [EmailNode.Text({ value: css })],
+	origins,
+	authored: false
+});
+/**
+* Put the retained rules in a `<style>` at the end of `<head>`, and project
+* `@font-face` rules in a sibling classic Outlook cannot see. Outlook for
+* Windows registers a face it cannot load and then renders the family in Times
+* New Roman, ignoring the stack; hidden, the family is merely missing and the
+* stack's fallback applies.
+*/
+const withHeadCss = (node, css, fontFaceCss) => {
+	const insert = (current) => {
+		if (current.type === "Fragment") {
+			for (const [index, child] of current.children.entries()) {
+				const replaced = insert(child);
+				if (replaced !== void 0) return EmailNode.Fragment({ children: current.children.with(index, replaced) });
+			}
+			return;
+		}
+		if (current.type !== "Element") return void 0;
+		if (current.tag === "head") return EmailNode.Element({
+			...current,
+			children: [
+				...current.children,
+				...css === "" ? [] : [headStyle(css, current.origins)],
+				...fontFaceCss === "" ? [] : [
+					EmailNode.Raw({
+						html: "<!--[if !mso]><!-->",
+						text: "",
+						origins: []
+					}),
+					headStyle(fontFaceCss, current.origins),
+					EmailNode.Raw({
+						html: "<!--<![endif]-->",
+						text: "",
+						origins: []
+					})
+				]
+			]
+		});
+		for (const [index, child] of current.children.entries()) {
+			const replaced = insert(child);
+			if (replaced !== void 0) return EmailNode.Element({
+				...current,
+				children: current.children.with(index, replaced)
+			});
+		}
+	};
+	return insert(node);
+};
+/**
+* Render authored content against a stylesheet: inline what a client honors,
+* keep the rest for `<head>`, and lower to HTML and text.
+*/
+const renderEmailContent = (stylesheet, render, options = {}) => {
+	drainEmailDiagnostics();
+	const content = render();
+	const invalid = [];
+	const fail = (code, message) => invalid.push({
+		code,
+		severity: "error",
+		message,
+		origins: []
+	});
+	if (typeof content.subject !== "string" || /[\r\n\u0000]/.test(content.subject)) fail("invalid-subject", "Invalid email subject: it must be one line of text.");
+	if (content.preheader !== void 0 && typeof content.preheader !== "string") fail("invalid-preheader", "Invalid email preheader: it must be a string.");
+	if (content.text !== void 0 && typeof content.text !== "string") fail("invalid-text", "Invalid plain text: it must be a string.");
+	settle(invalid);
+	const base = content.preheader === void 0 ? content.body : withPreheader(content.body, content.preheader);
+	const styled = stylesheet === void 0 ? {
+		tree: base,
+		headCss: "",
+		fontFaceCss: "",
+		diagnostics: []
+	} : applyStylesheet(base, stylesheet);
+	const style = [...styled.diagnostics];
+	let tree = styled.tree;
+	if (styled.headCss !== "" || styled.fontFaceCss !== "") {
+		const placed = withHeadCss(tree, styled.headCss, styled.fontFaceCss);
+		if (placed === void 0) style.push({
+			code: "missing-head",
+			severity: "error",
+			message: "Styles that cannot be inlined — media queries, dark-scheme rules and pseudo-selectors — need a <head> to live in. Wrap the message in <Email>, or write those declarations as inline styles.",
+			origins: []
+		});
+		else tree = placed;
+	}
+	settle(style);
+	const compiled = compileEmail(tree, options);
+	const prefix = compiled.html.startsWith("<html") ? EMAIL_DOCTYPE : "";
+	const html = `${prefix}${compiled.html}`;
+	const positions = prefix === "" ? compiled.positions : compiled.positions.map((position) => ({
+		...position,
+		start: position.start + prefix.length,
+		end: position.end + prefix.length
+	}));
+	return {
+		subject: content.subject,
+		preheader: content.preheader,
+		html,
+		text: content.text ?? compiled.text,
+		tree,
+		diagnostics: [...style, ...compiled.diagnostics],
+		positions
+	};
+};
+//#endregion
+export { deriveEmailText as i, compileEmail as n, renderEmailContent as r, EMAIL_DOCTYPE as t };
+
+//# sourceMappingURL=render-BQmfh94k.js.map

package/dist/render.d.ts

@@ -0,0 +1,35 @@
+import { C as isUrlAttribute, S as emailElement, _ as EmailGlobalProps, b as EmailStyle, g as EmailElementSpec, h as EmailAttributeSpec, m as EMAIL_GLOBAL_ATTRIBUTES, p as EMAIL_ELEMENTS, r as EmailNode, v as EmailIntrinsicElements, x as EmailTag, y as EmailLayout } from "./jsx-runtime-ylIOnaSf.js";
+import { $ as IrWhatsApp, A as emailAuthoringTarget, B as IrElement, D as EmittedPosition, E as EmailElementSelection, F as emailSelections, G as IrPredicate, H as IrFormatter, I as renderIrPreview, J as IrRawPart, K as IrPreheader, L as IrArithmetic, M as emailSelectionAncestry, N as emailSelectionIndex, O as INSTANCE_PATH_ATTRIBUTE, P as emailSelectionSiblings, Q as IrValue, R as IrComparison, U as IrIf, V as IrEmail, W as IrNode, X as IrSource, Y as IrSms, Z as IrStyle, a as renderEmailContent, at as RenderedPosition, c as checkAttribute, ct as TemplateIr, d as escapeText, et as IrWhatsAppButton, f as kebab, i as compileEmail, it as RenderedIrWhatsApp, j as emailDefinitionInstances, k as IrPreview, l as declarationValue, m as serializeStyle, n as EmailCompileOutput, nt as RenderOptions, o as EmailHtmlOutput, ot as RenderedWhatsAppButton, p as serializeEmailHtml, q as IrRaw, r as RenderedEmail, rt as RenderedIrEmail, s as SerializeEmailOptions, st as SML_IR_VERSION, t as EMAIL_DOCTYPE, tt as IrWhatsAppButtonNode, u as escapeAttribute, z as IrEach } from "./render-BPonDpCl.js";
+//#region src/render-ir.d.ts
+interface IrRenderDiagnostic {
+  readonly code: string;
+  readonly message: string;
+}
+declare class IrRenderError extends Error {
+  readonly diagnostics: readonly IrRenderDiagnostic[];
+  constructor(diagnostics: readonly IrRenderDiagnostic[]);
+}
+/** Render the email channel of a compiled template against one validated input. */
+declare const renderIr: (ir: TemplateIr, input: unknown, options?: RenderOptions) => RenderedIrEmail;
+/** Render the SMS channel of a compiled template to plain text. */
+declare const renderIrSms: (ir: TemplateIr, input: unknown, options?: RenderOptions) => string;
+/** Render the WhatsApp channel of a compiled template: every text rendered, conditional buttons resolved. */
+declare const renderIrWhatsApp: (ir: TemplateIr, input: unknown, options?: RenderOptions) => RenderedIrWhatsApp;
+//#endregion
+//#region src/email/text.d.ts
+/** Derive the plain-text alternative from the semantic tree in reading order. */
+declare const deriveEmailText: (node: EmailNode) => string;
+//#endregion
+//#region src/sms-segments.d.ts
+/** The encoding a message needs: GSM-7 when every character fits, UCS-2 otherwise. */
+type SmsEncoding = "gsm7" | "ucs2";
+interface SmsSegmentInfo {
+  readonly encoding: SmsEncoding;
+  readonly characterCount: number;
+  readonly segmentCount: number;
+}
+declare const smsSegmentInfo: (text: string) => SmsSegmentInfo;
+declare const hasSmsOptOut: (text: string) => boolean;
+//#endregion
+export { EMAIL_DOCTYPE, EMAIL_ELEMENTS, EMAIL_GLOBAL_ATTRIBUTES, EmailAttributeSpec, EmailCompileOutput, EmailElementSelection, EmailElementSpec, EmailGlobalProps, EmailHtmlOutput, EmailIntrinsicElements, EmailLayout, EmailStyle, EmailTag, EmittedPosition, INSTANCE_PATH_ATTRIBUTE, IrArithmetic, IrComparison, IrEach, IrElement, IrEmail, IrFormatter, IrIf, IrNode, IrPredicate, IrPreheader, IrPreview, IrRaw, IrRawPart, IrRenderDiagnostic, IrRenderError, IrSms, IrSource, IrStyle, IrValue, IrWhatsApp, IrWhatsAppButton, IrWhatsAppButtonNode, RenderOptions, RenderedEmail, RenderedIrEmail, RenderedIrWhatsApp, RenderedPosition, RenderedWhatsAppButton, SML_IR_VERSION, SerializeEmailOptions, SmsEncoding, SmsSegmentInfo, TemplateIr, checkAttribute, compileEmail, declarationValue, deriveEmailText, emailAuthoringTarget, emailDefinitionInstances, emailElement, emailSelectionAncestry, emailSelectionIndex, emailSelectionSiblings, emailSelections, escapeAttribute, escapeText, hasSmsOptOut, isUrlAttribute, kebab, renderEmailContent, renderIr, renderIrPreview, renderIrSms, renderIrWhatsApp, serializeEmailHtml, serializeStyle, smsSegmentInfo };
+//# sourceMappingURL=render.d.ts.map

package/dist/render.js

@@ -0,0 +1,49 @@
+import { A as renderIrSms, C as emailSelectionAncestry, D as renderIrPreview, E as emailSelections, F as isUrlAttribute, M as EMAIL_ELEMENTS, N as EMAIL_GLOBAL_ATTRIBUTES, O as IrRenderError, P as emailElement, S as emailDefinitionInstances, T as emailSelectionSiblings, _ as kebab, b as INSTANCE_PATH_ATTRIBUTE, g as escapeText, h as escapeAttribute, j as renderIrWhatsApp, k as renderIr, m as declarationValue, p as checkAttribute, v as serializeEmailHtml, w as emailSelectionIndex, x as emailAuthoringTarget, y as serializeStyle } from "./components-BZCqegS8.js";
+import { t as SML_IR_VERSION } from "./ir-CLhlklKV.js";
+import { i as deriveEmailText, n as compileEmail, r as renderEmailContent, t as EMAIL_DOCTYPE } from "./render-BQmfh94k.js";
+//#region src/sms-segments.ts
+const GSM7_EXTENDED = /* @__PURE__ */ new Set([
+	"[",
+	"]",
+	"{",
+	"}",
+	"\\",
+	"~",
+	"|",
+	"€",
+	"^",
+	"\f"
+]);
+const GSM7_BASIC_PATTERN = /^[@£$¥èéùìòÇ\nØø\rÅåΔ_ΦΓΛΩΠΨΣΘΞÆæßÉ !"#¤%&'()*+,\-./:;<=>?¡0-9ABCDEFGHIJKLMNOPQRSTUVWXYZÄÖÑܧ¿abcdefghijklmnopqrstuvwxyzäöñüà]*$/;
+const containsNonGsmCharacters = (text) => {
+	for (const char of text) {
+		if (GSM7_EXTENDED.has(char)) continue;
+		if (!GSM7_BASIC_PATTERN.test(char)) return true;
+	}
+	return false;
+};
+const smsSegmentInfo = (text) => {
+	if (containsNonGsmCharacters(text)) {
+		const codePoints = [...text].length;
+		const segmentCount = codePoints <= 70 ? 1 : Math.ceil(codePoints / 67);
+		return {
+			encoding: "ucs2",
+			characterCount: text.length,
+			segmentCount
+		};
+	}
+	let encodedLength = 0;
+	for (const char of text) encodedLength += GSM7_EXTENDED.has(char) ? 2 : 1;
+	const segmentCount = encodedLength <= 160 ? 1 : Math.ceil(encodedLength / 153);
+	return {
+		encoding: "gsm7",
+		characterCount: text.length,
+		segmentCount
+	};
+};
+const SMS_OPT_OUT_PATTERN = /\b(stop|unsubscribe|opt[\s-]?out|cancel|quit)\b/i;
+const hasSmsOptOut = (text) => SMS_OPT_OUT_PATTERN.test(text);
+//#endregion
+export { EMAIL_DOCTYPE, EMAIL_ELEMENTS, EMAIL_GLOBAL_ATTRIBUTES, INSTANCE_PATH_ATTRIBUTE, IrRenderError, SML_IR_VERSION, checkAttribute, compileEmail, declarationValue, deriveEmailText, emailAuthoringTarget, emailDefinitionInstances, emailElement, emailSelectionAncestry, emailSelectionIndex, emailSelectionSiblings, emailSelections, escapeAttribute, escapeText, hasSmsOptOut, isUrlAttribute, kebab, renderEmailContent, renderIr, renderIrPreview, renderIrSms, renderIrWhatsApp, serializeEmailHtml, serializeStyle, smsSegmentInfo };
+
+//# sourceMappingURL=render.js.map

package/dist/sms.d.ts

@@ -0,0 +1,16 @@
+import { r as EmailNode, t as EmailChild } from "./jsx-runtime-ylIOnaSf.js";
+import { t as SmsCategory } from "./channel-specs-C2feJwuP.js";
+//#region src/sms.d.ts
+interface SmsProps {
+  readonly category?: SmsCategory | undefined;
+  readonly children?: EmailChild;
+}
+/**
+ * The root of an SMS body: plain text with bindings, conditionals and formatters. The compiler
+ * reads it from source; executed, it is a fragment of its children so a template file that also
+ * declares an email body still evaluates.
+ */
+declare const Sms: (props: SmsProps) => EmailNode;
+//#endregion
+export { Sms, type SmsCategory, SmsProps };
+//# sourceMappingURL=sms.d.ts.map

package/dist/sms.js

@@ -0,0 +1,12 @@
+import { a as jsx, n as Fragment } from "./jsx-runtime-CBlexoeR.js";
+//#region src/sms.ts
+/**
+* The root of an SMS body: plain text with bindings, conditionals and formatters. The compiler
+* reads it from source; executed, it is a fragment of its children so a template file that also
+* declares an email body still evaluates.
+*/
+const Sms = (props) => jsx(Fragment, { children: props.children });
+//#endregion
+export { Sms };
+
+//# sourceMappingURL=sms.js.map

package/dist/source-locations-C8wCsiAy.d.ts

@@ -0,0 +1,23 @@
+//#region src/source-locations.d.ts
+/**
+ * The source payload a JSX transform may attach to an element. The transform may omit any field
+ * for synthetic calls; only a complete payload can identify a source origin safely.
+ */
+interface JsxSource {
+  readonly fileName?: string | undefined;
+  readonly lineNumber?: number | undefined;
+  readonly columnNumber?: number | undefined;
+}
+/** A complete, normalized source origin for a JSX element. */
+interface JsxSourceLocation {
+  readonly fileName: string;
+  readonly lineNumber: number;
+  readonly columnNumber: number;
+}
+/** The JSX prop that carries a {@link JsxSource} to the email JSX runtime. */
+declare const JSX_SOURCE_LOCATION_PROP: "__samva_source_location";
+/** Normalize the optional payload a JSX transform attaches. */
+declare const completeJsxSourceLocation: (source: JsxSource | null | undefined) => JsxSourceLocation | undefined;
+//#endregion
+export { completeJsxSourceLocation as i, JsxSource as n, JsxSourceLocation as r, JSX_SOURCE_LOCATION_PROP as t };
+//# sourceMappingURL=source-locations-C8wCsiAy.d.ts.map

package/dist/template-DMPwxMSq.d.ts

@@ -0,0 +1,65 @@
+import { r as EmailNode } from "./jsx-runtime-ylIOnaSf.js";
+import { r as InputSchema } from "./input-schema-7dPFVvNE.js";
+import { StandardJSONSchemaV1 } from "@standard-schema/spec";
+//#region src/template.d.ts
+/** One actual-input render owns all of a message's authored content. */
+interface EmailContent {
+  readonly subject: string;
+  readonly preheader?: string;
+  readonly body: EmailNode;
+  readonly text?: string;
+}
+/**
+ * The one naming contract for a template id and a fixture key: a letter, a digit or `_` first,
+ * then those plus `.`, `_` and `-`.
+ *
+ * Both names are written into file paths — a local export writes one page at
+ * `templates/<id>/<fixture>.html` — so each has to be a single plain path segment. The rule lives
+ * at the declaration, so a project that could not be exported is refused where the name is
+ * written rather than at the end of a build. Consumers that resolve a path from these names
+ * import this pattern; they do not restate it.
+ */
+declare const TEMPLATE_NAME_PATTERN: RegExp;
+/** Caller input for generated references and separate authoring consumers. */
+type TemplateInput<T extends {
+  readonly schema: unknown;
+}> = T["schema"] extends InputSchema<infer Input> ? Input : never;
+/**
+ * The one naming contract for a template `id`: lowercase kebab-case, the same rule as the CLI and
+ * API slug, so the id a definition declares is the handle a caller sends by.
+ */
+declare const TEMPLATE_ID_PATTERN: RegExp;
+/** The email channel of a template: an envelope and a body, each a function of the input. */
+interface EmailChannel<Input> {
+  readonly subject: (input: Input) => string;
+  readonly preheader?: ((input: Input) => string | undefined) | undefined;
+  readonly body: (input: Input) => EmailNode;
+}
+/** A template as `defineTemplate` returns it: its identity, input contract and each channel it declares. */
+interface SmlTemplate<Input> {
+  readonly id: string;
+  readonly schema: InputSchema<Input>;
+  readonly fixtures: Readonly<Record<string, Input>>;
+  readonly locale?: string | undefined;
+  readonly email?: EmailChannel<Input> | undefined;
+  readonly sms?: ((input: Input) => EmailNode) | undefined;
+  readonly whatsapp?: ((input: Input) => EmailNode) | undefined;
+}
+/**
+ * Define a template: one id, one input schema, named fixtures and one body per channel. Every
+ * function in it receives the validated input and returns JSX or a string; a compiler reads them
+ * without running them, so nothing here executes at send time. Types are inferred from the
+ * Standard JSON Schema input.
+ */
+declare const defineTemplate: <S extends StandardJSONSchemaV1>(definition: {
+  readonly id: string;
+  readonly schema: S;
+  readonly fixtures: Readonly<Record<string, NoInfer<StandardJSONSchemaV1.InferInput<S>>>>;
+  readonly locale?: string | undefined;
+  readonly email?: EmailChannel<NoInfer<StandardJSONSchemaV1.InferInput<S>>> | undefined;
+  readonly sms?: ((input: NoInfer<StandardJSONSchemaV1.InferInput<S>>) => EmailNode) | undefined;
+  readonly whatsapp?: ((input: NoInfer<StandardJSONSchemaV1.InferInput<S>>) => EmailNode) | undefined;
+}) => SmlTemplate<StandardJSONSchemaV1.InferInput<S>>;
+//#endregion
+export { TEMPLATE_NAME_PATTERN as a, TEMPLATE_ID_PATTERN as i, EmailContent as n, TemplateInput as o, SmlTemplate as r, defineTemplate as s, EmailChannel as t };
+//# sourceMappingURL=template-DMPwxMSq.d.ts.map

package/dist/template-zLUjcwfF.js

@@ -0,0 +1,42 @@
+import { n as inputSchema } from "./input-schema-zjkgrXn2.js";
+//#region src/template.ts
+/**
+* The one naming contract for a template id and a fixture key: a letter, a digit or `_` first,
+* then those plus `.`, `_` and `-`.
+*
+* Both names are written into file paths — a local export writes one page at
+* `templates/<id>/<fixture>.html` — so each has to be a single plain path segment. The rule lives
+* at the declaration, so a project that could not be exported is refused where the name is
+* written rather than at the end of a build. Consumers that resolve a path from these names
+* import this pattern; they do not restate it.
+*/
+const TEMPLATE_NAME_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9._-]*$/;
+const checkTemplateName = (kind, value) => {
+	if (TEMPLATE_NAME_PATTERN.test(value)) return;
+	throw new TypeError(`${kind} ${JSON.stringify(value)} is not one path segment. A template id and a fixture key are written into file paths, so each must start with a letter, a digit or "_" and continue with letters, digits, ".", "_" or "-".`);
+};
+/**
+* The one naming contract for a template `id`: lowercase kebab-case, the same rule as the CLI and
+* API slug, so the id a definition declares is the handle a caller sends by.
+*/
+const TEMPLATE_ID_PATTERN = /^(?=.{1,100}$)[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/**
+* Define a template: one id, one input schema, named fixtures and one body per channel. Every
+* function in it receives the validated input and returns JSX or a string; a compiler reads them
+* without running them, so nothing here executes at send time. Types are inferred from the
+* Standard JSON Schema input.
+*/
+const defineTemplate = (definition) => {
+	if (!TEMPLATE_ID_PATTERN.test(definition.id)) throw new TypeError(`Template id ${JSON.stringify(definition.id)} is not lowercase kebab-case. The id is the handle a send names, so write lowercase letters and digits joined by single hyphens, for example "order-shipped".`);
+	const fixtureNames = Object.keys(definition.fixtures);
+	if (fixtureNames.length === 0) throw new TypeError(`Template ${definition.id} declares no fixtures. Fixtures are the preview, the agent's render targets and the publish check; declare at least one.`);
+	for (const fixture of fixtureNames) checkTemplateName("Fixture key", fixture);
+	return {
+		...definition,
+		schema: inputSchema(definition.schema)
+	};
+};
+//#endregion
+export { TEMPLATE_NAME_PATTERN as n, defineTemplate as r, TEMPLATE_ID_PATTERN as t };
+
+//# sourceMappingURL=template-zLUjcwfF.js.map

package/dist/{theme-css-hFqcPSar.js → theme-css-JtRCm1fb.js}

@@ -1,5 +1,5 @@
-import { Result } from "better-result";
 import { generate, parse, walk } from "css-tree";
+import { Result } from "better-result";
 //#region src/email/css-color.ts
 const clamp = (value, low = 0, high = 1) => value < low ? low : value > high ? high : value;
 const toGamma = (channel) => channel <= .0031308 ? 12.92 * channel : 1.055 * channel ** (1 / 2.4) - .055;
@@ -584,4 +584,4 @@ const brandTailwindCss = (brand) => printBrandCss({
 //#endregion
 export { brandThemeVariables as a, parseBrandCss as c, formatColor as d, parseColor as f, brandTailwindCss as i, printBrandCss as l, BRAND_FOREGROUND_VARIABLE as n, contrastForeground as o, brandForegroundDefaults as r, darkVariableName as s, BRAND_COLOR_VARIABLE as t, downlevelColors as u };
 
-//# sourceMappingURL=theme-css-hFqcPSar.js.map
+//# sourceMappingURL=theme-css-JtRCm1fb.js.map

package/dist/whatsapp.d.ts

@@ -0,0 +1,57 @@
+import { r as EmailNode, t as EmailChild } from "./jsx-runtime-ylIOnaSf.js";
+import { n as WhatsAppCategory, r as WhatsAppHeaderType } from "./channel-specs-C2feJwuP.js";
+//#region src/whatsapp.d.ts
+interface WhatsAppProps {
+  readonly name?: string | undefined;
+  /** The Meta language code, for example `en_US`. */
+  readonly language: string;
+  readonly category: WhatsAppCategory;
+  readonly children?: EmailChild;
+}
+interface WhatsAppHeaderProps {
+  /** `text` by default; for `image`, `video` and `document` the child is the media URL. */
+  readonly type?: WhatsAppHeaderType | undefined;
+  readonly children?: EmailChild;
+}
+interface WhatsAppTextProps {
+  readonly children?: EmailChild;
+}
+interface WhatsAppButtonsProps {
+  readonly children?: EmailChild;
+}
+interface WhatsAppUrlButtonProps {
+  readonly url: string;
+  /** The button label. */
+  readonly children?: EmailChild;
+}
+interface WhatsAppPhoneButtonProps {
+  readonly phone: string;
+  /** The button label. */
+  readonly children?: EmailChild;
+}
+interface WhatsAppQuickReplyButtonProps {
+  /** The button label. */
+  readonly children?: EmailChild;
+}
+interface WhatsAppCopyCodeButtonProps {
+  /** The code the button copies. */
+  readonly children?: EmailChild;
+}
+/**
+ * The root of a WhatsApp body. Meta's template anatomy is the vocabulary: `WhatsApp.Header`,
+ * `WhatsApp.Body`, `WhatsApp.Footer` and `WhatsApp.Buttons`, whose children are the four button
+ * kinds.
+ */
+declare const WhatsApp: ((props: WhatsAppProps) => EmailNode) & {
+  Header: (props: WhatsAppHeaderProps) => EmailNode;
+  Body: (props: WhatsAppTextProps) => EmailNode;
+  Footer: (props: WhatsAppTextProps) => EmailNode;
+  Buttons: (props: WhatsAppButtonsProps) => EmailNode;
+  UrlButton: (props: WhatsAppUrlButtonProps) => EmailNode;
+  QuickReplyButton: (props: WhatsAppQuickReplyButtonProps) => EmailNode;
+  PhoneButton: (props: WhatsAppPhoneButtonProps) => EmailNode;
+  CopyCodeButton: (props: WhatsAppCopyCodeButtonProps) => EmailNode;
+};
+//#endregion
+export { WhatsApp, WhatsAppButtonsProps, type WhatsAppCategory, WhatsAppCopyCodeButtonProps, WhatsAppHeaderProps, type WhatsAppHeaderType, WhatsAppPhoneButtonProps, WhatsAppProps, WhatsAppQuickReplyButtonProps, WhatsAppTextProps, WhatsAppUrlButtonProps };
+//# sourceMappingURL=whatsapp.d.ts.map

package/dist/whatsapp.js

@@ -0,0 +1,22 @@
+import { a as jsx, n as Fragment } from "./jsx-runtime-CBlexoeR.js";
+//#region src/whatsapp.ts
+const fragment = (children) => jsx(Fragment, { children });
+/**
+* The root of a WhatsApp body. Meta's template anatomy is the vocabulary: `WhatsApp.Header`,
+* `WhatsApp.Body`, `WhatsApp.Footer` and `WhatsApp.Buttons`, whose children are the four button
+* kinds.
+*/
+const WhatsApp = Object.assign((props) => fragment(props.children), {
+	Header: (props) => fragment(props.children),
+	Body: (props) => fragment(props.children),
+	Footer: (props) => fragment(props.children),
+	Buttons: (props) => fragment(props.children),
+	UrlButton: (props) => fragment(props.children),
+	QuickReplyButton: (props) => fragment(props.children),
+	PhoneButton: (props) => fragment(props.children),
+	CopyCodeButton: (props) => fragment(props.children)
+});
+//#endregion
+export { WhatsApp };
+
+//# sourceMappingURL=whatsapp.js.map