@samva/markup 0.8.0 → 0.10.0

package/dist/{render-vAv_4r9v.js → ir-CLhlklKV.js}

@@ -1,10 +1,95 @@
 import { n as isObject } from "./guards-eV1qLbf2.js";
-import { EmailNode, drainEmailDiagnostics } from "./email/jsx-runtime.js";
-import { declarationValue, escapeAttribute, kebab, serializeEmailHtml } from "./email/html.js";
-import { PREHEADER_ATTRIBUTE, preheaderNode } from "./email/components.js";
-import { EmailCompileError, hasBlockingDiagnostic } from "./email/diagnostics.js";
-import { snapshotStylesheets } from "./email/stylesheets.js";
-import { deriveEmailText } from "./email/text.js";
+import { _ as kebab, h as escapeAttribute, m as declarationValue } from "./components-BZCqegS8.js";
+import { t as EmailNode } from "./jsx-runtime-CBlexoeR.js";
+//#region src/email/font-stacks.ts
+/** Generic families every email client understands as the last resort in a stack. */
+const GENERIC_FAMILIES = /* @__PURE__ */ new Set([
+	"serif",
+	"sans-serif",
+	"monospace",
+	"cursive",
+	"fantasy"
+]);
+/** One family name as written, without its quotes and with runs of spaces collapsed. */
+const unquote = (value) => {
+	const trimmed = value.trim();
+	const quote = trimmed[0];
+	return (quote === "\"" || quote === "'") && trimmed.endsWith(quote) && trimmed.length >= 2 ? trimmed.slice(1, -1) : trimmed.replace(/\s+/g, " ");
+};
+/** The families of a `font-family` value, unquoted, in stack order. */
+const fontStackFamilies = (value) => {
+	const families = [];
+	let start = 0;
+	let quote;
+	for (let index = 0; index < value.length; index++) {
+		const character = value[index];
+		if (quote !== void 0) {
+			if (character === quote) quote = void 0;
+		} else if (character === "'" || character === "\"") quote = character;
+		else if (character === ",") {
+			families.push(unquote(value.slice(start, index)));
+			start = index + 1;
+		}
+	}
+	families.push(unquote(value.slice(start)));
+	return families.filter((family) => family !== "");
+};
+const FONT_SIZE = /^(?:xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large|larger|smaller|[+-]?(?:\d+\.?\d*|\.\d+)(?:[a-z]+|%)|(?:calc|clamp|min|max|var)\(.*\))$/i;
+/** Whitespace-separated tokens at the top level, keeping parentheses and quotes whole. */
+const shorthandTokens = (value) => {
+	const tokens = [];
+	let current = "";
+	let depth = 0;
+	let quote;
+	for (const character of value.trim()) {
+		if (quote !== void 0) {
+			if (character === quote) quote = void 0;
+		} else if (character === "'" || character === "\"") quote = character;
+		else if (character === "(") depth++;
+		else if (character === ")") depth--;
+		else if (/\s/.test(character) && depth === 0) {
+			if (current !== "") tokens.push(current);
+			current = "";
+			continue;
+		}
+		current += character;
+	}
+	if (current !== "") tokens.push(current);
+	return tokens;
+};
+/**
+* The family list of a `font` shorthand: everything after the size (and its
+* optional line height), or `undefined` for a system-font keyword that names
+* no family.
+*/
+const fontShorthandFamilies = (value) => {
+	const tokens = shorthandTokens(value);
+	const size = tokens.findIndex((token) => FONT_SIZE.test(token.replace(/\/.*$/, "")));
+	if (size < 0) return void 0;
+	let next = size + 1;
+	const sizeToken = tokens[size];
+	if (sizeToken.endsWith("/")) next += 1;
+	else if (!sizeToken.includes("/") && tokens[next]?.startsWith("/")) next += tokens[next] === "/" ? 2 : 1;
+	const family = tokens.slice(next).join(" ");
+	return family === "" ? void 0 : family;
+};
+/**
+* True when a stack names a declared project family without ending in a
+* generic. `declared` holds lowercased family names. A quoted `"sans-serif"`
+* names a font called sans-serif, not the generic, so it does not count.
+*/
+const lacksGenericFallback = (value, declared) => {
+	const stack = value.replace(/\s*!important\s*$/i, "");
+	if (!fontStackFamilies(stack).some((family) => declared.has(family.toLowerCase()))) return false;
+	const last = stack.slice(stack.lastIndexOf(",") + 1).trim();
+	return !GENERIC_FAMILIES.has(last.toLowerCase());
+};
+const fontFallbackDiagnostic = (value) => ({
+	code: "email-font-fallback",
+	severity: "error",
+	message: `font-family ${JSON.stringify(value)} uses a project font without a generic fallback. Clients that drop webfonts (Gmail, classic Outlook) render this stack as written, so end it with sans-serif, serif or monospace.`
+});
+//#endregion
 //#region src/email/css-values.ts
 const MAX_RESOLVED_VALUE_LENGTH = 65536;
 const MAX_RESOLUTION_WORK = 262144;
