@assistant-ui/react-generative-ui 0.0.6 → 0.0.8

package/dist/teams/decodeSubmitData.js

@@ -0,0 +1,44 @@
+//#region src/teams/decodeSubmitData.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Decodes the merged `activity.value` object a Teams bot receives on
+* Action.Submit, inverting the `aui` envelope {@link buildSubmitAction} nests
+* the resume action under. Adaptive Cards fold every other same-card input's
+* value into the same submit object keyed by its `id`, so every top-level key
+* besides `aui` is collected into `$input` (omitted when there are none).
+* `aui` is reserved for the envelope: `toAdaptiveCard` renames any input
+* whose id would collide to an unused id derived from it before encoding, so
+* a same-card input value can never land on this key. `$input` and `type`
+* are reserved on the way out: a `$input` key inside the envelope payload is
+* dropped so the slot only ever reflects same-card input values, and the
+* envelope's own `type` wins over a payload key of the same name. Every
+* collected key (in `payload` or `$input`) is kept as an own data property of
+* the returned object, even a `__proto__` or `constructor` key, since the
+* object is always built by spreading and `Object.fromEntries` rather than by
+* keyed assignment. Envelope keys are read as own properties only, so
+* prototype-inherited `aui`, `type`, or `payload` values never dispatch.
+* Returns `undefined` for a missing or malformed `aui` envelope; never throws.
+*/
+function decodeSubmitData(value) {
+	try {
+		if (!isRecord(value) || !Object.hasOwn(value, "aui")) return void 0;
+		const aui = value["aui"];
+		if (!isRecord(aui) || !Object.hasOwn(aui, "type") || typeof aui["type"] !== "string") return;
+		const type = aui["type"];
+		const payload = Object.hasOwn(aui, "payload") && isRecord(aui["payload"]) ? aui["payload"] : {};
+		const payloadEntries = Object.entries(payload).filter(([key]) => key !== "$input");
+		const inputEntries = Object.entries(value).filter(([key]) => key !== "aui");
+		const input = inputEntries.length > 0 ? Object.fromEntries(inputEntries) : void 0;
+		return {
+			...Object.fromEntries(payloadEntries),
+			type,
+			...input !== void 0 ? { $input: input } : {}
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+export { decodeSubmitData };
+
+//# sourceMappingURL=decodeSubmitData.js.map

package/dist/teams/decodeSubmitData.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decodeSubmitData.js","names":[],"sources":["../../src/teams/decodeSubmitData.ts"],"sourcesContent":["import type { Action } from \"../ir\";\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\n/**\n * Decodes the merged `activity.value` object a Teams bot receives on\n * Action.Submit, inverting the `aui` envelope {@link buildSubmitAction} nests\n * the resume action under. Adaptive Cards fold every other same-card input's\n * value into the same submit object keyed by its `id`, so every top-level key\n * besides `aui` is collected into `$input` (omitted when there are none).\n * `aui` is reserved for the envelope: `toAdaptiveCard` renames any input\n * whose id would collide to an unused id derived from it before encoding, so\n * a same-card input value can never land on this key. `$input` and `type`\n * are reserved on the way out: a `$input` key inside the envelope payload is\n * dropped so the slot only ever reflects same-card input values, and the\n * envelope's own `type` wins over a payload key of the same name. Every\n * collected key (in `payload` or `$input`) is kept as an own data property of\n * the returned object, even a `__proto__` or `constructor` key, since the\n * object is always built by spreading and `Object.fromEntries` rather than by\n * keyed assignment. Envelope keys are read as own properties only, so\n * prototype-inherited `aui`, `type`, or `payload` values never dispatch.\n * Returns `undefined` for a missing or malformed `aui` envelope; never throws.\n */\nexport function decodeSubmitData(value: unknown): Action | undefined {\n  try {\n    if (!isRecord(value) || !Object.hasOwn(value, \"aui\")) return undefined;\n    const aui = value[\"aui\"];\n    if (\n      !isRecord(aui) ||\n      !Object.hasOwn(aui, \"type\") ||\n      typeof aui[\"type\"] !== \"string\"\n    ) {\n      return undefined;\n    }\n    const type = aui[\"type\"];\n\n    const payload =\n      Object.hasOwn(aui, \"payload\") && isRecord(aui[\"payload\"])\n        ? aui[\"payload\"]\n        : {};\n    const payloadEntries = Object.entries(payload).filter(\n      ([key]) => key !== \"$input\",\n    );\n    const inputEntries = Object.entries(value).filter(([key]) => key !== \"aui\");\n    const input =\n      inputEntries.length > 0 ? Object.fromEntries(inputEntries) : undefined;\n\n    return {\n      ...Object.fromEntries(payloadEntries),\n      type,\n      ...(input !== undefined ? { $input: input } : {}),\n    };\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":";AAEA,MAAM,YAAY,UAChB,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,KAAK;;;;;;;;;;;;;;;;;;;;AAqBrE,SAAgB,iBAAiB,OAAoC;CACnE,IAAI;EACF,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,OAAO,OAAO,OAAO,KAAK,GAAG,OAAO,KAAA;EAC7D,MAAM,MAAM,MAAM;EAClB,IACE,CAAC,SAAS,GAAG,KACb,CAAC,OAAO,OAAO,KAAK,MAAM,KAC1B,OAAO,IAAI,YAAY,UAEvB;EAEF,MAAM,OAAO,IAAI;EAEjB,MAAM,UACJ,OAAO,OAAO,KAAK,SAAS,KAAK,SAAS,IAAI,UAAU,IACpD,IAAI,aACJ,CAAC;EACP,MAAM,iBAAiB,OAAO,QAAQ,OAAO,CAAC,CAAC,QAC5C,CAAC,SAAS,QAAQ,QACrB;EACA,MAAM,eAAe,OAAO,QAAQ,KAAK,CAAC,CAAC,QAAQ,CAAC,SAAS,QAAQ,KAAK;EAC1E,MAAM,QACJ,aAAa,SAAS,IAAI,OAAO,YAAY,YAAY,IAAI,KAAA;EAE/D,OAAO;GACL,GAAG,OAAO,YAAY,cAAc;GACpC;GACA,GAAI,UAAU,KAAA,IAAY,EAAE,QAAQ,MAAM,IAAI,CAAC;EACjD;CACF,QAAQ;EACN;CACF;AACF"}

package/dist/teams/toAdaptiveCard.d.ts

@@ -0,0 +1,39 @@
+import { NormalizedUIElement, NormalizedUINode } from "../ir.js";
+import { AdaptiveCardResult, TeamsAdaptiveCard, TeamsCardElement, TeamsConversionWarning, ToAdaptiveCardOptions } from "./types.js";
+//#region src/teams/toAdaptiveCard.d.ts
+/** Shared mutable conversion state threaded through one top-level conversion. */
+interface ConversionContext {
+  readonly warnings: TeamsConversionWarning[];
+  usedInputIds: Set<string>;
+}
+declare function convertElement(element: NormalizedUIElement, context: ConversionContext, depth: number): TeamsCardElement[];
+/**
+ * Walks a normalized sequence into card body elements. Nested arrays are
+ * flattened into one flat sibling sequence first (via {@link normalizedList}),
+ * so a `Divider`/`Fact`/`Button` run merges correctly even when the model
+ * wrapped some of its siblings in their own array. Consecutive `Fact`
+ * siblings merge into one FactSet and consecutive `Button` siblings merge
+ * into one ActionSet; a `Divider`/`Spacer` emits nothing itself but sets
+ * `separator`/`spacing` on the next emitted sibling (a trailing or orphan
+ * one is dropped silently, since there is no sibling left to carry it).
+ * `depth` advances by exactly one per element-nesting level: this call does
+ * not itself add a level, since flattening a sibling array or converting a
+ * sibling element is not a descent; only a container's own recursive
+ * `convertSequence(children, depth + 1)` call is.
+ */
+declare function convertSequence(node: NormalizedUINode | undefined, context: ConversionContext, depth: number): TeamsCardElement[];
+/** Builds a full card (schema envelope plus body) from an already-normalized root, checking the soft payload budget. */
+declare function convertRootToCard(root: NormalizedUINode | readonly NormalizedUINode[], context: ConversionContext): TeamsAdaptiveCard;
+/**
+ * Converts a generative-ui tree into a Microsoft Teams Adaptive Card and
+ * non-fatal downgrade warnings. Sizes, weights, and colors map to Adaptive
+ * Card's semantic enums rather than raw values. An Input/Select/RadioGroup/
+ * Checkbox/DatePicker whose id would be the reserved {@link RESERVED_INPUT_ID}
+ * is renamed with a warning (see `decodeSubmitData`). Never throws: an
+ * unknown `$type` is skipped with a "dropped" warning, and a malformed input
+ * resolves to an empty card plus a "dropped" warning instead of throwing.
+ */
+declare function toAdaptiveCard(node: unknown, _options?: ToAdaptiveCardOptions): AdaptiveCardResult;
+//#endregion
+export { ConversionContext, convertElement, convertRootToCard, convertSequence, toAdaptiveCard };
+//# sourceMappingURL=toAdaptiveCard.d.ts.map

package/dist/teams/toAdaptiveCard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toAdaptiveCard.d.ts","names":[],"sources":["../../src/teams/toAdaptiveCard.ts"],"mappings":";;;;UAsCiB;WACN,UAAU;EACnB,cAAc;;iBAuTA,eACd,SAAS,qBACT,SAAS,mBACT,gBACC;;;;;;;;;;;;;;;iBAkRa,gBACd,MAAM,8BACN,SAAS,mBACT,gBACC;;iBA0Ea,kBACd,MAAM,4BAA4B,oBAClC,SAAS,oBACR;;;;;;;;;;iBAyBa,eACd,eACA,WAAW,wBACV"}

package/dist/teams/toAdaptiveCard.js

@@ -0,0 +1,496 @@
+import { normalizeSpec } from "../ir.js";
+import { buildCard, buildSubmitAction, clampReasonDetail, utf8ByteLength } from "./constants.js";
+import { boundSpec } from "./boundSpec.js";
+//#region src/teams/toAdaptiveCard.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isElement = (node) => isRecord(node);
+const asString = (value) => typeof value === "string" ? value : "";
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const SUBTLE_COLORS = /* @__PURE__ */ new Set([
+	"secondary",
+	"alpha-70",
+	"white",
+	"white-70",
+	"white-50"
+]);
+const isSubtleColor = (color) => typeof color === "string" && SUBTLE_COLORS.has(color);
+const BOLDER_WEIGHTS = /* @__PURE__ */ new Set([
+	"medium",
+	"semibold",
+	"bold"
+]);
+const isBolderWeight = (weight) => typeof weight === "string" && BOLDER_WEIGHTS.has(weight);
+const TEXT_SIZE_MAP = {
+	sm: "small",
+	lg: "medium",
+	xl: "large",
+	"2xl": "extraLarge",
+	"3xl": "extraLarge"
+};
+const warn = (context, code, component, detail) => {
+	context.warnings.push({
+		code,
+		component,
+		detail
+	});
+};
+/**
+* The `aui` key is reserved for the submit envelope (see
+* {@link buildSubmitData} and `decodeSubmitData`): Adaptive Cards merge
+* every input's current value into the same submit object keyed by its
+* `id`, so an input id of `aui` would clobber the envelope. Renamed to an
+* unused id derived from `aui_` instead of being emitted as-is.
+*/
+const RESERVED_INPUT_ID = "aui";
+function reservedSafeId(id, component, context) {
+	const reserved = id === RESERVED_INPUT_ID;
+	const base = reserved ? `${RESERVED_INPUT_ID}_` : id;
+	let candidate = base;
+	let n = 2;
+	while (context.usedInputIds.has(candidate)) {
+		candidate = `${base}_${n}`;
+		n += 1;
+	}
+	if (reserved) warn(context, "clamped", component, `the input id "${RESERVED_INPUT_ID}" collides with the submit envelope's reserved key and was renamed to "${candidate}".`);
+	else if (candidate !== base) warn(context, "clamped", component, `the input id "${base}" was already used on this card and was renamed to "${candidate}".`);
+	context.usedInputIds.add(candidate);
+	return candidate;
+}
+/**
+* The shared bounded-iteration primitive: slices `value` to `cap` entries
+* without ever reading past that many indices, so a hostile array (sparse or
+* proxied with a fabricated `length`) cannot stall the event loop.
+*/
+const clampArray = (value, cap) => {
+	if (!Array.isArray(value)) return {
+		items: [],
+		truncated: false
+	};
+	return {
+		items: value.slice(0, cap),
+		truncated: value.length > cap
+	};
+};
+const normalizedList = (node) => {
+	if (node === void 0 || node === null) return [];
+	if (!Array.isArray(node)) return [node];
+	return node.flatMap((child) => normalizedList(child));
+};
+function textBlock(text, extra) {
+	return {
+		type: "TextBlock",
+		text,
+		wrap: true,
+		...extra
+	};
+}
+function applyPending(element, separator, spacing) {
+	if (!separator && !spacing) return element;
+	return {
+		...element,
+		...separator ? { separator: true } : {},
+		...spacing ? { spacing: "large" } : {}
+	};
+}
+const toChoice = (option) => {
+	if (!isRecord(option) || typeof option["value"] !== "string") return;
+	return {
+		title: asString(option["label"]),
+		value: option["value"]
+	};
+};
+const choicesFrom = (optionsProp, component, context) => {
+	const { items, truncated } = clampArray(optionsProp, 100);
+	if (truncated) warn(context, "clamped", component, `options were clamped to 100 entries.`);
+	const choices = [];
+	for (const item of items) {
+		const choice = toChoice(item);
+		if (choice !== void 0) choices.push(choice);
+	}
+	return choices;
+};
+function convertFacts(facts) {
+	return {
+		type: "FactSet",
+		facts: facts.map((fact) => ({
+			title: asString(fact.props["label"]),
+			value: asString(fact.props["value"])
+		}))
+	};
+}
+function convertButtons(buttons, context) {
+	if (buttons.length > 6) warn(context, "clamped", "Button", `actions beyond 6 were set to secondary mode.`);
+	return {
+		type: "ActionSet",
+		actions: buttons.map((button, index) => buildSubmitAction(asString(button.props["label"]), button.action, index >= 6 ? "secondary" : void 0))
+	};
+}
+function withCompanionSubmit(element, input, context) {
+	if (element.action === void 0) return [input];
+	warn(context, "fallback", element.type, "Teams inputs cannot dispatch on change; a companion submit action was appended.");
+	return [input, {
+		type: "ActionSet",
+		actions: [buildSubmitAction("Submit", element.action)]
+	}];
+}
+function cardFooterActionSet(props) {
+	const actions = ["confirm", "cancel"].map((key) => props[key]).filter(isRecord).map((footer) => buildSubmitAction(asString(footer["label"]), footer["$action"]));
+	return actions.length > 0 ? {
+		type: "ActionSet",
+		actions
+	} : void 0;
+}
+const ALERT_STYLE_MAP = {
+	info: "accent",
+	success: "good",
+	warning: "warning",
+	danger: "attention"
+};
+const stringifyCell = (value) => {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return "";
+};
+function convertTable(props, context) {
+	const { items: rawColumns, truncated: columnsTruncated } = clampArray(props["columns"], 20);
+	const { items: rawRows, truncated: rowsTruncated } = clampArray(props["rows"], 100);
+	if (columnsTruncated) warn(context, "clamped", "Table", `columns were clamped to 20 entries.`);
+	if (rowsTruncated) warn(context, "clamped", "Table", `rows were clamped to 100 entries.`);
+	const hasColumns = rawColumns.length > 0;
+	const columns = rawColumns.map(() => ({ width: 1 }));
+	const headerRow = hasColumns ? {
+		type: "TableRow",
+		cells: rawColumns.map((column) => ({
+			type: "TableCell",
+			items: [textBlock(isRecord(column) ? asString(column["label"]) : "")]
+		}))
+	} : void 0;
+	const dataRows = rawRows.map((row) => ({
+		type: "TableRow",
+		cells: (Array.isArray(row) ? row.slice(0, 20) : []).map((cell) => ({
+			type: "TableCell",
+			items: [textBlock(stringifyCell(cell))]
+		}))
+	}));
+	return {
+		type: "Table",
+		firstRowAsHeaders: hasColumns,
+		columns,
+		rows: headerRow !== void 0 ? [headerRow, ...dataRows] : dataRows
+	};
+}
+function convertListViewItem(element, context, depth) {
+	const items = convertSequence(element.children, context, depth + 1);
+	const selectAction = isRecord(element.action) ? buildSubmitAction("Open", element.action) : void 0;
+	return {
+		type: "Container",
+		items,
+		...selectAction !== void 0 ? { selectAction } : {}
+	};
+}
+function convertElement(element, context, depth) {
+	const { props } = element;
+	switch (element.type) {
+		case "Header": return [textBlock(asString(props["text"]), {
+			size: "large",
+			weight: "bolder",
+			style: "heading"
+		})];
+		case "Text": {
+			const mappedSize = typeof props["size"] === "string" ? TEXT_SIZE_MAP[props["size"]] : void 0;
+			return [textBlock(asString(props["value"]), {
+				...mappedSize !== void 0 ? { size: mappedSize } : {},
+				...isBolderWeight(props["weight"]) ? { weight: "bolder" } : {},
+				...isSubtleColor(props["color"]) ? { isSubtle: true } : {}
+			})];
+		}
+		case "Caption": return [textBlock(asString(props["value"]), {
+			size: "small",
+			isSubtle: true
+		})];
+		case "Badge": return [textBlock(asString(props["value"]), {
+			size: "small",
+			isSubtle: true
+		})];
+		case "Markdown": return [textBlock(asString(props["value"]))];
+		case "Fact": return [convertFacts([element])];
+		case "Image": {
+			const size = props["size"];
+			let mappedSize;
+			if (size === "sm") mappedSize = "small";
+			else if (size === "md") mappedSize = "medium";
+			else if (size === "lg") mappedSize = "large";
+			else if (typeof size === "number") warn(context, "dropped", "Image", "A numeric size was dropped.");
+			return [{
+				type: "Image",
+				url: asString(props["src"]),
+				altText: asString(props["alt"]),
+				...mappedSize !== void 0 ? { size: mappedSize } : {}
+			}];
+		}
+		case "Divider":
+		case "Spacer":
+		case "Icon": return [];
+		case "Button": return [convertButtons([element], context)];
+		case "Select": {
+			const name = asString(props["name"]);
+			const placeholder = asString(props["placeholder"]);
+			const label = asString(props["label"]);
+			return withCompanionSubmit(element, {
+				type: "Input.ChoiceSet",
+				id: reservedSafeId(name || "select", "Select", context),
+				style: "compact",
+				choices: choicesFrom(props["options"], "Select", context),
+				...placeholder ? { placeholder } : {},
+				...label ? { label } : {}
+			}, context);
+		}
+		case "RadioGroup": {
+			const name = asString(props["name"]);
+			const label = asString(props["label"]);
+			const defaultValue = props["defaultValue"];
+			return withCompanionSubmit(element, {
+				type: "Input.ChoiceSet",
+				id: reservedSafeId(name || "radiogroup", "RadioGroup", context),
+				style: "expanded",
+				choices: choicesFrom(props["options"], "RadioGroup", context),
+				...typeof defaultValue === "string" && defaultValue ? { value: defaultValue } : {},
+				...label ? { label } : {}
+			}, context);
+		}
+		case "Checkbox": {
+			const name = asString(props["name"]);
+			const label = asString(props["label"]);
+			return withCompanionSubmit(element, {
+				type: "Input.Toggle",
+				id: reservedSafeId(name || label || "checkbox", "Checkbox", context),
+				title: label,
+				value: props["defaultChecked"] === true ? "true" : "false",
+				valueOn: "true",
+				valueOff: "false"
+			}, context);
+		}
+		case "Input": {
+			const name = asString(props["name"]);
+			const label = asString(props["label"]);
+			const placeholder = asString(props["placeholder"]);
+			return withCompanionSubmit(element, {
+				type: "Input.Text",
+				id: reservedSafeId(name || "input", "Input", context),
+				...label ? { label } : {},
+				...placeholder ? { placeholder } : {},
+				...props["multiline"] === true ? { isMultiline: true } : {}
+			}, context);
+		}
+		case "DatePicker": {
+			const name = asString(props["name"]);
+			const label = asString(props["label"]);
+			const rawValue = props["value"];
+			const value = typeof rawValue === "string" && DATE_PATTERN.test(rawValue) ? rawValue : void 0;
+			const rawMin = props["min"];
+			const min = typeof rawMin === "string" && DATE_PATTERN.test(rawMin) ? rawMin : void 0;
+			const rawMax = props["max"];
+			const max = typeof rawMax === "string" && DATE_PATTERN.test(rawMax) ? rawMax : void 0;
+			return withCompanionSubmit(element, {
+				type: "Input.Date",
+				id: reservedSafeId(name || "datepicker", "DatePicker", context),
+				...label ? { label } : {},
+				...value !== void 0 ? { value } : {},
+				...min !== void 0 ? { min } : {},
+				...max !== void 0 ? { max } : {}
+			}, context);
+		}
+		case "Form": return [...convertSequence(element.children, context, depth + 1), {
+			type: "ActionSet",
+			actions: [buildSubmitAction("Submit", element.action)]
+		}];
+		case "Card": {
+			const titleText = asString(props["title"]);
+			const items = [];
+			if (titleText) items.push(textBlock(titleText, {
+				size: "large",
+				weight: "bolder",
+				style: "heading"
+			}));
+			items.push(...convertSequence(element.children, context, depth + 1));
+			const container = {
+				type: "Container",
+				style: "default",
+				items
+			};
+			const actionSet = cardFooterActionSet(props);
+			return actionSet !== void 0 ? [container, actionSet] : [container];
+		}
+		case "Col":
+		case "Box": return [{
+			type: "Container",
+			items: convertSequence(element.children, context, depth + 1)
+		}];
+		case "Row": {
+			const children = normalizedList(element.children);
+			if (children.length > 3) warn(context, "clamped", "Row", "Teams recommends at most 3 columns.");
+			return [{
+				type: "ColumnSet",
+				columns: children.map((child) => ({
+					type: "Column",
+					width: "auto",
+					items: convertSequence(child, context, depth + 1)
+				}))
+			}];
+		}
+		case "ListView": {
+			const containers = [];
+			for (const child of normalizedList(element.children)) {
+				if (!isElement(child)) continue;
+				if (child.type === "ListViewItem") containers.push(convertListViewItem(child, context, depth + 1));
+				else convertElement(child, context, depth + 1);
+			}
+			return containers.map((container, index) => index > 0 ? {
+				...container,
+				separator: true
+			} : container);
+		}
+		case "ListViewItem": return [convertListViewItem(element, context, depth)];
+		case "Table": return [convertTable(props, context)];
+		case "Alert": {
+			const tone = props["tone"];
+			const style = typeof tone === "string" ? ALERT_STYLE_MAP[tone] ?? "default" : "default";
+			const titleText = asString(props["title"]);
+			const description = asString(props["description"]);
+			const items = [];
+			if (titleText) items.push(textBlock(titleText, { weight: "bolder" }));
+			if (description) items.push(textBlock(description));
+			return [{
+				type: "Container",
+				style,
+				items
+			}];
+		}
+		case "Carousel":
+			warn(context, "fallback", "Carousel", "A carousel was rendered as sequential cards because it is not at the root.");
+			return normalizedList(element.children).filter((child) => isElement(child) && child.type === "Card").flatMap((card) => convertElement(card, context, depth + 1));
+		case "Chart":
+			warn(context, "dropped", "Chart", "Chart was replaced by a Teams omission note.");
+			return [textBlock("Chart omitted on Teams.", {
+				isSubtle: true,
+				size: "small"
+			})];
+		default:
+			warn(context, "dropped", element.type, "Unknown component type was dropped.");
+			return [];
+	}
+}
+/**
+* Walks a normalized sequence into card body elements. Nested arrays are
+* flattened into one flat sibling sequence first (via {@link normalizedList}),
+* so a `Divider`/`Fact`/`Button` run merges correctly even when the model
+* wrapped some of its siblings in their own array. Consecutive `Fact`
+* siblings merge into one FactSet and consecutive `Button` siblings merge
+* into one ActionSet; a `Divider`/`Spacer` emits nothing itself but sets
+* `separator`/`spacing` on the next emitted sibling (a trailing or orphan
+* one is dropped silently, since there is no sibling left to carry it).
+* `depth` advances by exactly one per element-nesting level: this call does
+* not itself add a level, since flattening a sibling array or converting a
+* sibling element is not a descent; only a container's own recursive
+* `convertSequence(children, depth + 1)` call is.
+*/
+function convertSequence(node, context, depth) {
+	if (node === void 0 || node === null || depth > 64) return [];
+	const nodes = normalizedList(node);
+	const items = [];
+	let pendingSeparator = false;
+	let pendingSpacing = false;
+	const emit = (converted) => {
+		const [first, ...rest] = converted;
+		if (first === void 0) return;
+		items.push(applyPending(first, pendingSeparator, pendingSpacing), ...rest);
+		pendingSeparator = false;
+		pendingSpacing = false;
+	};
+	for (let index = 0; index < nodes.length;) {
+		const current = nodes[index];
+		if (current === void 0 || current === null) {
+			index += 1;
+			continue;
+		}
+		if (isElement(current) && current.type === "Divider") {
+			pendingSeparator = true;
+			index += 1;
+			continue;
+		}
+		if (isElement(current) && current.type === "Spacer") {
+			pendingSpacing = true;
+			index += 1;
+			continue;
+		}
+		if (isElement(current) && current.type === "Fact") {
+			const facts = [];
+			while (index < nodes.length) {
+				const candidate = nodes[index];
+				if (!candidate || !isElement(candidate) || candidate.type !== "Fact") break;
+				facts.push(candidate);
+				index += 1;
+			}
+			emit([convertFacts(facts)]);
+			continue;
+		}
+		if (isElement(current) && current.type === "Button") {
+			const buttons = [];
+			while (index < nodes.length) {
+				const candidate = nodes[index];
+				if (!candidate || !isElement(candidate) || candidate.type !== "Button") break;
+				buttons.push(candidate);
+				index += 1;
+			}
+			emit([convertButtons(buttons, context)]);
+			continue;
+		}
+		if (typeof current === "string" || typeof current === "number") emit([textBlock(String(current))]);
+		else emit(convertElement(current, context, depth));
+		index += 1;
+	}
+	return items;
+}
+/** Builds a full card (schema envelope plus body) from an already-normalized root, checking the soft payload budget. */
+function convertRootToCard(root, context) {
+	context.usedInputIds = /* @__PURE__ */ new Set();
+	const card = buildCard(convertSequence(root, context, 0));
+	const size = utf8ByteLength(JSON.stringify(card));
+	if (size > 8e4) warn(context, "clamped", "Root", `the card is ${size} bytes, exceeding Teams' 100 KB bot message limit.`);
+	return card;
+}
+/**
+* Converts a generative-ui tree into a Microsoft Teams Adaptive Card and
+* non-fatal downgrade warnings. Sizes, weights, and colors map to Adaptive
+* Card's semantic enums rather than raw values. An Input/Select/RadioGroup/
+* Checkbox/DatePicker whose id would be the reserved {@link RESERVED_INPUT_ID}
+* is renamed with a warning (see `decodeSubmitData`). Never throws: an
+* unknown `$type` is skipped with a "dropped" warning, and a malformed input
+* resolves to an empty card plus a "dropped" warning instead of throwing.
+*/
+function toAdaptiveCard(node, _options) {
+	const context = {
+		warnings: [],
+		usedInputIds: /* @__PURE__ */ new Set()
+	};
+	try {
+		const { root } = normalizeSpec(boundSpec(node, (reason) => warn(context, "clamped", "Root", clampReasonDetail(reason))));
+		return {
+			card: convertRootToCard(root, context),
+			warnings: context.warnings
+		};
+	} catch {
+		return {
+			card: buildCard([]),
+			warnings: [{
+				code: "dropped",
+				component: "Root",
+				detail: "Input could not be converted."
+			}]
+		};
+	}
+}
+//#endregion
+export { convertElement, convertRootToCard, convertSequence, toAdaptiveCard };
+
+//# sourceMappingURL=toAdaptiveCard.js.map