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

package/dist/slack/toSlackBlocks.js

@@ -0,0 +1,649 @@
+import { normalizeSpec } from "../ir.js";
+import { CONTEXT_TEXT_CAP, DATA_TABLE_CHAR_BUDGET, FACT_FIELD_TEXT_CAP, INPUT_LABEL_CAP, MARKDOWN_TEXT_BUDGET, NODE_BUDGET, SECTION_TEXT_CAP, buildAlertBlock, buildAlertFallback, buildBlockBudgetNote, buildCardBlock, buildCarouselBlock, buildDataTableBlock } from "./constants.js";
+//#region src/slack/toSlackBlocks.ts
+const INTERACTIVE_TYPES = /* @__PURE__ */ new Set([
+	"Button",
+	"Select",
+	"DatePicker",
+	"Checkbox",
+	"RadioGroup"
+]);
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isElement = (node) => isRecord(node);
+const asString = (value) => typeof value === "string" ? value : "";
+const warn = (context, code, component, detail) => {
+	context.warnings.push({
+		code,
+		component,
+		detail
+	});
+};
+const clampText = (value, cap, component, field, context) => {
+	if (value.length <= cap) return value;
+	warn(context, "clamped", component, `${field} was clamped to ${cap} characters.`);
+	return value.slice(0, cap);
+};
+const asActionId = (action, component, context) => clampText(isRecord(action) && typeof action["type"] === "string" ? action["type"] : "action", 255, component, "action_id", context);
+const plainText = (text) => ({
+	type: "plain_text",
+	text
+});
+const actionValue = (action) => {
+	if (!isRecord(action)) return void 0;
+	const { type: _type, ...payload } = action;
+	if (Object.keys(payload).length === 0) return void 0;
+	try {
+		const serialized = JSON.stringify(payload);
+		return serialized === "{}" ? void 0 : serialized;
+	} catch {
+		return;
+	}
+};
+const buttonElement = (label, buttonStyle, action, component, context) => {
+	let value = actionValue(action);
+	if (value !== void 0 && value.length > 2e3) {
+		warn(context, "dropped", component, "value was dropped because the action payload was too large to round-trip.");
+		value = void 0;
+	}
+	const style = buttonStyle === "primary" || buttonStyle === "danger" ? buttonStyle : void 0;
+	return {
+		type: "button",
+		text: plainText(clampText(label, 75, component, "label", context)),
+		action_id: asActionId(action, component, context),
+		...value !== void 0 ? { value } : {},
+		...style !== void 0 ? { style } : {}
+	};
+};
+const optionFrom = (value, component, context) => {
+	if (!isRecord(value) || typeof value["label"] !== "string" || typeof value["value"] !== "string") return;
+	return {
+		text: plainText(clampText(value["label"], 75, component, "option label", context)),
+		value: value["value"]
+	};
+};
+const toActionElement = (element, context) => {
+	const { props, action } = element;
+	switch (element.type) {
+		case "Button": return buttonElement(asString(props["label"]), props["buttonStyle"], action, "Button", context);
+		case "Select": {
+			const rawOptions = Array.isArray(props["options"]) ? props["options"] : [];
+			if (rawOptions.length > 100) warn(context, "clamped", "Select", `options were clamped to 100 entries.`);
+			const options = rawOptions.slice(0, 100).map((option) => optionFrom(option, "Select", context)).filter((option) => option !== void 0);
+			const placeholder = clampText(asString(props["placeholder"]), 150, "Select", "placeholder", context);
+			return {
+				type: "static_select",
+				action_id: asActionId(action, "Select", context),
+				options,
+				...placeholder ? { placeholder: plainText(placeholder) } : {}
+			};
+		}
+		case "DatePicker": {
+			const rawDate = asString(props["value"]);
+			const initialDate = DATE_PATTERN.test(rawDate) ? rawDate : void 0;
+			if (rawDate && initialDate === void 0) warn(context, "dropped", "DatePicker", "value did not match the YYYY-MM-DD format and was dropped.");
+			return {
+				type: "datepicker",
+				action_id: asActionId(action, "DatePicker", context),
+				...initialDate !== void 0 ? { initial_date: initialDate } : {}
+			};
+		}
+		case "Checkbox": {
+			const label = clampText(asString(props["label"]), 75, "Checkbox", "label", context);
+			const name = asString(props["name"]);
+			const option = {
+				text: plainText(label),
+				value: name || label
+			};
+			return {
+				type: "checkboxes",
+				action_id: asActionId(action, "Checkbox", context),
+				options: [option],
+				...props["defaultChecked"] === true ? { initial_options: [option] } : {}
+			};
+		}
+		case "RadioGroup": {
+			const rawOptions = Array.isArray(props["options"]) ? props["options"] : [];
+			if (rawOptions.length > 10) warn(context, "clamped", "RadioGroup", `options were clamped to 10 entries.`);
+			const options = rawOptions.slice(0, 10).map((option) => optionFrom(option, "RadioGroup", context)).filter((option) => option !== void 0);
+			const selectedValue = typeof props["value"] === "string" ? props["value"] : asString(props["defaultValue"]);
+			const initialOption = options.find((option) => option.value === selectedValue);
+			return {
+				type: "radio_buttons",
+				action_id: asActionId(action, "RadioGroup", context),
+				options,
+				...initialOption !== void 0 ? { initial_option: initialOption } : {}
+			};
+		}
+		default: return;
+	}
+};
+const normalizedList = (node) => {
+	if (node === void 0 || node === null) return [];
+	if (!Array.isArray(node)) return [node];
+	return node.flatMap((child) => normalizedList(child));
+};
+const convertFacts = (facts, context) => {
+	const fields = facts.map((fact) => {
+		const label = asString(fact.props["label"]);
+		const value = asString(fact.props["value"]);
+		return {
+			type: "mrkdwn",
+			text: clampText(`*${label}*\n${value}`, FACT_FIELD_TEXT_CAP, "Fact", "field", context)
+		};
+	});
+	const blocks = [];
+	for (let index = 0; index < fields.length; index += 10) blocks.push({
+		type: "section",
+		fields: fields.slice(index, index + 10)
+	});
+	return blocks;
+};
+const convertActions = (elements, context) => {
+	const converted = elements.map((element) => toActionElement(element, context)).filter((element) => element !== void 0);
+	const blocks = [];
+	for (let index = 0; index < converted.length; index += 25) blocks.push({
+		type: "actions",
+		elements: converted.slice(index, index + 25)
+	});
+	return blocks;
+};
+const cardActionButtons = (props, context) => {
+	const buttons = [];
+	for (const key of ["confirm", "cancel"]) {
+		const footer = props[key];
+		if (!isRecord(footer)) continue;
+		buttons.push(buttonElement(asString(footer["label"]), key === "confirm" ? "primary" : void 0, footer["$action"], "Card", context));
+	}
+	return buttons;
+};
+const cardTitleText = (props, context) => {
+	const rawTitle = asString(props["title"]);
+	return rawTitle ? clampText(rawTitle, 150, "Card", "title", context) : void 0;
+};
+const isCardNoOp = (node) => isElement(node) && (node.type === "Spacer" || node.type === "Icon");
+const collectText = (node, depth) => {
+	if (node === void 0 || node === null || depth > 64) return [];
+	if (typeof node === "string" || typeof node === "number") return [String(node)];
+	if (Array.isArray(node)) return node.flatMap((child) => collectText(child, depth + 1));
+	const element = node;
+	return [...[
+		"text",
+		"value",
+		"label",
+		"title",
+		"description"
+	].map((key) => element.props[key]).filter((value) => typeof value === "string"), ...collectText(element.children, depth + 1)];
+};
+/**
+* Scans a card's children for the pieces the native card block shape can
+* carry (a hero image, body text, and subtext), each taken from the first
+* matching child. Anything left over means the card cannot map cleanly onto
+* the native shape.
+*/
+const extractCardFields = (element) => {
+	const children = normalizedList(element.children);
+	let heroImage;
+	let bodyRaw;
+	let subtextRaw;
+	const leftover = [];
+	for (const child of children) {
+		if (heroImage === void 0 && isElement(child) && child.type === "Image") {
+			heroImage = {
+				type: "image",
+				image_url: asString(child.props["src"]),
+				alt_text: asString(child.props["alt"])
+			};
+			continue;
+		}
+		if (bodyRaw === void 0 && isElement(child) && (child.type === "Text" || child.type === "Markdown")) {
+			bodyRaw = asString(child.props["value"]);
+			continue;
+		}
+		if (subtextRaw === void 0 && isElement(child) && child.type === "Caption") {
+			subtextRaw = asString(child.props["value"]);
+			continue;
+		}
+		if (isCardNoOp(child)) continue;
+		leftover.push(child);
+	}
+	return {
+		heroImage,
+		bodyRaw,
+		subtextRaw,
+		leftover
+	};
+};
+/** Assembles a native card block, clamping its body and subtext text. */
+const assembleCleanCard = (titleText, fields, buttons, context) => {
+	const body = fields.bodyRaw !== void 0 ? {
+		type: "mrkdwn",
+		text: clampText(fields.bodyRaw, 200, "Card", "body", context)
+	} : void 0;
+	const subtext = fields.subtextRaw !== void 0 ? {
+		type: "mrkdwn",
+		text: clampText(fields.subtextRaw, 200, "Card", "subtext", context)
+	} : void 0;
+	if (buttons.length > 3) warn(context, "clamped", "Card", `actions were clamped to 3 entries.`);
+	return buildCardBlock({
+		...fields.heroImage !== void 0 ? { heroImage: fields.heroImage } : {},
+		...titleText !== void 0 ? { title: {
+			type: "mrkdwn",
+			text: titleText
+		} } : {},
+		...body !== void 0 ? { body } : {},
+		...subtext !== void 0 ? { subtext } : {},
+		...buttons.length > 0 ? { actions: buttons.slice(0, 3) } : {}
+	});
+};
+/**
+* A card requires at least one of `hero_image`, `title`, `body`, or `actions`
+* (see {@link SlackCardBlock}); a card with none of them is not a valid
+* native block and must be dropped instead of emitted.
+*/
+const isEmptyCard = (card) => card.hero_image === void 0 && card.title === void 0 && card.body === void 0 && (card.actions === void 0 || card.actions.length === 0);
+const convertCard = (element, context, depth) => {
+	const titleText = cardTitleText(element.props, context);
+	const fields = extractCardFields(element);
+	const buttons = cardActionButtons(element.props, context);
+	if (fields.leftover.length > 0) {
+		warn(context, "fallback", "Card", "A card with content beyond hero_image, body, subtext, and actions was rendered inline.");
+		return [
+			...titleText ? [{
+				type: "header",
+				text: plainText(titleText)
+			}] : [],
+			...convertSequence(element.children, context, depth + 1),
+			...buttons.length > 0 ? [{
+				type: "actions",
+				elements: buttons
+			}] : []
+		];
+	}
+	const card = assembleCleanCard(titleText, fields, buttons, context);
+	if (isEmptyCard(card)) {
+		warn(context, "dropped", "Card", "A card with none of hero_image, title, body, or actions was dropped.");
+		return [];
+	}
+	return [card];
+};
+/**
+* Degrades a card that cannot map cleanly into a title-and-body card block.
+* A carousel cannot fall back to a block sequence like a standalone card
+* can, so its content is clamped down to fit the card shape instead.
+*/
+const degradeCard = (element, context, depth) => {
+	const rawTitle = asString(element.props["title"]);
+	const textChunks = collectText(element.children, depth + 1);
+	const titleSource = rawTitle || textChunks[0] || "";
+	const bodyChunks = rawTitle ? textChunks : textChunks.slice(1);
+	const titleText = titleSource.slice(0, 150);
+	const bodyText = bodyChunks.join("\n").slice(0, 200);
+	warn(context, "clamped", "Card", "A card inside a carousel was degraded to title and body.");
+	return buildCardBlock({
+		...titleText ? { title: {
+			type: "mrkdwn",
+			text: titleText
+		} } : {},
+		...bodyText ? { body: {
+			type: "mrkdwn",
+			text: bodyText
+		} } : {}
+	});
+};
+const convertCarouselCard = (element, context, depth) => {
+	const fields = extractCardFields(element);
+	const card = fields.leftover.length === 0 ? assembleCleanCard(cardTitleText(element.props, context), fields, cardActionButtons(element.props, context), context) : degradeCard(element, context, depth);
+	if (isEmptyCard(card)) {
+		warn(context, "dropped", "Card", "A card with none of hero_image, title, body, or actions was dropped.");
+		return;
+	}
+	return card;
+};
+const isBadgeOrCaption = (node) => isElement(node) && (node.type === "Badge" || node.type === "Caption");
+const contextRow = (element, context) => {
+	const allChildren = normalizedList(element.children);
+	const children = allChildren.filter(isBadgeOrCaption);
+	if (allChildren.length === 0 || children.length !== allChildren.length) return;
+	if (children.length > 10) warn(context, "clamped", "Row", `context elements were clamped to 10 entries.`);
+	return [{
+		type: "context",
+		elements: children.slice(0, 10).map((child) => ({
+			type: "mrkdwn",
+			text: clampText(asString(child.props["value"]), CONTEXT_TEXT_CAP, child.type, "value", context)
+		}))
+	}];
+};
+const convertListItem = (element, context, depth) => {
+	const text = clampText(collectText(element.children, depth + 1).join("\n"), SECTION_TEXT_CAP, "ListViewItem", "text", context);
+	const accessory = isRecord(element.action) ? buttonElement("Open", void 0, element.action, "ListViewItem", context) : void 0;
+	return {
+		type: "section",
+		text: {
+			type: "mrkdwn",
+			text
+		},
+		...accessory !== void 0 ? { accessory } : {}
+	};
+};
+const convertListView = (element, context, depth) => {
+	return normalizedList(element.children).filter((child) => isElement(child) && child.type === "ListViewItem").flatMap((item, index) => [...index > 0 ? [{ type: "divider" }] : [], convertListItem(item, context, depth + 1)]);
+};
+const convertCarousel = (element, context, depth) => {
+	const cardChildren = [];
+	for (const child of normalizedList(element.children)) if (isElement(child) && child.type === "Card") cardChildren.push(child);
+	else warn(context, "dropped", "Carousel", "A non-card child was dropped.");
+	if (cardChildren.length > 10) warn(context, "clamped", "Carousel", `cards were clamped to 10 entries.`);
+	const cards = cardChildren.slice(0, 10).map((card) => convertCarouselCard(card, context, depth + 1)).filter((card) => card !== void 0);
+	if (cards.length < 1) {
+		warn(context, "dropped", "Carousel", "A carousel without renderable cards was dropped.");
+		return [];
+	}
+	return [buildCarouselBlock(cards)];
+};
+const toDataTableCell = (value) => {
+	if (typeof value === "number") return {
+		type: "raw_number",
+		text: String(value)
+	};
+	if (typeof value === "string" || typeof value === "boolean") return {
+		type: "raw_text",
+		text: String(value)
+	};
+};
+const rowCharacters = (row) => row.reduce((sum, cell) => sum + cell.text.length, 0);
+const convertTable = (element, context) => {
+	const rawColumns = Array.isArray(element.props["columns"]) ? element.props["columns"] : [];
+	const rawRows = Array.isArray(element.props["rows"]) ? element.props["rows"] : [];
+	if (rawColumns.length > 20) warn(context, "clamped", "Table", `columns were clamped to 20 entries.`);
+	if (rawRows.length > 100) warn(context, "clamped", "Table", `rows were clamped to 100 entries.`);
+	const columnHeaderRow = rawColumns.slice(0, 20).filter(isRecord).map((column) => ({
+		type: "raw_text",
+		text: asString(column["label"])
+	}));
+	const dataRows = rawRows.slice(0, 100).map((row) => (Array.isArray(row) ? row : []).slice(0, 20).map((value) => toDataTableCell(value) ?? {
+		type: "raw_text",
+		text: ""
+	}));
+	const width = Math.max(columnHeaderRow.length, 0, ...dataRows.map((row) => row.length));
+	const padRow = (row) => row.length >= width ? row : [...row, ...Array.from({ length: width - row.length }, () => ({
+		type: "raw_text",
+		text: ""
+	}))];
+	const headerRow = padRow(columnHeaderRow);
+	const headerCharacters = rowCharacters(headerRow);
+	if (context.dataTableCharacters + headerCharacters > 1e4) {
+		warn(context, "dropped", "Table", `the table was dropped because its header row exceeds the ${DATA_TABLE_CHAR_BUDGET}-character table budget.`);
+		return [];
+	}
+	const kept = [headerRow];
+	let tableCharacters = headerCharacters;
+	let budgetClamped = false;
+	for (const row of dataRows.map(padRow)) {
+		const chars = rowCharacters(row);
+		if (context.dataTableCharacters + tableCharacters + chars > 1e4) {
+			budgetClamped = true;
+			break;
+		}
+		kept.push(row);
+		tableCharacters += chars;
+	}
+	context.dataTableCharacters += tableCharacters;
+	if (budgetClamped) warn(context, "clamped", "Table", `rows were clamped to fit the ${DATA_TABLE_CHAR_BUDGET}-character table budget.`);
+	return [buildDataTableBlock(kept)];
+};
+const convertElement = (element, context, depth) => {
+	const { props } = element;
+	switch (element.type) {
+		case "Header": return [{
+			type: "header",
+			text: plainText(clampText(asString(props["text"]), 150, "Header", "text", context))
+		}];
+		case "Text": return [{
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: clampText(asString(props["value"]), SECTION_TEXT_CAP, "Text", "value", context)
+			}
+		}];
+		case "Caption":
+		case "Badge": return [{
+			type: "context",
+			elements: [{
+				type: "mrkdwn",
+				text: clampText(asString(props["value"]), CONTEXT_TEXT_CAP, element.type, "value", context)
+			}]
+		}];
+		case "Fact": return convertFacts([element], context);
+		case "Image": return [{
+			type: "image",
+			image_url: asString(props["src"]),
+			alt_text: asString(props["alt"])
+		}];
+		case "Divider": return [{ type: "divider" }];
+		case "Button":
+		case "Select":
+		case "DatePicker":
+		case "Checkbox":
+		case "RadioGroup": return convertActions([element], context);
+		case "Input": {
+			const label = clampText(asString(props["label"]), INPUT_LABEL_CAP, "Input", "label", context);
+			const placeholder = clampText(asString(props["placeholder"]), 150, "Input", "placeholder", context);
+			return [{
+				type: "input",
+				label: plainText(label),
+				element: {
+					type: "plain_text_input",
+					action_id: asActionId(element.action, "Input", context),
+					...props["multiline"] === true ? { multiline: true } : {},
+					...placeholder ? { placeholder: plainText(placeholder) } : {}
+				}
+			}];
+		}
+		case "Alert": {
+			const tone = props["tone"] === "success" || props["tone"] === "warning" || props["tone"] === "danger" ? props["tone"] : "info";
+			const titleText = asString(props["title"]);
+			const description = asString(props["description"]);
+			if (context.surface === "modal") {
+				const combined = [titleText, description].filter(Boolean).join("\n");
+				return [buildAlertBlock(clampText(combined, 200, "Alert", "text", context), tone)];
+			}
+			warn(context, "fallback", "Alert", "Alert was rendered with message-surface fallback blocks.");
+			return [...buildAlertFallback(titleText, clampText(description, SECTION_TEXT_CAP, "Alert", "description", context), tone)];
+		}
+		case "Card": return convertCard(element, context, depth);
+		case "Carousel": return convertCarousel(element, context, depth);
+		case "Col":
+		case "Box": return convertSequence(element.children, context, depth + 1);
+		case "Row": return contextRow(element, context) ?? convertSequence(element.children, context, depth + 1);
+		case "Spacer":
+		case "Icon": return [];
+		case "Table": return convertTable(element, context);
+		case "Markdown": {
+			const value = asString(props["value"]);
+			if (!context.markdownExhausted && context.markdownCharacters + value.length <= 12e3) {
+				context.markdownCharacters += value.length;
+				return [{
+					type: "markdown",
+					text: value
+				}];
+			}
+			context.markdownExhausted = true;
+			warn(context, "fallback", "Markdown", `The ${MARKDOWN_TEXT_BUDGET}-character markdown budget was exceeded.`);
+			return [{
+				type: "section",
+				text: {
+					type: "mrkdwn",
+					text: clampText(value, SECTION_TEXT_CAP, "Markdown", "fallback text", context)
+				}
+			}];
+		}
+		case "Chart":
+			warn(context, "dropped", "Chart", "Chart was replaced by a Slack omission note.");
+			return [{
+				type: "context",
+				elements: [{
+					type: "mrkdwn",
+					text: "Chart omitted on Slack."
+				}]
+			}];
+		case "ListView": return convertListView(element, context, depth);
+		case "ListViewItem": return [convertListItem(element, context, depth)];
+		case "Form": return [...convertSequence(element.children, context, depth + 1), {
+			type: "actions",
+			elements: [buttonElement("Submit", "primary", element.action, "Form", context)]
+		}];
+		default:
+			warn(context, "dropped", element.type, "Unknown component type was dropped.");
+			return [];
+	}
+};
+function convertSequence(node, context, depth) {
+	if (node === void 0 || node === null || depth > 64) return [];
+	const nodes = Array.isArray(node) ? node : [node];
+	const blocks = [];
+	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 === "Fact") {
+			const facts = [];
+			while (index < nodes.length) {
+				const candidate = nodes[index];
+				if (!candidate || !isElement(candidate) || candidate.type !== "Fact") break;
+				facts.push(candidate);
+				index += 1;
+			}
+			blocks.push(...convertFacts(facts, context));
+			continue;
+		}
+		if (isElement(current) && INTERACTIVE_TYPES.has(current.type)) {
+			const controls = [];
+			while (index < nodes.length) {
+				const candidate = nodes[index];
+				if (!candidate || !isElement(candidate) || !INTERACTIVE_TYPES.has(candidate.type)) break;
+				controls.push(candidate);
+				index += 1;
+			}
+			blocks.push(...convertActions(controls, context));
+			continue;
+		}
+		if (typeof current === "string" || typeof current === "number") blocks.push({
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: clampText(String(current), SECTION_TEXT_CAP, "Text", "value", context)
+			}
+		});
+		else if (Array.isArray(current)) blocks.push(...convertSequence(current, context, depth + 1));
+		else blocks.push(...convertElement(current, context, depth + 1));
+		index += 1;
+	}
+	return blocks;
+}
+function boundNode(value, depth, onClamp, state, ancestors) {
+	if (state.remaining <= 0) {
+		if (!state.exhausted) {
+			state.exhausted = true;
+			onClamp("budget");
+		}
+		return null;
+	}
+	state.remaining -= 1;
+	if (depth > 64) {
+		onClamp("depth");
+		return null;
+	}
+	if (Array.isArray(value)) {
+		if (ancestors.has(value)) {
+			onClamp("cycle");
+			return null;
+		}
+		ancestors.add(value);
+		const bounded = Array.prototype.slice.call(value, 0, 200);
+		if (value.length > 200) onClamp("children");
+		const result = bounded.map((item) => boundNode(item, depth + 1, onClamp, state, ancestors));
+		ancestors.delete(value);
+		return result;
+	}
+	if (value !== null && typeof value === "object" && "children" in value) {
+		if (ancestors.has(value)) {
+			onClamp("cycle");
+			return null;
+		}
+		ancestors.add(value);
+		const record = value;
+		const result = {
+			...record,
+			children: boundNode(record["children"], depth + 1, onClamp, state, ancestors)
+		};
+		ancestors.delete(value);
+		return result;
+	}
+	return value;
+}
+/**
+* Produces a bounded plain copy of a raw generative-ui spec before it
+* reaches `normalizeSpec`, whose own traversal of the root array or any
+* `children` array walks the full reported length of a hostile proxied
+* array before any per-field cap downstream ever applies. Every array
+* (root, or `children` at any depth) is capped to {@link CHILDREN_CAP}
+* entries via `Array.prototype.slice`, which bounds even a proxy with a
+* fabricated `length`; recursion itself is capped at
+* {@link MAX_TRAVERSAL_DEPTH}. `onClamp` fires once per level that was
+* truncated, receiving the reason for that truncation: `"children"`,
+* `"depth"`, `"budget"`, or `"cycle"`. The walk also spends a total budget of
+* {@link NODE_BUDGET} nodes, so shared references cannot multiply work
+* exponentially, and a node that is its own ancestor is cut to `null`.
+*/
+function boundSpec(spec, onClamp) {
+	return boundNode(spec, 0, onClamp, {
+		remaining: NODE_BUDGET,
+		exhausted: false
+	}, /* @__PURE__ */ new WeakSet());
+}
+/** Converts a generative-UI tree into Slack Block Kit JSON and downgrade warnings. */
+function toSlackBlocks(node, options) {
+	const surface = options?.surface === "modal" ? "modal" : "message";
+	const context = {
+		blockCap: surface === "modal" ? 100 : 50,
+		surface,
+		warnings: [],
+		markdownCharacters: 0,
+		markdownExhausted: false,
+		dataTableCharacters: 0
+	};
+	try {
+		const { root } = normalizeSpec(boundSpec(node, (reason) => {
+			const detail = reason === "budget" ? `the tree was truncated after ${NODE_BUDGET} nodes.` : reason === "cycle" ? "a self-referencing node was dropped." : reason === "depth" ? `nodes deeper than 64 levels were dropped.` : `children were clamped to 200 entries.`;
+			warn(context, "clamped", "Root", detail);
+		}));
+		const converted = convertSequence(root, context, 0);
+		if (converted.length <= context.blockCap) return {
+			blocks: converted,
+			warnings: context.warnings
+		};
+		const kept = converted.slice(0, context.blockCap - 1);
+		const omitted = converted.length - kept.length;
+		warn(context, "clamped", "Root", `${omitted} ${omitted === 1 ? "block was" : "blocks were"} omitted.`);
+		return {
+			blocks: [...kept, buildBlockBudgetNote(omitted)],
+			warnings: context.warnings
+		};
+	} catch {
+		return {
+			blocks: [],
+			warnings: [{
+				code: "dropped",
+				component: "Root",
+				detail: "Input could not be converted."
+			}]
+		};
+	}
+}
+//#endregion
+export { toSlackBlocks };
+
+//# sourceMappingURL=toSlackBlocks.js.map