@@ -192,95 +277,6 @@ const renderHeadCss = (rules, headAtRules, variables) => {
 	return blocks.join("");
 };
 //#endregion
-//#region src/email/font-stacks.ts
-/** Generic families every email client understands as the last resort in a stack. */
-const GENERIC_FAMILIES = /* @__PURE__ */ new Set([
-	"serif",
-	"sans-serif",
-	"monospace",
-	"cursive",
-	"fantasy"
-]);
-/** One family name as written, without its quotes and with runs of spaces collapsed. */
-const unquote = (value) => {
-	const trimmed = value.trim();
-	const quote = trimmed[0];
-	return (quote === "\"" || quote === "'") && trimmed.endsWith(quote) && trimmed.length >= 2 ? trimmed.slice(1, -1) : trimmed.replace(/\s+/g, " ");
-};
-/** The families of a `font-family` value, unquoted, in stack order. */
-const fontStackFamilies = (value) => {
-	const families = [];
-	let start = 0;
-	let quote;
-	for (let index = 0; index < value.length; index++) {
-		const character = value[index];
-		if (quote !== void 0) {
-			if (character === quote) quote = void 0;
-		} else if (character === "'" || character === "\"") quote = character;
-		else if (character === ",") {
-			families.push(unquote(value.slice(start, index)));
-			start = index + 1;
-		}
-	}
-	families.push(unquote(value.slice(start)));
-	return families.filter((family) => family !== "");
-};
-const FONT_SIZE = /^(?:xx-small|x-small|small|medium|large|x-large|xx-large|xxx-large|larger|smaller|[+-]?(?:\d+\.?\d*|\.\d+)(?:[a-z]+|%)|(?:calc|clamp|min|max|var)\(.*\))$/i;
-/** Whitespace-separated tokens at the top level, keeping parentheses and quotes whole. */
-const shorthandTokens = (value) => {
-	const tokens = [];
-	let current = "";
-	let depth = 0;
-	let quote;
-	for (const character of value.trim()) {
-		if (quote !== void 0) {
-			if (character === quote) quote = void 0;
-		} else if (character === "'" || character === "\"") quote = character;
-		else if (character === "(") depth++;
-		else if (character === ")") depth--;
-		else if (/\s/.test(character) && depth === 0) {
-			if (current !== "") tokens.push(current);
-			current = "";
-			continue;
-		}
-		current += character;
-	}
-	if (current !== "") tokens.push(current);
-	return tokens;
-};
-/**
-* The family list of a `font` shorthand: everything after the size (and its
-* optional line height), or `undefined` for a system-font keyword that names
-* no family.
-*/
-const fontShorthandFamilies = (value) => {
-	const tokens = shorthandTokens(value);
-	const size = tokens.findIndex((token) => FONT_SIZE.test(token.replace(/\/.*$/, "")));
-	if (size < 0) return void 0;
-	let next = size + 1;
-	const sizeToken = tokens[size];
-	if (sizeToken.endsWith("/")) next += 1;
-	else if (!sizeToken.includes("/") && tokens[next]?.startsWith("/")) next += tokens[next] === "/" ? 2 : 1;
-	const family = tokens.slice(next).join(" ");
-	return family === "" ? void 0 : family;
-};
-/**
-* True when a stack names a declared project family without ending in a
-* generic. `declared` holds lowercased family names. A quoted `"sans-serif"`
-* names a font called sans-serif, not the generic, so it does not count.
-*/
-const lacksGenericFallback = (value, declared) => {
-	const stack = value.replace(/\s*!important\s*$/i, "");
-	if (!fontStackFamilies(stack).some((family) => declared.has(family.toLowerCase()))) return false;
-	const last = stack.slice(stack.lastIndexOf(",") + 1).trim();
-	return !GENERIC_FAMILIES.has(last.toLowerCase());
-};
-const fontFallbackDiagnostic = (value) => ({
-	code: "email-font-fallback",
-	severity: "error",
-	message: `font-family ${JSON.stringify(value)} uses a project font without a generic fallback. Clients that drop webfonts (Gmail, classic Outlook) render this stack as written, so end it with sans-serif, serif or monospace.`
-});
-//#endregion
 //#region src/email/selectors.ts
 const classListOf = (element) => {
 	const value = element.props.class ?? element.props.className;
@@ -578,189 +574,10 @@ const applyStylesheet = (root, sheet, options = {}) => {
 	};
 };
 //#endregion
