@webskill/sdk 0.3.0 → 0.4.0

package/dist/jsonRenderRegistry-9GrWP_hE-U6Do3Kid.js

@@ -1,2468 +0,0 @@
-import { ft as uiCatalog } from "./dist-ZKaM8j06.js";
-import { n as catalogComponentImpls } from "./catalogComponents-C_V39rbF-BOHveMWa.js";
-import { z } from "zod";
-import React, { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
-import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
-
-//#region ../../node_modules/.pnpm/@json-render+core@0.19.0_zod@4.4.3/node_modules/@json-render/core/dist/chunk-AFLK3Q4T.mjs
-var DynamicValueSchema = z.union([
-	z.string(),
-	z.number(),
-	z.boolean(),
-	z.null(),
-	z.object({ $state: z.string() })
-]);
-var DynamicStringSchema = z.union([z.string(), z.object({ $state: z.string() })]);
-var DynamicNumberSchema = z.union([z.number(), z.object({ $state: z.string() })]);
-var DynamicBooleanSchema = z.union([z.boolean(), z.object({ $state: z.string() })]);
-function resolveDynamicValue(value, stateModel) {
-	if (value === null || value === void 0) return;
-	if (typeof value === "object" && "$state" in value) return getByPath(stateModel, value.$state);
-	return value;
-}
-function unescapeJsonPointer(token) {
-	return token.replace(/~1/g, "/").replace(/~0/g, "~");
-}
-function parseJsonPointer(path) {
-	return (path.startsWith("/") ? path.slice(1).split("/") : path.split("/")).map(unescapeJsonPointer);
-}
-function getByPath(obj, path) {
-	if (!path || path === "/") return obj;
-	const segments = parseJsonPointer(path);
-	let current = obj;
-	for (const segment of segments) {
-		if (current === null || current === void 0) return;
-		if (Array.isArray(current)) current = current[parseInt(segment, 10)];
-		else if (typeof current === "object") current = current[segment];
-		else return;
-	}
-	return current;
-}
-var SPEC_DATA_PART = "spec";
-var SPEC_DATA_PART_TYPE = `data-${SPEC_DATA_PART}`;
-function immutableSetByPath(root, path, value) {
-	const segments = parseJsonPointer(path);
-	if (segments.length === 0) return root;
-	const result = { ...root };
-	let current = result;
-	for (let i = 0; i < segments.length - 1; i++) {
-		const seg = segments[i];
-		const child = current[seg];
-		if (Array.isArray(child)) current[seg] = [...child];
-		else if (child !== null && typeof child === "object") current[seg] = { ...child };
-		else {
-			const nextSeg = segments[i + 1];
-			current[seg] = nextSeg !== void 0 && /^\d+$/.test(nextSeg) ? [] : {};
-		}
-		current = current[seg];
-	}
-	const lastSeg = segments[segments.length - 1];
-	if (Array.isArray(current)) if (lastSeg === "-") current.push(value);
-	else current[parseInt(lastSeg, 10)] = value;
-	else current[lastSeg] = value;
-	return result;
-}
-function createStateStore(initialState = {}) {
-	let state = { ...initialState };
-	const listeners = /* @__PURE__ */ new Set();
-	function notify() {
-		for (const listener of listeners) listener();
-	}
-	return {
-		get(path) {
-			return getByPath(state, path);
-		},
-		set(path, value) {
-			if (getByPath(state, path) === value) return;
-			state = immutableSetByPath(state, path, value);
-			notify();
-		},
-		update(updates) {
-			let changed = false;
-			let next = state;
-			for (const [path, value] of Object.entries(updates)) if (getByPath(next, path) !== value) {
-				next = immutableSetByPath(next, path, value);
-				changed = true;
-			}
-			if (!changed) return;
-			state = next;
-			notify();
-		},
-		getSnapshot() {
-			return state;
-		},
-		getServerSnapshot() {
-			return state;
-		},
-		subscribe(listener) {
-			listeners.add(listener);
-			return () => {
-				listeners.delete(listener);
-			};
-		}
-	};
-}
-var MAX_FLATTEN_DEPTH = 20;
-function flattenToPointers(obj, prefix = "", _depth = 0, _seen, _warned) {
-	const seen = _seen ?? /* @__PURE__ */ new Set();
-	const warned = _warned ?? { current: false };
-	const result = {};
-	for (const [key, value] of Object.entries(obj)) {
-		const pointer = `${prefix}/${key}`;
-		if (_depth < MAX_FLATTEN_DEPTH && value !== null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype && !seen.has(value)) {
-			seen.add(value);
-			Object.assign(result, flattenToPointers(value, pointer, _depth + 1, seen, warned));
-		} else {
-			if (process.env.NODE_ENV !== "production" && !warned.current && _depth >= MAX_FLATTEN_DEPTH && value !== null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype && !seen.has(value)) {
-				warned.current = true;
-				console.warn(`flattenToPointers: depth limit (${MAX_FLATTEN_DEPTH}) reached. Nested state beyond this depth will be treated as a leaf value.`);
-			}
-			result[pointer] = value;
-		}
-	}
-	return result;
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/@json-render+core@0.19.0_zod@4.4.3/node_modules/@json-render/core/dist/index.mjs
-var numericOrStateRef = z.union([z.number(), z.object({ $state: z.string() })]);
-var comparisonOps = {
-	eq: z.unknown().optional(),
-	neq: z.unknown().optional(),
-	gt: numericOrStateRef.optional(),
-	gte: numericOrStateRef.optional(),
-	lt: numericOrStateRef.optional(),
-	lte: numericOrStateRef.optional(),
-	not: z.literal(true).optional()
-};
-var StateConditionSchema = z.object({
-	$state: z.string(),
-	...comparisonOps
-});
-var ItemConditionSchema = z.object({
-	$item: z.string(),
-	...comparisonOps
-});
-var IndexConditionSchema = z.object({
-	$index: z.literal(true),
-	...comparisonOps
-});
-var SingleConditionSchema = z.union([
-	StateConditionSchema,
-	ItemConditionSchema,
-	IndexConditionSchema
-]);
-var VisibilityConditionSchema = z.lazy(() => z.union([
-	z.boolean(),
-	SingleConditionSchema,
-	z.array(SingleConditionSchema),
-	z.object({ $and: z.array(VisibilityConditionSchema) }),
-	z.object({ $or: z.array(VisibilityConditionSchema) })
-]));
-function resolveComparisonValue(value, ctx) {
-	if (typeof value === "object" && value !== null) {
-		if ("$state" in value && typeof value.$state === "string") return getByPath(ctx.stateModel, value.$state);
-	}
-	return value;
-}
-function isItemCondition(cond) {
-	return "$item" in cond;
-}
-function isIndexCondition(cond) {
-	return "$index" in cond;
-}
-function resolveConditionValue(cond, ctx) {
-	if (isIndexCondition(cond)) return ctx.repeatIndex;
-	if (isItemCondition(cond)) {
-		if (ctx.repeatItem === void 0) return void 0;
-		return cond.$item === "" ? ctx.repeatItem : getByPath(ctx.repeatItem, cond.$item);
-	}
-	return getByPath(ctx.stateModel, cond.$state);
-}
-function evaluateCondition(cond, ctx) {
-	const value = resolveConditionValue(cond, ctx);
-	let result;
-	if (cond.eq !== void 0) result = value === resolveComparisonValue(cond.eq, ctx);
-	else if (cond.neq !== void 0) result = value !== resolveComparisonValue(cond.neq, ctx);
-	else if (cond.gt !== void 0) {
-		const rhs = resolveComparisonValue(cond.gt, ctx);
-		result = typeof value === "number" && typeof rhs === "number" ? value > rhs : false;
-	} else if (cond.gte !== void 0) {
-		const rhs = resolveComparisonValue(cond.gte, ctx);
-		result = typeof value === "number" && typeof rhs === "number" ? value >= rhs : false;
-	} else if (cond.lt !== void 0) {
-		const rhs = resolveComparisonValue(cond.lt, ctx);
-		result = typeof value === "number" && typeof rhs === "number" ? value < rhs : false;
-	} else if (cond.lte !== void 0) {
-		const rhs = resolveComparisonValue(cond.lte, ctx);
-		result = typeof value === "number" && typeof rhs === "number" ? value <= rhs : false;
-	} else result = Boolean(value);
-	return cond.not === true ? !result : result;
-}
-function isAndCondition(condition) {
-	return typeof condition === "object" && condition !== null && !Array.isArray(condition) && "$and" in condition;
-}
-function isOrCondition(condition) {
-	return typeof condition === "object" && condition !== null && !Array.isArray(condition) && "$or" in condition;
-}
-function evaluateVisibility(condition, ctx) {
-	if (condition === void 0) return true;
-	if (typeof condition === "boolean") return condition;
-	if (Array.isArray(condition)) return condition.every((c) => evaluateCondition(c, ctx));
-	if (isAndCondition(condition)) return condition.$and.every((child) => evaluateVisibility(child, ctx));
-	if (isOrCondition(condition)) return condition.$or.some((child) => evaluateVisibility(child, ctx));
-	return evaluateCondition(condition, ctx);
-}
-function createDirectiveRegistry(directives) {
-	const registry = /* @__PURE__ */ new Map();
-	for (const d of directives) registry.set(d.name, d);
-	return registry;
-}
-function findDirective(value, directives) {
-	if (!directives || directives.size === 0) return void 0;
-	let match;
-	for (const [key, def] of directives) if (key in value) {
-		if (match) throw new Error(`Ambiguous directive: object has multiple directive keys ("${match.name}" and "${key}")`);
-		match = def;
-	}
-	return match;
-}
-function isStateExpression(value) {
-	return typeof value === "object" && value !== null && "$state" in value && typeof value.$state === "string";
-}
-function isItemExpression(value) {
-	return typeof value === "object" && value !== null && "$item" in value && typeof value.$item === "string";
-}
-function isIndexExpression(value) {
-	return typeof value === "object" && value !== null && "$index" in value && value.$index === true;
-}
-function isBindStateExpression(value) {
-	return typeof value === "object" && value !== null && "$bindState" in value && typeof value.$bindState === "string";
-}
-function isBindItemExpression(value) {
-	return typeof value === "object" && value !== null && "$bindItem" in value && typeof value.$bindItem === "string";
-}
-function isCondExpression(value) {
-	return typeof value === "object" && value !== null && "$cond" in value && "$then" in value && "$else" in value;
-}
-function isComputedExpression(value) {
-	return typeof value === "object" && value !== null && "$computed" in value && typeof value.$computed === "string";
-}
-function isTemplateExpression(value) {
-	return typeof value === "object" && value !== null && "$template" in value && typeof value.$template === "string";
-}
-var WARNED_COMPUTED_MAX = 100;
-var warnedComputedFns = /* @__PURE__ */ new Set();
-function resolveBindItemPath(itemPath, ctx) {
-	if (ctx.repeatBasePath == null) {
-		console.warn(`$bindItem used outside repeat scope: "${itemPath}"`);
-		return;
-	}
-	if (itemPath === "") return ctx.repeatBasePath;
-	return ctx.repeatBasePath + "/" + itemPath;
-}
-function resolvePropValue(value, ctx) {
-	if (value === null || value === void 0) return value;
-	if (isStateExpression(value)) return getByPath(ctx.stateModel, value.$state);
-	if (isItemExpression(value)) {
-		if (ctx.repeatItem === void 0) return void 0;
-		return value.$item === "" ? ctx.repeatItem : getByPath(ctx.repeatItem, value.$item);
-	}
-	if (isIndexExpression(value)) return ctx.repeatIndex;
-	if (isBindStateExpression(value)) return getByPath(ctx.stateModel, value.$bindState);
-	if (isBindItemExpression(value)) {
-		const resolvedPath = resolveBindItemPath(value.$bindItem, ctx);
-		if (resolvedPath === void 0) return void 0;
-		return getByPath(ctx.stateModel, resolvedPath);
-	}
-	if (isCondExpression(value)) return resolvePropValue(evaluateVisibility(value.$cond, ctx) ? value.$then : value.$else, ctx);
-	if (isComputedExpression(value)) {
-		const fn = ctx.functions?.[value.$computed];
-		if (!fn) {
-			if (!warnedComputedFns.has(value.$computed)) {
-				if (warnedComputedFns.size < WARNED_COMPUTED_MAX) warnedComputedFns.add(value.$computed);
-				console.warn(`Unknown $computed function: "${value.$computed}"`);
-			}
-			return;
-		}
-		const resolvedArgs = {};
-		if (value.args) for (const [key, arg] of Object.entries(value.args)) resolvedArgs[key] = resolvePropValue(arg, ctx);
-		return fn(resolvedArgs);
-	}
-	if (isTemplateExpression(value)) return value.$template.replace(/\$\{([^}]+)\}/g, (_match, rawPath) => {
-		if (rawPath.startsWith("/")) {
-			const resolved2 = getByPath(ctx.stateModel, rawPath);
-			return resolved2 != null ? String(resolved2) : "";
-		}
-		if (ctx.repeatItem !== void 0) {
-			const fromItem = getByPath(ctx.repeatItem, rawPath);
-			if (fromItem != null) return String(fromItem);
-		}
-		const resolved = getByPath(ctx.stateModel, "/" + rawPath);
-		return resolved != null ? String(resolved) : "";
-	});
-	if (Array.isArray(value)) return value.map((item) => resolvePropValue(item, ctx));
-	if (typeof value === "object") {
-		const directive = findDirective(value, ctx.directives);
-		if (directive) return directive.resolve(value, ctx);
-		const resolved = {};
-		for (const [key, val] of Object.entries(value)) resolved[key] = resolvePropValue(val, ctx);
-		return resolved;
-	}
-	return value;
-}
-function resolveElementProps(props, ctx) {
-	const resolved = {};
-	for (const [key, value] of Object.entries(props)) resolved[key] = resolvePropValue(value, ctx);
-	return resolved;
-}
-function resolveBindings(props, ctx) {
-	let bindings;
-	for (const [key, value] of Object.entries(props)) if (isBindStateExpression(value)) {
-		if (!bindings) bindings = {};
-		bindings[key] = value.$bindState;
-	} else if (isBindItemExpression(value)) {
-		const resolved = resolveBindItemPath(value.$bindItem, ctx);
-		if (resolved !== void 0) {
-			if (!bindings) bindings = {};
-			bindings[key] = resolved;
-		}
-	}
-	return bindings;
-}
-function resolveActionParam(value, ctx) {
-	if (isItemExpression(value)) return resolveBindItemPath(value.$item, ctx);
-	if (isIndexExpression(value)) return ctx.repeatIndex;
-	return resolvePropValue(value, ctx);
-}
-var observers = /* @__PURE__ */ new Set();
-function notifyActionDispatch(evt) {
-	for (const o of observers) {
-		const fn = o.onDispatch;
-		if (!fn) continue;
-		try {
-			fn(evt);
-		} catch (err) {
-			if (process.env.NODE_ENV !== "production") console.error("[json-render] action observer threw in onDispatch:", err);
-		}
-	}
-}
-function notifyActionSettle(evt) {
-	for (const o of observers) {
-		const fn = o.onSettle;
-		if (!fn) continue;
-		try {
-			fn(evt);
-		} catch (err) {
-			if (process.env.NODE_ENV !== "production") console.error("[json-render] action observer threw in onSettle:", err);
-		}
-	}
-}
-var dispatchCounter = 0;
-function nextActionDispatchId() {
-	dispatchCounter += 1;
-	return `${Date.now()}-${dispatchCounter}`;
-}
-var activeCount = 0;
-var listeners = /* @__PURE__ */ new Set();
-function isDevtoolsActive() {
-	return activeCount > 0;
-}
-function subscribeDevtoolsActive(listener) {
-	listeners.add(listener);
-	return () => {
-		listeners.delete(listener);
-	};
-}
-var ActionConfirmSchema = z.object({
-	title: z.string(),
-	message: z.string(),
-	confirmLabel: z.string().optional(),
-	cancelLabel: z.string().optional(),
-	variant: z.enum(["default", "danger"]).optional()
-});
-var ActionOnSuccessSchema = z.union([
-	z.object({ navigate: z.string() }),
-	z.object({ set: z.record(z.string(), z.unknown()) }),
-	z.object({ action: z.string() })
-]);
-var ActionOnErrorSchema = z.union([z.object({ set: z.record(z.string(), z.unknown()) }), z.object({ action: z.string() })]);
-var ActionBindingSchema = z.object({
-	action: z.string(),
-	params: z.record(z.string(), DynamicValueSchema).optional(),
-	confirm: ActionConfirmSchema.optional(),
-	onSuccess: ActionOnSuccessSchema.optional(),
-	onError: ActionOnErrorSchema.optional(),
-	preventDefault: z.boolean().optional()
-});
-function resolveAction(binding, stateModel) {
-	const resolvedParams = {};
-	if (binding.params) for (const [key, value] of Object.entries(binding.params)) resolvedParams[key] = resolveDynamicValue(value, stateModel);
-	let confirm = binding.confirm;
-	if (confirm) confirm = {
-		...confirm,
-		message: interpolateString(confirm.message, stateModel),
-		title: interpolateString(confirm.title, stateModel)
-	};
-	return {
-		action: binding.action,
-		params: resolvedParams,
-		confirm,
-		onSuccess: binding.onSuccess,
-		onError: binding.onError
-	};
-}
-function interpolateString(template, stateModel) {
-	return template.replace(/\$\{([^}]+)\}/g, (_, path) => {
-		const value = resolveDynamicValue({ $state: path }, stateModel);
-		return String(value ?? "");
-	});
-}
-async function executeAction(ctx) {
-	const { action: action2, handler, setState, navigate, executeAction: executeAction2 } = ctx;
-	try {
-		await handler(action2.params);
-		if (action2.onSuccess) {
-			if ("navigate" in action2.onSuccess && navigate) navigate(action2.onSuccess.navigate);
-			else if ("set" in action2.onSuccess) for (const [path, value] of Object.entries(action2.onSuccess.set)) setState(path, value);
-			else if ("action" in action2.onSuccess && executeAction2) await executeAction2(action2.onSuccess.action);
-		}
-	} catch (error) {
-		if (action2.onError) {
-			if ("set" in action2.onError) for (const [path, value] of Object.entries(action2.onError.set)) setState(path, typeof value === "string" && value === "$error.message" ? error.message : value);
-			else if ("action" in action2.onError && executeAction2) await executeAction2(action2.onError.action);
-		} else throw error;
-	}
-}
-var ValidationCheckSchema = z.object({
-	type: z.string(),
-	args: z.record(z.string(), DynamicValueSchema).optional(),
-	message: z.string()
-});
-var ValidationConfigSchema = z.object({
-	checks: z.array(ValidationCheckSchema).optional(),
-	validateOn: z.enum([
-		"change",
-		"blur",
-		"submit"
-	]).optional(),
-	enabled: VisibilityConditionSchema.optional()
-});
-var matchesImpl = (value, args) => {
-	return value === args?.other;
-};
-var builtInValidationFunctions = {
-	/**
-	* Check if value is not null, undefined, or empty string
-	*/
-	required: (value) => {
-		if (value === null || value === void 0) return false;
-		if (typeof value === "string") return value.trim().length > 0;
-		if (Array.isArray(value)) return value.length > 0;
-		return true;
-	},
-	/**
-	* Check if value is a valid email address
-	*/
-	email: (value) => {
-		if (typeof value !== "string") return false;
-		return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
-	},
-	/**
-	* Check minimum string length
-	*/
-	minLength: (value, args) => {
-		if (typeof value !== "string") return false;
-		const min = args?.min;
-		if (typeof min !== "number") return false;
-		return value.length >= min;
-	},
-	/**
-	* Check maximum string length
-	*/
-	maxLength: (value, args) => {
-		if (typeof value !== "string") return false;
-		const max = args?.max;
-		if (typeof max !== "number") return false;
-		return value.length <= max;
-	},
-	/**
-	* Check if string matches a regex pattern
-	*/
-	pattern: (value, args) => {
-		if (typeof value !== "string") return false;
-		const pattern = args?.pattern;
-		if (typeof pattern !== "string") return false;
-		try {
-			return new RegExp(pattern).test(value);
-		} catch {
-			return false;
-		}
-	},
-	/**
-	* Check minimum numeric value
-	*/
-	min: (value, args) => {
-		if (typeof value !== "number") return false;
-		const min = args?.min;
-		if (typeof min !== "number") return false;
-		return value >= min;
-	},
-	/**
-	* Check maximum numeric value
-	*/
-	max: (value, args) => {
-		if (typeof value !== "number") return false;
-		const max = args?.max;
-		if (typeof max !== "number") return false;
-		return value <= max;
-	},
-	/**
-	* Check if value is a number
-	*/
-	numeric: (value) => {
-		if (typeof value === "number") return !isNaN(value);
-		if (typeof value === "string") return !isNaN(parseFloat(value));
-		return false;
-	},
-	/**
-	* Check if value is a valid URL
-	*/
-	url: (value) => {
-		if (typeof value !== "string") return false;
-		try {
-			new URL(value);
-			return true;
-		} catch {
-			return false;
-		}
-	},
-	/**
-	* Check if value matches another field
-	*/
-	matches: matchesImpl,
-	/**
-	* Alias for matches with a more descriptive name for cross-field equality
-	*/
-	equalTo: matchesImpl,
-	/**
-	* Check if value is less than another field's value.
-	* Supports numbers, strings (useful for ISO date comparison), and
-	* cross-type numeric coercion (e.g. string "3" vs number 5).
-	*/
-	lessThan: (value, args) => {
-		const other = args?.other;
-		if (value == null || other == null || value === "" || other === "") return false;
-		if (typeof value === "number" && typeof other === "number") return value < other;
-		if (typeof value === "string" && typeof other === "string") return value < other;
-		const numVal = Number(value);
-		const numOther = Number(other);
-		if (!isNaN(numVal) && !isNaN(numOther)) return numVal < numOther;
-		return false;
-	},
-	/**
-	* Check if value is greater than another field's value.
-	* Supports numbers, strings (useful for ISO date comparison), and
-	* cross-type numeric coercion (e.g. string "7" vs number 5).
-	*/
-	greaterThan: (value, args) => {
-		const other = args?.other;
-		if (value == null || other == null || value === "" || other === "") return false;
-		if (typeof value === "number" && typeof other === "number") return value > other;
-		if (typeof value === "string" && typeof other === "string") return value > other;
-		const numVal = Number(value);
-		const numOther = Number(other);
-		if (!isNaN(numVal) && !isNaN(numOther)) return numVal > numOther;
-		return false;
-	},
-	/**
-	* Required only when a condition is met.
-	* Uses JS truthiness: 0, false, "", null, and undefined are all
-	* treated as "condition not met" (field not required), matching
-	* the visibility system's bare-condition semantics.
-	*/
-	requiredIf: (value, args) => {
-		if (!args?.field) return true;
-		if (value === null || value === void 0) return false;
-		if (typeof value === "string") return value.trim().length > 0;
-		if (Array.isArray(value)) return value.length > 0;
-		return true;
-	}
-};
-function runValidationCheck(check2, ctx) {
-	const { value, stateModel, customFunctions } = ctx;
-	const resolvedArgs = {};
-	if (check2.args) for (const [key, argValue] of Object.entries(check2.args)) resolvedArgs[key] = resolvePropValue(argValue, { stateModel });
-	const validationFn = builtInValidationFunctions[check2.type] ?? customFunctions?.[check2.type];
-	if (!validationFn) {
-		console.warn(`Unknown validation function: ${check2.type}`);
-		return {
-			type: check2.type,
-			valid: true,
-			message: check2.message
-		};
-	}
-	const valid = validationFn(value, resolvedArgs);
-	return {
-		type: check2.type,
-		valid,
-		message: check2.message
-	};
-}
-function runValidation(config, ctx) {
-	const checks = [];
-	const errors = [];
-	if (config.enabled) {
-		if (!evaluateVisibility(config.enabled, { stateModel: ctx.stateModel })) return {
-			valid: true,
-			errors: [],
-			checks: []
-		};
-	}
-	if (config.checks) for (const check2 of config.checks) {
-		const result = runValidationCheck(check2, ctx);
-		checks.push(result);
-		if (!result.valid) errors.push(result.message);
-	}
-	return {
-		valid: errors.length === 0,
-		errors,
-		checks
-	};
-}
-var DEFAULT_MODES = ["patch"];
-function normalizeModes(config) {
-	if (!config?.modes?.length) return DEFAULT_MODES;
-	return config.modes;
-}
-function jsonPatchInstructions() {
-	return [
-		"PATCH MODE (RFC 6902 JSON Patch):",
-		"Output one JSON object per line. Each line is a patch operation.",
-		"- Add: {\"op\":\"add\",\"path\":\"/elements/new-key\",\"value\":{...}}",
-		"- Replace: {\"op\":\"replace\",\"path\":\"/elements/existing-key\",\"value\":{...}}",
-		"- Remove: {\"op\":\"remove\",\"path\":\"/elements/old-key\"}",
-		"Only output patches for what needs to change."
-	].join("\n");
-}
-function jsonMergeInstructions() {
-	return [
-		"MERGE MODE (RFC 7396 JSON Merge Patch):",
-		"Output a single JSON object on one line with __json_edit set to true.",
-		"Include only the keys that changed. Unmentioned keys are preserved.",
-		"Set a key to null to delete it.",
-		"",
-		"Example (update a title and add an element):",
-		"{\"__json_edit\":true,\"elements\":{\"main\":{\"props\":{\"title\":\"New Title\"}},\"new-el\":{\"type\":\"Card\",\"props\":{},\"children\":[]}}}",
-		"",
-		"Example (delete an element):",
-		"{\"__json_edit\":true,\"elements\":{\"old-widget\":null}}"
-	].join("\n");
-}
-function jsonDiffInstructions() {
-	return [
-		"DIFF MODE (unified diff):",
-		"Output a unified diff inside a ```diff code fence.",
-		"The diff applies against the JSON-serialized current spec.",
-		"",
-		"Example:",
-		"```diff",
-		"--- a/spec.json",
-		"+++ b/spec.json",
-		"@@ -3,1 +3,1 @@",
-		"-      \"title\": \"Login\"",
-		"+      \"title\": \"Welcome Back\"",
-		"```"
-	].join("\n");
-}
-function yamlPatchInstructions() {
-	return [
-		"PATCH MODE (RFC 6902 JSON Patch):",
-		"Output RFC 6902 JSON Patch lines inside a ```yaml-patch code fence.",
-		"Each line is one JSON patch operation.",
-		"",
-		"Example:",
-		"```yaml-patch",
-		"{\"op\":\"replace\",\"path\":\"/elements/main/props/title\",\"value\":\"New Title\"}",
-		"{\"op\":\"add\",\"path\":\"/elements/new-el\",\"value\":{\"type\":\"Card\",\"props\":{},\"children\":[]}}",
-		"```"
-	].join("\n");
-}
-function yamlMergeInstructions() {
-	return [
-		"MERGE MODE (RFC 7396 JSON Merge Patch):",
-		"Output only the changed parts in a ```yaml-edit code fence.",
-		"Uses deep merge semantics: only keys you include are updated. Unmentioned elements and props are preserved.",
-		"Set a key to null to delete it.",
-		"",
-		"Example edit (update title, add a new element):",
-		"```yaml-edit",
-		"elements:",
-		"  main:",
-		"    props:",
-		"      title: Updated Title",
-		"  new-chart:",
-		"    type: Card",
-		"    props: {}",
-		"    children: []",
-		"```",
-		"",
-		"Example deletion:",
-		"```yaml-edit",
-		"elements:",
-		"  old-widget: null",
-		"```"
-	].join("\n");
-}
-function yamlDiffInstructions() {
-	return [
-		"DIFF MODE (unified diff):",
-		"Output a unified diff inside a ```diff code fence.",
-		"The diff applies against the YAML-serialized current spec.",
-		"",
-		"Example:",
-		"```diff",
-		"--- a/spec.yaml",
-		"+++ b/spec.yaml",
-		"@@ -6,1 +6,1 @@",
-		"-      title: Login",
-		"+      title: Welcome Back",
-		"```"
-	].join("\n");
-}
-function modeSelectionGuidance(modes) {
-	if (modes.length === 1) return "";
-	const parts = ["Choose the best edit strategy for the requested change:"];
-	if (modes.includes("patch")) parts.push("- PATCH: best for precise, targeted single-field updates");
-	if (modes.includes("merge")) parts.push("- MERGE: best for structural changes (add/remove elements, reparent children, update multiple props at once)");
-	if (modes.includes("diff")) parts.push("- DIFF: best for small text-level changes when you can see the exact lines to change");
-	return parts.join("\n");
-}
-function buildEditInstructions(config, format) {
-	const modes = normalizeModes(config);
-	const sections = [];
-	sections.push("EDITING EXISTING SPECS:");
-	sections.push("");
-	const guidance = modeSelectionGuidance(modes);
-	if (guidance) {
-		sections.push(guidance);
-		sections.push("");
-	}
-	for (const mode of modes) {
-		if (format === "json") switch (mode) {
-			case "patch":
-				sections.push(jsonPatchInstructions());
-				break;
-			case "merge":
-				sections.push(jsonMergeInstructions());
-				break;
-			case "diff":
-				sections.push(jsonDiffInstructions());
-				break;
-		}
-		else switch (mode) {
-			case "patch":
-				sections.push(yamlPatchInstructions());
-				break;
-			case "merge":
-				sections.push(yamlMergeInstructions());
-				break;
-			case "diff":
-				sections.push(yamlDiffInstructions());
-				break;
-		}
-		sections.push("");
-	}
-	return sections.join("\n");
-}
-function createBuilder() {
-	return {
-		string: () => ({ kind: "string" }),
-		number: () => ({ kind: "number" }),
-		boolean: () => ({ kind: "boolean" }),
-		array: (item) => ({
-			kind: "array",
-			inner: item
-		}),
-		object: (shape) => ({
-			kind: "object",
-			inner: shape
-		}),
-		record: (value) => ({
-			kind: "record",
-			inner: value
-		}),
-		any: () => ({ kind: "any" }),
-		zod: () => ({ kind: "zod" }),
-		ref: (path) => ({
-			kind: "ref",
-			inner: path
-		}),
-		propsOf: (path) => ({
-			kind: "propsOf",
-			inner: path
-		}),
-		map: (entryShape) => ({
-			kind: "map",
-			inner: entryShape
-		}),
-		optional: () => ({ optional: true })
-	};
-}
-function defineSchema(builder, options) {
-	return {
-		definition: builder(createBuilder()),
-		promptTemplate: options?.promptTemplate,
-		defaultRules: options?.defaultRules,
-		builtInActions: options?.builtInActions,
-		createCatalog(catalog) {
-			return createCatalogFromSchema(this, catalog);
-		}
-	};
-}
-function createCatalogFromSchema(schema, catalogData) {
-	const components = catalogData.components;
-	const actions = catalogData.actions;
-	const componentNames = components ? Object.keys(components) : [];
-	const actionNames = actions ? Object.keys(actions) : [];
-	const zodSchema = buildZodSchemaFromDefinition(schema.definition, catalogData);
-	return {
-		schema,
-		data: catalogData,
-		componentNames,
-		actionNames,
-		prompt(options = {}) {
-			return generatePrompt(this, options);
-		},
-		jsonSchema(options = {}) {
-			return zodToJsonSchema(zodSchema, options.strict ?? false);
-		},
-		validate(spec) {
-			const result = zodSchema.safeParse(spec);
-			if (result.success) return {
-				success: true,
-				data: result.data
-			};
-			return {
-				success: false,
-				error: result.error
-			};
-		},
-		zodSchema() {
-			return zodSchema;
-		},
-		get _specType() {
-			throw new Error("_specType is only for type inference");
-		}
-	};
-}
-function buildZodSchemaFromDefinition(definition, catalogData) {
-	return buildZodType(definition.spec, catalogData);
-}
-function buildZodType(schemaType, catalogData) {
-	switch (schemaType.kind) {
-		case "string": return z.string();
-		case "number": return z.number();
-		case "boolean": return z.boolean();
-		case "any": return z.any();
-		case "array": {
-			const inner = buildZodType(schemaType.inner, catalogData);
-			return z.array(inner);
-		}
-		case "object": {
-			const shape = schemaType.inner;
-			const zodShape = {};
-			for (const [key, value] of Object.entries(shape)) {
-				let zodType = buildZodType(value, catalogData);
-				if (value.optional) zodType = zodType.optional();
-				zodShape[key] = zodType;
-			}
-			return z.object(zodShape);
-		}
-		case "record": {
-			const inner = buildZodType(schemaType.inner, catalogData);
-			return z.record(z.string(), inner);
-		}
-		case "ref": {
-			const path = schemaType.inner;
-			const keys = getKeysFromPath(path, catalogData);
-			if (keys.length === 0) return z.string();
-			if (keys.length === 1) return z.literal(keys[0]);
-			return z.enum(keys);
-		}
-		case "propsOf": {
-			const path = schemaType.inner;
-			const propsSchemas = getPropsFromPath(path, catalogData);
-			if (propsSchemas.length === 0) return z.record(z.string(), z.unknown());
-			if (propsSchemas.length === 1) return propsSchemas[0];
-			return z.record(z.string(), z.unknown());
-		}
-		default: return z.unknown();
-	}
-}
-function getKeysFromPath(path, catalogData) {
-	const parts = path.split(".");
-	let current = { catalog: catalogData };
-	for (const part of parts) if (current && typeof current === "object") current = current[part];
-	else return [];
-	if (current && typeof current === "object") return Object.keys(current);
-	return [];
-}
-function getPropsFromPath(path, catalogData) {
-	const parts = path.split(".");
-	let current = { catalog: catalogData };
-	for (const part of parts) if (current && typeof current === "object") current = current[part];
-	else return [];
-	if (current && typeof current === "object") return Object.values(current).map((entry) => entry.props).filter((props) => props !== void 0);
-	return [];
-}
-function generatePrompt(catalog, options) {
-	if (catalog.schema.promptTemplate) {
-		const context = {
-			catalog: catalog.data,
-			componentNames: catalog.componentNames,
-			actionNames: catalog.actionNames,
-			options,
-			formatZodType
-		};
-		return catalog.schema.promptTemplate(context);
-	}
-	const { system = "You are a UI generator that outputs JSON.", customRules = [], mode: rawMode = "standalone" } = options;
-	const mode = rawMode === "chat" ? (console.warn("[json-render] mode \"chat\" is deprecated, use \"inline\" instead"), "inline") : rawMode === "generate" ? (console.warn("[json-render] mode \"generate\" is deprecated, use \"standalone\" instead"), "standalone") : rawMode;
-	const lines = [];
-	lines.push(system);
-	lines.push("");
-	if (mode === "inline") {
-		lines.push("OUTPUT FORMAT (text + JSONL, RFC 6902 JSON Patch):");
-		lines.push("You respond conversationally. When generating UI, first write a brief explanation (1-3 sentences), then output JSONL patch lines wrapped in a ```spec code fence.");
-		lines.push("The JSONL lines use RFC 6902 JSON Patch operations to build a UI tree. Always wrap them in a ```spec fence block:");
-		lines.push("  ```spec");
-		lines.push("  {\"op\":\"add\",\"path\":\"/root\",\"value\":\"main\"}");
-		lines.push("  {\"op\":\"add\",\"path\":\"/elements/main\",\"value\":{\"type\":\"Card\",\"props\":{\"title\":\"Hello\"},\"children\":[]}}");
-		lines.push("  ```");
-		lines.push("If the user's message does not require a UI (e.g. a greeting or clarifying question), respond with text only — no JSONL.");
-	} else {
-		lines.push("OUTPUT FORMAT (JSONL, RFC 6902 JSON Patch):");
-		lines.push("Output JSONL (one JSON object per line) using RFC 6902 JSON Patch operations to build a UI tree.");
-	}
-	lines.push("Each line is a JSON patch operation (add, remove, replace). Start with /root, then stream /elements and /state patches interleaved so the UI fills in progressively as it streams.");
-	lines.push("");
-	lines.push("Example output (each line is a separate JSON object):");
-	lines.push("");
-	const allComponents = catalog.data.components;
-	const cn = catalog.componentNames;
-	const comp1 = cn[0] || "Component";
-	const comp2 = cn.length > 1 ? cn[1] : comp1;
-	const comp1Def = allComponents?.[comp1];
-	const comp2Def = allComponents?.[comp2];
-	const comp1Props = comp1Def ? getExampleProps(comp1Def) : {};
-	const comp2Props = comp2Def ? getExampleProps(comp2Def) : {};
-	const dynamicPropName = comp2Def?.props ? findFirstStringProp(comp2Def.props) : null;
-	const dynamicProps = dynamicPropName ? {
-		...comp2Props,
-		[dynamicPropName]: { $item: "title" }
-	} : comp2Props;
-	const exampleOutput = [
-		JSON.stringify({
-			op: "add",
-			path: "/root",
-			value: "main"
-		}),
-		JSON.stringify({
-			op: "add",
-			path: "/elements/main",
-			value: {
-				type: comp1,
-				props: comp1Props,
-				children: ["child-1", "list"]
-			}
-		}),
-		JSON.stringify({
-			op: "add",
-			path: "/elements/child-1",
-			value: {
-				type: comp2,
-				props: comp2Props,
-				children: []
-			}
-		}),
-		JSON.stringify({
-			op: "add",
-			path: "/elements/list",
-			value: {
-				type: comp1,
-				props: comp1Props,
-				repeat: {
-					statePath: "/items",
-					key: "id"
-				},
-				children: ["item"]
-			}
-		}),
-		JSON.stringify({
-			op: "add",
-			path: "/elements/item",
-			value: {
-				type: comp2,
-				props: dynamicProps,
-				children: []
-			}
-		}),
-		JSON.stringify({
-			op: "add",
-			path: "/state/items",
-			value: []
-		}),
-		JSON.stringify({
-			op: "add",
-			path: "/state/items/0",
-			value: {
-				id: "1",
-				title: "First Item"
-			}
-		}),
-		JSON.stringify({
-			op: "add",
-			path: "/state/items/1",
-			value: {
-				id: "2",
-				title: "Second Item"
-			}
-		})
-	].join("\n");
-	lines.push(`${exampleOutput}
-
-Note: state patches appear right after the elements that use them, so the UI fills in as it streams. ONLY use component types from the AVAILABLE COMPONENTS list below.`);
-	lines.push("");
-	lines.push("INITIAL STATE:");
-	lines.push("Specs include a /state field to seed the state model. Components with { $bindState } or { $bindItem } read from and write to this state, and $state expressions read from it.");
-	lines.push("CRITICAL: You MUST include state patches whenever your UI displays data via $state, $bindState, $bindItem, $item, or $index expressions, or uses repeat to iterate over arrays. Without state, these references resolve to nothing and repeat lists render zero items.");
-	lines.push("Output state patches right after the elements that reference them, so the UI fills in progressively as it streams.");
-	lines.push("Stream state progressively - output one patch per array item instead of one giant blob:");
-	lines.push("  For arrays: {\"op\":\"add\",\"path\":\"/state/posts/0\",\"value\":{\"id\":\"1\",\"title\":\"First Post\",...}} then /state/posts/1, /state/posts/2, etc.");
-	lines.push("  For scalars: {\"op\":\"add\",\"path\":\"/state/newTodoText\",\"value\":\"\"}");
-	lines.push("  Initialize the array first if needed: {\"op\":\"add\",\"path\":\"/state/posts\",\"value\":[]}");
-	lines.push("When content comes from the state model, use { \"$state\": \"/some/path\" } dynamic props to display it instead of hardcoding the same value in both state and props. The state model is the single source of truth.");
-	lines.push("Include realistic sample data in state. For blogs: 3-4 posts with titles, excerpts, authors, dates. For product lists: 3-5 items with names, prices, descriptions. Never leave arrays empty.");
-	lines.push("");
-	lines.push("DYNAMIC LISTS (repeat field):");
-	lines.push("Any element can have a top-level \"repeat\" field to render its children once per item in a state array: { \"repeat\": { \"statePath\": \"/arrayPath\", \"key\": \"id\" } }.");
-	lines.push("The element itself renders once (as the container), and its children are expanded once per array item. \"statePath\" is the state array path. \"key\" is an optional field name on each item for stable React keys.");
-	lines.push(`Example: ${JSON.stringify({
-		type: comp1,
-		props: comp1Props,
-		repeat: {
-			statePath: "/todos",
-			key: "id"
-		},
-		children: ["todo-item"]
-	})}`);
-	lines.push("Inside children of a repeated element, use { \"$item\": \"field\" } to read a field from the current item, and { \"$index\": true } to get the current array index. For two-way binding to an item field use { \"$bindItem\": \"completed\" } on the appropriate prop.");
-	lines.push("ALWAYS use the repeat field for lists backed by state arrays. NEVER hardcode individual elements for each array item.");
-	lines.push("IMPORTANT: \"repeat\" is a top-level field on the element (sibling of type/props/children), NOT inside props.");
-	lines.push("");
-	lines.push("ARRAY STATE ACTIONS:");
-	lines.push("Use action \"pushState\" to append items to arrays. Params: { statePath: \"/arrayPath\", value: { ...item }, clearStatePath: \"/inputPath\" }.");
-	lines.push("Values inside pushState can contain { \"$state\": \"/statePath\" } references to read current state (e.g. the text from an input field).");
-	lines.push("Use \"$id\" inside a pushState value to auto-generate a unique ID.");
-	lines.push("Example: on: { \"press\": { \"action\": \"pushState\", \"params\": { \"statePath\": \"/todos\", \"value\": { \"id\": \"$id\", \"title\": { \"$state\": \"/newTodoText\" }, \"completed\": false }, \"clearStatePath\": \"/newTodoText\" } } }");
-	lines.push(`Use action "removeState" to remove items from arrays by index. Params: { statePath: "/arrayPath", index: N }. Inside a repeated element's children, use { "$index": true } for the current item index. Action params support the same expressions as props: { "$item": "field" } resolves to the absolute state path, { "$index": true } resolves to the index number, and { "$state": "/path" } reads a value from state.`);
-	lines.push("For lists where users can add/remove items (todos, carts, etc.), use pushState and removeState instead of hardcoding with setState.");
-	lines.push("");
-	lines.push("IMPORTANT: State paths use RFC 6901 JSON Pointer syntax (e.g. \"/todos/0/title\"). Do NOT use JavaScript-style dot notation (e.g. \"/todos.length\" is WRONG). To generate unique IDs for new items, use \"$id\" instead of trying to read array length.");
-	lines.push("");
-	const components = allComponents;
-	if (components) {
-		lines.push(`AVAILABLE COMPONENTS (${catalog.componentNames.length}):`);
-		lines.push("");
-		for (const [name, def] of Object.entries(components)) {
-			const propsStr = def.props ? formatZodType(def.props) : "{}";
-			const childrenStr = def.slots && def.slots.length > 0 ? " [accepts children]" : "";
-			const eventsStr = def.events && def.events.length > 0 ? ` [events: ${def.events.join(", ")}]` : "";
-			const descStr = def.description ? ` - ${def.description}` : "";
-			lines.push(`- ${name}: ${propsStr}${descStr}${childrenStr}${eventsStr}`);
-		}
-		lines.push("");
-	}
-	const actions = catalog.data.actions;
-	const builtInActions = catalog.schema.builtInActions ?? [];
-	const hasCustomActions = actions && catalog.actionNames.length > 0;
-	const hasBuiltInActions = builtInActions.length > 0;
-	if (hasCustomActions || hasBuiltInActions) {
-		lines.push("AVAILABLE ACTIONS:");
-		lines.push("");
-		for (const action2 of builtInActions) lines.push(`- ${action2.name}: ${action2.description} [built-in]`);
-		if (hasCustomActions) for (const [name, def] of Object.entries(actions)) lines.push(`- ${name}${def.description ? `: ${def.description}` : ""}`);
-		lines.push("");
-	}
-	lines.push("EVENTS (the `on` field):");
-	lines.push("Elements can have an optional `on` field to bind events to actions. The `on` field is a top-level field on the element (sibling of type/props/children), NOT inside props.");
-	lines.push("Each key in `on` is an event name (from the component's supported events), and the value is an action binding: `{ \"action\": \"<actionName>\", \"params\": { ... } }`.");
-	lines.push("");
-	lines.push("Example:");
-	lines.push(`  ${JSON.stringify({
-		type: comp1,
-		props: comp1Props,
-		on: { press: {
-			action: "setState",
-			params: {
-				statePath: "/saved",
-				value: true
-			}
-		} },
-		children: []
-	})}`);
-	lines.push("");
-	lines.push("Action params can use dynamic references to read from state: { \"$state\": \"/statePath\" }.");
-	lines.push("IMPORTANT: Do NOT put action/actionParams inside props. Always use the `on` field for event bindings.");
-	lines.push("");
-	lines.push("VISIBILITY CONDITIONS:");
-	lines.push("Elements can have an optional `visible` field to conditionally show/hide based on state. IMPORTANT: `visible` is a top-level field on the element object (sibling of type/props/children), NOT inside props.");
-	lines.push(`Correct: ${JSON.stringify({
-		type: comp1,
-		props: comp1Props,
-		visible: {
-			$state: "/activeTab",
-			eq: "home"
-		},
-		children: ["..."]
-	})}`);
-	lines.push("- `{ \"$state\": \"/path\" }` - visible when state at path is truthy");
-	lines.push("- `{ \"$state\": \"/path\", \"not\": true }` - visible when state at path is falsy");
-	lines.push("- `{ \"$state\": \"/path\", \"eq\": \"value\" }` - visible when state equals value");
-	lines.push("- `{ \"$state\": \"/path\", \"neq\": \"value\" }` - visible when state does not equal value");
-	lines.push("- `{ \"$state\": \"/path\", \"gt\": N }` / `gte` / `lt` / `lte` - numeric comparisons");
-	lines.push("- Use ONE operator per condition (eq, neq, gt, gte, lt, lte). Do not combine multiple operators.");
-	lines.push("- Any condition can add `\"not\": true` to invert its result");
-	lines.push("- `[condition, condition]` - all conditions must be true (implicit AND)");
-	lines.push("- `{ \"$and\": [condition, condition] }` - explicit AND (use when nesting inside $or)");
-	lines.push("- `{ \"$or\": [condition, condition] }` - at least one must be true (OR)");
-	lines.push("- `true` / `false` - always visible/hidden");
-	lines.push("");
-	lines.push("Use a component with on.press bound to setState to update state and drive visibility.");
-	lines.push(`Example: A ${comp1} with on: { "press": { "action": "setState", "params": { "statePath": "/activeTab", "value": "home" } } } sets state, then a container with visible: { "$state": "/activeTab", "eq": "home" } shows only when that tab is active.`);
-	lines.push("");
-	lines.push("For tab patterns where the first/default tab should be visible when no tab is selected yet, use $or to handle both cases: visible: { \"$or\": [{ \"$state\": \"/activeTab\", \"eq\": \"home\" }, { \"$state\": \"/activeTab\", \"not\": true }] }. This ensures the first tab is visible both when explicitly selected AND when /activeTab is not yet set.");
-	lines.push("");
-	lines.push("DYNAMIC PROPS:");
-	lines.push("Any prop value can be a dynamic expression that resolves based on state. Three forms are supported:");
-	lines.push("");
-	lines.push("1. Read-only state: `{ \"$state\": \"/statePath\" }` - resolves to the value at that state path (one-way read).");
-	lines.push("   Example: `\"color\": { \"$state\": \"/theme/primary\" }` reads the color from state.");
-	lines.push("");
-	lines.push("2. Two-way binding: `{ \"$bindState\": \"/statePath\" }` - resolves to the value at the state path AND enables write-back. Use on form input props (value, checked, pressed, etc.).");
-	lines.push("   Example: `\"value\": { \"$bindState\": \"/form/email\" }` binds the input value to /form/email.");
-	lines.push("   Inside repeat scopes: `\"checked\": { \"$bindItem\": \"completed\" }` binds to the current item's completed field.");
-	lines.push("");
-	lines.push("3. Conditional: `{ \"$cond\": <condition>, \"$then\": <value>, \"$else\": <value> }` - evaluates the condition (same syntax as visibility conditions) and picks the matching value.");
-	lines.push("   Example: `\"color\": { \"$cond\": { \"$state\": \"/activeTab\", \"eq\": \"home\" }, \"$then\": \"#007AFF\", \"$else\": \"#8E8E93\" }`");
-	lines.push("");
-	lines.push("Use $bindState for form inputs (text fields, checkboxes, selects, sliders, etc.) and $state for read-only data display. Inside repeat scopes, use $bindItem for form inputs bound to the current item. Use dynamic props instead of duplicating elements with opposing visible conditions when only prop values differ.");
-	lines.push("");
-	lines.push("4. Template: `{ \"$template\": \"Hello, ${/name}!\" }` - interpolates references in the string. Absolute paths like `${/path}` resolve against the state model. Bare names like `${field}` resolve against the current repeat item first, then fall back to the state model at `/<field>`.");
-	lines.push("   Example: `\"label\": { \"$template\": \"Items: ${/cart/count} | Total: ${/cart/total}\" }` renders \"Items: 3 | Total: 42.00\" when /cart/count is 3 and /cart/total is 42.00. Inside a repeat, `{ \"$template\": \"${name} - ${email}\" }` reads name and email from each item.");
-	lines.push("");
-	const catalogFunctions = catalog.data.functions;
-	if (catalogFunctions && Object.keys(catalogFunctions).length > 0) {
-		lines.push("5. Computed: `{ \"$computed\": \"<functionName>\", \"args\": { \"key\": <expression> } }` - calls a registered function with resolved args and returns the result.");
-		lines.push("   Example: `\"value\": { \"$computed\": \"fullName\", \"args\": { \"first\": { \"$state\": \"/form/firstName\" }, \"last\": { \"$state\": \"/form/lastName\" } } }`");
-		lines.push("   Available functions:");
-		for (const name of Object.keys(catalogFunctions)) lines.push(`   - ${name}`);
-		lines.push("");
-	}
-	const directives = options.directives;
-	if (directives && directives.length > 0) {
-		lines.push("CUSTOM DYNAMIC VALUES:");
-		lines.push("");
-		for (const d of directives) {
-			const desc = d.description ? ` (${d.description})` : "";
-			lines.push(`- ${d.name}${desc}: ${formatZodType(d.schema)}`);
-		}
-		lines.push("");
-		lines.push("Directives compose: any value field can contain another directive or a $state expression, resolved inside-out.");
-		lines.push("");
-	}
-	if (allComponents ? Object.entries(allComponents).some(([, def]) => {
-		if (!def.props) return false;
-		return formatZodType(def.props).includes("checks");
-	}) : false) {
-		lines.push("VALIDATION:");
-		lines.push("Form components that accept a `checks` prop support client-side validation.");
-		lines.push("Each check is an object: { \"type\": \"<name>\", \"message\": \"...\", \"args\": { ... } }");
-		lines.push("");
-		lines.push("Built-in validation types:");
-		lines.push("  - required — value must be non-empty");
-		lines.push("  - email — valid email format");
-		lines.push("  - minLength — minimum string length (args: { \"min\": N })");
-		lines.push("  - maxLength — maximum string length (args: { \"max\": N })");
-		lines.push("  - pattern — match a regex (args: { \"pattern\": \"regex\" })");
-		lines.push("  - min — minimum numeric value (args: { \"min\": N })");
-		lines.push("  - max — maximum numeric value (args: { \"max\": N })");
-		lines.push("  - numeric — value must be a number");
-		lines.push("  - url — valid URL format");
-		lines.push("  - matches — must equal another field (args: { \"other\": { \"$state\": \"/path\" } })");
-		lines.push("  - equalTo — alias for matches (args: { \"other\": { \"$state\": \"/path\" } })");
-		lines.push("  - lessThan — value must be less than another field (args: { \"other\": { \"$state\": \"/path\" } })");
-		lines.push("  - greaterThan — value must be greater than another field (args: { \"other\": { \"$state\": \"/path\" } })");
-		lines.push("  - requiredIf — required only when another field is truthy (args: { \"field\": { \"$state\": \"/path\" } })");
-		lines.push("");
-		lines.push("Example:");
-		lines.push("  \"checks\": [{ \"type\": \"required\", \"message\": \"Email is required\" }, { \"type\": \"email\", \"message\": \"Invalid email\" }]");
-		lines.push("");
-		lines.push("IMPORTANT: When using checks, the component must also have a { $bindState } or { $bindItem } on its value/checked prop for two-way binding.");
-		lines.push("Always include validation checks on form inputs for a good user experience (e.g. required, email, minLength).");
-		lines.push("");
-	}
-	if (hasCustomActions || hasBuiltInActions) {
-		lines.push("STATE WATCHERS:");
-		lines.push("Elements can have an optional `watch` field to react to state changes and trigger actions. The `watch` field is a top-level field on the element (sibling of type/props/children), NOT inside props.");
-		lines.push("Maps state paths (JSON Pointers) to action bindings. When the value at a watched path changes, the bound actions fire automatically.");
-		lines.push("");
-		lines.push("Example (cascading select — country changes trigger city loading):");
-		lines.push(`  ${JSON.stringify({
-			type: "Select",
-			props: {
-				value: { $bindState: "/form/country" },
-				options: [
-					"US",
-					"Canada",
-					"UK"
-				]
-			},
-			watch: { "/form/country": {
-				action: "loadCities",
-				params: { country: { $state: "/form/country" } }
-			} },
-			children: []
-		})}`);
-		lines.push("");
-		lines.push("Use `watch` for cascading dependencies where changing one field should trigger side effects (loading data, resetting dependent fields, computing derived values).");
-		lines.push("IMPORTANT: `watch` is a top-level field on the element (sibling of type/props/children), NOT inside props. Watchers only fire when the value changes, not on initial render.");
-		lines.push("");
-	}
-	const editModes = options.editModes;
-	if (editModes && editModes.length > 0) lines.push(buildEditInstructions({ modes: editModes }, "json"));
-	lines.push("RULES:");
-	const baseRules = mode === "inline" ? [
-		"When generating UI, wrap all JSONL patches in a ```spec code fence - one JSON object per line inside the fence",
-		"Write a brief conversational response before any JSONL output",
-		"First set root: {\"op\":\"add\",\"path\":\"/root\",\"value\":\"<root-key>\"}",
-		"Then add each element: {\"op\":\"add\",\"path\":\"/elements/<key>\",\"value\":{...}}",
-		"Output /state patches right after the elements that use them, one per array item for progressive loading. REQUIRED whenever using $state, $bindState, $bindItem, $item, $index, or repeat.",
-		"ONLY use components listed above",
-		"Each element value needs: type, props, children (array of child keys)",
-		"Use unique keys for the element map entries (e.g., 'header', 'metric-1', 'chart-revenue')"
-	] : [
-		"Output ONLY JSONL patches - one JSON object per line, no markdown, no code fences",
-		"First set root: {\"op\":\"add\",\"path\":\"/root\",\"value\":\"<root-key>\"}",
-		"Then add each element: {\"op\":\"add\",\"path\":\"/elements/<key>\",\"value\":{...}}",
-		"Output /state patches right after the elements that use them, one per array item for progressive loading. REQUIRED whenever using $state, $bindState, $bindItem, $item, $index, or repeat.",
-		"ONLY use components listed above",
-		"Each element value needs: type, props, children (array of child keys)",
-		"Use unique keys for the element map entries (e.g., 'header', 'metric-1', 'chart-revenue')"
-	];
-	const schemaRules = catalog.schema.defaultRules ?? [];
-	[
-		...baseRules,
-		...schemaRules,
-		...customRules
-	].forEach((rule, i) => {
-		lines.push(`${i + 1}. ${rule}`);
-	});
-	return lines.join("\n");
-}
-function getExampleProps(def) {
-	if (def.example && Object.keys(def.example).length > 0) return def.example;
-	if (def.props) return generateExamplePropsFromZod(def.props);
-	return {};
-}
-function generateExamplePropsFromZod(schema) {
-	if (!schema || !schema._def) return {};
-	const def = schema._def;
-	const typeName = getZodTypeName(schema);
-	if (typeName !== "ZodObject" && typeName !== "object") return {};
-	const shape = typeof def.shape === "function" ? def.shape() : def.shape;
-	if (!shape) return {};
-	const result = {};
-	for (const [key, value] of Object.entries(shape)) {
-		const innerTypeName = getZodTypeName(value);
-		if (innerTypeName === "ZodOptional" || innerTypeName === "optional" || innerTypeName === "ZodNullable" || innerTypeName === "nullable") continue;
-		result[key] = generateExampleValue(value);
-	}
-	return result;
-}
-function generateExampleValue(schema) {
-	if (!schema || !schema._def) return "...";
-	const def = schema._def;
-	switch (getZodTypeName(schema)) {
-		case "ZodString":
-		case "string": return "example";
-		case "ZodNumber":
-		case "number": return 0;
-		case "ZodBoolean":
-		case "boolean": return true;
-		case "ZodLiteral":
-		case "literal": return def.value;
-		case "ZodEnum":
-		case "enum":
-			if (Array.isArray(def.values) && def.values.length > 0) return def.values[0];
-			if (def.entries && typeof def.entries === "object") {
-				const values = Object.values(def.entries);
-				return values.length > 0 ? values[0] : "example";
-			}
-			return "example";
-		case "ZodOptional":
-		case "optional":
-		case "ZodNullable":
-		case "nullable":
-		case "ZodDefault":
-		case "default": {
-			const inner = def.innerType ?? def.wrapped;
-			return inner ? generateExampleValue(inner) : null;
-		}
-		case "ZodArray":
-		case "array": return [];
-		case "ZodObject":
-		case "object": return generateExamplePropsFromZod(schema);
-		case "ZodUnion":
-		case "union": {
-			const options = def.options;
-			return options && options.length > 0 ? generateExampleValue(options[0]) : "...";
-		}
-		default: return "...";
-	}
-}
-function findFirstStringProp(schema) {
-	if (!schema || !schema._def) return null;
-	const def = schema._def;
-	const typeName = getZodTypeName(schema);
-	if (typeName !== "ZodObject" && typeName !== "object") return null;
-	const shape = typeof def.shape === "function" ? def.shape() : def.shape;
-	if (!shape) return null;
-	for (const [key, value] of Object.entries(shape)) {
-		const innerTypeName = getZodTypeName(value);
-		if (innerTypeName === "ZodOptional" || innerTypeName === "optional" || innerTypeName === "ZodNullable" || innerTypeName === "nullable") continue;
-		if (innerTypeName === "ZodString" || innerTypeName === "string") return key;
-	}
-	return null;
-}
-function getZodTypeName(schema) {
-	if (!schema || !schema._def) return "";
-	const def = schema._def;
-	return def.typeName ?? def.type ?? "";
-}
-function formatZodType(schema) {
-	if (!schema || !schema._def) return "unknown";
-	const def = schema._def;
-	switch (getZodTypeName(schema)) {
-		case "ZodString":
-		case "string": return "string";
-		case "ZodNumber":
-		case "number": return "number";
-		case "ZodBoolean":
-		case "boolean": return "boolean";
-		case "ZodLiteral":
-		case "literal": {
-			const litValue = def.values?.[0] ?? def.value;
-			return JSON.stringify(litValue);
-		}
-		case "ZodEnum":
-		case "enum": {
-			let values;
-			if (Array.isArray(def.values)) values = def.values;
-			else if (def.entries && typeof def.entries === "object") values = Object.values(def.entries);
-			else return "enum";
-			return values.map((v) => `"${v}"`).join(" | ");
-		}
-		case "ZodArray":
-		case "array": {
-			const inner = typeof def.element === "object" ? def.element : typeof def.type === "object" ? def.type : void 0;
-			return inner ? `Array<${formatZodType(inner)}>` : "Array<unknown>";
-		}
-		case "ZodObject":
-		case "object": {
-			const shape = typeof def.shape === "function" ? def.shape() : def.shape;
-			if (!shape) return "object";
-			return `{ ${Object.entries(shape).map(([key, value]) => {
-				const innerTypeName = getZodTypeName(value);
-				return `${key}${innerTypeName === "ZodOptional" || innerTypeName === "ZodNullable" || innerTypeName === "optional" || innerTypeName === "nullable" ? "?" : ""}: ${formatZodType(value)}`;
-			}).join(", ")} }`;
-		}
-		case "ZodOptional":
-		case "optional":
-		case "ZodNullable":
-		case "nullable": {
-			const inner = def.innerType ?? def.wrapped;
-			return inner ? formatZodType(inner) : "unknown";
-		}
-		case "ZodUnion":
-		case "union": {
-			const options = def.options;
-			return options ? options.map((opt) => formatZodType(opt)).join(" | ") : "unknown";
-		}
-		case "ZodRecord":
-		case "record": {
-			const keyType = def.keyType ?? void 0;
-			const valueType = def.valueType ?? def.element ?? void 0;
-			return `Record<${keyType ? formatZodType(keyType) : "string"}, ${valueType ? formatZodType(valueType) : "unknown"}>`;
-		}
-		case "ZodDefault":
-		case "default": {
-			const inner = def.innerType ?? def.wrapped;
-			return inner ? formatZodType(inner) : "unknown";
-		}
-		default: return "unknown";
-	}
-}
-function zodTypeName(def) {
-	if (typeof def.type === "string") return def.type;
-	if (typeof def.typeName === "string") return def.typeName;
-	return "";
-}
-function normalizeTypeName(raw) {
-	if (raw.startsWith("Zod")) return raw.slice(3).toLowerCase();
-	return raw.toLowerCase();
-}
-function zodToJsonSchema(schema, strict = false) {
-	const def = schema._def;
-	switch (normalizeTypeName(zodTypeName(def))) {
-		case "string": return { type: "string" };
-		case "number": return { type: "number" };
-		case "boolean": return { type: "boolean" };
-		case "literal": {
-			const values = def.values;
-			return { const: values ? values[0] : def.value };
-		}
-		case "enum": {
-			const entries = def.entries;
-			return { enum: (entries ? Object.values(entries) : def.values) ?? [] };
-		}
-		case "array": {
-			const inner = def.element ?? def.type;
-			return {
-				type: "array",
-				items: inner ? zodToJsonSchema(inner, strict) : {}
-			};
-		}
-		case "object": {
-			const rawShape = def.shape;
-			const shape = typeof rawShape === "function" ? rawShape() : rawShape;
-			if (!shape) {
-				if (strict) return {
-					type: "object",
-					properties: {},
-					required: [],
-					additionalProperties: false
-				};
-				return { type: "object" };
-			}
-			const properties = {};
-			const required = [];
-			for (const [key, value] of Object.entries(shape)) {
-				const innerDef = value._def;
-				const innerKind = normalizeTypeName(zodTypeName(innerDef));
-				const isOptional = innerKind === "optional" || innerKind === "nullable";
-				if (strict) {
-					required.push(key);
-					if (isOptional) properties[key] = { anyOf: [zodToJsonSchema(value, strict), { type: "null" }] };
-					else properties[key] = zodToJsonSchema(value, strict);
-				} else {
-					properties[key] = zodToJsonSchema(value);
-					if (!isOptional) required.push(key);
-				}
-			}
-			return {
-				type: "object",
-				properties,
-				required: required.length > 0 ? required : void 0,
-				additionalProperties: false
-			};
-		}
-		case "record": {
-			const valueType = def.valueType;
-			if (strict) return {
-				type: "object",
-				properties: {},
-				required: [],
-				additionalProperties: false
-			};
-			return {
-				type: "object",
-				additionalProperties: valueType ? zodToJsonSchema(valueType) : true
-			};
-		}
-		case "optional":
-		case "nullable": {
-			const inner = def.innerType;
-			return inner ? zodToJsonSchema(inner, strict) : {};
-		}
-		case "union": {
-			const options = def.options;
-			return options ? { anyOf: options.map((o) => zodToJsonSchema(o, strict)) } : {};
-		}
-		case "any":
-		case "unknown":
-			if (strict) return {
-				type: "object",
-				properties: {},
-				required: [],
-				additionalProperties: false
-			};
-			return {};
-		default: return {};
-	}
-}
-function defineCatalog(schema, catalog) {
-	return schema.createCatalog(catalog);
-}
-
-//#endregion
-//#region ../../node_modules/.pnpm/@json-render+react@0.19.0_react@19.2.8_zod@4.4.3/node_modules/@json-render/react/dist/chunk-WYDS23XB.mjs
-var schema = defineSchema((s) => ({
-	spec: s.object({
-		/** Root element key */
-		root: s.string(),
-		/** Flat map of elements by key */
-		elements: s.record(s.object({
-			/** Component type from catalog */
-			type: s.ref("catalog.components"),
-			/** Component props */
-			props: s.propsOf("catalog.components"),
-			/** Child element keys (flat reference) */
-			children: s.array(s.string()),
-			/** Visibility condition */
-			visible: s.any()
-		}))
-	}),
-	catalog: s.object({
-		/** Component definitions */
-		components: s.map({
-			/** Zod schema for component props */
-			props: s.zod(),
-			/** Slots for this component. Use ['default'] for children, or named slots like ['header', 'footer'] */
-			slots: s.array(s.string()),
-			/** Description for AI generation hints */
-			description: s.string(),
-			/** Example prop values used in prompt examples (auto-generated from Zod schema if omitted) */
-			example: s.any()
-		}),
-		/** Action definitions (optional) */
-		actions: s.map({
-			/** Zod schema for action params */
-			params: s.zod(),
-			/** Description for AI generation hints */
-			description: s.string()
-		})
-	})
-}), {
-	builtInActions: [
-		{
-			name: "setState",
-			description: "Update a value in the state model at the given statePath. Params: { statePath: string, value: any }"
-		},
-		{
-			name: "pushState",
-			description: "Append an item to an array in state. Params: { statePath: string, value: any, clearStatePath?: string }. Value can contain {\"$state\":\"/path\"} refs and \"$id\" for auto IDs."
-		},
-		{
-			name: "removeState",
-			description: "Remove an item from an array in state by index. Params: { statePath: string, index: number }"
-		},
-		{
-			name: "validateForm",
-			description: "Validate all registered form fields and write the result to state. Params: { statePath?: string }. Defaults to /formValidation. Result: { valid: boolean, errors: Record<string, string[]> }."
-		}
-	],
-	defaultRules: [
-		"CRITICAL INTEGRITY CHECK: Before outputting ANY element that references children, you MUST have already output (or will output) each child as its own element. If an element has children: ['a', 'b'], then elements 'a' and 'b' MUST exist. A missing child element causes that entire branch of the UI to be invisible.",
-		"SELF-CHECK: After generating all elements, mentally walk the tree from root. Every key in every children array must resolve to a defined element. If you find a gap, output the missing element immediately.",
-		"CRITICAL: The \"visible\" field goes on the ELEMENT object, NOT inside \"props\". Correct: {\"type\":\"<ComponentName>\",\"props\":{},\"visible\":{\"$state\":\"/tab\",\"eq\":\"home\"},\"children\":[...]}.",
-		"CRITICAL: The \"on\" field goes on the ELEMENT object, NOT inside \"props\". Use on.press, on.change, on.submit etc. NEVER put action/actionParams inside props.",
-		"When the user asks for a UI that displays data (e.g. blog posts, products, users), ALWAYS include a state field with realistic sample data. The state field is a top-level field on the spec (sibling of root/elements).",
-		"When building repeating content backed by a state array (e.g. posts, products, items), use the \"repeat\" field on a container element. Example: { \"type\": \"<ContainerComponent>\", \"props\": {}, \"repeat\": { \"statePath\": \"/posts\", \"key\": \"id\" }, \"children\": [\"post-card\"] }. Replace <ContainerComponent> with an appropriate component from the AVAILABLE COMPONENTS list. Inside repeated children, use { \"$item\": \"field\" } to read a field from the current item, and { \"$index\": true } for the current array index. For two-way binding to an item field use { \"$bindItem\": \"completed\" }. Do NOT hardcode individual elements for each array item.",
-		"Design with visual hierarchy: use container components to group content, heading components for section titles, proper spacing, and status indicators. ONLY use components from the AVAILABLE COMPONENTS list.",
-		"For data-rich UIs, use multi-column layout components if available. For forms and single-column content, use vertical layout components. ONLY use components from the AVAILABLE COMPONENTS list.",
-		"Always include realistic, professional-looking sample data. For blogs include 3-4 posts with varied titles, authors, dates, categories. For products include names, prices, images. Never leave data empty."
-	]
-});
-
-//#endregion
-//#region ../../node_modules/.pnpm/@json-render+react@0.19.0_react@19.2.8_zod@4.4.3/node_modules/@json-render/react/dist/index.mjs
-var StateContext = createContext(null);
-function computeInitialFlat(isControlled, initialState) {
-	if (isControlled) return null;
-	if (Object.keys(initialState).length === 0) return {};
-	return flattenToPointers(initialState);
-}
-function StateProvider({ store: externalStore, initialState = {}, onStateChange, children }) {
-	const internalStoreRef = useRef(void 0);
-	if (!externalStore && !internalStoreRef.current) internalStoreRef.current = createStateStore(initialState);
-	const store = externalStore ?? internalStoreRef.current;
-	const storeRef = useRef(store);
-	storeRef.current = store;
-	const isControlledRef = useRef(!!externalStore);
-	isControlledRef.current = !!externalStore;
-	const initialModeRef = useRef(externalStore ? "controlled" : "uncontrolled");
-	const modeWarnedRef = useRef(false);
-	if (process.env.NODE_ENV !== "production") {
-		const currentMode = externalStore ? "controlled" : "uncontrolled";
-		if (currentMode !== initialModeRef.current && !modeWarnedRef.current) {
-			modeWarnedRef.current = true;
-			console.warn(`StateProvider: switching from ${initialModeRef.current} to ${currentMode} mode is not supported.`);
-		}
-	}
-	const prevInitialStateRef = useRef(initialState);
-	const prevFlatRef = useRef(computeInitialFlat(!!externalStore, initialState));
-	useEffect(() => {
-		if (externalStore) return;
-		if (initialState === prevInitialStateRef.current) return;
-		prevInitialStateRef.current = initialState;
-		const nextFlat = initialState && Object.keys(initialState).length > 0 ? flattenToPointers(initialState) : {};
-		const prevFlat = prevFlatRef.current ?? {};
-		const allKeys = /* @__PURE__ */ new Set([...Object.keys(prevFlat), ...Object.keys(nextFlat)]);
-		const updates = {};
-		for (const key of allKeys) if (prevFlat[key] !== nextFlat[key]) updates[key] = key in nextFlat ? nextFlat[key] : void 0;
-		prevFlatRef.current = nextFlat;
-		if (Object.keys(updates).length > 0) store.update(updates);
-	}, [
-		externalStore,
-		initialState,
-		store
-	]);
-	const state = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot ?? store.getSnapshot);
-	const onStateChangeRef = useRef(onStateChange);
-	onStateChangeRef.current = onStateChange;
-	const set = useCallback((path, value2) => {
-		const s = storeRef.current;
-		const prev = s.getSnapshot();
-		s.set(path, value2);
-		if (!isControlledRef.current && s.getSnapshot() !== prev) onStateChangeRef.current?.([{
-			path,
-			value: value2
-		}]);
-	}, []);
-	const update = useCallback((updates) => {
-		const s = storeRef.current;
-		const prev = s.getSnapshot();
-		s.update(updates);
-		if (!isControlledRef.current && s.getSnapshot() !== prev) {
-			const changes = [];
-			for (const [path, value2] of Object.entries(updates)) if (getByPath(prev, path) !== value2) changes.push({
-				path,
-				value: value2
-			});
-			if (changes.length > 0) onStateChangeRef.current?.(changes);
-		}
-	}, []);
-	const get = useCallback((path) => storeRef.current.get(path), []);
-	const getSnapshot = useCallback(() => storeRef.current.getSnapshot(), []);
-	const value = useMemo(() => ({
-		state,
-		get,
-		set,
-		update,
-		getSnapshot
-	}), [
-		state,
-		get,
-		set,
-		update,
-		getSnapshot
-	]);
-	return /* @__PURE__ */ jsx(StateContext.Provider, {
-		value,
-		children
-	});
-}
-function useStateStore() {
-	const ctx = useContext(StateContext);
-	if (!ctx) throw new Error("useStateStore must be used within a StateProvider");
-	return ctx;
-}
-var VisibilityContext = createContext(null);
-function VisibilityProvider({ children }) {
-	const { state } = useStateStore();
-	const ctx = useMemo(() => ({ stateModel: state }), [state]);
-	const isVisible = useMemo(() => (condition) => evaluateVisibility(condition, ctx), [ctx]);
-	const value = useMemo(() => ({
-		isVisible,
-		ctx
-	}), [isVisible, ctx]);
-	return /* @__PURE__ */ jsx(VisibilityContext.Provider, {
-		value,
-		children
-	});
-}
-function useVisibility() {
-	const ctx = useContext(VisibilityContext);
-	if (!ctx) throw new Error("useVisibility must be used within a VisibilityProvider");
-	return ctx;
-}
-var ValidationContext = createContext(null);
-function dynamicArgsEqual(a, b) {
-	if (a === b) return true;
-	if (!a || !b) return false;
-	const keysA = Object.keys(a);
-	const keysB = Object.keys(b);
-	if (keysA.length !== keysB.length) return false;
-	for (const key of keysA) {
-		const va = a[key];
-		const vb = b[key];
-		if (va === vb) continue;
-		if (typeof va === "object" && va !== null && typeof vb === "object" && vb !== null) {
-			const sa = va.$state;
-			const sb = vb.$state;
-			if (typeof sa === "string" && sa === sb) continue;
-		}
-		return false;
-	}
-	return true;
-}
-function validationConfigEqual(a, b) {
-	if (a === b) return true;
-	if (a.validateOn !== b.validateOn) return false;
-	const ac = a.checks ?? [];
-	const bc = b.checks ?? [];
-	if (ac.length !== bc.length) return false;
-	for (let i = 0; i < ac.length; i++) {
-		const ca = ac[i];
-		const cb = bc[i];
-		if (ca.type !== cb.type) return false;
-		if (ca.message !== cb.message) return false;
-		if (!dynamicArgsEqual(ca.args, cb.args)) return false;
-	}
-	return true;
-}
-function ValidationProvider({ customFunctions = {}, children }) {
-	const { state, getSnapshot } = useStateStore();
-	const [fieldStates, setFieldStates] = useState({});
-	const fieldStatesRef = useRef({});
-	const [fieldConfigs, setFieldConfigs] = useState({});
-	const registerField = useCallback((path, config) => {
-		setFieldConfigs((prev) => {
-			const existing = prev[path];
-			if (existing && validationConfigEqual(existing, config)) return prev;
-			return {
-				...prev,
-				[path]: config
-			};
-		});
-	}, []);
-	const validate = useCallback((path, config) => {
-		const currentState = getSnapshot();
-		const segments = path.split("/").filter(Boolean);
-		let value2 = currentState;
-		for (const seg of segments) if (value2 != null && typeof value2 === "object") value2 = value2[seg];
-		else {
-			value2 = void 0;
-			break;
-		}
-		const result = runValidation(config, {
-			value: value2,
-			stateModel: currentState,
-			customFunctions
-		});
-		const newFieldState = {
-			touched: fieldStatesRef.current[path]?.touched ?? true,
-			validated: true,
-			result
-		};
-		fieldStatesRef.current = {
-			...fieldStatesRef.current,
-			[path]: newFieldState
-		};
-		setFieldStates(fieldStatesRef.current);
-		return result;
-	}, [customFunctions, getSnapshot]);
-	const touch = useCallback((path) => {
-		fieldStatesRef.current = {
-			...fieldStatesRef.current,
-			[path]: {
-				...fieldStatesRef.current[path],
-				touched: true,
-				validated: fieldStatesRef.current[path]?.validated ?? false,
-				result: fieldStatesRef.current[path]?.result ?? null
-			}
-		};
-		setFieldStates(fieldStatesRef.current);
-	}, []);
-	const clear = useCallback((path) => {
-		const { [path]: _, ...rest } = fieldStatesRef.current;
-		fieldStatesRef.current = rest;
-		setFieldStates(rest);
-	}, []);
-	const validateAll = useCallback(() => {
-		let allValid = true;
-		for (const [path, config] of Object.entries(fieldConfigs)) if (!validate(path, config).valid) allValid = false;
-		return allValid;
-	}, [fieldConfigs, validate]);
-	const value = useMemo(() => ({
-		customFunctions,
-		get fieldStates() {
-			return fieldStatesRef.current;
-		},
-		validate,
-		touch,
-		clear,
-		validateAll,
-		registerField
-	}), [
-		customFunctions,
-		fieldStates,
-		validate,
-		touch,
-		clear,
-		validateAll,
-		registerField
-	]);
-	return /* @__PURE__ */ jsx(ValidationContext.Provider, {
-		value,
-		children
-	});
-}
-function useOptionalValidation() {
-	return useContext(ValidationContext);
-}
-var idCounter = 0;
-function generateUniqueId() {
-	idCounter += 1;
-	return `${Date.now()}-${idCounter}`;
-}
-function deepResolveValue(value, get) {
-	if (value === null || value === void 0) return value;
-	if (value === "$id") return generateUniqueId();
-	if (typeof value === "object" && !Array.isArray(value)) {
-		const obj = value;
-		const keys = Object.keys(obj);
-		if (keys.length === 1 && typeof obj.$state === "string") return get(obj.$state);
-		if (keys.length === 1 && "$id" in obj) return generateUniqueId();
-	}
-	if (Array.isArray(value)) return value.map((item) => deepResolveValue(item, get));
-	if (typeof value === "object") {
-		const resolved = {};
-		for (const [key, val] of Object.entries(value)) resolved[key] = deepResolveValue(val, get);
-		return resolved;
-	}
-	return value;
-}
-var ActionContext = createContext(null);
-function ActionProvider({ handlers: initialHandlers = {}, navigate, children }) {
-	const { get, set, getSnapshot } = useStateStore();
-	const validation = useOptionalValidation();
-	const [handlers, setHandlers] = useState(initialHandlers);
-	const [loadingActions, setLoadingActions] = useState(/* @__PURE__ */ new Set());
-	const [pendingConfirmation, setPendingConfirmation] = useState(null);
-	const registerHandler = useCallback((name, handler) => {
-		setHandlers((prev) => ({
-			...prev,
-			[name]: handler
-		}));
-	}, []);
-	const execute = useCallback(async (binding) => {
-		const resolved = resolveAction(binding, getSnapshot());
-		const dispatchId = nextActionDispatchId();
-		const dispatchedAt = Date.now();
-		notifyActionDispatch({
-			id: dispatchId,
-			name: resolved.action,
-			params: resolved.params,
-			at: dispatchedAt
-		});
-		let __ok = true;
-		let __error = void 0;
-		try {
-			if (resolved.action === "setState" && resolved.params) {
-				const statePath = resolved.params.statePath;
-				const value2 = resolved.params.value;
-				if (statePath) set(statePath, value2);
-				return;
-			}
-			if (resolved.action === "pushState" && resolved.params) {
-				const statePath = resolved.params.statePath;
-				const rawValue = resolved.params.value;
-				if (statePath) {
-					const resolvedValue = deepResolveValue(rawValue, get);
-					const arr = get(statePath) ?? [];
-					set(statePath, [...arr, resolvedValue]);
-					const clearStatePath = resolved.params.clearStatePath;
-					if (clearStatePath) set(clearStatePath, "");
-				}
-				return;
-			}
-			if (resolved.action === "removeState" && resolved.params) {
-				const statePath = resolved.params.statePath;
-				const index = resolved.params.index;
-				if (statePath !== void 0 && index !== void 0) {
-					const arr = get(statePath) ?? [];
-					set(statePath, arr.filter((_, i) => i !== index));
-				}
-				return;
-			}
-			if (resolved.action === "push" && resolved.params) {
-				const screen = resolved.params.screen;
-				if (screen) {
-					const currentScreen = get("/currentScreen");
-					const navStack = get("/navStack") ?? [];
-					if (currentScreen) set("/navStack", [...navStack, currentScreen]);
-					else set("/navStack", [...navStack, ""]);
-					set("/currentScreen", screen);
-				}
-				return;
-			}
-			if (resolved.action === "pop") {
-				const navStack = get("/navStack") ?? [];
-				if (navStack.length > 0) {
-					const previousScreen = navStack[navStack.length - 1];
-					set("/navStack", navStack.slice(0, -1));
-					if (previousScreen) set("/currentScreen", previousScreen);
-					else set("/currentScreen", void 0);
-				}
-				return;
-			}
-			if (resolved.action === "validateForm") {
-				const validateAll = validation?.validateAll;
-				if (!validateAll) {
-					console.warn("validateForm action was dispatched but no ValidationProvider is connected. Ensure ValidationProvider is rendered inside the provider tree.");
-					return;
-				}
-				const valid = validateAll();
-				const errors = {};
-				for (const [path, fs] of Object.entries(validation.fieldStates)) if (fs.result && !fs.result.valid) errors[path] = fs.result.errors;
-				const statePath = resolved.params?.statePath || "/formValidation";
-				set(statePath, {
-					valid,
-					errors
-				});
-				return;
-			}
-			const handler = handlers[resolved.action];
-			if (!handler) {
-				console.warn(`No handler registered for action: ${resolved.action}`);
-				return;
-			}
-			if (resolved.confirm) return new Promise((resolve, reject) => {
-				setPendingConfirmation({
-					action: resolved,
-					handler,
-					resolve: () => {
-						setPendingConfirmation(null);
-						resolve();
-					},
-					reject: () => {
-						setPendingConfirmation(null);
-						reject(/* @__PURE__ */ new Error("Action cancelled"));
-					}
-				});
-			}).then(async () => {
-				setLoadingActions((prev) => new Set(prev).add(resolved.action));
-				try {
-					await executeAction({
-						action: resolved,
-						handler,
-						setState: set,
-						navigate,
-						executeAction: async (name) => {
-							await execute({ action: name });
-						}
-					});
-				} finally {
-					setLoadingActions((prev) => {
-						const next = new Set(prev);
-						next.delete(resolved.action);
-						return next;
-					});
-				}
-			});
-			setLoadingActions((prev) => new Set(prev).add(resolved.action));
-			try {
-				await executeAction({
-					action: resolved,
-					handler,
-					setState: set,
-					navigate,
-					executeAction: async (name) => {
-						await execute({ action: name });
-					}
-				});
-			} finally {
-				setLoadingActions((prev) => {
-					const next = new Set(prev);
-					next.delete(resolved.action);
-					return next;
-				});
-			}
-		} catch (err) {
-			__ok = false;
-			__error = err;
-			throw err;
-		} finally {
-			const now = Date.now();
-			notifyActionSettle({
-				id: dispatchId,
-				name: resolved.action,
-				ok: __ok,
-				at: now,
-				durationMs: now - dispatchedAt,
-				error: __error
-			});
-		}
-	}, [
-		handlers,
-		get,
-		set,
-		getSnapshot,
-		navigate,
-		validation
-	]);
-	const confirm = useCallback(() => {
-		pendingConfirmation?.resolve();
-	}, [pendingConfirmation]);
-	const cancel = useCallback(() => {
-		pendingConfirmation?.reject();
-	}, [pendingConfirmation]);
-	const value = useMemo(() => ({
-		handlers,
-		loadingActions,
-		pendingConfirmation,
-		execute,
-		confirm,
-		cancel,
-		registerHandler
-	}), [
-		handlers,
-		loadingActions,
-		pendingConfirmation,
-		execute,
-		confirm,
-		cancel,
-		registerHandler
-	]);
-	return /* @__PURE__ */ jsx(ActionContext.Provider, {
-		value,
-		children
-	});
-}
-function useActions() {
-	const ctx = useContext(ActionContext);
-	if (!ctx) throw new Error("useActions must be used within an ActionProvider");
-	return ctx;
-}
-function ConfirmDialog({ confirm, onConfirm, onCancel }) {
-	const isDanger = confirm.variant === "danger";
-	return /* @__PURE__ */ jsx("div", {
-		style: {
-			position: "fixed",
-			inset: 0,
-			backgroundColor: "rgba(0, 0, 0, 0.5)",
-			display: "flex",
-			alignItems: "center",
-			justifyContent: "center",
-			zIndex: 50
-		},
-		onClick: onCancel,
-		children: /* @__PURE__ */ jsxs("div", {
-			style: {
-				backgroundColor: "white",
-				borderRadius: "8px",
-				padding: "24px",
-				maxWidth: "400px",
-				width: "100%",
-				boxShadow: "0 20px 25px -5px rgba(0, 0, 0, 0.1)"
-			},
-			onClick: (e) => e.stopPropagation(),
-			children: [
-				/* @__PURE__ */ jsx("h3", {
-					style: {
-						margin: "0 0 8px 0",
-						fontSize: "18px",
-						fontWeight: 600
-					},
-					children: confirm.title
-				}),
-				/* @__PURE__ */ jsx("p", {
-					style: {
-						margin: "0 0 24px 0",
-						color: "#6b7280"
-					},
-					children: confirm.message
-				}),
-				/* @__PURE__ */ jsxs("div", {
-					style: {
-						display: "flex",
-						gap: "12px",
-						justifyContent: "flex-end"
-					},
-					children: [/* @__PURE__ */ jsx("button", {
-						onClick: onCancel,
-						style: {
-							padding: "8px 16px",
-							borderRadius: "6px",
-							border: "1px solid #d1d5db",
-							backgroundColor: "white",
-							cursor: "pointer"
-						},
-						children: confirm.cancelLabel ?? "Cancel"
-					}), /* @__PURE__ */ jsx("button", {
-						onClick: onConfirm,
-						style: {
-							padding: "8px 16px",
-							borderRadius: "6px",
-							border: "none",
-							backgroundColor: isDanger ? "#dc2626" : "#3b82f6",
-							color: "white",
-							cursor: "pointer"
-						},
-						children: confirm.confirmLabel ?? "Confirm"
-					})]
-				})
-			]
-		})
-	});
-}
-var RepeatScopeContext = createContext(null);
-function RepeatScopeProvider({ item, index, basePath, children }) {
-	return /* @__PURE__ */ jsx(RepeatScopeContext.Provider, {
-		value: {
-			item,
-			index,
-			basePath
-		},
-		children
-	});
-}
-function useRepeatScope() {
-	return useContext(RepeatScopeContext);
-}
-var ElementErrorBoundary = class extends React.Component {
-	constructor(props) {
-		super(props);
-		this.state = { hasError: false };
-	}
-	static getDerivedStateFromError() {
-		return { hasError: true };
-	}
-	componentDidCatch(error, info) {
-		console.error(`[json-render] Rendering error in <${this.props.elementType}>:`, error, info.componentStack);
-	}
-	render() {
-		if (this.state.hasError) return null;
-		return this.props.children;
-	}
-};
-var EMPTY_FUNCTIONS = {};
-var FunctionsContext = React.createContext(EMPTY_FUNCTIONS);
-function useFunctions() {
-	return React.useContext(FunctionsContext);
-}
-var DirectivesContext = React.createContext(void 0);
-function useDirectives() {
-	return React.useContext(DirectivesContext);
-}
-function useDevtoolsActive() {
-	return React.useSyncExternalStore(subscribeDevtoolsActive, isDevtoolsActive, () => false);
-}
-var ElementRenderer = React.memo(function ElementRenderer2({ element, elementKey, spec, registry, loading, fallback }) {
-	const devtoolsActive = useDevtoolsActive();
-	const repeatScope = useRepeatScope();
-	const { ctx } = useVisibility();
-	const { execute } = useActions();
-	const { getSnapshot, state: watchState } = useStateStore();
-	const functions = useFunctions();
-	const directives = useDirectives();
-	const fullCtx = useMemo(() => {
-		const base = repeatScope ? {
-			...ctx,
-			repeatItem: repeatScope.item,
-			repeatIndex: repeatScope.index,
-			repeatBasePath: repeatScope.basePath
-		} : { ...ctx };
-		base.functions = functions;
-		base.directives = directives;
-		return base;
-	}, [
-		ctx,
-		repeatScope,
-		functions,
-		directives
-	]);
-	const isVisible = element.visible === void 0 ? true : evaluateVisibility(element.visible, fullCtx);
-	const onBindings = element.on;
-	const emit = useCallback(async (eventName) => {
-		const binding = onBindings?.[eventName];
-		if (!binding) return;
-		const actionBindings = Array.isArray(binding) ? binding : [binding];
-		for (const b of actionBindings) {
-			if (!b.params) {
-				await execute(b);
-				continue;
-			}
-			const liveCtx = {
-				...fullCtx,
-				stateModel: getSnapshot()
-			};
-			const resolved = {};
-			for (const [key, val] of Object.entries(b.params)) resolved[key] = resolveActionParam(val, liveCtx);
-			await execute({
-				...b,
-				params: resolved
-			});
-		}
-	}, [
-		onBindings,
-		execute,
-		fullCtx,
-		getSnapshot
-	]);
-	const on = useCallback((eventName) => {
-		const binding = onBindings?.[eventName];
-		if (!binding) return {
-			emit: () => {},
-			shouldPreventDefault: false,
-			bound: false
-		};
-		return {
-			emit: () => emit(eventName),
-			shouldPreventDefault: (Array.isArray(binding) ? binding : [binding]).some((b) => b.preventDefault),
-			bound: true
-		};
-	}, [onBindings, emit]);
-	const watchConfig = element.watch;
-	const prevWatchValues = useRef(null);
-	const stableWatchRef = useRef(void 0);
-	const watchedValues = useMemo(() => {
-		if (!watchConfig) return void 0;
-		const values = {};
-		for (const path of Object.keys(watchConfig)) values[path] = getByPath(watchState, path);
-		const prev = stableWatchRef.current;
-		if (prev) {
-			const keys = Object.keys(values);
-			if (keys.length === Object.keys(prev).length && keys.every((k) => values[k] === prev[k])) return prev;
-		}
-		stableWatchRef.current = values;
-		return values;
-	}, [watchConfig, watchState]);
-	useEffect(() => {
-		if (!watchConfig || !watchedValues) return;
-		const paths = Object.keys(watchConfig);
-		if (paths.length === 0) return;
-		const prev = prevWatchValues.current;
-		prevWatchValues.current = watchedValues;
-		if (prev === null) return;
-		let cancelled = false;
-		(async () => {
-			for (const path of paths) {
-				if (cancelled) break;
-				if (watchedValues[path] !== prev[path]) {
-					const binding = watchConfig[path];
-					if (!binding) continue;
-					const bindings = Array.isArray(binding) ? binding : [binding];
-					for (const b of bindings) {
-						if (cancelled) break;
-						if (!b.params) {
-							await execute(b);
-							if (cancelled) break;
-							continue;
-						}
-						const liveCtx = {
-							...fullCtx,
-							stateModel: getSnapshot()
-						};
-						const resolved = {};
-						for (const [key, val] of Object.entries(b.params)) resolved[key] = resolveActionParam(val, liveCtx);
-						await execute({
-							...b,
-							params: resolved
-						});
-						if (cancelled) break;
-					}
-				}
-			}
-		})().catch(console.error);
-		return () => {
-			cancelled = true;
-		};
-	}, [
-		watchConfig,
-		watchedValues,
-		execute,
-		fullCtx,
-		getSnapshot
-	]);
-	if (!isVisible) return null;
-	const rawProps = element.props;
-	const elementBindings = resolveBindings(rawProps, fullCtx);
-	const resolvedProps = resolveElementProps(rawProps, fullCtx);
-	const resolvedElement = resolvedProps !== element.props ? {
-		...element,
-		props: resolvedProps
-	} : element;
-	const Component = registry[resolvedElement.type] ?? fallback;
-	if (!Component) {
-		console.warn(`No renderer for component type: ${resolvedElement.type}`);
-		return null;
-	}
-	const rendered = /* @__PURE__ */ jsx(Component, {
-		element: resolvedElement,
-		emit,
-		on,
-		bindings: elementBindings,
-		loading,
-		children: resolvedElement.repeat ? /* @__PURE__ */ jsx(RepeatChildren, {
-			element: resolvedElement,
-			spec,
-			registry,
-			loading,
-			fallback
-		}) : resolvedElement.children?.map((childKey) => {
-			const childElement = spec.elements[childKey];
-			if (!childElement) {
-				if (!loading) console.warn(`[json-render] Missing element "${childKey}" referenced as child of "${resolvedElement.type}". This element will not render.`);
-				return null;
-			}
-			return /* @__PURE__ */ jsx(ElementRenderer2, {
-				element: childElement,
-				elementKey: childKey,
-				spec,
-				registry,
-				loading,
-				fallback
-			}, childKey);
-		})
-	});
-	const tagged = devtoolsActive && elementKey ? /* @__PURE__ */ jsx("span", {
-		"data-jr-key": elementKey,
-		style: { display: "contents" },
-		children: rendered
-	}) : rendered;
-	return /* @__PURE__ */ jsx(ElementErrorBoundary, {
-		elementType: resolvedElement.type,
-		children: tagged
-	});
-});
-function RepeatChildren({ element, spec, registry, loading, fallback }) {
-	const { state } = useStateStore();
-	const repeat = element.repeat;
-	const statePath = repeat.statePath;
-	return /* @__PURE__ */ jsx(Fragment$1, { children: (getByPath(state, statePath) ?? []).map((itemValue, index) => {
-		const key = repeat.key && typeof itemValue === "object" && itemValue !== null ? String(itemValue[repeat.key] ?? index) : String(index);
-		return /* @__PURE__ */ jsx(RepeatScopeProvider, {
-			item: itemValue,
-			index,
-			basePath: `${statePath}/${index}`,
-			children: element.children?.map((childKey) => {
-				const childElement = spec.elements[childKey];
-				if (!childElement) {
-					if (!loading) console.warn(`[json-render] Missing element "${childKey}" referenced as child of "${element.type}" (repeat). This element will not render.`);
-					return null;
-				}
-				return /* @__PURE__ */ jsx(ElementRenderer, {
-					element: childElement,
-					elementKey: childKey,
-					spec,
-					registry,
-					loading,
-					fallback
-				}, childKey);
-			})
-		}, key);
-	}) });
-}
-function Renderer({ spec, registry, loading, fallback }) {
-	if (!spec || !spec.root) return null;
-	const rootElement = spec.elements[spec.root];
-	if (!rootElement) return null;
-	return /* @__PURE__ */ jsx(ElementRenderer, {
-		element: rootElement,
-		elementKey: spec.root,
-		spec,
-		registry,
-		loading,
-		fallback
-	});
-}
-function JSONUIProvider({ registry, store, initialState, handlers, navigate, validationFunctions, functions, directives, onStateChange, children }) {
-	const directiveRegistry = useMemo(() => directives ? createDirectiveRegistry(directives) : void 0, [directives]);
-	return /* @__PURE__ */ jsx(StateProvider, {
-		store,
-		initialState,
-		onStateChange,
-		children: /* @__PURE__ */ jsx(VisibilityProvider, { children: /* @__PURE__ */ jsx(ValidationProvider, {
-			customFunctions: validationFunctions,
-			children: /* @__PURE__ */ jsx(ActionProvider, {
-				handlers,
-				navigate,
-				children: /* @__PURE__ */ jsx(FunctionsContext.Provider, {
-					value: functions ?? EMPTY_FUNCTIONS,
-					children: /* @__PURE__ */ jsxs(DirectivesContext.Provider, {
-						value: directiveRegistry,
-						children: [children, /* @__PURE__ */ jsx(ConfirmationDialogManager, {})]
-					})
-				})
-			})
-		}) })
-	});
-}
-function ConfirmationDialogManager() {
-	const { pendingConfirmation, confirm, cancel } = useActions();
-	if (!pendingConfirmation?.action.confirm) return null;
-	return /* @__PURE__ */ jsx(ConfirmDialog, {
-		confirm: pendingConfirmation.action.confirm,
-		onConfirm: confirm,
-		onCancel: cancel
-	});
-}
-function defineRegistry(_catalog, options) {
-	const registry = {};
-	if (options.components) for (const [name, componentFn] of Object.entries(options.components)) registry[name] = ({ element, children, emit, on, bindings, loading }) => {
-		return componentFn({
-			props: element.props,
-			children,
-			emit,
-			on,
-			bindings,
-			loading
-		});
-	};
-	const actionMap = options.actions ? Object.entries(options.actions) : [];
-	const handlers = (getSetState, getState) => {
-		const result = {};
-		for (const [name, actionFn] of actionMap) result[name] = async (params) => {
-			const setState = getSetState();
-			const state = getState();
-			if (setState) await actionFn(params, setState, state);
-		};
-		return result;
-	};
-	const executeAction2 = async (actionName, params, setState, state = {}) => {
-		const entry = actionMap.find(([name]) => name === actionName);
-		if (entry) await entry[1](params, setState, state);
-		else console.warn(`Unknown action: ${actionName}`);
-	};
-	return {
-		registry,
-		handlers,
-		executeAction: executeAction2
-	};
-}
-
-//#endregion
-//#region ../ui-react/dist/jsonRenderRegistry-9GrWP_hE.js
-/** catalog 的 json-render 投影：props 复用同一份 zod schema，不维护第二份定义 */
-const jsonRenderCatalog = defineCatalog(schema, {
-	components: Object.fromEntries(uiCatalog.components.map((def) => [def.name, {
-		props: def.props,
-		description: def.description,
-		...def.children !== void 0 ? { slots: ["default"] } : {},
-		...def.example?.props ? { example: def.example.props } : {}
-	}])),
-	actions: Object.fromEntries(uiCatalog.actions.map((action) => [action.name, { description: action.description }]))
-});
-/** registry 是白名单：catalog 之外的组件名在 Renderer 里直接落到 fallback */
-const { registry: jsonRenderRegistry } = defineRegistry(jsonRenderCatalog, {
-	components: catalogComponentImpls,
-	actions: Object.fromEntries(uiCatalog.actions.map((action) => [action.name, () => void 0]))
-});
-const JSON_RENDER_COMPONENTS = Object.keys(catalogComponentImpls);
-
-//#endregion
-export { JSONUIProvider, JSON_RENDER_COMPONENTS, Renderer, jsonRenderCatalog, jsonRenderRegistry };