@samva/markup 0.15.1 → 0.17.0

package/dist/html-DJUK2YJF.js

@@ -0,0 +1,483 @@
+import { n as isObject } from "./guards-eV1qLbf2.js";
+import { a as EMAIL_ELEMENTS, d as reservedBrandAttributes, f as samvaBrandPlugin, o as EMAIL_GLOBAL_ATTRIBUTES, r as renderEmail, s as emailElement } from "./render-template-DwPDm3Hq.js";
+//#region src/internal/unsubscribe-link.ts
+/**
+* Marks the one link the serializer lets carry the brand plugin's unsubscribe
+* placeholder as its href. Only `BrandFooter` sets it; nothing public exports
+* it, so no author-written link can claim the exemption.
+*/
+const UNSUBSCRIBE_LINK = Symbol("samva.unsubscribe-link");
+/**
+* Marks the elements `BrandFooter` writes the brand plugin's footer markers
+* on. The serializer emits those reserved attributes only for an element
+* carrying it, so an author cannot claim a footer the send path would then
+* not append.
+*/
+const BRAND_FOOTER_MARKER = Symbol("samva.brand-footer-marker");
+//#endregion
+//#region src/preview.ts
+/**
+* The attribute a preview stamps so a click in a rendered document resolves to exactly one
+* rendered element. A delivered message never carries it.
+*/
+const INSTANCE_PATH_ATTRIBUTE = "data-samva-instance";
+const locationKey = (origin) => `${origin.fileName}:${origin.lineNumber}:${origin.columnNumber}`;
+const originKey = (selection) => `${selection.tag}\u0000${selection.origins.map(locationKey).join("\0")}`;
+const parentOf = (instancePath) => {
+	const cut = instancePath.lastIndexOf(".");
+	return cut === -1 ? void 0 : instancePath.slice(0, cut);
+};
+/**
+* Turn one render's positions into selections, in document order. `occurrence` and `occurrences`
+* count the rendered elements that share an authored origin and tag.
+*/
+const emailSelections = (positions) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const position of positions) {
+		const key = originKey(position);
+		counts.set(key, (counts.get(key) ?? 0) + 1);
+	}
+	const seen = /* @__PURE__ */ new Map();
+	return [...positions].toSorted((left, right) => left.start === right.start ? right.end - left.end : left.start - right.start).map((position) => {
+		const key = originKey(position);
+		const occurrence = (seen.get(key) ?? 0) + 1;
+		seen.set(key, occurrence);
+		const parentPath = parentOf(position.instancePath);
+		return {
+			instancePath: position.instancePath,
+			tag: position.tag,
+			origins: position.origins,
+			authored: position.authored,
+			occurrence,
+			occurrences: counts.get(key) ?? 1,
+			...parentPath === void 0 ? {} : { parentPath },
+			start: position.start,
+			end: position.end
+		};
+	});
+};
+/**
+* Render one fixture with an instance path stamped on every element, and the selection each path
+* resolves to. The selections come from the spans the compiler recorded, so a click on the canvas
+* lands on the exact node of the source that produced it.
+*/
+const previewEmail = (template, input, options = {}) => {
+	const rendered = renderEmail(template, input, {
+		...options,
+		positions: true
+	});
+	const sources = template.sources ?? [];
+	const ordered = (rendered.positions ?? []).map((position) => {
+		const src = position.src;
+		const origins = src === void 0 ? [] : [{
+			fileName: sources[src[2] ?? 0] ?? "",
+			lineNumber: src[0],
+			columnNumber: src[1]
+		}];
+		return {
+			start: position.start,
+			end: position.end,
+			tag: position.tag,
+			src: src === void 0 ? void 0 : src.join(":"),
+			origins,
+			path: "",
+			parent: void 0
+		};
+	}).toSorted((left, right) => left.start === right.start ? right.end - left.end : left.start - right.start);
+	const open = [];
+	const childCount = /* @__PURE__ */ new Map();
+	for (const element of ordered) {
+		while (open.length > 0 && open[open.length - 1].end <= element.start) open.pop();
+		const parent = open[open.length - 1];
+		const index = childCount.get(parent) ?? 0;
+		childCount.set(parent, index + 1);
+		element.parent = parent;
+		element.path = parent === void 0 ? String(index) : `${parent.path}.${index}`;
+		open.push(element);
+	}
+	const inserts = ordered.map((element) => ({
+		at: element.start + 1 + element.tag.length,
+		text: ` ${INSTANCE_PATH_ATTRIBUTE}="${element.path}"`
+	}));
+	inserts.sort((left, right) => left.at - right.at);
+	let html = "";
+	let cursor = 0;
+	for (const insert of inserts) {
+		html += rendered.html.slice(cursor, insert.at) + insert.text;
+		cursor = insert.at;
+	}
+	html += rendered.html.slice(cursor);
+	const shift = (offset) => {
+		let moved = 0;
+		for (const insert of inserts) {
+			if (insert.at > offset) break;
+			moved += insert.text.length;
+		}
+		return offset + moved;
+	};
+	const positions = ordered.map((element) => ({
+		start: shift(element.start),
+		end: shift(element.end),
+		origins: element.origins,
+		instancePath: element.path,
+		tag: element.tag,
+		authored: element.src !== void 0 && (element.parent === void 0 || element.parent.src !== element.src)
+	}));
+	const selections = emailSelections(positions);
+	return {
+		subject: rendered.subject,
+		preheader: rendered.preheader,
+		html,
+		text: rendered.text,
+		selections
+	};
+};
+/** Look selections up by the instance path a rendered document carries. */
+const emailSelectionIndex = (selections) => new Map(selections.map((selection) => [selection.instancePath, selection]));
+/**
+* The authoring element a selection edits. For an authored element that is the element itself; for
+* a generated wrapper it is the primitive that asked for it. Undefined only where the compiler
+* generated markup with no authoring behind it, which nothing can edit in place.
+*/
+const emailAuthoringTarget = (selection) => selection.origins[0];
+/** Root-first ancestry of a selection, itself last. */
+const emailSelectionAncestry = (index, instancePath) => {
+	const chain = [];
+	let current = index.get(instancePath);
+	while (current !== void 0) {
+		chain.unshift(current);
+		current = current.parentPath === void 0 ? void 0 : index.get(current.parentPath);
+	}
+	return chain;
+};
+/**
+* Every rendered instance produced by the same authored element, in document order. One entry
+* means it rendered once; several mean it repeated.
+*/
+const emailSelectionSiblings = (selections, selection) => {
+	const key = originKey(selection);
+	return selections.filter((candidate) => originKey(candidate) === key);
+};
+/**
+* Every rendered instance of the same authored element. A partial edited at its definition changes
+* all of these, which is the scope a control has to name before it applies.
+*/
+const emailDefinitionInstances = (selections, selection) => {
+	const authoring = selection.origins[0];
+	const key = `${selection.tag}\u0000${authoring === void 0 ? "" : locationKey(authoring)}`;
+	return selections.filter((candidate) => {
+		const origin = candidate.origins[0];
+		return `${candidate.tag}\u0000${origin === void 0 ? "" : locationKey(origin)}` === key;
+	});
+};
+//#endregion
+//#region src/email/html.ts
+/** Escape a value for element content. */
+const escapeText = (value) => value.replace(/[&<>]/g, (character) => ({
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;"
+})[character] ?? character);
+/** Escape a value for a double-quoted attribute. */
+const escapeAttribute = (value) => value.replace(/[&<>"']/g, (character) => ({
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+})[character] ?? character);
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/;
+const SAFE_URL_SCHEME = /^(https:\/\/|mailto:|tel:|cid:|#)/i;
+const RELATIVE_URL = /^(\.{1,2}\/|\/(?!\/))/;
+/**
+* Only references an email client will follow safely; no `javascript:`, no
+* `data:`. A relative reference is legal only for an export: a file on disk can
+* resolve one against its own directory, and a delivered message cannot resolve
+* anything but an absolute URL.
+*/
+const isSafeUrl = (value, relative) => !/^[\u0000-\u0020]/.test(value) && !CONTROL_CHARACTERS.test(value) && !value.includes("\\") && (SAFE_URL_SCHEME.test(value) || relative && RELATIVE_URL.test(value));
+const CSS_PROPERTY = /^(--[a-zA-Z0-9-]+|[a-zA-Z][a-zA-Z0-9-]*)$/;
+const CSS_UNSAFE = /[;{}<>\\]|expression\s*\(|@import|\/\*/i;
+const CSS_URL = /url\(\s*(['"]?)([^'")]*)\1\s*\)/gi;
+/** camelCase to kebab-case; already-kebab names pass through unchanged. */
+const kebab = (property) => property.startsWith("--") ? property : property.replace(/[A-Z]/g, (l) => `-${l.toLowerCase()}`);
+const UNITLESS = /* @__PURE__ */ new Set([
+	"opacity",
+	"zIndex",
+	"fontWeight",
+	"lineHeight",
+	"order",
+	"flexGrow",
+	"flexShrink",
+	"columnCount",
+	"orphans",
+	"widows",
+	"zoom",
+	"fillOpacity",
+	"strokeOpacity"
+]);
+/** A bare number is pixels for every property that takes a length. */
+const declarationValue = (property, value) => typeof value === "number" && value !== 0 && !UNITLESS.has(property) && !property.startsWith("--") ? `${value}px` : String(value);
+const report = (sink, code, message, origins, severity = "error") => {
+	sink.diagnostics.push({
+		code,
+		severity,
+		message,
+		origins
+	});
+};
+const declarations = (sink, style, origins) => {
+	const parts = [];
+	for (const [property, value] of Object.entries(style)) {
+		if (value === void 0 || value === null) continue;
+		if (!CSS_PROPERTY.test(property)) {
+			report(sink, "unsupported-style-property", `Style property ${JSON.stringify(property)} is not a CSS property name; write it in camelCase (backgroundColor) or as a custom property (--brand).`, origins);
+			continue;
+		}
+		if (typeof value !== "string" && typeof value !== "number") {
+			report(sink, "invalid-style-value", `Style ${property} must be a string or number, not ${typeof value}.`, origins);
+			continue;
+		}
+		const text = declarationValue(property, value);
+		if (CSS_UNSAFE.test(text) || CONTROL_CHARACTERS.test(text)) {
+			report(sink, "unsafe-style-value", `Style ${property} contains CSS that could break out of the declaration; remove ${JSON.stringify(text)}.`, origins);
+			continue;
+		}
+		let unsafeUrl;
+		for (const match of text.matchAll(CSS_URL)) if (!isSafeUrl(match[2] ?? "", sink.relativeUrls)) unsafeUrl = match[2] ?? "";
+		if (unsafeUrl !== void 0) {
+			report(sink, "unsafe-url", `Style ${property} points at ${JSON.stringify(unsafeUrl)}; email URLs must use https:, mailto:, tel:, cid: or a fragment${sink.relativeUrls ? ", or a relative path" : ""}.`, origins);
+			continue;
+		}
+		parts.push(`${kebab(property)}:${text}`);
+	}
+	return parts.join(";");
+};
+const attributeValue = (sink, tag, name, spec, value, origins) => {
+	if (value === void 0 || value === null || value === false) return void 0;
+	if (value === true) return "";
+	if (typeof value !== "string" && typeof value !== "number") {
+		report(sink, "invalid-attribute-value", `<${tag} ${name}> must be a string or number, not ${typeof value}.`, origins);
+		return;
+	}
+	const text = String(value);
+	if (CONTROL_CHARACTERS.test(text)) {
+		report(sink, "invalid-attribute-value", `<${tag} ${name}> contains control characters.`, origins);
+		return;
+	}
+	if (spec.values !== void 0 && !spec.values.includes(text)) {
+		report(sink, "invalid-attribute-value", `<${tag} ${name}> accepts ${spec.values.join(", ")}; received ${JSON.stringify(text)}.`, origins);
+		return;
+	}
+	if (spec.type === "number" && !/^-?\d+$/.test(text)) {
+		report(sink, "invalid-attribute-value", `<${tag} ${name}> must be an integer.`, origins);
+		return;
+	}
+	if (spec.type === "measure" && !/^\d+(\.\d+)?%?$/.test(text)) {
+		report(sink, "invalid-attribute-value", `<${tag} ${name}> must be a pixel count or a percentage.`, origins);
+		return;
+	}
+	if (spec.type === "url" && !isSafeUrl(text, sink.relativeUrls)) {
+		report(sink, "unsafe-url", sink.relativeUrls ? `<${tag} ${name}> must use https:, mailto:, tel:, cid:, a fragment, or a relative path; received ${JSON.stringify(text)}.` : `<${tag} ${name}> must use https:, mailto:, tel:, cid: or a fragment; received ${JSON.stringify(text)}. A relative path resolves only in an export, never in a delivered message.`, origins);
+		return;
+	}
+	return text;
+};
+const attributes = (sink, tag, spec, props, origins) => {
+	const emitted = [];
+	const present = /* @__PURE__ */ new Set();
+	let classes;
+	const unsubscribeLink = tag === "a" && props[UNSUBSCRIBE_LINK] === true;
+	const { unsubscribeUrlPlaceholder, noTrackAttribute } = sink.brandPlugin;
+	for (const [key, value] of Object.entries(props)) {
+		if (key === "key") continue;
+		const name = key === "className" ? "class" : key;
+		if (unsubscribeLink && name === "href" && value === unsubscribeUrlPlaceholder) {
+			present.add(name);
+			emitted.push(` href="${escapeAttribute(unsubscribeUrlPlaceholder)}" ${noTrackAttribute}`);
+			continue;
+		}
+		if (name === "class") {
+			if (value === void 0 || value === null) continue;
+			if (typeof value !== "string") {
+				report(sink, "invalid-attribute-value", `<${tag} class> must be a string.`, origins);
+				continue;
+			}
+			if (classes !== void 0) {
+				report(sink, "duplicate-attribute", `<${tag}> sets both class and className; keep one.`, origins);
+				continue;
+			}
+			classes = value;
+			emitted.push(` class="${escapeAttribute(value)}"`);
+			continue;
+		}
+		if (name === "style") {
+			if (value === void 0 || value === null) continue;
+			if (!isObject(value) || Array.isArray(value)) {
+				report(sink, "invalid-style", `<${tag} style> must be a property object, for example style={{ backgroundColor: "#fff" }}.`, origins);
+				continue;
+			}
+			const css = declarations(sink, value, origins);
+			if (css !== "") emitted.push(` style="${escapeAttribute(css)}"`);
+			continue;
+		}
+		if (/^on/i.test(name)) {
+			report(sink, "event-handler", `<${tag} ${name}> is an event handler; email clients strip scripting and Samva refuses it.`, origins);
+			continue;
+		}
+		if (sink.reservedAttributes.has(name) && props[BRAND_FOOTER_MARKER] !== true) {
+			report(sink, "reserved-attribute", `<${tag} ${name}> is written only by BrandFooter from ${sink.brandPlugin.specifier}; render BrandFooter instead of marking an element as the footer.`, origins);
+			continue;
+		}
+		if (/^(data|aria)-[a-z0-9-]+$/.test(name)) {
+			const text = attributeValue(sink, tag, name, { type: "string" }, value, origins);
+			if (text !== void 0) emitted.push(` ${name}="${escapeAttribute(text)}"`);
+			continue;
+		}
+		const globalAttributes = EMAIL_GLOBAL_ATTRIBUTES;
+		const attribute = Object.hasOwn(globalAttributes, name) ? globalAttributes[name] : Object.hasOwn(spec.attributes, name) ? spec.attributes[name] : void 0;
+		if (attribute === void 0) {
+			const supported = [
+				...Object.keys(EMAIL_GLOBAL_ATTRIBUTES),
+				...Object.keys(spec.attributes),
+				"class",
+				"style"
+			].sort().join(", ");
+			report(sink, "unsupported-attribute", `<${tag}> does not support the ${name} attribute. Supported: ${supported}, plus data-* and aria-*.`, origins);
+			continue;
+		}
+		present.add(name);
+		const text = attributeValue(sink, tag, name, attribute, value, origins);
+		if (text !== void 0) emitted.push(` ${name}="${escapeAttribute(text)}"`);
+	}
+	for (const [name, attribute] of Object.entries(spec.attributes)) if (attribute.required === true && !present.has(name)) report(sink, "missing-attribute", `<${tag}> requires the ${name} attribute.`, origins);
+	return emitted.join("");
+};
+/** Fragments are transparent to a content model; raw compatibility markup is not content. */
+const contentChildren = (children) => children.flatMap((child) => child.type === "Fragment" ? contentChildren(child.children) : [child]);
+const checkContentModel = (sink, tag, spec, children, origins) => {
+	if (spec.content === "void") {
+		if (contentChildren(children).length > 0) report(sink, "void-element-children", `<${tag}> cannot have children.`, origins);
+		return;
+	}
+	if (spec.content === "text" || spec.content === "raw") {
+		for (const child of contentChildren(children)) if (child.type !== "Text") report(sink, "invalid-content", `<${tag}> accepts text only.`, child.type === "Element" ? child.origins : origins);
+		return;
+	}
+	if (spec.childElements === void 0) return;
+	for (const child of contentChildren(children)) {
+		if (child.type === "Raw") continue;
+		if (child.type === "Text") {
+			if (child.value.trim() !== "") report(sink, "invalid-content", `<${tag}> cannot contain text directly; put it inside <${spec.childElements[0]}>.`, origins);
+			continue;
+		}
+		if (child.type === "Element" && !spec.childElements.includes(child.tag)) report(sink, "invalid-content", `<${tag}> accepts only ${spec.childElements.map((name) => `<${name}>`).join(", ")}; found <${child.tag}>.`, child.origins);
+	}
+};
+/** Every write goes through here so `sink.written` stays the emitted offset. */
+const emit = (sink, text) => {
+	sink.written += text.length;
+	return text;
+};
+const serialize = (sink, node, parentPath, counter) => {
+	switch (node.type) {
+		case "Text": return emit(sink, escapeText(node.value));
+		case "Raw": return emit(sink, node.html);
+		case "Fragment": return node.children.map((child) => serialize(sink, child, parentPath, counter)).join("");
+		case "Element": {
+			const start = sink.written;
+			const index = counter.next++;
+			const path = parentPath === "" ? String(index) : `${parentPath}.${index}`;
+			const own = { next: 0 };
+			const stamp = sink.instancePaths ? ` ${INSTANCE_PATH_ATTRIBUTE}="${path}"` : "";
+			const spec = emailElement(node.tag);
+			if (spec === void 0) {
+				report(sink, "unsupported-element", `<${node.tag}> is not part of the supported email vocabulary. Supported elements: ${Object.keys(EMAIL_ELEMENTS).join(", ")}.`, node.origins);
+				return "";
+			}
+			checkContentModel(sink, node.tag, spec, node.children, node.origins);
+			if (spec.content === "raw") {
+				const css = node.children.map((child) => child.type === "Text" ? child.value : "").join("");
+				if (/<\/|<!--/i.test(css)) {
+					report(sink, "unsafe-raw-text", `<${node.tag}> content cannot contain markup.`, node.origins);
+					return "";
+				}
+				const rawAttrs = attributes(sink, node.tag, spec, node.props, node.origins);
+				const raw = css === "" ? "" : `<${node.tag}${rawAttrs}${stamp}>${css}</${node.tag}>`;
+				return record(sink, start, node, path, emit(sink, raw));
+			}
+			const attrs = attributes(sink, node.tag, spec, node.props, node.origins);
+			if (spec.content === "void") return record(sink, start, node, path, emit(sink, `<${node.tag}${attrs}${stamp} />`));
+			const open = emit(sink, `<${node.tag}${attrs}${stamp}>`);
+			const children = node.children.map((child) => serialize(sink, child, path, own)).join("");
+			const close = emit(sink, `</${node.tag}>`);
+			return record(sink, start, node, path, `${open}${children}${close}`);
+		}
+	}
+};
+/** Record an element's emitted range once its content is written. */
+const record = (sink, start, node, instancePath, text) => {
+	sink.positions.push({
+		start,
+		end: sink.written,
+		origins: node.origins,
+		instancePath,
+		tag: node.tag,
+		authored: node.authored
+	});
+	return text;
+};
+const serializationSink = (options) => {
+	const brandPlugin = options.brandPlugin ?? samvaBrandPlugin;
+	return {
+		diagnostics: [],
+		positions: [],
+		written: 0,
+		relativeUrls: options.relativeUrls === true,
+		instancePaths: options.instancePaths === true,
+		brandPlugin,
+		reservedAttributes: reservedBrandAttributes(brandPlugin)
+	};
+};
+/** Lower the derived tree to email HTML, reporting every unsupported construct with its origin. */
+const serializeEmailHtml = (node, options = {}) => {
+	const sink = serializationSink(options);
+	return {
+		html: serialize(sink, node, "", { next: 0 }),
+		diagnostics: sink.diagnostics,
+		positions: sink.positions
+	};
+};
+/** An authored style object as a declaration list, checked by the same rules as a serialized tree. */
+const serializeStyle = (style, origins) => {
+	const sink = serializationSink({});
+	return {
+		css: declarations(sink, style, origins),
+		diagnostics: sink.diagnostics
+	};
+};
+/**
+* Check one static attribute value against its element's spec, as serialization does. Returns
+* the text that would be emitted, or `undefined` when the attribute is dropped or invalid.
+*/
+const checkAttribute = (tag, name, value, origins) => {
+	const sink = serializationSink({});
+	const element = emailElement(tag);
+	const globals = EMAIL_GLOBAL_ATTRIBUTES;
+	const attributeSpec = () => {
+		if (/^(data|aria)-[a-z0-9-]+$/.test(name)) return { type: "string" };
+		if (Object.hasOwn(globals, name)) return globals[name];
+		if (element !== void 0 && Object.hasOwn(element.attributes, name)) return element.attributes[name];
+	};
+	const spec = attributeSpec();
+	if (spec === void 0) return {
+		text: void 0,
+		diagnostics: sink.diagnostics
+	};
+	return {
+		text: attributeValue(sink, tag, name, spec, value, origins),
+		diagnostics: sink.diagnostics
+	};
+};
+//#endregion
+export { UNSUBSCRIBE_LINK as _, kebab as a, INSTANCE_PATH_ATTRIBUTE as c, emailSelectionAncestry as d, emailSelectionIndex as f, BRAND_FOOTER_MARKER as g, previewEmail as h, escapeText as i, emailAuthoringTarget as l, emailSelections as m, declarationValue as n, serializeEmailHtml as o, emailSelectionSiblings as p, escapeAttribute as r, serializeStyle as s, checkAttribute as t, emailDefinitionInstances as u };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { i as TEMPLATE_ID_PATTERN, o as TemplateInput, r as SmlTemplate, s as defineTemplate, t as EmailChannel } from "./template-B-UDXK8a.js";
+import { a as TemplateInput, n as SmlTemplate, o as defineTemplate, r as TEMPLATE_ID_PATTERN, t as EmailChannel } from "./template-DmNcoH4Q.js";
 export { type EmailChannel, type SmlTemplate, TEMPLATE_ID_PATTERN, type TemplateInput, defineTemplate };

package/dist/{jsx-runtime-DC7xG0aA.d.ts → jsx-runtime-DL8NVF1f.d.ts}

@@ -1,5 +1,5 @@
 import { r as JsxSourceLocation } from "./source-locations-C8wCsiAy.js";
-import { r as EmailDiagnostic } from "./diagnostics-CUYlQ_6x.js";
+import { n as EmailDiagnostic } from "./diagnostics-D4vSLQrO.js";
 //#region src/email/elements.d.ts
 /** How one attribute is spelled and what values it accepts. */
 interface EmailAttributeSpec {
@@ -641,9 +641,13 @@ type EmailNode = {
    * can have its own props edited there.
    */
   readonly authored: boolean;
+  /** Findings a primitive saw while building this node; see `withEmailDiagnostics`. */
+  readonly diagnostics?: readonly EmailDiagnostic[];
 } | {
   readonly type: "Fragment";
   readonly children: readonly EmailNode[];
+  /** Findings a primitive saw while building this node; see `withEmailDiagnostics`. */
+  readonly diagnostics?: readonly EmailDiagnostic[];
 } |
 /**
  * Compatibility markup a compiler primitive emits verbatim — conditional
@@ -672,10 +676,12 @@ type EmailComponent<P = never> = (props: P) => EmailChild;
 declare const Fragment: unique symbol;
 /** Call sites enclosing the element being built, innermost first. */
 declare const currentEmailOrigins: () => readonly JsxSourceLocation[];
-/** Record a finding from inside a compiler primitive, located at the authoring call site. */
-declare const reportEmailDiagnostic: (diagnostic: Omit<EmailDiagnostic, "origins">) => void;
-/** Take and clear the findings primitives reported during a render. */
-declare const drainEmailDiagnostics: () => readonly EmailDiagnostic[];
+/** A finding a primitive records before `withEmailDiagnostics` locates it. */
+type EmailFinding = Omit<EmailDiagnostic, "origins">;
+/** Attach findings to a primitive's output, located at the authoring call site. */
+declare const withEmailDiagnostics: (node: EmailNode, findings: readonly EmailFinding[]) => EmailNode;
+/** Every finding attached to a tree, in document order. */
+declare const collectEmailDiagnostics: (node: EmailNode) => readonly EmailDiagnostic[];
 /** Normalize actual values without interpolation or recording proxies. */
 declare const normalizeChildren: (input: unknown) => EmailNode[];
 /** Compatibility markup emitted by a compiler primitive, with the text it stands for. */
@@ -695,4 +701,4 @@ declare namespace JSX {
   interface IntrinsicElements extends EmailIntrinsicElements {}
 }
 //#endregion
-export { isUrlAttribute as C, emailElement as S, EmailGlobalProps as _, JSX as a, EmailStyle as b, jsx as c, rawMarkup as d, reportEmailDiagnostic as f, EmailElementSpec as g, EmailAttributeSpec as h, Fragment as i, jsxs as l, EMAIL_GLOBAL_ATTRIBUTES as m, EmailComponent as n, currentEmailOrigins as o, EMAIL_ELEMENTS as p, EmailNode as r, drainEmailDiagnostics as s, EmailChild as t, normalizeChildren as u, EmailIntrinsicElements as v, EmailTag as x, EmailLayout as y };
+export { emailElement as C, EmailTag as S, EmailElementSpec as _, Fragment as a, EmailLayout as b, currentEmailOrigins as c, normalizeChildren as d, rawMarkup as f, EmailAttributeSpec as g, EMAIL_GLOBAL_ATTRIBUTES as h, EmailNode as i, jsx as l, EMAIL_ELEMENTS as m, EmailComponent as n, JSX as o, withEmailDiagnostics as p, EmailFinding as r, collectEmailDiagnostics as s, EmailChild as t, jsxs as u, EmailGlobalProps as v, isUrlAttribute as w, EmailStyle as x, EmailIntrinsicElements as y };

package/dist/{jsx-runtime-CBlexoeR.js → jsx-runtime-qL19u3Fy.js}

@@ -44,16 +44,23 @@ const Fragment = Symbol.for("@samva/markup/email/Fragment");
 const callSites = [];
 /** Call sites enclosing the element being built, innermost first. */
 const currentEmailOrigins = () => [...callSites].reverse();
-const reported = [];
-/** Record a finding from inside a compiler primitive, located at the authoring call site. */
-const reportEmailDiagnostic = (diagnostic) => {
-	reported.push({
-		...diagnostic,
-		origins: currentEmailOrigins()
-	});
+/** Attach findings to a primitive's output, located at the authoring call site. */
+const withEmailDiagnostics = (node, findings) => {
+	if (findings.length === 0 || node.type !== "Element" && node.type !== "Fragment") return node;
+	const origins = currentEmailOrigins();
+	return {
+		...node,
+		diagnostics: [...node.diagnostics ?? [], ...findings.map((finding) => ({
+			...finding,
+			origins
+		}))]
+	};
+};
+/** Every finding attached to a tree, in document order. */
+const collectEmailDiagnostics = (node) => {
+	if (node.type !== "Element" && node.type !== "Fragment") return [];
+	return [...node.diagnostics ?? [], ...node.children.flatMap(collectEmailDiagnostics)];
 };
-/** Take and clear the findings primitives reported during a render. */
-const drainEmailDiagnostics = () => reported.splice(0);
 /** Normalize actual values without interpolation or recording proxies. */
 const normalizeChildren = (input) => {
 	if (input === null || input === void 0 || typeof input === "boolean") return [];
@@ -93,4 +100,4 @@ const jsx = (type, props) => {
 };
 const jsxs = jsx;
 //#endregion
-export { jsx as a, rawMarkup as c, completeJsxSourceLocation as d, drainEmailDiagnostics as i, reportEmailDiagnostic as l, Fragment as n, jsxs as o, currentEmailOrigins as r, normalizeChildren as s, EmailNode as t, JSX_SOURCE_LOCATION_PROP as u };
+export { jsx as a, rawMarkup as c, completeJsxSourceLocation as d, currentEmailOrigins as i, withEmailDiagnostics as l, Fragment as n, jsxs as o, collectEmailDiagnostics as r, normalizeChildren as s, EmailNode as t, JSX_SOURCE_LOCATION_PROP as u };