-//#region src/email/render.ts
-/** Classic Outlook lays a document out correctly only under a transitional doctype. */
-const EMAIL_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">";
-const settle = (diagnostics) => {
-	if (hasBlockingDiagnostic(diagnostics)) throw new EmailCompileError({ diagnostics });
-	return diagnostics;
-};
-/** Lower the derived tree to HTML and its plain-text alternative. */
-const compileEmail = (node, options = {}) => {
-	const serialized = serializeEmailHtml(node, options);
-	const diagnostics = settle([...drainEmailDiagnostics(), ...serialized.diagnostics]);
-	return {
-		html: serialized.html,
-		text: deriveEmailText(node),
-		diagnostics,
-		positions: serialized.positions
-	};
-};
-/** The preview text already present in the tree, from `<Email preheader>`. */
-const declaredPreheader = (node) => {
-	switch (node.type) {
-		case "Text":
-		case "Raw": return;
-		case "Fragment": return node.children.reduce((found, child) => found ?? declaredPreheader(child), void 0);
-		case "Element": {
-			const declared = node.props[PREHEADER_ATTRIBUTE];
-			if (typeof declared === "string") return declared;
-			return node.children.reduce((found, child) => found ?? declaredPreheader(child), void 0);
-		}
-	}
-};
-/** Put the hidden preview block first inside `<body>`, or first overall when there is no shell. */
-const withPreheader = (node, text) => {
-	const insert = (current) => {
-		if (current.type === "Fragment") {
-			for (const [index, child] of current.children.entries()) {
-				const replaced = insert(child);
-				if (replaced !== void 0) return EmailNode.Fragment({ children: current.children.with(index, replaced) });
-			}
-			return;
-		}
-		if (current.type !== "Element") return void 0;
-		if (current.tag === "body") return EmailNode.Element({
-			...current,
-			children: [preheaderNode(text), ...current.children]
-		});
-		for (const [index, child] of current.children.entries()) {
-			const replaced = insert(child);
-			if (replaced !== void 0) return EmailNode.Element({
-				...current,
-				children: current.children.with(index, replaced)
-			});
-		}
-	};
-	return insert(node) ?? EmailNode.Fragment({ children: [preheaderNode(text), node] });
-};
-const headStyle = (css, origins) => EmailNode.Element({
-	tag: "style",
-	props: {},
-	children: [EmailNode.Text({ value: css })],
-	origins,
-	authored: false
-});
-/**
-* Put the retained rules in a `<style>` at the end of `<head>`, and project
-* `@font-face` rules in a sibling classic Outlook cannot see. Outlook for
-* Windows registers a face it cannot load and then renders the family in Times
-* New Roman, ignoring the stack; hidden, the family is merely missing and the
-* stack's fallback applies.
-*/
-const withHeadCss = (node, css, fontFaceCss) => {
-	const insert = (current) => {
-		if (current.type === "Fragment") {
-			for (const [index, child] of current.children.entries()) {
-				const replaced = insert(child);
-				if (replaced !== void 0) return EmailNode.Fragment({ children: current.children.with(index, replaced) });
-			}
-			return;
-		}
-		if (current.type !== "Element") return void 0;
-		if (current.tag === "head") return EmailNode.Element({
-			...current,
-			children: [
-				...current.children,
-				...css === "" ? [] : [headStyle(css, current.origins)],
-				...fontFaceCss === "" ? [] : [
-					EmailNode.Raw({
-						html: "<!--[if !mso]><!-->",
-						text: "",
-						origins: []
-					}),
-					headStyle(fontFaceCss, current.origins),
-					EmailNode.Raw({
-						html: "<!--<![endif]-->",
-						text: "",
-						origins: []
-					})
-				]
-			]
-		});
-		for (const [index, child] of current.children.entries()) {
-			const replaced = insert(child);
-			if (replaced !== void 0) return EmailNode.Element({
-				...current,
-				children: current.children.with(index, replaced)
-			});
-		}
-	};
-	return insert(node);
-};
-/** Render one validated input through the template's only content function. Host isolation is required for untrusted source. */
-const renderEmail = (template, data, options = {}) => renderEmailWith(snapshotStylesheets(), template, data, options);
-/**
-* A render bound to the sheets registered so far. A compiled project's wrapper
-* calls this once its own stylesheet imports have run, so a later project
-* loaded into the same process cannot restyle an entry that is rendered again.
-*/
-const bindStylesheets = (stylesheet = snapshotStylesheets()) => (template, data, options = {}) => renderEmailWith(stylesheet, template, data, options);
-const renderEmailWith = (stylesheet, template, data, options) => {
-	if (!template.schema.validate(data)) throw new TypeError(`Invalid template input: ${JSON.stringify(template.schema.validate.errors)}`);
-	return renderEmailContent(stylesheet, () => template.render(data), options);
-};
-/**
-* Render authored content against a stylesheet: inline what a client honors,
-* keep the rest for `<head>`, and lower to HTML and text. `renderEmail` runs a
-* validated template through it; a host that composes content without a
-* template definition calls it directly.
-*/
-const renderEmailContent = (stylesheet, render, options = {}) => {
-	drainEmailDiagnostics();
-	const content = render();
-	const invalid = [];
-	const fail = (code, message) => invalid.push({
-		code,
-		severity: "error",
-		message,
-		origins: []
-	});
-	if (typeof content.subject !== "string" || /[\r\n\u0000]/.test(content.subject)) fail("invalid-subject", "Invalid email subject: it must be one line of text.");
-	if (content.preheader !== void 0 && typeof content.preheader !== "string") fail("invalid-preheader", "Invalid email preheader: it must be a string.");
-	if (content.text !== void 0 && typeof content.text !== "string") fail("invalid-text", "Invalid plain text: it must be a string.");
-	const declared = declaredPreheader(content.body);
-	if (content.preheader !== void 0 && declared !== void 0) fail("duplicate-preheader", "Preheader is set on both the template content and <Email preheader>; keep one.");
-	settle(invalid);
-	const base = content.preheader === void 0 ? content.body : withPreheader(content.body, content.preheader);
-	const styled = stylesheet === void 0 ? {
-		tree: base,
-		headCss: "",
-		fontFaceCss: "",
-		diagnostics: []
-	} : applyStylesheet(base, stylesheet);
-	const style = [...styled.diagnostics];
-	let tree = styled.tree;
-	if (styled.headCss !== "" || styled.fontFaceCss !== "") {
-		const placed = withHeadCss(tree, styled.headCss, styled.fontFaceCss);
-		if (placed === void 0) style.push({
-			code: "missing-head",
-			severity: "error",
-			message: "Styles that cannot be inlined — media queries, dark-scheme rules and pseudo-selectors — need a <head> to live in. Wrap the message in <Email>, or write those declarations as inline styles.",
-			origins: []
-		});
-		else tree = placed;
-	}
-	settle(style);
-	const compiled = compileEmail(tree, options);
-	const prefix = compiled.html.startsWith("<html") ? EMAIL_DOCTYPE : "";
-	const html = `${prefix}${compiled.html}`;
-	const positions = prefix === "" ? compiled.positions : compiled.positions.map((position) => ({
-		...position,
-		start: position.start + prefix.length,
-		end: position.end + prefix.length
-	}));
-	return {
-		subject: content.subject,
-		preheader: content.preheader ?? declared,
-		html,
-		text: content.text ?? compiled.text,
-		tree,
-		diagnostics: [...style, ...compiled.diagnostics],
-		positions
-	};
-};
+//#region src/ir.ts
+/** The IR version this package writes. A publication pins the version it was built with. */
+const SML_IR_VERSION = 1;
 //#endregion
