@samva/markup 0.15.1 → 0.17.0

package/AGENTS.md

@@ -2,8 +2,8 @@
 
 `@samva/markup` is the authoring language and compiler for Samva templates. A template is one TSX
 file in a static profile that default-exports `defineTemplate`: ordinary JSX, HTML and Tailwind that
-a compiler reads without running. The compiler produces a versioned JSON IR, and a pure renderer
-turns the IR and an input into subject, preheader, HTML and text, so nothing executes at send time.
+a compiler reads without running. The compiler produces a versioned JSON compiled template, and a
+pure renderer turns it and an input into a message, so nothing executes at send time.
 A body that would compute over its input is a diagnostic, not a second mode: compute the value in
 the caller and send it in the payload. The package is plain TypeScript with no application runtime;
 the local editor, project builds, and exports live in `@samva/vite`.
@@ -32,38 +32,45 @@ Authoring entries are what a template file imports:
   `"types": ["@samva/markup/samva-brand"]` to the project's tsconfig for `tsc`. In `theme.css`,
   `@import "samva:brand";` layers the brand theme over the default theme (`DEFAULT_THEME`); `samva:brand/<slug>` names one brand. These are
   Samva's brand plugin (`samvaBrandPlugin` from `@samva/markup/brand`), the default; a host that
-  delivers mail itself passes its own `BrandPlugin` as `brandPlugin` to `compileTemplate`,
-  `renderIr` and `renderBrandFooter` to rename the brand import, the footer markers, the
-  unsubscribe placeholder and the unsubscribe link's no-track marker.
+  delivers mail itself passes its own `BrandPlugin` as the `brandPlugin` option of `compileTemplate`,
+  `render` and `compileFooter` to rename the brand import, the footer markers, the unsubscribe
+  placeholder and the unsubscribe link's no-track marker.
 
 Tooling entries are what a host (Vite, the CLI, the editor, the API, the template agent) imports:
 
-- `@samva/markup/compiler` — `compileTemplate`, which reads a project's files and returns the IR,
-  the fixtures, the assets and the diagnostics; `checkTemplateCompatibility` checks each fixture
-  against the client matrix and locates findings at source. `checkStaticProfile(source | files,
-entry?)` is the synchronous structural check: it runs the compiler's lowering without Tailwind, a
-  brand or the files an import names, and returns only findings the source itself owns.
-  `introducedProfileErrors(before, after)` is what a visual edit is refused on. It also holds the
-  compiler's building blocks (`transformProject`, Tailwind, the cascade, CSS), the brand footer and
-  sample renders (`renderBrandFooter`, `renderBrandSample`), and `TEMPLATE_NAME_PATTERN`. It imports no Vite, esbuild, or Node builtins, so it runs in any
-  JavaScript host.
+- `@samva/markup/compiler` — `compileTemplate`, which reads a project's files and returns a
+  `CompileResult`: the compiled `template`, the fixtures, the assets and the diagnostics.
+  `checkTemplate(source | files, { entry?, brandPlugin? })` is the synchronous structural check: it
+  runs the compiler's lowering without Tailwind, a brand or the files an import names, and returns
+  only findings the source itself owns. `introducedErrors(before, after)` is what a visual edit is
+  refused on. It also holds the brand compiles: `compileFooter`, the footer a send appends (with
+  its unsubscribe row, which the send drops with `withoutUnsubscribeRow`; a brand theme outside the
+  grammar comes back as diagnostics), and `previewBrand`, a sample email in an unsaved brand
+  compiled and rendered as a template that imports the brand. It imports no
+  Vite, esbuild, Node builtins or caniemail, so it runs in Node, Bun, Workers and the browser
+  (`tests/browser-entries.test.ts` loads it without `process`).
+- `@samva/markup/compatibility` — `checkCompatibility`, which checks each fixture against
+  the client matrix and locates findings at source; `checkHtmlCompatibility` for HTML a host
+  already has; `hasBlockingCompatibility` and the matrix. It is the only entry that loads
+  caniemail, whose glob dependency reads `process` when it loads.
 - `@samva/markup/diagnostics` — source spans and line maps, the `DIAGNOSTIC_CODES` registry with
