@character-foundry/character-foundry 0.1.3 → 0.1.6

package/dist/app-framework.js

@@ -1,2 +1,1836 @@
-export * from '@character-foundry/app-framework';
+// ../app-framework/dist/index.js
+import { useMemo as useMemo2, useEffect as useEffect2, useCallback as useCallback5, useRef as useRef3, useState as useState5 } from "react";
+import "zod";
+import { useForm, Controller, FormProvider } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { z } from "zod";
+import { createContext, useContext } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+import { useState, useCallback, useRef, useEffect, useMemo } from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+import { useState as useState2, useCallback as useCallback2 } from "react";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+import { useState as useState3, useCallback as useCallback3 } from "react";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+import { useState as useState4, useCallback as useCallback4, useRef as useRef2 } from "react";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+import { useState as useState6, useCallback as useCallback6 } from "react";
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+var noopServices = {
+  toast: {
+    success: () => {
+    },
+    error: () => {
+    },
+    info: () => {
+    },
+    warning: () => {
+    }
+  },
+  dialog: {
+    confirm: async () => false,
+    alert: async () => {
+    },
+    prompt: async () => null
+  },
+  events: {
+    emit: () => {
+    },
+    on: () => () => {
+    },
+    once: () => () => {
+    }
+  }
+};
+var Registry = class {
+  items = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * Register an item with the given ID.
+   * Overwrites existing item with same ID (with warning).
+   */
+  register(id, item) {
+    if (this.items.has(id)) {
+      console.warn(`Registry: Overwriting existing item with id "${id}"`);
+    }
+    this.items.set(id, item);
+    this.notify(id, item, "register");
+  }
+  /**
+   * Unregister an item by ID.
+   * @returns true if item existed and was removed
+   */
+  unregister(id) {
+    const existed = this.items.delete(id);
+    if (existed) {
+      this.notify(id, null, "unregister");
+    }
+    return existed;
+  }
+  /**
+   * Get an item by ID.
+   * @returns The item or undefined if not found
+   */
+  get(id) {
+    return this.items.get(id);
+  }
+  /**
+   * Check if an item with the given ID exists.
+   */
+  has(id) {
+    return this.items.has(id);
+  }
+  /**
+   * Get all registered items as a Map.
+   * Returns a copy to prevent external modification.
+   */
+  getAll() {
+    return new Map(this.items);
+  }
+  /**
+   * Get all registered item IDs.
+   */
+  getAllIds() {
+    return Array.from(this.items.keys());
+  }
+  /**
+   * Get the number of registered items.
+   */
+  get size() {
+    return this.items.size;
+  }
+  /**
+   * Subscribe to registry changes.
+   * @returns Unsubscribe function
+   */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /**
+   * Clear all registered items.
+   * Notifies listeners for each removed item.
+   */
+  clear() {
+    const ids = this.getAllIds();
+    this.items.clear();
+    ids.forEach((id) => this.notify(id, null, "unregister"));
+  }
+  /**
+   * Iterate over all items.
+   */
+  forEach(callback) {
+    this.items.forEach((item, id) => callback(item, id));
+  }
+  /**
+   * Find items matching a predicate.
+   */
+  filter(predicate) {
+    const results = [];
+    this.items.forEach((item, id) => {
+      if (predicate(item, id)) {
+        results.push(item);
+      }
+    });
+    return results;
+  }
+  notify(id, item, action) {
+    this.listeners.forEach((listener) => listener(id, item, action));
+  }
+};
+var SettingsRegistry = class extends Registry {
+  /**
+   * Register a settings panel.
+   */
+  registerPanel(panel) {
+    super.register(panel.id, panel);
+  }
+  /**
+   * Get all panels sorted by order (lower order = earlier).
+   * Hidden panels are excluded.
+   */
+  getSortedPanels() {
+    return Array.from(this.getAll().values()).filter((panel) => !panel.hidden).sort((a, b) => (a.order ?? 100) - (b.order ?? 100));
+  }
+  /**
+   * Get a panel by ID with proper typing.
+   */
+  getPanel(id) {
+    return this.get(id);
+  }
+};
+var settingsRegistry = new SettingsRegistry();
+var ProviderRegistry = class extends Registry {
+  constructor(providerType) {
+    super();
+    this.providerType = providerType;
+  }
+  /**
+   * Register a provider.
+   */
+  registerProvider(provider) {
+    super.register(
+      provider.id,
+      provider
+    );
+  }
+  /**
+   * Get a provider by ID with proper typing.
+   */
+  getProvider(id) {
+    return this.get(id);
+  }
+  /**
+   * Create a client instance for a provider.
+   * Validates config against schema and runs custom validation if provided.
+   *
+   * @throws Error if provider not found, config invalid, or custom validation fails
+   */
+  async createClient(providerId, config) {
+    const provider = this.get(providerId);
+    if (!provider) {
+      throw new Error(
+        `Provider "${providerId}" not found${this.providerType ? ` in ${this.providerType} registry` : ""}`
+      );
+    }
+    const result = provider.configSchema.safeParse(config);
+    if (!result.success) {
+      throw new Error(`Invalid provider config: ${result.error.message}`);
+    }
+    if (provider.validateConfig) {
+      const validation = await provider.validateConfig(result.data);
+      if (!validation.valid) {
+        throw new Error(validation.error ?? "Provider config validation failed");
+      }
+    }
+    return provider.createClient(result.data);
+  }
+  /**
+   * Get all providers as an array.
+   */
+  getAllProviders() {
+    return Array.from(this.getAll().values());
+  }
+};
+function createProviderRegistry(providerType) {
+  return new ProviderRegistry(providerType);
+}
+var WidgetRegistry = class extends Registry {
+  /**
+   * Register a custom widget.
+   */
+  registerWidget(definition) {
+    super.register(definition.id, definition);
+  }
+  /**
+   * Register a widget component directly with just an ID.
+   */
+  registerComponent(id, component) {
+    super.register(id, { id, component });
+  }
+  /**
+   * Get a widget component by ID.
+   * Returns the component directly, not the definition.
+   */
+  getComponent(id) {
+    return this.get(id)?.component;
+  }
+  /**
+   * Check if a widget ID is a built-in widget type.
+   * This list must stay in sync with the BuiltinWidget type in ui-hints.ts.
+   */
+  isBuiltinWidget(id) {
+    const builtins = [
+      "text",
+      "number",
+      "password",
+      "textarea",
+      "switch",
+      "checkbox",
+      "select",
+      "radio",
+      "slider",
+      "color-picker",
+      "tag-input",
+      "searchable-select",
+      "file-upload"
+    ];
+    return builtins.includes(id);
+  }
+};
+var widgetRegistry = new WidgetRegistry();
+function analyzeSchema(schema, prefix = "") {
+  const shape = schema.shape;
+  const fields = /* @__PURE__ */ new Map();
+  for (const [name, zodType] of Object.entries(shape)) {
+    const fullName = prefix ? `${prefix}.${name}` : name;
+    fields.set(fullName, analyzeField(fullName, zodType));
+  }
+  return fields;
+}
+function flattenSchema(schema, prefix = "") {
+  const fields = /* @__PURE__ */ new Map();
+  const shape = schema.shape;
+  for (const [name, zodType] of Object.entries(shape)) {
+    const fullName = prefix ? `${prefix}.${name}` : name;
+    const fieldInfo = analyzeField(fullName, zodType);
+    fields.set(fullName, fieldInfo);
+    if (fieldInfo.typeName === "ZodObject" && fieldInfo.innerSchema) {
+      const nestedFields = flattenSchema(fieldInfo.innerSchema, fullName);
+      for (const [nestedName, nestedInfo] of nestedFields) {
+        fields.set(nestedName, nestedInfo);
+      }
+    }
+  }
+  return fields;
+}
+function analyzeField(name, zodType) {
+  let currentType = zodType;
+  let isOptional = false;
+  let isNullable = false;
+  let defaultValue;
+  const description = getDescription(zodType);
+  if (currentType instanceof z.ZodOptional) {
+    isOptional = true;
+    currentType = currentType.unwrap();
+  }
+  if (currentType instanceof z.ZodNullable) {
+    isNullable = true;
+    currentType = currentType.unwrap();
+  }
+  if (currentType instanceof z.ZodDefault) {
+    defaultValue = currentType._def.defaultValue();
+    currentType = currentType._def.innerType;
+  }
+  if (currentType instanceof z.ZodEffects) {
+    currentType = currentType._def.schema;
+  }
+  if (currentType instanceof z.ZodUnion) {
+    const options = currentType._def.options;
+    if (options.length > 0 && options[0]) {
+      currentType = options[0];
+    }
+  }
+  if (currentType instanceof z.ZodDiscriminatedUnion) {
+  }
+  if (currentType instanceof z.ZodRecord) {
+  }
+  if (currentType instanceof z.ZodSet) {
+  }
+  const typeName = currentType.constructor.name;
+  let nestedFields;
+  let innerSchema;
+  if (currentType instanceof z.ZodObject) {
+    innerSchema = currentType;
+    nestedFields = /* @__PURE__ */ new Map();
+    const shape = currentType.shape;
+    for (const [childName, childType] of Object.entries(shape)) {
+      nestedFields.set(
+        childName,
+        analyzeField(`${name}.${childName}`, childType)
+      );
+    }
+  }
+  return {
+    name,
+    zodType: currentType,
+    typeName,
+    isOptional,
+    isNullable,
+    defaultValue,
+    description,
+    enumValues: extractEnumValues(currentType),
+    innerType: extractInnerType(name, currentType),
+    nestedFields,
+    innerSchema,
+    constraints: extractConstraints(currentType)
+  };
+}
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isSafeKey(key) {
+  return !DANGEROUS_KEYS.has(key);
+}
+function getValueAtPath(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (!isSafeKey(part)) {
+      return void 0;
+    }
+    if (current == null || typeof current !== "object") {
+      return void 0;
+    }
+    if (!Object.hasOwn(current, part)) {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function setValueAtPath(obj, path, value) {
+  const parts = path.split(".");
+  if (parts.length === 0 || parts[0] === void 0) {
+    return obj;
+  }
+  const first = parts[0];
+  if (!isSafeKey(first)) {
+    console.warn(`Rejected dangerous property key in path: ${first}`);
+    return obj;
+  }
+  if (parts.length === 1) {
+    return { ...obj, [first]: value };
+  }
+  const rest = parts.slice(1);
+  const nested = (Object.hasOwn(obj, first) ? obj[first] : {}) ?? {};
+  return {
+    ...obj,
+    [first]: setValueAtPath(nested, rest.join("."), value)
+  };
+}
+function getDescription(zodType) {
+  return zodType._def?.description;
+}
+function extractEnumValues(zodType) {
+  if (zodType instanceof z.ZodEnum) {
+    return zodType._def.values;
+  }
+  if (zodType instanceof z.ZodNativeEnum) {
+    const values = zodType._def.values;
+    return Object.values(values).filter(
+      (v) => typeof v === "string"
+    );
+  }
+  return void 0;
+}
+function extractInnerType(name, zodType) {
+  if (zodType instanceof z.ZodArray) {
+    return analyzeField(`${name}[]`, zodType._def.type);
+  }
+  if (zodType instanceof z.ZodSet) {
+    return analyzeField(`${name}[]`, zodType._def.valueType);
+  }
+  return void 0;
+}
+function extractConstraints(zodType) {
+  const constraints = {};
+  const checks = zodType._def?.checks;
+  if (!Array.isArray(checks)) {
+    return void 0;
+  }
+  for (const check of checks) {
+    switch (check.kind) {
+      case "min":
+        if (zodType instanceof z.ZodString) {
+          constraints.minLength = check.value;
+        } else {
+          constraints.min = check.value;
+        }
+        break;
+      case "max":
+        if (zodType instanceof z.ZodString) {
+          constraints.maxLength = check.value;
+        } else {
+          constraints.max = check.value;
+        }
+        break;
+      case "length":
+        constraints.minLength = check.value;
+        constraints.maxLength = check.value;
+        break;
+      case "email":
+        constraints.email = true;
+        break;
+      case "url":
+        constraints.url = true;
+        break;
+      case "uuid":
+        constraints.uuid = true;
+        break;
+      case "regex":
+        constraints.regex = check.value;
+        break;
+      case "int":
+        constraints.int = true;
+        break;
+      case "multipleOf":
+        constraints.multipleOf = check.value;
+        break;
+    }
+  }
+  if (zodType instanceof z.ZodNumber) {
+    const minCheck = checks.find((c) => c.kind === "min");
+    if (minCheck && minCheck.inclusive === false && minCheck.value === 0) {
+      constraints.positive = true;
+    }
+    const maxCheck = checks.find((c) => c.kind === "max");
+    if (maxCheck && maxCheck.inclusive === false && maxCheck.value === 0) {
+      constraints.negative = true;
+    }
+  }
+  return Object.keys(constraints).length > 0 ? constraints : void 0;
+}
+function getDefaultWidgetType(fieldInfo) {
+  const { typeName, description, enumValues, innerType, constraints } = fieldInfo;
+  if (description) {
+    const lowerDesc = description.toLowerCase();
+    if (lowerDesc.includes("password") || lowerDesc.includes("secret") || lowerDesc.includes("api key") || lowerDesc.includes("apikey") || lowerDesc.includes("token")) {
+      return "password";
+    }
+  }
+  if (constraints?.email) return "text";
+  if (constraints?.url) return "text";
+  switch (typeName) {
+    case "ZodString":
+      return "text";
+    case "ZodNumber":
+      return "number";
+    case "ZodBoolean":
+      return "switch";
+    case "ZodEnum":
+    case "ZodNativeEnum":
+      if (enumValues) {
+        if (enumValues.length <= 4) return "radio";
+        if (enumValues.length > 10) return "searchable-select";
+      }
+      return "select";
+    case "ZodArray":
+      if (innerType?.typeName === "ZodString") {
+        return "tag-input";
+      }
+      return "text";
+    // Fallback
+    case "ZodSet":
+      if (innerType?.typeName === "ZodString") {
+        return "tag-input";
+      }
+      return "text";
+    // Fallback
+    case "ZodObject":
+      return "nested";
+    // Special marker for nested objects
+    case "ZodRecord":
+      return "text";
+    // Records need custom widgets or JSON editor
+    case "ZodDiscriminatedUnion":
+      return "select";
+    // Use discriminator field to select variant
+    case "ZodDate":
+      return "text";
+    // Could be 'date' widget
+    default:
+      return "text";
+  }
+}
+function isSecretField(fieldInfo) {
+  if (!fieldInfo.description) return false;
+  const lowerDesc = fieldInfo.description.toLowerCase();
+  return lowerDesc.includes("password") || lowerDesc.includes("secret") || lowerDesc.includes("api key") || lowerDesc.includes("apikey") || lowerDesc.includes("token") || lowerDesc.includes("credential");
+}
+function isNestedObject(fieldInfo) {
+  return fieldInfo.typeName === "ZodObject" && fieldInfo.nestedFields != null;
+}
+var WidgetRegistryContext = createContext(widgetRegistry);
+function useWidgetRegistry() {
+  return useContext(WidgetRegistryContext);
+}
+function TextInput({
+  value,
+  onChange,
+  name,
+  label,
+  error,
+  disabled,
+  required,
+  hint
+}) {
+  const id = `field-${name}`;
+  const errorId = `${id}-error`;
+  const helperId = `${id}-helper`;
+  const hasError = Boolean(error);
+  const hasHelper = Boolean(hint?.helperText);
+  return /* @__PURE__ */ jsxs("div", { className: hint?.className, "data-field": name, "data-error": hasError, children: [
+    label && /* @__PURE__ */ jsxs("label", { htmlFor: id, children: [
+      label,
+      required && /* @__PURE__ */ jsx("span", { "aria-hidden": "true", "data-required": true, children: "*" })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        id,
+        type: "text",
+        name,
+        value: value ?? "",
+        onChange: (e) => onChange(e.target.value),
+        disabled,
+        placeholder: hint?.placeholder,
+        "aria-invalid": hasError,
+        "aria-describedby": [hasError && errorId, hasHelper && helperId].filter(Boolean).join(" ") || void 0,
+        "aria-required": required,
+        readOnly: hint?.readOnly,
+        minLength: hint?.min,
+        maxLength: hint?.max
+      }
+    ),
+    hasHelper && /* @__PURE__ */ jsx("p", { id: helperId, "data-helper": true, children: hint?.helperText }),
+    hasError && /* @__PURE__ */ jsx("p", { id: errorId, role: "alert", "data-error-message": true, children: error })
+  ] });
+}
+function Textarea({
+  value,
+  onChange,
+  name,
+  label,
+  error,
+  disabled,
+  required,
+  hint
+}) {
+  const id = `field-${name}`;
+  const errorId = `${id}-error`;
+  const helperId = `${id}-helper`;
+  const hasError = Boolean(error);
+  const hasHelper = Boolean(hint?.helperText);
+  const rows = hint?.rows ?? 4;
+  return /* @__PURE__ */ jsxs2("div", { className: hint?.className, "data-field": name, "data-error": hasError, children: [
+    label && /* @__PURE__ */ jsxs2("label", { htmlFor: id, children: [
+      label,
+      required && /* @__PURE__ */ jsx2("span", { "aria-hidden": "true", "data-required": true, children: "*" })
+    ] }),
+    /* @__PURE__ */ jsx2(
+      "textarea",
+      {
+        id,
+        name,
+        value: value ?? "",
+        onChange: (e) => onChange(e.target.value),
+        disabled,
+        readOnly: hint?.readOnly,
+        placeholder: hint?.placeholder,
+        rows,
+        minLength: hint?.min,
+        maxLength: hint?.max,
+        "aria-invalid": hasError,
+        "aria-describedby": [hasError && errorId, hasHelper && helperId].filter(Boolean).join(" ") || void 0,
+        "aria-required": required,
+        "data-textarea": true
+      }
+    ),
+    hasHelper && /* @__PURE__ */ jsx2("p", { id: helperId, "data-helper": true, children: hint?.helperText }),
+    hasError && /* @__PURE__ */ jsx2("p", { id: errorId, role: "alert", "data-error-message": true, children: error })
+  ] });
+}
+function NumberInput({
+  value,
+  onChange,
+  name,
+  label,
+  error,
+  disabled,
+  required,
+  hint
+}) {
+  const id = `field-${name}`;
+  const errorId = `${id}-error`;
+  const helperId = `${id}-helper`;
+  const hasError = Boolean(error);
+  const hasHelper = Boolean(hint?.helperText);
+  const handleChange = (e) => {
+    const val = e.target.value;
+    if (val === "") {
+      onChange(void 0);
+    } else {
+      const num = parseFloat(val);
+      if (!isNaN(num)) {
+        onChange(num);
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs3("div", { className: hint?.className, "data-field": name, "data-error": hasError, children: [
+    label && /* @__PURE__ */ jsxs3("label", { htmlFor: id, children: [
+      label,
+      required && /* @__PURE__ */ jsx3("span", { "aria-hidden": "true", "data-required": true, children: "*" })
+    ] }),
+    /* @__PURE__ */ jsx3(
+      "input",
+      {
+        id,
+        type: "number",
+        name,
+        value: value ?? "",
+        onChange: handleChange,
+        disabled,
+        placeholder: hint?.placeholder,
+        "aria-invalid": hasError,
+        "aria-describedby": [hasError && errorId, hasHelper && helperId].filter(Boolean).join(" ") || void 0,
+        "aria-required": required,
+        readOnly: hint?.readOnly,
+        min: hint?.min,
+        max: hint?.max,
+        step: hint?.step
+      }
+    ),
+    hasHelper && /* @__PURE__ */ jsx3("p", { id: helperId, "data-helper": true, children: hint?.helperText }),
+    hasError && /* @__PURE__ */ jsx3("p", { id: errorId, role: "alert", "data-error-message": true, children: error })
+  ] });
+}
+function Switch({
+  value,
+  onChange,
+  name,
+  label,
+  error,
+  disabled,
+  hint
+}) {
+  const id = `field-${name}`;
+  const errorId = `${id}-error`;
+  const helperId = `${id}-helper`;
+  const hasError = Boolean(error);
+  const hasHelper = Boolean(hint?.helperText);
+  return /* @__PURE__ */ jsxs4("div", { className: hint?.className, "data-field": name, "data-error": hasError, children: [
+    /* @__PURE__ */ jsxs4("label", { htmlFor: id, children: [
+      /* @__PURE__ */ jsx4(
+        "input",
+        {
+          id,
+          type: "checkbox",
+          role: "switch",
+          name,
+          checked: value ?? false,
+          onChange: (e) => onChange(e.target.checked),
+          disabled: disabled || hint?.readOnly,
+          "aria-invalid": hasError,
+          "aria-describedby": [hasError && errorId, hasHelper && helperId].filter(Boolean).join(" ") || void 0
+        }
+      ),
+      /* @__PURE__ */ jsx4("span", { "data-switch-label": true, children: label })
+    ] }),
+    hasHelper && /* @__PURE__ */ jsx4("p", { id: helperId, "data-helper": true, children: hint?.helperText }),
+    hasError && /* @__PURE__ */ jsx4("p", { id: errorId, role: "alert", "data-error-message": true, children: error })
+  ] });
+}
+function Select({
+  value,
+  onChange,
+  name,
+  label,
+  error,
+  disabled,
+  required,
+  hint
+}) {
+  const id = `field-${name}`;
+  const errorId = `${id}-error`;
+  const helperId = `${id}-helper`;
+  const hasError = Boolean(error);
+  const hasHelper = Boolean(hint?.helperText);
+  const options = hint?.options ?? [];
+  return /* @__PURE__ */ jsxs5("div", { className: hint?.className, "data-field": name, "data-error": hasError, children: [
+    label && /* @__PURE__ */ jsxs5("label", { htmlFor: id, children: [
+      label,
+      required && /* @__PURE__ */ jsx5("span", { "aria-hidden": "true", "data-required": true, children: "*" })
+    ] }),
+    /* @__PURE__ */ jsxs5(
+      "select",
+      {
+        id,
+        name,
+        value: value ?? "",
+        onChange: (e) => onChange(e.target.value),
+        disabled: disabled || hint?.readOnly,
+        "aria-invalid": hasError,
+        "aria-describedby": [hasError && errorId, hasHelper && helperId].filter(Boolean).join(" ") || void 0,
+        "aria-required": required,
+        children: [
+          !required && /* @__PURE__ */ jsx5("option", { value: "", children: "-- Select --" }),
+          options.map((opt) => /* @__PURE__ */ jsx5("option", { value: opt.value, children: opt.label }, opt.value))
+        ]
+      }
+    ),
+    hasHelper && /* @__PURE__ */ jsx5("p", { id: helperId, "data-helper": true, children: hint?.helperText }),
+    hasError && /* @__PURE__ */ jsx5("p", { id: errorId, role: "alert", "data-error-message": true, children: error })
+  ] });
+}
+function SearchableSelect({
+  value,
+  onChange,
+  name,
+  label,
+  error,
+  disabled,
+  required,
+  hint
+}) {
+  const id = `field-${name}`;
+  const errorId = `${id}-error`;
+  const helperId = `${id}-helper`;
+  const listboxId = `${id}-listbox`;
+  const hasError = Boolean(error);
+  const hasHelper = Boolean(hint?.helperText);
+  const containerRef = useRef(null);
+  const inputRef = useRef(null);
+  const listRef = useRef(null);
+  const [isOpen, setIsOpen] = useState(false);
+  const [searchTerm, setSearchTerm] = useState("");
+  const [highlightedIndex, setHighlightedIndex] = useState(-1);
+  const rawOptions = hint?.options ?? [];
+  const indexedOptions = useMemo(() => {
+    return rawOptions.map((opt) => ({
+      option: opt,
+      labelLower: opt.label.toLowerCase(),
+      valueLower: opt.value.toLowerCase()
+    }));
+  }, [rawOptions]);
+  const optionsByValue = useMemo(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const opt of rawOptions) {
+      map.set(opt.value, opt);
+    }
+    return map;
+  }, [rawOptions]);
+  const filteredOptions = useMemo(() => {
+    if (!searchTerm) {
+      return rawOptions;
+    }
+    const searchLower = searchTerm.toLowerCase();
+    return indexedOptions.filter(
+      (indexed) => indexed.labelLower.includes(searchLower) || indexed.valueLower.includes(searchLower)
+    ).map((indexed) => indexed.option);
+  }, [searchTerm, indexedOptions, rawOptions]);
+  const selectedOption = optionsByValue.get(value ?? "");
+  const displayValue = selectedOption?.label ?? value ?? "";
+  useEffect(() => {
+    function handleClickOutside(e) {
+      if (containerRef.current && !containerRef.current.contains(e.target)) {
+        setIsOpen(false);
+        setSearchTerm("");
+      }
+    }
+    document.addEventListener("mousedown", handleClickOutside);
+    return () => document.removeEventListener("mousedown", handleClickOutside);
+  }, []);
+  useEffect(() => {
+    if (isOpen && highlightedIndex >= 0 && listRef.current) {
+      const item = listRef.current.children[highlightedIndex];
+      item?.scrollIntoView({ block: "nearest" });
+    }
+  }, [highlightedIndex, isOpen]);
+  const handleOpen = useCallback(() => {
+    if (!disabled && !hint?.readOnly) {
+      setIsOpen(true);
+      setSearchTerm("");
+      setHighlightedIndex(-1);
+      setTimeout(() => inputRef.current?.focus(), 0);
+    }
+  }, [disabled, hint?.readOnly]);
+  const handleSelect = useCallback(
+    (optionValue) => {
+      onChange(optionValue);
+      setIsOpen(false);
+      setSearchTerm("");
+    },
+    [onChange]
+  );
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (disabled || hint?.readOnly) return;
+      switch (e.key) {
+        case "Enter":
+          e.preventDefault();
+          if (!isOpen) {
+            handleOpen();
+          } else if (highlightedIndex >= 0 && filteredOptions[highlightedIndex]) {
+            handleSelect(filteredOptions[highlightedIndex].value);
+          }
+          break;
+        case "Escape":
+          e.preventDefault();
+          setIsOpen(false);
+          setSearchTerm("");
+          break;
+        case "ArrowDown":
+          e.preventDefault();
+          if (!isOpen) {
+            handleOpen();
+          } else {
+            setHighlightedIndex(
+              (prev) => prev < filteredOptions.length - 1 ? prev + 1 : 0
+            );
+          }
+          break;
+        case "ArrowUp":
+          e.preventDefault();
+          if (isOpen) {
+            setHighlightedIndex(
+              (prev) => prev > 0 ? prev - 1 : filteredOptions.length - 1
+            );
+          }
+          break;
+        case "Home":
+          if (isOpen) {
+            e.preventDefault();
+            setHighlightedIndex(0);
+          }
+          break;
+        case "End":
+          if (isOpen) {
+            e.preventDefault();
+            setHighlightedIndex(filteredOptions.length - 1);
+          }
+          break;
+      }
+    },
+    [disabled, filteredOptions, handleOpen, handleSelect, highlightedIndex, hint?.readOnly, isOpen]
+  );
+  const handleSearchChange = useCallback((e) => {
+    setSearchTerm(e.target.value);
+    setHighlightedIndex(-1);
+  }, []);
+  const noResultsText = hint?.noResultsText ?? "No results found";
+  const searchPlaceholder = hint?.searchPlaceholder ?? "Search...";
+  return /* @__PURE__ */ jsxs6(
+    "div",
+    {
+      ref: containerRef,
+      className: hint?.className,
+      "data-field": name,
+      "data-error": hasError,
+      onKeyDown: handleKeyDown,
+      children: [
+        label && /* @__PURE__ */ jsxs6("label", { id: `${id}-label`, children: [
+          label,
+          required && /* @__PURE__ */ jsx6("span", { "aria-hidden": "true", "data-required": true, children: "*" })
+        ] }),
+        /* @__PURE__ */ jsxs6("div", { "data-searchable-select": true, "data-open": isOpen, "data-disabled": disabled || hint?.readOnly, children: [
+          /* @__PURE__ */ jsxs6(
+            "button",
+            {
+              type: "button",
+              id,
+              onClick: handleOpen,
+              disabled,
+              "aria-haspopup": "listbox",
+              "aria-expanded": isOpen,
+              "aria-labelledby": `${id}-label`,
+              "aria-describedby": [hasError && errorId, hasHelper && helperId].filter(Boolean).join(" ") || void 0,
+              "aria-invalid": hasError,
+              "data-searchable-select-trigger": true,
+              children: [
+                /* @__PURE__ */ jsx6("span", { "data-searchable-select-value": true, children: displayValue || hint?.placeholder || "Select..." }),
+                /* @__PURE__ */ jsx6("span", { "data-searchable-select-arrow": true, "aria-hidden": "true", children: isOpen ? "\u25B2" : "\u25BC" })
+              ]
+            }
+          ),
+          isOpen && /* @__PURE__ */ jsxs6("div", { "data-searchable-select-dropdown": true, children: [
+            /* @__PURE__ */ jsx6(
+              "input",
+              {
+                ref: inputRef,
+                type: "text",
+                value: searchTerm,
+                onChange: handleSearchChange,
+                placeholder: searchPlaceholder,
+                "aria-label": "Search options",
+                "data-searchable-select-input": true
+              }
+            ),
+            /* @__PURE__ */ jsx6(
+              "ul",
+              {
+                ref: listRef,
+                id: listboxId,
+                role: "listbox",
+                "aria-labelledby": `${id}-label`,
+                "data-searchable-select-list": true,
+                children: filteredOptions.length === 0 ? /* @__PURE__ */ jsx6("li", { "data-searchable-select-no-results": true, children: noResultsText }) : filteredOptions.map((option, index) => /* @__PURE__ */ jsx6(
+                  "li",
+                  {
+                    role: "option",
+                    "aria-selected": option.value === value,
+                    "data-searchable-select-option": true,
+                    "data-selected": option.value === value,
+                    "data-highlighted": index === highlightedIndex,
+                    onClick: () => handleSelect(option.value),
+                    onMouseEnter: () => setHighlightedIndex(index),
+                    children: option.label
+                  },
+                  option.value
+                ))
+              }
+            )
+          ] })
+        ] }),
+        hasHelper && /* @__PURE__ */ jsx6("p", { id: helperId, "data-helper": true, children: hint?.helperText }),
+        hasError && /* @__PURE__ */ jsx6("p", { id: errorId, role: "alert", "data-error-message": true, children: error })
+      ]
+    }
+  );
+}
+function TagInput({
+  value,
+  onChange,
+  name,
+  label,
+  error,
+  disabled,
+  required,
+  hint
+}) {
+  const id = `field-${name}`;
+  const errorId = `${id}-error`;
+  const helperId = `${id}-helper`;
+  const hasError = Boolean(error);
+  const hasHelper = Boolean(hint?.helperText);
+  const tags = value ?? [];
+  const [inputValue, setInputValue] = useState2("");
+  const addTag = useCallback2(
+    (tag) => {
+      const trimmed = tag.trim();
+      if (trimmed && !tags.includes(trimmed)) {
+        onChange([...tags, trimmed]);
+      }
+      setInputValue("");
+    },
+    [tags, onChange]
+  );
+  const removeTag = useCallback2(
+    (index) => {
+      onChange(tags.filter((_, i) => i !== index));
+    },
+    [tags, onChange]
+  );
+  const handleKeyDown = useCallback2(
+    (e) => {
+      if (e.key === "Enter" || e.key === ",") {
+        e.preventDefault();
+        addTag(inputValue);
+      } else if (e.key === "Backspace" && inputValue === "" && tags.length > 0) {
+        removeTag(tags.length - 1);
+      }
+    },
+    [inputValue, tags, addTag, removeTag]
+  );
+  const handleBlur = useCallback2(() => {
+    if (inputValue.trim()) {
+      addTag(inputValue);
+    }
+  }, [inputValue, addTag]);
+  return /* @__PURE__ */ jsxs7("div", { className: hint?.className, "data-field": name, "data-error": hasError, children: [
+    label && /* @__PURE__ */ jsxs7("label", { htmlFor: id, children: [
+      label,
+      required && /* @__PURE__ */ jsx7("span", { "aria-hidden": "true", "data-required": true, children: "*" })
+    ] }),
+    /* @__PURE__ */ jsxs7("div", { "data-tag-container": true, children: [
+      tags.map((tag, index) => /* @__PURE__ */ jsxs7("span", { "data-tag": true, children: [
+        tag,
+        !disabled && !hint?.readOnly && /* @__PURE__ */ jsx7(
+          "button",
+          {
+            type: "button",
+            onClick: () => removeTag(index),
+            "aria-label": `Remove ${tag}`,
+            "data-tag-remove": true,
+            children: "\xD7"
+          }
+        )
+      ] }, `${tag}-${index}`)),
+      /* @__PURE__ */ jsx7(
+        "input",
+        {
+          id,
+          type: "text",
+          value: inputValue,
+          onChange: (e) => setInputValue(e.target.value),
+          onKeyDown: handleKeyDown,
+          onBlur: handleBlur,
+          disabled,
+          readOnly: hint?.readOnly,
+          placeholder: hint?.placeholder ?? "Add tag...",
+          "aria-invalid": hasError,
+          "aria-describedby": [hasError && errorId, hasHelper && helperId].filter(Boolean).join(" ") || void 0,
+          "data-tag-input": true
+        }
+      )
+    ] }),
+    hasHelper && /* @__PURE__ */ jsx7("p", { id: helperId, "data-helper": true, children: hint?.helperText }),
+    hasError && /* @__PURE__ */ jsx7("p", { id: errorId, role: "alert", "data-error-message": true, children: error })
+  ] });
+}
+function SecretInput({
+  value,
+  onChange,
+  name,
+  label,
+  error,
+  disabled,
+  required,
+  hint
+}) {
+  const id = `field-${name}`;
+  const errorId = `${id}-error`;
+  const helperId = `${id}-helper`;
+  const hasError = Boolean(error);
+  const hasHelper = Boolean(hint?.helperText);
+  const [showValue, setShowValue] = useState3(false);
+  const toggleVisibility = useCallback3(() => {
+    setShowValue((prev) => !prev);
+  }, []);
+  return /* @__PURE__ */ jsxs8("div", { className: hint?.className, "data-field": name, "data-error": hasError, children: [
+    label && /* @__PURE__ */ jsxs8("label", { htmlFor: id, children: [
+      label,
+      required && /* @__PURE__ */ jsx8("span", { "aria-hidden": "true", "data-required": true, children: "*" })
+    ] }),
+    /* @__PURE__ */ jsxs8("div", { "data-secret-container": true, children: [
+      /* @__PURE__ */ jsx8(
+        "input",
+        {
+          id,
+          type: showValue ? "text" : "password",
+          name,
+          value: value ?? "",
+          onChange: (e) => onChange(e.target.value),
+          disabled,
+          placeholder: hint?.placeholder,
+          "aria-invalid": hasError,
+          "aria-describedby": [hasError && errorId, hasHelper && helperId].filter(Boolean).join(" ") || void 0,
+          "aria-required": required,
+          readOnly: hint?.readOnly,
+          autoComplete: "off",
+          "data-secret-input": true
+        }
+      ),
+      /* @__PURE__ */ jsx8(
+        "button",
+        {
+          type: "button",
+          onClick: toggleVisibility,
+          disabled,
+          "aria-label": showValue ? "Hide value" : "Show value",
+          "data-secret-toggle": true,
+          children: showValue ? "Hide" : "Show"
+        }
+      )
+    ] }),
+    hasHelper && /* @__PURE__ */ jsx8("p", { id: helperId, "data-helper": true, children: hint?.helperText }),
+    hasError && /* @__PURE__ */ jsx8("p", { id: errorId, role: "alert", "data-error-message": true, children: error })
+  ] });
+}
+function FileUpload({
+  value,
+  onChange,
+  name,
+  label,
+  error,
+  disabled,
+  required,
+  hint
+}) {
+  const id = `field-${name}`;
+  const errorId = `${id}-error`;
+  const helperId = `${id}-helper`;
+  const hasError = Boolean(error);
+  const hasHelper = Boolean(hint?.helperText);
+  const inputRef = useRef2(null);
+  const [isDragging, setIsDragging] = useState4(false);
+  const [localError, setLocalError] = useState4(null);
+  const accept = hint?.accept;
+  const multiple = hint?.multiple ?? false;
+  const maxSize = hint?.maxSize;
+  const validateFiles = useCallback4(
+    (files2) => {
+      const valid = [];
+      const errors = [];
+      for (const file of files2) {
+        if (maxSize && file.size > maxSize) {
+          const maxMB = (maxSize / 1024 / 1024).toFixed(1);
+          errors.push(`${file.name} exceeds ${maxMB}MB limit`);
+          continue;
+        }
+        if (accept) {
+          const acceptedTypes = accept.split(",").map((t) => t.trim());
+          const fileExt = `.${file.name.split(".").pop()?.toLowerCase()}`;
+          const fileMime = file.type;
+          const isAccepted = acceptedTypes.some((type) => {
+            if (type.startsWith(".")) {
+              return fileExt === type.toLowerCase();
+            }
+            if (type.endsWith("/*")) {
+              return fileMime.startsWith(type.replace("/*", "/"));
+            }
+            return fileMime === type;
+          });
+          if (!isAccepted) {
+            errors.push(`${file.name} is not an accepted file type`);
+            continue;
+          }
+        }
+        valid.push(file);
+      }
+      return { valid, errors };
+    },
+    [accept, maxSize]
+  );
+  const handleFiles = useCallback4(
+    (files2) => {
+      if (!files2 || files2.length === 0) {
+        onChange(multiple ? [] : null);
+        setLocalError(null);
+        return;
+      }
+      const fileArray = Array.from(files2);
+      const { valid, errors } = validateFiles(fileArray);
+      if (errors.length > 0) {
+        setLocalError(errors.join(", "));
+      } else {
+        setLocalError(null);
+      }
+      if (valid.length === 0) {
+        onChange(multiple ? [] : null);
+        return;
+      }
+      if (multiple) {
+        onChange(valid);
+      } else {
+        const firstFile = valid[0];
+        onChange(firstFile ?? null);
+      }
+    },
+    [multiple, onChange, validateFiles]
+  );
+  const handleChange = useCallback4(
+    (e) => {
+      handleFiles(e.target.files);
+    },
+    [handleFiles]
+  );
+  const handleDragOver = useCallback4((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragging(true);
+  }, []);
+  const handleDragLeave = useCallback4((e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    setIsDragging(false);
+  }, []);
+  const handleDrop = useCallback4(
+    (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      setIsDragging(false);
+      if (disabled || hint?.readOnly) return;
+      handleFiles(e.dataTransfer.files);
+    },
+    [disabled, handleFiles, hint?.readOnly]
+  );
+  const handleClick = useCallback4(() => {
+    if (!disabled && !hint?.readOnly) {
+      inputRef.current?.click();
+    }
+  }, [disabled, hint?.readOnly]);
+  const handleRemove = useCallback4(
+    (index) => {
+      if (multiple && Array.isArray(value)) {
+        if (index !== void 0) {
+          const newFiles = value.filter((_, i) => i !== index);
+          onChange(newFiles);
+        } else {
+          onChange([]);
+        }
+      } else {
+        onChange(null);
+      }
+      setLocalError(null);
+      if (inputRef.current) {
+        inputRef.current.value = "";
+      }
+    },
+    [multiple, onChange, value]
+  );
+  const displayError = error ?? localError;
+  const files = multiple ? Array.isArray(value) ? value : [] : value instanceof File ? [value] : [];
+  return /* @__PURE__ */ jsxs9("div", { className: hint?.className, "data-field": name, "data-error": Boolean(displayError), children: [
+    label && /* @__PURE__ */ jsxs9("label", { htmlFor: id, children: [
+      label,
+      required && /* @__PURE__ */ jsx9("span", { "aria-hidden": "true", "data-required": true, children: "*" })
+    ] }),
+    /* @__PURE__ */ jsxs9(
+      "div",
+      {
+        "data-file-dropzone": true,
+        "data-dragging": isDragging,
+        "data-disabled": disabled || hint?.readOnly,
+        onDragOver: handleDragOver,
+        onDragLeave: handleDragLeave,
+        onDrop: handleDrop,
+        onClick: handleClick,
+        role: "button",
+        tabIndex: disabled ? -1 : 0,
+        "aria-describedby": [Boolean(displayError) && errorId, hasHelper && helperId].filter(Boolean).join(" ") || void 0,
+        children: [
+          /* @__PURE__ */ jsx9(
+            "input",
+            {
+              ref: inputRef,
+              id,
+              type: "file",
+              name,
+              accept,
+              multiple,
+              disabled,
+              onChange: handleChange,
+              "aria-invalid": Boolean(displayError),
+              "aria-required": required,
+              "data-file-input": true
+            }
+          ),
+          files.length === 0 ? /* @__PURE__ */ jsx9("p", { "data-file-placeholder": true, children: hint?.placeholder ?? (isDragging ? "Drop files here..." : "Click or drag files to upload") }) : /* @__PURE__ */ jsx9("ul", { "data-file-list": true, children: files.map((file, index) => /* @__PURE__ */ jsxs9("li", { "data-file-item": true, children: [
+            /* @__PURE__ */ jsx9("span", { "data-file-name": true, children: file.name }),
+            /* @__PURE__ */ jsxs9("span", { "data-file-size": true, children: [
+              "(",
+              formatFileSize(file.size),
+              ")"
+            ] }),
+            !disabled && !hint?.readOnly && /* @__PURE__ */ jsx9(
+              "button",
+              {
+                type: "button",
+                onClick: (e) => {
+                  e.stopPropagation();
+                  handleRemove(multiple ? index : void 0);
+                },
+                "aria-label": `Remove ${file.name}`,
+                "data-file-remove": true,
+                children: "\xD7"
+              }
+            )
+          ] }, `${file.name}-${index}`)) })
+        ]
+      }
+    ),
+    hasHelper && /* @__PURE__ */ jsx9("p", { id: helperId, "data-helper": true, children: hint?.helperText }),
+    displayError && /* @__PURE__ */ jsx9("p", { id: errorId, role: "alert", "data-error-message": true, children: displayError })
+  ] });
+}
+function formatFileSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+var BUILTIN_WIDGETS = {
+  text: TextInput,
+  textarea: Textarea,
+  number: NumberInput,
+  switch: Switch,
+  checkbox: Switch,
+  select: Select,
+  "searchable-select": SearchableSelect,
+  radio: Select,
+  // Could be RadioGroup
+  password: SecretInput,
+  "tag-input": TagInput,
+  "file-upload": FileUpload,
+  slider: NumberInput,
+  // Could be Slider widget
+  "color-picker": TextInput
+  // Could be ColorPicker widget
+};
+var TYPE_TO_WIDGET = {
+  ZodString: TextInput,
+  ZodNumber: NumberInput,
+  ZodBoolean: Switch,
+  ZodEnum: Select,
+  ZodNativeEnum: Select,
+  ZodArray: TagInput
+};
+function FieldRenderer({
+  fieldInfo,
+  hint,
+  value,
+  onChange,
+  error,
+  disabled,
+  renderNestedField
+}) {
+  const widgetRegistry2 = useWidgetRegistry();
+  if (fieldInfo.typeName === "ZodObject" && fieldInfo.nestedFields && renderNestedField) {
+    const nestedFields = Array.from(fieldInfo.nestedFields.values());
+    const fieldBaseName2 = fieldInfo.name.split(".").pop() ?? fieldInfo.name;
+    return /* @__PURE__ */ jsx10("div", { "data-nested-object": true, "data-field": fieldInfo.name, children: /* @__PURE__ */ jsxs10("fieldset", { "data-nested-fieldset": true, children: [
+      /* @__PURE__ */ jsx10("legend", { "data-nested-legend": true, children: hint?.label ?? fieldInfo.description ?? formatLabel(fieldBaseName2) }),
+      hint?.helperText && /* @__PURE__ */ jsx10("p", { "data-helper": true, children: hint.helperText }),
+      /* @__PURE__ */ jsx10("div", { "data-nested-fields": true, children: nestedFields.map((nestedInfo) => renderNestedField(nestedInfo)) })
+    ] }) });
+  }
+  let Widget;
+  if (hint?.widget) {
+    if (typeof hint.widget === "string") {
+      Widget = BUILTIN_WIDGETS[hint.widget] ?? widgetRegistry2.getComponent(hint.widget) ?? TextInput;
+    } else {
+      Widget = hint.widget;
+    }
+  } else {
+    const defaultType = getDefaultWidgetType(fieldInfo);
+    if (fieldInfo.typeName === "ZodString" && hint?.rows && hint.rows > 1) {
+      Widget = Textarea;
+    } else if (defaultType === "searchable-select") {
+      Widget = SearchableSelect;
+    } else {
+      Widget = BUILTIN_WIDGETS[defaultType] ?? TYPE_TO_WIDGET[fieldInfo.typeName] ?? TextInput;
+    }
+    if (fieldInfo.typeName === "ZodString" && isSecretField(fieldInfo)) {
+      Widget = SecretInput;
+    }
+  }
+  const options = hint?.options ?? (fieldInfo.enumValues ? fieldInfo.enumValues.map((v) => ({ value: v, label: v })) : void 0);
+  const fieldBaseName = fieldInfo.name.split(".").pop() ?? fieldInfo.name;
+  const props = {
+    value,
+    onChange,
+    name: fieldInfo.name,
+    // Full path for form registration
+    label: hint?.label ?? fieldInfo.description ?? formatLabel(fieldBaseName),
+    error,
+    disabled: disabled || hint?.readOnly,
+    required: !fieldInfo.isOptional,
+    hint: {
+      ...hint,
+      options,
+      min: hint?.min ?? fieldInfo.constraints?.min ?? fieldInfo.constraints?.minLength,
+      max: hint?.max ?? fieldInfo.constraints?.max ?? fieldInfo.constraints?.maxLength
+    }
+  };
+  return /* @__PURE__ */ jsx10(Widget, { ...props });
+}
+function formatLabel(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/_/g, " ").replace(/^\w/, (c) => c.toUpperCase()).trim();
+}
+function AutoForm({
+  schema,
+  values,
+  defaultValues,
+  onChange,
+  onSubmit,
+  uiHints = {},
+  fieldOrder,
+  disabled = false,
+  withSubmit = false,
+  submitText = "Submit",
+  className,
+  widgetRegistry: widgetRegistry2,
+  children
+}) {
+  const fieldInfoMap = useMemo2(() => analyzeSchema(schema), [schema]);
+  const flatFieldInfoMap = useMemo2(() => flattenSchema(schema), [schema]);
+  const schemaDefaults = useMemo2(() => {
+    const defaults = {};
+    function extractDefaults(fields, prefix = "") {
+      fields.forEach((info, key) => {
+        const fullKey = prefix ? `${prefix}.${key}` : key;
+        if (info.defaultValue !== void 0) {
+          setNestedValue(defaults, fullKey, info.defaultValue);
+        }
+        if (info.nestedFields) {
+          extractDefaults(info.nestedFields, fullKey);
+        }
+      });
+    }
+    extractDefaults(fieldInfoMap);
+    return defaults;
+  }, [fieldInfoMap]);
+  const mergedDefaults = useMemo2(() => {
+    return deepMerge(
+      deepMerge(schemaDefaults, defaultValues ?? {}),
+      values ?? {}
+    );
+  }, [schemaDefaults, defaultValues, values]);
+  const methods = useForm({
+    resolver: zodResolver(schema),
+    defaultValues: mergedDefaults,
+    mode: "onChange",
+    shouldUnregister: true
+  });
+  const { control, handleSubmit, watch, formState, reset, getValues } = methods;
+  const prevValuesRef = useRef3(values);
+  const conditionFields = useMemo2(() => {
+    const fields = /* @__PURE__ */ new Set();
+    const extractConditionFields = (hints, prefix = "") => {
+      for (const [key, value] of Object.entries(hints)) {
+        if (!value || typeof value !== "object") continue;
+        const hint = value;
+        if (hint.condition && typeof hint.condition === "object") {
+          const condition = hint.condition;
+          if (condition.field) {
+            fields.add(condition.field);
+          }
+        }
+        if (!("widget" in hint) && !("label" in hint) && !("condition" in hint)) {
+          extractConditionFields(hint, prefix ? `${prefix}.${key}` : key);
+        }
+      }
+    };
+    extractConditionFields(uiHints);
+    return Array.from(fields);
+  }, [uiHints]);
+  const [conditionValues, setConditionValues] = useState5({});
+  useEffect2(() => {
+    if (conditionFields.length === 0) return;
+    const initial = {};
+    const currentValues = getValues();
+    for (const field of conditionFields) {
+      initial[field] = getValueAtPath(currentValues, field);
+    }
+    setConditionValues(initial);
+    const subscription = watch((formValues, { name }) => {
+      if (name && conditionFields.includes(name)) {
+        setConditionValues((prev) => ({
+          ...prev,
+          [name]: getValueAtPath(formValues, name)
+        }));
+      }
+    });
+    return () => subscription.unsubscribe();
+  }, [conditionFields, watch, getValues]);
+  useEffect2(() => {
+    if (values && !shallowEqual(values, prevValuesRef.current)) {
+      prevValuesRef.current = values;
+      const resetValues = deepMerge(
+        deepMerge(schemaDefaults, defaultValues ?? {}),
+        values ?? {}
+      );
+      reset(resetValues);
+    }
+  }, [values, reset, schemaDefaults, defaultValues]);
+  const onChangeRef = useRef3(onChange);
+  onChangeRef.current = onChange;
+  const schemaRef = useRef3(schema);
+  schemaRef.current = schema;
+  useEffect2(() => {
+    if (!onChangeRef.current) return;
+    const subscription = watch((formValues, { type }) => {
+      if (type !== "change") return;
+      const result = schemaRef.current.safeParse(formValues);
+      if (result.success && onChangeRef.current) {
+        onChangeRef.current(result.data);
+      }
+    });
+    return () => subscription.unsubscribe();
+  }, [watch]);
+  const HINT_KEYS = /* @__PURE__ */ new Set([
+    "widget",
+    "label",
+    "placeholder",
+    "helperText",
+    "hidden",
+    "readOnly",
+    "className",
+    "condition",
+    "group",
+    "rows",
+    "accept",
+    "multiple",
+    "maxSize",
+    "options",
+    "searchable",
+    "searchPlaceholder",
+    "noResultsText"
+  ]);
+  const isFieldUIHint = useCallback5((obj) => {
+    if (!obj || typeof obj !== "object") return false;
+    return Object.keys(obj).some((key) => HINT_KEYS.has(key));
+  }, []);
+  const getHint = useCallback5(
+    (fieldName) => {
+      if (fieldName in uiHints) {
+        const hint = uiHints[fieldName];
+        if (isFieldUIHint(hint)) return hint;
+      }
+      const parts = fieldName.split(".");
+      let current = uiHints;
+      for (const part of parts) {
+        if (current == null || typeof current !== "object") return void 0;
+        current = current[part];
+      }
+      if (isFieldUIHint(current)) {
+        return current;
+      }
+      return void 0;
+    },
+    [uiHints, isFieldUIHint]
+  );
+  const isConditionMet = useCallback5(
+    (condition) => {
+      if (!condition) return true;
+      const fieldValue = conditionFields.length > 0 ? conditionValues[condition.field] : getValueAtPath(getValues(), condition.field);
+      if (condition.when) {
+        return condition.when(fieldValue, getValues());
+      }
+      if ("equals" in condition && condition.equals !== void 0) {
+        return fieldValue === condition.equals;
+      }
+      if ("notEquals" in condition && condition.notEquals !== void 0) {
+        return fieldValue !== condition.notEquals;
+      }
+      if (condition.oneOf) {
+        return condition.oneOf.includes(fieldValue);
+      }
+      if (condition.notOneOf) {
+        return !condition.notOneOf.includes(fieldValue);
+      }
+      return true;
+    },
+    [conditionFields, conditionValues, getValues]
+  );
+  const orderedFields = useMemo2(() => {
+    if (fieldOrder) {
+      return fieldOrder.map((f) => String(f));
+    }
+    return Array.from(fieldInfoMap.keys());
+  }, [fieldOrder, fieldInfoMap]);
+  const onFormSubmit = handleSubmit(async (data) => {
+    await onSubmit?.(data);
+  });
+  const renderField = useCallback5(
+    (fieldInfo) => {
+      const hint = getHint(fieldInfo.name);
+      if (hint?.hidden) return null;
+      if (!isConditionMet(hint?.condition)) return null;
+      return /* @__PURE__ */ jsx11(
+        Controller,
+        {
+          name: fieldInfo.name,
+          control,
+          render: ({ field, fieldState }) => /* @__PURE__ */ jsx11(
+            FieldRenderer,
+            {
+              fieldInfo,
+              hint,
+              value: field.value,
+              onChange: field.onChange,
+              error: fieldState.error?.message,
+              disabled,
+              renderNestedField: renderField
+            }
+          )
+        },
+        fieldInfo.name
+      );
+    },
+    [control, disabled, getHint, isConditionMet]
+  );
+  const renderedFields = orderedFields.map((fieldName) => {
+    const fieldInfo = fieldInfoMap.get(fieldName);
+    if (!fieldInfo) return null;
+    return renderField(fieldInfo);
+  }).filter(Boolean);
+  const getField = useCallback5(
+    (name) => {
+      const fieldInfo = flatFieldInfoMap.get(name);
+      if (!fieldInfo) return null;
+      return renderField(fieldInfo);
+    },
+    [flatFieldInfoMap, renderField]
+  );
+  const getFieldsByGroup = useCallback5(
+    (group) => {
+      const fields = [];
+      for (const [name] of flatFieldInfoMap) {
+        const hint = getHint(name);
+        if (hint?.group === group) {
+          const rendered = getField(name);
+          if (rendered) fields.push(rendered);
+        }
+      }
+      return fields;
+    },
+    [flatFieldInfoMap, getField, getHint]
+  );
+  const submitButton = withSubmit ? /* @__PURE__ */ jsx11(
+    "button",
+    {
+      type: "submit",
+      disabled: disabled || formState.isSubmitting,
+      "data-autoform-submit": true,
+      children: formState.isSubmitting ? "Submitting..." : submitText
+    }
+  ) : null;
+  const formContent = /* @__PURE__ */ jsx11(FormProvider, { ...methods, children: /* @__PURE__ */ jsx11("form", { onSubmit: onFormSubmit, className, "data-autoform": true, children: children ? children({
+    fields: renderedFields,
+    submit: submitButton,
+    formState: {
+      isSubmitting: formState.isSubmitting,
+      isValid: formState.isValid,
+      isDirty: formState.isDirty
+    },
+    getField,
+    getFieldsByGroup
+  }) : /* @__PURE__ */ jsxs11(Fragment, { children: [
+    renderedFields,
+    submitButton
+  ] }) }) });
+  if (widgetRegistry2) {
+    return /* @__PURE__ */ jsx11(WidgetRegistryContext.Provider, { value: widgetRegistry2, children: formContent });
+  }
+  return formContent;
+}
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    if (!isSafeKey2(key)) continue;
+    const baseVal = base[key];
+    const overrideVal = override[key];
+    if (isPlainObject(baseVal) && isPlainObject(overrideVal)) {
+      result[key] = deepMerge(
+        baseVal,
+        overrideVal
+      );
+    } else if (overrideVal !== void 0) {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+function isPlainObject(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val) && Object.getPrototypeOf(val) === Object.prototype;
+}
+var DANGEROUS_KEYS2 = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isSafeKey2(key) {
+  return !DANGEROUS_KEYS2.has(key);
+}
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (part === void 0) continue;
+    if (!isSafeKey2(part)) {
+      console.warn(`Rejected dangerous property key in path: ${part}`);
+      return;
+    }
+    if (!Object.hasOwn(current, part) || typeof current[part] !== "object") {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastPart = parts[parts.length - 1];
+  if (lastPart !== void 0) {
+    if (!isSafeKey2(lastPart)) {
+      console.warn(`Rejected dangerous property key in path: ${lastPart}`);
+      return;
+    }
+    current[lastPart] = value;
+  }
+}
+function shallowEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return a === b;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    const valA = a[key];
+    const valB = b[key];
+    if (typeof valA === "object" && typeof valB === "object" && valA !== null && valB !== null) {
+      if (!shallowEqual(valA, valB)) return false;
+    } else if (valA !== valB) {
+      return false;
+    }
+  }
+  return true;
+}
+function FieldGroup({
+  title,
+  description,
+  collapsible = false,
+  defaultCollapsed = false,
+  className,
+  children
+}) {
+  const [isCollapsed, setIsCollapsed] = useState6(defaultCollapsed);
+  const toggleCollapsed = useCallback6(() => {
+    if (collapsible) {
+      setIsCollapsed((prev) => !prev);
+    }
+  }, [collapsible]);
+  const headerId = `fieldgroup-${title.toLowerCase().replace(/\s+/g, "-")}`;
+  const contentId = `${headerId}-content`;
+  return /* @__PURE__ */ jsxs12(
+    "fieldset",
+    {
+      className,
+      "data-fieldgroup": true,
+      "data-collapsible": collapsible,
+      "data-collapsed": isCollapsed,
+      children: [
+        collapsible ? /* @__PURE__ */ jsx12("legend", { children: /* @__PURE__ */ jsxs12(
+          "button",
+          {
+            type: "button",
+            onClick: toggleCollapsed,
+            "aria-expanded": !isCollapsed,
+            "aria-controls": contentId,
+            "data-fieldgroup-toggle": true,
+            children: [
+              /* @__PURE__ */ jsx12("span", { "data-fieldgroup-arrow": true, "aria-hidden": "true", children: isCollapsed ? "\u25B6" : "\u25BC" }),
+              /* @__PURE__ */ jsx12("span", { id: headerId, "data-fieldgroup-title": true, children: title })
+            ]
+          }
+        ) }) : /* @__PURE__ */ jsx12("legend", { id: headerId, "data-fieldgroup-title": true, children: title }),
+        description && /* @__PURE__ */ jsx12("p", { "data-fieldgroup-description": true, children: description }),
+        /* @__PURE__ */ jsx12(
+          "div",
+          {
+            id: contentId,
+            role: "group",
+            "aria-labelledby": headerId,
+            "data-fieldgroup-content": true,
+            hidden: collapsible && isCollapsed,
+            children
+          }
+        )
+      ]
+    }
+  );
+}
+var FieldSection = FieldGroup;
+export {
+  AutoForm,
+  FieldGroup,
+  FieldRenderer,
+  FieldSection,
+  FileUpload,
+  NumberInput,
+  ProviderRegistry,
+  Registry,
+  SearchableSelect,
+  SecretInput,
+  Select,
+  SettingsRegistry,
+  Switch,
+  TagInput,
+  TextInput,
+  Textarea,
+  WidgetRegistry,
+  WidgetRegistryContext,
+  analyzeField,
+  analyzeSchema,
+  createProviderRegistry,
+  flattenSchema,
+  getDefaultWidgetType,
+  getValueAtPath,
+  isNestedObject,
+  isSecretField,
+  noopServices,
+  setValueAtPath,
+  settingsRegistry,
+  useWidgetRegistry,
+  widgetRegistry
+};
 //# sourceMappingURL=app-framework.js.map