@samva/markup 0.16.0 → 0.17.1

package/dist/compiled-template-Bc4Dq9zy.d.ts

@@ -0,0 +1,268 @@
+//#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;
+//#endregion
+//#region src/compiled-template.d.ts
+/** The version this package writes. A publication pins the version it was built with. */
+declare const COMPILED_TEMPLATE_VERSION = 1;
+/**
+ * Where a node came from: `[line, column]` in the entry file, or `[line, column, file]` with an
+ * index into `CompiledTemplate.sources` when the node came from an imported project file. Published
+ * sends strip these.
+ */
+type CompiledSource = readonly [line: number, column: number, file?: number];
+/**
+ * A value read at render time.
+ *
+ * - a string, number, boolean or `null` is a literal;
+ * - `bind` reads the input: `"order.id"` is a path from the input root, `"$item.title"` a path
+ *   from the enclosing `each` variable named `item` (the `$` prefix keeps loop variables from
+ *   colliding with input fields);
+ * - `lit` is a literal object or array, for formatter options;
+ * - `concat` joins the text of its parts (a template string);
+ * - `format` calls one formatter from `@samva/markup/fmt`;
+ * - `if` selects between two values (a conditional attribute or class);
+ * - `op` is arithmetic, allowed inside formatter arguments and conditions;
+ * - `length` is `.length` of a bound array or string;
+ * - `count` is `.filter(...).length`: the items of an array that satisfy a condition.
+ */
+type CompiledValue = string | number | boolean | null | {
+  readonly bind: string;
+} | {
+  readonly lit: unknown;
+} | {
+  readonly concat: readonly CompiledValue[];
+} | {
+  readonly format: CompiledFormatter;
+  readonly args: readonly CompiledValue[];
+} | {
+  readonly if: CompiledPredicate;
+  readonly then: CompiledValue;
+  readonly else: CompiledValue;
+} | {
+  readonly op: CompiledArithmetic;
+  readonly args: readonly [CompiledValue, CompiledValue];
+} | {
+  readonly length: CompiledValue;
+} |
+/** How many items of a bound array satisfy `where`, with each item bound as `$as` while it runs. */
+{
+  readonly count: CompiledValue;
+  readonly as: string;
+  readonly where: CompiledPredicate;
+};
+type CompiledFormatter = "money" | "number" | "date" | "time" | "plural" | "list";
+type CompiledArithmetic = "+" | "-" | "*" | "/" | "%";
+type CompiledComparison = "eq" | "ne" | "lt" | "gt" | "le" | "ge";
+/** A condition over the input. Truthiness follows JavaScript: `""`, `0`, `null` and absent are false. */
+type CompiledPredicate =
+/** The bound value at this path is truthy. */
+{
+  readonly present: string;
+} |
+/** Any value is truthy. */
+{
+  readonly truthy: CompiledValue;
+} | {
+  readonly not: CompiledPredicate;
+} | {
+  readonly and: readonly CompiledPredicate[];
+} | {
+  readonly or: readonly CompiledPredicate[];
+} | {
+  readonly cmp: CompiledComparison;
+  readonly args: readonly [CompiledValue, CompiledValue];
+};
+/**
+ * An element's inline style. A string is fully static and was checked at compile time; a list
+ * carries declarations whose values are read at render time; `if` selects between two styles.
+ */
+type CompiledStyle = string | readonly (readonly [property: string, value: CompiledValue])[] | {
+  readonly if: CompiledPredicate;
+  readonly then: CompiledStyle;
+  readonly else: CompiledStyle;
+};
+/** A part of compatibility markup the primitives emit verbatim. */
+type CompiledRawPart = string | {
+  readonly attr: CompiledValue;
+} | {
+  readonly text: CompiledValue;
+};
+interface CompiledElement {
+  readonly el: string;
+  readonly attrs?: Readonly<Record<string, CompiledValue>>;
+  readonly style?: CompiledStyle;
+  readonly children?: readonly CompiledNode[];
+  /**
+   * Set by the compiler on the elements `BrandFooter` writes: only they may carry the reserved
+   * footer markers, so an element the author wrote cannot claim a footer the send path would
+   * then not append.
+   */
+  readonly reserved?: true;
+  readonly src?: CompiledSource;
+}
+/** Content that appears when the predicate holds, or else `else`. */
+interface CompiledIf {
+  readonly if: CompiledPredicate;
+  readonly then: readonly CompiledNode[];
+  readonly else?: readonly CompiledNode[];
+  readonly src?: CompiledSource;
+}
+/**
+ * Repeat `children` for each item of a bound array.
+ *
+ * `where` skips the items that fail a condition (`.filter(...)`), with the item bound as `$as`.
+ * `chunk` groups the items into consecutive slices of that size instead: the loop variable `$as`
+ * then holds one slice, an array, and the last slice may be shorter. Filtering applies first.
+ */
+interface CompiledEach {
+  readonly each: CompiledValue;
+  /** The loop variable, referenced as `$as.field`. */
+  readonly as: string;
+  /** The zero-based index variable, referenced as `$index`. */
+  readonly index?: string;
+  readonly where?: CompiledPredicate;
+  readonly chunk?: number;
+  readonly children: readonly CompiledNode[];
+  readonly src?: CompiledSource;
+}
+/**
+ * Compatibility markup the email primitives emit verbatim (conditional comments, VML). Bound
+ * parts are escaped for the context they sit in. `text` is what the plain-text part reads.
+ */
+interface CompiledRaw {
+  readonly raw: readonly CompiledRawPart[];
+  readonly text?: CompiledValue;
+  readonly src?: CompiledSource;
+}
+/** Where the hidden inbox-preview block goes; it renders the channel's `preheader`. */
+interface CompiledPreheader {
+  readonly preheader: true;
+}
+/** A node in an email body. A bare value in child position is rendered as escaped text. */
+type CompiledNode = CompiledValue | CompiledElement | CompiledIf | CompiledEach | CompiledRaw | CompiledPreheader;
+interface CompiledEmail {
+  readonly subject: CompiledValue;
+  readonly preheader?: CompiledValue;
+  readonly body: CompiledNode;
+}
+/** A plain-text channel body: text pieces, conditionals and loops. */
+interface CompiledSms {
+  readonly category?: string;
+  readonly body: readonly CompiledNode[];
+}
+type CompiledWhatsAppButton = {
+  readonly type: "quick-reply";
+  readonly text: CompiledValue;
+} | {
+  readonly type: "url";
+  readonly text: CompiledValue;
+  readonly url: CompiledValue;
+} | {
+  readonly type: "phone";
+  readonly text: CompiledValue;
+  readonly phone: CompiledValue;
+} | {
+  readonly type: "copy-code";
+  readonly code: CompiledValue;
+} | {
+  readonly type: "flow";
+  readonly text: CompiledValue;
+  /** The Samva flow handle, resolved to Meta's flow id when the template is registered. */
+  readonly flow: string;
+  readonly action: "navigate" | "data_exchange";
+  /** Meta's `navigate_screen`; absent opens the flow's first entry screen. */
+  readonly screen?: string;
+};
+/** A button, or buttons that appear when a condition over the input holds. */
+type CompiledWhatsAppButtonNode = CompiledWhatsAppButton | {
+  readonly if: CompiledPredicate;
+  readonly then: readonly CompiledWhatsAppButtonNode[];
+  readonly else?: readonly CompiledWhatsAppButtonNode[];
+  readonly src?: CompiledSource;
+};
+interface CompiledWhatsApp {
+  readonly category: string;
+  readonly language: string;
+  /** For a media header, `content` is the media URL. */
+  readonly header?: {
+    readonly type: "text" | "image" | "video" | "document";
+    readonly content: readonly CompiledNode[];
+  };
+  readonly body: readonly CompiledNode[];
+  readonly footer?: readonly CompiledNode[];
+  readonly buttons?: readonly CompiledWhatsAppButtonNode[];
+}
+interface CompiledTemplate {
+  readonly sml: typeof COMPILED_TEMPLATE_VERSION;
+  readonly template: string;
+  readonly locale?: string;
+  /** Project paths that `CompiledSource` file indexes name; index 0 is the entry. */
+  readonly sources?: readonly string[];
+  readonly email?: CompiledEmail;
+  readonly sms?: CompiledSms;
+  readonly whatsapp?: CompiledWhatsApp;
+  /** The portable JSON Schema every send's input is validated against. */
+  readonly schema: Readonly<Record<string, unknown>>;
+}
+/** The channels a template can declare and `render` can render. */
+type Channel = "email" | "sms" | "whatsapp";
+interface RenderedEmail {
+  readonly subject: string;
+  readonly preheader: string | undefined;
+  readonly html: string;
+  readonly text: string;
+}
+/** An SMS message: its text and what it costs in segments. */
+interface RenderedSms {
+  readonly text: string;
+  readonly segments: SmsSegmentInfo;
+}
+type RenderedWhatsAppButton = {
+  readonly type: "quick-reply";
+  readonly text: string;
+} | {
+  readonly type: "url";
+  readonly text: string;
+  readonly url: string;
+} | {
+  readonly type: "phone";
+  readonly text: string;
+  readonly phone: string;
+} | {
+  readonly type: "copy-code";
+  readonly code: string;
+} | {
+  readonly type: "flow";
+  readonly text: string;
+  readonly flow: string;
+  readonly action: "navigate" | "data_exchange";
+  readonly screen?: string;
+};
+/** A WhatsApp message with every text rendered and every conditional button resolved. */
+interface RenderedWhatsApp {
+  readonly language: string;
+  readonly category: string;
+  /** For a media header, `text` is the media URL. */
+  readonly header?: {
+    readonly type: "text" | "image" | "video" | "document";
+    readonly text: string;
+  };
+  readonly body: string;
+  readonly footer?: string;
+  readonly buttons: readonly RenderedWhatsAppButton[];
+}
+/** What `render` returns for each channel. */
+interface RenderedMessage {
+  readonly email: RenderedEmail;
+  readonly sms: RenderedSms;
+  readonly whatsapp: RenderedWhatsApp;
+}
+//#endregion
+export { smsSegmentInfo as A, RenderedEmail as C, RenderedWhatsAppButton as D, RenderedWhatsApp as E, SmsEncoding as O, CompiledWhatsAppButtonNode as S, RenderedSms as T, CompiledStyle as _, CompiledEach as a, CompiledWhatsApp as b, CompiledFormatter as c, CompiledPredicate as d, CompiledPreheader as f, CompiledSource as g, CompiledSms as h, CompiledComparison as i, SmsSegmentInfo as k, CompiledIf as l, CompiledRawPart as m, Channel as n, CompiledElement as o, CompiledRaw as p, CompiledArithmetic as r, CompiledEmail as s, COMPILED_TEMPLATE_VERSION as t, CompiledNode as u, CompiledTemplate as v, RenderedMessage as w, CompiledWhatsAppButton as x, CompiledValue as y };