-export { renderEmailContent as a, matchesSelector as c, finalizeValue as d, foldCalc as f, renderEmail as i, unquote as l, resolveVariables as m, bindStylesheets as n, applyStylesheet as o, renderHeadCss as p, compileEmail as r, classListOf as s, EMAIL_DOCTYPE as t, downlevelMediaQuery as u };
+export { downlevelMediaQuery as a, renderHeadCss as c, matchesSelector as i, resolveVariables as l, applyStylesheet as n, finalizeValue as o, classListOf as r, foldCalc as s, SML_IR_VERSION as t, unquote as u };
 
-//# sourceMappingURL=render-vAv_4r9v.js.map
+//# sourceMappingURL=ir-CLhlklKV.js.map

package/dist/jsx-runtime-CBlexoeR.js

@@ -0,0 +1,98 @@
+import { t as hasProperty } from "./guards-eV1qLbf2.js";
+//#region src/source-locations.ts
+/** The JSX prop that carries a {@link JsxSource} to the email JSX runtime. */
+const JSX_SOURCE_LOCATION_PROP = "__samva_source_location";
+/** Normalize the optional payload a JSX transform attaches. */
+const completeJsxSourceLocation = (source) => {
+	if (source?.fileName === void 0 || source.lineNumber === void 0 || source.columnNumber === void 0) return;
+	return Object.freeze({
+		fileName: source.fileName,
+		lineNumber: source.lineNumber,
+		columnNumber: source.columnNumber
+	});
+};
+//#endregion
+//#region src/email/jsx-runtime.ts
+/** Constructors for the authoring tree. The tree is data; nothing here validates it. */
+const EmailNode = {
+	Text: (fields) => ({
+		type: "Text",
+		...fields
+	}),
+	Element: (fields) => ({
+		type: "Element",
+		...fields
+	}),
+	Fragment: (fields) => ({
+		type: "Fragment",
+		...fields
+	}),
+	Raw: (fields) => ({
+		type: "Raw",
+		...fields
+	})
+};
+const EMAIL_NODE_TYPES = /* @__PURE__ */ new Set([
+	"Text",
+	"Element",
+	"Fragment",
+	"Raw"
+]);
+/** True for a node this runtime built; anything else is not a child it can place. */
+const isEmailNode = (input) => hasProperty(input, "type") && typeof input.type === "string" && EMAIL_NODE_TYPES.has(input.type);
+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()
+	});
+};
+/** 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 [];
+	if (typeof input === "string") return [EmailNode.Text({ value: input })];
+	if (typeof input === "number" && Number.isFinite(input)) return [EmailNode.Text({ value: String(input) })];
+	if (Array.isArray(input)) return input.flatMap(normalizeChildren);
+	if (isEmailNode(input)) return [input];
+	throw new TypeError("Email children must be synchronous text, finite numbers, elements, or arrays");
+};
+/** Compatibility markup emitted by a compiler primitive, with the text it stands for. */
+const rawMarkup = (html, text = "") => EmailNode.Raw({
+	html,
+	text,
+	origins: currentEmailOrigins()
+});
+/** Automatic JSX factory for ordinary HTML and synchronous imported components. */
+const jsx = (type, props) => {
+	const { children, [JSX_SOURCE_LOCATION_PROP]: source, ...attributes } = props ?? {};
+	const origin = completeJsxSourceLocation(source);
+	if (type === Fragment) return EmailNode.Fragment({ children: normalizeChildren(children) });
+	if (typeof type === "string") return EmailNode.Element({
+		tag: type,
+		props: attributes,
+		children: normalizeChildren(children),
+		origins: origin === void 0 ? currentEmailOrigins() : [origin, ...currentEmailOrigins()],
+		authored: origin !== void 0
+	});
+	if (origin !== void 0) callSites.push(origin);
+	try {
+		return EmailNode.Fragment({ children: normalizeChildren(type({
+			...attributes,
+			children
+		})) });
+	} finally {
+		if (origin !== void 0) callSites.pop();
+	}
+};
+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 };
+
+//# sourceMappingURL=jsx-runtime-CBlexoeR.js.map