-  each code's fix and upgrade recipe, and `EmailDiagnostic`/`EmailCompileError`. It does not load
-  the compiler, so a host that only reports imports it.
-- `@samva/markup/render` — `renderIr(ir, input, { locale, timeZone })`, `renderIrSms` and
-  `renderIrWhatsApp`; the IR types and `SML_IR_VERSION`; `renderIrPreview(ir, input)`, the render an
-  editor shows, with an instance path (`INSTANCE_PATH_ATTRIBUTE`) on every element and the
-  `selections` that map each one to its TSX span; `compileEmail`, the HTML serializer and text
-  derivation; the email element table; SMS segment counts. Its import closure excludes the
-  compiler's libraries (`tests/entry-closure.test.ts`): it is the send-time security boundary and
-  what the API bundles.
+  each code's fix and upgrade recipe, and `EmailDiagnostic`. It does not load the compiler, so a
+  host that only reports imports it.
+- `@samva/markup/render` — `render(template, input, { channel, locale?, timeZone?, brandPlugin? })`,
+  which returns the `channel`'s message (`RenderedEmail`, `RenderedSms` with its segment counts, or
+  `RenderedWhatsApp`) and throws only `RenderError`, including for a template compiled by another
+  `COMPILED_TEMPLATE_VERSION`; the `Compiled*` types; the email element table and `escapeText` /
+  `escapeAttribute`; `smsSegmentInfo`. Its import closure excludes the compiler's libraries
+  (`tests/entry-closure.test.ts`): it is the send-time security boundary and what the API bundles.
 - `@samva/markup/edit` — the code transforms behind visual edits (`inspectSourceElement`,
   `literalReplacement`, `expressionReplacement`, `classNameEdit`, `structuralReplacements`,
   `applySourceReplacements` with a `ProfileGuard`); form reads and exact edits for the `sms` and
   `whatsapp` channel bodies (`readSmsChannel`, `editSmsChannel`, `readWhatsAppChannel`,
   `editWhatsAppChannel`), where text between expressions is editable and every expression,
-  conditional or element is a locked segment; and JSX source locations. Browser-safe: Babel parser
-  only.
+  conditional or element is a locked segment; JSX source locations; and `previewEmail(template,
+input)`, the render an editor shows, with an instance path (`INSTANCE_PATH_ATTRIBUTE`) on every
+  element and the `selections` that map each one to its TSX span. Browser-safe: its closure holds
+  Babel's parser and css-tree only (`tests/entry-closure.test.ts`).
 - `@samva/markup/brand` — brand records and their CSS model (`parseBrandCss`, `printBrandCss`), the
   theme vocabulary (`THEME_COLOR_ROLES`, `THEME_TOKENS`, `DEFAULT_THEME`, `foregroundDefaults`), the
   footer markers a send reads (`renderedFooterMarkers`, `withoutUnsubscribeRow`), and project
@@ -124,7 +131,7 @@ Read the contract before authoring. Import only subpaths declared in `package.js
   generated `sml-dark-*` class, so `bg-card` switches by itself. A `--color-card-dark` token is just
   another color, and `dark:` only picks a different token. A block styled with palette colors
   (`bg-indigo-600`) or raw hex ignores the theme; style with the vocabulary in `THEME_COLOR_ROLES`.
-- **Reading contrast off the light render.** `checkEmailCompatibility` includes `email-contrast`,
+- **Reading contrast off the light render.** `checkHtmlCompatibility` includes `email-contrast`,
   which judges each fixture in light and dark mode (`CONTRAST_THRESHOLDS`); a color a dark block
   leaves unpaired is an error there, not a visual nit.
 - **Declaring a webfont as if every client loads it.** A project font is an ordinary `@font-face`
@@ -146,12 +153,12 @@ Read the contract before authoring. Import only subpaths declared in `package.js
   channel. Helper modules are ordinary imports, not catalog entries; a partial is a function from
   props (and `children`) to JSX that the compiler inlines. A fixture is data: literals, constants
   and imported assets.
