@samva/markup 0.8.0 → 0.10.0

package/dist/profile-pWGtWZXF.js

@@ -0,0 +1,3803 @@
+import { n as isObject } from "./guards-eV1qLbf2.js";
+import { n as inputSchema, r as jsonSchema } from "./input-schema-zjkgrXn2.js";
+import { n as TEMPLATE_NAME_PATTERN, t as TEMPLATE_ID_PATTERN } from "./template-zLUjcwfF.js";
+import { n as RESERVED_FOOTER_ATTRIBUTES, t as BRAND_FOOTER_MARKER } from "./unsubscribe-link-CoesnQDU.js";
+import { M as EMAIL_ELEMENTS, P as emailElement, a as Email, d as equalColumnWidth, i as Divider, l as Section, n as Column, o as Image, p as checkAttribute, r as Columns, s as Link, t as Button, u as Spacer, y as serializeStyle } from "./components-BZCqegS8.js";
+import { FORMATTER_NAMES } from "./fmt.js";
+import { i as drainEmailDiagnostics, t as EmailNode } from "./jsx-runtime-CBlexoeR.js";
+import { n as applyStylesheet } from "./ir-CLhlklKV.js";
+import { i as lineColumn, t as buildLineMap } from "./diagnostic-model-DJtqbETd.js";
+import { d as isAssetPath, i as brandComponents } from "./brand-C0MKTwmX.js";
+import { parse } from "css-tree";
+import { parse as parse$1 } from "@babel/parser";
+//#region src/email/theme-imports.ts
+/** The CSS and TSX specifier a template uses to reach its organization's brand. */
+const BRAND_SPECIFIER = "samva:brand";
+const BRAND_IMPORT = /^samva:brand(?:\/([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?))?$/;
+/** The brand a `samva:brand` specifier names: `undefined` slug means the default brand. */
+const parseBrandSpecifier = (specifier) => {
+	const match = BRAND_IMPORT.exec(specifier);
+	return match === null ? void 0 : { slug: match[1] };
+};
+/** The directory part of a project path, with no trailing slash (`""` at the root). */
+const projectDirectory = (path) => path.includes("/") ? path.slice(0, path.lastIndexOf("/")) : "";
+/** A relative or root-absolute stylesheet reference, resolved from a project directory. */
+const resolveFromDirectory = (directory, reference) => {
+	const segments = reference.startsWith("/") || directory === "" ? [] : directory.split("/");
+	for (const segment of reference.split("/")) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") {
+			if (segments.length === 0) return void 0;
+			segments.pop();
+		} else segments.push(segment);
+	}
+	return segments.length === 0 ? void 0 : segments.join("/");
+};
+const importTarget = (node) => {
+	if (node.type !== "Atrule" || node.prelude === null || node.prelude.type !== "AtrulePrelude") return { extra: true };
+	const parts = [...node.prelude.children].filter((part) => part.type !== "WhiteSpace");
+	const first = parts[0];
+	const target = first?.type === "String" ? first.value : first?.type === "Url" ? first.value : void 0;
+	return target === void 0 ? { extra: true } : {
+		target,
+		extra: parts.length > 1
+	};
+};
+/**
+* Walk the theme's `@import` graph. Project `.css` files resolve from the
+* importing file's directory; `samva:brand` and `samva:brand/<slug>` are
+* recorded for the brand the build supplies. Anything else is an error.
+*/
+const resolveThemeImports = (themePath, themeCss, files) => {
+	const stylesheets = /* @__PURE__ */ new Map([[themePath, themeCss]]);
+	const brandSpecifiers = /* @__PURE__ */ new Set();
+	const diagnostics = [];
+	const visit = (path, source, chain) => {
+		const lineMap = buildLineMap(source);
+		const ast = parse(source, {
+			positions: true,
+			parseValue: false,
+			parseRulePrelude: false
+		});
+		if (ast.type !== "StyleSheet") return;
+		for (const node of ast.children) {
+			if (node.type !== "Atrule" || node.name.toLowerCase() !== "import") continue;
+			const position = lineColumn(lineMap, node.loc?.start.offset ?? 0);
+			const origins = [{
+				fileName: path,
+				lineNumber: position.line,
+				columnNumber: position.column
+			}];
+			const refuse = (message) => diagnostics.push({
+				code: "css-import-unresolved",
+				severity: "error",
+				message,
+				origins
+			});
+			const { target, extra } = importTarget(node);
+			if (target === void 0) {
+				refuse(`${path}: @import needs a quoted stylesheet path or "samva:brand".`);
+				continue;
+			}
+			if (extra) {
+				refuse(`${path}: @import ${JSON.stringify(target)} takes no layer, supports or media conditions; the import order is the layering.`);
+				continue;
+			}
+			if (parseBrandSpecifier(target) !== void 0) {
+				brandSpecifiers.add(target);
+				continue;
+			}
+			if (!/^\.{0,2}\//.test(target) || !/\.css$/i.test(target.replace(/[?#].*$/, ""))) {
+				refuse(`${path}: @import ${JSON.stringify(target)} is not a project stylesheet or "samva:brand". The compiler supplies Tailwind itself; import project .css files by relative path.`);
+				continue;
+			}
+			const resolved = resolveFromDirectory(projectDirectory(path), target.replace(/[?#].*$/, ""));
+			const content = resolved === void 0 ? void 0 : files[resolved];
+			if (resolved === void 0 || typeof content !== "string") {
+				refuse(`${path}: @import ${JSON.stringify(target)} names no stylesheet in the project.`);
+				continue;
+			}
+			if (chain.includes(resolved)) {
+				refuse(`${path}: @import ${JSON.stringify(target)} imports itself through ${chain.join(" → ")}.`);
+				continue;
+			}
+			if (stylesheets.has(resolved)) continue;
+			stylesheets.set(resolved, content);
+			visit(resolved, content, [...chain, resolved]);
+		}
+	};
+	visit(themePath, themeCss, [themePath]);
+	return {
+		stylesheets,
+		brandSpecifiers: [...brandSpecifiers].sort(),
+		diagnostics
+	};
+};
+//#endregion
+//#region src/sml/diagnostics.ts
+/** Collects the findings of one compile. Every finding carries a code, a location and a fix. */
+var Findings = class {
+	items = [];
+	/** The `file:line:col` of a node. */
+	locate(source, node) {
+		const at = source.position(node.start);
+		return {
+			fileName: source.path,
+			lineNumber: at.line,
+			columnNumber: at.column
+		};
+	}
+	add(source, node, code, message, fix, severity = "error") {
+		this.items.push({
+			code,
+			severity,
+			message,
+			...fix === void 0 ? {} : { fix },
+			origins: [this.locate(source, node)]
+		});
+	}
+	get blocking() {
+		return this.items.some((item) => item.severity === "error");
+	}
+};
+//#endregion
+//#region src/email/stylesheets.ts
+/** Sheets flattened into one, with rule order preserved across sheets. */
+const mergeStylesheets = (sheets) => {
+	let base = 0;
+	const rules = sheets.flatMap((sheet) => {
+		const offset = base;
+		base += sheet.rules.length + 1;
+		return sheet.rules.map((rule) => ({
+			...rule,
+			order: offset + rule.order
+		}));
+	});
+	const variables = {};
+	const headAtRules = [];
+	const fontFaces = /* @__PURE__ */ new Map();
+	const diagnostics = sheets.flatMap((sheet) => sheet.diagnostics);
+	for (const sheet of sheets) {
+		Object.assign(variables, sheet.variables);
+		headAtRules.push(...sheet.headAtRules);
+		for (const face of sheet.fontFaces) fontFaces.set(face.css, face);
+	}
+	return {
+		rules,
+		headAtRules,
+		fontFaces: [...fontFaces.values()],
+		variables,
+		diagnostics
+	};
+};
+//#endregion
+//#region src/sml/ast.ts
+const isNode = (value) => isObject(value) && typeof value.type === "string" && typeof value.start === "number" && typeof value.end === "number";
+/** The child node under `key`, or `undefined`. */
+const child = (node, key) => {
+	const value = node[key];
+	return isNode(value) ? value : void 0;
+};
+/** The child nodes under `key`; array holes and non-nodes are dropped. */
+const children = (node, key) => {
+	const value = node[key];
+	return Array.isArray(value) ? value.filter(isNode) : [];
+};
+const text = (node, key) => {
+	const value = node[key];
+	return typeof value === "string" ? value : void 0;
+};
+/** The name a property key spells: an identifier or a string literal. */
+const keyName = (key) => {
+	if (key === void 0) return void 0;
+	if (key.type === "Identifier") return text(key, "name");
+	if (key.type === "StringLiteral") return text(key, "value");
+};
+/** Strip wrappers that carry no runtime meaning: parentheses and TypeScript assertions. */
+const unwrap = (node) => {
+	let current = node;
+	for (;;) {
+		if (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSNonNullExpression" || current.type === "TSTypeAssertion" || current.type === "TypeCastExpression") {
+			const inner = child(current, "expression");
+			if (inner === void 0) return current;
+			current = inner;
+			continue;
+		}
+		return current;
+	}
+};
+var SourceSyntaxError = class extends Error {
+	path;
+	line;
+	column;
+	constructor(path, message, line, column) {
+		super(message);
+		this.name = "SourceSyntaxError";
+		this.path = path;
+		this.line = line;
+		this.column = column;
+	}
+};
+/** Parse a TSX/TS project file. Throws `SourceSyntaxError` on a syntax error. */
+const parseSource = (path, source) => {
+	const lines = buildLineMap(source);
+	const position = (offset) => lineColumn(lines, offset);
+	let program;
+	try {
+		program = parse$1(source, {
+			plugins: ["typescript", "jsx"],
+			sourceType: "module"
+		}).program;
+	} catch (error) {
+		const at = isObject(error) && isObject(error.loc) ? error.loc : void 0;
+		const line = typeof at?.line === "number" ? at.line : 1;
+		const column = typeof at?.column === "number" ? at.column + 1 : 1;
+		throw new SourceSyntaxError(path, error instanceof Error ? error.message.replace(/\s*\(\d+:\d+\)\s*$/, "") : "", line, column);
+	}
+	if (!isNode(program)) throw new SourceSyntaxError(path, "The file did not parse to a program.", 1, 1);
+	return {
+		path,
+		source,
+		program,
+		position
+	};
+};
+//#endregion
+//#region src/sml/bindings.ts
+const joinPath = (base, segment) => base === "" ? segment : `${base}.${segment}`;
+/** The IR value a binding reads, or `undefined` for bindings that are not values. */
+const bindingValue = (binding) => {
+	switch (binding.k) {
+		case "path": return binding.path === "" ? void 0 : { bind: binding.path };
+		case "value": return binding.value;
+		default: return;
+	}
+};
+const isStaticScalar = (value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+/** True when a node in child position is a value (rendered as text) rather than structure. */
+const isValueNode = (node) => {
+	if (typeof node !== "object" || node === null) return true;
+	if ("el" in node || "each" in node || "raw" in node || "preheader" in node) return false;
+	if ("if" in node && Array.isArray(node.then)) return false;
+	return true;
+};
+//#endregion
+//#region src/channel-specs.ts
+const SMS_CATEGORIES = [
+	"transactional",
+	"promotional",
+	"service_implicit"
+];
+const WHATSAPP_CATEGORIES = [
+	"marketing",
+	"utility",
+	"authentication"
+];
+const WHATSAPP_HEADER_TYPES = [
+	"text",
+	"image",
+	"video",
+	"document"
+];
+/** The attributes `<Sms>` accepts. */
+const SMS_ATTRIBUTES = ["category"];
+/** The attributes `<WhatsApp>` accepts. */
+const WHATSAPP_ATTRIBUTES = [
+	"name",
+	"language",
+	"category"
+];
+//#endregion
+//#region src/whatsapp-template.ts
+const isConcat = (value) => typeof value === "object" && value !== null && "concat" in value;
+/**
+* Number the non-literal values of a header, body or footer in order of first appearance. A value
+* that appears twice (by JSON identity) shares its placeholder. Text pieces stay literal.
+*/
+const whatsappTemplate = (part) => {
+	const params = [];
+	const keys = [];
+	let template = "";
+	const visit = (node) => {
+		if (node === null || typeof node === "boolean") return;
+		if (typeof node === "string") {
+			template += node;
+			return;
+		}
+		if (typeof node === "number") {
+			template += String(node);
+			return;
+		}
+		if (typeof node === "object" && isConcat(node)) {
+			for (const inner of node.concat) visit(inner);
+			return;
+		}
+		if (typeof node === "object" && ("el" in node || "each" in node || "raw" in node)) throw new TypeError("A WhatsApp text part holds text and values only.");
+		if (typeof node === "object" && "if" in node && Array.isArray(node.then)) throw new TypeError("A WhatsApp text part cannot branch.");
+		const value = node;
+		const key = JSON.stringify(value);
+		let index = keys.indexOf(key);
+		if (index < 0) {
+			index = keys.length;
+			keys.push(key);
+			params.push(value);
+		}
+		template += `{{${index + 1}}}`;
+	};
+	for (const node of part) visit(node);
+	return {
+		template,
+		params
+	};
+};
+//#endregion
+//#region src/sml/suggest.ts
+/** Levenshtein distance, capped so a long non-match is cheap. */
+const distance = (a, b, cap) => {
+	if (Math.abs(a.length - b.length) > cap) return cap + 1;
+	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+	for (let i = 1; i <= a.length; i++) {
+		const row = [i];
+		for (let j = 1; j <= b.length; j++) row[j] = Math.min(row[j - 1] + 1, previous[j] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+		previous = row;
+	}
+	return previous[b.length];
+};
+/** The candidate closest to `name`, when one is close enough to be a typo. */
+const didYouMean = (name, candidates) => {
+	const lower = name.toLowerCase();
+	const exact = candidates.find((candidate) => candidate.toLowerCase() === lower);
+	if (exact !== void 0 && exact !== name) return exact;
+	const cap = Math.max(1, Math.min(3, Math.floor(name.length / 3)));
+	let best;
+	let bestDistance = cap + 1;
+	for (const candidate of candidates) {
+		const d = distance(lower, candidate.toLowerCase(), cap);
+		if (d < bestDistance) {
+			best = candidate;
+			bestDistance = d;
+		}
+	}
+	return best;
+};
+//#endregion
+//#region src/sml/check.ts
+const isSchema = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** Follow local `$ref`s to the schema they name. */
+const resolve = (root, schema, depth = 0) => {
+	const ref = schema.$ref;
+	if (typeof ref !== "string" || depth > 16) return schema;
+	if (ref === "#") return root;
+	let current = root;
+	for (const segment of ref.replace(/^#\//, "").split("/")) {
+		if (!isSchema(current)) return schema;
+		current = current[segment.replace(/~1/g, "/").replace(/~0/g, "~")];
+	}
+	return isSchema(current) ? resolve(root, current, depth + 1) : schema;
+};
+const branches = (root, schema) => {
+	const resolved = resolve(root, schema);
+	return [resolved, ...[
+		resolved.anyOf,
+		resolved.oneOf,
+		resolved.allOf
+	].flatMap((list) => Array.isArray(list) ? list.filter(isSchema).flatMap((item) => branches(root, item)) : [])];
+};
+const typeOf = (root, schema) => {
+	if (schema === void 0) return "unknown";
+	const types = /* @__PURE__ */ new Set();
+	for (const branch of branches(root, schema)) {
+		const declared = branch.type;
+		if (typeof declared === "string") types.add(declared);
+		else if (Array.isArray(declared)) {
+			for (const item of declared) if (typeof item === "string") types.add(item);
+		}
+		if (branch.const !== void 0) types.add(typeof branch.const);
+		if (Array.isArray(branch.enum)) for (const item of branch.enum) types.add(typeof item);
+	}
+	types.delete("null");
+	if (types.size !== 1) return "unknown";
+	const [only] = types;
+	switch (only) {
+		case "string": return "string";
+		case "number":
+		case "integer": return "number";
+		case "boolean": return "boolean";
+		case "array": return "array";
+		case "object": return "object";
+		default: return "unknown";
+	}
+};
+const step = (root, schema, segment) => {
+	const names = [];
+	let open = true;
+	let found;
+	for (const branch of branches(root, schema)) {
+		if (isSchema(branch.properties)) {
+			open = false;
+			names.push(...Object.keys(branch.properties));
+			if (Object.hasOwn(branch.properties, segment)) {
+				const property = branch.properties[segment];
+				const required = Array.isArray(branch.required) && branch.required.includes(segment);
+				found = {
+					schema: isSchema(property) ? property : void 0,
+					required: found?.required === true || required
+				};
+			}
+		}
+		if (branch.type === "object" && !isSchema(branch.properties) && branch.additionalProperties === false) open = false;
+		if (Array.isArray(branch.items) || isSchema(branch.items)) {
+			if (/^\d+$/.test(segment)) {
+				open = false;
+				return {
+					found: true,
+					schema: isSchema(branch.items) ? branch.items : void 0,
+					required: true,
+					names,
+					open: false
+				};
+			}
+		}
+		if (isSchema(branch.additionalProperties) && found === void 0) {
+			found = {
+				schema: branch.additionalProperties,
+				required: false
+			};
+			open = false;
+		}
+	}
+	if (found !== void 0) return {
+		found: true,
+		schema: found.schema,
+		required: found.required,
+		names,
+		open: false
+	};
+	return {
+		found: false,
+		schema: void 0,
+		required: false,
+		names,
+		open
+	};
+};
+const withGuards = (scope, extra) => extra.size === 0 ? scope : {
+	...scope,
+	guards: /* @__PURE__ */ new Set([...scope.guards, ...extra])
+};
+const prefixes = (path) => {
+	const segments = path.split(".");
+	return segments.map((_, index) => segments.slice(0, index + 1).join("."));
+};
+const bindPath = (value) => typeof value === "object" && value !== null && "bind" in value ? value.bind : void 0;
+const guardsOf = (predicate, positive) => {
+	const own = (path) => path === void 0 ? /* @__PURE__ */ new Set() : new Set(prefixes(path));
+	if ("present" in predicate) return positive ? own(predicate.present) : /* @__PURE__ */ new Set();
+	if ("truthy" in predicate) {
+		const value = predicate.truthy;
+		const path = bindPath(value) ?? (typeof value === "object" && value !== null && "length" in value ? bindPath(value.length) : void 0);
+		return positive ? own(path) : /* @__PURE__ */ new Set();
+	}
+	if ("not" in predicate) return guardsOf(predicate.not, !positive);
+	if ("and" in predicate || "or" in predicate) {
+		const list = "and" in predicate ? predicate.and : predicate.or;
+		const union = "and" in predicate ? positive : !positive;
+		const sets = list.map((item) => guardsOf(item, positive));
+		if (union) return new Set(sets.flatMap((set) => [...set]));
+		const [first, ...rest] = sets;
+		return new Set([...first ?? []].filter((path) => rest.every((set) => set.has(path))));
+	}
+	const [left, right] = predicate.args;
+	const path = bindPath(left) ?? bindPath(right);
+	const other = bindPath(left) === void 0 ? left : right;
+	if (path === void 0) return /* @__PURE__ */ new Set();
+	const isNull = other === null;
+	const literal = other === null || typeof other !== "object" || "concat" in other || "format" in other || "op" in other || "length" in other || "count" in other;
+	if (predicate.cmp === "eq") return !literal || positive === isNull ? /* @__PURE__ */ new Set() : own(path);
+	if (predicate.cmp === "ne") return !literal || positive !== isNull ? /* @__PURE__ */ new Set() : own(path);
+	return positive ? own(path) : /* @__PURE__ */ new Set();
+};
+/** Check every binding in a lowered email or channel body against the input schema. */
+const checkBindings = (schema, roots, values) => {
+	const findings = [];
+	const reported = /* @__PURE__ */ new Set();
+	const report = (finding) => {
+		const key = `${finding.code}\0${finding.message}\0${finding.src?.join(",") ?? ""}`;
+		if (reported.has(key)) return;
+		reported.add(key);
+		findings.push(finding);
+	};
+	const display = (path) => path.startsWith("$") ? path.slice(1) : `input.${path}`;
+	/** Resolve a bound path, reporting unknown and unguarded fields. Returns its schema when known. */
+	const walk = (path, scope, src) => {
+		const segments = path.split(".");
+		const head = segments[0];
+		let current;
+		if (head.startsWith("$")) {
+			if (!scope.variables.has(head.slice(1))) return void 0;
+			current = scope.variables.get(head.slice(1));
+		} else {
+			const first = step(schema, schema, head);
+			if (!first.found) return unknownField(head, first, "", src, path);
+			if (!first.required && !scope.guards.has(head)) unguarded(head, src);
+			current = first.schema;
+		}
+		for (let index = 1; index < segments.length; index++) {
+			if (current === void 0) return void 0;
+			const segment = segments[index];
+			const next = step(schema, current, segment);
+			const prefix = segments.slice(0, index).join(".");
+			if (!next.found) {
+				if (next.open) return void 0;
+				return unknownField(segment, next, prefix, src, path);
+			}
+			const here = segments.slice(0, index + 1).join(".");
+			if (!next.required && !scope.guards.has(here)) unguarded(here, src);
+			current = next.schema;
+		}
+		return current;
+	};
+	const unknownField = (segment, stepResult, prefix, src, full) => {
+		if (stepResult.open) return void 0;
+		const near = didYouMean(segment, stepResult.names);
+		const owner = prefix === "" ? "input" : display(prefix);
+		report({
+			code: "unknown-field",
+			message: `\`${prefix === "" ? "input" : display(prefix)}.${segment}\` is not in the schema${stepResult.names.length === 0 ? "" : ` (${owner} has ${stepResult.names.map((name) => `\`${name}\``).join(", ")})`}.`,
+			...near === void 0 ? { fix: `Add \`${segment}\` to the schema, or bind a field it declares.` } : { fix: `Did you mean \`${prefix === "" ? "input" : display(prefix)}.${near}\`?` },
+			src
+		});
+	};
+	const unguarded = (path, src) => {
+		report({
+			code: "unguarded-optional",
+			message: `\`${display(path)}\` is optional and is read outside a guard, so a send without it would render a blank.`,
+			fix: `Guard it: {${display(path)} && …}, or make the field required in the schema.`,
+			src
+		});
+	};
+	const valueType = (value, scope, src) => {
+		if (typeof value === "string") return "string";
+		if (typeof value === "number") return "number";
+		if (typeof value === "boolean") return "boolean";
+		if (value === null) return "unknown";
+		if ("bind" in value) return typeOf(schema, walk(value.bind, scope, src));
+		if ("lit" in value) return "unknown";
+		if ("concat" in value) {
+			for (const part of value.concat) valueType(part, scope, src);
+			return "string";
+		}
+		if ("format" in value) {
+			checkFormat(value.format, value.args, scope, src);
+			return "string";
+		}
+		if ("if" in value) {
+			visitPredicate(value.if, scope, src);
+			const then = valueType(value.then, withGuards(scope, guardsOf(value.if, true)), src);
+			valueType(value.else, withGuards(scope, guardsOf(value.if, false)), src);
+			return then;
+		}
+		if ("op" in value) {
+			for (const operand of value.args) requireType(operand, "number", scope, src, "arithmetic");
+			return "number";
+		}
+		if ("length" in value) {
+			valueType(value.length, scope, src);
+			return "number";
+		}
+		if ("count" in value) {
+			const path = bindPath(value.count);
+			let item;
+			if (path === void 0) valueType(value.count, scope, src);
+			else {
+				const list = walk(path, scope, src);
+				if (list !== void 0) {
+					for (const branch of branches(schema, list)) if (isSchema(branch.items)) item = resolve(schema, branch.items);
+				}
+			}
+			const variables = new Map(scope.variables).set(value.as.replace(/^\$/, ""), item);
+			visitPredicate(value.where, {
+				...scope,
+				variables
+			}, src);
+			return "number";
+		}
+		return "unknown";
+	};
+	const requireType = (value, expected, scope, src, where) => {
+		const actual = valueType(value, scope, src);
+		if (actual === "unknown" || actual === expected) return;
+		const path = bindPath(value);
+		report({
+			code: "invalid-binding-type",
+			message: `${path === void 0 ? "This value" : `\`${display(path)}\``} is ${actual === "array" ? "an array" : `a ${actual}`}, and ${where} needs ${expected === "array" ? "an array" : `a ${expected}`}.`,
+			fix: expected === "number" ? "Bind a number field, or send the number in the payload." : `Bind a ${expected} field.`,
+			src
+		});
+	};
+	const checkFormat = (name, args, scope, src) => {
+		const expected = {
+			money: [
+				"number",
+				"string",
+				"string"
+			],
+			number: [
+				"number",
+				void 0,
+				"string"
+			],
+			date: [
+				"string",
+				"string",
+				"string"
+			],
+			time: [
+				"string",
+				"string",
+				"string"
+			],
+			plural: [
+				"number",
+				void 0,
+				"string"
+			],
+			list: ["array", "string"]
+		};
+		for (const [index, argument] of args.entries()) {
+			const type = expected[name]?.[index];
+			if (type === void 0) valueType(argument, scope, src);
+			else requireType(argument, type, scope, src, `\`fmt.${name}\``);
+		}
+	};
+	const visitPredicate = (predicate, scope, src) => {
+		if ("present" in predicate) {
+			walkGuard(predicate.present, scope, src);
+			return;
+		}
+		if ("truthy" in predicate) {
+			const value = predicate.truthy;
+			const path = bindPath(value);
+			if (path !== void 0) walkGuard(path, scope, src);
+			else valueTypeGuard(value, scope, src);
+			return;
+		}
+		if ("not" in predicate) {
+			visitPredicate(predicate.not, scope, src);
+			return;
+		}
+		if ("and" in predicate) {
+			let running = scope;
+			for (const part of predicate.and) {
+				visitPredicate(part, running, src);
+				running = withGuards(running, guardsOf(part, true));
+			}
+			return;
+		}
+		if ("or" in predicate) {
+			let running = scope;
+			for (const part of predicate.or) {
+				visitPredicate(part, running, src);
+				running = withGuards(running, guardsOf(part, false));
+			}
+			return;
+		}
+		const numeric = predicate.cmp === "lt" || predicate.cmp === "gt" || predicate.cmp === "le" || predicate.cmp === "ge";
+		const strings = numeric && predicate.args.every((operand) => valueType(operand, scope, src) === "string");
+		for (const operand of predicate.args) {
+			const path = bindPath(operand);
+			if (strings) continue;
+			if (path !== void 0 && !numeric) walkGuard(path, scope, src);
+			else if (numeric) requireType(operand, "number", scope, src, "a comparison");
+			else valueTypeGuard(operand, scope, src);
+		}
+	};
+	/** Reading a field to test it is what a guard is; only the field itself must exist. */
+	const walkGuard = (path, scope, src) => {
+		walk(path, {
+			...scope,
+			guards: /* @__PURE__ */ new Set([...scope.guards, ...prefixes(path)])
+		}, src);
+	};
+	const valueTypeGuard = (value, scope, src) => {
+		if (typeof value === "object" && value !== null && "length" in value) {
+			const path = bindPath(value.length);
+			if (path !== void 0) {
+				walkGuard(path, scope, src);
+				return;
+			}
+		}
+		valueType(value, scope, src);
+	};
+	const scalar = (value, scope, src, where) => {
+		const type = valueType(value, scope, src);
+		if (type === "array" || type === "object") {
+			const path = bindPath(value);
+			report({
+				code: "invalid-binding-type",
+				message: `${path === void 0 ? "This value" : `\`${display(path)}\``} is ${type === "array" ? "an array" : "an object"}, and ${where} takes a string or a number.`,
+				fix: type === "array" ? "Render the items with .map, or bind one of their fields." : "Bind one of its fields.",
+				src
+			});
+		}
+	};
+	const visitStyle = (style, scope, src) => {
+		if (style === void 0 || typeof style === "string") return;
+		if (Array.isArray(style)) {
+			for (const [, value] of style) scalar(value, scope, src, "a style value");
+			return;
+		}
+		const conditional = style;
+		visitPredicate(conditional.if, scope, src);
+		visitStyle(conditional.then, withGuards(scope, guardsOf(conditional.if, true)), src);
+		visitStyle(conditional.else, withGuards(scope, guardsOf(conditional.if, false)), src);
+	};
+	const visit = (nodes, scope, parent) => {
+		for (const node of nodes) {
+			if (isValueNode(node)) {
+				scalar(node, scope, parent, "text");
+				continue;
+			}
+			if ("el" in node) {
+				for (const value of Object.values(node.attrs ?? {})) scalar(value, scope, node.src, "an attribute");
+				visitStyle(node.style, scope, node.src);
+				visit(node.children ?? [], scope, node.src);
+			} else if ("if" in node) {
+				visitPredicate(node.if, scope, node.src);
+				visit(node.then, withGuards(scope, guardsOf(node.if, true)), node.src ?? parent);
+				visit(node.else ?? [], withGuards(scope, guardsOf(node.if, false)), node.src ?? parent);
+			} else if ("each" in node) {
+				const path = bindPath(node.each);
+				let listSchema;
+				if (path !== void 0) {
+					listSchema = walk(path, scope, node.src);
+					const type = typeOf(schema, listSchema);
+					if (type !== "array" && type !== "unknown") report({
+						code: "invalid-binding-type",
+						message: `\`${display(path)}\` is ${type === "object" ? "an object" : `a ${type}`}, and a loop needs an array.`,
+						fix: "Loop over an array field.",
+						src: node.src
+					});
+				} else valueType(node.each, scope, node.src);
+				let item;
+				if (listSchema !== void 0) {
+					for (const branch of branches(schema, listSchema)) if (isSchema(branch.items)) item = resolve(schema, branch.items);
+				}
+				const itemName = node.as.replace(/^\$/, "");
+				if (node.where !== void 0) visitPredicate(node.where, {
+					...scope,
+					variables: new Map(scope.variables).set(itemName, item)
+				}, node.src ?? parent);
+				const variables = new Map(scope.variables);
+				variables.set(itemName, node.chunk === void 0 || item === void 0 ? item : {
+					type: "array",
+					items: item
+				});
+				if (node.index !== void 0) variables.set(node.index.replace(/^\$/, ""), { type: "integer" });
+				const kept = node.where === void 0 ? scope : withGuards(scope, guardsOf(node.where, true));
+				visit(node.children, {
+					...kept,
+					variables
+				}, node.src ?? parent);
+			} else if ("raw" in node) {
+				for (const part of node.raw) if (typeof part !== "string") scalar("attr" in part ? part.attr : part.text, scope, node.src, "markup");
+			}
+		}
+	};
+	const base = {
+		variables: /* @__PURE__ */ new Map(),
+		guards: /* @__PURE__ */ new Set()
+	};
+	visit(roots, base);
+	for (const value of values) scalar(value, base, void 0, "the subject or preheader");
+	return findings;
+};
+/** The element content rules the serializer enforces, checked before any send. */
+const checkStructure = (roots, report) => {
+	const flat = (nodes) => nodes.flatMap((node) => {
+		if (isValueNode(node)) return [node];
+		if ("if" in node) return [...flat(node.then), ...flat(node.else ?? [])];
+		if ("each" in node) return flat(node.children);
+		return [node];
+	});
+	const visit = (nodes) => {
+		for (const node of nodes) {
+			if (isValueNode(node)) continue;
+			if ("el" in node) checkElement(node);
+			else if ("if" in node) {
+				visit(node.then);
+				visit(node.else ?? []);
+			} else if ("each" in node) visit(node.children);
+		}
+	};
+	const checkElement = (element) => {
+		const spec = emailElement(element.el);
+		const kids = flat(element.children ?? []);
+		if (spec === void 0) return;
+		if (spec.content === "void" && kids.length > 0) report({
+			code: "void-element-children",
+			message: `<${element.el}> cannot have children.`,
+			src: element.src
+		});
+		else if (spec.content === "text" || spec.content === "raw") {
+			for (const kid of kids) if (!isValueNode(kid) && !("raw" in kid)) report({
+				code: "invalid-content",
+				message: `<${element.el}> accepts text only.`,
+				src: element.src
+			});
+		} else if (spec.childElements !== void 0) {
+			for (const kid of kids) if (isValueNode(kid)) {
+				if (typeof kid === "string" && kid.trim() === "") continue;
+				report({
+					code: "invalid-content",
+					message: `<${element.el}> cannot contain text directly; put it inside <${spec.childElements[0]}>.`,
+					src: element.src
+				});
+			} else if ("el" in kid && !spec.childElements.includes(kid.el)) report({
+				code: "invalid-content",
+				message: `<${element.el}> accepts only ${spec.childElements.map((name) => `<${name}>`).join(", ")}; found <${kid.el}>.`,
+				src: kid.src ?? element.src
+			});
+		}
+		visit(element.children ?? []);
+	};
+	visit(roots);
+};
+//#endregion
+//#region src/sml/tokens.ts
+const OPEN = "";
+const CLOSE = "";
+const TOKEN = /(\d+)/g;
+/** Values and node lists a component call reads at render time, addressable from inside a string. */
+var Tokens = class {
+	entries = [];
+	value(value) {
+		if (typeof value === "string") return value;
+		this.entries.push({ value });
+		return `${OPEN}${this.entries.length - 1}${CLOSE}`;
+	}
+	nodes(nodes) {
+		this.entries.push({ nodes });
+		return `${OPEN}${this.entries.length - 1}${CLOSE}`;
+	}
+	/** A string with tokens in it, as static text and the entries it names. */
+	parse(input) {
+		const parts = [];
+		let last = 0;
+		for (const match of input.matchAll(TOKEN)) {
+			if (match.index > last) parts.push(input.slice(last, match.index));
+			const entry = this.entries[Number(match[1])];
+			if (entry !== void 0) parts.push(entry);
+			last = match.index + match[0].length;
+		}
+		if (last < input.length) parts.push(input.slice(last));
+		return parts;
+	}
+	/** The value a string with tokens stands for: itself, one entry's value, or their concatenation. */
+	toValue(input) {
+		const parts = this.parse(input);
+		if (parts.length === 0) return "";
+		const values = [];
+		for (const part of parts) if (typeof part === "string") values.push(part);
+		else if ("value" in part) values.push(part.value);
+		else return void 0;
+		return values.length === 1 ? values[0] : { concat: values };
+	}
+};
+/** A prop value for a primitive: a literal stays itself and anything else becomes a token. */
+const propFor = (tokens, value) => isStaticScalar(value) ? value : tokens.value(value);
+const SOURCE = (source) => source === void 0 ? {} : { src: source };
+/** Split compatibility markup into parts, deciding by position whether a token is in a tag. */
+const rawParts = (tokens, html) => {
+	const parts = [];
+	let inTag = false;
+	let quote;
+	let buffer = "";
+	const flush = () => {
+		if (buffer !== "") parts.push(buffer);
+		buffer = "";
+	};
+	for (let index = 0; index < html.length; index++) {
+		const character = html[index];
+		if (character === OPEN) {
+			const end = html.indexOf(CLOSE, index);
+			const entry = tokens.parse(html.slice(index, end + 1))[0];
+			if (end > index && entry !== void 0 && typeof entry !== "string" && "value" in entry) {
+				flush();
+				parts.push(inTag ? { attr: entry.value } : { text: entry.value });
+				index = end;
+				continue;
+			}
+		}
+		if (!inTag && character === "<") inTag = true;
+		else if (inTag && quote === void 0 && (character === "\"" || character === "'")) quote = character;
+		else if (inTag && quote === character) quote = void 0;
+		else if (inTag && quote === void 0 && character === ">") inTag = false;
+		buffer += character;
+	}
+	flush();
+	return parts;
+};
+const styleList = (tokens, style) => {
+	if (!isObject(style)) return void 0;
+	const entries = [];
+	for (const [property, value] of Object.entries(style)) {
+		if (value === void 0 || value === null) continue;
+		if (typeof value === "number") entries.push([property, value]);
+		else if (typeof value === "string") {
+			const resolved = tokens.toValue(value);
+			if (resolved !== void 0) entries.push([property, resolved]);
+		}
+	}
+	return entries;
+};
+/** Turn the tree a primitive returned back into IR, restoring each token to what it stood for. */
+const emailNodeToIr = (node, tokens, source) => {
+	if (node === null) return [];
+	switch (node.type) {
+		case "Text": {
+			const output = [];
+			for (const part of tokens.parse(node.value)) if (typeof part === "string") output.push(part);
+			else if ("value" in part) output.push(part.value);
+			else output.push(...part.nodes);
+			return output;
+		}
+		case "Fragment": return node.children.flatMap((childNode) => emailNodeToIr(childNode, tokens, source));
+		case "Raw": return [{
+			raw: rawParts(tokens, node.html),
+			...node.text === "" ? {} : { text: node.text },
+			...SOURCE(source)
+		}];
+		case "Element": {
+			const attrs = {};
+			let style;
+			for (const [key, value] of Object.entries(node.props)) {
+				if (key === "key" || value === void 0 || value === null || value === false) continue;
+				if (key === "style") {
+					style = styleList(tokens, value);
+					continue;
+				}
+				const name = key === "className" ? "class" : key;
+				if (typeof value === "string") attrs[name] = tokens.toValue(value) ?? value;
+				else if (typeof value === "number" || value === true) attrs[name] = value;
+			}
+			const reserved = node.props[BRAND_FOOTER_MARKER] === true;
+			return [{
+				el: node.tag,
+				...Object.keys(attrs).length === 0 ? {} : { attrs },
+				...style === void 0 || Array.isArray(style) && style.length === 0 ? {} : { style },
+				...node.children.length === 0 ? {} : { children: node.children.flatMap((childNode) => emailNodeToIr(childNode, tokens, source)) },
+				...reserved ? { reserved: true } : {},
+				...SOURCE(source)
+			}];
+		}
+	}
+};
+//#endregion
+//#region src/sml/components.ts
+const NUMERIC = {
+	Button: [
+		"height",
+		"paddingX",
+		"borderRadius",
+		"borderWidth",
+		"fontSize",
+		"width"
+	],
+	Spacer: ["height"],
+	Divider: ["thickness"],
+	BrandLogo: ["width"]
+};
+const COMPONENTS = {
+	Email,
+	Section,
+	Columns,
+	Column,
+	Button,
+	Spacer,
+	Divider,
+	Image,
+	Link
+};
+const bindingToProp = (call, tokens, name, binding) => {
+	switch (binding.k) {
+		case "object": {
+			const output = {};
+			for (const [key, field] of binding.fields) output[key] = bindingToProp(call, tokens, key, field);
+			return output;
+		}
+		case "nodes":
+			call.lowerer.error(call.ctx, call.node, "dynamic-expression", `<${call.name} ${name}> takes text, not markup.`);
+			return;
+		default: {
+			const value = bindingValue(binding);
+			if (value === void 0) {
+				call.lowerer.error(call.ctx, call.node, "dynamic-expression", `<${call.name} ${name}> cannot be the input as a whole.`, "Bind one field.");
+				return;
+			}
+			return propFor(tokens, value);
+		}
+	}
+};
+/** Content between the tags, the way a primitive would have received it. */
+const childrenProp = (tokens, nodes) => {
+	const only = nodes.length === 1 ? nodes[0] : void 0;
+	if (only !== void 0 && isValueNode(only) && only !== null && typeof only !== "boolean") return typeof only === "string" ? only : tokens.value(only);
+	return nodes.map((node) => isValueNode(node) ? typeof node === "string" ? node : tokens.value(node) : tokens.nodes([node]));
+};
+/** The width each cell of a `<Columns each>` row takes when it states none. */
+const equalWidth = (per, list) => {
+	if (per !== void 0) return equalColumnWidth(per);
+	const count = { length: list };
+	return { concat: [{
+		op: "/",
+		args: [{
+			op: "-",
+			args: [100, {
+				op: "%",
+				args: [100, count]
+			}]
+		}, count]
+	}, "%"] };
+};
+/**
+* `<Columns each={list} per={n}>{(item, i) => <Column … />}</Columns>`: one row per chunk of `n`
+* items (all in one row without `per`), each cell from the callback. Returns the nodes to place
+* inside the Columns table, and a wrapper that repeats that table per chunk.
+*/
+const columnsEach = (call, bindings) => {
+	const { lowerer, ctx, node } = call;
+	const listValue = bindings.get("each");
+	const list = listValue === void 0 ? void 0 : bindingValue(listValue);
+	if (list === void 0) {
+		lowerer.error(ctx, node, "invalid-columns-each", "<Columns each> takes a list from the input.", "Write each={input.items}.");
+		return;
+	}
+	const perBinding = bindings.get("per");
+	const perValue = perBinding?.k === "value" ? perBinding.value : void 0;
+	if (perBinding !== void 0 && !(typeof perValue === "number" && Number.isInteger(perValue) && perValue >= 1)) {
+		lowerer.error(ctx, node, "invalid-columns-per", "<Columns per> is a whole number of cells, one or more.", "Write per={2}.");
+		return;
+	}
+	const per = typeof perValue === "number" ? perValue : void 0;
+	const contents = children(node, "children").filter((item) => !(item.type === "JSXText" && (text(item, "value") ?? "").trim() === ""));
+	const container = contents.length === 1 ? contents[0] : void 0;
+	const expression = container?.type === "JSXExpressionContainer" ? child(container, "expression") : void 0;
+	const fn = expression === void 0 ? void 0 : unwrap(expression);
+	if (fn === void 0 || !/Function/.test(fn.type)) {
+		lowerer.error(ctx, node, "invalid-columns-each", "<Columns each> takes a function of one item as its only child.", "Write {(item) => <Column>…</Column>}.");
+		return;
+	}
+	const row = per === void 0 ? void 0 : lowerer.freshName(ctx, "row");
+	const cellCtx = {
+		...ctx,
+		loops: row === void 0 ? ctx.loops : [...ctx.loops, row],
+		columnWidth: equalWidth(per, list)
+	};
+	const cells = lowerer.eachOver(cellCtx, node, row === void 0 ? list : { bind: `$${row}` }, fn);
+	if (cells === void 0) return void 0;
+	return {
+		cells,
+		wrap: (table) => {
+			if (row === void 0 || per === void 0) return table;
+			return [{
+				each: list,
+				as: row,
+				chunk: per,
+				children: table,
+				src: lowerer.src(ctx.module, node)
+			}];
+		}
+	};
+};
+/** Run a compiler primitive at compile time and lower what it returns. */
+const runBuiltinComponent = (call) => {
+	const { lowerer, ctx, node, binding } = call;
+	const specifier = binding.kind === "markup" ? binding.specifier : "samva:brand";
+	if (binding.kind === "markup" && (specifier === "@samva/markup/sms" || specifier === "@samva/markup/whatsapp")) {
+		const lowered = call.channel?.(call);
+		if (lowered !== void 0) return lowered;
+		lowerer.error(ctx, node, "wrong-channel", `<${call.name}> belongs in the ${specifier.split("/").pop()} body of a template.`, "Write it in the `sms` or `whatsapp` function of defineTemplate.");
+		return [];
+	}
+	const exported = binding.imported;
+	const isEmail = binding.kind === "markup" && specifier === "@samva/markup/email";
+	const isBrand = binding.kind === "brand";
+	if (!(isEmail || isBrand)) {
+		lowerer.error(ctx, node, "unknown-component", `<${call.name}> is not a component the profile can read.`, "Import components from @samva/markup/email, samva:brand, or the project.");
+		return [];
+	}
+	let fn;
+	if (isEmail) fn = COMPONENTS[exported];
+	else {
+		if (call.brand === void 0) {
+			lowerer.error(ctx, node, "brand-unavailable", `<${call.name}> comes from samva:brand, and this build has no brand to resolve it.`, "Compile with a brand, or remove the brand components.");
+			return [];
+		}
+		const brand = brandComponents(call.brand);
+		fn = exported === "BrandLogo" ? brand.BrandLogo : exported === "BrandFooter" ? brand.BrandFooter : void 0;
+	}
+	if (fn === void 0 || !Object.hasOwn(COMPONENTS, exported) && isEmail) {
+		lowerer.error(ctx, node, "unknown-component", `\`${exported}\` is not an email component.`, `Use one of ${Object.keys(COMPONENTS).join(", ")}, BrandLogo or BrandFooter.`);
+		return [];
+	}
+	const declared = lowerer.attributeBindings(ctx, call.attributes);
+	if (declared === void 0) return [];
+	let bindings = declared;
+	let wrap = (table) => table;
+	let kids;
+	const childCtx = {
+		...ctx,
+		columnWidth: void 0
+	};
+	if (exported === "Columns" && declared.has("each")) {
+		const chunked = columnsEach(call, declared);
+		if (chunked === void 0) return [];
+		bindings = new Map([...declared].filter(([name]) => name !== "each" && name !== "per"));
+		kids = [chunked.cells];
+		wrap = chunked.wrap;
+	} else kids = lowerer.jsxChildren(childCtx, node);
+	const tokens = new Tokens();
+	const props = {};
+	for (const [name, bound] of bindings) props[name] = bindingToProp(call, tokens, name, bound);
+	for (const name of NUMERIC[exported] ?? []) {
+		const value = props[name];
+		if (typeof value === "string" && !/^-?\d+(\.\d+)?$/.test(value) && value !== void 0) {
+			lowerer.error(ctx, node, "dynamic-numeric-prop", `<${call.name} ${name}> sizes the layout at compile time, so it must be a number literal.`, `Write ${name}={44}.`);
+			return [];
+		}
+	}
+	if (exported === "Column" && props.width === void 0 && ctx.columnWidth !== void 0) props.width = propFor(tokens, ctx.columnWidth);
+	if (kids.length > 0) props.children = childrenProp(tokens, kids);
+	if (exported === "Button" && typeof props.children === "string" && props.children !== "" && props.width === void 0 && props.height !== void 0 && tokens.toValue(props.children) !== props.children) {
+		lowerer.error(ctx, node, "button-dynamic-label", "Classic Outlook draws the button from a fixed box, and a label read at render time cannot size it.", "Give the button a width: <Button width={200} …>.");
+		return [];
+	}
+	drainEmailDiagnostics();
+	const output = fn(props);
+	const location = lowerer.findings.locate(ctx.module.parsed, node);
+	for (const diagnostic of drainEmailDiagnostics()) lowerer.findings.items.push({
+		...diagnostic,
+		origins: [location]
+	});
+	if (output !== null && (!isObject(output) || typeof output.type !== "string")) return [];
+	return wrap([...emailNodeToIr(output, tokens, lowerer.src(ctx.module, node))]);
+};
+//#endregion
+//#region src/sml/values.ts
+const fail = (module, node, reason) => ({
+	ok: false,
+	node,
+	module,
+	reason
+});
+const keyOf = (property) => {
+	if (property.type === "ObjectProperty" && property.computed !== true) {
+		const key = child(property, "key");
+		if (key === void 0) return void 0;
+		if (key.type === "Identifier") return text(key, "name");
+		if (key.type === "StringLiteral") return text(key, "value");
+		if (key.type === "NumericLiteral") return String(key.value);
+	}
+};
+/** Resolve a top-level constant name in a module, following project imports and re-exports. */
+const resolveName = (context, module, name, seen = /* @__PURE__ */ new Set()) => {
+	const key = `${module.path}\0${name}`;
+	if (seen.has(key)) return void 0;
+	seen.add(key);
+	const declared = module.declarations.get(name);
+	if (declared !== void 0) return {
+		module,
+		value: declared.value
+	};
+	const imported = module.imports.get(name);
+	if (imported === void 0) return void 0;
+	if (imported.kind === "asset") return { asset: imported.path };
+	if (imported.kind !== "project") return void 0;
+	const target = context.project.modules.get(imported.path);
+	if (target === void 0) return void 0;
+	if (imported.imported === "default") {
+		const value = target.defaultExport;
+		return value === void 0 ? void 0 : {
+			module: target,
+			value
+		};
+	}
+	const local = target.exports.get(imported.imported);
+	return local === void 0 ? void 0 : resolveName(context, target, local, seen);
+};
+/** Read a node as plain JSON-like data. */
+const readStatic = (context, module, node, seen = /* @__PURE__ */ new Set()) => {
+	const current = unwrap(node);
+	switch (current.type) {
+		case "StringLiteral": return {
+			ok: true,
+			value: current.value
+		};
+		case "NumericLiteral": return {
+			ok: true,
+			value: current.value
+		};
+		case "BooleanLiteral": return {
+			ok: true,
+			value: current.value
+		};
+		case "NullLiteral": return {
+			ok: true,
+			value: null
+		};
+		case "TemplateLiteral": {
+			if (children(current, "expressions").length > 0) return fail(module, current, "a template string with a `${}` part is computed at run time");
+			const value = children(current, "quasis")[0]?.value;
+			const cooked = value?.cooked ?? value?.raw;
+			return {
+				ok: true,
+				value: typeof cooked === "string" ? cooked : ""
+			};
+		}
+		case "UnaryExpression": {
+			const argument = child(current, "argument");
+			if (text(current, "operator") === "-" && argument !== void 0 && argument.type === "NumericLiteral" && typeof argument.value === "number") return {
+				ok: true,
+				value: -argument.value
+			};
+			return fail(module, current, "only a negative number literal is data");
+		}
+		case "Identifier": {
+			const name = text(current, "name") ?? "";
+			if (name === "undefined") return {
+				ok: true,
+				value: void 0
+			};
+			const resolved = resolveName(context, module, name);
+			if (resolved === void 0) return fail(module, current, `\`${name}\` is not a constant in the project`);
+			if ("asset" in resolved) {
+				const url = context.assetUrl(resolved.asset);
+				return url === void 0 ? fail(module, current, `\`${name}\` names an asset the build did not address`) : {
+					ok: true,
+					value: url
+				};
+			}
+			const key = `${resolved.module.path}\0${name}\0${resolved.value.start}`;
+			if (seen.has(key)) return fail(module, current, `\`${name}\` refers to itself`);
+			seen.add(key);
+			const read = readStatic(context, resolved.module, resolved.value, seen);
+			seen.delete(key);
+			return read;
+		}
+		case "ArrayExpression": {
+			const output = [];
+			for (const element of Array.isArray(current.elements) ? current.elements : []) {
+				if (element === null || typeof element !== "object") return fail(module, current, "an array hole");
+				const item = element;
+				if (item.type === "SpreadElement") {
+					const argument = child(item, "argument");
+					if (argument === void 0) return fail(module, item, "an empty spread");
+					const spread = readStatic(context, module, argument, seen);
+					if (!spread.ok) return spread;
+					if (!Array.isArray(spread.value)) return fail(module, item, "a spread of a non-array");
+					output.push(...spread.value);
+					continue;
+				}
+				const value = readStatic(context, module, item, seen);
+				if (!value.ok) return value;
+				output.push(value.value);
+			}
+			return {
+				ok: true,
+				value: output
+			};
+		}
+		case "ObjectExpression": {
+			const output = {};
+			for (const property of children(current, "properties")) {
+				if (property.type === "SpreadElement") {
+					const argument = child(property, "argument");
+					if (argument === void 0) return fail(module, property, "an empty spread");
+					const spread = readStatic(context, module, argument, seen);
+					if (!spread.ok) return spread;
+					if (typeof spread.value !== "object" || spread.value === null || Array.isArray(spread.value)) return fail(module, property, "a spread of a non-object");
+					Object.assign(output, spread.value);
+					continue;
+				}
+				const key = keyOf(property);
+				if (key === void 0) return fail(module, property, "a computed or method property");
+				const valueNode = child(property, "value");
+				if (valueNode === void 0) return fail(module, property, "a property without a value");
+				const value = readStatic(context, module, valueNode, seen);
+				if (!value.ok) return value;
+				if (value.value !== void 0) output[key] = value.value;
+			}
+			return {
+				ok: true,
+				value: output
+			};
+		}
+		case "CallExpression": {
+			const callee = child(current, "callee");
+			const first = children(current, "arguments")[0];
+			if (callee?.type === "Identifier" && text(callee, "name") === "jsonSchema" && first !== void 0) return readStatic(context, module, first, seen);
+			return fail(module, current, "a call is computed at run time");
+		}
+		default: return fail(module, current, `${current.type} is not data`);
+	}
+};
+//#endregion
+//#region src/sml/lower.ts
+const MAX_DEPTH = 40;
+const ARITHMETIC = {
+	"+": "+",
+	"-": "-",
+	"*": "*",
+	"/": "/",
+	"%": "%"
+};
+const COMPARISON = {
+	"===": "eq",
+	"!==": "ne",
+	"<": "lt",
+	">": "gt",
+	"<=": "le",
+	">=": "ge"
+};
+const FORMATTER_ARITY = {
+	money: [2, 3],
+	number: [1, 3],
+	date: [1, 3],
+	time: [1, 3],
+	plural: [2, 3],
+	list: [1, 2]
+};
+const RUN_TIME_METHODS = /* @__PURE__ */ new Set([
+	"reduce",
+	"filter",
+	"slice",
+	"join",
+	"sort",
+	"concat",
+	"flatMap",
+	"find",
+	"some",
+	"every",
+	"toFixed",
+	"toLocaleString",
+	"toLocaleDateString",
+	"toUpperCase",
+	"toLowerCase",
+	"trim",
+	"split",
+	"replace",
+	"padStart",
+	"includes",
+	"indexOf",
+	"at"
+]);
+/** React's rule for JSX text: trim lines, drop blank ones, join the rest with a space. */
+const cleanJsxText = (raw) => {
+	const lines = raw.split(/\r\n|\n|\r/);
+	let lastNonEmpty = 0;
+	for (const [index, line] of lines.entries()) if (/[^ \t]/.test(line)) lastNonEmpty = index;
+	let output = "";
+	for (const [index, line] of lines.entries()) {
+		let trimmed = line.replace(/\t/g, " ");
+		if (index !== 0) trimmed = trimmed.replace(/^ +/, "");
+		if (index !== lines.length - 1) trimmed = trimmed.replace(/ +$/, "");
+		if (trimmed !== "") {
+			if (index !== lastNonEmpty) trimmed += " ";
+			output += trimmed;
+		}
+	}
+	return output;
+};
+const jsxName$1 = (name) => {
+	if (name.type === "JSXIdentifier") return text(name, "name") ?? "";
+	if (name.type === "JSXNamespacedName") return `${text(child(name, "namespace") ?? name, "name") ?? ""}:${text(child(name, "name") ?? name, "name") ?? ""}`;
+	if (name.type === "JSXMemberExpression") return `${jsxName$1(child(name, "object") ?? name)}.${text(child(name, "property") ?? name, "name") ?? ""}`;
+	return "";
+};
+const isStatic = (value) => value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+const statementKind = (type) => {
+	if (type === "VariableDeclaration") return "`const`";
+	if (type === "IfStatement") return "`if`";
+	if (/For|While/.test(type)) return "a loop";
+	return "a statement";
+};
+var Lowerer = class {
+	options;
+	sources = [];
+	uniqueId = 0;
+	constructor(options) {
+		this.options = options;
+	}
+	get findings() {
+		return this.options.findings;
+	}
+	/** A stable source reference for a node: `[line, column]` in the entry, else with a file index. */
+	src(module, node) {
+		const at = module.parsed.position(node.start);
+		if (module.path === this.options.project.entry.path) return [at.line, at.column];
+		let index = this.sources.indexOf(module.path);
+		if (index < 0) {
+			index = this.sources.length;
+			this.sources.push(module.path);
+		}
+		return [
+			at.line,
+			at.column,
+			index + 1
+		];
+	}
+	error(ctx, node, code, message, fix) {
+		this.findings.add(ctx.module.parsed, node, code, message, fix);
+	}
+	dynamic(ctx, node, what, fix) {
+		this.error(ctx, node, "dynamic-expression", `${what} runs code, and templates render without running code.`, fix);
+	}
+	/** The expression a function returns, or a diagnostic when its body is more than one. */
+	functionExpression(ctx, fn) {
+		const body = child(fn, "body");
+		if (body === void 0) return void 0;
+		if (body.type !== "BlockStatement") return body;
+		const statements = children(body, "body");
+		const first = statements[0];
+		if (statements.length === 1 && first?.type === "ReturnStatement") {
+			const argument = child(first, "argument");
+			if (argument !== void 0) return argument;
+		}
+		const offender = statements.find((statement) => statement.type !== "ReturnStatement") ?? body;
+		const kind = statementKind(offender.type);
+		this.error(ctx, offender, "statement-in-body", `A body is one expression, and ${kind} is a statement.`, "Write the value where it is used: `cond && <X />` or `cond ? <A /> : <B />` for branches, `.map` for lists. Compute anything else in the caller and send it in the payload.");
+	}
+	/** Bind a parameter pattern to a binding, adding the names it introduces to `env`. */
+	bindPattern(ctx, pattern, binding, env, allowDefaults) {
+		switch (pattern.type) {
+			case "Identifier": {
+				const name = text(pattern, "name") ?? "";
+				env.set(name, binding ?? {
+					k: "value",
+					value: null
+				});
+				return;
+			}
+			case "AssignmentPattern": {
+				const left = child(pattern, "left");
+				const right = child(pattern, "right");
+				if (left === void 0 || right === void 0) return;
+				if (!allowDefaults) {
+					this.error(ctx, pattern, "unsupported-pattern", "A default value on the input is never inserted, so it is not part of the profile.", "Remove the default; declare the field as required or guard it where it is read.");
+					return;
+				}
+				let resolved = binding;
+				if (resolved === void 0) {
+					const defaultValue = readStatic(this.options.staticContext, ctx.module, right);
+					if (!defaultValue.ok) {
+						this.error(ctx, right, "dynamic-expression", "A default prop value must be a literal.", "Use a string, number or boolean literal.");
+						return;
+					}
+					resolved = {
+						k: "value",
+						value: defaultValue.value
+					};
+				}
+				this.bindPattern(ctx, left, resolved, env, allowDefaults);
+				return;
+			}
+			case "ObjectPattern":
+				for (const property of children(pattern, "properties")) {
+					if (property.type === "RestElement") {
+						this.error(ctx, property, "unsupported-pattern", "A rest element gathers props at run time.", "Name each prop you use.");
+						continue;
+					}
+					const key = child(property, "key");
+					const value = child(property, "value");
+					const name = keyName(key);
+					if (name === void 0 || value === void 0 || property.computed === true) {
+						this.error(ctx, property, "unsupported-pattern", "A computed key cannot be read statically.");
+						continue;
+					}
+					const field = binding === void 0 ? void 0 : this.field(ctx, binding, name, property);
+					this.bindPattern(ctx, value, field, env, allowDefaults);
+				}
+				return;
+			default: this.error(ctx, pattern, "unsupported-pattern", "A parameter is a name or an object pattern of names.", "Write `(input) =>` or `({ name, items }) =>`.");
+		}
+	}
+	/** The binding for `base.name`. */
+	field(ctx, base, name, at) {
+		switch (base.k) {
+			case "path":
+				if (name === "length" && base.path !== "") return {
+					k: "value",
+					value: { length: { bind: base.path } }
+				};
+				return {
+					k: "path",
+					path: joinPath(base.path, name)
+				};
+			case "object": return base.fields.get(name);
+			case "value":
+				if (name === "length") return {
+					k: "value",
+					value: { length: base.value }
+				};
+				if (base.value === null) return {
+					k: "value",
+					value: null
+				};
+				this.error(ctx, at, "dynamic-expression", `\`.${name}\` reads a property of a computed value.`, "Read fields of the input directly.");
+				return;
+			case "nodes":
+				this.error(ctx, at, "dynamic-expression", "`children` has no fields.", "Render `{children}` as is.");
+				return;
+		}
+	}
+	/** Resolve an identifier or member chain to a binding. */
+	binding(ctx, expression) {
+		const node = unwrap(expression);
+		if (node.type === "Identifier") {
+			const name = text(node, "name") ?? "";
+			if (name === "undefined") return {
+				k: "value",
+				value: null
+			};
+			const found = ctx.env.get(name);
+			if (found !== void 0) return found;
+			const imported = ctx.module.imports.get(name);
+			if (imported?.kind === "asset") {
+				const url = this.options.assetUrl(imported.path);
+				if (url !== void 0) return {
+					k: "value",
+					value: url
+				};
+			}
+			this.error(ctx, node, "dynamic-expression", `\`${name}\` is not a binding the template declared.`, "Read the input through the function's parameter, for example `input.name`.");
+			return;
+		}
+		if (node.type === "MemberExpression") {
+			const object = child(node, "object");
+			const property = child(node, "property");
+			if (object === void 0 || property === void 0) return void 0;
+			if (node.computed !== true && text(property, "name") === "length" && this.filterChain(ctx, object) !== void 0) {
+				const source = this.filterChain(ctx, object);
+				if (source.list === void 0) return void 0;
+				const first = source.filters[0];
+				const param = first === void 0 ? void 0 : children(first, "params")[0];
+				const as = this.uniqueName(ctx, param?.type === "Identifier" ? text(param, "name") ?? "item" : "item");
+				const where = this.whereClause({
+					...ctx,
+					loops: [...ctx.loops, as]
+				}, as, source.filters);
+				return where === void 0 ? void 0 : {
+					k: "value",
+					value: {
+						count: source.list,
+						as,
+						where
+					}
+				};
+			}
+			const base = this.binding(ctx, object);
+			if (base === void 0) return void 0;
+			let key;
+			if (node.computed === true) {
+				if (property.type === "StringLiteral") key = text(property, "value");
+				else if (property.type === "NumericLiteral") key = String(property.value);
+				if (key === void 0) {
+					this.dynamic(ctx, node, "A computed property", "Use `.name`, or a numeric index such as `[0]`.");
+					return;
+				}
+			} else key = text(property, "name");
+			if (key === void 0) return void 0;
+			return this.field(ctx, base, key, node);
+		}
+		if (node.type === "OptionalMemberExpression" || node.type === "OptionalCallExpression") {
+			this.dynamic(ctx, node, "Optional chaining", "Guard the field: `input.discount && <p>{input.discount.label}</p>`.");
+			return;
+		}
+		const value = this.value(ctx, node, false);
+		return value === void 0 ? void 0 : {
+			k: "value",
+			value
+		};
+	}
+	/** Lower an expression to a value read at render time. `arith` allows arithmetic operators. */
+	value(ctx, expression, arith) {
+		const node = unwrap(expression);
+		switch (node.type) {
+			case "StringLiteral": return this.checkedText(ctx, node, text(node, "value") ?? "");
+			case "NumericLiteral": return typeof node.value === "number" ? node.value : void 0;
+			case "BooleanLiteral": return node.value === true;
+			case "NullLiteral": return null;
+			case "Identifier":
+			case "MemberExpression":
+			case "OptionalMemberExpression": {
+				const bound = this.binding(ctx, node);
+				if (bound === void 0) return void 0;
+				const value = bindingValue(bound);
+				if (value !== void 0) return value;
+				this.error(ctx, node, "dynamic-expression", bound.k === "path" ? "The input as a whole is not a value." : "An object or `children` is not text.", bound.k === "path" ? "Read one field: `input.name`." : "Render `{children}` as content, or read one field.");
+				return;
+			}
+			case "TemplateLiteral": return this.template(ctx, node, arith);
+			case "ConditionalExpression": {
+				const test = child(node, "test");
+				const consequent = child(node, "consequent");
+				const alternate = child(node, "alternate");
+				if (test === void 0 || consequent === void 0 || alternate === void 0) return void 0;
+				const predicate = this.predicate(ctx, test);
+				const then = this.value(ctx, consequent, arith);
+				const otherwise = this.value(ctx, alternate, arith);
+				if (predicate === void 0 || then === void 0 || otherwise === void 0) return void 0;
+				return {
+					if: predicate,
+					then,
+					else: otherwise
+				};
+			}
+			case "LogicalExpression": {
+				const operator = text(node, "operator");
+				const left = child(node, "left");
+				const right = child(node, "right");
+				if (left === void 0 || right === void 0) return void 0;
+				if (operator === "||") {
+					const a = this.value(ctx, left, arith);
+					const b = this.value(ctx, right, arith);
+					if (a === void 0 || b === void 0) return void 0;
+					return {
+						if: { truthy: a },
+						then: a,
+						else: b
+					};
+				}
+				if (operator === "??") {
+					this.error(ctx, node, "dynamic-expression", "`??` is not one of the conditions the profile reads.", "Write the condition out: `input.name === null ? \"there\" : input.name`, or `input.name || \"there\"`.");
+					return;
+				}
+				this.error(ctx, node, "dynamic-expression", "`&&` in a value position yields its left operand when that is falsy.", "Use a conditional: `cond ? value : fallback`, or `cond && <X />` in content.");
+				return;
+			}
+			case "CallExpression": return this.call(ctx, node);
+			case "BinaryExpression": {
+				const operator = text(node, "operator") ?? "";
+				const op = ARITHMETIC[operator];
+				const left = child(node, "left");
+				const right = child(node, "right");
+				if (op === void 0 || left === void 0 || right === void 0) {
+					this.error(ctx, node, "dynamic-expression", `\`${operator}\` produces a condition, not a value.`, "Use it as the test of `&&`, `? :` or `||`.");
+					return;
+				}
+				if (!arith) {
+					this.error(ctx, node, "dynamic-expression", "Arithmetic runs code, and it is allowed only inside a `fmt.*` argument or a condition.", "Wrap it: `fmt.number(item.price * item.qty)`, or send the computed value in the payload.");
+					return;
+				}
+				if (op === "+" && [left, right].some((side) => /StringLiteral|TemplateLiteral/.test(unwrap(side).type))) {
+					this.error(ctx, node, "dynamic-expression", "`+` with a string joins text at run time.", "Use a template string: `${a} ${b}`.");
+					return;
+				}
+				const a = this.value(ctx, left, true);
+				const b = this.value(ctx, right, true);
+				return a === void 0 || b === void 0 ? void 0 : {
+					op,
+					args: [a, b]
+				};
+			}
+			case "UnaryExpression": {
+				const operator = text(node, "operator");
+				const argument = child(node, "argument");
+				if (operator === "-" && argument !== void 0) {
+					const inner = unwrap(argument);
+					if (inner.type === "NumericLiteral" && typeof inner.value === "number") return -inner.value;
+					if (arith) {
+						const value = this.value(ctx, argument, true);
+						return value === void 0 ? void 0 : {
+							op: "-",
+							args: [0, value]
+						};
+					}
+				}
+				if (operator === "!") {
+					this.error(ctx, node, "dynamic-expression", "`!` produces a condition, not a value.", "Use it as the test of `&&`, `? :` or `||`.");
+					return;
+				}
+				return this.dynamic(ctx, node, `\`${operator ?? "?"}\``, "Send the computed value in the payload.");
+			}
+			case "JSXElement":
+			case "JSXFragment":
+				this.error(ctx, node, "dynamic-expression", "Markup is not a text value.", "Use it as content.");
+				return;
+			case "ArrowFunctionExpression":
+			case "FunctionExpression": return this.dynamic(ctx, node, "A function", "Write the value directly.");
+			case "NewExpression":
+			case "AwaitExpression":
+			case "AssignmentExpression":
+			case "UpdateExpression":
+			case "SequenceExpression":
+			case "ObjectExpression":
+			case "ArrayExpression":
+			case "SpreadElement": return this.dynamic(ctx, node, `\`${node.type}\``, "Send the computed value in the payload.");
+			default: return this.dynamic(ctx, node, `\`${node.type}\``, "Send the computed value in the payload.");
+		}
+	}
+	checkedText(ctx, node, value) {
+		if (/[-]/.test(value)) this.error(ctx, node, "reserved-character", "This text contains a private-use character the compiler reserves.", "Remove the characters U+E000 to U+E003.");
+		return value;
+	}
+	template(ctx, node, arith) {
+		const quasis = children(node, "quasis");
+		const expressions = children(node, "expressions");
+		const parts = [];
+		let ok = true;
+		for (const [index, quasi] of quasis.entries()) {
+			const chunk = templateChunk(quasi);
+			if (chunk !== "") parts.push(this.checkedText(ctx, quasi, chunk));
+			const expression = expressions[index];
+			if (expression !== void 0) {
+				const value = this.value(ctx, expression, arith);
+				if (value === void 0) ok = false;
+				else parts.push(value);
+			}
+		}
+		if (!ok) return void 0;
+		return joinValues(parts);
+	}
+	/** A `fmt.*` call. Any other call is the dynamic expression the profile refuses. */
+	call(ctx, node) {
+		const callee = child(node, "callee");
+		const args = children(node, "arguments");
+		if (callee === void 0) return void 0;
+		const target = unwrap(callee);
+		if (target.type === "MemberExpression" && target.computed !== true) {
+			const object = child(target, "object");
+			const property = child(target, "property");
+			const method = property === void 0 ? void 0 : text(property, "name");
+			if (object !== void 0 && method !== void 0 && this.isFmt(ctx, object)) {
+				if (!FORMATTER_NAMES.includes(method)) {
+					this.error(ctx, node, "unknown-formatter", `\`fmt.${method}\` is not a formatter.`, `Use one of ${FORMATTER_NAMES.map((name) => `fmt.${name}`).join(", ")}.`);
+					return;
+				}
+				const name = method;
+				const [min, max] = FORMATTER_ARITY[name];
+				if (args.length < min || args.length > max) {
+					this.error(ctx, node, "formatter-arguments", `\`fmt.${name}\` takes ${min === max ? min : `${min} to ${max}`} arguments.`, "Check the formatter table in the reference.");
+					return;
+				}
+				const lowered = [];
+				for (const argument of args) {
+					const inner = unwrap(argument);
+					if (inner.type === "ObjectExpression") {
+						const literal = readStatic(this.options.staticContext, ctx.module, inner);
+						if (!literal.ok) {
+							this.error(ctx, inner, "dynamic-expression", "Formatter options are literal.", "Write plain string and number values.");
+							return;
+						}
+						lowered.push({ lit: literal.value });
+						continue;
+					}
+					if (inner.type === "ArrayExpression") {
+						const literal = readStatic(this.options.staticContext, ctx.module, inner);
+						if (literal.ok) {
+							lowered.push({ lit: literal.value });
+							continue;
+						}
+					}
+					const value = this.value(ctx, argument, true);
+					if (value === void 0) return void 0;
+					lowered.push(value);
+				}
+				return {
+					format: name,
+					args: lowered
+				};
+			}
+			if (method !== void 0 && RUN_TIME_METHODS.has(method)) return this.dynamic(ctx, node, `\`.${method}(…)\``, "Send the computed value in the payload and bind it, or format with `fmt.*`.");
+		}
+		if (target.type === "Identifier" && /^use[A-Z]/.test(text(target, "name") ?? "")) {
+			this.error(ctx, node, "hook-call", `\`${text(target, "name")}\` is a hook, and a template has no state, effects or context.`, "Read the input through the function's parameter; send anything else in the payload.");
+			return;
+		}
+		const name = target.type === "Identifier" ? text(target, "name") ?? "" : target.type === "MemberExpression" ? `${jsxLike(child(target, "object"))}.${text(child(target, "property") ?? target, "name") ?? ""}` : "a call";
+		return this.dynamic(ctx, node, `\`${name}(…)\``, "Send the computed value in the payload and bind it, or format with `fmt.money`, `fmt.number`, `fmt.date`, `fmt.time`, `fmt.plural` or `fmt.list`.");
+	}
+	isFmt(ctx, object) {
+		const node = unwrap(object);
+		if (node.type !== "Identifier") return false;
+		const imported = ctx.module.imports.get(text(node, "name") ?? "");
+		return imported?.kind === "markup" && imported.specifier === "@samva/markup/fmt";
+	}
+	predicate(ctx, expression) {
+		const node = unwrap(expression);
+		if (node.type === "LogicalExpression") {
+			const operator = text(node, "operator");
+			const left = child(node, "left");
+			const right = child(node, "right");
+			if (left !== void 0 && right !== void 0 && (operator === "&&" || operator === "||")) {
+				const a = this.predicate(ctx, left);
+				const b = this.predicate(ctx, right);
+				if (a === void 0 || b === void 0) return void 0;
+				if (operator === "&&") {
+					const flat = (predicate) => "and" in predicate ? predicate.and : [predicate];
+					return { and: [...flat(a), ...flat(b)] };
+				}
+				const flat = (predicate) => "or" in predicate ? predicate.or : [predicate];
+				return { or: [...flat(a), ...flat(b)] };
+			}
+		}
+		if (node.type === "UnaryExpression" && text(node, "operator") === "!") {
+			const argument = child(node, "argument");
+			const inner = argument === void 0 ? void 0 : this.predicate(ctx, argument);
+			return inner === void 0 ? void 0 : { not: inner };
+		}
+		if (node.type === "BinaryExpression") {
+			const operator = text(node, "operator") ?? "";
+			const cmp = COMPARISON[operator];
+			const left = child(node, "left");
+			const right = child(node, "right");
+			if (cmp === void 0 || left === void 0 || right === void 0) {
+				this.error(ctx, node, "dynamic-expression", operator === "==" || operator === "!=" ? `\`${operator}\` coerces types at run time.` : `\`${operator}\` is not a comparison the profile reads.`, "Use `===`, `!==`, `<`, `>`, `<=` or `>=`.");
+				return;
+			}
+			const a = this.value(ctx, left, true);
+			const b = this.value(ctx, right, true);
+			return a === void 0 || b === void 0 ? void 0 : {
+				cmp,
+				args: [a, b]
+			};
+		}
+		const value = this.value(ctx, node, true);
+		if (value === void 0) return void 0;
+		if (typeof value === "object" && value !== null && "bind" in value) return { present: value.bind };
+		if (isStatic(value)) return { truthy: value };
+		return { truthy: value };
+	}
+	/** Lower the children of a JSX element or fragment. */
+	jsxChildren(ctx, parent) {
+		const output = [];
+		for (const item of children(parent, "children")) switch (item.type) {
+			case "JSXText": {
+				const cleaned = cleanJsxText(text(item, "value") ?? "");
+				if (cleaned !== "") output.push(this.checkedText(ctx, item, cleaned));
+				break;
+			}
+			case "JSXExpressionContainer": {
+				const expression = child(item, "expression");
+				if (expression === void 0 || expression.type === "JSXEmptyExpression") break;
+				output.push(...this.content(ctx, expression));
+				break;
+			}
+			case "JSXElement":
+			case "JSXFragment":
+				output.push(...this.element(ctx, item));
+				break;
+			case "JSXSpreadChild": this.dynamic(ctx, item, "A spread child", "List the children.");
+		}
+		return output;
+	}
+	/** Lower an expression in content position. */
+	content(ctx, expression) {
+		if (ctx.depth > MAX_DEPTH) {
+			this.error(ctx, expression, "nesting-limit", "The template nests too deeply.", "Flatten it.");
+			return [];
+		}
+		const node = unwrap(expression);
+		switch (node.type) {
+			case "JSXElement":
+			case "JSXFragment": return this.element(ctx, node);
+			case "StringLiteral": {
+				const value = text(node, "value") ?? "";
+				return value === "" ? [] : [this.checkedText(ctx, node, value)];
+			}
+			case "NumericLiteral": return typeof node.value === "number" ? [node.value] : [];
+			case "BooleanLiteral":
+			case "NullLiteral": return [];
+			case "Identifier": {
+				const name = text(node, "name") ?? "";
+				if (name === "undefined") return [];
+				const found = ctx.env.get(name);
+				if (found?.k === "nodes") return [...found.nodes];
+				break;
+			}
+			case "LogicalExpression": {
+				const operator = text(node, "operator");
+				const left = child(node, "left");
+				const right = child(node, "right");
+				if (operator === "&&" && left !== void 0 && right !== void 0) {
+					const test = this.predicate(ctx, left);
+					const then = this.content(ctx, right);
+					if (test === void 0) return [];
+					return [{
+						if: test,
+						then,
+						src: this.src(ctx.module, node)
+					}];
+				}
+				break;
+			}
+			case "ConditionalExpression": {
+				const test = child(node, "test");
+				const consequent = child(node, "consequent");
+				const alternate = child(node, "alternate");
+				if (test === void 0 || consequent === void 0 || alternate === void 0) return [];
+				const predicate = this.predicate(ctx, test);
+				const then = this.content(ctx, consequent);
+				const otherwise = this.content(ctx, alternate);
+				if (predicate === void 0) return [];
+				return [{
+					if: predicate,
+					then,
+					...otherwise.length === 0 ? {} : { else: otherwise },
+					src: this.src(ctx.module, node)
+				}];
+			}
+			case "CallExpression": {
+				const callee = child(node, "callee");
+				const target = callee === void 0 ? void 0 : unwrap(callee);
+				const property = target === void 0 ? void 0 : child(target, "property");
+				if (target?.type === "MemberExpression" && target.computed !== true && property !== void 0 && text(property, "name") === "map") return this.each(ctx, node, target);
+				break;
+			}
+		}
+		const value = this.value(ctx, node, false);
+		return value === void 0 ? [] : [value];
+	}
+	/** A loop variable name that shadows none in scope. */
+	freshName(ctx, base) {
+		return this.uniqueName(ctx, base);
+	}
+	uniqueName(ctx, base) {
+		if (!ctx.loops.includes(base)) return base;
+		this.uniqueId += 1;
+		return `${base}_${this.uniqueId}`;
+	}
+	each(ctx, call, callee) {
+		const object = child(callee, "object");
+		const callback = children(call, "arguments")[0];
+		if (object === void 0 || callback === void 0) return [];
+		const source = this.filterChain(ctx, object);
+		const list = source === void 0 ? this.value(ctx, object, false) : source.list;
+		const fn = unwrap(callback);
+		if (fn.type !== "ArrowFunctionExpression" && fn.type !== "FunctionExpression") {
+			this.dynamic(ctx, callback, "A callback that is not an inline function", "Write `.map((item) => <Row item={item} />)`.");
+			return [];
+		}
+		if (list === void 0) return [];
+		const each = this.eachOver(ctx, call, list, fn, source?.filters ?? []);
+		return each === void 0 ? [] : [each];
+	}
+	/** `list.filter(a).filter(b)`: the list underneath and the callbacks, innermost first. */
+	filterChain(ctx, expression) {
+		const filters = [];
+		let current = unwrap(expression);
+		for (;;) {
+			if (current.type !== "CallExpression") break;
+			const callee = child(current, "callee");
+			const target = callee === void 0 ? void 0 : unwrap(callee);
+			const property = target === void 0 ? void 0 : child(target, "property");
+			if (target?.type !== "MemberExpression" || target.computed === true || property === void 0 || text(property, "name") !== "filter") break;
+			const callback = children(current, "arguments")[0];
+			const object = child(target, "object");
+			if (callback === void 0 || object === void 0) return void 0;
+			filters.unshift(unwrap(callback));
+			current = unwrap(object);
+		}
+		if (filters.length === 0) return void 0;
+		return {
+			list: this.value(ctx, current, false),
+			filters
+		};
+	}
+	/** The condition `.filter(callbacks)` keeps items by, with the item bound as `$as`. */
+	whereClause(ctx, as, filters) {
+		const predicates = [];
+		for (const filter of filters) {
+			if (!/Function/.test(filter.type)) {
+				this.dynamic(ctx, filter, "A `.filter` callback that is not an inline function", "Write `.filter((item) => item.done)`.");
+				return;
+			}
+			const params = children(filter, "params");
+			if (params.length > 1) {
+				this.error(ctx, filter, "dynamic-expression", "A `.filter` callback reads the item; its index and the array are not part of the profile.", "Remove the extra parameters.");
+				return;
+			}
+			const env = new Map(ctx.env);
+			if (params[0] !== void 0) this.bindPattern(ctx, params[0], {
+				k: "path",
+				path: `$${as}`
+			}, env, false);
+			const scoped = {
+				...ctx,
+				env
+			};
+			const body = this.functionExpression(scoped, filter);
+			const predicate = body === void 0 ? void 0 : this.predicate(scoped, body);
+			if (predicate === void 0) return void 0;
+			predicates.push(predicate);
+		}
+		if (predicates.length === 0) return void 0;
+		return predicates.length === 1 ? predicates[0] : { and: predicates };
+	}
+	/** Lower `list.map(fn)` to a loop, keeping only the items the filters keep. */
+	eachOver(ctx, at, list, fn, filters = [], options = {}) {
+		const params = children(fn, "params");
+		if (params.length > 2) {
+			this.error(ctx, fn, "dynamic-expression", "`.map` callbacks read the item and its index; a third parameter is the whole array.", "Remove the third parameter.");
+			return;
+		}
+		const env = new Map(ctx.env);
+		const loops = [...ctx.loops];
+		let as = "";
+		let index;
+		const itemPattern = params[0];
+		if (itemPattern !== void 0) {
+			const raw = itemPattern.type === "Identifier" ? text(itemPattern, "name") ?? "item" : "item";
+			as = this.uniqueName({
+				...ctx,
+				loops
+			}, options.name ?? raw);
+			loops.push(as);
+			this.bindPattern({
+				...ctx,
+				loops
+			}, itemPattern, {
+				k: "path",
+				path: `$${as}`
+			}, env, false);
+		} else {
+			as = this.uniqueName(ctx, options.name ?? "item");
+			loops.push(as);
+		}
+		const indexPattern = params[1];
+		if (indexPattern !== void 0) {
+			if (indexPattern.type !== "Identifier") this.error(ctx, indexPattern, "unsupported-pattern", "The index is a plain name.");
+			else {
+				index = this.uniqueName({
+					...ctx,
+					loops
+				}, text(indexPattern, "name") ?? "index");
+				loops.push(index);
+				env.set(text(indexPattern, "name") ?? "index", {
+					k: "value",
+					value: { bind: `$${index}` }
+				});
+			}
+		}
+		const where = filters.length === 0 ? void 0 : this.whereClause(ctx, as, filters);
+		if (filters.length > 0 && where === void 0) return void 0;
+		const inner = {
+			...ctx,
+			env,
+			loops,
+			depth: ctx.depth + 1
+		};
+		const body = this.functionExpression(inner, fn);
+		if (body === void 0) return void 0;
+		const nodes = this.content(inner, body);
+		return {
+			each: list,
+			as,
+			...index === void 0 ? {} : { index },
+			...where === void 0 ? {} : { where },
+			...options.chunk === void 0 ? {} : { chunk: options.chunk },
+			children: nodes,
+			src: this.src(ctx.module, at)
+		};
+	}
+	/** Lower a JSX element or fragment to IR nodes. */
+	element(ctx, node) {
+		if (node.type === "JSXFragment") return this.jsxChildren({
+			...ctx,
+			depth: ctx.depth + 1
+		}, node);
+		const opening = child(node, "openingElement");
+		const nameNode = opening === void 0 ? void 0 : child(opening, "name");
+		if (opening === void 0 || nameNode === void 0) return [];
+		const name = jsxName$1(nameNode);
+		const inner = {
+			...ctx,
+			depth: ctx.depth + 1
+		};
+		if (inner.depth > MAX_DEPTH) {
+			this.error(ctx, node, "nesting-limit", "The template nests too deeply.", "Flatten it.");
+			return [];
+		}
+		if (/^[a-z]/.test(name) && !name.includes(".")) return this.intrinsic(inner, node, opening, name);
+		return this.component(inner, node, opening, name);
+	}
+	attributeName(attribute) {
+		const name = child(attribute, "name");
+		return name === void 0 ? "" : jsxName$1(name);
+	}
+	intrinsic(ctx, node, opening, tag) {
+		const spec = emailElement(tag);
+		if (spec === void 0) {
+			const near = didYouMean(tag, Object.keys(EMAIL_ELEMENTS));
+			this.error(ctx, node, "unsupported-element", `<${tag}> is not part of the supported email vocabulary.`, near === void 0 ? `Use one of: ${Object.keys(EMAIL_ELEMENTS).join(", ")}.` : `Did you mean <${near}>? Supported elements: ${Object.keys(EMAIL_ELEMENTS).join(", ")}.`);
+			return [];
+		}
+		const attrs = {};
+		let style;
+		const origin = [this.findings.locate(ctx.module.parsed, node)];
+		for (const attribute of children(opening, "attributes")) {
+			if (attribute.type === "JSXSpreadAttribute") {
+				this.dynamic(ctx, attribute, "A spread attribute", "Write each attribute.");
+				continue;
+			}
+			const name = this.attributeName(attribute);
+			const valueNode = child(attribute, "value");
+			if (name === "key") continue;
+			if (name === "ref" || name === "dangerouslySetInnerHTML" || /^on[A-Z]/.test(name)) {
+				const isHtml = name === "dangerouslySetInnerHTML";
+				this.error(ctx, attribute, isHtml ? "dangerous-html" : name === "ref" ? "unsupported-attribute" : "event-handler", isHtml ? "`dangerouslySetInnerHTML` injects unescaped markup." : name === "ref" ? "A `ref` needs a running component." : `\`${name}\` is an event handler; email clients strip scripting and Samva refuses it.`, isHtml ? "Write the markup as elements." : "Remove it.");
+				continue;
+			}
+			if (RESERVED_FOOTER_ATTRIBUTES.has(name)) {
+				this.error(ctx, attribute, "reserved-attribute", `\`${name}\` is written only by BrandFooter from samva:brand.`, "Render <BrandFooter /> instead of marking an element as the footer.");
+				continue;
+			}
+			if (name === "className" || name === "class") {
+				const value = valueNode === void 0 ? "" : this.classValue(ctx, valueNode);
+				if (value !== void 0 && value !== "") attrs.class = value;
+				continue;
+			}
+			if (name === "style") {
+				style = this.styleAttribute(ctx, valueNode);
+				continue;
+			}
+			let value;
+			if (valueNode === void 0) value = true;
+			else if (valueNode.type === "StringLiteral") value = this.checkedText(ctx, valueNode, text(valueNode, "value") ?? "");
+			else if (valueNode.type === "JSXExpressionContainer") {
+				const expression = child(valueNode, "expression");
+				value = expression === void 0 ? void 0 : this.value(ctx, expression, false);
+			} else {
+				this.error(ctx, valueNode, "dynamic-expression", "An attribute value is text, a number or a binding.");
+				continue;
+			}
+			if (value === void 0) continue;
+			if (value === false || value === null) continue;
+			if (value === "%samva:unsubscribe-url%") {
+				this.error(ctx, attribute, "reserved-url", "That URL is the unsubscribe placeholder only BrandFooter can write.", "Render <BrandFooter /> instead.");
+				continue;
+			}
+			if (isStatic(value)) {
+				const checked = checkAttribute(tag, name, value, origin);
+				if (checked.text === void 0 && checked.diagnostics.length === 0) {
+					const near = didYouMean(name, Object.keys({
+						...spec.attributes,
+						id: 0,
+						title: 0,
+						lang: 0,
+						dir: 0,
+						role: 0
+					}));
+					this.error(ctx, attribute, "unsupported-attribute", `<${tag}> does not support the ${name} attribute.`, near === void 0 ? `Supported: ${Object.keys(spec.attributes).join(", ") || "none"}, plus id, title, lang, dir, role, class, style, data-* and aria-*.` : `Did you mean \`${near}\`?`);
+					continue;
+				}
+				this.findings.items.push(...checked.diagnostics);
+			}
+			attrs[name] = value;
+		}
+		const kids = spec.content === "void" ? [] : this.jsxChildren(ctx, node);
+		return [{
+			el: tag,
+			...Object.keys(attrs).length === 0 ? {} : { attrs },
+			...style === void 0 ? {} : { style },
+			...kids.length === 0 ? {} : { children: kids },
+			src: this.src(ctx.module, node)
+		}];
+	}
+	/** A class value: literal classes, possibly chosen by a condition. Tailwind cannot see anything else. */
+	classValue(ctx, valueNode) {
+		const node = valueNode.type === "JSXExpressionContainer" ? child(valueNode, "expression") : valueNode;
+		if (node === void 0) return void 0;
+		const value = this.classExpression(ctx, node);
+		if (value === void 0) this.error(ctx, valueNode, "dynamic-class", "This class is built at run time, and Tailwind cannot see class names it does not read.", "Write the classes literally, or choose between literal classes: `input.vip ? \"bg-amber-100\" : \"bg-white\"`.");
+		return value;
+	}
+	classExpression(ctx, expression) {
+		const node = unwrap(expression);
+		switch (node.type) {
+			case "StringLiteral": return text(node, "value") ?? "";
+			case "NullLiteral": return "";
+			case "BooleanLiteral": return "";
+			case "Identifier":
+			case "MemberExpression": {
+				if (node.type === "Identifier" && text(node, "name") === "undefined") return "";
+				const bound = this.binding(ctx, node);
+				return bound?.k === "value" && isClassValue(bound.value) ? bound.value : void 0;
+			}
+			case "TemplateLiteral": {
+				const quasis = children(node, "quasis");
+				const expressions = children(node, "expressions");
+				const parts = [];
+				for (const [index, quasi] of quasis.entries()) {
+					const chunk = templateChunk(quasi);
+					if (chunk !== "") parts.push(chunk);
+					const inner = expressions[index];
+					if (inner !== void 0) {
+						const value = this.classExpression(ctx, inner);
+						if (value === void 0) return void 0;
+						parts.push(value);
+					}
+				}
+				return joinValues(parts);
+			}
+			case "ConditionalExpression": {
+				const test = child(node, "test");
+				const consequent = child(node, "consequent");
+				const alternate = child(node, "alternate");
+				if (test === void 0 || consequent === void 0 || alternate === void 0) return void 0;
+				const predicate = this.predicate(ctx, test);
+				const then = this.classExpression(ctx, consequent);
+				const otherwise = this.classExpression(ctx, alternate);
+				if (predicate === void 0 || then === void 0 || otherwise === void 0) return void 0;
+				return {
+					if: predicate,
+					then,
+					else: otherwise
+				};
+			}
+			case "LogicalExpression": {
+				const left = child(node, "left");
+				const right = child(node, "right");
+				if (text(node, "operator") !== "&&" || left === void 0 || right === void 0) return void 0;
+				const predicate = this.predicate(ctx, left);
+				const then = this.classExpression(ctx, right);
+				if (predicate === void 0 || then === void 0) return void 0;
+				return {
+					if: predicate,
+					then,
+					else: ""
+				};
+			}
+			case "BinaryExpression": {
+				const left = child(node, "left");
+				const right = child(node, "right");
+				if (text(node, "operator") !== "+" || left === void 0 || right === void 0) return void 0;
+				const a = this.classExpression(ctx, left);
+				const b = this.classExpression(ctx, right);
+				return a === void 0 || b === void 0 ? void 0 : joinValues([a, b]);
+			}
+			default: return;
+		}
+	}
+	styleAttribute(ctx, valueNode) {
+		const expression = valueNode === void 0 ? void 0 : child(valueNode, "expression");
+		const object = expression === void 0 ? void 0 : unwrap(expression);
+		if (object === void 0 || object.type !== "ObjectExpression") {
+			if (valueNode !== void 0) this.error(ctx, valueNode, "invalid-style", "`style` is an object literal of CSS properties.", "Write style={{ backgroundColor: \"#fff\" }}, or use Tailwind classes.");
+			return;
+		}
+		return this.styleObject(ctx, object);
+	}
+	/** A `style` object literal as declarations whose values may be read at render time. */
+	styleObject(ctx, object) {
+		const entries = [];
+		for (const property of children(object, "properties")) {
+			if (property.type !== "ObjectProperty" || property.computed === true) {
+				this.dynamic(ctx, property, "A spread or computed style entry", "Write each property.");
+				continue;
+			}
+			const key = child(property, "key");
+			const value = child(property, "value");
+			const name = keyName(key);
+			if (name === void 0 || value === void 0) continue;
+			const lowered = this.value(ctx, value, false);
+			if (lowered === void 0) continue;
+			if (lowered === null) continue;
+			entries.push([name, lowered]);
+		}
+		return entries;
+	}
+	component(ctx, node, opening, name) {
+		const head = name.split(".")[0] ?? name;
+		const imported = ctx.module.imports.get(head);
+		const local = ctx.module.declarations.get(head);
+		const attributes = children(opening, "attributes");
+		if (imported?.kind === "markup" || imported?.kind === "brand") return runBuiltinComponent({
+			lowerer: this,
+			ctx,
+			node,
+			attributes,
+			name,
+			binding: imported,
+			brand: this.options.brand,
+			channel: this.options.channel
+		});
+		let fn;
+		if (imported?.kind === "project") {
+			const target = this.options.project.modules.get(imported.path);
+			if (target !== void 0) fn = this.exportedFunction(target, imported.imported, /* @__PURE__ */ new Set());
+		} else if (local !== void 0) fn = {
+			module: ctx.module,
+			value: local.value
+		};
+		if (fn === void 0 || !/Function|Arrow/.test(fn.value.type)) {
+			this.error(ctx, node, "unknown-component", `<${name}> is not a component the profile can read.`, "Import it from @samva/markup/email, or from a project file that exports it as a function.");
+			return [];
+		}
+		return this.partial(ctx, node, attributes, name, fn.module, fn.value);
+	}
+	exportedFunction(module, exported, seen) {
+		const key = `${module.path}\0${exported}`;
+		if (seen.has(key)) return void 0;
+		seen.add(key);
+		if (exported === "default") {
+			const value = module.defaultExport;
+			if (value === void 0) return void 0;
+			if (value.type === "Identifier") {
+				const declared = module.declarations.get(text(value, "name") ?? "");
+				return declared === void 0 ? void 0 : {
+					module,
+					value: declared.value
+				};
+			}
+			return {
+				module,
+				value
+			};
+		}
+		const local = module.exports.get(exported);
+		if (local === void 0) return void 0;
+		const declared = module.declarations.get(local);
+		if (declared !== void 0) return {
+			module,
+			value: declared.value
+		};
+		const imported = module.imports.get(local);
+		if (imported?.kind === "project") {
+			const target = this.options.project.modules.get(imported.path);
+			return target === void 0 ? void 0 : this.exportedFunction(target, imported.imported, seen);
+		}
+	}
+	/** Bindings for the attributes written on a component tag. */
+	attributeBindings(ctx, attributes) {
+		const props = /* @__PURE__ */ new Map();
+		let ok = true;
+		for (const attribute of attributes) {
+			if (attribute.type === "JSXSpreadAttribute") {
+				this.dynamic(ctx, attribute, "A spread attribute", "Write each prop.");
+				ok = false;
+				continue;
+			}
+			const name = this.attributeName(attribute);
+			if (name === "key") continue;
+			const valueNode = child(attribute, "value");
+			if (valueNode === void 0) {
+				props.set(name, {
+					k: "value",
+					value: true
+				});
+				continue;
+			}
+			if (valueNode.type === "StringLiteral") {
+				props.set(name, {
+					k: "value",
+					value: this.checkedText(ctx, valueNode, text(valueNode, "value") ?? "")
+				});
+				continue;
+			}
+			const expression = valueNode.type === "JSXExpressionContainer" ? child(valueNode, "expression") : void 0;
+			if (expression === void 0) {
+				this.error(ctx, valueNode, "dynamic-expression", "A prop value is text, a number, a binding or an object.");
+				ok = false;
+				continue;
+			}
+			const bound = this.propBinding(ctx, expression);
+			if (bound === void 0) ok = false;
+			else props.set(name, bound);
+		}
+		return ok ? props : void 0;
+	}
+	propBinding(ctx, expression) {
+		const node = unwrap(expression);
+		if (node.type === "ObjectExpression") {
+			const fields = /* @__PURE__ */ new Map();
+			for (const property of children(node, "properties")) {
+				if (property.type !== "ObjectProperty" || property.computed === true) {
+					this.dynamic(ctx, property, "A spread or computed entry", "Write each field.");
+					return;
+				}
+				const key = child(property, "key");
+				const value = child(property, "value");
+				const name = key === void 0 ? void 0 : key.type === "Identifier" ? text(key, "name") : text(key, "value");
+				if (name === void 0 || value === void 0) return void 0;
+				const bound = this.propBinding(ctx, value);
+				if (bound === void 0) return void 0;
+				fields.set(name, bound);
+			}
+			return {
+				k: "object",
+				fields
+			};
+		}
+		if (node.type === "Identifier" || node.type === "MemberExpression") return this.binding(ctx, node);
+		if (node.type === "JSXElement" || node.type === "JSXFragment") return {
+			k: "nodes",
+			nodes: this.element(ctx, node)
+		};
+		const value = this.value(ctx, node, false);
+		return value === void 0 ? void 0 : {
+			k: "value",
+			value
+		};
+	}
+	partial(ctx, node, attributes, name, module, fn) {
+		const id = `${module.path}#${fn.start}`;
+		if (ctx.stack.includes(id)) {
+			this.error(ctx, node, "recursive-partial", `<${name}> renders itself, and the compiler inlines partials.`, "Flatten the recursion, or repeat the structure with `.map`.");
+			return [];
+		}
+		const props = this.attributeBindings(ctx, attributes);
+		if (props === void 0) return [];
+		const kids = this.jsxChildren(ctx, node);
+		if (kids.length > 0) props.set("children", {
+			k: "nodes",
+			nodes: kids
+		});
+		const inner = {
+			module,
+			env: /* @__PURE__ */ new Map(),
+			stack: [...ctx.stack, id],
+			loops: ctx.loops,
+			depth: ctx.depth + 1
+		};
+		const env = /* @__PURE__ */ new Map();
+		const param = children(fn, "params")[0];
+		if (param !== void 0) {
+			const bag = {
+				k: "object",
+				fields: props
+			};
+			if (param.type === "Identifier") env.set(text(param, "name") ?? "props", bag);
+			else this.bindPattern(inner, param, bag, env, true);
+		}
+		const scoped = {
+			...inner,
+			env
+		};
+		const body = this.functionExpression(scoped, fn);
+		return body === void 0 ? [] : this.content(scoped, body);
+	}
+};
+const jsxLike = (node) => node === void 0 ? "" : node.type === "Identifier" ? text(node, "name") ?? "" : "…";
+/** A value made only of literal class lists and choices between them. */
+const isClassValue = (value) => {
+	if (typeof value === "string") return true;
+	if (typeof value !== "object" || value === null) return false;
+	if ("if" in value) return isClassValue(value.then) && isClassValue(value.else);
+	if ("concat" in value) return value.concat.every(isClassValue);
+	return false;
+};
+/** The cooked text of one template-string segment. */
+const templateChunk = (quasi) => {
+	const value = quasi.value;
+	if (typeof value !== "object" || value === null) return "";
+	const cooked = value.cooked;
+	const raw = value.raw;
+	return typeof cooked === "string" ? cooked : typeof raw === "string" ? raw : "";
+};
+/** Concatenate values, merging adjacent literals. A lone part stays itself. */
+const joinValues = (parts) => {
+	const merged = [];
+	for (const part of parts) {
+		const previous = merged[merged.length - 1];
+		if (typeof part === "string" && typeof previous === "string") merged[merged.length - 1] = previous + part;
+		else if (typeof part === "object" && part !== null && "concat" in part) for (const inner of part.concat) {
+			const last = merged[merged.length - 1];
+			if (typeof inner === "string" && typeof last === "string") merged[merged.length - 1] = last + inner;
+			else merged.push(inner);
+		}
+		else merged.push(part);
+	}
+	if (merged.length === 0) return "";
+	if (merged.length === 1) return merged[0];
+	return { concat: merged };
+};
+//#endregion
+//#region src/sml/channels.ts
+/**
+* The SMS and WhatsApp roots are read by `channelBodies` from the channel field, never lowered
+* as content, so a channel component met anywhere else is in the wrong channel.
+*/
+const channelLowering = () => void 0;
+const HEADER_LIMIT = 60;
+const FOOTER_LIMIT = 60;
+const BODY_LIMIT = 1024;
+const BUTTON_TEXT_LIMIT = 25;
+const URL_BUTTON_LIMIT = 2;
+const PHONE_BUTTON_LIMIT = 1;
+const QUICK_REPLY_LIMIT = 10;
+const BUTTON_LIMIT = 10;
+const jsxName = (name) => {
+	if (name.type === "JSXIdentifier") return text(name, "name") ?? "";
+	if (name.type === "JSXMemberExpression") return `${jsxName(child(name, "object") ?? name)}.${text(child(name, "property") ?? name, "name") ?? ""}`;
+	return "";
+};
+const tagOf = (element) => {
+	const opening = child(element, "openingElement");
+	const name = opening === void 0 ? void 0 : child(opening, "name");
+	return name === void 0 ? "" : jsxName(name);
+};
+const attributesOf = (element) => {
+	const opening = child(element, "openingElement");
+	return opening === void 0 ? [] : children(opening, "attributes");
+};
+/** The root element of a channel body, when it is the channel's own component. */
+const readRoot = (input, field, imported, specifier) => {
+	const opened = input.openFunction(field);
+	if (opened === void 0) return void 0;
+	const { ctx, body } = opened;
+	const node = unwrap(body);
+	const tag = node.type === "JSXElement" ? tagOf(node) : "";
+	const binding = ctx.module.imports.get(tag);
+	if (node.type !== "JSXElement" || binding?.kind !== "markup" || binding.specifier !== specifier || binding.imported !== imported) {
+		input.lowerer.error(ctx, node, "wrong-channel", `The ${imported === "Sms" ? "sms" : "whatsapp"} channel returns one <${imported}> element imported from ${specifier}.`, `Write \`import { ${imported} } from "${specifier}"\` and return <${imported}>…</${imported}>.`);
+		return;
+	}
+	return {
+		ctx,
+		node,
+		local: tag
+	};
+};
+/** The string-literal attributes of a channel root; anything else is reported. */
+const readAttributes = (input, root, allowed) => {
+	const values = /* @__PURE__ */ new Map();
+	for (const attribute of attributesOf(root.node)) {
+		if (attribute.type === "JSXSpreadAttribute") {
+			input.lowerer.error(root.ctx, attribute, "dynamic-expression", "A spread attribute runs code, and templates render without running code.", "Write each attribute as a string literal.");
+			continue;
+		}
+		const nameNode = child(attribute, "name");
+		const name = nameNode === void 0 ? "" : jsxName(nameNode);
+		if (name === "key") continue;
+		if (!allowed.includes(name)) {
+			input.lowerer.error(root.ctx, attribute, "unknown-attribute", `\`${name}\` is not an attribute of this component.`, `The attributes are ${allowed.join(", ")}.`);
+			continue;
+		}
+		const value = child(attribute, "value");
+		const literal = value?.type === "JSXExpressionContainer" ? child(value, "expression") : value;
+		if (literal?.type !== "StringLiteral") {
+			input.lowerer.error(root.ctx, attribute, "dynamic-expression", `\`${name}\` is fixed when the template is compiled, so it is a string literal.`, `Write ${name}="…".`);
+			continue;
+		}
+		values.set(name, text(literal, "value") ?? "");
+	}
+	return values;
+};
+const oneOf = (input, root, node, name, value, allowed) => {
+	if (allowed.includes(value)) return true;
+	input.lowerer.error(root.ctx, node, "invalid-attribute", `\`${value}\` is not a ${name} this channel accepts.`, `Use one of ${allowed.join(", ")}.`);
+	return false;
+};
+const valueOnly = (nodes) => nodes.every((node) => isValueNode(node));
+const containsElement = (nodes) => nodes.some((node) => {
+	if (isValueNode(node)) return false;
+	if ("el" in node || "raw" in node) return true;
+	if ("if" in node) return containsElement(node.then) || containsElement(node.else ?? []);
+	if ("each" in node) return containsElement(node.children);
+	return false;
+});
+const smsChannel = (input, field) => {
+	const root = readRoot(input, field, "Sms", "@samva/markup/sms");
+	if (root === void 0) return void 0;
+	const attributes = readAttributes(input, root, SMS_ATTRIBUTES);
+	const categoryNode = attributesOf(root.node).find((attribute) => text(child(attribute, "name") ?? attribute, "name") === "category");
+	const category = attributes.get("category");
+	if (category !== void 0 && categoryNode !== void 0 && !oneOf(input, root, categoryNode, "category", category, SMS_CATEGORIES)) return void 0;
+	const body = input.lowerer.jsxChildren(root.ctx, root.node);
+	if (containsElement(body)) input.lowerer.error(root.ctx, root.node, "sms-markup", "An SMS body is plain text, and this one contains an element.", "Write the message as text and bindings; use a newline in the text for a line break.");
+	if (input.schema !== void 0) input.checks.push(...checkBindings(input.schema, body, []));
+	return {
+		...category === void 0 ? {} : { category },
+		body
+	};
+};
+const staticLength = (value) => {
+	if (typeof value === "string") return value.length;
+	if (typeof value === "number") return String(value).length;
+	if (typeof value === "object" && value !== null && "concat" in value) return value.concat.reduce((total, part) => total + staticLength(part), 0);
+	return 0;
+};
+const ZERO = {
+	url: 0,
+	phone: 0,
+	quickReply: 0,
+	total: 0
+};
+/** The most buttons of each kind any combination of the conditions can produce. */
+const maximalCounts = (nodes) => {
+	let counts = ZERO;
+	for (const node of nodes) {
+		let add;
+		if ("if" in node) {
+			const then = maximalCounts(node.then);
+			const otherwise = maximalCounts(node.else ?? []);
+			add = {
+				url: Math.max(then.url, otherwise.url),
+				phone: Math.max(then.phone, otherwise.phone),
+				quickReply: Math.max(then.quickReply, otherwise.quickReply),
+				total: Math.max(then.total, otherwise.total)
+			};
+		} else add = {
+			url: node.type === "url" ? 1 : 0,
+			phone: node.type === "phone" ? 1 : 0,
+			quickReply: node.type === "quick-reply" ? 1 : 0,
+			total: 1
+		};
+		counts = {
+			url: counts.url + add.url,
+			phone: counts.phone + add.phone,
+			quickReply: counts.quickReply + add.quickReply,
+			total: counts.total + add.total
+		};
+	}
+	return counts;
+};
+const buttonNodes = (buttons) => buttons.flatMap((button) => {
+	if ("if" in button) return [{
+		if: button.if,
+		then: buttonNodes(button.then),
+		...button.else === void 0 ? {} : { else: buttonNodes(button.else) },
+		...button.src === void 0 ? {} : { src: button.src }
+	}];
+	switch (button.type) {
+		case "quick-reply": return [button.text];
+		case "url": return [button.text, button.url];
+		case "phone": return [button.text, button.phone];
+		case "copy-code": return [button.code];
+	}
+});
+const whatsappChannel = (input, field) => {
+	const root = readRoot(input, field, "WhatsApp", "@samva/markup/whatsapp");
+	if (root === void 0) return void 0;
+	const { lowerer } = input;
+	const { ctx } = root;
+	const attributes = readAttributes(input, root, WHATSAPP_ATTRIBUTES);
+	for (const required of ["category", "language"]) if (!attributes.has(required)) lowerer.error(ctx, root.node, "missing-attribute", `<WhatsApp> needs \`${required}\`.`, required === "category" ? `Write category="utility" (${WHATSAPP_CATEGORIES.join(", ")}).` : "Write language=\"en_US\".");
+	const category = attributes.get("category");
+	const categoryNode = attributesOf(root.node).find((attribute) => text(child(attribute, "name") ?? attribute, "name") === "category");
+	if (category !== void 0 && categoryNode !== void 0 && !oneOf(input, root, categoryNode, "category", category, WHATSAPP_CATEGORIES)) return void 0;
+	const parts = /* @__PURE__ */ new Map();
+	for (const item of children(root.node, "children")) {
+		if (item.type === "JSXText") {
+			if ((text(item, "value") ?? "").trim() !== "") lowerer.error(ctx, item, "whatsapp-structure", "Text sits inside Header, Body, Footer or Buttons, not directly in <WhatsApp>.", "Move it into <WhatsApp.Body>.");
+			continue;
+		}
+		const tag = item.type === "JSXElement" ? tagOf(item) : "";
+		const part = tag.startsWith(`${root.local}.`) ? tag.slice(root.local.length + 1) : "";
+		if (![
+			"Header",
+			"Body",
+			"Footer",
+			"Buttons"
+		].includes(part)) {
+			lowerer.error(ctx, item, "whatsapp-structure", "<WhatsApp> holds <WhatsApp.Header>, <WhatsApp.Body>, <WhatsApp.Footer> and <WhatsApp.Buttons>.", "Wrap the content in one of them.");
+			continue;
+		}
+		if (parts.has(part)) {
+			lowerer.error(ctx, item, "whatsapp-structure", `<WhatsApp.${part}> appears twice.`, "A WhatsApp template has at most one of each part.");
+			continue;
+		}
+		parts.set(part, item);
+	}
+	const roots = [];
+	const lengthWarning = (part, node, length, limit) => {
+		if (length > limit) lowerer.findings.add(ctx.module.parsed, node, "whatsapp-length", `The ${part} is at least ${length} characters, and Meta allows ${limit}.`, `Shorten the ${part}.`, "warning");
+	};
+	/** A text part: literal text and values, no branching. */
+	const textPart = (name, node, limit) => {
+		const nodes = lowerer.jsxChildren(ctx, node);
+		if (!valueOnly(nodes)) {
+			lowerer.error(ctx, node, "whatsapp-conditional", `A WhatsApp ${name} cannot branch or contain elements: Meta registers its text once.`, "Choose the wording as a parameter in the payload, or write separate templates.");
+			return;
+		}
+		lengthWarning(name, node, nodes.reduce((total, part) => total + (isValueNode(part) ? staticLength(part) : 0), 0), limit);
+		roots.push(...nodes);
+		return nodes;
+	};
+	let header;
+	const headerNode = parts.get("Header");
+	if (headerNode !== void 0) {
+		const typeAttribute = attributesOf(headerNode).find((attribute) => text(child(attribute, "name") ?? attribute, "name") === "type");
+		const literal = typeAttribute === void 0 ? void 0 : child(typeAttribute, "value");
+		const raw = literal?.type === "JSXExpressionContainer" ? child(literal, "expression") : literal;
+		const typeValue = raw?.type === "StringLiteral" ? text(raw, "value") ?? "text" : "text";
+		if (typeAttribute !== void 0 && raw?.type !== "StringLiteral") lowerer.error(ctx, typeAttribute, "dynamic-expression", "`type` is fixed when the template is compiled, so it is a string literal.", "Write type=\"image\".");
+		else if (typeAttribute !== void 0 && !WHATSAPP_HEADER_TYPES.includes(typeValue)) lowerer.error(ctx, typeAttribute, "invalid-attribute", `\`${typeValue}\` is not a header type.`, `Use one of ${WHATSAPP_HEADER_TYPES.join(", ")}.`);
+		else {
+			const type = typeValue;
+			const content = textPart("header", headerNode, type === "text" ? HEADER_LIMIT : Infinity);
+			if (content !== void 0) {
+				if (type === "text") {
+					if (whatsappTemplate(content).params.length > 1) lowerer.error(ctx, headerNode, "whatsapp-header-variables", "A WhatsApp header text takes at most one variable.", "Keep one binding in the header and move the rest to the body.");
+				} else if (content.length !== 1) lowerer.error(ctx, headerNode, "whatsapp-header-media", `A ${type} header is one URL.`, "Write the media URL as the only child: a literal or one binding.");
+				header = {
+					type,
+					content
+				};
+			}
+		}
+	}
+	let body = [];
+	const bodyNode = parts.get("Body");
+	if (bodyNode === void 0) lowerer.error(ctx, root.node, "whatsapp-body-required", "A WhatsApp template needs a body.", "Add <WhatsApp.Body>…</WhatsApp.Body>.");
+	else {
+		const lowered = textPart("body", bodyNode, BODY_LIMIT);
+		body = lowered ?? [];
+		if (lowered !== void 0 && lowered.length === 0) lowerer.error(ctx, bodyNode, "whatsapp-body-required", "The WhatsApp body is empty.", "Write the message text.");
+	}
+	const footerNode = parts.get("Footer");
+	const footer = footerNode === void 0 ? void 0 : textPart("footer", footerNode, FOOTER_LIMIT);
+	const buttonPart = parts.get("Buttons");
+	const buttons = buttonPart === void 0 ? void 0 : buttonList(input, ctx, root.local, buttonPart);
+	if (buttons !== void 0) {
+		const counts = maximalCounts(buttons);
+		const over = (kind, count, limit) => {
+			if (count > limit) lowerer.error(ctx, buttonPart, "whatsapp-button-limit", `A WhatsApp template allows ${limit} ${kind}, and these conditions can produce ${count}.`, `Remove ${count - limit}, or split the template.`);
+		};
+		over("URL buttons", counts.url, URL_BUTTON_LIMIT);
+		over("phone buttons", counts.phone, PHONE_BUTTON_LIMIT);
+		over("quick-reply buttons", counts.quickReply, QUICK_REPLY_LIMIT);
+		over("buttons in all", counts.total, BUTTON_LIMIT);
+		roots.push(...buttonNodes(buttons));
+	}
+	if (input.schema !== void 0) input.checks.push(...checkBindings(input.schema, roots, []));
+	if (category === void 0 || !attributes.has("language")) return void 0;
+	const name = attributes.get("name");
+	return {
+		...name === void 0 ? {} : { name },
+		category,
+		language: attributes.get("language"),
+		...header === void 0 ? {} : { header },
+		body,
+		...footer === void 0 ? {} : { footer },
+		...buttons === void 0 ? {} : { buttons }
+	};
+};
+const BUTTON_TAGS = [
+	"UrlButton",
+	"QuickReplyButton",
+	"PhoneButton",
+	"CopyCodeButton"
+];
+const buttonList = (input, ctx, local, parent) => {
+	const { lowerer } = input;
+	const label = (element, what) => {
+		const nodes = lowerer.jsxChildren(ctx, element);
+		if (!valueOnly(nodes) || nodes.length === 0) {
+			lowerer.error(ctx, element, nodes.length === 0 ? "whatsapp-button-text" : "whatsapp-conditional", nodes.length === 0 ? `A button needs its ${what}.` : `A button ${what} cannot branch or contain elements.`, `Write the ${what} as text between the tags.`);
+			return;
+		}
+		const value = joinValues(nodes);
+		if (what === "label" && staticLength(value) > BUTTON_TEXT_LIMIT) lowerer.findings.add(ctx.module.parsed, element, "whatsapp-length", `The button label is at least ${staticLength(value)} characters, and Meta allows ${BUTTON_TEXT_LIMIT}.`, "Shorten the label.", "warning");
+		return value;
+	};
+	const attribute = (element, name) => {
+		const bindings = lowerer.attributeBindings(ctx, attributesOf(element));
+		if (bindings === void 0) return void 0;
+		const known = attributesOf(element).map((item) => text(child(item, "name") ?? item, "name"));
+		for (const item of known) if (item !== void 0 && item !== name && item !== "key") lowerer.error(ctx, element, "unknown-attribute", `\`${item}\` is not an attribute of this button.`, name === void 0 ? "Remove it." : `The attribute is ${name}.`);
+		if (name === void 0) return void 0;
+		const bound = bindings.get(name);
+		const value = bound === void 0 ? void 0 : bindingValue(bound);
+		if (value === void 0) lowerer.error(ctx, element, "missing-attribute", `This button needs \`${name}\`.`, `Write ${name}="…" or ${name}={input.field}.`);
+		return value;
+	};
+	const single = (element) => {
+		const tag = tagOf(element);
+		switch (tag.startsWith(`${local}.`) ? tag.slice(local.length + 1) : "") {
+			case "UrlButton": {
+				const url = attribute(element, "url");
+				const label_ = label(element, "label");
+				return url === void 0 || label_ === void 0 ? void 0 : {
+					type: "url",
+					text: label_,
+					url
+				};
+			}
+			case "PhoneButton": {
+				const phone = attribute(element, "phone");
+				const label_ = label(element, "label");
+				return phone === void 0 || label_ === void 0 ? void 0 : {
+					type: "phone",
+					text: label_,
+					phone
+				};
+			}
+			case "QuickReplyButton": {
+				attribute(element, void 0);
+				const label_ = label(element, "label");
+				return label_ === void 0 ? void 0 : {
+					type: "quick-reply",
+					text: label_
+				};
+			}
+			case "CopyCodeButton": {
+				const code = label(element, "code");
+				return code === void 0 ? void 0 : {
+					type: "copy-code",
+					code
+				};
+			}
+			default:
+				lowerer.error(ctx, element, "whatsapp-structure", `<WhatsApp.Buttons> holds ${BUTTON_TAGS.map((name) => `<WhatsApp.${name}>`).join(", ")}.`, "Use one of the button components.");
+				return;
+		}
+	};
+	const expression = (node) => {
+		const inner = unwrap(node);
+		switch (inner.type) {
+			case "JSXElement": {
+				const button = single(inner);
+				return button === void 0 ? [] : [button];
+			}
+			case "JSXFragment": return fragment(inner);
+			case "NullLiteral":
+			case "BooleanLiteral": return [];
+			case "LogicalExpression": {
+				const left = child(inner, "left");
+				const right = child(inner, "right");
+				if (text(inner, "operator") === "&&" && left !== void 0 && right !== void 0) {
+					const test = lowerer.predicate(ctx, left);
+					const then = expression(right);
+					return test === void 0 ? [] : [{
+						if: test,
+						then,
+						src: lowerer.src(ctx.module, inner)
+					}];
+				}
+				break;
+			}
+			case "ConditionalExpression": {
+				const test = child(inner, "test");
+				const consequent = child(inner, "consequent");
+				const alternate = child(inner, "alternate");
+				if (test === void 0 || consequent === void 0 || alternate === void 0) return [];
+				const predicate = lowerer.predicate(ctx, test);
+				const then = expression(consequent);
+				const otherwise = expression(alternate);
+				return predicate === void 0 ? [] : [{
+					if: predicate,
+					then,
+					...otherwise.length === 0 ? {} : { else: otherwise },
+					src: lowerer.src(ctx.module, inner)
+				}];
+			}
+		}
+		lowerer.error(ctx, inner, "dynamic-expression", "Buttons are fixed by the template, and this expression builds them at render time.", "List each button; wrap one in `condition && <WhatsApp.UrlButton … />` to make it optional.");
+		return [];
+	};
+	const fragment = (node) => {
+		const output = [];
+		for (const item of children(node, "children")) if (item.type === "JSXText") {
+			if ((text(item, "value") ?? "").trim() !== "") lowerer.error(ctx, item, "whatsapp-structure", "Text cannot sit between buttons.", "Put the label inside the button.");
+		} else if (item.type === "JSXExpressionContainer") {
+			const inner = child(item, "expression");
+			if (inner !== void 0 && inner.type !== "JSXEmptyExpression") output.push(...expression(inner));
+		} else output.push(...expression(item));
+		return output;
+	};
+	return fragment(parent);
+};
+const channelBodies = (input) => {
+	const smsField = input.fields.get("sms");
+	const whatsappField = input.fields.get("whatsapp");
+	const sms = smsField === void 0 ? void 0 : smsChannel(input, smsField);
+	const whatsapp = whatsappField === void 0 ? void 0 : whatsappChannel(input, whatsappField);
+	return {
+		...sms === void 0 ? {} : { sms },
+		...whatsapp === void 0 ? {} : { whatsapp }
+	};
+};
+//#endregion
+//#region src/sml/styles.ts
+const MAX_CLASS_VARIANTS = 8;
+const product = (left, right) => {
+	if ("leaf" in left) {
+		const prefix = left.leaf;
+		const prepend = (tree) => "leaf" in tree ? { leaf: prefix + tree.leaf } : {
+			pred: tree.pred,
+			then: prepend(tree.then),
+			else: prepend(tree.else)
+		};
+		return prepend(right);
+	}
+	return {
+		pred: left.pred,
+		then: product(left.then, right),
+		else: product(left.else, right)
+	};
+};
+const classTree = (value) => {
+	if (typeof value === "string") return { leaf: value };
+	if (typeof value !== "object" || value === null) return void 0;
+	if ("if" in value) {
+		const then = classTree(value.then);
+		const otherwise = classTree(value.else);
+		return then === void 0 || otherwise === void 0 ? void 0 : {
+			pred: value.if,
+			then,
+			else: otherwise
+		};
+	}
+	if ("concat" in value) {
+		let tree = { leaf: "" };
+		for (const part of value.concat) {
+			const next = classTree(part);
+			if (next === void 0) return void 0;
+			tree = product(tree, next);
+		}
+		return tree;
+	}
+};
+const leavesOf = (tree) => "leaf" in tree ? [tree.leaf] : [...leavesOf(tree.then), ...leavesOf(tree.else)];
+const mapTree = (tree, leafStyle, counter = { next: 0 }) => {
+	if ("leaf" in tree) return leafStyle(counter.next++);
+	const then = mapTree(tree.then, leafStyle, counter);
+	const otherwise = mapTree(tree.else, leafStyle, counter);
+	return JSON.stringify(then) === JSON.stringify(otherwise) ? then : {
+		if: tree.pred,
+		then,
+		else: otherwise
+	};
+};
+const collect = (nodes, into) => {
+	for (const node of nodes) {
+		if (isValueNode(node)) continue;
+		if ("el" in node) {
+			into.push({
+				kind: "el",
+				el: node
+			});
+			collect(node.children ?? [], into);
+		} else if ("if" in node) {
+			collect(node.then, into);
+			collect(node.else ?? [], into);
+		} else if ("each" in node) collect(node.children, into);
+		else if ("raw" in node) into.push({
+			kind: "raw",
+			raw: node
+		});
+	}
+};
+const rawHtml = (tokens, parts) => parts.map((part) => typeof part === "string" ? part : tokens.value("attr" in part ? part.attr : part.text)).join("");
+/** Resolve the sheet against a lowered tree and write each element's inline style. */
+const applyStyles = (root, sheet, options) => {
+	const items = [];
+	collect([root], items);
+	const tokens = new Tokens();
+	const trees = items.map((item) => {
+		if (item.kind !== "el") return void 0;
+		const value = item.el.attrs?.class;
+		if (value === void 0) return void 0;
+		const tree = classTree(value);
+		if (tree === void 0) return void 0;
+		return tree;
+	});
+	const leafCounts = trees.map((tree) => tree === void 0 ? 1 : leavesOf(tree).length);
+	for (const [index, count] of leafCounts.entries()) if (count > MAX_CLASS_VARIANTS) {
+		const item = items[index];
+		const at = item?.kind === "el" ? options.locate(item.el.src) : void 0;
+		options.report({
+			code: "too-many-class-variants",
+			severity: "error",
+			message: `This class list chooses between ${count} literal lists; the compiler resolves at most ${MAX_CLASS_VARIANTS}.`,
+			fix: "Split the choice into fewer conditions, or move part of it to a partial.",
+			origins: at === void 0 ? [] : [at]
+		});
+		return {
+			root,
+			headCss: "",
+			fontFaceCss: ""
+		};
+	}
+	const passes = Math.max(1, ...leafCounts);
+	const shadow = (nodes, pass, cursor) => nodes.flatMap((node) => {
+		if (isValueNode(node)) return [];
+		if ("el" in node) {
+			const index = cursor.next++;
+			const tree = trees[index];
+			const leaves = tree === void 0 ? void 0 : leavesOf(tree);
+			const props = {};
+			for (const [name, value] of Object.entries(node.attrs ?? {})) {
+				if (name === "class") continue;
+				if (typeof value === "string" || typeof value === "number") props[name] = value;
+				else if (typeof value === "object" && value !== null) props[name] = tokens.value(value);
+			}
+			if (leaves !== void 0) props.class = leaves[Math.min(pass, leaves.length - 1)];
+			else if (node.attrs?.class !== void 0) props.class = tokens.value(node.attrs.class);
+			const style = node.style;
+			if (Array.isArray(style)) {
+				const declared = {};
+				for (const [property, value] of style) {
+					if (value === null || typeof value === "boolean") continue;
+					declared[property] = typeof value === "number" ? value : tokens.value(value);
+				}
+				props.style = declared;
+			} else if (typeof style === "string" && style !== "") {
+				const declared = {};
+				for (const part of style.split(";")) {
+					const at = part.indexOf(":");
+					if (at > 0) declared[part.slice(0, at)] = part.slice(at + 1);
+				}
+				props.style = declared;
+			}
+			const at = options.locate(node.src);
+			return [EmailNode.Element({
+				tag: node.el,
+				props,
+				children: shadow(node.children ?? [], pass, cursor),
+				origins: at === void 0 ? [] : [at],
+				authored: true
+			})];
+		}
+		if ("if" in node) return [EmailNode.Fragment({ children: [...shadow(node.then, pass, cursor), ...shadow(node.else ?? [], pass, cursor)] })];
+		if ("each" in node) return [EmailNode.Fragment({ children: shadow(node.children, pass, cursor) })];
+		if ("raw" in node) {
+			cursor.next++;
+			return [EmailNode.Raw({
+				html: rawHtml(tokens, node.raw),
+				text: "",
+				origins: []
+			})];
+		}
+		return [];
+	});
+	const read = (nodes, into) => {
+		for (const node of nodes) if (node.type === "Fragment") read(node.children, into);
+		else if (node.type === "Raw") into.raws.push(node.html);
+		else if (node.type === "Element") {
+			into.styles.push(node.props.style === void 0 ? void 0 : node.props.style);
+			into.bgcolors.push(typeof node.props.bgcolor === "string" ? node.props.bgcolor : void 0);
+			read(node.children, into);
+		}
+	};
+	const results = [];
+	let headCss = "";
+	let fontFaceCss = "";
+	const seen = /* @__PURE__ */ new Set();
+	for (let pass = 0; pass < passes; pass++) {
+		const tree = shadow([root], pass, { next: 0 });
+		const applied = applyStylesheet(tree[0] ?? EmailNode.Fragment({ children: [] }), sheet);
+		if (pass === 0) {
+			headCss = applied.headCss;
+			fontFaceCss = applied.fontFaceCss;
+		}
+		for (const diagnostic of applied.diagnostics) {
+			const key = `${diagnostic.code}\0${diagnostic.message}`;
+			if (seen.has(key)) continue;
+			seen.add(key);
+			options.report(diagnostic);
+		}
+		const result = {
+			styles: [],
+			bgcolors: [],
+			raws: []
+		};
+		read([applied.tree], result);
+		results.push(result);
+	}
+	const styleOf = (declarations, element) => {
+		if (declarations === void 0) return "";
+		const entries = Object.entries(declarations);
+		if (entries.length === 0) return "";
+		const at = options.locate(element.src);
+		const dynamic = entries.some(([, value]) => value.includes(""));
+		const staticOnly = Object.fromEntries(entries.filter(([, value]) => !value.includes("")));
+		const checked = serializeStyle(staticOnly, at === void 0 ? [] : [at]);
+		for (const diagnostic of checked.diagnostics) options.report(diagnostic);
+		if (!dynamic) return checked.css;
+		return entries.map(([property, value]) => {
+			return [property, tokens.toValue(value) ?? value];
+		});
+	};
+	let cursor = 0;
+	let elementCursor = 0;
+	let rawCursor = 0;
+	const rebuild = (nodes) => nodes.map((node) => {
+		if (isValueNode(node)) return node;
+		if ("el" in node) {
+			const index = cursor++;
+			const ordinal = elementCursor++;
+			const tree = trees[index];
+			const first = results[0];
+			const baseStyle = first?.styles[ordinal];
+			const style = tree !== void 0 && leavesOf(tree).length > 1 ? mapTree(tree, (leaf) => styleOf(results[Math.min(leaf, results.length - 1)]?.styles[ordinal], node)) : styleOf(baseStyle, node);
+			const bgcolor = first?.bgcolors[ordinal];
+			const attrs = typeof node.attrs?.bgcolor === "string" && bgcolor !== void 0 && bgcolor !== node.attrs.bgcolor ? {
+				...node.attrs,
+				bgcolor: tokens.toValue(bgcolor) ?? bgcolor
+			} : node.attrs;
+			const kids = rebuild(node.children ?? []);
+			const { style: _authored, children: _children, attrs: _attrs, ...rest } = node;
+			return {
+				...rest,
+				...attrs === void 0 ? {} : { attrs },
+				...style === "" ? {} : { style },
+				...kids.length === 0 ? {} : { children: kids }
+			};
+		}
+		if ("if" in node) {
+			const then = rebuild(node.then);
+			const otherwise = rebuild(node.else ?? []);
+			return {
+				...node,
+				then,
+				...node.else === void 0 ? {} : { else: otherwise }
+			};
+		}
+		if ("each" in node) return {
+			...node,
+			children: rebuild(node.children)
+		};
+		if ("raw" in node) {
+			cursor++;
+			const html = results[0]?.raws[rawCursor++];
+			return html === void 0 ? node : {
+				...node,
+				raw: rawParts(tokens, html)
+			};
+		}
+		return node;
+	});
+	return {
+		root: rebuild([root])[0] ?? root,
+		headCss,
+		fontFaceCss
+	};
+};
+//#endregion
+//#region src/sml/lower-project.ts
+const ENTRY_CALL = "defineTemplate";
+const CHANNELS = [
+	"email",
+	"sms",
+	"whatsapp"
+];
+const readDefinition = (project, findings) => {
+	const module = project.entry;
+	let expression = module.defaultExport;
+	if (expression?.type === "Identifier") expression = module.declarations.get(text(expression, "name") ?? "")?.value;
+	const fail = (message, fix, code = "no-template") => {
+		findings.add(module.parsed, expression ?? module.parsed.program, code, message, fix);
+	};
+	if (expression === void 0 || expression.type !== "CallExpression") return fail("The entry must default-export defineTemplate({ ... }).", "Write `export default defineTemplate({ id, schema, fixtures, email })`.");
+	const callee = child(expression, "callee");
+	const name = callee === void 0 ? void 0 : text(callee, "name");
+	const imported = name === void 0 ? void 0 : module.imports.get(name);
+	if (name === "defineEmail") return fail("`defineEmail` runs a render function, which the static profile does not read.", "Use `defineTemplate` from @samva/markup with `email: { subject, preheader, body }`.", "legacy-definition");
+	if (imported?.kind !== "markup" || imported.imported !== ENTRY_CALL) return fail("The entry must default-export defineTemplate({ ... }) imported from @samva/markup.", "Add `import { defineTemplate } from \"@samva/markup\";`.");
+	const argument = children(expression, "arguments")[0];
+	const object = argument === void 0 ? void 0 : unwrap(argument);
+	if (object === void 0 || object.type !== "ObjectExpression") return fail("defineTemplate takes one object literal.", "Write defineTemplate({ id, schema, fixtures, email }).");
+	const fields = /* @__PURE__ */ new Map();
+	for (const property of children(object, "properties")) {
+		const key = keyOf(property);
+		const value = child(property, "value");
+		if (key === void 0 || value === void 0) {
+			findings.add(module.parsed, property, "dynamic-definition", "A definition field is written out, not spread or computed.", "Write each field as `name: value`.");
+			continue;
+		}
+		fields.set(key, value);
+	}
+	return {
+		module,
+		call: expression,
+		fields
+	};
+};
+/** A function written in place, or named and declared in the project. */
+const resolveFunction = (project, module, node) => {
+	const value = unwrap(node);
+	if (/Function/.test(value.type)) return {
+		module,
+		fn: value
+	};
+	if (value.type === "Identifier") {
+		const name = text(value, "name") ?? "";
+		const declared = module.declarations.get(name);
+		if (declared !== void 0) return resolveFunction(project, module, declared.value);
+		const imported = module.imports.get(name);
+		if (imported?.kind === "project") {
+			const target = project.modules.get(imported.path);
+			if (target === void 0) return void 0;
+			const local = imported.imported === "default" ? void 0 : target.exports.get(imported.imported);
+			if (imported.imported === "default" && target.defaultExport !== void 0) return resolveFunction(project, target, target.defaultExport);
+			const declaration = local === void 0 ? void 0 : target.declarations.get(local);
+			return declaration === void 0 ? void 0 : resolveFunction(project, target, declaration.value);
+		}
+	}
+};
+const stylesheetOrder = (project) => {
+	const order = [];
+	const visited = /* @__PURE__ */ new Set();
+	const visit = (module) => {
+		if (visited.has(module.path)) return;
+		visited.add(module.path);
+		for (const item of module.ordered) if (item.kind === "css") {
+			if (!order.includes(item.path)) order.push(item.path);
+		} else {
+			const target = project.modules.get(item.path);
+			if (target !== void 0) visit(target);
+		}
+	};
+	visit(project.entry);
+	return order;
+};
+/** Rebuild a tree with `edit` applied to the first element it matches. */
+const editFirst = (nodes, matches, edit) => {
+	let done = false;
+	const walk = (list) => list.map((node) => {
+		if (done || isValueNode(node)) return node;
+		if ("el" in node) {
+			if (matches(node)) {
+				done = true;
+				return edit(node);
+			}
+			return {
+				...node,
+				...node.children === void 0 ? {} : { children: walk(node.children) }
+			};
+		}
+		if ("if" in node) {
+			const then = walk(node.then);
+			const otherwise = walk(node.else ?? []);
+			return {
+				...node,
+				then,
+				...node.else === void 0 ? {} : { else: otherwise }
+			};
+		}
+		if ("each" in node) return {
+			...node,
+			children: walk(node.children)
+		};
+		return node;
+	});
+	return {
+		nodes: walk(nodes),
+		done
+	};
+};
+const HEAD_COMMENT_OPEN = { raw: ["<!--[if !mso]><!-->"] };
+const HEAD_COMMENT_CLOSE = { raw: ["<!--<![endif]-->"] };
+const completed = (findings, ir, fixtures = {}, assets = []) => ({
+	ir: findings.blocking ? void 0 : ir,
+	fixtures,
+	assets,
+	diagnostics: findings.items
+});
+/**
+* Lower a loaded project to IR: the part of the compile that reads structure and needs no Tailwind
+* or brand. `checkStaticProfile` runs it with empty stylesheets.
+*/
+const lowerProject = (options, project, findings, inputs) => {
+	const done = (ir, fixtures = {}, assets = inputs.assets) => completed(findings, ir, fixtures, assets);
+	const urlFor = inputs.urlFor;
+	const staticContext = {
+		project,
+		assetUrl: urlFor
+	};
+	const definition = readDefinition(project, findings);
+	if (definition === void 0) return done(void 0);
+	const { module, fields } = definition;
+	const at = (name) => fields.get(name) ?? definition.call;
+	const id = fields.has("id") ? readStatic(staticContext, module, fields.get("id")) : void 0;
+	if (id === void 0 || !id.ok || typeof id.value !== "string") findings.add(module.parsed, at("id"), "invalid-template-id", "The template id is a string literal.", "Write id: \"order-shipped\".");
+	else if (!TEMPLATE_ID_PATTERN.test(id.value)) findings.add(module.parsed, at("id"), "invalid-template-id", `Template id ${JSON.stringify(id.value)} is not lowercase kebab-case.`, "Write lowercase letters and digits joined by single hyphens, for example \"order-shipped\".");
+	const templateId = id !== void 0 && id.ok && typeof id.value === "string" ? id.value : "";
+	let schemaJson;
+	const schemaNode = fields.get("schema");
+	if (schemaNode === void 0) findings.add(module.parsed, definition.call, "missing-schema", "The template declares no schema.", "Add `schema: jsonSchema<Input>({ ... })`.");
+	else {
+		const read = readStatic(staticContext, module, schemaNode);
+		if (read.ok && typeof read.value === "object" && read.value !== null) schemaJson = read.value;
+		else if (options.schema !== void 0) schemaJson = { ...options.schema };
+		else findings.add(read.ok ? module.parsed : read.module.parsed, read.ok ? schemaNode : read.node, "schema-not-static", `The schema cannot be read without running it${read.ok ? "" : ` (${read.reason})`}.`, "Write the schema as a literal: `jsonSchema<Input>({ type: \"object\", properties: { … } })`, or compile with the schema a library already converted.");
+	}
+	let validate = () => true;
+	if (schemaJson !== void 0) try {
+		const converted = inputSchema(jsonSchema(schemaJson));
+		validate = converted.validate;
+		schemaJson = converted.schema;
+	} catch (error) {
+		if (!(error instanceof TypeError)) throw error;
+		findings.add(module.parsed, at("schema"), "invalid-schema", error.message, "Use only the JSON Schema keywords the README lists.");
+		schemaJson = void 0;
+	}
+	const fixtures = {};
+	const fixtureNode = fields.get("fixtures");
+	if (fixtureNode === void 0) findings.add(module.parsed, definition.call, "missing-fixtures", "The template declares no fixtures.", "Add `fixtures: { default: { … } }`.");
+	else {
+		const read = readStatic(staticContext, module, fixtureNode);
+		if (!read.ok) findings.add(read.module.parsed, read.node, "fixtures-not-static", `Fixtures are data, and this one is computed (${read.reason}).`, "Write each fixture as a literal object; an imported asset is allowed.");
+		else if (typeof read.value !== "object" || read.value === null || Object.keys(read.value).length === 0) findings.add(module.parsed, fixtureNode, "missing-fixtures", "The template declares no fixtures.", "Declare at least one: `fixtures: { default: { … } }`.");
+		else {
+			const object = unwrap(fixtureNode);
+			const locations = /* @__PURE__ */ new Map();
+			if (object.type === "ObjectExpression") for (const property of children(object, "properties")) {
+				const key = keyOf(property);
+				if (key !== void 0) locations.set(key, child(property, "key") ?? property);
+			}
+			for (const [name, value] of Object.entries(read.value)) {
+				if (!TEMPLATE_NAME_PATTERN.test(name)) {
+					findings.add(module.parsed, locations.get(name) ?? fixtureNode, "invalid-fixture-name", `Fixture key ${JSON.stringify(name)} is not one path segment.`, "Use letters, digits, `.`, `_` and `-`, starting with a letter or digit.");
+					continue;
+				}
+				fixtures[name] = value;
+				if (schemaJson !== void 0 && !validate(value)) {
+					const first = validate.errors?.at(-1) ?? validate.errors?.[0];
+					findings.add(module.parsed, locations.get(name) ?? fixtureNode, "fixture-invalid", `Fixture ${JSON.stringify(name)} does not match the schema${first === void 0 ? "" : `: ${first.instanceLocation === "#" || first.instanceLocation === void 0 ? "" : `${first.instanceLocation.replace(/^#/, "")} `}${first.error ?? "is invalid"}`}.`, "Change the fixture, or the schema, so a fixture is a payload a send could make.");
+				}
+			}
+		}
+	}
+	const localeRead = fields.has("locale") ? readStatic(staticContext, module, fields.get("locale")) : void 0;
+	const locale = localeRead?.ok === true && typeof localeRead.value === "string" ? localeRead.value : void 0;
+	if (fields.has("locale") && locale === void 0) findings.add(module.parsed, at("locale"), "invalid-locale", "The locale is a string literal.", "Write locale: \"en-US\".");
+	const lowerer = new Lowerer({
+		project,
+		findings,
+		staticContext,
+		assetUrl: urlFor,
+		brand: options.brand,
+		brand: options.brand,
+		channel: channelLowering
+	});
+	const rootContext = (target) => ({
+		module: target,
+		env: /* @__PURE__ */ new Map(),
+		stack: [],
+		loops: [],
+		depth: 0
+	});
+	/** Bind the function's parameter to the input and return the single expression it returns. */
+	const openFunction = (node) => {
+		const resolved = resolveFunction(project, module, node);
+		if (resolved === void 0) {
+			findings.add(module.parsed, node, "not-a-function", "A channel field is a function of the input, written in place or declared in the project.", "Write `(input) => …`.");
+			return;
+		}
+		const ctx = rootContext(resolved.module);
+		const env = /* @__PURE__ */ new Map();
+		const parameter = children(resolved.fn, "params")[0];
+		if (parameter !== void 0) lowerer.bindPattern(ctx, parameter, {
+			k: "path",
+			path: ""
+		}, env, false);
+		const scoped = {
+			...ctx,
+			env
+		};
+		const body = lowerer.functionExpression(scoped, resolved.fn);
+		return body === void 0 ? void 0 : {
+			ctx: scoped,
+			body
+		};
+	};
+	for (const name of fields.keys()) if (![
+		"id",
+		"schema",
+		"fixtures",
+		"locale",
+		...CHANNELS
+	].includes(name)) findings.add(module.parsed, at(name), "unknown-field", `\`${name}\` is not a defineTemplate field.`, "The fields are id, schema, fixtures, locale, email, sms and whatsapp.");
+	let ir;
+	const checks = [];
+	const emailField = fields.get("email");
+	let emailIr;
+	if (emailField !== void 0) {
+		const object = unwrap(emailField);
+		const parts = /* @__PURE__ */ new Map();
+		if (object.type === "ObjectExpression") for (const property of children(object, "properties")) {
+			const key = keyOf(property);
+			const value = child(property, "value");
+			if (key !== void 0 && value !== void 0) parts.set(key, value);
+		}
+		else findings.add(module.parsed, emailField, "invalid-channel", "The email channel is an object: `{ subject, preheader, body }`.", "Write email: { subject: …, body: … }.");
+		for (const key of parts.keys()) if (![
+			"subject",
+			"preheader",
+			"body"
+		].includes(key)) findings.add(module.parsed, parts.get(key), "unknown-field", `\`${key}\` is not an email field.`, "The fields are subject, preheader and body.");
+		const value = (name) => {
+			const node = parts.get(name);
+			if (node === void 0) return void 0;
+			const opened = openFunction(node);
+			return opened === void 0 ? void 0 : lowerer.value(opened.ctx, opened.body, false);
+		};
+		const subject = parts.has("subject") ? value("subject") : void 0;
+		if (!parts.has("subject") && object.type === "ObjectExpression") findings.add(module.parsed, emailField, "missing-subject", "The email channel needs a subject.", "Add `subject: (input) => …`.");
+		const preheader = value("preheader");
+		let body;
+		const bodyNode = parts.get("body");
+		if (bodyNode === void 0 && object.type === "ObjectExpression") findings.add(module.parsed, emailField, "missing-body", "The email channel needs a body.", "Add `body: (input) => (<Email>…</Email>)`.");
+		else if (bodyNode !== void 0) {
+			const opened = openFunction(bodyNode);
+			if (opened !== void 0) {
+				const nodes = lowerer.content(opened.ctx, opened.body);
+				if (nodes.length === 1) body = nodes[0];
+				else if (!findings.blocking) findings.add(opened.ctx.module.parsed, opened.body, "multiple-roots", nodes.length === 0 ? "The email body renders nothing." : "The email body renders more than one root.", "Wrap the body in a single element such as <Email>.");
+			}
+		}
+		if (subject !== void 0 && body !== void 0) {
+			const sheets = [];
+			if (inputs.tailwindSheet !== void 0) sheets.push(inputs.tailwindSheet);
+			for (const path of stylesheetOrder(project)) {
+				const sheet = inputs.stylesheets.get(path);
+				if (sheet !== void 0) sheets.push(sheet);
+			}
+			const sources = [options.entry, ...lowerer.sources];
+			const locate = (source) => {
+				if (source === void 0) return void 0;
+				return {
+					fileName: sources[source[2] ?? 0] ?? options.entry,
+					lineNumber: source[0],
+					columnNumber: source[1]
+				};
+			};
+			const styled = applyStyles(body, mergeStylesheets(sheets), {
+				locate,
+				report: (diagnostic) => {
+					findings.items.push(diagnostic);
+				}
+			});
+			let root = styled.root;
+			if (styled.headCss !== "" || styled.fontFaceCss !== "") {
+				const additions = [...styled.headCss === "" ? [] : [{
+					el: "style",
+					children: [styled.headCss]
+				}], ...styled.fontFaceCss === "" ? [] : [
+					HEAD_COMMENT_OPEN,
+					{
+						el: "style",
+						children: [styled.fontFaceCss]
+					},
+					HEAD_COMMENT_CLOSE
+				]];
+				const edited = editFirst([root], (element) => element.el === "head", (head) => ({
+					...head,
+					children: [...head.children ?? [], ...additions]
+				}));
+				if (!edited.done) findings.items.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.",
+					fix: "Wrap the message in <Email>, or write those declarations as inline styles.",
+					origins: []
+				});
+				else root = edited.nodes[0] ?? root;
+			}
+			if (preheader !== void 0) {
+				const edited = editFirst([root], (element) => element.el === "body", (bodyElement) => ({
+					...bodyElement,
+					children: [{ preheader: true }, ...bodyElement.children ?? []]
+				}));
+				if (!edited.done) findings.add(module.parsed, at("email"), "preheader-without-shell", "A preheader is the hidden inbox preview inside <body>, and this body has no <Email> shell.", "Wrap the body in <Email>.");
+				else root = edited.nodes[0] ?? root;
+			}
+			checkStructure([root], (finding) => checks.push(finding));
+			if (schemaJson !== void 0) checks.push(...checkBindings(schemaJson, [root], [subject, ...preheader === void 0 ? [] : [preheader]]));
+			emailIr = {
+				subject,
+				...preheader === void 0 ? {} : { preheader },
+				body: root
+			};
+		}
+	}
+	const channelIr = channelBodies({
+		lowerer,
+		findings,
+		fields,
+		module,
+		openFunction,
+		checks,
+		schema: schemaJson
+	});
+	const sources = [options.entry, ...lowerer.sources];
+	for (const finding of checks) {
+		const source = finding.src;
+		const file = sources[source?.[2] ?? 0] ?? options.entry;
+		findings.items.push({
+			code: finding.code,
+			severity: "error",
+			message: finding.message,
+			...finding.fix === void 0 ? {} : { fix: finding.fix },
+			origins: source === void 0 ? [{
+				fileName: options.entry,
+				lineNumber: 1,
+				columnNumber: 1
+			}] : [{
+				fileName: file,
+				lineNumber: source[0],
+				columnNumber: source[1]
+			}]
+		});
+	}
+	if (schemaJson !== void 0 && templateId !== "" && (emailIr !== void 0 || channelIr.sms !== void 0 || channelIr.whatsapp !== void 0)) ir = {
+		sml: 1,
+		template: templateId,
+		...locale === void 0 ? {} : { locale },
+		sources,
+		...emailIr === void 0 ? {} : { email: emailIr },
+		...channelIr.sms === void 0 ? {} : { sms: channelIr.sms },
+		...channelIr.whatsapp === void 0 ? {} : { whatsapp: channelIr.whatsapp },
+		schema: schemaJson
+	};
+	else if (emailField === void 0 && !fields.has("sms") && !fields.has("whatsapp")) findings.add(module.parsed, definition.call, "no-channel", "The template declares no channel.", "Add `email`, `sms` or `whatsapp`.");
+	return done(ir, fixtures);
+};
+//#endregion
+//#region src/sml/project.ts
+const MARKUP_SPECIFIER = "@samva/markup";
+const MARKUP_PREFIX = "@samva/markup/";
+/** Entries a template could import that moved; each is reported with its replacement. */
+const MOVED_MARKUP_ENTRIES = { "@samva/markup/email/components": "@samva/markup/email" };
+const SCRIPT_EXTENSIONS = [".tsx", ".ts"];
+/** Resolve a relative specifier to a project file, or `undefined`. */
+const resolveSpecifier = (from, specifier, files) => {
+	const base = resolveFromDirectory(projectDirectory(from), specifier.replace(/[?#].*$/, ""));
+	if (base === void 0) return void 0;
+	if (Object.hasOwn(files, base)) return base;
+	for (const extension of SCRIPT_EXTENSIONS) if (Object.hasOwn(files, `${base}${extension}`)) return `${base}${extension}`;
+	for (const extension of SCRIPT_EXTENSIONS) if (Object.hasOwn(files, `${base}/index${extension}`)) return `${base}/index${extension}`;
+};
+const isScriptPath = (path) => /\.[cm]?[jt]sx?$/.test(path);
+const declaredNames = (pattern) => pattern.type === "Identifier" ? [text(pattern, "name") ?? ""] : [];
+/** Load the entry and everything it imports from the project. */
+const loadProject = (files, entryPath, findings, loadOptions = {}) => {
+	const modules = /* @__PURE__ */ new Map();
+	const unresolved = /* @__PURE__ */ new Set();
+	const loading = /* @__PURE__ */ new Set();
+	let failed = false;
+	const load = (path) => {
+		const existing = modules.get(path);
+		if (existing !== void 0) return existing;
+		if (loading.has(path)) return void 0;
+		const raw = files[path];
+		if (raw === void 0) return void 0;
+		const source = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+		let parsed;
+		try {
+			parsed = parseSource(path, source);
+		} catch (error) {
+			if (!(error instanceof SourceSyntaxError)) throw error;
+			findings.items.push({
+				code: "syntax-error",
+				severity: "error",
+				message: error.message,
+				origins: [{
+					fileName: path,
+					lineNumber: error.line,
+					columnNumber: error.column
+				}]
+			});
+			failed = true;
+			return;
+		}
+		loading.add(path);
+		const imports = /* @__PURE__ */ new Map();
+		const ordered = [];
+		const declarations = /* @__PURE__ */ new Map();
+		const exports = /* @__PURE__ */ new Map();
+		let defaultExport;
+		const noteDeclaration = (node) => {
+			if (node.type === "VariableDeclaration") for (const declarator of children(node, "declarations")) {
+				const id = child(declarator, "id");
+				const init = child(declarator, "init");
+				if (id === void 0 || init === void 0) continue;
+				for (const name of declaredNames(id)) declarations.set(name, {
+					value: unwrap(init),
+					node
+				});
+			}
+			else if (node.type === "FunctionDeclaration") {
+				const name = text(child(node, "id") ?? node, "name");
+				if (name !== void 0) declarations.set(name, {
+					value: node,
+					node
+				});
+			}
+		};
+		for (const statement of children(parsed.program, "body")) switch (statement.type) {
+			case "ImportDeclaration": {
+				const specifier = text(child(statement, "source") ?? statement, "value") ?? "";
+				const typeOnly = text(statement, "importKind") === "type";
+				const specifiers = children(statement, "specifiers");
+				if (typeOnly) break;
+				const local = (node) => text(child(node, "local") ?? node, "name") ?? "";
+				const importedName = (node) => {
+					if (node.type === "ImportDefaultSpecifier") return "default";
+					if (node.type === "ImportNamespaceSpecifier") return "*";
+					const imported = child(node, "imported");
+					return imported === void 0 ? local(node) : text(imported, "name") ?? text(imported, "value") ?? local(node);
+				};
+				const moved = MOVED_MARKUP_ENTRIES[specifier];
+				if (moved !== void 0) {
+					findings.add(parsed, child(statement, "source") ?? statement, "moved-import", `\`${specifier}\` moved to \`${moved}\`; the imported names are unchanged.`, `Import from "${moved}".`);
+					failed = true;
+					break;
+				}
+				if (specifier === MARKUP_SPECIFIER || specifier.startsWith(MARKUP_PREFIX)) {
+					for (const item of specifiers) {
+						if (text(item, "importKind") === "type") continue;
+						imports.set(local(item), {
+							kind: "markup",
+							specifier,
+							imported: importedName(item),
+							node: item
+						});
+					}
+					break;
+				}
+				if (/^samva:brand(\/|$)/.test(specifier)) {
+					for (const item of specifiers) if (text(item, "importKind") !== "type") imports.set(local(item), {
+						kind: "brand",
+						specifier,
+						imported: importedName(item),
+						node: item
+					});
+					break;
+				}
+				if (!/^\.{0,2}\//.test(specifier)) {
+					findings.add(parsed, statement, "non-project-import", `\`${specifier}\` is not part of the project; templates import only @samva/markup and files inside the project.`, "Remove the import, or copy the code you need into a project file.");
+					failed = true;
+					break;
+				}
+				const resolved = resolveSpecifier(path, specifier, files);
+				if (resolved === void 0 && loadOptions.lenient === true) {
+					const missing = resolveFromDirectory(projectDirectory(path), specifier.replace(/[?#].*$/, ""));
+					const asset = missing !== void 0 && isAssetPath(missing);
+					const script = missing !== void 0 && (isScriptPath(missing) || !/\.[a-z0-9]+$/i.test(missing));
+					if (missing !== void 0 && (missing.endsWith(".css") || asset || script)) {
+						if (!missing.endsWith(".css")) for (const item of specifiers) if (asset) imports.set(local(item), {
+							kind: "asset",
+							path: missing,
+							node: item
+						});
+						else {
+							unresolved.add(local(item));
+							imports.set(local(item), {
+								kind: "project",
+								path: missing,
+								imported: importedName(item),
+								node: item
+							});
+						}
+						break;
+					}
+				}
+				if (resolved === void 0) {
+					findings.add(parsed, statement, "unresolved-import", `\`${specifier}\` names no file in the project.`, "Check the path and the file extension.");
+					failed = true;
+					break;
+				}
+				if (resolved.endsWith(".css")) {
+					ordered.push({
+						kind: "css",
+						path: resolved
+					});
+					break;
+				}
+				if (isAssetPath(resolved)) {
+					for (const item of specifiers) imports.set(local(item), {
+						kind: "asset",
+						path: resolved,
+						node: item
+					});
+					break;
+				}
+				if (isScriptPath(resolved)) {
+					ordered.push({
+						kind: "script",
+						path: resolved
+					});
+					for (const item of specifiers) imports.set(local(item), {
+						kind: "project",
+						path: resolved,
+						imported: importedName(item),
+						node: item
+					});
+					break;
+				}
+				findings.add(parsed, statement, "unresolved-import", `\`${specifier}\` is a file type templates cannot import.`, "Import a script, a stylesheet or an asset such as .png or .woff2.");
+				failed = true;
+				break;
+			}
+			case "ExportNamedDeclaration": {
+				const declaration = child(statement, "declaration");
+				if (declaration !== void 0) {
+					noteDeclaration(declaration);
+					if (declaration.type === "VariableDeclaration") for (const declarator of children(declaration, "declarations")) for (const name of declaredNames(child(declarator, "id") ?? declarator)) exports.set(name, name);
+					else if (declaration.type === "FunctionDeclaration") {
+						const name = text(child(declaration, "id") ?? declaration, "name");
+						if (name !== void 0) exports.set(name, name);
+					}
+				} else for (const item of children(statement, "specifiers")) {
+					const exported = child(item, "exported");
+					const localNode = child(item, "local");
+					const exportedName = exported === void 0 ? void 0 : text(exported, "name") ?? text(exported, "value");
+					const localName = localNode === void 0 ? void 0 : text(localNode, "name");
+					if (exportedName !== void 0 && localName !== void 0) exports.set(exportedName, localName);
+				}
+				break;
+			}
+			case "ExportDefaultDeclaration": {
+				const declaration = child(statement, "declaration");
+				if (declaration !== void 0) defaultExport = unwrap(declaration);
+				break;
+			}
+			case "VariableDeclaration":
+			case "FunctionDeclaration": noteDeclaration(statement);
+		}
+		const module = {
+			path,
+			parsed,
+			imports,
+			ordered,
+			declarations,
+			exports,
+			defaultExport
+		};
+		modules.set(path, module);
+		loading.delete(path);
+		for (const item of ordered) if (item.kind === "script") load(item.path);
+		return module;
+	};
+	const entry = load(entryPath);
+	if (entry === void 0 || failed) return void 0;
+	return {
+		modules,
+		entry,
+		unresolved
+	};
+};
+//#endregion
+//#region src/sml/profile.ts
+const DEFAULT_ENTRY = "template.tsx";
+/** Findings that come from the inputs this check leaves out, not from the source. */
+const MISSING_INPUT_CODES = /* @__PURE__ */ new Set(["brand-unavailable", "unmatched-class"]);
+const asFiles = (files, entry) => typeof files === "string" ? { [entry]: files } : files;
+/**
+* Check an entry against the static profile. Pass the entry's source alone, or the project's files
+* and the entry's path. Imports of files that are absent are trusted to exist, and the brand,
+* Tailwind and theme are not resolved, so the result holds only findings the source itself owns.
+*/
+const checkStaticProfile = (files, entry = DEFAULT_ENTRY) => {
+	const findings = new Findings();
+	const project = loadProject(asFiles(files, entry), entry, findings, { lenient: true });
+	if (project === void 0) return findings.items;
+	lowerProject({
+		entry,
+		brand: void 0
+	}, project, findings, {
+		assets: [],
+		stylesheets: /* @__PURE__ */ new Map(),
+		tailwindSheet: void 0,
+		urlFor: (path) => `https://assets.invalid/${path}`
+	});
+	const unresolved = [...project.unresolved];
+	return findings.items.filter((item) => !MISSING_INPUT_CODES.has(item.code) && !item.code.startsWith("tailwind-") && !unresolved.some((name) => item.message.includes(`<${name}`) || item.message.includes(`\`${name}\``)));
+};
+const key = (item) => `${item.code}\0${item.message}`;
+/**
+* The errors in `after` that `before` did not already have, compared by code and message so a
+* finding that only moved does not count as new.
+*/
+const introducedProfileErrors = (before, after) => {
+	const known = /* @__PURE__ */ new Map();
+	for (const item of before) if (item.severity === "error") known.set(key(item), (known.get(key(item)) ?? 0) + 1);
+	const added = [];
+	for (const item of after) {
+		if (item.severity !== "error") continue;
+		const remaining = known.get(key(item)) ?? 0;
+		if (remaining > 0) known.set(key(item), remaining - 1);
+		else added.push(item);
+	}
+	return added;
+};
+//#endregion
+export { lowerProject as a, WHATSAPP_HEADER_TYPES as c, parseBrandSpecifier as d, projectDirectory as f, completed as i, Findings as l, resolveThemeImports as m, introducedProfileErrors as n, SMS_CATEGORIES as o, resolveFromDirectory as p, loadProject as r, WHATSAPP_CATEGORIES as s, checkStaticProfile as t, BRAND_SPECIFIER as u };
+
+//# sourceMappingURL=profile-pWGtWZXF.js.map