package/dist/{elements-BzjjnoCS.d.ts → jsx-runtime-ylIOnaSf.d.ts}

@@ -1,77 +1,5 @@
-import { i as JsxSourceLocation } from "./source-locations-DrCM82Ym.js";
-import { r as EmailDiagnostic } from "./diagnostics-BMYtBCQk.js";
-//#region src/email/jsx-runtime.d.ts
-/** Derived authoring tree; source stays canonical. Origins run from inner element to component call sites. */
-type EmailNode = {
-  readonly type: "Text";
-  readonly value: string;
-} | {
-  readonly type: "Element";
-  readonly tag: string;
-  readonly props: Readonly<Record<string, unknown>>;
-  readonly children: readonly EmailNode[];
-  readonly origins: readonly JsxSourceLocation[];
-  /**
-   * True when this element is written at `origins[0]`; false when a compiler
-   * primitive generated it and `origins[0]` is the call site that asked for
-   * it. Both point at the same authoring target, but only an authored element
-   * can have its own props edited there.
-   */
-  readonly authored: boolean;
-} | {
-  readonly type: "Fragment";
-  readonly children: readonly EmailNode[];
-} |
-/**
- * Compatibility markup a compiler primitive emits verbatim — conditional
- * comments and VML. Only the primitives in `./components` construct it;
- * nothing an author passes as a string reaches this node.
- */
-{
-  readonly type: "Raw";
-  readonly html: string;
-  readonly text: string;
-  readonly origins: readonly JsxSourceLocation[];
-};
-type EmailNodeOf<Type extends EmailNode["type"]> = Extract<EmailNode, {
-  readonly type: Type;
-}>;
-type EmailNodeFields<Type extends EmailNode["type"]> = Omit<EmailNodeOf<Type>, "type">;
-/** Constructors for the authoring tree. The tree is data; nothing here validates it. */
-declare const EmailNode: {
-  readonly Text: (fields: EmailNodeFields<"Text">) => EmailNodeOf<"Text">;
-  readonly Element: (fields: EmailNodeFields<"Element">) => EmailNodeOf<"Element">;
-  readonly Fragment: (fields: EmailNodeFields<"Fragment">) => EmailNodeOf<"Fragment">;
-  readonly Raw: (fields: EmailNodeFields<"Raw">) => EmailNodeOf<"Raw">;
-};
-type EmailChild = EmailNode | string | number | boolean | null | undefined | readonly EmailChild[];
-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[];
-/** 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. */
-declare const rawMarkup: (html: string, text?: string) => EmailNode;
-/** Automatic JSX factory for ordinary HTML and synchronous imported components. */
-declare const jsx: (type: string | EmailComponent<Record<string, unknown>> | typeof Fragment, props: Record<string, unknown> | null) => EmailNode;
-declare const jsxs: typeof jsx;
-declare namespace JSX {
-  type Element = EmailNode;
-  type ElementType = string | EmailComponent | typeof Fragment;
-  interface ElementChildrenAttribute {
-    readonly children: object;
-  }
-  interface IntrinsicAttributes {
-    readonly key?: string | number | undefined;
-  }
-  interface IntrinsicElements extends EmailIntrinsicElements {}
-}
-//#endregion
+import { r as JsxSourceLocation } from "./source-locations-C8wCsiAy.js";
+import { r as EmailDiagnostic } from "./diagnostics-B-Gym34R.js";
 //#region src/email/elements.d.ts
 /** How one attribute is spelled and what values it accepts. */
 interface EmailAttributeSpec {
@@ -695,5 +623,77 @@ type ChildrenProp<Content extends EmailElementSpec["content"]> = Content extends
 /** Props each supported tag accepts, derived from `EMAIL_ELEMENTS`. */
 type EmailIntrinsicElements = { readonly [Tag in EmailTag]: EmailGlobalProps & AttributeProps<typeof EMAIL_GLOBAL_ATTRIBUTES> & AttributeProps<(typeof EMAIL_ELEMENTS)[Tag]["attributes"]> & ChildrenProp<(typeof EMAIL_ELEMENTS)[Tag]["content"]>; };
 //#endregion
-export { reportEmailDiagnostic as C, rawMarkup as S, currentEmailOrigins as _, EmailGlobalProps as a, jsxs as b, EmailStyle as c, isUrlAttribute as d, EmailChild as f, JSX as g, Fragment as h, EmailElementSpec as i, EmailTag as l, EmailNode as m, EMAIL_GLOBAL_ATTRIBUTES as n, EmailIntrinsicElements as o, EmailComponent as p, EmailAttributeSpec as r, EmailLayout as s, EMAIL_ELEMENTS as t, emailElement as u, drainEmailDiagnostics as v, normalizeChildren as x, jsx as y };
-//# sourceMappingURL=elements-BzjjnoCS.d.ts.map
+//#region src/email/jsx-runtime.d.ts
+/** Derived authoring tree; source stays canonical. Origins run from inner element to component call sites. */
+type EmailNode = {
+  readonly type: "Text";
+  readonly value: string;
+} | {
+  readonly type: "Element";
+  readonly tag: string;
+  readonly props: Readonly<Record<string, unknown>>;
+  readonly children: readonly EmailNode[];
+  readonly origins: readonly JsxSourceLocation[];
+  /**
+   * True when this element is written at `origins[0]`; false when a compiler
+   * primitive generated it and `origins[0]` is the call site that asked for
+   * it. Both point at the same authoring target, but only an authored element
+   * can have its own props edited there.
+   */
+  readonly authored: boolean;
+} | {
+  readonly type: "Fragment";
+  readonly children: readonly EmailNode[];
+} |
+/**
+ * Compatibility markup a compiler primitive emits verbatim — conditional
+ * comments and VML. Only the primitives in `./components` construct it;
+ * nothing an author passes as a string reaches this node.
+ */
+{
+  readonly type: "Raw";
+  readonly html: string;
+  readonly text: string;
+  readonly origins: readonly JsxSourceLocation[];
+};
+type EmailNodeOf<Type extends EmailNode["type"]> = Extract<EmailNode, {
+  readonly type: Type;
+}>;
+type EmailNodeFields<Type extends EmailNode["type"]> = Omit<EmailNodeOf<Type>, "type">;
+/** Constructors for the authoring tree. The tree is data; nothing here validates it. */
+declare const EmailNode: {
+  readonly Text: (fields: EmailNodeFields<"Text">) => EmailNodeOf<"Text">;
+  readonly Element: (fields: EmailNodeFields<"Element">) => EmailNodeOf<"Element">;
+  readonly Fragment: (fields: EmailNodeFields<"Fragment">) => EmailNodeOf<"Fragment">;
+  readonly Raw: (fields: EmailNodeFields<"Raw">) => EmailNodeOf<"Raw">;
+};
+type EmailChild = EmailNode | string | number | boolean | null | undefined | readonly EmailChild[];
+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[];
+/** 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. */
+declare const rawMarkup: (html: string, text?: string) => EmailNode;
+/** Automatic JSX factory for ordinary HTML and synchronous imported components. */
+declare const jsx: (type: string | EmailComponent<Record<string, unknown>> | typeof Fragment, props: Record<string, unknown> | null) => EmailNode;
+declare const jsxs: typeof jsx;
+declare namespace JSX {
+  type Element = EmailNode;
+  type ElementType = string | EmailComponent | typeof Fragment;
+  interface ElementChildrenAttribute {
+    readonly children: object;
+  }
+  interface IntrinsicAttributes {
+    readonly key?: string | number | undefined;
+  }
+  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 };
+//# sourceMappingURL=jsx-runtime-ylIOnaSf.d.ts.map