@samva/markup 0.9.0 → 0.11.0

package/dist/assets-B0yseju_.d.ts

@@ -0,0 +1,115 @@
+import { t as BrandPlugin } from "./brand-plugin-CHhcei-j.js";
+import { r as EmailDiagnostic } from "./diagnostics-B-Gym34R.js";
+import { r as EmailNode } from "./jsx-runtime-ylIOnaSf.js";
+//#region src/email/brand.d.ts
+interface EmailBrandAddress {
+  readonly street1: string;
+  readonly street2?: string | undefined;
+  readonly city: string;
+  readonly region: string;
+  readonly postalCode: string;
+  readonly country: string;
+}
+interface EmailBrandSocialLink {
+  readonly label: string;
+  readonly url: string;
+}
+interface EmailBrandAssets {
+  readonly logoUrl?: string | undefined;
+  readonly logoDarkUrl?: string | undefined;
+  readonly iconUrl?: string | undefined;
+}
+interface EmailBrandFooter {
+  readonly companyName?: string | undefined;
+  readonly address?: EmailBrandAddress | undefined;
+  readonly socialLinks?: readonly EmailBrandSocialLink[] | undefined;
+}
+interface EmailBrand {
+  /** The brand's slug; a `<specifier>/<slug>` brand import must name it. */
+  readonly slug: string;
+  /** Brand theme CSS in the closed grammar `parseBrandCss` accepts. */
+  readonly css: string;
+  readonly assets?: EmailBrandAssets | undefined;
+  readonly footer?: EmailBrandFooter | undefined;
+}
+/** Every class the brand components use, compiled for any project that imports them. */
+declare const BRAND_COMPONENT_CLASSES: readonly ["dark:hidden!", "hidden", "dark:block!", "text-xs", "text-gray-500", "text-center", "font-semibold", "underline"];
+interface BrandLogoProps {
+  /** Rendered width in pixels; the height follows the image. */
+  readonly width?: number | undefined;
+  /** Defaults to the brand footer's company name. */
+  readonly alt?: string | undefined;
+  readonly align?: "left" | "center" | "right" | undefined;
+  readonly className?: string | undefined;
+}
+interface BrandFooterProps {
+  /** Text of the unsubscribe link. */
+  readonly unsubscribeLabel?: string | undefined;
+  readonly className?: string | undefined;
+}
+interface BrandComponents {
+  readonly BrandLogo: (props: BrandLogoProps) => EmailNode | null;
+  readonly BrandFooter: (props: BrandFooterProps) => EmailNode | null;
+}
+/** Bind `BrandLogo` and `BrandFooter` to one brand, marked as the plugin names. */
+declare const brandComponents: (brand: EmailBrand, plugin?: BrandPlugin) => BrandComponents;
+/** What a rendered message says about the footer it carries. */
+interface RenderedFooterMarkers {
+  /** The message renders `BrandFooter` (or claims to, with the marker). */
+  readonly footer: boolean;
+  /** The message carries the unsubscribe placeholder link only `BrandFooter` can write. */
+  readonly unsubscribeLink: boolean;
+}
+/** Read the plugin's footer markers from rendered HTML. */
+declare const renderedFooterMarkers: (html: string, plugin?: BrandPlugin) => RenderedFooterMarkers;
+/**
+ * Drop the unsubscribe row from a rendered message, for a send that resolved
+ * no unsubscribe group: there is no link to put there, so the row goes.
+ */
+declare const withoutUnsubscribeRow: (rendered: {
+  readonly html?: string | undefined;
+  readonly text?: string | undefined;
+}, plugin?: BrandPlugin) => {
+  readonly html: string | undefined;
+  readonly text: string | undefined;
+};
+//#endregion
+//#region src/email/assets.d.ts
+/** Files a template may import, and what they are served as. */
+declare const ASSET_CONTENT_TYPES: Readonly<Record<string, string>>;
+interface AssetEntry {
+  /** Project-relative path the template imported. */
+  readonly path: string;
+  /** SHA-256 of the exact bytes, lowercase hex. */
+  readonly digest: string;
+  readonly bytes: number;
+  readonly contentType: string;
+  /** `<digest><ext>` — the name the asset has under any base. */
+  readonly fileName: string;
+}
+interface AssetManifest {
+  /** Where these assets are served from in this build. */
+  readonly base: string;
+  readonly assets: readonly AssetEntry[];
+}
+/** True when the compiler turns this import into a content-addressed asset. */
+declare const isAssetPath: (path: string) => boolean;
+/** Address one file by its content. */
+declare const assetEntry: (path: string, bytes: Uint8Array) => Promise<AssetEntry>;
+/**
+ * The URL an asset has under a base. The base is a build input: publication
+ * passes its hosted origin, and a local export passes whatever it will serve
+ * the exported files from.
+ */
+declare const assetUrl: (entry: AssetEntry, base: string) => string;
+/** Record, but never fetch, a URL the template points at. */
+declare const isExternalAsset: (reference: string) => boolean;
+/**
+ * Reject an asset base that would produce URLs a client will not load. The
+ * relative forms are the ones a page on disk resolves against its own
+ * directory, which is what a local export writes.
+ */
+declare const checkAssetBase: (base: string) => readonly EmailDiagnostic[];
+//#endregion
+export { EmailBrandSocialLink as _, assetUrl as a, renderedFooterMarkers as b, isExternalAsset as c, BrandFooterProps as d, BrandLogoProps as f, EmailBrandFooter as g, EmailBrandAssets as h, assetEntry as i, BRAND_COMPONENT_CLASSES as l, EmailBrandAddress as m, AssetEntry as n, checkAssetBase as o, EmailBrand as p, AssetManifest as r, isAssetPath as s, ASSET_CONTENT_TYPES as t, BrandComponents as u, RenderedFooterMarkers as v, withoutUnsubscribeRow as x, brandComponents as y };
+//# sourceMappingURL=assets-B0yseju_.d.ts.map

