@burdenoff/fe-libs 2026.1027.2 → 2026.1027.4

package/dist/node_modules/@openuidev/lang-core/dist/index.js

@@ -0,0 +1,3779 @@
+import { __toESM as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { TELEMETRY_REQUEST_TIMEOUT_MS as t, getPostHogConfig as n, isRuntimeTelemetryEnabled as r, normalizeProjectIdentity as i } from "./shared-Dzgc28Wo.js";
+import { clone as a, mergeDefs as o } from "../../../zod/v4/core/util.js";
+import { globalRegistry as s, registry as c } from "../../../zod/v4/core/registries.js";
+import { toJSONSchema as l } from "../../../zod/v4/core/json-schema-processors.js";
+import { _enum as u, any as d, array as f, literal as p, number as m, object as h, record as g, string as _, union as v } from "../../../zod/v4/classic/schemas.js";
+//#region node_modules/@openuidev/lang-core/dist/index.mjs
+var ee = /* @__PURE__ */ new WeakSet();
+function te(e) {
+	ee.add(e);
+}
+function y(e) {
+	return typeof e == "object" && !!e && ee.has(e);
+}
+var b = /* @__PURE__ */ new WeakMap();
+function x(e, t) {
+	b.set(e, t);
+}
+var S = /* @__PURE__ */ new WeakMap();
+function ne(e, t) {
+	return S.set(t, e), t;
+}
+function re(e, t) {
+	let n = b.get(e);
+	n && b.set(t, n);
+	let r = S.get(e);
+	r && S.set(t, r);
+}
+function ie(e, t) {
+	if (typeof e == "object" && e && "_def" in e && !("_zod" in e)) throw Error(`[OpenUI] Component "${t}" was defined with a Zod 3 schema. OpenUI requires Zod 4 schemas. If you're on zod@3.25+, import from "zod/v4" instead of "zod". See: https://zod.dev/v4/versioning`);
+}
+function C(e) {
+	return e?._zod?.def;
+}
+function ae(e) {
+	return C(e)?.type;
+}
+function oe(e) {
+	let t = ae(e);
+	return t === "optional" || t === "default" || t === "nullable";
+}
+function w(e) {
+	let t = e, n = C(t);
+	for (; n?.type === "optional" || n?.type === "default" || n?.type === "nullable";) t = n.innerType, n = C(t);
+	return t;
+}
+function se(e) {
+	return ae(w(e)) === "array";
+}
+function ce(e) {
+	let t = C(w(e));
+	if (t?.type === "array") return t.element ?? t.innerType;
+}
+function le(e) {
+	let t = C(w(e));
+	if (t?.type === "enum") {
+		if (Array.isArray(t.values)) return t.values;
+		if (t.entries && typeof t.entries == "object") return Object.keys(t.entries);
+	}
+}
+function ue(e, t) {
+	try {
+		let n = t?.get(e);
+		if (n?.id) return n.id;
+	} catch {}
+	if (typeof e == "object" && e) return b.get(e);
+}
+function T(e) {
+	let t = C(e);
+	if (t?.type === "union" && Array.isArray(t.options)) return t.options;
+}
+function de(e) {
+	let t = C(e);
+	if (t?.type === "object" && t.shape && typeof t.shape == "object") return t.shape;
+}
+function E(e, t) {
+	let n = y(e), r = fe(w(e), t);
+	if (r) return n ? `$binding<${r}>` : r;
+}
+function fe(e, t) {
+	let n = typeof e == "object" && !!e && S.get(e);
+	if (n) return `@${n}`;
+	let r = ue(e, t);
+	if (r) return r;
+	let i = T(e);
+	if (i) {
+		let e = i.map((e) => E(e, t)).filter(Boolean);
+		if (e.length > 0) return e.join(" | ");
+	}
+	if (se(e)) {
+		let n = ce(e);
+		if (!n) return;
+		let r = E(n, t);
+		return r ? T(w(n)) === void 0 ? `${r}[]` : `(${r})[]` : void 0;
+	}
+	let a = ae(e);
+	if (a === "string") return "string";
+	if (a === "number") return "number";
+	if (a === "boolean") return "boolean";
+	if (a === "any") return "any";
+	if (a === "record") {
+		let n = C(e);
+		return `Record<${E(n?.keyType, t) ?? "string"}, ${E(n?.valueType, t) ?? "any"}>`;
+	}
+	let o = le(e);
+	if (o) return o.map((e) => `"${e}"`).join(" | ");
+	if (a === "literal") {
+		let t = C(e)?.values;
+		if (Array.isArray(t) && t.length === 1) {
+			let e = t[0];
+			return typeof e == "string" ? `"${e}"` : String(e);
+		}
+	}
+	let s = de(e);
+	return s ? `{${Object.entries(s).map(([e, n]) => {
+		let r = oe(n) ? "?" : "", i = E(n, t);
+		return i ? `${e}${r}: ${i}` : `${e}${r}`;
+	}).join(", ")}}` : "any";
+}
+function pe(e, t) {
+	return Object.entries(e).map(([e, n]) => ({
+		name: e,
+		isOptional: oe(n),
+		isArray: se(n),
+		typeAnnotation: E(n, t)
+	}));
+}
+function me(e, t) {
+	return `${e}(${t.map((e) => e.typeAnnotation ? e.isOptional ? `${e.name}?: ${e.typeAnnotation}` : `${e.name}: ${e.typeAnnotation}` : e.isArray ? e.isOptional ? `[${e.name}]?` : `[${e.name}]` : e.isOptional ? `${e.name}?` : e.name).join(", ")})`;
+}
+function he(e, t, n, r) {
+	let i = me(e, pe(t._zod.def.shape, r)), a = n && E(n, r);
+	return a ? `${i} → ${a}` : i;
+}
+var D = (e) => {
+	throw Error(`[extend] ${e}`);
+};
+function ge(e, t) {
+	let n = _e(e, t.components), r = be(n, ye(n));
+	return {
+		...e,
+		id: void 0,
+		components: Se(n, r),
+		componentGroups: Oe(e.componentGroups, n.removed),
+		functions: [...e.functions ?? [], ...t.functions?.add ?? []],
+		actions: [...e.actions ?? [], ...t.actions?.add ?? []]
+	};
+}
+function _e(e, t = {}) {
+	let n = new Map(e.components.map((e) => [e.name, e])), r = new Map(e.components.map((e) => [e.props, e.name])), i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Set(), o = (e) => {
+		n.set(e.name, e), r.set(e.props, e.name), a.add(e.name);
+	};
+	for (let e of t.add ?? []) {
+		let { component: t, slots: r } = "slots" in e ? e : {
+			component: e,
+			slots: void 0
+		}, a = t.name;
+		n.has(a) && D(`Component "${a}" already exists. Use override.`), r?.length === 0 && D(`"slots" for "${a}" is empty. Omit it to only list it.`), o(t), r && i.set(a, r);
+	}
+	let s = /* @__PURE__ */ new Set();
+	for (let e of t.override ?? []) n.has(e.name) || D(`Cannot override "${e.name}": not in the library. Use add.`), s.has(e.name) && D(`Component "${e.name}" is overridden twice.`), s.add(e.name), o(e);
+	let c = new Set(t.remove);
+	for (let t of c) a.has(t) && D(`Cannot remove "${t}": it is added or overridden in the same call.`), n.delete(t) || D(`Cannot remove "${t}": not in the library.`), t === e.root && D(`Cannot remove "${t}": it is the library root.`);
+	return {
+		byName: n,
+		nameOf: r,
+		slotRequests: i,
+		removed: c
+	};
+}
+function ve(e, t) {
+	let n = w(e), r = C(n);
+	return r?.type === "array" ? ve(r.element, t) : T(n)?.some((e) => t.has(e)) ? n : void 0;
+}
+function ye({ byName: e, nameOf: t }) {
+	let n = [];
+	for (let r of e.values()) for (let [e, i] of Object.entries(r.props.shape)) ve(i, t) && n.push(`${r.name}.${e}`);
+	return n;
+}
+function be(e, t) {
+	let n = /* @__PURE__ */ new Map();
+	for (let [r, i] of e.slotRequests) for (let a of i) {
+		let i = xe(a, r, t, e.byName), o = n.get(i) ?? [];
+		o.includes(r) || n.set(i, [...o, r]);
+	}
+	return n;
+}
+function xe(e, t, n, r) {
+	if (n.includes(e)) return e;
+	let i = e.split(".")[0], a = n.filter((e) => e.startsWith(`${i}.`));
+	if (!e.includes(".") && a.length === 1) return a[0];
+	let o = `Slot "${e}" for "${t}"`;
+	return r.has(i) || D(`${o}: "${i}" is not in the library.`), a.length || D(`${o}: "${i}" has no content slot (a prop that is a union of components, or an optional or array of one).`), D(`${o} must be one content slot. Candidates: ${a.join(", ")}.`);
+}
+function Se(e, t) {
+	let { byName: n, nameOf: r, removed: i } = e, a = new Map(n), o = /* @__PURE__ */ new Map();
+	for (let r of Ce(e, t)) {
+		let e = n.get(r), t = {}, i = De(e.props, { get shape() {
+			return t;
+		} });
+		a.set(r, {
+			...e,
+			props: i,
+			ref: i
+		}), o.set(r, t);
+	}
+	let s = (e) => a.get(e).props, c = (e, t) => D(`Cannot remove "${e}": it is the only type allowed in ${t.path}.`), l = (e, t, n) => {
+		let a = r.get(e);
+		if (a !== void 0) return i.has(a) && c(a, t), s(a);
+		let o = C(e);
+		if (!o || o.type === "lazy") return e;
+		if (n.has(e)) return n.get(e);
+		n.set(e, e);
+		let u = (e) => l(e, t, n), d = {}, f = T(e), p = f?.some((e) => r.has(e));
+		for (let [e, t] of Object.entries(o)) {
+			if (e === "checks" || p && e === "options") continue;
+			let n = Te(e, t, u);
+			Ee(n, t) || (d[e] = n);
+		}
+		if (p) {
+			let n = f.filter((e) => !i.has(r.get(e) ?? "")).map(u), a = e === t.union ? t.added.filter((e) => !n.includes(e)) : [];
+			!n.length && !a.length && c(r.get(f[0]), t);
+			let o = [...n, ...a];
+			Ee(o, f) || (d.options = o);
+		}
+		let m = Object.keys(d).length ? De(e, d) : e;
+		return n.set(e, m), m;
+	};
+	for (let [e, i] of o) for (let [a, o] of Object.entries(n.get(e).props.shape)) {
+		let n = `${e}.${a}`, c = (t.get(n) ?? []).map(s);
+		i[a] = l(o, {
+			path: n,
+			union: ve(o, r),
+			added: c
+		}, /* @__PURE__ */ new Map());
+	}
+	return [...a.values()];
+}
+function Ce({ byName: e, nameOf: t, removed: n }, r) {
+	let i = /* @__PURE__ */ new Map();
+	for (let [n, r] of e) {
+		let e = /* @__PURE__ */ new Set();
+		for (let n of Object.values(r.props.shape)) we(n, t, e);
+		i.set(n, e);
+	}
+	let a = (r) => {
+		let i = t.get(r);
+		return n.has(i) || e.get(i).props !== r;
+	}, o = new Set([...r.keys()].map((e) => e.split(".")[0])), s = new Set([...e.keys()].filter((e) => o.has(e)));
+	for (let [e, t] of i) [...t].some(a) && s.add(e);
+	for (let e = !0; e;) {
+		e = !1;
+		for (let [n, r] of i) s.has(n) || ![...r].some((e) => s.has(t.get(e))) || (s.add(n), e = !0);
+	}
+	return s;
+}
+function we(e, t, n, r = /* @__PURE__ */ new Set()) {
+	if (t.has(e)) return void n.add(e);
+	let i = C(e);
+	if (!(!i || i.type === "lazy" || r.has(e))) {
+		r.add(e);
+		for (let [e, a] of Object.entries(i)) e !== "checks" && Te(e, a, (e) => we(e, t, n, r));
+	}
+}
+function Te(e, t, n) {
+	if (C(t)) return n(t);
+	if (Array.isArray(t)) return t.map(n);
+	if (e !== "shape") return t;
+	let r = {};
+	for (let [e, i] of Object.entries(t)) r[e] = n(i);
+	return r;
+}
+function Ee(e, t) {
+	if (e === t) return !0;
+	if (C(e)) return !1;
+	let n = Object.entries(e);
+	return n.length === Object.keys(t).length && n.every(([e, n]) => n === t[e]);
+}
+function De(e, t) {
+	let n = e, r = a(n, o(n._zod.def, t));
+	re(n, r), y(n) && te(r);
+	let i = s.get(n);
+	return i && s.add(r, i), r;
+}
+function Oe(e, t) {
+	return e?.map((e) => ({
+		...e,
+		components: e.components.filter((e) => !t.has(e))
+	})).filter((e) => e.components.length);
+}
+function ke(e, t) {
+	if (ie(e, t), e?._zod?.def.type !== "object") throw Error(`[OpenUI] "${t}" params must be a z.object().`);
+}
+function O(e) {
+	return ke(e.params, e.name), e.returns && ie(e.returns, e.name), e;
+}
+function k(e) {
+	ke(e.params, e.name);
+	let t = h({
+		type: p(e.name),
+		params: e.params
+	});
+	return {
+		...e,
+		ref: ne(e.name, t)
+	};
+}
+function Ae(e, t) {
+	if (!t || e == null) return;
+	if (!t.includes(".")) return e[t];
+	let n = e;
+	for (let e of t.split(".")) {
+		if (n == null) return;
+		n = n[e];
+	}
+	return n;
+}
+function A(e) {
+	if (typeof e == "number") return e;
+	if (typeof e == "string") {
+		let t = Number(e);
+		return isNaN(t) ? 0 : t;
+	}
+	return typeof e == "boolean" ? +!!e : 0;
+}
+var je = (e) => e.reduce((e, t) => e + A(t), 0), j = () => f(d()), M = () => h({ numbers: f(m()) }), Me = () => h({ number: m() }), Ne = [
+	O({
+		name: "Count",
+		description: "Returns array length",
+		params: h({ array: j() }),
+		returns: m(),
+		fn: ({ array: e }) => Array.isArray(e) ? e.length : 0
+	}),
+	O({
+		name: "First",
+		description: "Returns first element of array",
+		params: h({ array: j() }),
+		returns: d(),
+		fn: ({ array: e }) => Array.isArray(e) ? e[0] ?? null : null
+	}),
+	O({
+		name: "Last",
+		description: "Returns last element of array",
+		params: h({ array: j() }),
+		returns: d(),
+		fn: ({ array: e }) => Array.isArray(e) ? e[e.length - 1] ?? null : null
+	}),
+	O({
+		name: "Sum",
+		description: "Sum of numeric array",
+		params: M(),
+		returns: m(),
+		fn: ({ numbers: e }) => Array.isArray(e) ? je(e) : 0
+	}),
+	O({
+		name: "Avg",
+		description: "Average of numeric array",
+		params: M(),
+		returns: m(),
+		fn: ({ numbers: e }) => Array.isArray(e) && e.length ? je(e) / e.length : 0
+	}),
+	O({
+		name: "Min",
+		description: "Minimum value in array",
+		params: M(),
+		returns: m(),
+		fn: ({ numbers: e }) => Array.isArray(e) && e.length ? e.reduce((e, t) => Math.min(e, A(t)), A(e[0])) : 0
+	}),
+	O({
+		name: "Max",
+		description: "Maximum value in array",
+		params: M(),
+		returns: m(),
+		fn: ({ numbers: e }) => Array.isArray(e) && e.length ? e.reduce((e, t) => Math.max(e, A(t)), A(e[0])) : 0
+	}),
+	O({
+		name: "Sort",
+		description: "Sort array by field. Direction: \"asc\" (default) or \"desc\"",
+		params: h({
+			array: j(),
+			field: _(),
+			direction: u(["asc", "desc"]).optional()
+		}),
+		returns: j(),
+		fn: ({ array: e, field: t, direction: n }) => {
+			if (!Array.isArray(e)) return e;
+			let r = String(t ?? ""), i = String(n ?? "asc") === "desc";
+			return [...e].sort((e, t) => {
+				let n = r ? Ae(e, r) : e, a = r ? Ae(t, r) : t, o = typeof n == "number" || typeof n == "string" && !isNaN(Number(n)) && n !== "", s = typeof a == "number" || typeof a == "string" && !isNaN(Number(a)) && a !== "";
+				if (o && s) {
+					let e = A(n) - A(a);
+					return i ? -e : e;
+				}
+				let c = String(n ?? "").localeCompare(String(a ?? ""));
+				return i ? -c : c;
+			});
+		}
+	}),
+	O({
+		name: "Filter",
+		description: "Filter array by field value",
+		params: h({
+			array: j(),
+			field: _(),
+			operator: u([
+				"==",
+				"!=",
+				">",
+				"<",
+				">=",
+				"<=",
+				"contains"
+			]),
+			value: d()
+		}),
+		returns: j(),
+		fn: ({ array: e, field: t, operator: n, value: r }) => {
+			if (!Array.isArray(e)) return [];
+			let i = String(t ?? ""), a = String(n ?? "==");
+			return e.filter((e) => {
+				let t = i ? Ae(e, i) : e;
+				switch (a) {
+					case "==": return t == r;
+					case "!=": return t != r;
+					case ">": return A(t) > A(r);
+					case "<": return A(t) < A(r);
+					case ">=": return A(t) >= A(r);
+					case "<=": return A(t) <= A(r);
+					case "contains": return String(t ?? "").includes(String(r ?? ""));
+					default: return !1;
+				}
+			});
+		}
+	}),
+	O({
+		name: "Round",
+		description: "Round to N decimal places (default 0)",
+		params: h({
+			number: m(),
+			decimals: m().optional()
+		}),
+		returns: m(),
+		fn: ({ number: e, decimals: t }) => {
+			let n = A(e), r = 10 ** (t == null ? 0 : A(t));
+			return Math.round(n * r) / r;
+		}
+	}),
+	O({
+		name: "Abs",
+		description: "Absolute value",
+		params: Me(),
+		returns: m(),
+		fn: ({ number: e }) => Math.abs(A(e))
+	}),
+	O({
+		name: "Floor",
+		description: "Round down to nearest integer",
+		params: Me(),
+		returns: m(),
+		fn: ({ number: e }) => Math.floor(A(e))
+	}),
+	O({
+		name: "Ceil",
+		description: "Round up to nearest integer",
+		params: Me(),
+		returns: m(),
+		fn: ({ number: e }) => Math.ceil(A(e))
+	}),
+	{
+		name: "Each",
+		description: "Evaluate template for each element. varName is the loop variable — use it ONLY inside the template expression (inline). Do NOT create a separate statement for the template.",
+		params: h({
+			array: j(),
+			varName: _(),
+			template: d()
+		}),
+		lazy: !0
+	}
+], Pe = Object.fromEntries(Ne.map((e) => [e.name, e])), N = {
+	Run: "run",
+	ToAssistant: "continue_conversation",
+	OpenUrl: "open_url",
+	Set: "set",
+	Reset: "reset"
+};
+function Fe(e) {
+	let t = d();
+	return x(t, e), t;
+}
+var Ie = () => h({
+	type: p("open_url"),
+	url: _()
+}), Le = () => h({
+	type: p("continue_conversation"),
+	context: _().optional()
+}), Re = v([
+	Ie(),
+	Le(),
+	h({
+		type: _(),
+		params: g(_(), d()).optional()
+	})
+]);
+x(Re, "ActionExpression");
+function ze() {
+	return Re;
+}
+var P = {
+	OpenUrl: { ref: ne("OpenUrl", Ie()) },
+	ToAssistant: { ref: ne("ToAssistant", Le()) }
+}, Be = {
+	ActionExpression: Re,
+	OpenUrl: P.OpenUrl.ref,
+	ToAssistant: P.ToAssistant.ref
+}, Ve = [
+	{
+		...k({
+			name: "Run",
+			description: "Execute a Mutation or re-fetch a Query (ref must be a declared Query/Mutation)",
+			params: h({ ref: Fe("Query | Mutation") })
+		}),
+		lazy: !0
+	},
+	{
+		...k({
+			name: "ToAssistant",
+			description: "Send a message to the assistant (for conversational buttons like \"Tell me more\", \"Explain this\"). The optional context is any value (object, array, string, number) passed to the assistant as hidden data, e.g. @ToAssistant(\"Show details\", {orderId: 42})",
+			params: h({
+				message: _(),
+				context: d().optional()
+			})
+		}),
+		ref: P.ToAssistant.ref,
+		step: ({ message: e, context: t }) => ({
+			type: N.ToAssistant,
+			message: String(e ?? ""),
+			context: t ?? void 0
+		})
+	},
+	{
+		...k({
+			name: "OpenUrl",
+			description: "Navigate to a URL",
+			params: h({ url: _() })
+		}),
+		ref: P.OpenUrl.ref,
+		step: ({ url: e }) => ({
+			type: N.OpenUrl,
+			url: String(e ?? "")
+		})
+	},
+	{
+		...k({
+			name: "Set",
+			description: "Set a $variable to a specific value",
+			params: h({
+				variable: Fe("$variable"),
+				value: d()
+			})
+		}),
+		lazy: !0
+	},
+	{
+		...k({
+			name: "Reset",
+			description: "Reset $variables to their declared defaults; pass several to reset each (e.g. @Reset($title, $priority) restores $title=\"\" and $priority=\"medium\")",
+			params: h({ variable: Fe("$variable") })
+		}),
+		lazy: !0
+	}
+], He = Object.fromEntries(Ve.map((e) => [e.name, e])), Ue = (e, t) => ({
+	kind: e,
+	params: Object.keys(t.params.shape).map((e) => ({
+		name: e,
+		required: !1
+	})),
+	builtin: !0,
+	...t.lazy ? { lazy: !0 } : {}
+}), F = new Map([
+	...Ne.map((e) => [e.name, Ue("function", e)]),
+	...Ve.map((e) => [e.name, Ue("action", e)]),
+	["Action", {
+		kind: "action",
+		params: [{
+			name: "steps",
+			required: !0
+		}],
+		builtin: !0,
+		lazy: !0
+	}]
+]);
+function I(e) {
+	return e?.callDefs ?? F;
+}
+function L(e) {
+	return F.has(e);
+}
+function We(e, t) {
+	return F.get(e)?.kind === "action" || !!t && Object.prototype.hasOwnProperty.call(t, e);
+}
+var R = {
+	Query: "Query",
+	Mutation: "Mutation"
+};
+function z(e) {
+	return e in R;
+}
+var Ge = "lang_core_system_prompt_generation_used", Ke = "lang_core_parser_parse_used", qe = .1, Je = .1, Ye = "1.0.1", Xe = Symbol.for("@openuidev/lang-core/telemetry/v1");
+function Ze(e) {
+	let t = (e.tools?.length ?? 0) > 0, n = e.toolCalls ?? t, r = e.bindings ?? n, i = Object.entries(e.components).sort(([e], [t]) => e.localeCompare(t)).map(([e, t]) => ({
+		name: e,
+		signature: t.signature,
+		description: t.description ?? null
+	})), a = (e.componentGroups ?? []).map((e) => ({
+		name: e.name,
+		components: [...e.components].sort(),
+		notes: [...e.notes ?? []]
+	})).sort((e, t) => e.name.localeCompare(t.name));
+	return {
+		root: e.root ?? "Root",
+		components: i,
+		componentGroups: a,
+		modes: {
+			toolCalls: n,
+			bindings: r,
+			editMode: e.editMode === !0,
+			inlineMode: e.inlineMode === !0
+		}
+	};
+}
+async function Qe(e) {
+	let t = globalThis.crypto?.subtle;
+	if (!t) throw Error("Web Crypto is unavailable");
+	let n = new TextEncoder().encode(e), r = await t.digest("SHA-256", n);
+	return Array.from(new Uint8Array(r), (e) => e.toString(16).padStart(2, "0")).join("");
+}
+function $e(e) {
+	return Qe(JSON.stringify(Ze(e)));
+}
+function et() {
+	let e = globalThis.process;
+	if (!(!e || typeof e != "object")) return e;
+}
+function tt() {
+	let e = globalThis;
+	return e.navigator?.product === "ReactNative" || !!(e.window && e.document);
+}
+function nt() {
+	let e = globalThis.WorkerGlobalScope;
+	return !!(e && e.prototype.isPrototypeOf(globalThis));
+}
+function rt() {
+	if (tt()) return;
+	let e = globalThis, t = et();
+	if (e.Bun && typeof e.Bun == "object") return {
+		name: "bun",
+		version: e.Bun.version,
+		env: t?.env,
+		process: t
+	};
+	if (e.Deno && typeof e.Deno == "object") return {
+		name: "deno",
+		version: e.Deno.version?.deno
+	};
+	if (typeof e.EdgeRuntime == "string") return {
+		name: "edge",
+		version: e.EdgeRuntime
+	};
+	if (typeof e.WebSocketPair == "function") return { name: "edge" };
+	if (!nt() && (t?.release?.name === "node" || typeof t?.versions?.node == "string" && t.versions.node.length > 0)) return {
+		name: "node",
+		version: t.versions?.node,
+		env: t.env,
+		process: t
+	};
+}
+function it(e) {
+	let t = e?.NODE_ENV;
+	return t === "production" || t === "development" || t === "test" ? t : "unknown";
+}
+function at() {
+	let e = globalThis;
+	return e[Xe] ??= { runtimeId: globalThis.crypto.randomUUID() }, e[Xe];
+}
+function ot(e) {
+	let t = e.getBuiltinModule?.("node:child_process")?.execFile;
+	return t ? new Promise((e) => {
+		try {
+			t("git", [
+				"config",
+				"--local",
+				"--get",
+				"remote.origin.url"
+			], {
+				encoding: "utf8",
+				timeout: 1e3,
+				windowsHide: !0
+			}, (t, n) => {
+				let r = n?.trim();
+				e(t || !r ? void 0 : r);
+			});
+		} catch {
+			e(void 0);
+		}
+	}) : Promise.resolve(void 0);
+}
+async function st(e) {
+	if (!e) return;
+	let t = await ot(e) || e.env?.REPOSITORY_URL || e.cwd?.();
+	return t && i(t) || void 0;
+}
+function ct(e) {
+	let t = i(e);
+	return t ? Qe(t) : Promise.reject(/* @__PURE__ */ TypeError("Repository identifier is empty"));
+}
+function lt(e, t) {
+	return t.name === "node" ? (e.projectHash ??= Promise.resolve().then(() => st(t.process)).then((e) => e ? ct(e) : void 0).catch(() => void 0), e.projectHash) : Promise.resolve(void 0);
+}
+async function ut(t) {
+	if (!t.env) return {
+		id: null,
+		isCI: !1
+	};
+	try {
+		let t = await import("../../../ci-info/index.js").then((t) => /* @__PURE__ */ e(t.default, 1));
+		return {
+			id: t.id,
+			isCI: t.isCI
+		};
+	} catch {
+		return {
+			id: null,
+			isCI: !1
+		};
+	}
+}
+async function dt(e, r, i) {
+	let a = n(i.env);
+	await globalThis.fetch(a.captureUrl, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			api_key: a.apiKey,
+			event: e,
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			properties: r
+		}),
+		keepalive: !0,
+		signal: globalThis.AbortSignal.timeout(t)
+	});
+}
+async function ft(e, t, n, r, i, a) {
+	let [o, s, c] = await Promise.all([
+		n,
+		lt(e, i),
+		ut(i)
+	]);
+	await dt(Ge, {
+		distinct_id: e.runtimeId,
+		$process_person_profile: !1,
+		event_id: globalThis.crypto.randomUUID(),
+		telemetry_schema_version: 1,
+		system_prompt_config_hash_version: 1,
+		system_prompt_config_hash: o,
+		component_count: Object.keys(t.components).length,
+		tool_count: t.tools?.length ?? 0,
+		sdk_name: "@openuidev/lang-core",
+		sdk_version: Ye,
+		api_surface: "generate_system_prompt",
+		input_shape: r,
+		runtime: i.name,
+		runtime_version: i.version,
+		environment: a,
+		ci: c.isCI,
+		...c.id ? { ci_name: c.id } : {},
+		sample_rate: qe,
+		...s ? {
+			project_hash_version: 1,
+			project_hash: s
+		} : {}
+	}, i);
+}
+function pt(e, t) {
+	try {
+		let n = rt();
+		if (!n || typeof globalThis.fetch != "function" || !globalThis.crypto?.subtle || typeof globalThis.crypto.randomUUID != "function" || typeof globalThis.AbortSignal?.timeout != "function") return;
+		let i = n.env, a = it(i);
+		if (!r(i) || Math.random() >= qe) return;
+		let o = at(), s = $e(e);
+		Promise.resolve().then(() => ft(o, e, s, t, n, a)).catch(() => void 0);
+	} catch {}
+}
+function mt(e) {
+	let t = {
+		"unknown-component": 0,
+		"missing-required": 0,
+		"null-required": 0,
+		"inline-reserved": 0,
+		"excess-args": 0,
+		"type-mismatch": 0,
+		"unknown-function": 0,
+		"no-root": 0
+	};
+	for (let n of e.meta.errors) t[n.code] += 1;
+	return {
+		unknown_component_count: t["unknown-component"],
+		missing_required_count: t["missing-required"],
+		null_required_count: t["null-required"],
+		inline_reserved_count: t["inline-reserved"],
+		excess_args_count: t["excess-args"]
+	};
+}
+function ht(e) {
+	return {
+		outcome: e.meta.errors.length > 0 ? "invalid" : e.root ? "valid" : "no_renderable_root",
+		incomplete: e.meta.incomplete,
+		has_renderable_root: e.root !== null,
+		statement_count: e.meta.statementCount,
+		unresolved_count: e.meta.unresolved.length,
+		orphaned_count: e.meta.orphaned.length,
+		validation_error_count: e.meta.errors.length,
+		...mt(e)
+	};
+}
+async function gt(e, t) {
+	let { state: n, runtime: r, environment: i } = e, [a, o] = await Promise.all([lt(n, r), ut(r)]);
+	await dt(Ke, {
+		distinct_id: n.runtimeId,
+		$process_person_profile: !1,
+		event_id: globalThis.crypto.randomUUID(),
+		telemetry_schema_version: 1,
+		sdk_name: "@openuidev/lang-core",
+		sdk_version: Ye,
+		api_surface: "parser.parse",
+		runtime: r.name,
+		runtime_version: r.version,
+		environment: i,
+		ci: o.isCI,
+		...o.id ? { ci_name: o.id } : {},
+		sample_rate: Je,
+		...t,
+		...a ? {
+			project_hash_version: 1,
+			project_hash: a
+		} : {}
+	}, r);
+}
+function _t() {
+	try {
+		let e = rt();
+		if (!e || typeof globalThis.fetch != "function" || typeof globalThis.crypto?.randomUUID != "function" || typeof globalThis.AbortSignal?.timeout != "function") return;
+		let t = e.env;
+		return !r(t) || Math.random() >= Je ? void 0 : {
+			state: at(),
+			runtime: e,
+			environment: it(t)
+		};
+	} catch {
+		return;
+	}
+}
+function vt(e, t) {
+	if (e) try {
+		let n = ht(t);
+		Promise.resolve().then(() => gt(e, n)).catch(() => void 0);
+	} catch {}
+}
+function yt(e) {
+	if (e) try {
+		Promise.resolve().then(() => gt(e, { outcome: "threw" })).catch(() => void 0);
+	} catch {}
+}
+var bt = /^#\/\$defs\/(.+)$/;
+function B(e) {
+	return typeof e == "object" && !!e && !Array.isArray(e);
+}
+function xt(e, t, n, r) {
+	if (Array.isArray(e)) {
+		e.forEach((e, i) => xt(e, `${t}/${i}`, n, r));
+		return;
+	}
+	if (!B(e)) return;
+	let i = e.$ref;
+	if (typeof i == "string") {
+		let e = bt.exec(i);
+		(!e || !n.has(e[1])) && r.push({
+			code: "unresolved-ref",
+			message: `Unresolvable $ref "${i}" at ${t} — refs must be "#/$defs/<name>" pointing at a component in $defs.`,
+			path: t
+		});
+	}
+	for (let [i, a] of Object.entries(e)) i !== "$ref" && xt(a, `${t}/${i}`, n, r);
+}
+function St(e) {
+	let t = [];
+	if (!B(e)) return [{
+		code: "invalid-shape",
+		message: "chatLibrary must be an object."
+	}];
+	let { root: n, schema: r, componentGroups: i } = e;
+	if (n !== void 0 && (typeof n != "string" || n.length === 0) && t.push({
+		code: "invalid-shape",
+		message: "chatLibrary.root, when present, must be a non-empty string.",
+		path: "root"
+	}), !B(r)) return t.push({
+		code: "invalid-shape",
+		message: "chatLibrary.schema must be an object with a $defs map of component schemas.",
+		path: "schema"
+	}), t;
+	let a = r.$defs;
+	if (!B(a) || Object.keys(a).length === 0) return t.push({
+		code: "invalid-shape",
+		message: "chatLibrary.schema.$defs must be a non-empty object keyed by component name.",
+		path: "schema/$defs"
+	}), t;
+	let o = new Set(Object.keys(a));
+	typeof n == "string" && n.length > 0 && !o.has(n) && t.push({
+		code: "root-not-found",
+		message: `Root component "${n}" was not found in schema.$defs. Available components: ${[...o].join(", ")}.`,
+		path: "root"
+	});
+	for (let [e, n] of Object.entries(a)) {
+		let r = `$defs/${e}`;
+		if (!B(n)) {
+			t.push({
+				code: "invalid-shape",
+				message: `${r} must be an object component schema.`,
+				path: r
+			});
+			continue;
+		}
+		let i = n.properties;
+		i !== void 0 && !B(i) && t.push({
+			code: "invalid-shape",
+			message: `${r}/properties must be an object.`,
+			path: `${r}/properties`
+		});
+		let a = n.required;
+		if (a !== void 0) if (!Array.isArray(a) || a.some((e) => typeof e != "string")) t.push({
+			code: "invalid-required",
+			message: `${r}/required must be an array of property names.`,
+			path: `${r}/required`
+		});
+		else {
+			let e = new Set(B(i) ? Object.keys(i) : []);
+			for (let n of a) e.has(n) || t.push({
+				code: "invalid-required",
+				message: `${r} lists required property "${n}" that is not in properties.`,
+				path: `${r}/required`
+			});
+		}
+		xt(i, `${r}/properties`, o, t);
+	}
+	for (let e of i ?? []) {
+		if (!B(e) || typeof e.name != "string" || !Array.isArray(e.components)) {
+			t.push({
+				code: "invalid-shape",
+				message: "Each componentGroups entry must be {name: string, components: string[], notes?: string[]}.",
+				path: "componentGroups"
+			});
+			continue;
+		}
+		for (let n of e.components) (typeof n != "string" || !o.has(n)) && t.push({
+			code: "unknown-group-component",
+			message: `Component group "${e.name}" references unknown component "${String(n)}".`,
+			path: "componentGroups"
+		});
+	}
+	return t;
+}
+var Ct = "]]>openui:config\n", wt = "0.1.0";
+function Tt(e) {
+	if (!e) return;
+	let t = {};
+	return e.examples && (t.examples = e.examples), e.preamble && (t.preamble = e.preamble), e.additionalRules && (t.additionalRules = e.additionalRules), Object.keys(t).length > 0 ? t : void 0;
+}
+function Et(e) {
+	let t;
+	if (e.library) {
+		let n = St(e.library);
+		if (n.length > 0) throw Error(`[generateSystemPrompt] Invalid library: ${n.map((e) => e.message).join(" ")}`);
+		let { components: r, ...i } = e.library, a = Tt(e.promptOptions);
+		t = {
+			chatLibrary: i,
+			...a ? { systemPromptOptions: a } : {}
+		};
+	} else {
+		if (e.promptOptions && Tt(e.promptOptions)) throw Error("[generateSystemPrompt] promptOptions requires a library — the built-in library ignores it.");
+		t = { libraryVersion: wt };
+	}
+	let n = `${Ct}${JSON.stringify(t)}`;
+	return e.instructions ? `${n}\n${e.instructions}` : n;
+}
+function Dt(e) {
+	let t = e.type;
+	if (t === "string") {
+		let t = e.enum;
+		return t ? t.map((e) => `"${e}"`).join(" | ") : "string";
+	}
+	if (t === "number" || t === "integer") return "number";
+	if (t === "boolean") return "boolean";
+	if (t === "array") {
+		let t = e.items;
+		return t ? `${Dt(t)}[]` : "any[]";
+	}
+	if (t === "object") {
+		let t = e.properties;
+		if (t && Object.keys(t).length > 0) {
+			let n = e.required ?? [];
+			return `{${Object.entries(t).map(([e, t]) => `${e}${n.includes(e) ? "" : "?"}: ${Dt(t)}`).join(", ")}}`;
+		}
+		return "object";
+	}
+	return "any";
+}
+function Ot(e) {
+	let t = e.type;
+	if (t === "string") return "";
+	if (t === "number" || t === "integer") return 0;
+	if (t === "boolean") return !1;
+	if (t === "array") return [];
+	if (t === "object") {
+		let t = e.properties;
+		if (t && Object.keys(t).length > 0) {
+			let e = {};
+			for (let [n, r] of Object.entries(t)) e[n] = Ot(r);
+			return e;
+		}
+		return {};
+	}
+	return null;
+}
+var kt = "You are an AI assistant that responds using openui-lang, a declarative UI language. Your ENTIRE response must be valid openui-lang code — no markdown, no explanations, just openui-lang.";
+function At(e, t) {
+	let n = [
+		"## Syntax Rules",
+		"",
+		"1. Each statement is on its own line: `identifier = Expression`",
+		`2. \`root\` is the entry point — every program must define \`root = ${e}(...)\``,
+		"3. Expressions are: strings (\"...\"), numbers, booleans (true/false), null, arrays ([...]), objects ({...}), or component calls TypeName(arg1, arg2, ...)",
+		"4. Use references for readability: define `name = ...` on one line, then use `name` later",
+		"5. EVERY variable (except root) MUST be referenced by at least one other variable. Unreferenced variables are silently dropped and will NOT render. Always include defined variables in their parent's children/items array.",
+		"6. Arguments are POSITIONAL (order matters, not names). Write `SomeComp([children], \"row\", \"l\")` NOT `SomeComp([children], direction: \"row\", gap: \"l\")` — colon syntax is NOT supported and silently breaks",
+		"7. Optional arguments can be omitted from the end"
+	], r = 8;
+	return t.bindings && n.push(`${r++}. Declare mutable state with \`$varName = defaultValue\`. Components marked with \`$binding\` can read/write these. Undeclared $variables are auto-created with null default.`), t.supportsExpressions && n.push(`${r++}. String concatenation: \`"text" + $var + "more"\``, `${r++}. Dot member access: \`query.field\` reads a field; on arrays it extracts that field from every element`, `${r++}. Index access: \`arr[0]\`, \`data[index]\``, `${r++}. Arithmetic operators: +, -, *, /, % (work on numbers; + is string concat when either side is a string)`, `${r++}. Comparison: ==, !=, >, <, >=, <=`, `${r++}. Logical: &&, ||, ! (prefix)`, `${r++}. Ternary: \`condition ? valueIfTrue : valueIfFalse\``, `${r++}. Parentheses for grouping: \`(a + b) * c\``), n.push("- Strings use double quotes with backslash escaping"), n.join("\n");
+}
+function V(e) {
+	return e.description ? `@${e.signature} — ${e.description}` : `@${e.signature}`;
+}
+function jt(e, t) {
+	let n = [...Object.values(Pe).map((e) => V({
+		...e,
+		signature: he(e.name, e.params, e.returns)
+	})), ...e].join("\n");
+	return `## Built-in Functions
+
+Data functions prefixed with \`@\` to distinguish from components. These are the ONLY functions available — do NOT invent new ones.
+Use @-prefixed built-in functions (@Count, @Sum, @Avg, @Min, @Max, @Round) on ${t ? "Query results" : "data"}. Do NOT hardcode computed values.
+
+${n}
+
+Builtins compose — output of one is input to the next:
+\`@Count(@Filter(data.rows, "field", "==", "val"))\` for KPIs/chart values, \`@Round(@Avg(data.rows.score), 1)\`, \`@Each(data.rows, "item", Comp(item.field))\` for per-item rendering.
+Array pluck: \`data.rows.field\` extracts a field from every row → use with @Sum, @Avg, charts, tables.
+
+IMPORTANT @Each rule: The loop variable (e.g. "item") is ONLY available inside the @Each template expression. Always inline the template — do NOT extract it to a separate statement.
+CORRECT: \`list = @Each(rows, "t", Comp(t.name))\`
+WRONG: \`item = Comp(t.name)\` then \`list = @Each(rows, "t", item)\`, because t is undefined in item.`;
+}
+function Mt() {
+	return "## Query — Live Data Fetching\n\nFetch data from available tools. Returns defaults instantly, swaps in real data when it arrives.\n\n```\nmetrics = Query(\"tool_name\", {arg1: value, arg2: $binding}, {defaultField: 0, defaultData: []}, refreshInterval?)\n```\n\n- First arg: tool name (string)\n- Second arg: arguments object (may reference $bindings — re-fetches automatically on change)\n- Third arg: default data (rendered immediately before fetch resolves)\n- Fourth arg (optional): refresh interval in seconds (e.g. 30 for auto-refresh every 30s)\n- Use dot access on results: metrics.totalEvents, metrics.data.day (array pluck)\n- Query results must use regular identifiers: `metrics = Query(...)`, NOT `$metrics = Query(...)`\n- Manual refresh: `Button(\"Refresh\", Action([@Run(query1), @Run(query2)]), \"secondary\")` — re-fetches the listed queries\n- Refresh all queries: create Action with @Run for each query";
+}
+function Nt() {
+	return "## Mutation — Write Operations\n\nExecute state-changing tool calls (create, update, delete). Unlike Query (auto-fetches on render), Mutation fires only on button click via Action.\n\n```\nresult = Mutation(\"tool_name\", {arg1: $binding, arg2: \"value\"})\n```\n\n- First arg: tool name (string)\n- Second arg: arguments object (evaluated with current $binding values at click time)\n- result.status: \"idle\" | \"loading\" | \"success\" | \"error\"\n- result.data: tool response on success\n- result.error: error message on failure\n- Mutation results use regular identifiers: `result = Mutation(...)`, NOT `$result`\n- Show loading state: `result.status == \"loading\" ? TextContent(\"Saving...\") : null`";
+}
+var Pt = "## Action — Button Behavior";
+function Ft(e) {
+	return Object.values(He).filter((t) => t.name === "Run" ? e.toolCalls : t.name === "Set" || t.name === "Reset" ? e.bindings : !0);
+}
+function It(e, t) {
+	let n = [...Ft(e).map((e) => `- ${V({
+		...e,
+		signature: he(e.name, e.params)
+	})}`), ...t], r = [];
+	e.toolCalls && r.push("Example — mutation + refresh + reset (PREFERRED pattern):\n```\n$binding = \"default\"\nresult = Mutation(\"tool_name\", {field: $binding})\ndata = Query(\"tool_name\", {}, {rows: []})\nonSubmit = Action([@Run(result), @Run(data), @Reset($binding)])\n```"), r.push("Example — simple nav:\n```\nviewBtn = Button(\"View\", @OpenUrl(\"https://example.com\"))\n```");
+	let i = ["- An action can be assigned to a variable or inlined: Button(\"Go\", onSubmit) and Button(\"Go\", Action([...])) both work"];
+	return e.toolCalls && i.push("- If a @Run(mutation) step fails, remaining steps are skipped (halt on failure)", "- @Run(queryRef) re-fetches the query (fire-and-forget, cannot fail)"), `${Pt}
+
+An action wires a button click to operations. Pass one @-prefixed step bare, e.g. Button("Ask", @ToAssistant("Tell me more")). Put several steps in Action([...]), e.g. Button("Read", Action([@OpenUrl("https://example.com"), @ToAssistant("Summarize this page")])). Steps execute in order.
+Buttons without an action automatically send their label to the assistant (equivalent to @ToAssistant(label)).
+
+Available steps:
+${n.join("\n")}
+
+${r.join("\n\n")}
+
+${i.join("\n")}`;
+}
+function Lt() {
+	return "## Interactive Filters\n\nTo let the user filter data with a dropdown:\n1. Declare a $variable with a default: `$dateRange = \"14\"`\n2. Create a Select with name, items, and binding: `Select(\"dateRange\", [SelectItem(\"7\", \"Last 7 days\"), ...], null, null, $dateRange)`\n3. Wrap in FormControl for a label: `FormControl(\"Date Range\", Select(...))`\n4. Pass $dateRange in Query args: `Query(\"tool\", {dateRange: $dateRange}, {defaults})`\n5. When the user changes the Select, $dateRange updates and the Query automatically re-fetches\n\nFILTER WIRING RULE: If a $binding filter is visible in the UI, EVERY relevant Query MUST reference that $binding in its args. Never show a filter dropdown while hardcoding the query args.\n\nRules for $variables:\n- $variables hold simple values (strings or numbers), NOT arrays or objects\n- $variables must be bound to a Select/Input component via the value argument (last positional arg) to be interactive\n- Queries must use regular identifiers (NOT $variables): `metrics = Query(...)` not `$metrics = Query(...)`\n- **Auto-declare**: You do NOT need to explicitly declare $variables. If you use `$foo` without declaring it, the parser auto-creates `$foo = null`. You can still declare explicitly to set a default: `$days = \"14\"`\n\n## Forms\n\nSimple form — no $bindings needed. Field values are managed internally by the Form via the name prop:\n```\ncontactForm = Form(\"contact\", submitBtn, [nameField, emailField])\nnameField = FormControl(\"Name\", Input(\"name\", \"Your name\", \"text\", {required: true}))\nemailField = FormControl(\"Email\", Input(\"email\", \"your@email.com\", \"email\", {required: true, email: true}))\nsubmitBtn = Button(\"Submit\")\n```\n\nUse $bindings when you need to read field values elsewhere (in Action context, Query args, or conditionals). They are auto-declared:\n```\n$role = \"engineer\"\ncontactForm = Form(\"contact\", submitBtn, [nameField, emailField, roleField])\nnameField = FormControl(\"Name\", Input(\"name\", \"Enter your name\", \"text\", {required: true}, $name))\nemailField = FormControl(\"Email\", Input(\"email\", \"Enter your email\", \"email\", {required: true, email: true}, $email))\nroleField = FormControl(\"Role\", Select(\"role\", [SelectItem(\"engineer\", \"Engineer\"), SelectItem(\"designer\", \"Designer\"), SelectItem(\"pm\", \"PM\")], null, {required: true}, $role))\nsubmitBtn = Button(\"Submit\")\n```\n\nFor form + mutation patterns (create, refresh, reset), see the Action section example above.\n\nIMPORTANT: Always add validation rules to form fields used with Mutations. Use OBJECT syntax: {required: true, email: true, minLength: 8}. The renderer shows error messages automatically and blocks submit when validation fails.";
+}
+function Rt() {
+	return "## Edit Mode\n\nThe runtime merges by statement name: same name = replace, new name = append.\nOutput ONLY statements that changed or are new. Everything else is kept automatically.\n\n### Delete\nTo remove a component, re-declare its parent without that component in the parent's children array. The removed component and any statements only it referenced are automatically garbage-collected.\n\n### Patch size guide\n- Changing a title or label: 1 statement\n- Adding a component: 2-3 statements (the new component + parent update)\n- Removing a component: 1 statement (re-declare parent without the removed child)\n- Adding a filter + wiring to query: 3-5 statements\n- Restructuring into tabs: 5-10 statements\n\n### Rules\n- Reuse existing statement names exactly — do not rename\n- Do NOT re-emit unchanged statements — the runtime keeps them\n- A typical edit patch is 1-10 statements, not 20+\n- If the existing code already satisfies the request, output only the root statement\n- NEVER output the entire program as a patch. Only output what actually changes\n- If you are about to output more than 10 statements, reconsider — most edits need fewer";
+}
+function zt(e, t) {
+	let n = [`1. \`root = ${e}(...)\` — UI shell appears immediately`];
+	if (t.supportsExpressions) {
+		n.push("2. $variable declarations — state ready for bindings"), t.toolCalls && n.push("3. Query statements — defaults resolve immediately so components render with data");
+		let e = n.length;
+		n.push(`${e + 1}. Component definitions — fill in with data already available`), n.push(`${e + 2}. Data values — leaf content last`);
+	} else n.push("2. Component definitions — fill in as they stream"), n.push("3. Data values — leaf content last");
+	return `## Hoisting & Streaming (CRITICAL)
+
+openui-lang supports hoisting: a reference can be used BEFORE it is defined. The parser resolves all references after the full input is parsed.
+
+During streaming, the output is re-parsed on every chunk. Undefined references are temporarily unresolved and appear once their definitions stream in. This creates a progressive top-down reveal — structure first, then data fills in.
+
+**Recommended statement order for optimal streaming:**
+${n.join("\n")}
+
+Always write the root = ${e}(...) statement first so the UI shell appears immediately, even before child data has streamed in.`;
+}
+function Bt() {
+	return "## Inline Mode\n\nYou are in inline mode. You can respond in two ways:\n\n### 1. Code response (when the user wants to CREATE or CHANGE the UI)\nWrap openui-lang code in triple-backtick fences. You can include explanatory text before/after:\n\nHere's your dashboard:\n\n```openui-lang\nroot = RootComp([header, content])\nheader = SomeHeader(\"Title\")\ncontent = SomeContent(\"Hello world\")\n```\n\nI created a simple layout with a header.\n\n### 2. Text-only response (when the user asks a QUESTION)\nIf the user asks \"what is this?\", \"explain the chart\", \"how does this work\", etc. — respond with plain text. Do NOT output any openui-lang code. The existing dashboard stays unchanged.\n\n### Rules\n- When the user asks for changes, output ONLY the changed/new statements in a fenced block\n- When the user asks a question, respond with text only — NO code. The dashboard stays unchanged.\n- The parser extracts code from fences automatically. Text outside fences is shown as chat.";
+}
+function Vt() {
+	return "## Data Workflow\n\nWhen tools are available, follow this workflow:\n1. FIRST: Call the most relevant tool to inspect the real data shape before generating code\n2. Use Query() for READ operations (data that should stay live) — NEVER hardcode tool results as literal arrays or objects\n3. Use Mutation() for WRITE operations (create, update, delete) — triggered by button clicks via @Run(mutationRef)\n4. Use the real data from step 1 as condensed Query defaults (3-5 rows) so the UI renders immediately\n5. Use @-prefixed builtins (@Count, @Filter, @Sort, @Sum) on Query results for KPIs and aggregations — the runtime evaluates these live on every refresh\n6. Hardcoded arrays are ONLY for static display data (labels, options) where no tool exists\n\nWRONG — you called a tool and got data back, but you inlined the results:\n```\nopenCount = 2\nitem1 = SomeComp(\"first item title\")\nitem2 = SomeComp(\"second item title\")\nlist = SomeList([item1, item2])\nchart = SomeChart([\"A\", \"B\"], [12, 8])\n```\nThis is static — it shows stale data and won't update. Creating item1, item2, item3... manually is ALWAYS wrong when a tool exists.\n\nRIGHT — use Query() for live data, Mutation() for writes, @builtins to derive values:\n```\ndata = Query(\"tool_name\", {}, {rows: []})\nopenCount = @Count(@Filter(data.rows, \"field\", \"==\", \"value\"))\nlist = @Each(data.rows, \"item\", SomeComp(item.title, item.field))\ncreateResult = Mutation(\"create_tool\", {title: $title})\nsubmitBtn = Button(\"Create\", Action([@Run(createResult), @Run(data), @Reset($title)]))\n```\nEverything derives from the Query — when data refreshes, the entire dashboard updates automatically.";
+}
+function Ht(e, t) {
+	let n = [`1. root = ${e}(...) is the FIRST line (for optimal streaming).`, "2. Every referenced name is defined. Every defined name (other than root) is reachable from root."];
+	return t.toolCalls && n.push("3. Every Query result is referenced by at least one component."), t.bindings && n.push(`${t.toolCalls ? "4" : "3"}. Every $binding appears in at least one component or expression.`), t.toolCalls && t.bindings && n.push("5. Every visible filter $binding appears in at least one Query args object."), `## Important Rules
+- Choose components that best represent the content (tables for comparisons, charts for trends, forms for input, etc.)
+
+## Final Verification
+Before finishing, walk your output and verify:
+${n.join("\n")}`;
+}
+function Ut(e) {
+	let t = "";
+	if (e.inputSchema) {
+		let n = e.inputSchema.properties, r = e.inputSchema.required ?? [];
+		n && Object.keys(n).length > 0 && (t = Object.entries(n).map(([e, t]) => `${e}${r.includes(e) ? "" : "?"}: ${Dt(t)}`).join(", "));
+	}
+	let n = "";
+	e.outputSchema && (n = ` → ${Dt(e.outputSchema)}`);
+	let r = `- ${e.name}(${t})${n}`;
+	return e.description && (r += `\n  ${e.description}`), r;
+}
+function Wt(e) {
+	let t = [], n = [], r = [];
+	for (let t of e) typeof t == "string" ? n.push(t) : r.push(t);
+	t.push("## Available Tools"), t.push(""), t.push("Use these with Query() for read operations or Mutation() for write operations. The LLM decides which is appropriate based on the tool's purpose."), t.push("");
+	for (let e of n) t.push(`- ${e}`);
+	for (let e of r) t.push(Ut(e));
+	let i = r.filter((e) => e.outputSchema);
+	if (i.length > 0) {
+		t.push(""), t.push("### Default values for Query results"), t.push(""), t.push("Use these shapes as minimal Query defaults:");
+		for (let e of i) {
+			let n = Ot(e.outputSchema);
+			t.push(`- ${e.name}: \`${JSON.stringify(n)}\``);
+		}
+	}
+	return t.push(""), t.push("CRITICAL: Use ONLY the tools listed above in Query() and Mutation() calls. Do NOT invent or guess tool names. If the user asks for functionality that doesn't match any available tool, use realistic mock data instead of fabricating a tool call."), t.join("\n");
+}
+var Gt = /[:|] @[A-Z]/;
+function Kt(e, t) {
+	let n = [
+		"## Component Signatures",
+		"",
+		"Arguments marked with ? are optional. Sub-components can be inline or referenced; prefer references for better streaming."
+	];
+	if (t.usesActionExpression) {
+		let r = [...Ft(t).map((e) => e.name), ...Object.keys(e.actions ?? {})].map((e) => `@${e}`);
+		n.push(`Props typed \`ActionExpression\` accept one @step, or Action([@steps...]) for several. See the Action section for available steps (${r.join(", ")}).`), Object.values(e.components).some((e) => Gt.test(e.signature ?? "")) && n.push("Props typed like `@OpenUrl | @ToAssistant` accept only the steps listed.");
+	}
+	(t.bindings || Object.values(e.components).some((e) => e.signature?.includes("$binding"))) && n.push("Props marked `$binding<type>` accept a `$variable` reference for two-way binding.");
+	let r = (e) => e.description ? `${e.signature} — ${e.description}` : e.signature;
+	if (e.componentGroups?.length) {
+		let t = /* @__PURE__ */ new Set();
+		for (let i of e.componentGroups) {
+			n.push("", `### ${i.name}`);
+			for (let a of i.components) {
+				if (t.has(a)) continue;
+				let i = e.components[a];
+				i && (t.add(a), n.push(r(i)));
+			}
+			if (i.notes?.length) for (let e of i.notes) n.push(e);
+		}
+		let i = Object.keys(e.components).filter((e) => !t.has(e));
+		if (i.length) {
+			n.push("", "### Other");
+			for (let t of i) {
+				let i = e.components[t];
+				n.push(r(i));
+			}
+		}
+	} else {
+		n.push("");
+		for (let [, t] of Object.entries(e.components)) n.push(r(t));
+	}
+	return n.join("\n");
+}
+function qt(e) {
+	let t = e.root ?? "Root", n = !!e.tools?.length, r = e.toolCalls ?? n, i = e.bindings ?? r, a = r || i, o = Object.values(e.components).some((e) => e.signature?.includes("ActionExpression") || Gt.test(e.signature ?? "")), s = [];
+	s.push(e.preamble ?? kt), s.push(""), s.push(At(t, {
+		supportsExpressions: a,
+		bindings: i
+	})), s.push(""), s.push(Kt(e, {
+		toolCalls: r,
+		bindings: i,
+		usesActionExpression: o
+	}));
+	let c = Object.values(e.functions ?? {}).map(V);
+	e.builtinFunctions ?? a ? (s.push(""), s.push(jt(c, r))) : c.length && (s.push(""), s.push(`## Built-in Functions\n\n${c.join("\n")}`)), r && (s.push(""), s.push(Mt()), s.push(""), s.push(Nt()));
+	let l = Object.values(e.actions ?? {}).map((e) => `- ${V(e)}`);
+	o ? (s.push(""), s.push(It({
+		toolCalls: r,
+		bindings: i
+	}, l))) : l.length && (s.push(""), s.push(`${Pt}\n\nPass one step, or Action([...]) with several steps, as a button's action.\n\nAvailable steps:\n${l.join("\n")}`)), r && i && (s.push(""), s.push(Lt())), r && (s.push(""), s.push(Vt())), e.tools?.length && (s.push(""), s.push(Wt(e.tools))), s.push(""), s.push(zt(t, {
+		supportsExpressions: a,
+		toolCalls: r
+	}));
+	let u = [...e.examples ?? [], ...e.toolExamples ?? []];
+	if (u.length) {
+		s.push(""), s.push("## Examples"), s.push("");
+		for (let e of u) s.push(e), s.push("");
+	}
+	if (e.editMode && (s.push(""), s.push(Rt())), e.inlineMode && (s.push(""), s.push(Bt())), s.push(Ht(t, {
+		toolCalls: r,
+		bindings: i
+	})), e.additionalRules?.length) {
+		s.push("");
+		for (let t of e.additionalRules) s.push(`- ${t}`);
+	}
+	return s.join("\n");
+}
+function Jt(e) {
+	if (Yt(e)) return Et(e);
+	if (!Xt(e)) {
+		let t = qt(e);
+		return pt(e, "legacy_prompt_spec"), t;
+	}
+	let t = {
+		...e.library,
+		...e.promptOptions
+	}, n = qt(t);
+	return pt(t, "library_spec"), n;
+}
+function Yt(e) {
+	return "cloud" in e && e.cloud === !0;
+}
+function Xt(e) {
+	return "library" in e && typeof e.library == "object";
+}
+function Zt(e) {
+	return ie(e.props, e.name), x(e.props, e.name), {
+		...e,
+		ref: e.props
+	};
+}
+function Qt(e, t) {
+	let n = {};
+	for (let [r, i] of Object.entries(e)) n[r] = {
+		signature: he(r, i.props, void 0, t),
+		description: i.description
+	};
+	return n;
+}
+function $t(e, t) {
+	let n = Object.entries(e);
+	if (!n.length) return;
+	let r = {};
+	for (let [e, i] of n) r[e] = {
+		signature: he(e, i.params, "returns" in i ? i.returns : void 0, t),
+		description: i.description
+	};
+	return r;
+}
+var en = 0;
+function tn() {
+	return typeof globalThis.crypto?.randomUUID == "function" ? globalThis.crypto.randomUUID() : (en += 1, `openui-lib-${Date.now().toString(36)}-${en.toString(36)}`);
+}
+function nn(e) {
+	let t = {}, n = c(), r = tn();
+	for (let r of e.components) n.add(r.props, { id: r.name }), t[r.name] = r;
+	for (let [e, r] of Object.entries(Be)) t[e] || n.add(r, { id: e });
+	if (e.root && !t[e.root]) {
+		let n = Object.keys(t).join(", ");
+		throw Error(`[createLibrary] Root component "${e.root}" was not found in components. Available components: ${n}`);
+	}
+	let i = new Set(Object.keys(t)), a = (e, t) => {
+		if (L(t) || z(t) || i.has(t)) throw Error(`[createLibrary] ${e} "${t}" collides with a built-in, component, function, or action of the same name. Rename it.`);
+		i.add(t);
+	}, o = {};
+	for (let t of e.functions ?? []) a("Function", t.name), o[t.name] = t;
+	let s = {};
+	for (let t of e.actions ?? []) a("Action", t.name), s[t.name] = t, n.add(t.ref, { id: t.name });
+	let u = () => {
+		let e = $t(o, n), t = $t(s, n);
+		return {
+			...e ? { functions: e } : {},
+			...t ? { actions: t } : {}
+		};
+	}, d = {
+		components: t,
+		componentGroups: e.componentGroups,
+		functions: o,
+		actions: s,
+		root: e.root,
+		id: e.id,
+		__libraryId: r,
+		prompt(r) {
+			return qt({
+				root: e.root,
+				components: Qt(t, n),
+				componentGroups: e.componentGroups,
+				...u(),
+				...r
+			});
+		},
+		toSpec() {
+			return {
+				root: e.root,
+				components: Qt(t, n),
+				componentGroups: e.componentGroups,
+				...u(),
+				schema: m(),
+				...e.id === void 0 ? {} : { id: e.id }
+			};
+		},
+		toJSONSchema() {
+			return m();
+		},
+		extend(t) {
+			return nn(ge(e, t));
+		}
+	};
+	function f(e) {
+		let { $schema: t, $defs: r, ...i } = l(e, { metadata: n });
+		return i;
+	}
+	function p(e) {
+		let t = Object.entries(e);
+		if (t.length) return Object.fromEntries(t.map(([e, t]) => [e, {
+			description: t.description,
+			params: f(t.params),
+			..."returns" in t && t.returns ? { returns: f(t.returns) } : {}
+		}]));
+	}
+	function m() {
+		let e = l(h(Object.fromEntries(Object.entries(t).map(([e, t]) => [e, t.props]))), { metadata: n });
+		for (let [n, r] of Object.entries(t)) {
+			let t = e.$defs?.[n];
+			t && r.description && (t.description = r.description);
+		}
+		let r = p(o);
+		r && (e.functions = r);
+		let i = p(s);
+		return i && (e.actions = i), e;
+	}
+	return d;
+}
+var H = "]]>openui:", rn = /^\]\]>openui:([a-z]+)(?:\?(.*))?$/, an = /([^\n])(?=\]\]>openui:content(?:\?|\r?\n|$))/g, on = /[^\n](\]\]>[a-z:]*)$/, sn = (e) => encodeURIComponent(e).replace(/[!'()~]/g, (e) => `%${e.charCodeAt(0).toString(16).toUpperCase()}`).replace(/%20/g, "+"), cn = (e) => {
+	try {
+		return decodeURIComponent(e.replace(/\+/g, " "));
+	} catch {
+		return e;
+	}
+};
+function ln(e = "") {
+	let t = {};
+	for (let n of e.split("&")) {
+		let e = n.indexOf("="), r = cn(e === -1 ? n : n.slice(0, e));
+		r && (t[r] = e === -1 ? "" : cn(n.slice(e + 1)));
+	}
+	return t;
+}
+function un(e, { streaming: t } = {}) {
+	let n = e.replace(an, "$1\n"), r = t ? on.exec(n) : null;
+	r && `${H}content`.startsWith(r[1]) && (n = n.slice(0, r.index + 1));
+	let i = n.split("\n"), a = i[i.length - 1], o = t && a !== "" && (a.startsWith(H) || H.startsWith(a));
+	o && i.pop();
+	let s = [{
+		kind: null,
+		attributes: {},
+		lines: []
+	}], c = () => {
+		let e = s[s.length - 1].lines;
+		e.length && (e[e.length - 1] = e[e.length - 1].replace(/\r$/, ""));
+	}, l = -1;
+	for (let [e, t] of i.entries()) {
+		let n = rn.exec(t.replace(/\r$/, ""));
+		if (!n) {
+			s[s.length - 1].lines.push(t);
+			continue;
+		}
+		if (c(), n[1] === "end") {
+			if (l = s.length - 1, e === i.length - 2 && i[e + 1] === "") break;
+			continue;
+		}
+		s.push({
+			kind: n[1],
+			attributes: ln(n[2]),
+			lines: []
+		});
+	}
+	o && c();
+	let u = s.map((e) => e.kind), d = Math.max(0, u.lastIndexOf("content")), f = u.lastIndexOf("context"), p = f > d ? s[f].lines.join("\n") : null;
+	try {
+		typeof p == "string" && (p = JSON.parse(p));
+	} catch {}
+	let m = s[d], h = l >= d;
+	return {
+		content: m.lines.join("\n"),
+		context: p,
+		attributes: m.attributes,
+		end: h
+	};
+}
+function dn({ content: e, context: t, attributes: n, end: r }) {
+	let i = Object.entries(n ?? {}).map(([e, t]) => `${sn(e)}=${sn(t)}`).join("&"), a = `${H}content${i ? `?${i}` : ""}\n${e}`;
+	return t != null && (a += `\n${H}context\n${typeof t == "string" ? t : JSON.stringify(t)}`), r ? `${a}\n${H}end` : a;
+}
+function U(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return !1;
+	let t = e;
+	return t.type === "element" && typeof t.typeName == "string" && typeof t.props == "object" && t.props !== null && typeof t.partial == "boolean";
+}
+var fn = /* @__PURE__ */ function(e) {
+	return e.ContinueConversation = "continue_conversation", e.OpenUrl = "open_url", e;
+}({});
+function pn(e) {
+	switch (e.k) {
+		case "StateRef":
+		case "RuntimeRef":
+		case "BinOp":
+		case "UnaryOp":
+		case "Ternary":
+		case "Member":
+		case "Index":
+		case "Assign": return !0;
+		default: return !1;
+	}
+}
+var mn = new Set([
+	"Comp",
+	"Ref",
+	"StateRef",
+	"RuntimeRef",
+	"BinOp",
+	"UnaryOp",
+	"Ternary",
+	"Member",
+	"Index",
+	"Assign",
+	"Str",
+	"Num",
+	"Bool",
+	"Null",
+	"Arr",
+	"Obj",
+	"Ph"
+]);
+function W(e) {
+	return !e || typeof e != "object" || Array.isArray(e) ? !1 : mn.has(e.k);
+}
+function hn(e, t) {
+	let n = (e) => {
+		switch (t(e), e.k) {
+			case "Comp":
+				e.args.forEach(n), Object.values(e.mappedProps ?? {}).forEach(n);
+				break;
+			case "Arr":
+				e.els.forEach(n);
+				break;
+			case "Obj":
+				e.entries.forEach(([, e]) => n(e));
+				break;
+			case "BinOp":
+				n(e.left), n(e.right);
+				break;
+			case "UnaryOp":
+				n(e.operand);
+				break;
+			case "Ternary":
+				n(e.cond), n(e.then), n(e.else);
+				break;
+			case "Member":
+				n(e.obj);
+				break;
+			case "Index":
+				n(e.obj), n(e.index);
+				break;
+			case "Assign":
+				n(e.value);
+				break;
+		}
+	};
+	n(e);
+}
+function gn(e) {
+	return e == null ? { k: "Null" } : typeof e == "string" ? {
+		k: "Str",
+		v: e
+	} : typeof e == "number" ? {
+		k: "Num",
+		v: e
+	} : typeof e == "boolean" ? {
+		k: "Bool",
+		v: e
+	} : Array.isArray(e) ? {
+		k: "Arr",
+		els: e.map(gn)
+	} : typeof e == "object" ? {
+		k: "Obj",
+		entries: Object.entries(e).map(([e, t]) => [e, gn(t)])
+	} : { k: "Null" };
+}
+function _n(e) {
+	switch (e.k) {
+		case "Str":
+		case "Num":
+		case "Bool": return { v: e.v };
+		case "Null": return { v: null };
+		case "Arr": {
+			let t = [];
+			for (let n of e.els) {
+				let e = _n(n);
+				if (!e) return;
+				t.push(e.v);
+			}
+			return { v: t };
+		}
+		case "Obj": {
+			let t = {};
+			for (let [n, r] of e.entries) {
+				let e = _n(r);
+				if (!e) return;
+				t[n] = e.v;
+			}
+			return { v: t };
+		}
+		default: return;
+	}
+}
+var vn = 1, yn = 2, bn = 3, xn = 4, G = 5, Sn = 6, Cn = 7, wn = 8, Tn = 9;
+function En(e) {
+	let t = 0, n = () => e[t] ?? { t: 13 }, r = () => {
+		let e = n();
+		return t++, e;
+	}, i = (e) => {
+		n().t === e && t++;
+	};
+	function a(e) {
+		switch (e.t) {
+			case 34: return vn;
+			case 32: return yn;
+			case 31: return bn;
+			case 25:
+			case 26: return xn;
+			case 27:
+			case 28:
+			case 29:
+			case 30: return G;
+			case 20:
+			case 21: return Sn;
+			case 22:
+			case 23:
+			case 24: return Cn;
+			case 19:
+			case 3: return Tn;
+			default: return 0;
+		}
+	}
+	function o(e = 0) {
+		let t = s();
+		for (; a(n()) > e;) t = c(t);
+		return t;
+	}
+	function s() {
+		let a = n();
+		if (a.t === 14) return r(), {
+			k: "Str",
+			v: a.v
+		};
+		if (a.t === 15) return r(), {
+			k: "Num",
+			v: a.v
+		};
+		if (a.t === 10) return r(), {
+			k: "Bool",
+			v: !0
+		};
+		if (a.t === 11) return r(), {
+			k: "Bool",
+			v: !1
+		};
+		if (a.t === 12) return r(), { k: "Null" };
+		if (a.t === 3) return u();
+		if (a.t === 5) return d();
+		if (a.t === 18) {
+			let e = a.v;
+			return r(), n().t === 9 ? (r(), {
+				k: "Assign",
+				target: e,
+				value: o(0)
+			}) : {
+				k: "StateRef",
+				n: e
+			};
+		}
+		if (a.t === 17) {
+			let n = a.v;
+			return e[t + 1]?.t === 1 && (!L(n) || n === "Action") ? l() : (r(), {
+				k: "Ref",
+				n
+			});
+		}
+		if (a.t === 35) {
+			if (e[t + 1]?.t === 1) {
+				let e = l();
+				return e.k === "Comp" && !L(e.name) && (e.fn = !0), e;
+			}
+			return r(), {
+				k: "Ref",
+				n: a.v
+			};
+		}
+		if (a.t === 16) return r(), {
+			k: "Ref",
+			n: a.v
+		};
+		if (a.t === 33) return r(), {
+			k: "UnaryOp",
+			op: "!",
+			operand: o(wn)
+		};
+		if (a.t === 21) return r(), {
+			k: "UnaryOp",
+			op: "-",
+			operand: o(wn)
+		};
+		if (a.t === 1) {
+			r();
+			let e = o(0);
+			return i(2), e;
+		}
+		return r(), { k: "Null" };
+	}
+	function c(e) {
+		let t = n();
+		if (t.t === 20) return r(), {
+			k: "BinOp",
+			op: "+",
+			left: e,
+			right: o(Sn)
+		};
+		if (t.t === 21) return r(), {
+			k: "BinOp",
+			op: "-",
+			left: e,
+			right: o(Sn)
+		};
+		if (t.t === 22) return r(), {
+			k: "BinOp",
+			op: "*",
+			left: e,
+			right: o(Cn)
+		};
+		if (t.t === 23) return r(), {
+			k: "BinOp",
+			op: "/",
+			left: e,
+			right: o(Cn)
+		};
+		if (t.t === 24) return r(), {
+			k: "BinOp",
+			op: "%",
+			left: e,
+			right: o(Cn)
+		};
+		if (t.t === 25) return r(), {
+			k: "BinOp",
+			op: "==",
+			left: e,
+			right: o(xn)
+		};
+		if (t.t === 26) return r(), {
+			k: "BinOp",
+			op: "!=",
+			left: e,
+			right: o(xn)
+		};
+		if (t.t === 27) return r(), {
+			k: "BinOp",
+			op: ">",
+			left: e,
+			right: o(G)
+		};
+		if (t.t === 28) return r(), {
+			k: "BinOp",
+			op: "<",
+			left: e,
+			right: o(G)
+		};
+		if (t.t === 29) return r(), {
+			k: "BinOp",
+			op: ">=",
+			left: e,
+			right: o(G)
+		};
+		if (t.t === 30) return r(), {
+			k: "BinOp",
+			op: "<=",
+			left: e,
+			right: o(G)
+		};
+		if (t.t === 31) return r(), {
+			k: "BinOp",
+			op: "&&",
+			left: e,
+			right: o(bn)
+		};
+		if (t.t === 32) return r(), {
+			k: "BinOp",
+			op: "||",
+			left: e,
+			right: o(yn)
+		};
+		if (t.t === 34) {
+			r();
+			let t = o(0);
+			return i(8), {
+				k: "Ternary",
+				cond: e,
+				then: t,
+				else: o(0)
+			};
+		}
+		if (t.t === 19) {
+			r();
+			let t = n();
+			return {
+				k: "Member",
+				obj: e,
+				field: t.t === 16 || t.t === 17 || t.t === 14 || t.t === 15 ? (r(), String(t.v)) : t.t === 18 ? (r(), t.v.replace(/^\$/, "")) : (r(), "?")
+			};
+		}
+		if (t.t === 3) {
+			r();
+			let t = o(0);
+			return i(4), {
+				k: "Index",
+				obj: e,
+				index: t
+			};
+		}
+		return e;
+	}
+	function l() {
+		let e = n().v;
+		r(), i(1);
+		let t = [];
+		for (; n().t !== 2 && n().t !== 13;) t.push(o(0)), n().t === 7 && r();
+		return i(2), {
+			k: "Comp",
+			name: e,
+			args: t
+		};
+	}
+	function u() {
+		r();
+		let e = [];
+		for (; n().t !== 4 && n().t !== 13;) e.push(o(0)), n().t === 7 && r();
+		return i(4), {
+			k: "Arr",
+			els: e
+		};
+	}
+	function d() {
+		r();
+		let e = [];
+		for (; n().t !== 6 && n().t !== 13;) {
+			let t = n(), a = t.t === 16 || t.t === 14 || t.t === 17 || t.t === 15 ? (r(), String(t.v)) : t.t === 18 ? (r(), t.v.replace(/^\$/, "")) : (r(), "?");
+			i(8), e.push([a, o(0)]), n().t === 7 && r();
+		}
+		return i(6), {
+			k: "Obj",
+			entries: e
+		};
+	}
+	return o(0);
+}
+function Dn(e) {
+	let t = [], n = 0, r = e.length;
+	for (; n < r;) {
+		for (; n < r && (e[n] === " " || e[n] === "	" || e[n] === "\r");) n++;
+		if (n >= r) break;
+		let i = e[n];
+		if (i === "\n") {
+			t.push({ t: 0 }), n++;
+			continue;
+		}
+		if (i === "(") {
+			t.push({ t: 1 }), n++;
+			continue;
+		}
+		if (i === ")") {
+			t.push({ t: 2 }), n++;
+			continue;
+		}
+		if (i === "[") {
+			t.push({ t: 3 }), n++;
+			continue;
+		}
+		if (i === "]") {
+			t.push({ t: 4 }), n++;
+			continue;
+		}
+		if (i === "{") {
+			t.push({ t: 5 }), n++;
+			continue;
+		}
+		if (i === "}") {
+			t.push({ t: 6 }), n++;
+			continue;
+		}
+		if (i === ",") {
+			t.push({ t: 7 }), n++;
+			continue;
+		}
+		if (i === ":") {
+			t.push({ t: 8 }), n++;
+			continue;
+		}
+		if (i === "=") {
+			n + 1 < r && e[n + 1] === "=" ? (t.push({ t: 25 }), n += 2) : (t.push({ t: 9 }), n++);
+			continue;
+		}
+		if (i === "!") {
+			n + 1 < r && e[n + 1] === "=" ? (t.push({ t: 26 }), n += 2) : (t.push({ t: 33 }), n++);
+			continue;
+		}
+		if (i === ">") {
+			n + 1 < r && e[n + 1] === "=" ? (t.push({ t: 29 }), n += 2) : (t.push({ t: 27 }), n++);
+			continue;
+		}
+		if (i === "<") {
+			n + 1 < r && e[n + 1] === "=" ? (t.push({ t: 30 }), n += 2) : (t.push({ t: 28 }), n++);
+			continue;
+		}
+		if (i === "&") {
+			n + 1 < r && e[n + 1] === "&" ? (t.push({ t: 31 }), n += 2) : (t.push({ t: 31 }), n++);
+			continue;
+		}
+		if (i === "|") {
+			n + 1 < r && e[n + 1] === "|" ? (t.push({ t: 32 }), n += 2) : (t.push({ t: 32 }), n++);
+			continue;
+		}
+		if (i === ".") {
+			t.push({ t: 19 }), n++;
+			continue;
+		}
+		if (i === "?") {
+			t.push({ t: 34 }), n++;
+			continue;
+		}
+		if (i === "+") {
+			t.push({ t: 20 }), n++;
+			continue;
+		}
+		if (i === "*") {
+			t.push({ t: 22 }), n++;
+			continue;
+		}
+		if (i === "/") {
+			t.push({ t: 23 }), n++;
+			continue;
+		}
+		if (i === "%") {
+			t.push({ t: 24 }), n++;
+			continue;
+		}
+		if (i === "\"") {
+			let i = n;
+			n++;
+			let a = !1;
+			for (; n < r;) if (e[n] === "\\") n += 2;
+			else if (e[n] === "\"") {
+				n++, a = !0;
+				break;
+			} else n++;
+			let o = e.slice(i, n);
+			try {
+				let e = a ? o : o + "\"";
+				t.push({
+					t: 14,
+					v: JSON.parse(e)
+				});
+			} catch {
+				let e = o.replace(/^"|"$/g, "");
+				t.push({
+					t: 14,
+					v: e
+				});
+			}
+			continue;
+		}
+		if (i === "'") {
+			n++;
+			let i = "";
+			for (; n < r;) if (e[n] === "\\") {
+				if (n++, n < r) {
+					let t = e[n];
+					t === "'" ? i += "'" : t === "\\" ? i += "\\" : t === "n" ? i += "\n" : t === "t" ? i += "	" : i += t, n++;
+				}
+			} else if (e[n] === "'") {
+				n++;
+				break;
+			} else i += e[n], n++;
+			t.push({
+				t: 14,
+				v: i
+			});
+			continue;
+		}
+		if (i === "-") {
+			let i = t.length > 0 ? t[t.length - 1] : null;
+			if (!(!(i != null && (i.t === 15 || i.t === 14 || i.t === 16 || i.t === 17 || i.t === 2 || i.t === 4 || i.t === 10 || i.t === 11 || i.t === 12 || i.t === 18 || i.t === 35)) && n + 1 < r && e[n + 1] >= "0" && e[n + 1] <= "9")) {
+				t.push({ t: 21 }), n++;
+				continue;
+			}
+		}
+		let a = i >= "0" && i <= "9", o = i === "-" && n + 1 < r && e[n + 1] >= "0" && e[n + 1] <= "9";
+		if (a || o) {
+			let i = n;
+			for (e[n] === "-" && n++; n < r && e[n] >= "0" && e[n] <= "9";) n++;
+			if (n < r && e[n] === "." && n + 1 < r && e[n + 1] >= "0" && e[n + 1] <= "9") for (n++; n < r && e[n] >= "0" && e[n] <= "9";) n++;
+			if (n < r && (e[n] === "e" || e[n] === "E")) for (n++, n < r && (e[n] === "+" || e[n] === "-") && n++; n < r && e[n] >= "0" && e[n] <= "9";) n++;
+			t.push({
+				t: 15,
+				v: +e.slice(i, n)
+			});
+			continue;
+		}
+		if (i === "$" && n + 1 < r && (e[n + 1] >= "a" && e[n + 1] <= "z" || e[n + 1] >= "A" && e[n + 1] <= "Z" || e[n + 1] === "_")) {
+			let i = n;
+			for (n++; n < r && (e[n] >= "a" && e[n] <= "z" || e[n] >= "A" && e[n] <= "Z" || e[n] >= "0" && e[n] <= "9" || e[n] === "_");) n++;
+			t.push({
+				t: 18,
+				v: e.slice(i, n)
+			});
+			continue;
+		}
+		if (i >= "a" && i <= "z" || i >= "A" && i <= "Z" || i === "_") {
+			let a = n;
+			for (; n < r && (e[n] >= "a" && e[n] <= "z" || e[n] >= "A" && e[n] <= "Z" || e[n] >= "0" && e[n] <= "9" || e[n] === "_");) n++;
+			let o = e.slice(a, n);
+			if (o === "true") {
+				t.push({ t: 10 });
+				continue;
+			}
+			if (o === "false") {
+				t.push({ t: 11 });
+				continue;
+			}
+			if (o === "null") {
+				t.push({ t: 12 });
+				continue;
+			}
+			let s = i >= "A" && i <= "Z" ? 17 : 16;
+			t.push({
+				t: s,
+				v: o
+			});
+			continue;
+		}
+		if (i === "@" && n + 1 < r && (e[n + 1] >= "a" && e[n + 1] <= "z" || e[n + 1] >= "A" && e[n + 1] <= "Z" || e[n + 1] === "_")) {
+			n++;
+			let i = n;
+			for (; n < r && (e[n] >= "a" && e[n] <= "z" || e[n] >= "A" && e[n] <= "Z" || e[n] >= "0" && e[n] <= "9" || e[n] === "_");) n++;
+			t.push({
+				t: 35,
+				v: e.slice(i, n)
+			});
+			continue;
+		}
+		n++;
+	}
+	return t.push({ t: 13 }), t;
+}
+var On = [
+	"string",
+	"number",
+	"boolean"
+], kn = {}, An = [];
+function jn(e) {
+	return Array.isArray(e) ? "array" : typeof e;
+}
+function Mn(e) {
+	return typeof e.$ref == "string" ? e.$ref.split("/").pop() : void 0;
+}
+function Nn(e) {
+	return "$ref" in e || "anyOf" in e || "oneOf" in e || "allOf" in e;
+}
+function Pn(e) {
+	if (Array.isArray(e.enum)) return { enumValues: e.enum };
+	if ("const" in e) return { enumValues: [e.const] };
+	switch (e.type) {
+		case "string": return { expectedType: "string" };
+		case "number":
+		case "integer": return { expectedType: "number" };
+		case "boolean": return { expectedType: "boolean" };
+		default: return {};
+	}
+}
+function Fn(e) {
+	if (!(!e || typeof e != "object" || Array.isArray(e))) return e.default;
+}
+function In(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return;
+	let t = e, n = Mn(t);
+	if (n) return n;
+	let r = Pn(t);
+	return r.enumValues ? r.enumValues.map((e) => JSON.stringify(e)).join("|") : r.expectedType ? r.expectedType : typeof t.type == "string" ? t.type : void 0;
+}
+function Ln(e, t) {
+	return `${e}(${t.map((e) => {
+		let t = In(e.schema), n = e.required ? `${e.name}*` : e.name;
+		return t ? `${n}: ${t}` : n;
+	}).join(", ")})`;
+}
+function Rn(e, t) {
+	let n = typeof e;
+	return t.enumValues ? !On.includes(n) || t.enumValues.includes(e) ? null : {
+		expected: `one of [${t.enumValues.map((e) => JSON.stringify(e)).join(", ")}]`,
+		actual: JSON.stringify(e)
+	} : t.expectedType && t.expectedType !== n ? {
+		expected: t.expectedType,
+		actual: jn(e)
+	} : null;
+}
+function zn(e, t, n) {
+	switch (n.code) {
+		case "type-mismatch": return `field "${t}" expects ${n.expected} but got ${n.actual}`;
+		case "missing-required": return `missing required field "${t}"${n.signature ? ` — signature: ${n.signature}` : ""}`;
+		case "null-required": return `required field "${t}" cannot be null${n.signature ? ` — signature: ${n.signature}` : ""}`;
+		case "unknown-component": return `Unknown component "${e}" — not found in catalog or builtins${n.available?.length ? `. Available components: ${n.available.join(", ")}` : ""}`;
+		case "inline-reserved": return `${e}() must be declared as a top-level statement, not used inline as a value`;
+		case "excess-args": return `${e} takes ${n.declared} arg(s), got ${n.got} (${n.got - n.declared} excess dropped)`;
+		case "unknown-function": return `Unknown function "@${e}": not a built-in or action step. The call evaluates to null`;
+		case "no-root": return n.reason === "not-component" ? "root does not evaluate to a component" : n.reason === "fallback" ? `No root statement. Rendering the first statement that calls the root component ${e}` : e ? `No root statement, and no statement calls the root component ${e}` : "No root statement";
+	}
+}
+function K(e, t, n, r) {
+	e.errors.push({
+		code: r.code,
+		component: t,
+		path: n,
+		message: zn(t, n, r),
+		statementId: e.currentStatementId,
+		...r.code === "no-root" && r.reason === "fallback" && { severity: "warning" }
+	});
+}
+var q = Symbol("invalid");
+function Bn(e, t) {
+	return t === void 0 ? e ? q : void 0 : t;
+}
+function Vn(e, t, n, r, i) {
+	return Nn(t) ? !1 : typeof t.type == "string" || Array.isArray(t.enum) || "const" in t ? (K(i, n, r, {
+		code: "type-mismatch",
+		expected: typeof t.type == "string" ? t.type : "a literal value",
+		actual: `component "${e.typeName}"`
+	}), !0) : !1;
+}
+function Hn(e) {
+	return (e.anyOf ?? e.oneOf ?? [e]).map(Mn);
+}
+function Un(e, t) {
+	let n = Hn(e);
+	return n.length > 0 && n.every((e) => e !== void 0 && t.cat?.has(e));
+}
+function Wn(e, t, n, r, i) {
+	if (typeof e != "object" || Array.isArray(e)) return K(i, n, r, {
+		code: "type-mismatch",
+		expected: "object",
+		actual: jn(e)
+	}), q;
+	let a = e, o, s = t.properties && typeof t.properties == "object" ? t.properties : kn, c = Array.isArray(t.required) ? t.required : An, l = !1;
+	if (!i.partial) for (let e of c) {
+		let t = e in a;
+		if (!t || a[e] == null) {
+			let c = Fn(s[e]);
+			if (c !== void 0) {
+				(o ??= { ...a })[e] = c;
+				continue;
+			}
+			K(i, n, `${r}/${e}`, { code: t ? "null-required" : "missing-required" }), l = !0;
+		}
+	}
+	for (let e of Object.keys(s)) {
+		if (!(e in a)) continue;
+		let t = s[e], u = J(a[e], t, n, `${r}/${e}`, i);
+		if (u === q && (u = Bn(c.includes(e), Fn(t)), u === q)) {
+			l = !0;
+			continue;
+		}
+		u !== a[e] && (o ??= { ...a }, u === void 0 ? delete o[e] : o[e] = u);
+	}
+	return l ? q : o ?? a;
+}
+function Gn(e, t, n, r, i) {
+	if (!Array.isArray(e)) return K(i, n, r, {
+		code: "type-mismatch",
+		expected: "array",
+		actual: jn(e)
+	}), q;
+	let a = t.items;
+	if (!a || typeof a != "object" || Array.isArray(a)) return e;
+	let o;
+	for (let t = 0; t < e.length; t++) {
+		let s = J(e[t], a, n, `${r}/${t}`, i);
+		s !== e[t] && !o && (o = e.slice(0, t)), o && s !== q && o.push(s);
+	}
+	return o ?? e;
+}
+function Kn(e, t, n, r, i) {
+	let a = Pn(t);
+	if (a.expectedType == null && a.enumValues == null || a.enumValues && i.partial) return !1;
+	let o = Rn(e, a);
+	return o ? (K(i, n, r, {
+		code: "type-mismatch",
+		...o
+	}), !0) : !1;
+}
+function J(e, t, n, r, i) {
+	if (!t || typeof t != "object" || Array.isArray(t)) return e;
+	let a = t;
+	if (e == null || W(e)) return e;
+	if (U(e)) return Vn(e, a, n, r, i) ? q : e;
+	if (Nn(a)) return Un(a, i) ? (K(i, n, r, {
+		code: "type-mismatch",
+		expected: Hn(a).join(" | "),
+		actual: Array.isArray(e) ? "array" : typeof e == "object" ? "plain object" : typeof e
+	}), q) : e;
+	let o = a.type;
+	return o === "object" ? Wn(e, a, n, r, i) : o === "array" ? Gn(e, a, n, r, i) : Kn(e, a, n, r, i) ? q : e;
+}
+function qn(e) {
+	if (typeof e != "object" || !e) return !1;
+	if (W(e)) return !0;
+	if (Array.isArray(e)) return e.some(qn);
+	if (U(e)) return Object.values(e.props).some(qn);
+	let t = e;
+	return Array.isArray(t.steps) ? !0 : Object.values(t).some(qn);
+}
+function Jn(e, t, n) {
+	if (t.visited.has(e) || !t.syms.has(e)) return t.unres.push(e), n === "expr" ? {
+		k: "Ph",
+		n: e
+	} : null;
+	let r = t.syms.get(e);
+	if (t.unreached?.delete(e), r.k === "Comp" && z(r.name)) return {
+		k: "RuntimeRef",
+		n: e,
+		refType: r.name === R.Mutation ? "mutation" : "query"
+	};
+	t.visited.add(e);
+	let i = t.currentStatementId;
+	t.currentStatementId = e;
+	try {
+		let i = n === "value" ? X(r, t) : tr(r, t);
+		return n === "value" && U(i) && (i.statementId = e), i;
+	} finally {
+		t.currentStatementId = i, t.visited.delete(e);
+	}
+}
+function Yn(e, t) {
+	return I(t.cat).has(e) || z(e);
+}
+function Xn(e, t) {
+	let n = {};
+	for (let r = 0; r < t.length && r < e.length; r++) n[t[r].name] = e[r];
+	return n;
+}
+function Zn(e, t, n, r) {
+	let { params: i } = n;
+	t.length > i.length && K(r, e, "", {
+		code: "excess-args",
+		declared: i.length,
+		got: t.length
+	});
+	let a = Xn(t, i), o = !1, s = r.errors.length;
+	for (let t of i) {
+		let n = a[t.name], s = n ? _n(n) : { v: void 0 };
+		if (!s) continue;
+		if (s.v == null) {
+			if (!t.required || t.defaultValue !== void 0) continue;
+			K(r, e, `/${t.name}`, {
+				code: n ? "null-required" : "missing-required",
+				signature: Ln(e, i)
+			}), o = !0;
+			continue;
+		}
+		let c = J(s.v, t.schema, e, `/${t.name}`, r);
+		c === q && (c = Bn(t.required, t.defaultValue)), c === q ? o = !0 : c === void 0 ? delete a[t.name] : c !== s.v && (a[t.name] = gn(c));
+	}
+	return n.kind === "action" && r.errors.length > s && (o = !0), o ? null : a;
+}
+function Qn(e, t, n) {
+	let r = e.args.map(n), i = I(t.cat).get(e.name);
+	if (!i || i.lazy) return {
+		...e,
+		args: r
+	};
+	let a = i.builtin ? Xn(r, i.params) : Zn(e.name, r, i, t);
+	return a ? {
+		...e,
+		args: r,
+		mappedProps: a
+	} : i.kind === "action" ? {
+		k: "Comp",
+		name: "Action",
+		args: [{
+			k: "Arr",
+			els: []
+		}]
+	} : { k: "Null" };
+}
+function $n(e, t, n) {
+	let r = t.currentStatementId;
+	t.currentStatementId = n;
+	let i = /* @__PURE__ */ new Set();
+	for (let n of e) hn(n, (e) => {
+		if (e.k !== "Comp" || i.has(e)) return;
+		i.add(e);
+		let n = I(t.cat).get(e.name);
+		!n || n.lazy || (e.mappedProps = (n.builtin ? null : Zn(e.name, e.args, n, t)) ?? Xn(e.args, n.params));
+	});
+	t.currentStatementId = r;
+}
+function er(e, t, n) {
+	let r = I(t.cat).get(e.name);
+	if (r?.kind !== "function" || !r.lazy || e.args.length < 3) return null;
+	let i = e.args[1], a = i.k === "Ref" ? i.n : i.k === "Str" ? i.v : null;
+	if (!a) return null;
+	let o = new Set(n);
+	o.add(a);
+	let s = e.args.map((e, n) => n === 1 ? e : Y(e, t, o));
+	return {
+		...e,
+		args: s
+	};
+}
+function Y(e, t, n) {
+	switch (e.k) {
+		case "Ref": return n.has(e.n) ? e : Jn(e.n, t, "expr");
+		case "Ph": return e;
+		case "Comp": {
+			if (e.fn && !Yn(e.name, t)) return K(t, e.name, "", { code: "unknown-function" }), { k: "Null" };
+			let r = er(e, t, n);
+			if (r) return r;
+			if (Yn(e.name, t)) return Qn(e, t, (e) => Y(e, t, n));
+			let i = e.args.map((e) => Y(e, t, n)), a = t.cat?.get(e.name);
+			if (a) {
+				let t = {};
+				for (let e = 0; e < a.params.length && e < i.length; e++) t[a.params[e].name] = i[e];
+				return {
+					...e,
+					args: i,
+					mappedProps: t
+				};
+			}
+			return K(t, e.name, "", {
+				code: "unknown-component",
+				available: t.cat && [...t.cat.keys()]
+			}), {
+				...e,
+				args: i
+			};
+		}
+		case "Arr": return {
+			...e,
+			els: e.els.map((e) => Y(e, t, n))
+		};
+		case "Obj": return {
+			...e,
+			entries: e.entries.map(([e, r]) => [e, Y(r, t, n)])
+		};
+		case "BinOp": return {
+			...e,
+			left: Y(e.left, t, n),
+			right: Y(e.right, t, n)
+		};
+		case "UnaryOp": return {
+			...e,
+			operand: Y(e.operand, t, n)
+		};
+		case "Ternary": return {
+			...e,
+			cond: Y(e.cond, t, n),
+			then: Y(e.then, t, n),
+			else: Y(e.else, t, n)
+		};
+		case "Member": return {
+			...e,
+			obj: Y(e.obj, t, n)
+		};
+		case "Index": return {
+			...e,
+			obj: Y(e.obj, t, n),
+			index: Y(e.index, t, n)
+		};
+		case "Assign": return {
+			...e,
+			value: Y(e.value, t, n)
+		};
+		default: return e;
+	}
+}
+function tr(e, t) {
+	return Y(e, t, /* @__PURE__ */ new Set());
+}
+function X(e, t) {
+	switch (e.k) {
+		case "Ref": return Jn(e.n, t, "value");
+		case "Str": return e.v;
+		case "Num": return e.v;
+		case "Bool": return e.v;
+		case "Null": return null;
+		case "Ph": return null;
+		case "Arr": {
+			let n = [];
+			for (let r of e.els) {
+				if (r.k === "Ph") continue;
+				let e = X(r, t);
+				e === null && (r.k === "Comp" || r.k === "Ref") || n.push(e);
+			}
+			return n;
+		}
+		case "Obj": {
+			let n = {};
+			for (let [r, i] of e.entries) n[r] = X(i, t);
+			return n;
+		}
+		case "Comp": {
+			let { name: n, args: r } = e;
+			if (e.fn && !Yn(n, t)) return K(t, n, "", { code: "unknown-function" }), null;
+			if (z(n)) return K(t, n, "", { code: "inline-reserved" }), null;
+			if (Yn(n, t)) return er(e, t, /* @__PURE__ */ new Set()) || Qn(e, t, (e) => tr(e, t));
+			let i = t.cat?.get(n), a = {};
+			if (i) {
+				let e = !1;
+				for (let o = 0; o < i.params.length && o < r.length; o++) {
+					let s = i.params[o], c = X(r[o], t);
+					if (a[s.name] = c, s.schema === void 0) continue;
+					let l = J(c, s.schema, n, `/${s.name}`, t);
+					l === q && (l = Bn(s.required, s.defaultValue), l === q ? e = !0 : l === void 0 && delete a[s.name]), l !== q && l !== void 0 && (a[s.name] = l);
+				}
+				r.length > i.params.length && K(t, n, "", {
+					code: "excess-args",
+					declared: i.params.length,
+					got: r.length
+				});
+				let o = i.params.filter((e) => e.required && (!(e.name in a) || a[e.name] === null));
+				if (o.length) {
+					let e = o.filter((e) => e.defaultValue === void 0 ? !0 : (a[e.name] = e.defaultValue, !1));
+					if (e.length) {
+						for (let r of e) K(t, n, `/${r.name}`, {
+							code: r.name in a ? "null-required" : "missing-required",
+							signature: Ln(n, i.params)
+						});
+						return null;
+					}
+				}
+				if (e) return null;
+			} else return K(t, n, "", {
+				code: "unknown-component",
+				available: t.cat && [...t.cat.keys()]
+			}), null;
+			let o = Object.values(a).some((e) => qn(e));
+			return {
+				type: "element",
+				typeName: n,
+				props: a,
+				partial: t.partial,
+				hasDynamicProps: o
+			};
+		}
+		default: return pn(e) ? tr(e, t) : e;
+	}
+}
+function nr(e) {
+	let t = [], n = !1, r = !1;
+	for (let i = 0; i < e.length; i++) {
+		let a = e[i];
+		if (r) {
+			r = !1;
+			continue;
+		}
+		if (a === "\\" && n) {
+			r = !0;
+			continue;
+		}
+		if (n) {
+			a === n && (n = !1);
+			continue;
+		}
+		if (a === "\"" || a === "'") {
+			n = a;
+			continue;
+		}
+		a === "(" || a === "[" || a === "{" ? t.push(a) : (a === ")" && t[t.length - 1] === "(" || a === "]" && t[t.length - 1] === "[" || a === "}" && t[t.length - 1] === "{") && t.pop();
+	}
+	if (!(n || t.length > 0)) return {
+		text: e,
+		wasIncomplete: !1
+	};
+	let i = e;
+	n && (r && (i += "\\"), i += n);
+	for (let e = t.length - 1; e >= 0; e--) i += t[e] === "(" ? ")" : t[e] === "[" ? "]" : "}";
+	return {
+		text: i,
+		wasIncomplete: !0
+	};
+}
+function rr(e) {
+	let t = [], n = 0;
+	for (; n < e.length;) {
+		for (; n < e.length && e[n].t === 0;) n++;
+		if (n >= e.length || e[n].t === 13) break;
+		let r = e[n];
+		if (r.t !== 16 && r.t !== 17 && r.t !== 18) {
+			for (; n < e.length && e[n].t !== 0 && e[n].t !== 13;) n++;
+			continue;
+		}
+		let i = r.v, a = r.t;
+		if (n++, n >= e.length || e[n].t !== 9) {
+			for (; n < e.length && e[n].t !== 0 && e[n].t !== 13;) n++;
+			continue;
+		}
+		n++;
+		let o = [], s = 0, c = 0;
+		for (; n < e.length && e[n].t !== 13;) {
+			let t = e[n].t;
+			if (t === 0 && s <= 0 && c <= 0) {
+				let t = n + 1;
+				for (; t < e.length && e[t].t === 0;) t++;
+				let r = t < e.length ? e[t].t : 13;
+				if (r === 34 || r === 8 && c > 0) {
+					n++;
+					continue;
+				}
+				break;
+			}
+			if (t === 0) {
+				n++;
+				continue;
+			}
+			t === 1 || t === 3 || t === 5 ? s++ : (t === 2 || t === 4 || t === 6) && s > 0 ? s-- : t === 34 && s === 0 ? c++ : t === 8 && s === 0 && c > 0 && c--, o.push(e[n++]);
+		}
+		o.length && t.push({
+			id: i,
+			idTokenType: a,
+			tokens: o
+		});
+	}
+	return t;
+}
+function ir(e = !0) {
+	return {
+		root: null,
+		meta: {
+			incomplete: e,
+			unresolved: [],
+			orphaned: [],
+			statementCount: 0,
+			errors: []
+		},
+		stateDeclarations: {},
+		queryStatements: [],
+		mutationStatements: []
+	};
+}
+function ar(e) {
+	if (!W(e)) return [];
+	let t = /* @__PURE__ */ new Set();
+	return hn(e, (e) => {
+		e.k === "StateRef" && t.add(e.n);
+	}), [...t];
+}
+function or(e, t) {
+	if (t.k === "Comp" && t.name === R.Query) {
+		let n = ar(t.args[1]);
+		return {
+			kind: "query",
+			id: e.id,
+			call: {
+				callee: R.Query,
+				args: t.args
+			},
+			expr: t,
+			deps: n.length > 0 ? n : void 0
+		};
+	}
+	return t.k === "Comp" && t.name === R.Mutation ? {
+		kind: "mutation",
+		id: e.id,
+		call: {
+			callee: R.Mutation,
+			args: t.args
+		},
+		expr: t
+	} : e.idTokenType === 18 ? {
+		kind: "state",
+		id: e.id,
+		init: t
+	} : {
+		kind: "value",
+		id: e.id,
+		expr: t
+	};
+}
+function sr(e, t, n) {
+	let r = {}, i = [], a = [];
+	for (let n of e) switch (n.kind) {
+		case "state":
+			r[n.id] = X(n.init, t);
+			break;
+		case "query":
+			$n(n.call.args, t, n.id), i.push({
+				statementId: n.id,
+				toolAST: n.call.args[0] ?? null,
+				argsAST: n.call.args[1] ?? null,
+				defaultsAST: n.call.args[2] ?? null,
+				refreshAST: n.call.args[3] ?? null,
+				deps: n.deps,
+				complete: !0
+			});
+			break;
+		case "mutation":
+			$n(n.call.args, t, n.id), a.push({
+				statementId: n.id,
+				toolAST: n.call.args[0] ?? null,
+				argsAST: n.call.args[1] ?? null
+			});
+			break;
+	}
+	for (let t of e) {
+		let e = t.kind === "state" ? [t.init] : t.kind === "value" ? [t.expr] : t.kind === "query" || t.kind === "mutation" ? t.call.args : [];
+		for (let i of e) for (let e of ar(i)) e === n?.name && n.stmts.has(t) || e in r || (r[e] = null);
+	}
+	return {
+		stateDeclarations: r,
+		queryStatements: i,
+		mutationStatements: a
+	};
+}
+var cr = "root";
+function lr(e) {
+	return e?.k === "Comp" && !e.fn && !L(e.name) && !z(e.name);
+}
+function ur(e, t) {
+	if (e.has(cr)) return {
+		id: cr,
+		fallback: !1
+	};
+	for (let n of e.values()) if (n.kind === "value" && lr(n.expr) && n.expr.name === t) return {
+		id: n.id,
+		fallback: !0
+	};
+	return null;
+}
+function dr(e, t) {
+	let n = /* @__PURE__ */ new Set();
+	for (; e?.k === "Ref" && !n.has(e.n);) n.add(e.n), e = t.get(e.n);
+	return lr(e);
+}
+function fr(e) {
+	let t = !1;
+	return hn(e, (e) => {
+		lr(e) && (t = !0);
+	}), t;
+}
+function pr(e, t, n, r, i, a, o) {
+	let s = ur(e, a), c = /* @__PURE__ */ new Map();
+	for (let [t, n] of e) c.set(t, n.kind === "state" ? n.init : n.expr);
+	let l = [], u = [], d = /* @__PURE__ */ new Set();
+	for (let [t, n] of e) t !== s?.id && (n.kind === "state" || n.kind === "query" || n.kind === "mutation" || d.add(t));
+	let f = {
+		syms: c,
+		cat: i,
+		errors: u,
+		unres: l,
+		visited: /* @__PURE__ */ new Set(),
+		partial: n,
+		currentStatementId: s?.id,
+		unreached: d
+	}, p = null, m;
+	if (s) {
+		let e = X(c.get(s.id), f);
+		U(e) ? (p = e, p.statementId = s.id) : W(e) && fr(e) && (m = e);
+	}
+	let { stateDeclarations: h, queryStatements: g, mutationStatements: _ } = sr(t, f, o);
+	f.currentStatementId = s?.id;
+	let v = a ?? "";
+	s ? !p && !m && !dr(c.get(s.id), c) ? K(f, v, "", {
+		code: "no-root",
+		reason: "not-component"
+	}) : s.fallback && K(f, v, "", {
+		code: "no-root",
+		reason: p ? "fallback" : "missing"
+	}) : K(f, v, "", {
+		code: "no-root",
+		reason: "missing"
+	});
+	let ee = s ? [...d] : [];
+	return {
+		root: p,
+		...m ? { rootExpression: m } : {},
+		meta: {
+			incomplete: n,
+			unresolved: l,
+			orphaned: ee,
+			statementCount: r,
+			errors: u
+		},
+		stateDeclarations: h,
+		queryStatements: g,
+		mutationStatements: _
+	};
+}
+function mr(e, t) {
+	if (e[t] !== "\"") return t;
+	let n = t + 1;
+	for (; n < e.length;) {
+		let t = e[n];
+		if (t === "\\") n += 2;
+		else if (t === "\"") return n + 1;
+		else n++;
+	}
+	return n;
+}
+function hr(e) {
+	let t = [], n = 0;
+	for (; n < e.length;) {
+		let r = -1;
+		for (; n < e.length;) {
+			let t = mr(e, n);
+			if (t > n) {
+				n = t;
+				continue;
+			}
+			if (e[n] === "`" && n + 1 < e.length && e[n + 1] === "`" && n + 2 < e.length && e[n + 2] === "`") {
+				r = n;
+				break;
+			}
+			n++;
+		}
+		if (r === -1) break;
+		let i = r + 3;
+		for (; i < e.length && e[i] !== "\n";) i++;
+		if (i >= e.length) {
+			t.push(e.slice(r + 3).replace(/^[^\n]*\n?/, "")), n = e.length;
+			break;
+		}
+		i++;
+		let a = -1, o = i;
+		for (; o < e.length;) {
+			let t = mr(e, o);
+			if (t > o) {
+				o = t;
+				continue;
+			}
+			if (e[o] === "`" && o + 1 < e.length && e[o + 1] === "`" && o + 2 < e.length && e[o + 2] === "`") {
+				a = o;
+				break;
+			}
+			o++;
+		}
+		a === -1 ? (t.push(e.slice(i)), n = e.length) : (t.push(e.slice(i, a)), n = a + 3);
+	}
+	if (t.length > 0) return t.join("\n");
+	if (e.startsWith("```")) {
+		let t = 3;
+		for (; t < e.length && e[t] !== "\n";) t++;
+		let n = t < e.length ? t + 1 : 3, r = e.slice(n), i = r.lastIndexOf("```");
+		return i === -1 ? r : r.slice(0, i);
+	}
+	return e;
+}
+function gr(e) {
+	let t = !1;
+	return e.split("\n").map((e) => {
+		for (let n = 0; n < e.length; n++) {
+			let r = e[n];
+			if (t) {
+				if (r === "\\" && n + 1 < e.length) {
+					n++;
+					continue;
+				}
+				r === t && (t = !1);
+				continue;
+			}
+			if (r === "\"" || r === "'") {
+				t = r;
+				continue;
+			}
+			if (r === "/" && e[n + 1] === "/" || r === "#") return e.substring(0, n).trimEnd();
+		}
+		return e;
+	}).join("\n");
+}
+function _r(e) {
+	return gr(hr(e.trim())).trim();
+}
+function vr(e, t, n) {
+	let r = _r(e);
+	if (!r) return ir();
+	let { text: i, wasIncomplete: a } = nr(r), o = rr(Dn(i));
+	if (!o.length) return ir(a);
+	let s = /* @__PURE__ */ new Map();
+	for (let e of o) {
+		let t = or(e, En(e.tokens));
+		s.set(e.id, t);
+	}
+	return pr(s, [...s.values()], a, s.size, t, n);
+}
+function yr(e, t) {
+	let n = "", r = "", i = 0, a = /* @__PURE__ */ new Map(), o = 0;
+	function s(e) {
+		let t = e.trim();
+		if (t) for (let e of rr(Dn(t))) {
+			let t = or(e, En(e.tokens));
+			a.set(e.id, t), o++;
+		}
+	}
+	function c() {
+		let e = _r(n);
+		e.startsWith(r.slice(0, i)) || (i = 0, a.clear(), o = 0), r = e;
+	}
+	function l() {
+		let e = 0, t = 0, n = !1, a = !1, o = i;
+		for (let c = i; c < r.length; c++) {
+			let l = r[c];
+			if (a) {
+				a = !1;
+				continue;
+			}
+			if (l === "\\" && n) {
+				a = !0;
+				continue;
+			}
+			if (n) {
+				l === n && (n = !1);
+				continue;
+			}
+			if (l === "\"" || l === "'") {
+				n = l;
+				continue;
+			}
+			if (l === "(" || l === "[" || l === "{") e++;
+			else if (l === ")" || l === "]" || l === "}") e = Math.max(0, e - 1);
+			else if (l === "?" && e === 0) t++;
+			else if (l === ":" && e === 0 && t > 0) t--;
+			else if (l === "\n" && e <= 0 && t <= 0) {
+				let e = c + 1;
+				for (; e < r.length && (r[e] === " " || r[e] === "	" || r[e] === "\r" || r[e] === "\n");) e++;
+				if (e < r.length && (r[e] === "?" || r[e] === ":" && t > 0)) continue;
+				let n = r.slice(o, c).trim();
+				n && s(n), o = c + 1, i = c + 1;
+			}
+		}
+		return o;
+	}
+	function u(i = !1) {
+		c();
+		let s = l(), u = r.slice(s).trim();
+		if (!u) return o === 0 ? ir() : pr(a, [...a.values()], !1, o, e, t);
+		let { text: d, wasIncomplete: f } = nr(u), p = rr(Dn(d));
+		if (!p.length) return o === 0 ? ir(f) : pr(a, [...a.values()], f, o, e, t);
+		let m = new Map(a), h = /* @__PURE__ */ new Set();
+		for (let e of p) {
+			if (a.has(e.id) && f) continue;
+			let t = or(e, En(e.tokens));
+			m.set(e.id, t), h.add(t);
+		}
+		let g = i ? void 0 : /\$\w+$/.exec(n)?.[0], _ = g && u.endsWith(g) && !RegExp(`\\${g}(?!\\w)`).test(u.slice(0, -g.length)) ? g : void 0;
+		return pr(m, [...m.values()], f, o + p.length, e, t, _ ? {
+			name: _,
+			stmts: h
+		} : void 0);
+	}
+	function d() {
+		n = "", r = "", i = 0, a.clear(), o = 0;
+	}
+	return {
+		push(e, t) {
+			return n += e, u(t);
+		},
+		set(e, t) {
+			(e.length < n.length || !e.startsWith(n)) && d();
+			let r = e.slice(n.length);
+			return r && (n += r), u(t);
+		},
+		getResult: u
+	};
+}
+function br(e, t) {
+	if (!e || typeof e != "object") return e;
+	let n = e.$ref;
+	if (typeof n == "string") return t.has(n) ? br(t.get(n), t) : e;
+	let r = Array.isArray(e) ? [...e] : { ...e }, i = !1;
+	for (let [e, n] of Object.entries(r)) r[e] = br(n, t), i ||= r[e] !== n;
+	return i ? r : e;
+}
+function xr(e, t) {
+	let n = e.properties ?? {}, r = e.required ?? [];
+	return Object.keys(n).map((e) => ({
+		name: e,
+		required: r.includes(e),
+		defaultValue: Fn(n[e]),
+		schema: t.size ? br(n[e], t) : n[e]
+	}));
+}
+function Sr(e) {
+	let t = /* @__PURE__ */ new Map(), n = e.properties && new Set(Object.keys(e.properties)), r = /* @__PURE__ */ new Map();
+	for (let t of [...Object.keys(Be), ...Object.keys(e.actions ?? {})]) {
+		let i = e.$defs?.[t];
+		i && !n?.has(t) && r.set(`#/$defs/${t}`, i);
+	}
+	for (let [i, a] of Object.entries(e.$defs ?? {})) (n ? !n.has(i) : r.has(`#/$defs/${i}`)) || t.set(i, { params: xr(a, r) });
+	t.callDefs = new Map(F);
+	for (let [n, i] of Object.entries(e.functions ?? {})) t.callDefs.set(n, {
+		kind: "function",
+		params: xr(i.params, r)
+	});
+	for (let [n, i] of Object.entries(e.actions ?? {})) t.callDefs.set(n, {
+		kind: "action",
+		params: xr(i.params, r)
+	});
+	return t;
+}
+function Cr(e, t) {
+	let n = Sr(e);
+	return { parse(e) {
+		let r = _t();
+		try {
+			let i = vr(e, n, t);
+			return vt(r, i), i;
+		} catch (e) {
+			throw yt(r), e;
+		}
+	} };
+}
+function wr(e, t) {
+	return yr(Sr(e), t);
+}
+function Tr(e, t) {
+	if (!t?.properties) return;
+	let n = new Set(t.required ?? []);
+	return `Signature: ${e}(${Object.keys(t.properties).map((e) => n.has(e) ? `${e}*` : e).join(", ")}) — * marks required`;
+}
+function Er(e, t, n) {
+	return e.map((e) => {
+		let r = {
+			source: "parser",
+			code: e.code,
+			message: e.message,
+			component: e.component,
+			path: e.path || void 0,
+			statementId: e.statementId,
+			...e.severity && { severity: e.severity }
+		};
+		return e.code === "unknown-component" && n.length ? r.hint = `Available components: ${n.join(", ")}` : e.code === "missing-required" || e.code === "null-required" ? r.hint = Tr(e.component, t.$defs?.[e.component]) : e.code === "inline-reserved" && (r.hint = `Declare as a top-level statement: myVar = ${e.component}(...)`), r;
+	});
+}
+function Dr(e) {
+	let t = [], n = 0, r = !1, i = !1, a = 0;
+	for (let o = 0; o < e.length; o++) {
+		let s = e[o];
+		if (i) {
+			i = !1;
+			continue;
+		}
+		if (s === "\\" && r) {
+			i = !0;
+			continue;
+		}
+		if (r) {
+			s === r && (r = !1);
+			continue;
+		}
+		if (s === "\"" || s === "'") {
+			r = s;
+			continue;
+		}
+		if (s === "(" || s === "[" || s === "{") n++;
+		else if (s === ")" || s === "]" || s === "}") n = Math.max(0, n - 1);
+		else if (s === "\n" && n <= 0) {
+			let n = e.slice(a, o).trim();
+			n && t.push(n), a = o + 1;
+		}
+	}
+	let o = e.slice(a).trim();
+	return o && t.push(o), t;
+}
+function Or(e) {
+	let t = e.trim();
+	if (!t) return [];
+	let n = [];
+	for (let e of Dr(t)) {
+		let t = rr(Dn(e))[0];
+		t && n.push({
+			id: t.id,
+			ast: En(t.tokens),
+			raw: e
+		});
+	}
+	return n;
+}
+function kr(e, t) {
+	hn(e, (e) => {
+		e.k === "Ref" && t.add(e.n), e.k === "RuntimeRef" && t.add(e.n);
+	});
+}
+function Ar(e, t, n, r = "root") {
+	if (!n.get(r)) return;
+	let i = new Set([r]), a = [r];
+	for (; a.length > 0;) {
+		let e = a.pop(), t = n.get(e);
+		if (!t) continue;
+		let r = /* @__PURE__ */ new Set();
+		kr(t, r);
+		for (let e of r) !i.has(e) && n.has(e) && (i.add(e), a.push(e));
+	}
+	for (let t of e) t.startsWith("$") && i.add(t);
+	for (let n = e.length - 1; n >= 0; n--) i.has(e[n]) || (t.delete(e[n]), e.splice(n, 1));
+}
+function jr(e, t, n = "root") {
+	let r = Or(e), i = Or(hr(t));
+	if (!r.length) return i.map((e) => e.raw).join("\n");
+	if (!i.length) return e;
+	let a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), s = [];
+	for (let e of r) a.set(e.id, e.raw), o.set(e.id, e.ast), s.push(e.id);
+	for (let e of i) {
+		if (e.ast.k === "Null") {
+			a.delete(e.id), o.delete(e.id);
+			let t = s.indexOf(e.id);
+			t !== -1 && s.splice(t, 1);
+			continue;
+		}
+		a.has(e.id) || s.push(e.id), a.set(e.id, e.raw), o.set(e.id, e.ast);
+	}
+	return Ar(s, a, o, n), s.filter((e) => a.has(e)).map((e) => a.get(e)).join("\n");
+}
+function Mr(e) {
+	return typeof e == "object" && !!e && e.__reactive === "assign";
+}
+function Z(e, t, n) {
+	switch (e.k) {
+		case "Str": return e.v;
+		case "Num": return e.v;
+		case "Bool": return e.v;
+		case "Null": return null;
+		case "Ph": return null;
+		case "StateRef": return t.extraScope?.[e.n] ?? t.getState(e.n);
+		case "Ref":
+		case "RuntimeRef": return t.resolveRef(e.n);
+		case "Arr": return e.els.map((e) => Z(e, t));
+		case "Obj": return Object.fromEntries(e.entries.map(([e, n]) => [e, Z(n, t)]));
+		case "Comp": {
+			let r = Pe[e.name];
+			if (r) return r.lazy ? qr(e.name, e.args, t, n) : r.fn(Fr(e, t));
+			if (We(e.name)) return Wr(e, t);
+			let i = t.functions;
+			if (i && Object.prototype.hasOwnProperty.call(i, e.name)) return zr(e.name, i[e.name], e, t);
+			let a = t.actions;
+			if (a && Object.prototype.hasOwnProperty.call(a, e.name)) {
+				let n = a[e.name], r = Ir(e, t, n.params);
+				if (Rr(r, n.params)) return { steps: [] };
+				let i = Lr(r, n.params, e.name, "", t, !0);
+				if (i === q) return { steps: [] };
+				let o = {
+					type: "custom_action",
+					name: e.name,
+					params: i
+				};
+				return Hr.add(o), { steps: [o] };
+			}
+			if (e.mappedProps) {
+				let r = n?.library.components[e.name], i = {};
+				for (let [a, o] of Object.entries(e.mappedProps)) {
+					let e = r?.props?.shape?.[a];
+					o.k === "StateRef" && e && y(e) ? i[a] = {
+						__reactive: "assign",
+						target: o.n,
+						expr: {
+							k: "StateRef",
+							n: "$value"
+						}
+					} : o.k === "StateRef" ? i[a] = n ? t.getState(o.n) : o : i[a] = Z(o, t, n);
+				}
+				let a = {
+					type: "element",
+					typeName: e.name,
+					props: i,
+					partial: !1,
+					hasDynamicProps: !0
+				};
+				if (n) for (let [e, r] of Object.entries(i)) U(r) ? i[e] = Nr(r, t, n) : Array.isArray(r) && (i[e] = r.map((e) => U(e) ? Nr(e, t, n) : e));
+				return a;
+			}
+			return console.warn(`[openui] Unexpected unmapped Comp node: ${e.name}`), null;
+		}
+		case "BinOp": {
+			if (e.op === "&&") return Z(e.left, t) && Z(e.right, t);
+			if (e.op === "||") return Z(e.left, t) || Z(e.right, t);
+			let n = Z(e.left, t), r = Z(e.right, t);
+			switch (e.op) {
+				case "+": return typeof n == "string" || typeof r == "string" ? String(n ?? "") + String(r ?? "") : A(n) + A(r);
+				case "-": return A(n) - A(r);
+				case "*": return A(n) * A(r);
+				case "/": return A(r) === 0 ? 0 : A(n) / A(r);
+				case "%": return A(r) === 0 ? 0 : A(n) % A(r);
+				case "==": return n == r;
+				case "!=": return n != r;
+				case ">": return A(n) > A(r);
+				case "<": return A(n) < A(r);
+				case ">=": return A(n) >= A(r);
+				case "<=": return A(n) <= A(r);
+				default: return null;
+			}
+		}
+		case "UnaryOp": return e.op === "!" ? !Z(e.operand, t) : e.op === "-" ? -A(Z(e.operand, t)) : null;
+		case "Ternary": return Z(e.cond, t) ? Z(e.then, t) : Z(e.else, t);
+		case "Member": {
+			let n = Z(e.obj, t);
+			return n == null ? null : Array.isArray(n) ? e.field === "length" ? n.length : n.map((t) => t?.[e.field] ?? null) : n[e.field];
+		}
+		case "Index": {
+			let n = Z(e.obj, t), r = Z(e.index, t);
+			return n == null || r == null ? null : Array.isArray(n) ? n[A(r)] : n[String(r)];
+		}
+		case "Assign": return {
+			__reactive: "assign",
+			target: e.target,
+			expr: e.value
+		};
+	}
+}
+function Nr(e, t, n) {
+	if (e.hasDynamicProps === !1) return e;
+	let r = n.library.components[e.typeName], i = {};
+	for (let [a, o] of Object.entries(e.props)) {
+		let e = r?.props?.shape?.[a];
+		i[a] = Pr(o, t, n, e);
+	}
+	return {
+		...e,
+		props: i
+	};
+}
+function Pr(e, t, n, r) {
+	return Jr(e, t, n, r, {
+		recurseElement: (e) => Nr(e, t, n),
+		recurse: (e, r) => Pr(e, t, n, r)
+	});
+}
+function Fr(e, t, n = F.get(e.name)?.params ?? []) {
+	let r = e.mappedProps ?? Xn(e.args, n), i = {};
+	for (let e in r) i[e] = Z(r[e], t);
+	return i;
+}
+function Ir(e, t, n) {
+	let r = Fr(e, t, Object.keys(n.properties ?? {}).map((e) => ({
+		name: e,
+		required: !1
+	})));
+	for (let e in r) r[e] === null && !n.required?.includes(e) && delete r[e];
+	return r;
+}
+function Lr(e, t, n, r, i, a = !1) {
+	let o = {
+		errors: [],
+		partial: !1
+	}, s = J(e, t, n, r, o);
+	for (let e of o.errors) i.reportError?.(`@${n}: ${e.message}`);
+	return a && o.errors.length > 0 ? q : s;
+}
+function Rr(e, t) {
+	return !!t.required?.some((n) => e[n] == null && Fn(t.properties?.[n]) === void 0);
+}
+function zr(e, t, n, r) {
+	let i = Ir(n, r, t.params);
+	if (Rr(i, t.params)) return null;
+	let a = Lr(i, t.params, e, "", r);
+	if (a === q) return null;
+	let o;
+	try {
+		o = t.fn(a);
+	} catch (t) {
+		return r.reportError?.(`@${e} threw: ${t instanceof Error ? t.message : String(t)}`), null;
+	}
+	if (!t.returns) return o;
+	let s = Lr(o, t.returns, e, "/returns", r);
+	return s === q ? null : s ?? null;
+}
+function Br(e) {
+	return typeof e == "object" && !!e && Array.isArray(e.steps);
+}
+function Vr(e) {
+	return Ur({ steps: e.flatMap((e) => Br(e) ? e.steps : typeof e == "object" && e && "type" in e ? [e] : []) });
+}
+var Hr = /* @__PURE__ */ new WeakSet();
+function Ur(e) {
+	let t = (e) => e?.type !== "custom_action" || Hr.has(e);
+	return e.steps.every(t) ? e : {
+		...e,
+		steps: e.steps.filter(t)
+	};
+}
+function Wr(e, t) {
+	let { name: n, args: r } = e;
+	if (n === "Action") {
+		let e = r.length > 0 ? Z(r[0], t) : [];
+		return Vr(Array.isArray(e) ? e : []);
+	}
+	let i = He[n], a = i.step ? i.step(Fr(e, t)) : Gr(n, r);
+	return { steps: a ? [a] : [] };
+}
+function Gr(e, t) {
+	switch (e) {
+		case "Run": {
+			let e = t[0];
+			return e?.k === "RuntimeRef" ? {
+				type: N.Run,
+				statementId: e.n,
+				refType: e.refType
+			} : null;
+		}
+		case "Set": return t.length < 2 || t[0].k !== "StateRef" ? null : {
+			type: N.Set,
+			target: t[0].n,
+			valueAST: t[1]
+		};
+		case "Reset": {
+			let e = t.filter((e) => e.k === "StateRef").map((e) => e.n);
+			return e.length === 0 ? null : {
+				type: N.Reset,
+				targets: e
+			};
+		}
+		default: return null;
+	}
+}
+function Q(e, t, n) {
+	switch (e.k) {
+		case "Ref": return e.n === t ? gn(n) : e;
+		case "Member":
+			if (W(e.obj)) {
+				let r = Q(e.obj, t, n);
+				if (r.k === "Obj") {
+					let t = r.entries.find(([t]) => t === e.field);
+					if (t) return t[1];
+				}
+				return {
+					...e,
+					obj: r
+				};
+			}
+			return e;
+		case "Index": return {
+			...e,
+			obj: W(e.obj) ? Q(e.obj, t, n) : e.obj,
+			index: W(e.index) ? Q(e.index, t, n) : e.index
+		};
+		case "BinOp": return {
+			...e,
+			left: Q(e.left, t, n),
+			right: Q(e.right, t, n)
+		};
+		case "UnaryOp": return {
+			...e,
+			operand: Q(e.operand, t, n)
+		};
+		case "Ternary": return {
+			...e,
+			cond: Q(e.cond, t, n),
+			then: Q(e.then, t, n),
+			else: Q(e.else, t, n)
+		};
+		case "Arr": return {
+			...e,
+			els: e.els.map((e) => Q(e, t, n))
+		};
+		case "Obj": return {
+			...e,
+			entries: e.entries.map(([e, r]) => [e, Q(r, t, n)])
+		};
+		case "Comp": {
+			let r = (e) => Q(e, t, n), i = {
+				...e,
+				args: e.args.map(r)
+			};
+			return e.mappedProps && (i.mappedProps = Kr(e.mappedProps, r)), i;
+		}
+		case "Assign": return {
+			...e,
+			value: Q(e.value, t, n)
+		};
+		default: return e;
+	}
+}
+function Kr(e, t) {
+	let n = {};
+	for (let r in e) n[r] = t(e[r]);
+	return n;
+}
+function qr(e, t, n, r) {
+	if (e === "Each") {
+		if (t.length < 3) return [];
+		let e = Z(t[0], n);
+		if (!Array.isArray(e)) return [];
+		let i = t[1].k === "Ref" ? t[1].n : t[1].k === "Str" ? t[1].v : null;
+		if (!i) return [];
+		let a = t[2];
+		return e.map((e, t) => {
+			let o = Q(a, i, e), s = {
+				...n,
+				resolveRef: (t) => t === i ? e : n.resolveRef(t)
+			}, c = Z(o, s, r);
+			return r && U(c) ? Nr(c, s, r) : c;
+		});
+	}
+	return null;
+}
+function Jr(e, t, n, r, i) {
+	let a = Yr(e, t, n, r, i);
+	return Br(a) ? Ur(a) : a;
+}
+function Yr(e, t, n, r, i) {
+	if (typeof e != "object" || !e) return e;
+	if (W(e)) {
+		if (e.k === "StateRef" && r && y(r)) return {
+			__reactive: "assign",
+			target: e.n,
+			expr: {
+				k: "StateRef",
+				n: "$value"
+			}
+		};
+		let a = Z(e, t, n);
+		return U(a) ? i.recurseElement(a) : Array.isArray(a) ? a.map((e) => U(e) ? i.recurseElement(e) : e) : Mr(a) && !(r && y(r)) ? t.getState(a.target) ?? null : a;
+	}
+	if (typeof e == "string" && r && y(r)) return e;
+	if (Array.isArray(e)) return e.map((e) => i.recurse(e, r));
+	if (U(e)) return i.recurseElement(e);
+	if (Br(e)) return e;
+	let a = e, o = !1;
+	for (let e of Object.values(a)) if (typeof e == "object" && e) {
+		o = !0;
+		break;
+	}
+	if (o) {
+		let e = {};
+		for (let [t, n] of Object.entries(a)) e[t] = i.recurse(n, r);
+		return e;
+	}
+	return e;
+}
+function Xr(e, t) {
+	if (e.hasDynamicProps === !1) return e;
+	let n = { library: t.library }, r = t.library.components[e.typeName], i = {}, a = "", o = (n) => {
+		t.errors?.push({
+			source: "runtime",
+			code: "runtime-error",
+			component: e.typeName,
+			statementId: e.statementId,
+			message: `Evaluating prop "${a}" on ${e.typeName} failed: ${n}`,
+			hint: `Check the expression used for prop "${a}"`
+		});
+	}, s = t.ctx.functions || t.ctx.actions ? {
+		...t,
+		ctx: {
+			...t.ctx,
+			reportError: o
+		}
+	} : t;
+	for (let [t, c] of Object.entries(e.props)) {
+		a = t;
+		let e = r?.props?.shape?.[a];
+		try {
+			i[a] = Qr(c, s, n, e);
+		} catch (e) {
+			i[a] = c, o(e instanceof Error ? e.message : String(e));
+		}
+	}
+	return {
+		...e,
+		props: i
+	};
+}
+function Zr(e, t) {
+	if (e.root) return Xr(e.root, t);
+	if (!e.rootExpression) return null;
+	let n = Z(e.rootExpression, t.ctx, { library: t.library });
+	return U(n) ? Xr(n, t) : (t.errors?.push({
+		source: "runtime",
+		code: "no-root",
+		statementId: "root",
+		message: "root does not evaluate to a component"
+	}), null);
+}
+function Qr(e, t, n, r) {
+	return Jr(e, t.ctx, n, r, {
+		recurseElement: (e) => Xr(e, t),
+		recurse: (e, r) => Qr(e, t, n, r)
+	});
+}
+var $r = class extends Error {
+	toolErrorText;
+	constructor(e) {
+		super(`MCP tool error: ${e || "Unknown error"}`), this.name = "McpToolError", this.toolErrorText = e;
+	}
+};
+function ei(e) {
+	if (e.isError) {
+		let t = e.content?.filter((e) => e.type === "text").map((e) => e.text).join("\n");
+		throw new $r(t || "Unknown error");
+	}
+	if (e.structuredContent != null) return e.structuredContent;
+	let t = e.content?.filter((e) => e.type === "text").map((e) => e.text ?? "");
+	if (t?.length) {
+		let e = t.join("");
+		try {
+			return JSON.parse(e);
+		} catch {
+			return e;
+		}
+	}
+	return null;
+}
+var ti = class extends Error {
+	toolName;
+	availableTools;
+	constructor(e, t = []) {
+		super(`[openui] No handler for tool "${e}". Available: ${t.join(", ") || "(none)"}`), this.name = "ToolNotFoundError", this.toolName = e, this.availableTools = t;
+	}
+};
+function ni(e) {
+	return JSON.stringify(e, (e, t) => {
+		if (t && typeof t == "object" && !Array.isArray(t)) {
+			let e = {};
+			for (let n of Object.keys(t).sort()) e[n] = t[n];
+			return e;
+		}
+		if (t === void 0) return "__undefined__";
+		if (typeof t == "number") {
+			if (Number.isNaN(t)) return "__NaN__";
+			if (t === Infinity) return "__Inf__";
+			if (t === -Infinity) return "__-Inf__";
+		}
+		return t;
+	});
+}
+function ri(e, t, n) {
+	let r = n == null ? "" : "::" + ni(n);
+	return e + "::" + ni(t) + r;
+}
+function ii(e) {
+	let t = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Set(), a = {
+		__openui_loading: [],
+		__openui_refetching: [],
+		__openui_errors: []
+	}, o = JSON.stringify(a), s = !1, c = 0;
+	function l() {
+		let e = {
+			__openui_loading: [],
+			__openui_refetching: [],
+			__openui_errors: []
+		};
+		for (let [n, i] of t) {
+			let t = r.get(i.cacheKey);
+			if (t && t.data !== void 0) e[n] = t.data;
+			else if (i.prevCacheKey) {
+				let t = r.get(i.prevCacheKey);
+				t && t.data !== void 0 ? e[n] = t.data : e[n] = i.defaults;
+			} else e[n] = i.defaults;
+			i.loading && (e.__openui_loading.push(n), i.everFetched && e.__openui_refetching.push(n)), i.error && e.__openui_errors.push(i.error);
+		}
+		for (let [t, r] of n) e[t] = r.result, r.error && e.__openui_errors.push(r.error);
+		try {
+			let t = JSON.stringify(e);
+			if (t === o) return !1;
+			a = e, o = t;
+		} catch {
+			a = e, o = "";
+		}
+		return !0;
+	}
+	function u() {
+		for (let e of [...i]) e();
+	}
+	async function d(n, i) {
+		if (!e) return;
+		let a = t.get(i);
+		if (!a) return;
+		let o = n, c = a.toolName, p = a.args, m = r.get(o);
+		m ? m.inFlight = !0 : (m = {
+			data: void 0,
+			inFlight: !0
+		}, r.set(o, m)), a.loading = !0, l(), u();
+		try {
+			let n = await e.callTool(c, p ?? {});
+			if (s) return;
+			let r = t.get(i);
+			if (!r || r.cacheKey !== o) {
+				m.inFlight = !1;
+				return;
+			}
+			if (m.data = n ?? null, r.everFetched = !0, r.error = void 0, r.prevCacheKey && r.prevCacheKey !== o) {
+				let e = r.prevCacheKey;
+				r.prevCacheKey = void 0, f(e);
+			}
+		} catch (e) {
+			let n = t.get(i);
+			n && n.cacheKey === o && (e instanceof ti ? n.error = {
+				source: "query",
+				code: "tool-not-found",
+				message: `Query tool "${c}" not found`,
+				statementId: i,
+				component: "Query",
+				toolName: c,
+				hint: e.availableTools.length ? `Available tools: ${e.availableTools.join(", ")}` : void 0
+			} : e instanceof $r ? n.error = {
+				source: "query",
+				code: "mcp-error",
+				message: `Query "${c}" returned an error: ${e.toolErrorText}`,
+				statementId: i,
+				component: "Query",
+				toolName: c
+			} : n.error = {
+				source: "query",
+				code: "tool-error",
+				message: `Query "${c}" failed: ${e instanceof Error ? e.message : String(e)}`,
+				statementId: i,
+				component: "Query",
+				toolName: c
+			}), console.error(`Query "${c}" failed:`, e);
+		} finally {
+			m.inFlight = !1;
+			let e = t.get(i);
+			e && e.cacheKey === o ? (e.loading = !1, l() && u(), e.needsRefetch && (e.needsRefetch = !1, d(e.cacheKey, i))) : l() && u();
+		}
+	}
+	function f(e) {
+		for (let n of t.values()) if (n.cacheKey === e || n.prevCacheKey === e) return;
+		r.delete(e);
+	}
+	function p(n) {
+		if (s) return;
+		let i = new Set(n.map((e) => e.statementId));
+		for (let [e, n] of t) i.has(e) || (n.timer && clearInterval(n.timer), t.delete(e), f(n.cacheKey), n.prevCacheKey && f(n.prevCacheKey));
+		for (let i of n) {
+			if (!i.complete) continue;
+			let n = ri(i.toolName, i.args, i.deps), a = t.get(i.statementId);
+			a ? (a.cacheKey !== n && (a.prevCacheKey = a.cacheKey), a.toolName = i.toolName, a.args = i.args, a.defaults = i.defaults, a.cacheKey = n) : t.set(i.statementId, {
+				toolName: i.toolName,
+				args: i.args,
+				defaults: i.defaults,
+				cacheKey: n,
+				loading: !1,
+				everFetched: !1,
+				refreshInterval: 0,
+				needsRefetch: !1
+			});
+			let o = t.get(i.statementId), c = r.get(n), l = c && c.data !== void 0 && !c.inFlight;
+			e && !l && !c?.inFlight && d(n, i.statementId);
+			let u = i.refreshInterval ?? 0;
+			u !== o.refreshInterval && (o.timer &&= (clearInterval(o.timer), void 0), u > 0 && (o.timer = setInterval(() => {
+				s || !e || r.get(o.cacheKey)?.inFlight || d(o.cacheKey, i.statementId);
+			}, u * 1e3)), o.refreshInterval = u);
+		}
+		l() && u();
+	}
+	function m(e) {
+		let n = t.get(e);
+		if (!n) return null;
+		let i = r.get(n.cacheKey);
+		if (i && i.data !== void 0) return i.data;
+		if (n.prevCacheKey) {
+			let e = r.get(n.prevCacheKey);
+			if (e && e.data !== void 0) return e.data;
+		}
+		return n.defaults;
+	}
+	function h(e) {
+		return t.get(e)?.loading ?? !1;
+	}
+	function g() {
+		for (let e of t.values()) if (e.loading) return !0;
+		return !1;
+	}
+	function _(n) {
+		if (s || !e) return;
+		let i = n?.length ? n.filter((e) => t.has(e)) : [...t.keys()];
+		for (let e of i) {
+			let n = t.get(e);
+			n && (r.get(n.cacheKey)?.inFlight ? n.needsRefetch = !0 : d(n.cacheKey, e));
+		}
+	}
+	function v(e) {
+		let t = new Set(e.map((e) => e.statementId));
+		for (let e of n.keys()) t.has(e) || n.delete(e);
+		for (let t of e) {
+			let e = n.get(t.statementId);
+			e ? e.toolName !== t.toolName && (e.toolName = t.toolName, e.result = {
+				status: "idle",
+				data: null,
+				error: null
+			}, e.error = void 0) : n.set(t.statementId, {
+				toolName: t.toolName,
+				result: { status: "idle" }
+			});
+		}
+		l() && u();
+	}
+	async function ee(t, r, i) {
+		if (s || !e) return !1;
+		let a = n.get(t);
+		if (!a || a.result.status === "loading") return !1;
+		let o = c;
+		a.result = { status: "loading" }, l(), u();
+		let d = !1;
+		try {
+			let t = await e.callTool(a.toolName, r);
+			if (s || o !== c) return !1;
+			a.result = {
+				status: "success",
+				data: t
+			}, a.error = void 0, d = !0;
+		} catch (e) {
+			if (s || o !== c) return !1;
+			let n = e instanceof Error ? e.message : String(e);
+			a.result = {
+				status: "error",
+				error: n
+			}, e instanceof ti ? a.error = {
+				source: "mutation",
+				code: "tool-not-found",
+				message: `Mutation tool "${a.toolName}" not found`,
+				statementId: t,
+				component: "Mutation",
+				toolName: a.toolName,
+				hint: e.availableTools.length ? `Available tools: ${e.availableTools.join(", ")}` : void 0
+			} : e instanceof $r ? a.error = {
+				source: "mutation",
+				code: "mcp-error",
+				message: `Mutation "${a.toolName}" returned an error: ${e.toolErrorText}`,
+				statementId: t,
+				component: "Mutation",
+				toolName: a.toolName
+			} : a.error = {
+				source: "mutation",
+				code: "tool-error",
+				message: `Mutation "${a.toolName}" failed: ${n}`,
+				statementId: t,
+				component: "Mutation",
+				toolName: a.toolName
+			};
+		}
+		return l(), u(), d && i?.length && _(i), d;
+	}
+	function te(e) {
+		return n.get(e)?.result ?? null;
+	}
+	function y(e) {
+		return i.add(e), () => i.delete(e);
+	}
+	function b() {
+		return a;
+	}
+	function x() {
+		s = !1;
+	}
+	function S() {
+		s = !0, c++, i.clear();
+		for (let e of t.values()) e.timer &&= (clearInterval(e.timer), void 0), e.refreshInterval = 0, e.loading = !1, e.needsRefetch = !1;
+		n.clear();
+	}
+	return {
+		evaluateQueries: p,
+		getResult: m,
+		isLoading: h,
+		isAnyLoading: g,
+		invalidate: _,
+		registerMutations: v,
+		fireMutation: ee,
+		getMutationResult: te,
+		subscribe: y,
+		getSnapshot: b,
+		activate: x,
+		dispose: S
+	};
+}
+function ai(e, t, n, r, i, a) {
+	if (Mr(t) && n && r) {
+		let { target: i, expr: a } = t;
+		return {
+			name: e,
+			value: n.get(i),
+			setValue: (e) => {
+				let t = { $value: e }, o = Z(a, {
+					...r,
+					extraScope: t
+				});
+				n.set(i, o);
+			},
+			isReactive: !0
+		};
+	}
+	return {
+		name: e,
+		value: i(e) ?? t,
+		setValue: (t) => a(e, t),
+		isReactive: !1
+	};
+}
+function oi() {
+	let e = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set(), r = {};
+	function i() {
+		let e = [...n];
+		for (let t of e) t();
+	}
+	function a() {
+		r = Object.fromEntries(e);
+	}
+	function o(t) {
+		return e.get(t);
+	}
+	function s(n, r, o) {
+		o?.pristine ? t.add(n) : t.delete(n);
+		let s = e.get(n);
+		if (!Object.is(s, r)) {
+			if (r && s && typeof r == "object" && typeof s == "object" && !Array.isArray(r) && !Array.isArray(s)) {
+				let e = Object.keys(r), t = Object.keys(s);
+				if (e.length === t.length && e.every((e) => Object.is(r[e], s[e]))) return;
+			}
+			e.set(n, r), a(), i();
+		}
+	}
+	function c(e) {
+		return n.add(e), () => {
+			n.delete(e);
+		};
+	}
+	function l() {
+		return r;
+	}
+	function u(n, r) {
+		let o = !1;
+		for (let n of Object.keys(r)) t.delete(n), (!e.has(n) || !Object.is(e.get(n), r[n])) && (e.set(n, r[n]), o = !0);
+		for (let r of Object.keys(n)) e.has(r) ? t.has(r) && !Object.is(e.get(r), n[r]) && (e.set(r, n[r]), o = !0) : (e.set(r, n[r]), t.add(r), o = !0);
+		o && (a(), i());
+	}
+	function d() {
+		e.clear(), t.clear(), n.clear(), r = {};
+	}
+	return {
+		get: o,
+		set: s,
+		subscribe: c,
+		getSnapshot: l,
+		initialize: u,
+		dispose: d
+	};
+}
+var si = new Set([
+	"min",
+	"max",
+	"minLength",
+	"maxLength"
+]);
+function ci(e) {
+	let t = e.indexOf(":");
+	if (t === -1) return { type: e };
+	let n = e.slice(0, t), r = e.slice(t + 1);
+	return {
+		type: n,
+		arg: si.has(n) && !Number.isNaN(Number(r)) ? Number(r) : r
+	};
+}
+function li(e) {
+	return Array.isArray(e) ? e.filter((e) => typeof e == "string").map(ci) : [];
+}
+function $(e) {
+	return e == null || e === "" || Array.isArray(e) && e.length === 0 ? !0 : e && typeof e == "object" && !Array.isArray(e) && "value" in e ? $(e.value) : !!(typeof e == "object" && e && !Array.isArray(e) && Object.keys(e).length === 0);
+}
+var ui = {
+	required: (e) => {
+		if ($(e)) return "This field is required";
+		if (typeof e == "object" && !Array.isArray(e) && e !== null) {
+			let t = Object.values(e);
+			if (t.length > 0 && t.every((e) => typeof e == "boolean") && !t.some(Boolean)) return "At least one option is required";
+		}
+	},
+	email: (e) => {
+		if (!$(e)) return typeof e == "string" && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(e) ? void 0 : "Please enter a valid email";
+	},
+	url: (e) => {
+		if (!$(e)) {
+			if (typeof e != "string") return "Please enter a valid URL";
+			try {
+				new URL(e);
+				return;
+			} catch {
+				return "Please enter a valid URL";
+			}
+		}
+	},
+	numeric: (e) => {
+		if (!$(e) && !(typeof e == "number" && !isNaN(e)) && !(typeof e == "string" && !isNaN(parseFloat(e)) && e.trim() !== "")) return "Must be a number";
+	},
+	min: (e, t) => {
+		if ($(e)) return;
+		let n = typeof e == "number" ? e : parseFloat(String(e));
+		if (isNaN(n)) return;
+		let r = Number(t);
+		return n >= r ? void 0 : `Must be at least ${r}`;
+	},
+	max: (e, t) => {
+		if ($(e)) return;
+		let n = typeof e == "number" ? e : parseFloat(String(e));
+		if (isNaN(n)) return;
+		let r = Number(t);
+		return n <= r ? void 0 : `Must be no more than ${r}`;
+	},
+	minLength: (e, t) => {
+		if ($(e) || typeof e != "string") return;
+		let n = Number(t);
+		return e.length >= n ? void 0 : `Must be at least ${n} characters`;
+	},
+	maxLength: (e, t) => {
+		if ($(e) || typeof e != "string") return;
+		let n = Number(t);
+		return e.length <= n ? void 0 : `Must be no more than ${n} characters`;
+	},
+	pattern: (e, t) => {
+		if (!$(e) && !(typeof e != "string" || typeof t != "string")) try {
+			return new RegExp(t).test(e) ? void 0 : "Invalid format";
+		} catch {
+			return;
+		}
+	}
+};
+function di(e, t, n) {
+	for (let r of t) {
+		let t = n?.[r.type] ?? ui[r.type];
+		if (!t) {
+			console.warn(`[openui] Unknown validation rule type: "${r.type}"`);
+			continue;
+		}
+		let i = t(e, r.arg);
+		if (i) return i;
+	}
+}
+function fi(e) {
+	if (!e || typeof e != "object" || Array.isArray(e)) return [];
+	let t = e, n = [];
+	for (let [e, r] of Object.entries(t)) r === !1 || r == null || (r === !0 ? n.push({ type: e }) : n.push({
+		type: e,
+		arg: r
+	}));
+	return n;
+}
+//#endregion
+export { N as ACTION_STEPS, fn as BuiltinActionType, ti as ToolNotFoundError, ze as action, dn as buildMessage, ui as builtInValidators, nn as createLibrary, Cr as createParser, ii as createQueryManager, oi as createStore, wr as createStreamingParser, k as defineAction, Zt as defineComponent, O as defineFunction, Er as enrichErrors, Z as evaluate, Zr as evaluateRoot, ei as extractToolResult, qt as generatePrompt, Jt as generateSystemPrompt, Mr as isReactiveAssign, te as markReactive, jr as mergeStatements, un as parseMessage, li as parseRules, fi as parseStructuredRules, ai as resolveStateField, P as steps, x as tagSchemaId, di as validate };