@ai-gui/plugin-ui 0.4.0

package/dist/index.cjs

@@ -0,0 +1,1142 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __ai_gui_core = __toESM(require("@ai-gui/core"));
+
+//#region src/css.ts
+const uiCss = `
+[data-aigui-ui] { display: block; color: inherit; font: inherit; }
+[data-aigui-ui-stack="row"] { display: flex; flex-direction: row; flex-wrap: wrap; }
+[data-aigui-ui-stack="column"] { display: flex; flex-direction: column; }
+[data-aigui-ui-grid] { display: grid; grid-template-columns: repeat(var(--aigui-ui-columns, 1), minmax(0, 1fr)); }
+[data-aigui-ui-grid="2"] { --aigui-ui-columns: 2; }
+[data-aigui-ui-grid="3"] { --aigui-ui-columns: 3; }
+[data-aigui-ui-grid="4"] { --aigui-ui-columns: 4; }
+[data-gap="sm"] { gap: .5rem; } [data-gap="md"] { gap: 1rem; } [data-gap="lg"] { gap: 1.5rem; }
+[data-align="start"] { align-items: flex-start; } [data-align="center"] { align-items: center; } [data-align="end"] { align-items: flex-end; } [data-align="stretch"] { align-items: stretch; }
+[data-tone="muted"] { color: color-mix(in srgb, currentColor 60%, transparent); }
+[data-tone="positive"] { color: #18794e; } [data-tone="warning"] { color: #9a6700; } [data-tone="critical"] { color: #b42318; }
+[data-aigui-ui] table { border-collapse: collapse; width: 100%; }
+[data-aigui-ui] th, [data-aigui-ui] td { border: 1px solid currentColor; padding: .4rem .6rem; text-align: left; }
+[data-aigui-ui-field] { display: grid; gap: .25rem; }
+[data-aigui-ui-field-error], [data-aigui-ui-action-error] { color: #b42318; }
+`;
+
+//#endregion
+//#region src/errors.ts
+var UIDocumentError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(issues[0] ?? "Invalid UI document.");
+		this.name = "UIDocumentError";
+		this.issues = [...issues];
+	}
+};
+var UILimitError = class extends UIDocumentError {
+	constructor(message) {
+		super([message]);
+		this.name = "UILimitError";
+	}
+};
+
+//#endregion
+//#region src/limits.ts
+const DEFAULT_UI_LIMITS = Object.freeze({
+	sourceBytes: 64 * 1024,
+	nodes: 200,
+	depth: 12,
+	children: 50,
+	state: 64,
+	string: 4096,
+	totalStrings: 64 * 1024,
+	tableRows: 100,
+	tableColumns: 20,
+	options: 100,
+	boundJSONDepth: 8,
+	boundJSONNodes: 512
+});
+function resolveUILimits(overrides) {
+	const limits = {
+		...DEFAULT_UI_LIMITS,
+		...overrides
+	};
+	for (const [key, value] of Object.entries(limits)) if (!Number.isInteger(value) || value < 1) throw new TypeError(`UI limit "${key}" must be a positive integer.`);
+	return limits;
+}
+
+//#endregion
+//#region src/validate.ts
+const SAFE_ID = /^[A-Za-z][A-Za-z0-9_-]{0,127}$/;
+const SAFE_STATE_KEY = /^[A-Za-z][A-Za-z0-9_.-]{0,127}$/;
+const DANGEROUS_KEYS = new Set([
+	"__proto__",
+	"prototype",
+	"constructor"
+]);
+const DOCUMENT_KEYS = set("version", "id", "state", "root");
+const BASE_KEYS = ["kind", "id"];
+const NODE_KEYS = {
+	stack: set(...BASE_KEYS, "direction", "gap", "align", "children"),
+	grid: set(...BASE_KEYS, "columns", "gap", "children"),
+	text: set(...BASE_KEYS, "text", "tone"),
+	heading: set(...BASE_KEYS, "level", "text"),
+	divider: set(...BASE_KEYS),
+	list: set(...BASE_KEYS, "ordered", "items"),
+	table: set(...BASE_KEYS, "caption", "headers", "rows"),
+	keyValue: set(...BASE_KEYS, "items"),
+	form: set(...BASE_KEYS, "children", "submit", "submitLabel"),
+	field: set(...BASE_KEYS, "bind", "fieldType", "label", "required", "placeholder", "minLength", "maxLength", "pattern", "min", "max", "options"),
+	button: set(...BASE_KEYS, "label", "variant", "action"),
+	card: set(...BASE_KEYS, "type", "data")
+};
+const GAPS = new Set([
+	"none",
+	"sm",
+	"md",
+	"lg"
+]);
+const ALIGNS = new Set([
+	"start",
+	"center",
+	"end",
+	"stretch"
+]);
+const TONES = new Set([
+	"default",
+	"muted",
+	"positive",
+	"warning",
+	"critical"
+]);
+const FIELD_TYPES = new Set([
+	"text",
+	"textarea",
+	"number",
+	"date",
+	"select",
+	"checkbox",
+	"radio"
+]);
+function parseUIDocument(source, options) {
+	if (typeof source !== "string") throw new UIDocumentError(["UI source must be a string."]);
+	const limits = resolveUILimits(options.limits);
+	if (new TextEncoder().encode(source).byteLength > limits.sourceBytes) throw new UILimitError("UI source exceeds the byte limit.");
+	let value;
+	try {
+		value = JSON.parse(source);
+	} catch {
+		throw new UIDocumentError(["UI source must be valid JSON."]);
+	}
+	return validateUIDocument(value, {
+		...options,
+		limits
+	});
+}
+function validateUIDocument(value, options) {
+	if (!options?.registry || !options?.actionRuntime) throw new TypeError("UI validation requires registry and actionRuntime.");
+	const limits = resolveUILimits(options.limits);
+	assertSafeGraph(value);
+	if (!isPlainObject(value)) throw new UIDocumentError(["UI document must be a plain object."]);
+	const issues = [];
+	rejectKeys(value, DOCUMENT_KEYS, "$", issues);
+	if (value.version !== 1) issues.push("$.version must be 1.");
+	const id = readString(value.id, "$.id", issues, limits);
+	if (id && !SAFE_ID.test(id)) issues.push("$.id is not a safe id.");
+	const state = Object.create(null);
+	if (value.state !== void 0) if (!isPlainObject(value.state)) issues.push("$.state must be a plain object.");
+	else {
+		const entries = Object.entries(value.state);
+		if (entries.length > limits.state) issues.push(`$.state exceeds ${limits.state} entries.`);
+		for (const [key, scalar] of entries) {
+			if (DANGEROUS_KEYS.has(key) || !SAFE_STATE_KEY.test(key)) issues.push(`$.state.${key} is not a safe state key.`);
+			if (!isScalar(scalar)) issues.push(`$.state.${key} must be a scalar.`);
+			else state[key] = scalar;
+		}
+	}
+	const ctx = {
+		registry: options.registry,
+		actionRuntime: options.actionRuntime,
+		limits,
+		state,
+		ids: new Set(),
+		nodes: 0,
+		totalStrings: 0,
+		issues
+	};
+	const root = validateNode(value.root, "$.root", 1, false, ctx);
+	if (issues.length || !id || !root) throw new UIDocumentError(issues.length ? issues : ["Invalid UI document."]);
+	return value;
+}
+function validateNode(value, path, depth, insideForm, ctx) {
+	if (depth > ctx.limits.depth) {
+		ctx.issues.push(`${path} exceeds maximum depth.`);
+		return void 0;
+	}
+	if (++ctx.nodes > ctx.limits.nodes) {
+		ctx.issues.push(`UI exceeds ${ctx.limits.nodes} nodes.`);
+		return void 0;
+	}
+	if (!isPlainObject(value)) {
+		ctx.issues.push(`${path} must be a plain object.`);
+		return void 0;
+	}
+	const kind = typeof value.kind === "string" ? value.kind : "";
+	const allowed = NODE_KEYS[kind];
+	if (!allowed) {
+		ctx.issues.push(`${path}.kind is not supported.`);
+		return void 0;
+	}
+	rejectKeys(value, allowed, path, ctx.issues);
+	const id = readString(value.id, `${path}.id`, ctx.issues, ctx.limits);
+	if (id) {
+		if (!SAFE_ID.test(id)) ctx.issues.push(`${path}.id is not safe.`);
+		if (ctx.ids.has(id)) ctx.issues.push(`${path}.id must be unique.`);
+		ctx.ids.add(id);
+	}
+	switch (kind) {
+		case "stack":
+			optionalEnum(value.direction, ["row", "column"], `${path}.direction`, ctx.issues);
+			optionalEnum(value.gap, GAPS, `${path}.gap`, ctx.issues);
+			optionalEnum(value.align, ALIGNS, `${path}.align`, ctx.issues);
+			validateChildren(value.children, path, depth, insideForm, ctx);
+			break;
+		case "grid":
+			if (![
+				1,
+				2,
+				3,
+				4
+			].includes(value.columns)) ctx.issues.push(`${path}.columns must be 1, 2, 3, or 4.`);
+			optionalEnum(value.gap, GAPS, `${path}.gap`, ctx.issues);
+			validateChildren(value.children, path, depth, insideForm, ctx);
+			break;
+		case "text":
+			validateScalarExpression(value.text, `${path}.text`, ctx);
+			optionalEnum(value.tone, TONES, `${path}.tone`, ctx.issues);
+			break;
+		case "heading":
+			if (![
+				2,
+				3,
+				4
+			].includes(value.level)) ctx.issues.push(`${path}.level must be 2, 3, or 4.`);
+			validateScalarExpression(value.text, `${path}.text`, ctx);
+			break;
+		case "divider": break;
+		case "list":
+			if (value.ordered !== void 0 && typeof value.ordered !== "boolean") ctx.issues.push(`${path}.ordered must be boolean.`);
+			if (!Array.isArray(value.items)) ctx.issues.push(`${path}.items must be an array.`);
+			else value.items.forEach((item, index) => {
+				if (!isScalar(item)) ctx.issues.push(`${path}.items[${index}] must be a scalar.`);
+				else countScalar(item, ctx, `${path}.items[${index}]`);
+			});
+			break;
+		case "table":
+			validateTable(value, path, ctx);
+			break;
+		case "keyValue":
+			validateKeyValue(value, path, ctx);
+			break;
+		case "form":
+			if (insideForm) ctx.issues.push(`${path} cannot nest a form.`);
+			validateActionType(value.submit, `${path}.submit`, ctx);
+			if (value.submitLabel !== void 0) readString(value.submitLabel, `${path}.submitLabel`, ctx.issues, ctx.limits);
+			validateChildren(value.children, path, depth, true, ctx);
+			break;
+		case "field":
+			validateField$1(value, path, insideForm, ctx);
+			break;
+		case "button":
+			readString(value.label, `${path}.label`, ctx.issues, ctx.limits);
+			optionalEnum(value.variant, [
+				"primary",
+				"secondary",
+				"danger"
+			], `${path}.variant`, ctx.issues);
+			validateAction(value.action, `${path}.action`, ctx);
+			break;
+		case "card": {
+			const type = readString(value.type, `${path}.type`, ctx.issues, ctx.limits);
+			validateBoundJSON(value.data, `${path}.data`, ctx);
+			if (type && !ctx.registry.get(type)) ctx.issues.push(`${path}.type is not registered.`);
+			else if (type) try {
+				if (!ctx.registry.validate(type, resolveBoundJSON(value.data, ctx.state))) ctx.issues.push(`${path}.data is invalid for card type "${type}".`);
+			} catch {
+				ctx.issues.push(`${path}.data is invalid.`);
+			}
+			break;
+		}
+	}
+	return value;
+}
+function validateChildren(value, path, depth, insideForm, ctx) {
+	if (!Array.isArray(value)) {
+		ctx.issues.push(`${path}.children must be an array.`);
+		return;
+	}
+	if (value.length > ctx.limits.children) ctx.issues.push(`${path}.children exceeds ${ctx.limits.children} items.`);
+	value.forEach((child, index) => validateNode(child, `${path}.children[${index}]`, depth + 1, insideForm, ctx));
+}
+function validateTable(value, path, ctx) {
+	readString(value.caption, `${path}.caption`, ctx.issues, ctx.limits, true);
+	if (!Array.isArray(value.headers) || value.headers.length > ctx.limits.tableColumns) ctx.issues.push(`${path}.headers must contain at most ${ctx.limits.tableColumns} strings.`);
+	else value.headers.forEach((header, index) => readString(header, `${path}.headers[${index}]`, ctx.issues, ctx.limits, true));
+	if (!Array.isArray(value.rows) || value.rows.length > ctx.limits.tableRows) ctx.issues.push(`${path}.rows must contain at most ${ctx.limits.tableRows} rows.`);
+	else value.rows.forEach((row, rowIndex) => {
+		if (!Array.isArray(row) || !Array.isArray(value.headers) || row.length !== value.headers.length) ctx.issues.push(`${path}.rows[${rowIndex}] must match header width.`);
+		else row.forEach((cell, cellIndex) => {
+			if (!isScalar(cell)) ctx.issues.push(`${path}.rows[${rowIndex}][${cellIndex}] must be a scalar.`);
+			else countScalar(cell, ctx, `${path}.rows[${rowIndex}][${cellIndex}]`);
+		});
+	});
+}
+function validateKeyValue(value, path, ctx) {
+	if (!Array.isArray(value.items)) {
+		ctx.issues.push(`${path}.items must be an array.`);
+		return;
+	}
+	value.items.forEach((item, index) => {
+		const itemPath = `${path}.items[${index}]`;
+		if (!isPlainObject(item)) {
+			ctx.issues.push(`${itemPath} must be a plain object.`);
+			return;
+		}
+		rejectKeys(item, set("label", "value"), itemPath, ctx.issues);
+		readString(item.label, `${itemPath}.label`, ctx.issues, ctx.limits);
+		validateScalarExpression(item.value, `${itemPath}.value`, ctx);
+	});
+}
+function validateField$1(value, path, insideForm, ctx) {
+	if (!insideForm) ctx.issues.push(`${path} must be inside a form.`);
+	const field = value;
+	const bind = readString(value.bind, `${path}.bind`, ctx.issues, ctx.limits);
+	const type = readString(value.fieldType, `${path}.fieldType`, ctx.issues, ctx.limits);
+	readString(value.label, `${path}.label`, ctx.issues, ctx.limits);
+	if (bind && !Object.hasOwn(ctx.state, bind)) ctx.issues.push(`${path}.bind must reference declared state.`);
+	if (type && !FIELD_TYPES.has(type)) ctx.issues.push(`${path}.fieldType is unsupported.`);
+	if (value.required !== void 0 && typeof value.required !== "boolean") ctx.issues.push(`${path}.required must be boolean.`);
+	if (value.placeholder !== void 0) readString(value.placeholder, `${path}.placeholder`, ctx.issues, ctx.limits, true);
+	const minLength = optionalNonNegativeInteger(value.minLength, `${path}.minLength`, ctx.issues);
+	const maxLength = optionalNonNegativeInteger(value.maxLength, `${path}.maxLength`, ctx.issues);
+	const min = optionalFiniteNumber(value.min, `${path}.min`, ctx.issues);
+	const max = optionalFiniteNumber(value.max, `${path}.max`, ctx.issues);
+	if (minLength !== void 0 && maxLength !== void 0 && minLength > maxLength) ctx.issues.push(`${path}.minLength cannot exceed maxLength.`);
+	if (min !== void 0 && max !== void 0 && min > max) ctx.issues.push(`${path}.min cannot exceed max.`);
+	let pattern;
+	if (value.pattern !== void 0) {
+		pattern = readString(value.pattern, `${path}.pattern`, ctx.issues, {
+			...ctx.limits,
+			string: Math.min(ctx.limits.string, 128)
+		});
+		if (pattern && !isSafePattern(pattern)) ctx.issues.push(`${path}.pattern uses unsupported regular expression features.`);
+		else if (pattern) try {
+			new RegExp(pattern);
+		} catch {
+			ctx.issues.push(`${path}.pattern is invalid.`);
+		}
+	}
+	validateOptions(value.options, path, ctx);
+	if (bind && type && Object.hasOwn(ctx.state, bind) && !compatibleState(type, ctx.state[bind])) ctx.issues.push(`${path}.bind has an incompatible initial value.`);
+	if (type === "number" && (minLength !== void 0 || maxLength !== void 0 || pattern !== void 0 || value.options !== void 0 || value.placeholder !== void 0)) ctx.issues.push(`${path} has constraints unsupported by number fields.`);
+	if ((type === "select" || type === "radio") && (!Array.isArray(value.options) || minLength !== void 0 || maxLength !== void 0 || pattern !== void 0 || min !== void 0 || max !== void 0 || value.placeholder !== void 0)) ctx.issues.push(`${path} has invalid choice-field properties.`);
+	if (type === "checkbox" && (value.options !== void 0 || minLength !== void 0 || maxLength !== void 0 || pattern !== void 0 || min !== void 0 || max !== void 0 || value.placeholder !== void 0)) ctx.issues.push(`${path} has invalid checkbox properties.`);
+	if (type === "date" && (value.options !== void 0 || minLength !== void 0 || maxLength !== void 0 || pattern !== void 0 || min !== void 0 || max !== void 0)) ctx.issues.push(`${path} has invalid date properties.`);
+	if ((type === "text" || type === "textarea") && (value.options !== void 0 || min !== void 0 || max !== void 0)) ctx.issues.push(`${path} has invalid string-field properties.`);
+}
+function validateOptions(value, path, ctx) {
+	if (value === void 0) return;
+	if (!Array.isArray(value) || value.length === 0 || value.length > ctx.limits.options) {
+		ctx.issues.push(`${path}.options must be a non-empty bounded array.`);
+		return;
+	}
+	const seen = new Set();
+	value.forEach((option, index) => {
+		const optionPath = `${path}.options[${index}]`;
+		if (!isPlainObject(option)) {
+			ctx.issues.push(`${optionPath} must be a plain object.`);
+			return;
+		}
+		rejectKeys(option, set("label", "value"), optionPath, ctx.issues);
+		readString(option.label, `${optionPath}.label`, ctx.issues, ctx.limits);
+		const optionValue = readString(option.value, `${optionPath}.value`, ctx.issues, ctx.limits, true);
+		if (optionValue !== void 0 && seen.has(optionValue)) ctx.issues.push(`${optionPath}.value must be unique.`);
+		if (optionValue !== void 0) seen.add(optionValue);
+	});
+}
+function validateAction(value, path, ctx) {
+	if (!isPlainObject(value)) {
+		ctx.issues.push(`${path} must be a plain object.`);
+		return;
+	}
+	rejectKeys(value, set("type", "params"), path, ctx.issues);
+	validateActionName(value.type, `${path}.type`, ctx);
+	if (value.params !== void 0) validateBoundJSON(value.params, `${path}.params`, ctx);
+}
+function validateActionType(value, path, ctx) {
+	if (!isPlainObject(value)) {
+		ctx.issues.push(`${path} must be a plain object.`);
+		return;
+	}
+	rejectKeys(value, set("type"), path, ctx.issues);
+	validateActionName(value.type, `${path}.type`, ctx);
+}
+function validateActionName(value, path, ctx) {
+	const type = readString(value, path, ctx.issues, ctx.limits);
+	if (type && !ctx.actionRuntime.hasAction(type)) ctx.issues.push(`${path} is not registered.`);
+}
+function validateScalarExpression(value, path, ctx) {
+	if (isScalar(value)) {
+		countScalar(value, ctx, path);
+		return true;
+	}
+	if (!isPlainObject(value) || Object.keys(value).length !== 1 || typeof value.$state !== "string") {
+		ctx.issues.push(`${path} must be a scalar or exact {$state:string} binding.`);
+		return false;
+	}
+	if (!Object.hasOwn(ctx.state, value.$state)) ctx.issues.push(`${path} references undeclared state.`);
+	countString(value.$state, ctx, path);
+	return true;
+}
+function validateBoundJSON(value, path, ctx) {
+	let count = 0;
+	const walk = (current, currentPath, depth) => {
+		if (++count > ctx.limits.boundJSONNodes) {
+			ctx.issues.push(`${path} exceeds bound JSON node limit.`);
+			return;
+		}
+		if (depth > ctx.limits.boundJSONDepth) {
+			ctx.issues.push(`${path} exceeds bound JSON depth.`);
+			return;
+		}
+		if (isScalar(current)) {
+			countScalar(current, ctx, currentPath);
+			return;
+		}
+		if (Array.isArray(current)) {
+			current.forEach((item, index) => walk(item, `${currentPath}[${index}]`, depth + 1));
+			return;
+		}
+		if (!isPlainObject(current)) {
+			ctx.issues.push(`${currentPath} must contain only JSON values and state bindings.`);
+			return;
+		}
+		if (Object.keys(current).length === 1 && typeof current.$state === "string") {
+			validateScalarExpression(current, currentPath, ctx);
+			return;
+		}
+		for (const [key, item] of Object.entries(current)) {
+			if (DANGEROUS_KEYS.has(key)) ctx.issues.push(`${currentPath}.${key} is dangerous.`);
+			countString(key, ctx, currentPath);
+			walk(item, `${currentPath}.${key}`, depth + 1);
+		}
+	};
+	walk(value, path, 1);
+}
+function resolveBoundJSON(value, state) {
+	if (isScalar(value)) return value;
+	if (Array.isArray(value)) return value.map((item) => resolveBoundJSON(item, state));
+	if (Object.keys(value).length === 1 && typeof value.$state === "string") return state[value.$state];
+	const result = Object.create(null);
+	for (const [key, item] of Object.entries(value)) result[key] = resolveBoundJSON(item, state);
+	return result;
+}
+function assertSafeGraph(value) {
+	const active = new Set();
+	const visited = new Set();
+	const walk = (current) => {
+		if (typeof current === "number" && !Number.isFinite(current)) throw new UIDocumentError(["UI values must be finite."]);
+		if (typeof current !== "object" || current === null) return;
+		if (active.has(current)) throw new UIDocumentError(["UI values must not contain cycles."]);
+		if (visited.has(current)) return;
+		if (!Array.isArray(current) && !isPlainObject(current)) throw new UIDocumentError(["UI values must use plain objects."]);
+		if (Array.isArray(current)) {
+			for (let i = 0; i < current.length; i++) if (!Object.hasOwn(current, i)) throw new UIDocumentError(["UI arrays must not be sparse."]);
+		}
+		active.add(current);
+		visited.add(current);
+		for (const key of Object.keys(current)) {
+			if (DANGEROUS_KEYS.has(key)) throw new UIDocumentError([`Dangerous key "${key}" is not allowed.`]);
+			walk(current[key]);
+		}
+		active.delete(current);
+	};
+	walk(value);
+}
+function rejectKeys(value, allowed, path, issues) {
+	for (const key of Object.keys(value)) if (DANGEROUS_KEYS.has(key) || !allowed.has(key)) issues.push(`${path}.${key} is not allowed.`);
+}
+function readString(value, path, issues, limits, allowEmpty = false) {
+	if (typeof value !== "string" || !allowEmpty && value.trim() === "" || value.length > limits.string) {
+		issues.push(`${path} must be ${allowEmpty ? "a" : "a non-empty"} bounded string.`);
+		return void 0;
+	}
+	return value;
+}
+function countString(value, ctx, path) {
+	if (value.length > ctx.limits.string) ctx.issues.push(`${path} exceeds string limit.`);
+	ctx.totalStrings += value.length;
+	if (ctx.totalStrings > ctx.limits.totalStrings) ctx.issues.push("UI exceeds total string limit.");
+}
+function countScalar(value, ctx, path) {
+	if (typeof value === "string") countString(value, ctx, path);
+}
+function optionalEnum(value, allowed, path, issues) {
+	if (value !== void 0 && !new Set(allowed).has(value)) issues.push(`${path} is invalid.`);
+}
+function optionalNonNegativeInteger(value, path, issues) {
+	if (value === void 0) return void 0;
+	if (!Number.isInteger(value) || value < 0) {
+		issues.push(`${path} must be a non-negative integer.`);
+		return void 0;
+	}
+	return value;
+}
+function optionalFiniteNumber(value, path, issues) {
+	if (value === void 0) return void 0;
+	if (typeof value !== "number" || !Number.isFinite(value)) {
+		issues.push(`${path} must be finite.`);
+		return void 0;
+	}
+	return value;
+}
+function compatibleState(type, value) {
+	if (value === null) return type !== "checkbox";
+	if (type === "checkbox") return typeof value === "boolean";
+	if (type === "number") return typeof value === "number";
+	return typeof value === "string";
+}
+function isScalar(value) {
+	return value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value);
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function set(...values) {
+	return new Set(values);
+}
+function isSafePattern(pattern) {
+	let index = pattern.startsWith("^") ? 1 : 0;
+	let hasAtom = false;
+	let canQuantify = false;
+	let quantified = false;
+	while (index < pattern.length) {
+		const char = pattern[index];
+		if (char === "$" && index === pattern.length - 1) return hasAtom;
+		if (char === "[") {
+			const end = readCharacterClass(pattern, index);
+			if (end < 0) return false;
+			index = end;
+			hasAtom = canQuantify = true;
+			quantified = false;
+			continue;
+		}
+		if (char === "\\") {
+			if (!isSafeEscape(pattern[index + 1])) return false;
+			index += 2;
+			hasAtom = canQuantify = true;
+			quantified = false;
+			continue;
+		}
+		if (char === "*" || char === "+" || char === "?") {
+			if (!canQuantify || quantified) return false;
+			index++;
+			canQuantify = false;
+			quantified = true;
+			continue;
+		}
+		if (char === "{") {
+			if (!canQuantify || quantified) return false;
+			const end = readBoundedQuantifier(pattern, index);
+			if (end < 0) return false;
+			index = end;
+			canQuantify = false;
+			quantified = true;
+			continue;
+		}
+		if (".^$|()]}".includes(char)) return false;
+		index++;
+		hasAtom = canQuantify = true;
+		quantified = false;
+	}
+	return hasAtom;
+}
+function readCharacterClass(pattern, start) {
+	let index = start + 1;
+	if (pattern[index] === "^") index++;
+	let any = false;
+	while (index < pattern.length) {
+		const char = pattern[index];
+		if (char === "]") return any ? index + 1 : -1;
+		if (char === "\\") {
+			if (!isSafeEscape(pattern[index + 1])) return -1;
+			index += 2;
+		} else {
+			if (char === "[") return -1;
+			index++;
+		}
+		any = true;
+	}
+	return -1;
+}
+function readBoundedQuantifier(pattern, start) {
+	const match = /^\{(\d{1,4})(?:,(\d{0,4}))?\}/.exec(pattern.slice(start));
+	if (!match) return -1;
+	const min = Number(match[1]);
+	const max = match[2] === void 0 || match[2] === "" ? min : Number(match[2]);
+	return min <= 1e3 && max <= 1e3 && max >= min ? start + match[0].length : -1;
+}
+function isSafeEscape(char) {
+	return char !== void 0 && ("dDsSwW\\.^$*+?{}[]|()-".includes(char) || !/[A-Za-z0-9]/.test(char));
+}
+
+//#endregion
+//#region src/mount.ts
+function mountUIDocument(host, document, options) {
+	if (!host || typeof host.replaceChildren !== "function") throw new TypeError("mountUIDocument requires an HTMLElement host.");
+	if (!options?.actionRuntime) throw new TypeError("mountUIDocument requires an actionRuntime.");
+	const context = {
+		document,
+		state: Object.assign(Object.create(null), document.state ?? {}),
+		options,
+		bindings: new Map(),
+		cleanups: [],
+		disposed: false
+	};
+	const root = createNode(document.root, context, void 0);
+	const container = globalThis.document.createElement("div");
+	container.setAttribute("data-aigui-ui", document.id);
+	container.appendChild(root);
+	host.replaceChildren(container);
+	let cleaned = false;
+	return () => {
+		if (cleaned) return;
+		cleaned = true;
+		context.disposed = true;
+		for (const cleanup of context.cleanups.splice(0).reverse()) try {
+			cleanup();
+		} catch {}
+	};
+}
+function createNode(node, context, form) {
+	switch (node.kind) {
+		case "stack": {
+			const element = base("div", node);
+			element.setAttribute("data-aigui-ui-stack", node.direction ?? "column");
+			if (node.gap) element.setAttribute("data-gap", node.gap);
+			if (node.align) element.setAttribute("data-align", node.align);
+			for (const child of node.children) element.appendChild(createNode(child, context, form));
+			return element;
+		}
+		case "grid": {
+			const element = base("div", node);
+			element.setAttribute("data-aigui-ui-grid", String(node.columns));
+			if (node.gap) element.setAttribute("data-gap", node.gap);
+			for (const child of node.children) element.appendChild(createNode(child, context, form));
+			return element;
+		}
+		case "text": {
+			const element = base("p", node);
+			element.setAttribute("data-tone", node.tone ?? "default");
+			bindText(element, node.text, context);
+			return element;
+		}
+		case "heading": {
+			const element = base(`h${node.level}`, node);
+			bindText(element, node.text, context);
+			return element;
+		}
+		case "divider": return base("hr", node);
+		case "list": {
+			const element = base(node.ordered ? "ol" : "ul", node);
+			for (const item of node.items) {
+				const li = globalThis.document.createElement("li");
+				li.textContent = scalarText(item);
+				element.appendChild(li);
+			}
+			return element;
+		}
+		case "table": {
+			const table = base("table", node);
+			const caption = globalThis.document.createElement("caption");
+			caption.textContent = node.caption;
+			table.appendChild(caption);
+			const thead = globalThis.document.createElement("thead");
+			const headRow = globalThis.document.createElement("tr");
+			for (const header of node.headers) {
+				const th = globalThis.document.createElement("th");
+				th.scope = "col";
+				th.textContent = header;
+				headRow.appendChild(th);
+			}
+			thead.appendChild(headRow);
+			table.appendChild(thead);
+			const tbody = globalThis.document.createElement("tbody");
+			for (const row of node.rows) {
+				const tr = globalThis.document.createElement("tr");
+				for (const cell of row) {
+					const td = globalThis.document.createElement("td");
+					td.textContent = scalarText(cell);
+					tr.appendChild(td);
+				}
+				tbody.appendChild(tr);
+			}
+			table.appendChild(tbody);
+			return table;
+		}
+		case "keyValue": return createKeyValue(node, context);
+		case "form": return createForm(node, context);
+		case "field": return createField(node, context, form);
+		case "button": return createButton(node, context);
+		case "card": return createCard(node, context);
+	}
+}
+function createKeyValue(node, context) {
+	const dl = base("dl", node);
+	for (const item of node.items) {
+		const dt = globalThis.document.createElement("dt");
+		dt.textContent = item.label;
+		const dd = globalThis.document.createElement("dd");
+		bindText(dd, item.value, context);
+		dl.append(dt, dd);
+	}
+	return dl;
+}
+function createForm(node, context) {
+	const form = base("form", node);
+	form.noValidate = true;
+	form.setAttribute("data-aigui-ui-form", node.id);
+	for (const child of node.children) form.appendChild(createNode(child, context, form));
+	const actionError = actionErrorElement(node.id);
+	const submit = globalThis.document.createElement("button");
+	submit.type = "submit";
+	submit.textContent = node.submitLabel ?? "Submit";
+	form.append(actionError, submit);
+	const owner = {};
+	const controller = new AbortController();
+	let pending = false;
+	const onSubmit = (event) => {
+		event.preventDefault();
+		if (pending || context.disposed) return;
+		const fields = collectFields(node);
+		const firstInvalid = fields.find((field) => !validateField(field, context, form));
+		if (firstInvalid) {
+			form.querySelector(`[data-aigui-ui-id="${firstInvalid.id}"] input, [data-aigui-ui-id="${firstInvalid.id}"] textarea, [data-aigui-ui-id="${firstInvalid.id}"] select`)?.focus();
+			return;
+		}
+		pending = true;
+		submit.disabled = true;
+		form.setAttribute("aria-busy", "true");
+		actionError.hidden = true;
+		const params = Object.create(null);
+		for (const field of fields) params[field.bind] = context.state[field.bind];
+		context.options.actionRuntime.dispatch({
+			type: node.submit.type,
+			params,
+			cardType: `ui:${context.document.id}:${node.id}`
+		}, {
+			owner,
+			signal: controller.signal
+		}).then(() => settle(), (error) => {
+			if (!context.disposed && !controller.signal.aborted) {
+				actionError.textContent = safeActionError(error);
+				actionError.hidden = false;
+			}
+			settle();
+		});
+		function settle() {
+			if (context.disposed) return;
+			pending = false;
+			submit.disabled = false;
+			form.removeAttribute("aria-busy");
+		}
+	};
+	form.addEventListener("submit", onSubmit);
+	context.cleanups.push(() => {
+		controller.abort();
+		form.removeEventListener("submit", onSubmit);
+	});
+	return form;
+}
+function createField(node, context, form) {
+	const container = base(node.fieldType === "radio" ? "fieldset" : "div", node);
+	container.setAttribute("data-aigui-ui-field", node.fieldType);
+	const controlId = `aigui-ui-${nextInstance()}-${context.document.id}-${node.id}`;
+	const errorId = `${controlId}-error`;
+	const error = globalThis.document.createElement("div");
+	error.id = errorId;
+	error.setAttribute("data-aigui-ui-field-error", node.id);
+	error.setAttribute("role", "alert");
+	error.hidden = true;
+	if (node.fieldType === "radio") {
+		const legend = globalThis.document.createElement("legend");
+		legend.textContent = node.label;
+		container.appendChild(legend);
+		for (const [index, option] of (node.options ?? []).entries()) {
+			const input = globalThis.document.createElement("input");
+			input.type = "radio";
+			input.id = `${controlId}-${index}`;
+			input.name = node.bind;
+			input.value = option.value;
+			input.checked = context.state[node.bind] === option.value;
+			input.required = node.required === true;
+			input.setAttribute("aria-describedby", errorId);
+			const label$1 = globalThis.document.createElement("label");
+			label$1.htmlFor = input.id;
+			label$1.textContent = option.label;
+			const onChange = () => {
+				if (input.checked) setState(node.bind, input.value, context);
+				clearFieldError(node, container);
+			};
+			input.addEventListener("change", onChange);
+			context.cleanups.push(() => input.removeEventListener("change", onChange));
+			container.append(input, label$1);
+		}
+		container.appendChild(error);
+		return container;
+	}
+	let control;
+	if (node.fieldType === "textarea") control = globalThis.document.createElement("textarea");
+	else if (node.fieldType === "select") {
+		const select = globalThis.document.createElement("select");
+		for (const option of node.options ?? []) {
+			const item = globalThis.document.createElement("option");
+			item.value = option.value;
+			item.textContent = option.label;
+			select.appendChild(item);
+		}
+		control = select;
+	} else {
+		const input = globalThis.document.createElement("input");
+		input.type = node.fieldType;
+		control = input;
+	}
+	control.id = controlId;
+	control.setAttribute("name", node.bind);
+	control.required = node.required === true;
+	control.setAttribute("aria-describedby", errorId);
+	if (node.placeholder !== void 0 && !(control instanceof HTMLSelectElement)) control.placeholder = node.placeholder;
+	if ((node.fieldType === "text" || node.fieldType === "textarea") && (control instanceof HTMLInputElement || control instanceof HTMLTextAreaElement)) {
+		if (node.minLength !== void 0) control.minLength = node.minLength;
+		if (node.maxLength !== void 0) control.maxLength = node.maxLength;
+		if (node.pattern !== void 0 && control instanceof HTMLInputElement) control.pattern = node.pattern;
+	}
+	if (node.fieldType === "number" && control instanceof HTMLInputElement) {
+		if (node.min !== void 0) control.min = String(node.min);
+		if (node.max !== void 0) control.max = String(node.max);
+	}
+	writeControl(control, node, context.state[node.bind]);
+	const label = globalThis.document.createElement("label");
+	label.htmlFor = controlId;
+	label.textContent = node.label;
+	const onInput = () => {
+		setState(node.bind, readControl(control, node), context);
+		clearFieldError(node, container);
+	};
+	control.addEventListener("input", onInput);
+	control.addEventListener("change", onInput);
+	context.cleanups.push(() => {
+		control.removeEventListener("input", onInput);
+		control.removeEventListener("change", onInput);
+	});
+	if (node.fieldType === "checkbox") container.append(control, label, error);
+	else container.append(label, control, error);
+	return container;
+}
+function createButton(node, context) {
+	const wrapper = globalThis.document.createElement("div");
+	wrapper.setAttribute("data-aigui-ui-button", node.variant ?? "secondary");
+	const button = base("button", node);
+	button.type = "button";
+	button.textContent = node.label;
+	const error = actionErrorElement(node.id);
+	wrapper.append(button, error);
+	const owner = {};
+	const controller = new AbortController();
+	let pending = false;
+	const onClick = () => {
+		if (pending || context.disposed) return;
+		pending = true;
+		button.disabled = true;
+		button.setAttribute("aria-busy", "true");
+		error.hidden = true;
+		const params = node.action.params === void 0 ? Object.create(null) : resolveBoundJSON(node.action.params, context.state);
+		context.options.actionRuntime.dispatch({
+			type: node.action.type,
+			params,
+			cardType: `ui:${context.document.id}:${node.id}`
+		}, {
+			owner,
+			signal: controller.signal
+		}).then(() => settle(), (cause) => {
+			if (!context.disposed && !controller.signal.aborted) {
+				error.textContent = safeActionError(cause);
+				error.hidden = false;
+			}
+			settle();
+		});
+		function settle() {
+			if (context.disposed) return;
+			pending = false;
+			button.disabled = false;
+			button.removeAttribute("aria-busy");
+		}
+	};
+	button.addEventListener("click", onClick);
+	context.cleanups.push(() => {
+		controller.abort();
+		button.removeEventListener("click", onClick);
+	});
+	return wrapper;
+}
+function createCard(node, context) {
+	const host = base("div", node);
+	host.setAttribute("data-aigui-ui-card", node.type);
+	let slot;
+	const update = () => {
+		const data = resolveBoundJSON(node.data, context.state);
+		if (slot) slot.update(data);
+		else {
+			slot = context.options.mountContext?.mountCard?.(host, {
+				type: node.type,
+				data
+			});
+			if (!slot) {
+				host.replaceChildren();
+				const fallback = globalThis.document.createElement("span");
+				fallback.setAttribute("data-aigui-ui-card-fallback", node.type);
+				fallback.textContent = "Card unavailable.";
+				host.appendChild(fallback);
+			}
+		}
+	};
+	for (const key of bindingKeys(node.data)) subscribe(key, update, context);
+	update();
+	context.cleanups.push(() => slot?.destroy());
+	return host;
+}
+function validateField(node, context, form) {
+	const container = form.querySelector(`[data-aigui-ui-id="${node.id}"]`);
+	if (!container) return true;
+	const value = context.state[node.bind];
+	let message = "";
+	if (node.required && (value === "" || value === null || value === false)) message = "This field is required.";
+	else if (node.fieldType === "number" && typeof value === "number") {
+		if (node.min !== void 0 && value < node.min) message = `Must be at least ${node.min}.`;
+		else if (node.max !== void 0 && value > node.max) message = `Must be at most ${node.max}.`;
+	} else if (typeof value === "string") {
+		if (node.minLength !== void 0 && value.length < node.minLength) message = `Must contain at least ${node.minLength} characters.`;
+		else if (node.maxLength !== void 0 && value.length > node.maxLength) message = `Must contain at most ${node.maxLength} characters.`;
+		else if (node.pattern !== void 0 && !new RegExp(node.pattern).test(value)) message = "Must match the required format.";
+		else if ((node.fieldType === "select" || node.fieldType === "radio") && !node.options?.some((option) => option.value === value)) message = "Select an allowed option.";
+	}
+	const controls = container.querySelectorAll("input, textarea, select");
+	const error = container.querySelector(`[data-aigui-ui-field-error="${node.id}"]`);
+	for (const control of controls) if (message) control.setAttribute("aria-invalid", "true");
+	else control.removeAttribute("aria-invalid");
+	if (error) {
+		error.textContent = message;
+		error.hidden = !message;
+	}
+	return !message;
+}
+function collectFields(node) {
+	const fields = [];
+	const walk = (children) => {
+		for (const child of children) if (child.kind === "field") fields.push(child);
+		else if (child.kind === "stack" || child.kind === "grid") walk(child.children);
+	};
+	walk(node.children);
+	return fields;
+}
+function bindText(element, expression, context) {
+	const update = () => {
+		element.textContent = scalarText(resolveScalar(expression, context.state));
+	};
+	if (isBinding(expression)) subscribe(expression.$state, update, context);
+	update();
+}
+function subscribe(key, update, context) {
+	let listeners = context.bindings.get(key);
+	if (!listeners) {
+		listeners = new Set();
+		context.bindings.set(key, listeners);
+	}
+	listeners.add(update);
+	context.cleanups.push(() => listeners?.delete(update));
+}
+function setState(key, value, context) {
+	if (Object.is(context.state[key], value)) return;
+	context.state[key] = value;
+	for (const update of context.bindings.get(key) ?? []) update();
+}
+function resolveScalar(value, state) {
+	return isBinding(value) ? state[value.$state] : value;
+}
+function bindingKeys(value) {
+	const keys = new Set();
+	const walk = (item) => {
+		if (isBinding(item)) keys.add(item.$state);
+		else if (Array.isArray(item)) item.forEach(walk);
+		else if (item !== null && typeof item === "object") Object.values(item).forEach(walk);
+	};
+	walk(value);
+	return keys;
+}
+function isBinding(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 1 && typeof value.$state === "string";
+}
+function scalarText(value) {
+	return value === null ? "" : String(value);
+}
+function readControl(control, field) {
+	if (field.fieldType === "checkbox" && control instanceof HTMLInputElement) return control.checked;
+	if (field.fieldType === "number") return control.value === "" ? null : Number(control.value);
+	return control.value;
+}
+function writeControl(control, field, value) {
+	if (field.fieldType === "checkbox" && control instanceof HTMLInputElement) control.checked = value === true;
+	else control.value = value === null ? "" : String(value);
+}
+function clearFieldError(node, container) {
+	for (const control of container.querySelectorAll("input, textarea, select")) control.removeAttribute("aria-invalid");
+	const error = container.querySelector(`[data-aigui-ui-field-error="${node.id}"]`);
+	if (error) {
+		error.textContent = "";
+		error.hidden = true;
+	}
+}
+function actionErrorElement(id) {
+	const error = globalThis.document.createElement("div");
+	error.setAttribute("data-aigui-ui-action-error", id);
+	error.setAttribute("role", "alert");
+	error.hidden = true;
+	return error;
+}
+function safeActionError(error) {
+	return error instanceof __ai_gui_core.ActionRuntimeError ? "Action failed." : "Action failed.";
+}
+function base(tag, node) {
+	const element = globalThis.document.createElement(tag);
+	element.setAttribute("data-aigui-ui-id", node.id);
+	return element;
+}
+let instance = 0;
+function nextInstance() {
+	return ++instance;
+}
+
+//#endregion
+//#region src/prompt.ts
+function uiPromptSpec(registry, actionRuntime, limits) {
+	const bounded = resolveUILimits(limits);
+	const actions = actionRuntime.listActionTypes();
+	const cards = registry.list();
+	const lines = [
+		"Declarative UI (fenced): emit exactly one ```ui fenced block containing one JSON document: {version:1,id,state?,root}.",
+		"Use only these node kinds: stack, grid, text, heading, divider, list, table, keyValue, form, field, button, card.",
+		"State is a flat scalar object. Bindings use only the exact form {\"$state\":\"key\"}. Actions are declarative; the application performs them.",
+		"Never emit HTML, Markdown, CSS, JavaScript, URLs, imports, remote components, workflows, artifact commands, generated code, or extra keys.",
+		`Bounds: ${bounded.nodes} nodes, depth ${bounded.depth}, ${bounded.children} children per container, ${bounded.sourceBytes} source bytes.`,
+		`Registered actions: ${actions.length ? actions.join(", ") : "none"}.`,
+		"Registered cards:"
+	];
+	if (!cards.length) lines.push("- none");
+	for (const card of cards) {
+		lines.push(`- ${card.type}: ${card.description}`);
+		const fields = schemaFields(card.schema);
+		if (fields) lines.push(`  fields: ${fields}`);
+	}
+	return lines.join("\n");
+}
+function schemaFields(schema) {
+	if (!schema?.properties) return "";
+	return Object.entries(schema.properties).map(([name, field]) => `${name}(${Array.isArray(field.type) ? field.type.join("|") : field.type ?? "any"})`).join(", ");
+}
+
+//#endregion
+//#region src/index.ts
+function ui(options) {
+	if (!options?.registry || !options?.actionRuntime) throw new TypeError("ui() requires registry and actionRuntime.");
+	const outputs = new WeakMap();
+	const rejected = new WeakSet();
+	const render = (node) => {
+		const cached = outputs.get(node);
+		if (cached) return cached;
+		let output;
+		if (!node.complete) output = {
+			kind: "html",
+			html: "<div data-aigui-block-loading=\"\" data-block-type=\"ui\"></div>"
+		};
+		else if (rejected.has(node)) output = invalidOutput();
+		else try {
+			const document = parseUIDocument(node.content ?? "", options);
+			output = {
+				kind: "mount",
+				mount: (host, mountContext) => mountUIDocument(host, document, {
+					actionRuntime: options.actionRuntime,
+					mountContext
+				})
+			};
+		} catch {
+			output = invalidOutput();
+		}
+		outputs.set(node, output);
+		return output;
+	};
+	return {
+		name: "ui",
+		nodeRenderers: { ui: render },
+		onASTCommit: (nodes) => {
+			let accepted = false;
+			for (const node of nodes) {
+				if (node.type !== "ui" || !node.complete) continue;
+				if (accepted) rejected.add(node);
+				else accepted = true;
+			}
+		},
+		promptSpec: () => uiPromptSpec(options.registry, options.actionRuntime, options.limits),
+		css: uiCss
+	};
+}
+function invalidOutput() {
+	return {
+		kind: "html",
+		html: "<div data-aigui-ui-invalid=\"\" role=\"alert\">Invalid UI.</div>"
+	};
+}
+
+//#endregion
+exports.DEFAULT_UI_LIMITS = DEFAULT_UI_LIMITS
+exports.UIDocumentError = UIDocumentError
+exports.UILimitError = UILimitError
+exports.mountUIDocument = mountUIDocument
+exports.parseUIDocument = parseUIDocument
+exports.resolveBoundJSON = resolveBoundJSON
+exports.resolveUILimits = resolveUILimits
+exports.ui = ui
+exports.uiCss = uiCss
+exports.uiPromptSpec = uiPromptSpec
+exports.validateUIDocument = validateUIDocument