package/dist/brand-DTctcDmf.js

@@ -0,0 +1,202 @@
+import { D as samvaBrandPlugin, O as BRAND_FOOTER_MARKER, k as UNSUBSCRIBE_LINK, r as escapeAttribute } from "./html-DjPxwjLi.js";
+import { a as jsx, n as Fragment } from "./jsx-runtime-CBlexoeR.js";
+//#region src/email/assets.ts
+/** Files a template may import, and what they are served as. */
+const ASSET_CONTENT_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".avif": "image/avif",
+	".svg": "image/svg+xml",
+	".ico": "image/x-icon",
+	".woff": "font/woff",
+	".woff2": "font/woff2",
+	".ttf": "font/ttf",
+	".otf": "font/otf",
+	".pdf": "application/pdf",
+	".txt": "text/plain"
+};
+const extensionOf = (path) => {
+	const dot = path.lastIndexOf(".");
+	return dot < 0 ? "" : path.slice(dot).toLowerCase();
+};
+/** True when the compiler turns this import into a content-addressed asset. */
+const isAssetPath = (path) => Object.hasOwn(ASSET_CONTENT_TYPES, extensionOf(path));
+const hex = (buffer) => Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+/** Address one file by its content. */
+const assetEntry = async (path, bytes) => {
+	const extension = extensionOf(path);
+	const view = new Uint8Array(bytes.byteLength);
+	view.set(bytes);
+	const digest = hex(await crypto.subtle.digest("SHA-256", view));
+	return {
+		path,
+		digest,
+		bytes: bytes.byteLength,
+		contentType: ASSET_CONTENT_TYPES[extension] ?? "application/octet-stream",
+		fileName: `${digest}${extension}`
+	};
+};
+/**
+* The URL an asset has under a base. The base is a build input: publication
+* passes its hosted origin, and a local export passes whatever it will serve
+* the exported files from.
+*/
+const assetUrl = (entry, base) => `${base.replace(/\/+$/, "")}/${entry.fileName}`;
+const EXTERNAL_IMAGE = /^https:\/\//i;
+/** Record, but never fetch, a URL the template points at. */
+const isExternalAsset = (reference) => EXTERNAL_IMAGE.test(reference);
+/**
+* Reject an asset base that would produce URLs a client will not load. The
+* relative forms are the ones a page on disk resolves against its own
+* directory, which is what a local export writes.
+*/
+const checkAssetBase = (base) => /^(https:\/\/|\.{1,2}\/|\/)/i.test(base) ? [] : [{
+	code: "invalid-asset-base",
+	severity: "error",
+	message: `Asset base ${JSON.stringify(base)} must be an https URL, an absolute path, or a relative path for a local export.`,
+	origins: []
+}];
+//#endregion
+//#region src/email/brand.ts
+/** Every class the brand components use, compiled for any project that imports them. */
+const BRAND_COMPONENT_CLASSES = [
+	"dark:hidden!",
+	"hidden",
+	"dark:block!",
+	"text-xs",
+	"text-gray-500",
+	"text-center",
+	"font-semibold",
+	"underline"
+];
+const addressLines = (address) => [
+	address.street1,
+	address.street2,
+	[
+		address.city,
+		address.region,
+		address.postalCode
+	].filter((part) => part.trim() !== "").join(", "),
+	address.country
+].filter((line) => line !== void 0 && line.trim() !== "");
+const classes = (...names) => {
+	const joined = names.filter((name) => name !== void 0 && name !== "").join(" ");
+	return joined === "" ? void 0 : joined;
+};
+const row = (children, props = {}) => jsx("tr", {
+	...props,
+	children: jsx("td", {
+		style: { padding: "0 0 8px 0" },
+		children
+	})
+});
+/** Bind `BrandLogo` and `BrandFooter` to one brand, marked as the plugin names. */
+const brandComponents = (brand, plugin = samvaBrandPlugin) => {
+	const assets = brand.assets ?? {};
+	const footer = brand.footer ?? {};
+	const BrandLogo = ({ width = 120, alt, align, className }) => {
+		if (assets.logoUrl === void 0) return null;
+		const label = alt ?? footer.companyName ?? "";
+		const image = (src, imageClass, imageAlt) => jsx("img", {
+			src,
+			alt: imageAlt,
+			width,
+			border: 0,
+			...align === void 0 ? {} : { align },
+			className: classes(imageClass, className),
+			style: {
+				display: "block",
+				outline: "none",
+				border: "none",
+				height: "auto"
+			}
+		});
+		if (assets.logoDarkUrl === void 0) return image(assets.logoUrl, void 0, label);
+		return jsx(Fragment, { children: [image(assets.logoUrl, "dark:hidden!", label), jsx("div", {
+			className: "hidden dark:block!",
+			style: {
+				msoHide: "all",
+				maxHeight: 0,
+				overflow: "hidden"
+			},
+			children: image(assets.logoDarkUrl, void 0, "")
+		})] });
+	};
+	const BrandFooter = ({ unsubscribeLabel = "Unsubscribe", className }) => {
+		const rows = [];
+		if (footer.companyName !== void 0 && footer.companyName.trim() !== "") rows.push(row(jsx("span", {
+			className: "font-semibold",
+			children: footer.companyName
+		})));
+		if (footer.address !== void 0) {
+			const lines = addressLines(footer.address);
+			if (lines.length > 0) rows.push(row(lines.flatMap((line, index) => index === 0 ? [line] : [jsx("br", {}), line])));
+		}
+		const links = footer.socialLinks ?? [];
+		if (links.length > 0) rows.push(row(links.flatMap((link, index) => [...index === 0 ? [] : [" · "], jsx("a", {
+			href: link.url,
+			className: "text-gray-500 underline",
+			children: link.label
+		})])));
+		rows.push(row(unsubscribeLink(unsubscribeLabel, plugin), {
+			[plugin.unsubscribeRowAttribute]: "",
+			[BRAND_FOOTER_MARKER]: true
+		}));
+		return jsx("table", {
+			role: "presentation",
+			width: "100%",
+			border: 0,
+			cellpadding: 0,
+			cellspacing: 0,
+			[plugin.footerAttribute]: "",
+			[BRAND_FOOTER_MARKER]: true,
+			children: jsx("tbody", { children: jsx("tr", { children: jsx("td", {
+				align: "center",
+				className: classes("text-xs text-gray-500 text-center", className),
+				style: { padding: "32px 16px" },
+				children: jsx("table", {
+					role: "presentation",
+					border: 0,
+					cellpadding: 0,
+					cellspacing: 0,
+					children: jsx("tbody", { children: rows })
+				})
+			}) }) })
+		});
+	};
+	return {
+		BrandLogo,
+		BrandFooter
+	};
+};
+/**
+* The unsubscribe link. Its href is the placeholder, which no author-written
+* link may carry: the serializer accepts it only on this node, and writes the
+* plugin's no-track marker on it so click tracking never rewrites it.
+*/
+const unsubscribeLink = (label, plugin) => jsx("a", {
+	href: plugin.unsubscribeUrlPlaceholder,
+	className: "text-gray-500 underline",
+	[UNSUBSCRIBE_LINK]: true,
+	children: label
+});
+/** Read the plugin's footer markers from rendered HTML. */
+const renderedFooterMarkers = (html, plugin = samvaBrandPlugin) => ({
+	footer: html.includes(`${plugin.footerAttribute}=""`),
+	unsubscribeLink: html.includes(`href="${escapeAttribute(plugin.unsubscribeUrlPlaceholder)}"`)
+});
+/**
+* Drop the unsubscribe row from a rendered message, for a send that resolved
+* no unsubscribe group: there is no link to put there, so the row goes.
+*/
+const withoutUnsubscribeRow = (rendered, plugin = samvaBrandPlugin) => ({
+	html: rendered.html?.replace(new RegExp(`<tr ${plugin.unsubscribeRowAttribute}=""[^>]*>[\\s\\S]*?</tr>`, "g"), ""),
+	text: rendered.text?.split("\n").filter((line) => !line.includes(plugin.unsubscribeUrlPlaceholder)).join("\n")
+});
+//#endregion
+export { ASSET_CONTENT_TYPES as a, checkAssetBase as c, withoutUnsubscribeRow as i, isAssetPath as l, brandComponents as n, assetEntry as o, renderedFooterMarkers as r, assetUrl as s, BRAND_COMPONENT_CLASSES as t, isExternalAsset as u };
+
+//# sourceMappingURL=brand-DTctcDmf.js.map