-- **The IR is the artifact.** Rendering is a pure function of the IR and the input. The renderer
-  escapes per context, applies the serializer's URL and style rules to every bound value, and
-  rejects unsafe input rather than sanitizing it.
+- **The compiled template is the artifact.** Rendering is a pure function of the template and the
+  input. The renderer escapes per context, applies the serializer's URL and style rules to every
+  bound value, and rejects unsafe input rather than sanitizing it.
 - **Failures are typed.** Compilation reports diagnostic values with a code, a location and a fix:
-  `compileTemplate` returns them beside the IR, and an error finding leaves no IR. A declaration the compiler cannot
-  accept at all, such as an invalid name or a nonportable input schema, throws a `TypeError`.
+  `compileTemplate` returns them beside the template, and an error finding leaves no template. A
+  declaration the compiler cannot accept at all, such as an invalid name or a nonportable input schema, throws a `TypeError`.
 - **Data models are plain types.** Markup's data models are TypeScript types, not schema
   declarations, so there is no schema library to adopt to consume them. Unions discriminate on
   `type`; only error classes carry `_tag`. The input schema is the one
@@ -161,9 +168,9 @@ Read the contract before authoring. Import only subpaths declared in `package.js
 
 - `tsc --noEmit` over the template project catches unsupported elements, attributes, and props.
 - `compileTemplate` reports every static-profile, binding and fixture finding with a source
-  location, and `renderIr(compiled.ir, fixture)` proves one fixture's output without executing the
-  template.
+  location, and `render(compiled.template, fixture, { channel: "email" })` proves one fixture's
+  output without executing the template.
 - `samva templates check` (from `@samva/cli`) compiles every entry and renders every fixture,
   reporting findings with source locations.
-- `renderIrPreview(compiled.ir, fixture)` returns the same document with the source spans an editor
-  selects by.
+- `previewEmail(compiled.template, fixture)` returns the same document with the source spans an
+  editor selects by.

package/CHANGELOG.md

@@ -1,3 +1,95 @@
+## @samva/markup@0.17.0
+
+### One compiler for every host, one render, one error model
+
+Breaking. Update imports and calls as follows:
+
+| Before                                                                         | After                                                                                                                   |
+| ------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------- |
+| `renderIr(ir, input, options)`                                                 | `render(template, input, { channel: "email", ...options })`                                                             |
+| `renderIrSms(ir, input)` (a string)                                            | `render(template, input, { channel: "sms" })` (`{ text, segments }`)                                                    |
+| `renderIrWhatsApp(ir, input)`                                                  | `render(template, input, { channel: "whatsapp" })`                                                                      |
+| `renderIrPreview` from `./render`                                              | `previewEmail` from `./edit`                                                                                            |
+| `TemplateIr`, `SML_IR_VERSION`                                                 | `CompiledTemplate`, `COMPILED_TEMPLATE_VERSION`                                                                         |
+| `IrRenderError`                                                                | `RenderError`, a tagged error                                                                                           |
+| `compileTemplate(...).ir`                                                      | `compileTemplate(...).template`                                                                                         |
+| `checkStaticProfile(files, entry, plugin)`                                     | `checkTemplate(files, { entry, brandPlugin })`                                                                          |
+| `introducedProfileErrors`                                                      | `introducedErrors`                                                                                                      |
+| `checkTemplateCompatibility`, `checkEmailCompatibility` from `./compiler`      | `checkCompatibility`, `checkHtmlCompatibility` from `./compatibility`                                                   |
+| `renderBrandFooter(brand, { unsubscribe })`                                    | `compileFooter(brand)`, which returns `{ footer, diagnostics }`; strip the unsubscribe row with `withoutUnsubscribeRow` |
+| `renderBrandSample` from `./brand-sample`                                      | `previewBrand(brand)` from `./compiler`                                                                                 |
+| `parseBrandSpecifier(s, plugin)`, `projectBrandSpecifier(files, path, plugin)` | `parseBrandSpecifier(s, { brandPlugin })`, `projectBrandSpecifier(files, { themePath, brandPlugin })`                   |
+| `@samva/vite` `TemplateBuild.ir`, `CompiledEntry.ir`                           | `.compiled`                                                                                                             |
+
+- `./compiler` now loads in a browser. caniemail, whose glob dependency reads Node's `process`, is
+  only in `./compatibility`.
+- `./compiler` exports only `compileTemplate`, `checkTemplate`, `introducedErrors`,
+  `compileFooter`, `previewBrand` and the brand specifiers. The cascade, CSS, Tailwind and
+  serializer helpers are no longer public, and `./brand-sample` is removed.
+- Compile and check functions return diagnostics and do not throw for bad input; `render` throws
+  only `RenderError`, including for a compiled template version it does not know. Stored compiled
+  templates keep their `sml` key and stay readable.
+- `readSmsChannel` and `readWhatsAppChannel` return `undefined` instead of `null`.
+
+### Design mode and pins
+
+The preview bar has a **Design** switch. In Design, a click on the email selects it with a
+toolbar that steps out to its container, moves, duplicates or deletes it, and beside a docked
+assistant the element's properties sit next to the email. Edits from the toolbar, the properties
+and the fixture data are staged instead of saved one field at a time: the preview shows them, a
+dock counts them, and undo, redo, reset (after a confirm) and a locked before-and-after compare
+work over them. **Apply** saves them as one version named "Design: N edits". Leaving Design waits
+for the edits to be applied or reset, and Design waits while an assistant turn is running.
+
+The Design tab speaks the author's language. Layers name the blocks and elements the template
+wrote (`Section`, `Button`, `Heading`, `Text`, `Image`) and leave out the compiler's tables and
+cells; a loop's copies are one layer. The inspector names the element and the blocks around it,
+with no internal paths, and edits it with plain controls: text with data bindings shown as chips,
+image description and size, component settings, theme colors as named swatches, type size and
+weight, alignment, and spacing. Each change is staged like any Design edit. The raw props and
+classes are under **Advanced**, and the whole template is in Source.
+
+Beside a docked assistant, the **Pin** switch drops numbered pins on parts of the email. A tray
+lists them with a note each, removes one at a time, and clears all after a confirm.
+
+For hosts:
+
+- `EditorProvider` takes `onPinsChange`, called with every `EditorPin` in tray order whenever the
+  pins change. The `rail.assistant` contribution reads `workspace.pins` and gets `removePin` and
+  `clearPins`, so a chat can attach pins to its next message and clear them once sent.
+- `workspace.design` reports `{ on, pending, applying, waiting }`. Hold the chat while `waiting`
+  is true.
+- `versions.save(revision, options)` receives `options.message`, the name the editor asks for.
+  The parameter is optional, so an existing host keeps working and names versions itself.
+
+### A warning for hotlinked images
+
+`email-external-asset` warns when an email's image points at an absolute URL outside the project's
+asset base. A hotlinked image can disappear, be blocked, track recipients or slow the message; the
+fix is to add the image to the project and import it. It is a warning, so every template that
+compiled before still compiles, and compiled output is unchanged: the email parity digests do not
+move.
+
+## @samva/markup@0.16.0
+
+### The brand footer is one line
+
+`BrandFooter` renders the company name, social links and the unsubscribe link on one line,
+separated by `·`, with the postal address on the line below. It follows a `text-left` or
+`text-right` `className` instead of always centering. Sends without an unsubscribe group drop only
+the unsubscribe link and its separator, and still strip the row of footers compiled before this
+release.
+
+This is an intended change to published output: the email parity digests
+(`packages/markup/tests/support/email-parity.ts`) move with the new footer markup, and Samva's hosted
+runtime must take the same values when it repins to this release.
+
+### Render a brand sample in the browser
+
+`@samva/markup/brand-sample` exports `renderBrandSample` without caniemail, whose glob dependency
+reads Node's `process` when it loads. Import it to preview a brand in a browser; `./compiler`
+still exports `renderBrandSample` for Node, Bun and Workers.
+
 ## @samva/markup@0.15.0
 
 ### WhatsApp template FLOW buttons

package/README.md

@@ -7,7 +7,7 @@ directly for TSX templates or together with `@samva/vite` for the visual editor
 
 - **SML** is the name of this toolkit, not a second syntax. An email is a TSX file that
   default-exports `defineTemplate`, written in the static profile (ordinary JSX, HTML, and Tailwind
-  classes read without running). Compiling it produces the **IR**, the JSON description that
+  classes read without running). Compiling it produces the **compiled template**, the JSON description that
   previews and sends render.
 - The package ships the `sml` skill at `skills/sml/SKILL.md`; it routes you through write, check,
   render, look, and repair. `AGENTS.md` and `contract.json` ship alongside it.
@@ -107,13 +107,13 @@ export default defineTemplate({
 
 A template is read, not run. `@samva/markup/compiler` parses the file and the project files it
 imports without evaluating them, checks every binding against the schema, resolves Tailwind and CSS
-against the markup, and produces the template's IR: JSON, versioned (`"sml": 1`), carrying the
+against the markup, and produces the compiled template: JSON, versioned (`"sml": 1`), carrying the
 markup, the bindings, the conditions, the loops and the formatters. `@samva/markup/render`
-renders that IR against an input. It is a pure function with no dependencies, so nothing executes
+renders that template against an input. It is a pure function with no dependencies, so nothing executes
 at send time.
 
 ```ts