package/dist/compiler.d.ts

@@ -1,135 +1,9 @@
-import { a as TemplateDiagnostic, r as EmailDiagnostic } from "./diagnostics-CUYlQ_6x.js";
-import { r as EmailNode } from "./jsx-runtime-DC7xG0aA.js";
-import { a as TEMPLATE_NAME_PATTERN, n as EmailContent } from "./template-B-UDXK8a.js";
-import { n as parseBrandSpecifier, t as BrandPlugin } from "./brand-plugin-CHhcei-j.js";
-import { a as EmailBrand } from "./brand-jFV6YtSV.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, v as Stylesheet, w as classListOf, x as Ancestry, y as compileSelector } from "./render-CuZej25A.js";
-import { n as renderBrandFooter, r as renderBrandSample, t as RenderedBrandFooter } from "./brand-footer-ClRtWnIc.js";
-import { n as AssetEntry } from "./assets-BSuNT9gr.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.
- * Values whose expansion exceeds the render-time budget are left as authored.
- */
-declare const resolveVariables: (value: string, variables: Readonly<Record<string, string>>, depth?: number) => string;
-/**
- * Fold a constant `calc()` to a plain value. Tailwind writes every spacing
- * utility as `calc(var(--spacing) * n)`, and classic Outlook does not implement
- * `calc()` at all, so an unfolded value is a silently missing style. An
- * expression that cannot be reduced to one term is left exactly as authored.
- */
-declare const foldCalc: (value: string) => string;
-/** Resolve custom properties, then fold what the arithmetic allows. */
-declare const finalizeValue: (value: string, variables: Readonly<Record<string, string>>) => string;
-/** Media Queries Level 4 range syntax down to the `min-`/`max-` prefixes clients support. */
-declare const downlevelMediaQuery: (condition: string) => string;
-/** Render the rules that could not be inlined as one `<style>` body. */
-declare const renderHeadCss: (rules: readonly CssRule[], headAtRules: readonly string[], variables: Readonly<Record<string, string>>, darkVariables?: Readonly<Record<string, string>>) => string;
-//#endregion
-//#region src/email/css-color.d.ts
-/** A color in extended sRGB, alpha included, before clamping and gamma. */
-interface Rgba {
-  readonly r: number;
-  readonly g: number;
-  readonly b: number;
-  readonly a: number;
-}
-/** Parse any supported color notation into extended sRGB. `undefined` means "leave it alone". */
-declare const parseColor: (value: string) => Rgba | undefined;
-/** sRGB hex, or `rgba()` when the color is not opaque. */
-declare const formatColor: (color: Rgba) => string;
-/** Rewrite every modern color function in a declaration value; other text is untouched. */
-declare const downlevelColors: (value: string) => string;
-//#endregion
-//#region src/email/cascade.d.ts
-interface AppliedStyles {
-  readonly tree: EmailNode;
-  /** Rules that could not be inlined, ready for a `<style>` element in `<head>` after `darkRules`. */
-  readonly headCss: string;
-  /**
-   * A generated class for each distinct set of dark-mode declarations, mapped
-   * to those declarations. An element whose inlined styles read a color the
-   * theme's dark-mode block redefines carries the class.
-   */
-  readonly darkRules: ReadonlyMap<string, string>;
-  /** Project `@font-face` rules, for a `<head>` style classic Outlook cannot see. */
-  readonly fontFaceCss: string;
-  readonly diagnostics: readonly EmailDiagnostic[];
-}
-/**
- * Resolve every stylesheet against the tree: inline what a client will honor on
- * the element, and keep the rest for `<head>`. Where the sheet has a dark-mode
- * theme, an element whose inlined styles read a color it redefines also gets a
- * generated class whose dark-mode rule restates those styles at their dark
- * values.
- */
-declare const applyStylesheet: (root: EmailNode, sheet: Stylesheet, options?: {
-  readonly knownClasses?: ReadonlySet<string>;
-}) => AppliedStyles;
-//#endregion
-//#region src/email/tailwind-stylesheets.gen.d.ts
-/** The exact Tailwind release the compiler runs, recorded in every build manifest. */
-declare const TAILWIND_VERSION = "4.3.3";
-//#endregion
+import { n as parseBrandSpecifier, t as BrandPlugin } from "./brand-plugin-Dj9SMpfS.js";
+import { i as TemplateDiagnostic, n as EmailDiagnostic } from "./diagnostics-D4vSLQrO.js";
+import { n as AssetEntry, p as EmailBrand } from "./assets-CS5Xa_mr.js";
+import { v as CompiledTemplate } from "./compiled-template-Bc4Dq9zy.js";
+import { i as TEMPLATE_NAME_PATTERN } from "./template-DmNcoH4Q.js";
+import "css-tree";
 //#region src/email/tailwind.d.ts
 interface TailwindOptions {
   /**
@@ -160,34 +34,6 @@ interface TailwindLimits {
   /** 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. */
@@ -203,35 +49,25 @@ interface TransformOptions {
   /** 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: the default theme, the primitives' rules, the project theme and
-   * the utilities the project uses. Without Tailwind, the default theme and the primitives' rules.
-   */
-  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>;
+declare const projectBrandSpecifier: (files: Readonly<Record<string, string | Uint8Array>>, options?: {
+  readonly themePath?: string | undefined;
+  readonly brandPlugin?: BrandPlugin | undefined;
+}) => string | undefined;
 //#endregion
 //#region src/sml/lower-project.d.ts
-interface CompiledTemplate {
-  /** The IR, or `undefined` when a finding blocks it. */
-  readonly ir: TemplateIr | undefined;
+interface CompileResult {
+  /** The compiled template, or `undefined` when a finding blocks it. */
+  readonly template: CompiledTemplate | 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. */
+  /** Errors block the template; warnings ride along. */
   readonly diagnostics: readonly TemplateDiagnostic[];
 }
 //#endregion
@@ -248,18 +84,8 @@ interface CompileTemplateOptions extends TransformOptions {
    */
   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[];
+/** Compile a project's entry template without evaluating any of it. */
+declare const compileTemplate: (options: CompileTemplateOptions) => Promise<CompileResult>;
 //#endregion
 //#region src/sml/profile.d.ts
 /**
@@ -267,11 +93,51 @@ declare const checkTemplateCompatibility: (ir: TemplateIr, fixtures: Readonly<Re
  * 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[];
+declare const checkTemplate: (files: string | Readonly<Record<string, string | Uint8Array>>, options?: {
+  readonly entry?: string | undefined;
+  readonly brandPlugin?: BrandPlugin | undefined;
+}) => 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[];
+declare const introducedErrors: (before: readonly TemplateDiagnostic[], after: readonly TemplateDiagnostic[]) => readonly TemplateDiagnostic[];
+//#endregion
+//#region src/email/footer.d.ts
+/** A footer block for the send path to append, and its plain-text tail. */
+interface CompiledFooter {
+  readonly html: string;
+  readonly text: string;
+  /**
+   * The rules the footer needs in the message's `<head>`: its dark-mode colors and the
+   * `dark:` swap of the brand logo. Empty when it needs none.
+   */
+  readonly headCss: string;
+}
+interface FooterCompile {
+  /** The footer, or `undefined` when a finding blocks it. */
+  readonly footer: CompiledFooter | undefined;
+  readonly diagnostics: readonly EmailDiagnostic[];
+}
+/**
+ * Compile `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. The footer always carries the
+ * unsubscribe row; the send drops it with `withoutUnsubscribeRow` from `./brand` where the message
+ * has none. A brand theme outside the grammar leaves no footer and comes back as diagnostics.
+ */
+declare const compileFooter: (brand: EmailBrand, options?: {
+  readonly brandPlugin?: BrandPlugin | undefined;
+}) => Promise<FooterCompile>;
+//#endregion
+//#region src/email/brand-preview.d.ts
+/** The preview's HTML, or `undefined` when a finding blocks it. */
+interface BrandPreview {
+  readonly html: string | undefined;
+  readonly diagnostics: readonly TemplateDiagnostic[];
+}
+declare const previewBrand: (brand: EmailBrand, options?: {
+  readonly brandPlugin?: BrandPlugin | undefined;
+}) => Promise<BrandPreview>;
 //#endregion
-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 };
+export { type BrandPreview, type CompileResult, type CompileTemplateOptions, type CompiledFooter, type FooterCompile, TEMPLATE_NAME_PATTERN, type TailwindOptions, checkTemplate, compileFooter, compileTemplate, introducedErrors, parseBrandSpecifier, previewBrand, projectBrandSpecifier };