@json-render/vue 0.9.1

package/dist/index.mjs

@@ -0,0 +1,1849 @@
+import {
+  schema
+} from "./chunk-WIPZLAF7.mjs";
+
+// src/composables/state.ts
+import {
+  computed,
+  defineComponent,
+  inject,
+  onUnmounted,
+  provide,
+  ref,
+  shallowRef,
+  watch
+} from "vue";
+import {
+  createStateStore,
+  getByPath
+} from "@json-render/core";
+import { flattenToPointers } from "@json-render/core/store-utils";
+var STATE_KEY = /* @__PURE__ */ Symbol("json-render:state");
+var StateProvider = defineComponent({
+  name: "StateProvider",
+  props: {
+    store: {
+      type: Object,
+      default: void 0
+    },
+    initialState: {
+      type: Object,
+      default: void 0
+    },
+    onStateChange: {
+      type: Function,
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    const isControlled = !!props.store;
+    const internalStore = !isControlled ? createStateStore(props.initialState ?? {}) : null;
+    const store = props.store ?? internalStore;
+    const state = shallowRef(store.getSnapshot());
+    const unsubscribe = store.subscribe(() => {
+      state.value = store.getSnapshot();
+    });
+    onUnmounted(unsubscribe);
+    if (!isControlled) {
+      let prevFlat = props.initialState && Object.keys(props.initialState).length > 0 ? flattenToPointers(props.initialState) : {};
+      watch(
+        () => props.initialState,
+        (newInitialState) => {
+          if (!newInitialState) return;
+          const nextFlat = Object.keys(newInitialState).length > 0 ? flattenToPointers(newInitialState) : {};
+          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;
+            }
+          }
+          prevFlat = nextFlat;
+          if (Object.keys(updates).length > 0) {
+            store.update(updates);
+          }
+        }
+      );
+    }
+    const onStateChangeRef = ref(props.onStateChange);
+    watch(
+      () => props.onStateChange,
+      (fn) => {
+        onStateChangeRef.value = fn;
+      }
+    );
+    const get = (path) => store.get(path);
+    const getSnapshot = () => store.getSnapshot();
+    const set = (path, value) => {
+      const prev = store.getSnapshot();
+      store.set(path, value);
+      if (!isControlled && store.getSnapshot() !== prev) {
+        onStateChangeRef.value?.([{ path, value }]);
+      }
+    };
+    const update = (updates) => {
+      const prev = store.getSnapshot();
+      store.update(updates);
+      if (!isControlled && store.getSnapshot() !== prev) {
+        const changes = [];
+        for (const [path, value] of Object.entries(updates)) {
+          if (getByPath(prev, path) !== value) {
+            changes.push({ path, value });
+          }
+        }
+        if (changes.length > 0) {
+          onStateChangeRef.value?.(changes);
+        }
+      }
+    };
+    provide(STATE_KEY, {
+      state,
+      get,
+      set,
+      update,
+      getSnapshot
+    });
+    return () => slots.default?.();
+  }
+});
+function useStateStore() {
+  const ctx = inject(STATE_KEY);
+  if (!ctx) {
+    throw new Error("useStateStore must be used within a StateProvider");
+  }
+  return ctx;
+}
+function useStateValue(path) {
+  const { state } = useStateStore();
+  return computed(() => getByPath(state.value, path));
+}
+function useStateBinding(path) {
+  const { state, set } = useStateStore();
+  const value = computed(() => getByPath(state.value, path));
+  const setValue = (newValue) => set(path, newValue);
+  return [value, setValue];
+}
+
+// src/composables/visibility.ts
+import {
+  computed as computed2,
+  defineComponent as defineComponent2,
+  inject as inject2,
+  provide as provide2
+} from "vue";
+import {
+  evaluateVisibility
+} from "@json-render/core";
+var VISIBILITY_KEY = /* @__PURE__ */ Symbol("json-render:visibility");
+var VisibilityProvider = defineComponent2({
+  name: "VisibilityProvider",
+  setup(_, { slots }) {
+    const { state } = useStateStore();
+    const ctx = computed2(() => ({
+      stateModel: state.value
+    }));
+    const isVisible = (condition) => evaluateVisibility(condition, ctx.value);
+    provide2(VISIBILITY_KEY, { isVisible, ctx });
+    return () => slots.default?.();
+  }
+});
+function useVisibility() {
+  const ctx = inject2(VISIBILITY_KEY);
+  if (!ctx) {
+    throw new Error("useVisibility must be used within a VisibilityProvider");
+  }
+  return ctx;
+}
+function useIsVisible(condition) {
+  const { ctx } = useVisibility();
+  return computed2(() => evaluateVisibility(condition, ctx.value));
+}
+
+// src/composables/actions.ts
+import {
+  computed as computed4,
+  defineComponent as defineComponent4,
+  h,
+  inject as inject4,
+  provide as provide4,
+  ref as ref3,
+  watch as watch2
+} from "vue";
+import {
+  resolveAction,
+  executeAction
+} from "@json-render/core";
+
+// src/composables/validation.ts
+import {
+  computed as computed3,
+  defineComponent as defineComponent3,
+  inject as inject3,
+  onMounted,
+  onUnmounted as onUnmounted2,
+  provide as provide3,
+  ref as ref2
+} from "vue";
+import {
+  runValidation
+} from "@json-render/core";
+var VALIDATION_KEY = /* @__PURE__ */ Symbol("json-render:validation");
+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;
+}
+var ValidationProvider = defineComponent3({
+  name: "ValidationProvider",
+  props: {
+    customFunctions: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(props, { slots }) {
+    const { state } = useStateStore();
+    const fieldStates = ref2({});
+    const fieldConfigs = ref2({});
+    const registerField = (path, config) => {
+      const existing = fieldConfigs.value[path];
+      if (existing && validationConfigEqual(existing, config)) return;
+      fieldConfigs.value = { ...fieldConfigs.value, [path]: config };
+    };
+    const validate = (path, config) => {
+      const currentState = state.value;
+      const segments = path.split("/").filter(Boolean);
+      let value = currentState;
+      for (const seg of segments) {
+        if (value != null && typeof value === "object") {
+          value = value[seg];
+        } else {
+          value = void 0;
+          break;
+        }
+      }
+      const result = runValidation(config, {
+        value,
+        stateModel: currentState,
+        customFunctions: props.customFunctions
+      });
+      fieldStates.value = {
+        ...fieldStates.value,
+        [path]: {
+          touched: fieldStates.value[path]?.touched ?? true,
+          validated: true,
+          result
+        }
+      };
+      return result;
+    };
+    const touch = (path) => {
+      fieldStates.value = {
+        ...fieldStates.value,
+        [path]: {
+          ...fieldStates.value[path],
+          touched: true,
+          validated: fieldStates.value[path]?.validated ?? false,
+          result: fieldStates.value[path]?.result ?? null
+        }
+      };
+    };
+    const clear = (path) => {
+      const { [path]: _, ...rest } = fieldStates.value;
+      fieldStates.value = rest;
+    };
+    const validateAll = () => {
+      let allValid = true;
+      for (const [path, config] of Object.entries(fieldConfigs.value)) {
+        const result = validate(path, config);
+        if (!result.valid) {
+          allValid = false;
+        }
+      }
+      return allValid;
+    };
+    provide3(VALIDATION_KEY, {
+      get customFunctions() {
+        return props.customFunctions;
+      },
+      get fieldStates() {
+        return fieldStates.value;
+      },
+      validate,
+      touch,
+      clear,
+      validateAll,
+      registerField
+    });
+    return () => slots.default?.();
+  }
+});
+function useOptionalValidation() {
+  return inject3(
+    VALIDATION_KEY,
+    null
+  ) ?? null;
+}
+function useValidation() {
+  const ctx = inject3(VALIDATION_KEY);
+  if (!ctx) {
+    throw new Error("useValidation must be used within a ValidationProvider");
+  }
+  return ctx;
+}
+function useFieldValidation(path, config) {
+  const ctx = useValidation();
+  onMounted(() => {
+    if (path && config) {
+      ctx.registerField(path, config);
+    }
+  });
+  onUnmounted2(() => {
+    ctx.clear(path);
+  });
+  const defaultState = {
+    touched: false,
+    validated: false,
+    result: null
+  };
+  return {
+    state: computed3(() => ctx.fieldStates[path] ?? defaultState),
+    validate: () => ctx.validate(path, config ?? { checks: [] }),
+    touch: () => ctx.touch(path),
+    clear: () => ctx.clear(path),
+    errors: computed3(() => ctx.fieldStates[path]?.result?.errors ?? []),
+    isValid: computed3(() => ctx.fieldStates[path]?.result?.valid ?? true)
+  };
+}
+
+// src/composables/actions.ts
+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 ACTIONS_KEY = /* @__PURE__ */ Symbol("json-render:actions");
+var ActionProvider = defineComponent4({
+  name: "ActionProvider",
+  props: {
+    handlers: {
+      type: Object,
+      default: () => ({})
+    },
+    navigate: {
+      type: Function,
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    const { get, set, getSnapshot } = useStateStore();
+    const validation = useOptionalValidation();
+    const handlers = ref3(props.handlers ?? {});
+    const loadingActions = ref3(/* @__PURE__ */ new Set());
+    const pendingConfirmation = ref3(null);
+    watch2(
+      () => props.handlers,
+      (newHandlers) => {
+        if (newHandlers) handlers.value = newHandlers;
+      }
+    );
+    const registerHandler = (name, handler) => {
+      handlers.value = { ...handlers.value, [name]: handler };
+    };
+    const execute = async (binding) => {
+      const resolved = resolveAction(binding, getSnapshot());
+      if (resolved.action === "setState" && resolved.params) {
+        const statePath = resolved.params.statePath;
+        const value = resolved.params.value;
+        if (statePath) {
+          set(statePath, value);
+        }
+        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 === "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;
+      }
+      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;
+      }
+      const handler = handlers.value[resolved.action];
+      if (!handler) {
+        console.warn(`No handler registered for action: ${resolved.action}`);
+        return;
+      }
+      if (resolved.confirm) {
+        await new Promise((resolve, reject) => {
+          pendingConfirmation.value = {
+            action: resolved,
+            handler,
+            resolve: () => {
+              pendingConfirmation.value = null;
+              resolve();
+            },
+            reject: () => {
+              pendingConfirmation.value = null;
+              reject(new Error("Action cancelled"));
+            }
+          };
+        });
+        const addLoading2 = new Set(loadingActions.value);
+        addLoading2.add(resolved.action);
+        loadingActions.value = addLoading2;
+        try {
+          await executeAction({
+            action: resolved,
+            handler,
+            setState: set,
+            navigate: props.navigate,
+            executeAction: async (name) => {
+              const subBinding = { action: name };
+              await execute(subBinding);
+            }
+          });
+        } finally {
+          const removeLoading = new Set(loadingActions.value);
+          removeLoading.delete(resolved.action);
+          loadingActions.value = removeLoading;
+        }
+        return;
+      }
+      const addLoading = new Set(loadingActions.value);
+      addLoading.add(resolved.action);
+      loadingActions.value = addLoading;
+      try {
+        await executeAction({
+          action: resolved,
+          handler,
+          setState: set,
+          navigate: props.navigate,
+          executeAction: async (name) => {
+            const subBinding = { action: name };
+            await execute(subBinding);
+          }
+        });
+      } finally {
+        const removeLoading = new Set(loadingActions.value);
+        removeLoading.delete(resolved.action);
+        loadingActions.value = removeLoading;
+      }
+    };
+    const confirm = () => pendingConfirmation.value?.resolve();
+    const cancel = () => pendingConfirmation.value?.reject();
+    provide4(ACTIONS_KEY, {
+      get handlers() {
+        return handlers.value;
+      },
+      get loadingActions() {
+        return loadingActions.value;
+      },
+      get pendingConfirmation() {
+        return pendingConfirmation.value;
+      },
+      execute,
+      confirm,
+      cancel,
+      registerHandler
+    });
+    return () => slots.default?.();
+  }
+});
+function useActions() {
+  const ctx = inject4(ACTIONS_KEY);
+  if (!ctx) {
+    throw new Error("useActions must be used within an ActionProvider");
+  }
+  return ctx;
+}
+function useAction(binding) {
+  const ctx = useActions();
+  return {
+    execute: () => ctx.execute(binding),
+    isLoading: computed4(() => ctx.loadingActions.has(binding.action))
+  };
+}
+var ConfirmDialog = defineComponent4({
+  name: "ConfirmDialog",
+  props: {
+    confirm: {
+      type: Object,
+      required: true
+    },
+    onConfirm: {
+      type: Function,
+      required: true
+    },
+    onCancel: {
+      type: Function,
+      required: true
+    }
+  },
+  setup(props) {
+    return () => {
+      const isDanger = props.confirm.variant === "danger";
+      return h(
+        "div",
+        {
+          style: {
+            position: "fixed",
+            inset: "0",
+            backgroundColor: "rgba(0, 0, 0, 0.5)",
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            zIndex: "50"
+          },
+          onClick: props.onCancel
+        },
+        [
+          h(
+            "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()
+            },
+            [
+              h(
+                "h3",
+                {
+                  style: {
+                    margin: "0 0 8px 0",
+                    fontSize: "18px",
+                    fontWeight: "600"
+                  }
+                },
+                props.confirm.title
+              ),
+              h(
+                "p",
+                {
+                  style: { margin: "0 0 24px 0", color: "#6b7280" }
+                },
+                props.confirm.message
+              ),
+              h(
+                "div",
+                {
+                  style: {
+                    display: "flex",
+                    gap: "12px",
+                    justifyContent: "flex-end"
+                  }
+                },
+                [
+                  h(
+                    "button",
+                    {
+                      style: {
+                        padding: "8px 16px",
+                        borderRadius: "6px",
+                        border: "1px solid #d1d5db",
+                        backgroundColor: "white",
+                        cursor: "pointer"
+                      },
+                      onClick: props.onCancel
+                    },
+                    props.confirm.cancelLabel ?? "Cancel"
+                  ),
+                  h(
+                    "button",
+                    {
+                      style: {
+                        padding: "8px 16px",
+                        borderRadius: "6px",
+                        border: "none",
+                        backgroundColor: isDanger ? "#dc2626" : "#3b82f6",
+                        color: "white",
+                        cursor: "pointer"
+                      },
+                      onClick: props.onConfirm
+                    },
+                    props.confirm.confirmLabel ?? "Confirm"
+                  )
+                ]
+              )
+            ]
+          )
+        ]
+      );
+    };
+  }
+});
+
+// src/composables/repeat-scope.ts
+import { defineComponent as defineComponent5, inject as inject5, provide as provide5 } from "vue";
+var REPEAT_SCOPE_KEY = /* @__PURE__ */ Symbol("json-render:repeat-scope");
+var RepeatScopeProvider = defineComponent5({
+  name: "RepeatScopeProvider",
+  props: {
+    item: {
+      required: true
+    },
+    index: {
+      type: Number,
+      required: true
+    },
+    basePath: {
+      type: String,
+      required: true
+    }
+  },
+  setup(props, { slots }) {
+    provide5(REPEAT_SCOPE_KEY, props);
+    return () => slots.default?.();
+  }
+});
+function useRepeatScope() {
+  return inject5(
+    REPEAT_SCOPE_KEY,
+    null
+  ) ?? null;
+}
+
+// src/index.ts
+import { createStateStore as createStateStore2 } from "@json-render/core";
+
+// src/hooks.ts
+import {
+  ref as ref4,
+  shallowRef as shallowRef2,
+  computed as computed5,
+  onUnmounted as onUnmounted3,
+  isRef
+} from "vue";
+import {
+  setByPath,
+  getByPath as getByPath2,
+  removeByPath,
+  createMixedStreamParser,
+  applySpecPatch,
+  nestedToFlat,
+  SPEC_DATA_PART_TYPE
+} from "@json-render/core";
+function parseLine(line) {
+  try {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("//")) {
+      return null;
+    }
+    const parsed = JSON.parse(trimmed);
+    if (parsed.__meta === "usage") {
+      return {
+        type: "usage",
+        usage: {
+          promptTokens: parsed.promptTokens ?? 0,
+          completionTokens: parsed.completionTokens ?? 0,
+          totalTokens: parsed.totalTokens ?? 0
+        }
+      };
+    }
+    return { type: "patch", patch: parsed };
+  } catch {
+    return null;
+  }
+}
+function setSpecValue(newSpec, path, value) {
+  if (path === "/root") {
+    newSpec.root = value;
+    return;
+  }
+  if (path === "/state") {
+    newSpec.state = value;
+    return;
+  }
+  if (path.startsWith("/state/")) {
+    if (!newSpec.state) newSpec.state = {};
+    const statePath = path.slice("/state".length);
+    setByPath(newSpec.state, statePath, value);
+    return;
+  }
+  if (path.startsWith("/elements/")) {
+    const pathParts = path.slice("/elements/".length).split("/");
+    const elementKey = pathParts[0];
+    if (!elementKey) return;
+    if (pathParts.length === 1) {
+      newSpec.elements[elementKey] = value;
+    } else {
+      const element = newSpec.elements[elementKey];
+      if (element) {
+        const propPath = "/" + pathParts.slice(1).join("/");
+        const newElement = { ...element };
+        setByPath(
+          newElement,
+          propPath,
+          value
+        );
+        newSpec.elements[elementKey] = newElement;
+      }
+    }
+  }
+}
+function removeSpecValue(newSpec, path) {
+  if (path === "/state") {
+    delete newSpec.state;
+    return;
+  }
+  if (path.startsWith("/state/") && newSpec.state) {
+    const statePath = path.slice("/state".length);
+    removeByPath(newSpec.state, statePath);
+    return;
+  }
+  if (path.startsWith("/elements/")) {
+    const pathParts = path.slice("/elements/".length).split("/");
+    const elementKey = pathParts[0];
+    if (!elementKey) return;
+    if (pathParts.length === 1) {
+      const { [elementKey]: _, ...rest } = newSpec.elements;
+      newSpec.elements = rest;
+    } else {
+      const element = newSpec.elements[elementKey];
+      if (element) {
+        const propPath = "/" + pathParts.slice(1).join("/");
+        const newElement = { ...element };
+        removeByPath(
+          newElement,
+          propPath
+        );
+        newSpec.elements[elementKey] = newElement;
+      }
+    }
+  }
+}
+function getSpecValue(spec, path) {
+  if (path === "/root") return spec.root;
+  if (path === "/state") return spec.state;
+  if (path.startsWith("/state/") && spec.state) {
+    const statePath = path.slice("/state".length);
+    return getByPath2(spec.state, statePath);
+  }
+  return getByPath2(spec, path);
+}
+function applyPatch(spec, patch) {
+  const newSpec = {
+    ...spec,
+    elements: { ...spec.elements },
+    ...spec.state ? { state: { ...spec.state } } : {}
+  };
+  switch (patch.op) {
+    case "add":
+    case "replace": {
+      setSpecValue(newSpec, patch.path, patch.value);
+      break;
+    }
+    case "remove": {
+      removeSpecValue(newSpec, patch.path);
+      break;
+    }
+    case "move": {
+      if (!patch.from) break;
+      const moveValue = getSpecValue(newSpec, patch.from);
+      removeSpecValue(newSpec, patch.from);
+      setSpecValue(newSpec, patch.path, moveValue);
+      break;
+    }
+    case "copy": {
+      if (!patch.from) break;
+      const copyValue = getSpecValue(newSpec, patch.from);
+      setSpecValue(newSpec, patch.path, copyValue);
+      break;
+    }
+    case "test": {
+      break;
+    }
+  }
+  return newSpec;
+}
+function useUIStream({
+  api,
+  onComplete,
+  onError
+}) {
+  const spec = shallowRef2(null);
+  const isStreaming = ref4(false);
+  const error = ref4(null);
+  const usage = ref4(null);
+  const rawLines = ref4([]);
+  const onCompleteRef = ref4(onComplete);
+  const onErrorRef = ref4(onError);
+  let abortController = null;
+  const clear = () => {
+    spec.value = null;
+    error.value = null;
+    usage.value = null;
+    rawLines.value = [];
+  };
+  const send = async (prompt, context) => {
+    abortController?.abort();
+    abortController = new AbortController();
+    isStreaming.value = true;
+    error.value = null;
+    usage.value = null;
+    rawLines.value = [];
+    const previousSpec = context?.previousSpec;
+    let currentSpec = previousSpec && previousSpec.root ? { ...previousSpec, elements: { ...previousSpec.elements } } : { root: "", elements: {} };
+    spec.value = currentSpec;
+    try {
+      const response = await fetch(api, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          prompt,
+          context,
+          currentSpec
+        }),
+        signal: abortController.signal
+      });
+      if (!response.ok) {
+        let errorMessage = `HTTP error: ${response.status}`;
+        try {
+          const errorData = await response.json();
+          if (errorData.message) {
+            errorMessage = errorData.message;
+          } else if (errorData.error) {
+            errorMessage = errorData.error;
+          }
+        } catch {
+        }
+        throw new Error(errorMessage);
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("No response body");
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          const result = parseLine(trimmed);
+          if (!result) continue;
+          if (result.type === "usage") {
+            usage.value = result.usage;
+          } else {
+            rawLines.value = [...rawLines.value, trimmed];
+            currentSpec = applyPatch(currentSpec, result.patch);
+            spec.value = { ...currentSpec };
+          }
+        }
+      }
+      if (buffer.trim()) {
+        const trimmed = buffer.trim();
+        const result = parseLine(trimmed);
+        if (result) {
+          if (result.type === "usage") {
+            usage.value = result.usage;
+          } else {
+            rawLines.value = [...rawLines.value, trimmed];
+            currentSpec = applyPatch(currentSpec, result.patch);
+            spec.value = { ...currentSpec };
+          }
+        }
+      }
+      onCompleteRef.value?.(currentSpec);
+    } catch (err) {
+      if (err.name === "AbortError") {
+        return;
+      }
+      const resolvedError = err instanceof Error ? err : new Error(String(err));
+      error.value = resolvedError;
+      onErrorRef.value?.(resolvedError);
+    } finally {
+      isStreaming.value = false;
+    }
+  };
+  onUnmounted3(() => {
+    abortController?.abort();
+  });
+  return {
+    spec,
+    isStreaming,
+    error,
+    usage,
+    rawLines,
+    send,
+    clear
+  };
+}
+function flatToTree(elements) {
+  const elementMap = {};
+  let root = "";
+  for (const element of elements) {
+    elementMap[element.key] = {
+      type: element.type,
+      props: element.props,
+      children: [],
+      visible: element.visible
+    };
+  }
+  for (const element of elements) {
+    if (element.parentKey) {
+      const parent = elementMap[element.parentKey];
+      if (parent) {
+        if (!parent.children) {
+          parent.children = [];
+        }
+        parent.children.push(element.key);
+      }
+    } else {
+      root = element.key;
+    }
+  }
+  return { root, elements: elementMap };
+}
+function useBoundProp(propValue, bindingPath) {
+  const { set } = useStateStore();
+  return [
+    propValue,
+    (value) => {
+      if (bindingPath) set(bindingPath, value);
+    }
+  ];
+}
+function isSpecDataPart(data) {
+  if (typeof data !== "object" || data === null) return false;
+  const obj = data;
+  switch (obj.type) {
+    case "patch":
+      return typeof obj.patch === "object" && obj.patch !== null;
+    case "flat":
+    case "nested":
+      return typeof obj.spec === "object" && obj.spec !== null;
+    default:
+      return false;
+  }
+}
+function buildSpecFromParts(parts) {
+  const spec = { root: "", elements: {} };
+  let hasSpec = false;
+  for (const part of parts) {
+    if (part.type === SPEC_DATA_PART_TYPE) {
+      if (!isSpecDataPart(part.data)) continue;
+      const payload = part.data;
+      if (payload.type === "patch") {
+        hasSpec = true;
+        applySpecPatch(spec, payload.patch);
+      } else if (payload.type === "flat") {
+        hasSpec = true;
+        Object.assign(spec, payload.spec);
+      } else if (payload.type === "nested") {
+        hasSpec = true;
+        const flat = nestedToFlat(payload.spec);
+        Object.assign(spec, flat);
+      }
+    }
+  }
+  return hasSpec ? spec : null;
+}
+function getTextFromParts(parts) {
+  return parts.filter(
+    (p) => p.type === "text" && typeof p.text === "string"
+  ).map((p) => p.text.trim()).filter(Boolean).join("\n\n");
+}
+function useJsonRenderMessage(parts) {
+  const partsRef = isRef(parts) ? parts : ref4(parts);
+  const spec = computed5(() => buildSpecFromParts(partsRef.value));
+  const text = computed5(() => getTextFromParts(partsRef.value));
+  const hasSpec = computed5(
+    () => spec.value !== null && Object.keys(spec.value.elements || {}).length > 0
+  );
+  return { spec, text, hasSpec };
+}
+var chatMessageIdCounter = 0;
+function generateChatId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  chatMessageIdCounter += 1;
+  return `msg-${Date.now()}-${chatMessageIdCounter}`;
+}
+function useChatUI({
+  api,
+  onComplete,
+  onError
+}) {
+  const messages = ref4([]);
+  const isStreaming = ref4(false);
+  const error = ref4(null);
+  const onCompleteRef = ref4(onComplete);
+  const onErrorRef = ref4(onError);
+  let abortController = null;
+  const clear = () => {
+    messages.value = [];
+    error.value = null;
+  };
+  const send = async (text) => {
+    if (!text.trim()) return;
+    abortController?.abort();
+    abortController = new AbortController();
+    const userMessage = {
+      id: generateChatId(),
+      role: "user",
+      text: text.trim(),
+      spec: null
+    };
+    const assistantId = generateChatId();
+    const assistantMessage = {
+      id: assistantId,
+      role: "assistant",
+      text: "",
+      spec: null
+    };
+    messages.value = [...messages.value, userMessage, assistantMessage];
+    isStreaming.value = true;
+    error.value = null;
+    const historyForApi = [
+      ...messages.value.filter((m) => m.id !== assistantId).map((m) => ({ role: m.role, content: m.text })),
+      { role: "user", content: text.trim() }
+    ];
+    let accumulatedText = "";
+    let currentSpec = { root: "", elements: {} };
+    let hasSpec = false;
+    try {
+      const response = await fetch(api, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ messages: historyForApi }),
+        signal: abortController.signal
+      });
+      if (!response.ok) {
+        let errorMessage = `HTTP error: ${response.status}`;
+        try {
+          const errorData = await response.json();
+          if (errorData.message) {
+            errorMessage = errorData.message;
+          } else if (errorData.error) {
+            errorMessage = errorData.error;
+          }
+        } catch {
+        }
+        throw new Error(errorMessage);
+      }
+      const reader = response.body?.getReader();
+      if (!reader) {
+        throw new Error("No response body");
+      }
+      const decoder = new TextDecoder();
+      const parser = createMixedStreamParser({
+        onPatch(patch) {
+          hasSpec = true;
+          applySpecPatch(currentSpec, patch);
+          messages.value = messages.value.map(
+            (m) => m.id === assistantId ? {
+              ...m,
+              spec: {
+                root: currentSpec.root,
+                elements: { ...currentSpec.elements },
+                ...currentSpec.state ? { state: { ...currentSpec.state } } : {}
+              }
+            } : m
+          );
+        },
+        onText(line) {
+          accumulatedText += (accumulatedText ? "\n" : "") + line;
+          messages.value = messages.value.map(
+            (m) => m.id === assistantId ? { ...m, text: accumulatedText } : m
+          );
+        }
+      });
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        parser.push(decoder.decode(value, { stream: true }));
+      }
+      parser.flush();
+      const finalMessage = {
+        id: assistantId,
+        role: "assistant",
+        text: accumulatedText,
+        spec: hasSpec ? {
+          root: currentSpec.root,
+          elements: { ...currentSpec.elements },
+          ...currentSpec.state ? { state: { ...currentSpec.state } } : {}
+        } : null
+      };
+      onCompleteRef.value?.(finalMessage);
+    } catch (err) {
+      if (err.name === "AbortError") {
+        return;
+      }
+      const resolvedError = err instanceof Error ? err : new Error(String(err));
+      error.value = resolvedError;
+      messages.value = messages.value.filter(
+        (m) => m.id !== assistantId || m.text.length > 0
+      );
+      onErrorRef.value?.(resolvedError);
+    } finally {
+      isStreaming.value = false;
+    }
+  };
+  onUnmounted3(() => {
+    abortController?.abort();
+  });
+  return {
+    messages,
+    isStreaming,
+    error,
+    send,
+    clear
+  };
+}
+
+// src/renderer.ts
+import {
+  computed as computed6,
+  defineComponent as defineComponent6,
+  h as h2,
+  inject as inject6,
+  onErrorCaptured,
+  provide as provide6,
+  ref as ref5,
+  watch as watch3
+} from "vue";
+import {
+  resolveElementProps,
+  resolveBindings,
+  resolveActionParam,
+  evaluateVisibility as evaluateVisibility2,
+  getByPath as getByPath3
+} from "@json-render/core";
+var EMPTY_FUNCTIONS = {};
+var FUNCTIONS_KEY = /* @__PURE__ */ Symbol("json-render:functions");
+var FunctionsProvider = defineComponent6({
+  name: "FunctionsProvider",
+  props: {
+    functions: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    const fns = computed6(() => props.functions ?? EMPTY_FUNCTIONS);
+    provide6(FUNCTIONS_KEY, fns);
+    return () => slots.default?.();
+  }
+});
+function useFunctions() {
+  return inject6(
+    FUNCTIONS_KEY,
+    computed6(() => EMPTY_FUNCTIONS)
+  );
+}
+var ElementErrorBoundary = defineComponent6({
+  name: "ElementErrorBoundary",
+  props: {
+    elementType: {
+      type: String,
+      required: true
+    }
+  },
+  setup(props, { slots }) {
+    const hasError = ref5(false);
+    onErrorCaptured((error) => {
+      console.error(
+        `[json-render] Rendering error in <${props.elementType}>:`,
+        error
+      );
+      hasError.value = true;
+      return false;
+    });
+    return () => {
+      if (hasError.value) return null;
+      return slots.default?.();
+    };
+  }
+});
+async function resolveAndExecuteBindings(actionBindings, ctx, getSnapshot, execute, cancelled) {
+  for (const b of actionBindings) {
+    if (cancelled?.()) break;
+    if (!b.params) {
+      await execute(b);
+      if (cancelled?.()) break;
+      continue;
+    }
+    const liveCtx = {
+      ...ctx,
+      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;
+  }
+}
+var ElementRenderer = defineComponent6({
+  name: "JsonRenderElement",
+  props: {
+    element: {
+      type: Object,
+      required: true
+    },
+    spec: {
+      type: Object,
+      required: true
+    },
+    registry: {
+      type: Object,
+      required: true
+    },
+    loading: {
+      type: Boolean,
+      default: void 0
+    },
+    fallback: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup(props) {
+    const repeatScope = useRepeatScope();
+    const { ctx: visibilityCtx } = useVisibility();
+    const { execute } = useActions();
+    const { getSnapshot, state: watchState } = useStateStore();
+    const functions = useFunctions();
+    const fullCtx = computed6(() => {
+      const base = repeatScope ? {
+        ...visibilityCtx.value,
+        repeatItem: repeatScope.item,
+        repeatIndex: repeatScope.index,
+        repeatBasePath: repeatScope.basePath
+      } : { ...visibilityCtx.value };
+      base.functions = functions.value;
+      return base;
+    });
+    const emitEvent = async (eventName) => {
+      const binding = props.element.on?.[eventName];
+      if (!binding) return;
+      const actionBindings = Array.isArray(binding) ? binding : [binding];
+      await resolveAndExecuteBindings(
+        actionBindings,
+        fullCtx.value,
+        getSnapshot,
+        execute
+      );
+    };
+    const onEvent = (eventName) => {
+      const binding = props.element.on?.[eventName];
+      if (!binding) {
+        return { emit: () => {
+        }, shouldPreventDefault: false, bound: false };
+      }
+      const actionBindings = Array.isArray(binding) ? binding : [binding];
+      const shouldPreventDefault = actionBindings.some((b) => b.preventDefault);
+      return {
+        emit: () => {
+          void emitEvent(eventName);
+        },
+        shouldPreventDefault,
+        bound: true
+      };
+    };
+    const watchedValues = computed6(() => {
+      const cfg = props.element.watch;
+      if (!cfg) return void 0;
+      const values = {};
+      for (const path of Object.keys(cfg)) {
+        values[path] = getByPath3(watchState.value, path);
+      }
+      return values;
+    });
+    watch3(
+      watchedValues,
+      (current, prev, onCleanup) => {
+        const cfg = props.element.watch;
+        if (!cfg || !current) return;
+        let cancelled = false;
+        onCleanup(() => {
+          cancelled = true;
+        });
+        const paths = Object.keys(cfg);
+        void (async () => {
+          for (const path of paths) {
+            if (cancelled) break;
+            if (prev && current[path] === prev[path]) continue;
+            const binding = cfg[path];
+            if (!binding) continue;
+            const bindings = Array.isArray(binding) ? binding : [binding];
+            await resolveAndExecuteBindings(
+              bindings,
+              fullCtx.value,
+              getSnapshot,
+              execute,
+              () => cancelled
+            );
+          }
+        })().catch(console.error);
+      },
+      { deep: true }
+    );
+    return () => {
+      const ctx = fullCtx.value;
+      const isVisible = props.element.visible === void 0 ? true : evaluateVisibility2(props.element.visible, ctx);
+      if (!isVisible) return null;
+      const rawProps = props.element.props;
+      const elementBindings = resolveBindings(rawProps, ctx);
+      const resolvedProps = resolveElementProps(rawProps, ctx);
+      const resolvedElement = resolvedProps !== props.element.props ? { ...props.element, props: resolvedProps } : props.element;
+      const Component = props.registry[resolvedElement.type] ?? props.fallback;
+      if (!Component) {
+        console.warn(
+          `[json-render] No renderer for component type: ${resolvedElement.type}`
+        );
+        return null;
+      }
+      const childrenVNodes = resolvedElement.repeat ? h2(RepeatChildren, {
+        element: resolvedElement,
+        spec: props.spec,
+        registry: props.registry,
+        loading: props.loading,
+        fallback: props.fallback
+      }) : resolvedElement.children?.map((childKey) => {
+        const childElement = props.spec.elements[childKey];
+        if (!childElement) {
+          if (!props.loading) {
+            console.warn(
+              `[json-render] Missing element "${childKey}" referenced as child of "${resolvedElement.type}". This element will not render.`
+            );
+          }
+          return null;
+        }
+        return h2(ElementRenderer, {
+          key: childKey,
+          element: childElement,
+          spec: props.spec,
+          registry: props.registry,
+          loading: props.loading,
+          fallback: props.fallback
+        });
+      }).filter((n) => n !== null) ?? void 0;
+      return h2(
+        ElementErrorBoundary,
+        { elementType: resolvedElement.type },
+        {
+          default: () => h2(
+            Component,
+            {
+              element: resolvedElement,
+              emit: emitEvent,
+              on: onEvent,
+              bindings: elementBindings,
+              loading: props.loading
+            },
+            { default: () => childrenVNodes }
+          )
+        }
+      );
+    };
+  }
+});
+var RepeatChildren = defineComponent6({
+  name: "JsonRenderRepeatChildren",
+  props: {
+    element: {
+      type: Object,
+      required: true
+    },
+    spec: {
+      type: Object,
+      required: true
+    },
+    registry: {
+      type: Object,
+      required: true
+    },
+    loading: {
+      type: Boolean,
+      default: void 0
+    },
+    fallback: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup(props) {
+    const { state } = useStateStore();
+    return () => {
+      const repeat = props.element.repeat;
+      if (!repeat?.statePath) return null;
+      const statePath = repeat.statePath;
+      const raw = getByPath3(state.value, statePath);
+      const items = Array.isArray(raw) ? raw : [];
+      return items.map((itemValue, index) => {
+        const key = repeat.key && typeof itemValue === "object" && itemValue !== null ? String(
+          itemValue[repeat.key] ?? index
+        ) : String(index);
+        return h2(
+          RepeatScopeProvider,
+          { key, item: itemValue, index, basePath: `${statePath}/${index}` },
+          {
+            default: () => props.element.children?.map((childKey) => {
+              const childElement = props.spec.elements[childKey];
+              if (!childElement) {
+                if (!props.loading) {
+                  console.warn(
+                    `[json-render] Missing element "${childKey}" referenced as child of "${props.element.type}" (repeat). This element will not render.`
+                  );
+                }
+                return null;
+              }
+              return h2(ElementRenderer, {
+                key: childKey,
+                element: childElement,
+                spec: props.spec,
+                registry: props.registry,
+                loading: props.loading,
+                fallback: props.fallback
+              });
+            }).filter((n) => n !== null) ?? null
+          }
+        );
+      });
+    };
+  }
+});
+var Renderer = defineComponent6({
+  name: "JsonRenderer",
+  props: {
+    spec: {
+      type: Object,
+      default: null
+    },
+    registry: {
+      type: Object,
+      required: true
+    },
+    loading: {
+      type: Boolean,
+      default: void 0
+    },
+    fallback: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup(props) {
+    return () => {
+      if (!props.spec?.root) return null;
+      const rootElement = props.spec.elements[props.spec.root];
+      if (!rootElement) return null;
+      return h2(ElementRenderer, {
+        element: rootElement,
+        spec: props.spec,
+        registry: props.registry,
+        loading: props.loading,
+        fallback: props.fallback
+      });
+    };
+  }
+});
+var ConfirmationDialogManager = defineComponent6({
+  name: "ConfirmationDialogManager",
+  setup() {
+    const { pendingConfirmation, confirm, cancel } = useActions();
+    return () => {
+      if (!pendingConfirmation?.action.confirm) return null;
+      return h2(ConfirmDialog, {
+        confirm: pendingConfirmation.action.confirm,
+        onConfirm: confirm,
+        onCancel: cancel
+      });
+    };
+  }
+});
+var JSONUIProvider = defineComponent6({
+  name: "JSONUIProvider",
+  props: {
+    registry: {
+      type: Object,
+      required: true
+    },
+    store: {
+      type: Object,
+      default: void 0
+    },
+    initialState: {
+      type: Object,
+      default: void 0
+    },
+    handlers: {
+      type: Object,
+      default: void 0
+    },
+    navigate: {
+      type: Function,
+      default: void 0
+    },
+    validationFunctions: {
+      type: Object,
+      default: void 0
+    },
+    functions: {
+      type: Object,
+      default: void 0
+    },
+    onStateChange: {
+      type: Function,
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    return () => h2(
+      StateProvider,
+      {
+        store: props.store,
+        initialState: props.initialState,
+        onStateChange: props.onStateChange
+      },
+      {
+        default: () => h2(VisibilityProvider, null, {
+          default: () => h2(
+            ValidationProvider,
+            { customFunctions: props.validationFunctions },
+            {
+              default: () => h2(
+                ActionProvider,
+                { handlers: props.handlers, navigate: props.navigate },
+                {
+                  default: () => h2(
+                    FunctionsProvider,
+                    { functions: props.functions },
+                    {
+                      default: () => [
+                        slots.default?.(),
+                        h2(ConfirmationDialogManager)
+                      ]
+                    }
+                  )
+                }
+              )
+            }
+          )
+        })
+      }
+    );
+  }
+});
+function defineRegistry(_catalog, options) {
+  const registry = {};
+  if (options.components) {
+    for (const [name, componentFn] of Object.entries(options.components)) {
+      registry[name] = defineComponent6({
+        name: `JsonRenderRegistry_${name}`,
+        props: {
+          element: {
+            type: Object,
+            required: true
+          },
+          emit: {
+            type: Function,
+            required: true
+          },
+          on: {
+            type: Function,
+            required: true
+          },
+          bindings: {
+            type: Object,
+            default: void 0
+          },
+          loading: {
+            type: Boolean,
+            default: void 0
+          }
+        },
+        setup(registryProps, { slots }) {
+          return () => componentFn({
+            props: registryProps.element.props,
+            children: slots.default?.(),
+            emit: registryProps.emit,
+            on: registryProps.on,
+            bindings: registryProps.bindings,
+            loading: registryProps.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 };
+}
+function createRenderer(catalog, components) {
+  const registry = components;
+  return defineComponent6({
+    name: "CatalogRenderer",
+    props: {
+      spec: {
+        type: Object,
+        default: null
+      },
+      store: {
+        type: Object,
+        default: void 0
+      },
+      state: {
+        type: Object,
+        default: void 0
+      },
+      onAction: {
+        type: Function,
+        default: void 0
+      },
+      onStateChange: {
+        type: Function,
+        default: void 0
+      },
+      functions: {
+        type: Object,
+        default: void 0
+      },
+      loading: {
+        type: Boolean,
+        default: void 0
+      },
+      fallback: {
+        type: Object,
+        default: void 0
+      }
+    },
+    setup(rendererProps) {
+      return () => {
+        const actionHandlers = rendererProps.onAction ? new Proxy(
+          {},
+          {
+            get: (_target, prop) => {
+              return (params) => rendererProps.onAction(prop, params);
+            },
+            has: () => true
+          }
+        ) : void 0;
+        return h2(
+          StateProvider,
+          {
+            store: rendererProps.store,
+            initialState: rendererProps.state,
+            onStateChange: rendererProps.onStateChange
+          },
+          {
+            default: () => h2(VisibilityProvider, null, {
+              default: () => h2(ValidationProvider, null, {
+                default: () => h2(
+                  ActionProvider,
+                  { handlers: actionHandlers },
+                  {
+                    default: () => h2(
+                      FunctionsProvider,
+                      { functions: rendererProps.functions },
+                      {
+                        default: () => [
+                          h2(Renderer, {
+                            spec: rendererProps.spec,
+                            registry,
+                            loading: rendererProps.loading,
+                            fallback: rendererProps.fallback
+                          }),
+                          h2(ConfirmationDialogManager)
+                        ]
+                      }
+                    )
+                  }
+                )
+              })
+            })
+          }
+        );
+      };
+    }
+  });
+}
+export {
+  ActionProvider,
+  ConfirmDialog,
+  JSONUIProvider,
+  Renderer,
+  RepeatScopeProvider,
+  StateProvider,
+  ValidationProvider,
+  VisibilityProvider,
+  buildSpecFromParts,
+  createRenderer,
+  createStateStore2 as createStateStore,
+  defineRegistry,
+  flatToTree,
+  getTextFromParts,
+  schema,
+  useAction,
+  useActions,
+  useBoundProp,
+  useChatUI,
+  useFieldValidation,
+  useIsVisible,
+  useJsonRenderMessage,
+  useOptionalValidation,
+  useRepeatScope,
+  useStateBinding,
+  useStateStore,
+  useStateValue,
+  useUIStream,
+  useValidation,
+  useVisibility
+};
+//# sourceMappingURL=index.mjs.map