-import { renderIr } from "@samva/markup/render";
+import { render } from "@samva/markup/render";
 import { compileTemplate } from "@samva/markup/compiler";
 
 const compiled = await compileTemplate({
@@ -122,9 +122,10 @@ const compiled = await compileTemplate({
   assetBase: "https://assets.example.com",
   tailwind: { css: files["theme.css"] },
 });
-if (compiled.ir === undefined) throw new Error(compiled.diagnostics.map(String).join("\n"));
+if (compiled.template === undefined) throw new Error(compiled.diagnostics.map(String).join("\n"));
 
-const { subject, preheader, html, text } = renderIr(compiled.ir, compiled.fixtures.default, {
+const { subject, preheader, html, text } = render(compiled.template, compiled.fixtures.default, {
+  channel: "email",
   locale: "en-US",
   timeZone: "UTC",
 });
@@ -157,7 +158,7 @@ chains before `.map(...)` or `.length`. `<Columns each per>` lays a list out in
 (one row without `per`): the child is a function from an item, and its index within the row, to a
 `Column`. A `Column` that states no `width` takes an equal share of the row, whole percent rounded
 down, and a last row with fewer items keeps that share, so it leaves empty space instead of
-stretching. Both lower to a loop in the IR, so nothing is computed at send time.
+stretching. Both lower to a loop in the compiled template, so nothing is computed at send time.
 
 Rejected, each with its own diagnostic: calls other than `fmt.*` and `.map` (`dynamic-expression`),
 statements in a body (`statement-in-body`), imports other than `@samva/markup` and project files
@@ -234,7 +235,7 @@ is checked for these vendors, but a converter-supplied JSON Schema constraint re
 ### Authoring with an agent
 
 The package ships what an agent needs without any other source. `AGENTS.md` opens with the model:
-a template is TSX in the static profile that compiles to IR, and nothing runs at send time.
+a template is TSX in the static profile that compiles to a compiled template, and nothing runs at send time.
 `@samva/markup/contract.json` lists the components with their props, the profile's forms, the
 formatters, the HTML elements and every diagnostic code with its fix; it is generated from the
 compiler, so it matches the version you installed. `skills/sml/SKILL.md` is the `sml` skill: it
@@ -243,7 +244,7 @@ for diagnostics an agent can apply.
 
 ### Previewing a render
 
-`renderIrPreview(ir, input)` from `@samva/markup/render` renders a fixture the way `renderIr` does
+`previewEmail(template, input)` from `@samva/markup/edit` renders a fixture the way `render` does
 and stamps `data-samva-instance` on every element. Its `selections` map each stamped element to the
 line and column of the JSX that produced it, so an editor can select an element on the canvas and
 edit the source at that span. A delivered message never carries the attribute.

package/dist/{assets-tISHaQNF.d.ts → assets-CS5Xa_mr.d.ts}

@@ -1,6 +1,6 @@
-import { t as BrandPlugin } from "./brand-plugin-CHhcei-j.js";
-import { r as EmailDiagnostic } from "./diagnostics-CUYlQ_6x.js";
-import { r as EmailNode } from "./jsx-runtime-DC7xG0aA.js";
+import { t as BrandPlugin } from "./brand-plugin-Dj9SMpfS.js";
+import { n as EmailDiagnostic } from "./diagnostics-D4vSLQrO.js";
+import { i as EmailNode } from "./jsx-runtime-DL8NVF1f.js";
 //#region src/email/brand.d.ts
 interface EmailBrandAddress {
   readonly street1: string;

package/dist/{brand-nreeKWxF.js → brand-CIiEqkU7.js}

@@ -1,5 +1,6 @@
-import { D as samvaBrandPlugin, O as BRAND_FOOTER_MARKER, k as UNSUBSCRIBE_LINK, r as escapeAttribute } from "./html-BvRFepeO.js";
-import { a as jsx, n as Fragment } from "./jsx-runtime-CBlexoeR.js";
+import { _ as UNSUBSCRIBE_LINK, g as BRAND_FOOTER_MARKER, r as escapeAttribute } from "./html-DJUK2YJF.js";
+import { f as samvaBrandPlugin } from "./render-template-DwPDm3Hq.js";
+import { a as jsx, c as rawMarkup, n as Fragment } from "./jsx-runtime-qL19u3Fy.js";
 //#region src/email/assets.ts
 /** Files a template may import, and what they are served as. */
 const ASSET_CONTENT_TYPES = {
@@ -86,13 +87,12 @@ 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
-	})
+const line = (children, last) => jsx("p", {
+	style: { margin: last ? "0" : "0 0 8px 0" },
+	children
 });
+/** The alignment a footer `className` asks for; the footer centers when it names none. */
+const footerAlignment = (className) => /(?:^|\s)text-(left|center|right)(?:\s|$)/.exec(className ?? "")?.[1] ?? "center";
 /** Bind `BrandLogo` and `BrandFooter` to one brand, marked as the plugin names. */
 const brandComponents = (brand, plugin = samvaBrandPlugin) => {
 	const assets = brand.assets ?? {};
@@ -126,25 +126,24 @@ const brandComponents = (brand, plugin = samvaBrandPlugin) => {
 		})] });
 	};
 	const BrandFooter = ({ unsubscribeLabel = "Unsubscribe", className }) => {
-		const rows = [];
-		if (footer.companyName !== void 0 && footer.companyName.trim() !== "") rows.push(row(jsx("span", {
+		const items = [];
+		const separator = () => items.length === 0 ? [] : [" · "];
+		if (footer.companyName !== void 0 && footer.companyName.trim() !== "") items.push(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", {
+		}));
+		for (const link of footer.socialLinks ?? []) items.push(...separator(), jsx("a", {
 			href: link.url,
 			className: "text-muted-foreground underline",
 			children: link.label
-		})])));
-		rows.push(row(unsubscribeLink(unsubscribeLabel, plugin), {
+		}));
+		items.push(jsx("span", {
 			[plugin.unsubscribeRowAttribute]: "",
-			[BRAND_FOOTER_MARKER]: true
+			[BRAND_FOOTER_MARKER]: true,
+			children: [...items.length === 0 ? [] : [rawMarkup(" · ", "\n")], unsubscribeLink(unsubscribeLabel, plugin)]
 		}));