package/dist/brand-plugin-CHhcei-j.d.ts

@@ -0,0 +1,32 @@
+//#region src/email/brand-plugin.d.ts
+/**
+ * How a template reaches its brand and how the footer `BrandFooter` renders is
+ * marked for the send path that delivers it. The compiler and the IR renderer
+ * read every brand import, footer marker and unsubscribe link from the plugin
+ * a build passes; `samvaBrandPlugin` is the default.
+ */
+interface BrandPlugin {
+  /**
+   * The module and stylesheet specifier a template imports its brand from.
+   * `<specifier>/<slug>` names one brand; the bare specifier names the default.
+   */
+  readonly specifier: string;
+  /** Marks the block `BrandFooter` renders, so the send path finds a template's own footer. */
+  readonly footerAttribute: `data-${string}`;
+  /** Marks the footer row that carries the unsubscribe link, so a send can drop it. */
+  readonly unsubscribeRowAttribute: `data-${string}`;
+  /** The unsubscribe link's href; the send path substitutes each delivery's URL for it. */
+  readonly unsubscribeUrlPlaceholder: string;
+  /**
+   * Written on the unsubscribe link, so the send path delivers it without
+   * click tracking: a rewritten link would carry another recipient's token.
+   */
+  readonly noTrackAttribute: `data-${string}`;
+}
+/** The brand a specifier names: `undefined` slug means the default brand; `undefined` when it names none. */
+declare const parseBrandSpecifier: (specifier: string, plugin?: BrandPlugin) => {
+  readonly slug: string | undefined;
+} | undefined;
+//#endregion
+export { parseBrandSpecifier as n, BrandPlugin as t };
+//# sourceMappingURL=brand-plugin-CHhcei-j.d.ts.map

package/dist/{theme-css.d.ts → brand.d.ts}

@@ -1,5 +1,16 @@
-import { Diagnostic } from "./diagnostics.js";
+import { t as BrandPlugin } from "./brand-plugin-CHhcei-j.js";
+import { _ as EmailBrandSocialLink, a as assetUrl, b as renderedFooterMarkers, c as isExternalAsset, d as BrandFooterProps, f as BrandLogoProps, g as EmailBrandFooter, h as EmailBrandAssets, i as assetEntry, l as BRAND_COMPONENT_CLASSES, m as EmailBrandAddress, n as AssetEntry, o as checkAssetBase, p as EmailBrand, r as AssetManifest, s as isAssetPath, t as ASSET_CONTENT_TYPES, u as BrandComponents, v as RenderedFooterMarkers, x as withoutUnsubscribeRow, y as brandComponents } from "./assets-B0yseju_.js";
+import { t as Diagnostic } from "./diagnostic-model-DxthUZBT.js";
 import { Result } from "better-result";
+//#region src/email/samva-brand-plugin.d.ts
+/**
+ * Samva's brand plugin, the compiler's default. A template imports its
+ * organization's brand from `samva:brand`, and Samva's send path fills
+ * `%samva:unsubscribe-url%` per delivery and turns `data-samva-no-track` into
+ * its email provider's own no-track marker.
+ */
+declare const samvaBrandPlugin: BrandPlugin;
+//#endregion
 //#region src/theme-css.d.ts
 /** One `@font-face` a brand declares. `src` is the declaration value as authored. */
 interface BrandFontFace {
@@ -58,8 +69,8 @@ declare const brandForegroundDefaults: (brand: BrandCss) => {
  * build compiles the same default and the stored CSS never carries it.
  */
 declare const brandThemeVariables: (brand: BrandCss) => Readonly<Record<string, string>>;
-/** The stylesheet Tailwind compiles for `@import "samva:brand"`: `brandThemeVariables` and the font faces. */
+/** The stylesheet Tailwind compiles for the theme's brand import: `brandThemeVariables` and the font faces. */
 declare const brandTailwindCss: (brand: BrandCss) => string;
 //#endregion
-export { BRAND_COLOR_VARIABLE, BRAND_FOREGROUND_VARIABLE, BrandCss, BrandFontFace, brandForegroundDefaults, brandTailwindCss, brandThemeVariables, contrastForeground, darkVariableName, parseBrandCss, printBrandCss };
-//# sourceMappingURL=theme-css.d.ts.map
+export { ASSET_CONTENT_TYPES, AssetEntry, AssetManifest, BRAND_COLOR_VARIABLE, BRAND_COMPONENT_CLASSES, BRAND_FOREGROUND_VARIABLE, BrandComponents, BrandCss, BrandFontFace, BrandFooterProps, BrandLogoProps, type BrandPlugin, EmailBrand, EmailBrandAddress, EmailBrandAssets, EmailBrandFooter, EmailBrandSocialLink, RenderedFooterMarkers, assetEntry, assetUrl, brandComponents, brandForegroundDefaults, brandTailwindCss, brandThemeVariables, checkAssetBase, contrastForeground, darkVariableName, isAssetPath, isExternalAsset, parseBrandCss, printBrandCss, renderedFooterMarkers, samvaBrandPlugin, withoutUnsubscribeRow };
+//# sourceMappingURL=brand.d.ts.map

package/dist/brand.js

@@ -0,0 +1,4 @@
+import { D as samvaBrandPlugin } from "./html-DjPxwjLi.js";
+import { a as brandThemeVariables, c as parseBrandCss, i as brandTailwindCss, l as printBrandCss, n as BRAND_FOREGROUND_VARIABLE, o as contrastForeground, r as brandForegroundDefaults, s as darkVariableName, t as BRAND_COLOR_VARIABLE } from "./theme-css-CEUrDpqq.js";
+import { a as ASSET_CONTENT_TYPES, c as checkAssetBase, i as withoutUnsubscribeRow, l as isAssetPath, n as brandComponents, o as assetEntry, r as renderedFooterMarkers, s as assetUrl, t as BRAND_COMPONENT_CLASSES, u as isExternalAsset } from "./brand-DTctcDmf.js";
+export { ASSET_CONTENT_TYPES, BRAND_COLOR_VARIABLE, BRAND_COMPONENT_CLASSES, BRAND_FOREGROUND_VARIABLE, assetEntry, assetUrl, brandComponents, brandForegroundDefaults, brandTailwindCss, brandThemeVariables, checkAssetBase, contrastForeground, darkVariableName, isAssetPath, isExternalAsset, parseBrandCss, printBrandCss, renderedFooterMarkers, samvaBrandPlugin, withoutUnsubscribeRow };

package/dist/compiler.d.ts

@@ -1,13 +1,68 @@
-import { i as EmailDiagnosticSeverity, n as EmailCompileError, o as formatEmailDiagnostic, r as EmailDiagnostic, s as hasBlockingDiagnostic } from "./diagnostics-B-Gym34R.js";
-import { a as EmailGlobalProps, c as EmailStyle, d as isUrlAttribute, i as EmailElementSpec, l as EmailTag, m as EmailNode, n as EMAIL_GLOBAL_ATTRIBUTES, o as EmailIntrinsicElements, r as EmailAttributeSpec, s as EmailLayout, t as EMAIL_ELEMENTS, u as emailElement } from "./elements-cqldpaJt.js";
-import { a as emailAuthoringTarget, c as emailSelectionIndex, l as emailSelectionSiblings, n as EmittedPosition, o as emailDefinitionInstances, r as INSTANCE_PATH_ATTRIBUTE, s as emailSelectionAncestry, t as EmailElementSelection, u as emailSelections } from "./preview-Ekdg1dXG.js";
-import { a as escapeAttribute, c as serializeEmailHtml, n as SerializeEmailOptions, o as escapeText, t as EmailHtmlOutput } from "./html-BJepOwZ4.js";
-import { _ as checkEmailCompatibility, a as ClassDiscovery, c as TailwindOutput, d as COMPATIBILITY_PROVENANCE, f as CompatibilityInput, g as EmailClientTarget, h as ESSENTIAL_CONSTRUCTS, i as transformProject, l as compileTailwind, m as EMAIL_CLIENT_MATRIX, n as TransformOptions, o as TailwindLimits, p as CompatibilityProvenance, r as projectBrandSpecifier, s as TailwindOptions, t as ProjectTransform, u as discoverClassCandidates, v as hasBlockingCompatibility, y as unknownCoverage } from "./transform-Ct2OMkFN.js";
-import { deriveEmailText } from "./email/text.js";
-import { a as compileSelector, c as CompiledSelector, d as matchesSelector, i as Stylesheet, l as Compound, n as CssRule, o as parseStylesheet, r as Specificity, s as Ancestry, t as CssDeclaration, u as classListOf } from "./css-BVQKICKC.js";
-import { EMAIL_DOCTYPE, EmailCompileOutput, RenderedEmail, compileEmail } from "./email/render.js";
-import { a as assetUrl, c as isExternalAsset, i as assetEntry, n as AssetEntry, o as checkAssetBase, r as AssetManifest, s as isAssetPath, t as ASSET_CONTENT_TYPES } from "./assets-C5duwTya.js";
-import { a as EmailBrand, c as EmailBrandFooter, l as EmailBrandSocialLink, o as EmailBrandAddress, s as EmailBrandAssets } from "./brand-B-0bN_Ir.js";
+import { n as parseBrandSpecifier, t as BrandPlugin } from "./brand-plugin-CHhcei-j.js";
+import { a as TemplateDiagnostic, r as EmailDiagnostic } from "./diagnostics-B-Gym34R.js";
+import { r as EmailNode } from "./jsx-runtime-ylIOnaSf.js";
+import { n as AssetEntry, p as EmailBrand, u as BrandComponents } from "./assets-B0yseju_.js";
+import { C as Compound, D as EmittedPosition, S as CompiledSelector, T as matchesSelector, _ as Specificity, b as parseStylesheet, ct as TemplateIr, g as CssRule, h as CssDeclaration, r as RenderedEmail, v as Stylesheet, w as classListOf, x as Ancestry, y as compileSelector } from "./render-DQKz4Aco.js";
+import { a as TEMPLATE_NAME_PATTERN, n as EmailContent } from "./template-DMPwxMSq.js";
+import { caniemail } from "caniemail";
+//#region src/email/compatibility.d.ts
+type CaniemailClient = Parameters<typeof caniemail>[0]["clients"][number];
+/** One client this compiler makes claims about. */
+interface EmailClientTarget {
+  readonly id: CaniemailClient;
+  readonly label: string;
+}
+/**
+ * The pinned matrix. Every finding is reported per client, and a client absent
+ * from this list is a client Samva makes no claim about.
+ */
+declare const EMAIL_CLIENT_MATRIX: readonly EmailClientTarget[];
+interface CompatibilityProvenance {
+  /** The exact rules package a finding came from. */
+  readonly rules: string;
+  readonly apiVersion: string;
+  /** The day caniemail last changed the data this build was checked against. */
+  readonly lastUpdate: string;
+}
+declare const COMPATIBILITY_PROVENANCE: CompatibilityProvenance;
+/**
+ * The constructs whose loss actually breaks a message: the recipient reads
+ * something different, in a different order, follows a link that does not work,
+ * or sees a layout that has collapsed. A target client dropping one of these
+ * blocks publication.
+ *
+ * The list is deliberately short and enumerated, because the contract is to
+ * block *known* failures. Nonessential differences require an assessment of
+ * emitted values: a concrete risk warns, expected differences and unverified
+ * behavior remain compatibility observations.
+ */
+declare const ESSENTIAL_CONSTRUCTS: ReadonlySet<string>;
+interface CompatibilityInput {
+  /** The document the recipient receives. */
+  readonly html: string;
+  /** The declared fixture checked by this invocation. */
+  readonly fixture?: string | undefined;
+  /** Retained head rules, when they are not already inside the HTML. */
+  readonly css?: string | undefined;
+  /** Emitted-offset ranges with the origins of the node that produced them. */
+  readonly positions?: readonly EmittedPosition[] | undefined;
+  readonly clients?: readonly EmailClientTarget[] | undefined;
+}
+/**
+ * Check the emitted document against the pinned matrix.
+ *
+ * Findings are grouped by construct rather than repeated per client, so one
+ * unsupported property is one diagnostic naming every client that drops it.
+ */
+declare const checkEmailCompatibility: (input: CompatibilityInput) => readonly EmailDiagnostic[];
+/**
+ * Constructs the pinned data says nothing about for a target client. These are
+ * reported so "we did not check that" is never mistaken for "that works".
+ */
+declare const unknownCoverage: (titles: Iterable<string>) => readonly EmailDiagnostic[];
+/** A publication carrying one of these is refused; the message would arrive broken. */
+declare const hasBlockingCompatibility: (findings: readonly EmailDiagnostic[]) => boolean;
+//#endregion
 //#region src/email/css-values.d.ts
 /**
  * Expand `var(--x, fallback)` against the collected custom properties.
@@ -64,13 +119,176 @@ declare const applyStylesheet: (root: EmailNode, sheet: Stylesheet, options?: {
 /** The exact Tailwind release the compiler runs, recorded in every build manifest. */
 declare const TAILWIND_VERSION = "4.3.3";
 //#endregion
-//#region src/email/theme-imports.d.ts
-/** The CSS and TSX specifier a template uses to reach its organization's brand. */
-declare const BRAND_SPECIFIER = "samva:brand";
-/** The brand a `samva:brand` specifier names: `undefined` slug means the default brand. */
-declare const parseBrandSpecifier: (specifier: string) => {
-  readonly slug: string | undefined;
-} | undefined;
+//#region src/email/tailwind.d.ts
+interface TailwindOptions {
+  /**
+   * Project CSS appended to the compiled entry: `@theme` overrides, `@utility`
+   * definitions and ordinary rules. This is the project's pinned configuration.
+   */
+  readonly css?: string | undefined;
+  /**
+   * The project path `css` was read from (`theme.css` by default). Its
+   * relative `@import`s resolve from this file's directory.
+   */
+  readonly cssPath?: string | undefined;
+  /** Classes the compiler cannot discover, declared by the project on purpose. */
+  readonly safelist?: readonly string[] | undefined;
+  /** Tailwind's browser reset is off by default; email clients do not want it. */
+  readonly preflight?: boolean | undefined;
+  /**
+   * Bounds on what the compiler may generate. Class discovery reads authored
+   * source, so a project can hand it an unbounded candidate set and get an
+   * unbounded stylesheet back — inside a build that has a wall clock and a
+   * bundle a Worker then has to load. A host that publishes supplies these.
+   */
+  readonly limits?: TailwindLimits | undefined;
+}
+interface TailwindLimits {
+  /** Distinct classes handed to the compiler. */
+  readonly candidates: number;
+  /** Bytes of generated CSS. */
+  readonly cssBytes: number;
+}
+interface TailwindOutput {
+  readonly css: string;
+  readonly version: string;
+  /** Every candidate handed to the compiler, sorted, for the build manifest. */
+  readonly candidates: readonly string[];
+}
+/**
+ * What the project theme's `@import`s resolve to, already checked by
+ * `resolveThemeImports`: project stylesheets by path, and the brand theme the
+ * brand plugin's specifier stands for.
+ */
+interface TailwindImports {
+  readonly stylesheets: ReadonlyMap<string, string>;
+  readonly brandCss?: string | undefined;
+  /** Names the brand import; `samvaBrandPlugin` when omitted. */
+  readonly brandPlugin?: BrandPlugin | undefined;
+}
+/** Compile the discovered class set into CSS with the pinned Tailwind release. */
+declare const compileTailwind: (candidates: Iterable<string>, options?: TailwindOptions, imports?: TailwindImports) => Promise<TailwindOutput>;
+interface ClassDiscovery {
+  readonly candidates: readonly string[];
+  readonly diagnostics: readonly EmailDiagnostic[];
+}
+/**
+ * Collect the class names one module states literally, and report the positions
+ * where a class is assembled from values the compiler cannot see.
+ */
+declare const discoverClassCandidates: (source: string, fileName: string) => ClassDiscovery;
+//#endregion
+//#region src/email/transform.d.ts
+/** Where this build serves assets from, and how Tailwind is configured. */
+interface TransformOptions {
+  readonly assetBase: string;
+  /** `false` compiles no Tailwind at all. */
+  readonly tailwind?: TailwindOptions | false | undefined;
+  /**
+   * The brand the brand import resolves to, supplied by the host. A project
+   * that imports a brand with no brand here fails to compile.
+   */
+  readonly brand?: EmailBrand | undefined;
+  /** Names the brand import and marks the footer `BrandFooter` renders; `samvaBrandPlugin` when omitted. */
+  readonly brandPlugin?: BrandPlugin | undefined;
+}
+interface ProjectTransform {
+  readonly assets: readonly AssetEntry[];
+  /** The compiled Tailwind sheet, when the project used any utility class. */
+  readonly tailwindSheet: Stylesheet | undefined;
+  /** Every project stylesheet, parsed, by path. */
+  readonly stylesheets: ReadonlyMap<string, Stylesheet>;
+  readonly diagnostics: readonly EmailDiagnostic[];
+}
+/**
+ * The brand specifier a project imports — from its theme's `@import`s or its
+ * TSX — so a host can fetch that brand before it compiles. `undefined` when
+ * the project imports no brand. A project that names two brands gets the
+ * first here and a refusal from the compile.
+ */
+declare const projectBrandSpecifier: (files: Readonly<Record<string, string | Uint8Array>>, themePath?: string, brandPlugin?: BrandPlugin) => string | undefined;
+/** Read a whole project, then compile the classes its scripts used. */
+declare const transformProject: (files: Readonly<Record<string, string | Uint8Array>>, options: TransformOptions) => Promise<ProjectTransform>;
+//#endregion
+//#region src/email/brand-footer.d.ts
+/** A footer block for the send path to append, and its plain-text tail. */
+interface RenderedBrandFooter {
+  readonly html: string;
+  readonly text: string;
+}
+/**
+ * Render `BrandFooter` against a brand on its own, for the send path to
+ * append to a message whose template renders no footer of its own. It
+ * compiles the same component, styled by the same brand theme, a template
+ * would get from its brand import. Without `unsubscribe` the unsubscribe row is
+ * left out.
+ */
+declare const renderBrandFooter: (brand: EmailBrand, options: {
+  readonly unsubscribe: boolean;
+  readonly brandPlugin?: BrandPlugin | undefined;
+}) => Promise<RenderedBrandFooter>;
+/**
+ * Render content against a brand as a project whose `theme.css` imports only
+ * the brand renders it: Tailwind compiles the brand theme for
+ * the classes the content names, `BrandLogo` and `BrandFooter` are bound to the
+ * brand, and the render inlines the result. A brand preview renders through
+ * this, so it shows what a template importing the brand compiles to.
+ */
+declare const renderBrandSample: (brand: EmailBrand, sample: {
+  /** Every class the content names; nothing is discovered from source here. */
+  readonly classes: readonly string[];
+  readonly render: (components: BrandComponents) => EmailContent;
+}, brandPlugin?: BrandPlugin) => Promise<RenderedEmail>;
+//#endregion
+//#region src/sml/lower-project.d.ts
+interface CompiledTemplate {
+  /** The IR, or `undefined` when a finding blocks it. */
+  readonly ir: TemplateIr | undefined;
+  /** The fixtures read from the entry, with imported assets resolved to their URLs. */
+  readonly fixtures: Readonly<Record<string, unknown>>;
+  readonly assets: readonly AssetEntry[];
+  /** Errors block the IR; warnings ride along. */
+  readonly diagnostics: readonly TemplateDiagnostic[];
+}
+//#endregion
+//#region src/sml/compile.d.ts
+interface CompileTemplateOptions extends TransformOptions {
+  /** The project's files by path. Binary files are addressed as assets. */
+  readonly files: Readonly<Record<string, string | Uint8Array>>;
+  /** The entry: a `.tsx` file that default-exports `defineTemplate({ ... })`. */
+  readonly entry: string;
+  /**
+   * The portable JSON Schema, for an entry whose `schema` is not a literal `jsonSchema(...)`
+   * (a Zod or Effect schema needs a library to become JSON Schema). A host that has evaluated the
+   * schema passes its conversion here; a literal schema is read from source and this is ignored.
+   */
+  readonly schema?: Readonly<Record<string, unknown>> | undefined;
+}
+/** Compile a project's entry template to IR without evaluating any of it. */
+declare const compileTemplate: (options: CompileTemplateOptions) => Promise<CompiledTemplate>;
+//#endregion
+//#region src/sml/compatibility.d.ts
+/**
+ * Check what each declared fixture delivers against the pinned client matrix. The rules run on the
+ * rendered document, because what a client drops is what the compiler produced, and every finding
+ * is located at the source of the element that produced it.
+ */
+declare const checkTemplateCompatibility: (ir: TemplateIr, fixtures: Readonly<Record<string, unknown>>, options?: {
+  readonly clients?: readonly EmailClientTarget[] | undefined;
+}) => readonly EmailDiagnostic[];
+//#endregion
+//#region src/sml/profile.d.ts
+/**
+ * Check an entry against the static profile. Pass the entry's source alone, or the project's files
+ * and the entry's path. Imports of files that are absent are trusted to exist, and the brand,
+ * Tailwind and theme are not resolved, so the result holds only findings the source itself owns.
+ */
+declare const checkStaticProfile: (files: string | Readonly<Record<string, string | Uint8Array>>, entry?: string, brandPlugin?: BrandPlugin) => readonly TemplateDiagnostic[];
+/**
+ * The errors in `after` that `before` did not already have, compared by code and message so a
+ * finding that only moved does not count as new.
+ */
+declare const introducedProfileErrors: (before: readonly TemplateDiagnostic[], after: readonly TemplateDiagnostic[]) => readonly TemplateDiagnostic[];
 //#endregion
-export { ASSET_CONTENT_TYPES, type Ancestry, type AppliedStyles, type AssetEntry, type AssetManifest, BRAND_SPECIFIER, COMPATIBILITY_PROVENANCE, type ClassDiscovery, type CompatibilityInput, type CompatibilityProvenance, type CompiledSelector, type Compound, type CssDeclaration, type CssRule, EMAIL_CLIENT_MATRIX, EMAIL_DOCTYPE, EMAIL_ELEMENTS, EMAIL_GLOBAL_ATTRIBUTES, ESSENTIAL_CONSTRUCTS, type EmailAttributeSpec, type EmailBrand, type EmailBrandAddress, type EmailBrandAssets, type EmailBrandFooter, type EmailBrandSocialLink, type EmailClientTarget, EmailCompileError, type EmailCompileOutput, type EmailDiagnostic, type EmailDiagnosticSeverity, type EmailElementSelection, type EmailElementSpec, type EmailGlobalProps, type EmailHtmlOutput, type EmailIntrinsicElements, type EmailLayout, type EmailStyle, type EmailTag, type EmittedPosition, INSTANCE_PATH_ATTRIBUTE, type ProjectTransform, type RenderedEmail, type SerializeEmailOptions, type Specificity, type Stylesheet, TAILWIND_VERSION, type TailwindLimits, type TailwindOptions, type TailwindOutput, type TransformOptions, applyStylesheet, assetEntry, assetUrl, checkAssetBase, checkEmailCompatibility, classListOf, compileEmail, compileSelector, compileTailwind, deriveEmailText, discoverClassCandidates, downlevelColors, downlevelMediaQuery, emailAuthoringTarget, emailDefinitionInstances, emailElement, emailSelectionAncestry, emailSelectionIndex, emailSelectionSiblings, emailSelections, escapeAttribute, escapeText, finalizeValue, foldCalc, formatColor, formatEmailDiagnostic, hasBlockingCompatibility, hasBlockingDiagnostic, isAssetPath, isExternalAsset, isUrlAttribute, matchesSelector, parseBrandSpecifier, parseColor, parseStylesheet, projectBrandSpecifier, renderHeadCss, resolveVariables, serializeEmailHtml, transformProject, unknownCoverage };
+export { type Ancestry, type AppliedStyles, COMPATIBILITY_PROVENANCE, type ClassDiscovery, type CompatibilityInput, type CompatibilityProvenance, type CompileTemplateOptions, type CompiledSelector, type CompiledTemplate, type Compound, type CssDeclaration, type CssRule, EMAIL_CLIENT_MATRIX, ESSENTIAL_CONSTRUCTS, type EmailClientTarget, type EmailContent, type ProjectTransform, type RenderedBrandFooter, type Specificity, type Stylesheet, TAILWIND_VERSION, TEMPLATE_NAME_PATTERN, type TailwindLimits, type TailwindOptions, type TailwindOutput, type TransformOptions, applyStylesheet, checkEmailCompatibility, checkStaticProfile, checkTemplateCompatibility, classListOf, compileSelector, compileTailwind, compileTemplate, discoverClassCandidates, downlevelColors, downlevelMediaQuery, finalizeValue, foldCalc, formatColor, hasBlockingCompatibility, introducedProfileErrors, matchesSelector, parseBrandSpecifier, parseColor, parseStylesheet, projectBrandSpecifier, renderBrandFooter, renderBrandSample, renderHeadCss, resolveVariables, transformProject, unknownCoverage };
 //# sourceMappingURL=compiler.d.ts.map