+		const address = footer.address === void 0 ? [] : addressLines(footer.address);
+		const alignment = footerAlignment(className);
 		return jsx("table", {
 			role: "presentation",
 			width: "100%",
@@ -154,16 +153,10 @@ const brandComponents = (brand, plugin = samvaBrandPlugin) => {
 			[plugin.footerAttribute]: "",
 			[BRAND_FOOTER_MARKER]: true,
 			children: jsx("tbody", { children: jsx("tr", { children: jsx("td", {
-				align: "center",
-				className: classes("text-xs text-muted-foreground text-center", className),
+				align: alignment,
+				className: classes("text-xs text-muted-foreground", alignment === "center" ? "text-center" : void 0, className),
 				style: { padding: "32px 16px" },
-				children: jsx("table", {
-					role: "presentation",
-					border: 0,
-					cellpadding: 0,
-					cellspacing: 0,
-					children: jsx("tbody", { children: rows })
-				})
+				children: [line(items, address.length === 0), ...address.length === 0 ? [] : [line([address.join(", ")], true)]]
 			}) }) })
 		});
 	};
@@ -193,8 +186,8 @@ const renderedFooterMarkers = (html, plugin = samvaBrandPlugin) => ({
 * 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")
+	html: rendered.html?.replace(new RegExp(`<(span|tr) ${plugin.unsubscribeRowAttribute}=""[^>]*>[\\s\\S]*?</\\1>`, "g"), ""),
+	text: rendered.text?.split("\n").filter((textLine) => !textLine.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 };

package/dist/{brand-plugin-CHhcei-j.d.ts → brand-plugin-Dj9SMpfS.d.ts}

@@ -24,7 +24,9 @@ interface BrandPlugin {
   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) => {
+declare const parseBrandSpecifier: (specifier: string, options?: {
+  readonly brandPlugin?: BrandPlugin | undefined;
+}) => {
   readonly slug: string | undefined;
 } | undefined;
 //#endregion

package/dist/brand.d.ts

@@ -1,5 +1,5 @@
-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-tISHaQNF.js";
+import { t as BrandPlugin } from "./brand-plugin-Dj9SMpfS.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-CS5Xa_mr.js";
 import { t as Diagnostic } from "./diagnostic-model-DxthUZBT.js";
 import { Result } from "better-result";
 //#region src/email/samva-brand-plugin.d.ts

package/dist/brand.js

@@ -1,4 +1,4 @@
-import { D as samvaBrandPlugin } from "./html-BvRFepeO.js";
-import { a as THEME_COLOR_ROLES, c as foregroundDefaults, i as THEME_COLORS, l as parseBrandCss, n as DEFAULT_THEME_CSS, o as THEME_TOKENS, r as FILL_COLORS, s as contrastForeground, t as DEFAULT_THEME, u as printBrandCss } from "./theme-css-s9QwD5Ko.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-nreeKWxF.js";
+import { f as samvaBrandPlugin } from "./render-template-DwPDm3Hq.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-CIiEqkU7.js";
+import { a as THEME_COLOR_ROLES, c as foregroundDefaults, i as THEME_COLORS, l as parseBrandCss, n as DEFAULT_THEME_CSS, o as THEME_TOKENS, r as FILL_COLORS, s as contrastForeground, t as DEFAULT_THEME, u as printBrandCss } from "./theme-css-P9F5S7Ic.js";
 export { ASSET_CONTENT_TYPES, BRAND_COMPONENT_CLASSES, DEFAULT_THEME, DEFAULT_THEME_CSS, FILL_COLORS, THEME_COLORS, THEME_COLOR_ROLES, THEME_TOKENS, assetEntry, assetUrl, brandComponents, checkAssetBase, contrastForeground, foregroundDefaults, isAssetPath, isExternalAsset, parseBrandCss, printBrandCss, renderedFooterMarkers, samvaBrandPlugin, withoutUnsubscribeRow };

package/dist/compatibility.d.ts

@@ -0,0 +1,76 @@
+import { t as BrandPlugin } from "./brand-plugin-Dj9SMpfS.js";
+import { n as EmailDiagnostic } from "./diagnostics-D4vSLQrO.js";
+import { v as CompiledTemplate } from "./compiled-template-Bc4Dq9zy.js";
+import { r as EmittedPosition } from "./preview-rNoJBEIY.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 checkHtmlCompatibility: (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/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. A fixture the renderer refuses throws
+ * its `RenderError`: validate fixtures before asking what they deliver.
+ */
+declare const checkCompatibility: (template: CompiledTemplate, fixtures: Readonly<Record<string, unknown>>, options?: {
+  readonly clients?: readonly EmailClientTarget[] | undefined;
+  readonly brandPlugin?: BrandPlugin | undefined;
+}) => readonly EmailDiagnostic[];
+//#endregion
+export { COMPATIBILITY_PROVENANCE, type CompatibilityInput, type CompatibilityProvenance, EMAIL_CLIENT_MATRIX, ESSENTIAL_CONSTRUCTS, type EmailClientTarget, checkCompatibility, checkHtmlCompatibility, hasBlockingCompatibility, unknownCoverage };