@golemui/gui-mcp 1.5.1 → 1.6.0-rc.0

package/{get-concept-MFKfeD4D.js → get-concept-BqdUfdaO.js}

@@ -1984,12 +1984,12 @@ function checkSlot(expr, slot, path, out, inTemplate) {
     });
   }
 }
-function validateFormDefinition(input) {
+function validateFormDefinition(input2) {
   const validate = getFormValidator();
-  const ajvOk = validate(input.formDefinition);
-  const { errors, warnings } = formatAjvErrors(validate.errors, input.formDefinition);
-  const expressionWarnings = lintReactiveExpressions(input.formDefinition);
-  const interpolationWarnings = lintStringInterpolations(input.formDefinition);
+  const ajvOk = validate(input2.formDefinition);
+  const { errors, warnings } = formatAjvErrors(validate.errors, input2.formDefinition);
+  const expressionWarnings = lintReactiveExpressions(input2.formDefinition);
+  const interpolationWarnings = lintStringInterpolations(input2.formDefinition);
   if (!ajvOk && errors.length === 0) {
     errors.push({
       path: "/",
@@ -1997,7 +1997,7 @@ function validateFormDefinition(input) {
       message: "Form failed schema validation but no specific error could be localized. The form may contain a widget at a position the form schema does not allow, or a structural shape that our targeted validator missed. Verify each widget against its `json_get_widget_spec` entry."
     });
   }
-  const booleanValidatorWarnings = lintBooleanValidators(input.formDefinition).map(
+  const booleanValidatorWarnings = lintBooleanValidators(input2.formDefinition).map(
     (f) => ({
       path: f.path,
       message: f.message,
@@ -2028,386 +2028,2470 @@ const JSON_VALIDATE_FORM_DEFINITION_TOOL = {
     required: ["formDefinition"]
   }
 };
-const FORM_SCHEMA_URL = "https://golemui.com/schemas/form.schema.json";
-const SUPPORTED_STRING_FORMATS = /* @__PURE__ */ new Set([
-  "email",
-  "hostname",
-  "ipv4",
-  "ipv6",
-  "url",
-  "uuid",
-  "date",
-  "time",
-  "date-time",
-  "duration"
+const CHECKED_FORMATS = /* @__PURE__ */ new Set(["email", "hostname", "ipv4", "ipv6", "url", "uuid", "duration"]);
+const FORMAT_NAMES = { uri: "url" };
+const NUMBER_KEYWORDS$1 = [
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf"
+];
+function guiValidator(node) {
+  const { schema } = node;
+  const constraints = {};
+  const copyNumbers = (keywords) => {
+    for (const keyword of keywords) {
+      if (typeof schema[keyword] === "number") {
+        constraints[keyword] = schema[keyword];
+      }
+    }
+  };
+  switch (node.type) {
+    case "string": {
+      copyNumbers(["minLength", "maxLength"]);
+      if (typeof schema["pattern"] === "string") {
+        constraints["pattern"] = schema["pattern"];
+      }
+      const format = typeof schema["format"] === "string" ? FORMAT_NAMES[schema["format"]] ?? schema["format"] : void 0;
+      if (format !== void 0 && CHECKED_FORMATS.has(format)) {
+        constraints["format"] = format;
+      }
+      copyLiterals(schema, constraints, (value) => typeof value === "string");
+      break;
+    }
+    case "number":
+    case "integer":
+      copyNumbers(NUMBER_KEYWORDS$1);
+      copyLiterals(schema, constraints, (value) => typeof value === "number");
+      break;
+    case "boolean":
+      copyLiterals(schema, constraints, (value) => typeof value === "boolean");
+      break;
+    case "array":
+      copyNumbers(["minItems", "maxItems"]);
+      if (schema["uniqueItems"] === true) {
+        constraints["uniqueItems"] = true;
+      }
+      break;
+    default:
+      return void 0;
+  }
+  const required2 = node.required || node.type === "boolean" && constraints["const"] === true;
+  if (!required2 && Object.keys(constraints).length === 0) {
+    return void 0;
+  }
+  return { type: node.type, ...required2 ? { required: true } : {}, ...constraints };
+}
+function copyLiterals(schema, constraints, hasType) {
+  if ("const" in schema && hasType(schema["const"])) {
+    constraints["const"] = schema["const"];
+  }
+  if (Array.isArray(schema["enum"])) {
+    const values = schema["enum"].filter(hasType);
+    if (values.length > 0) {
+      constraints["enum"] = values;
+    }
+  }
+}
+const DEFAULT_SCHEMA_URL = "https://golemui.com/schemas/form.schema.json";
+const DEFAULT_SELECT_THRESHOLD = 6;
+const LONG_TEXT_MIN_LENGTH = 200;
+const SECRET_NAME = /(password|secret|api[_-]?key|token)/i;
+const DATE_AND_TIME_WIDGETS = {
+  date: "dateInput",
+  "date-time": "dateTimePicker",
+  time: "timeInput"
+};
+const TAG_CONSTRAINTS = ["format", "pattern", "minLength", "maxLength", "minimum", "maximum"];
+function guiPreset(options = {}) {
+  const radioThreshold = options.enumThresholds?.radio ?? 0;
+  const selectThreshold = options.enumThresholds?.select ?? DEFAULT_SELECT_THRESHOLD;
+  const objectTitle = options.objectTitle ?? "none";
+  const group = (children, groupOptions) => layout("flex", { direction: "column", gap: 8 }, withTitle(children, groupOptions.title), {
+    uid: groupOptions.uid,
+    include: groupOptions.include
+  });
+  const withTitle = (children, title2) => {
+    if (typeof title2 !== "string" || title2 === "" || objectTitle === "none") {
+      return children;
+    }
+    const heading = objectTitle === "markdownText" ? { kind: "display", type: "markdownText", props: { md: `### ${title2}` } } : { kind: "display", type: "alert", props: { text: title2, level: "info" } };
+    return [heading, ...children];
+  };
+  const choice = (node, context, forcedType) => {
+    const options2 = context.enumOptions(node) ?? [];
+    const type2 = forcedType ?? (options2.length <= radioThreshold ? "radiogroup" : options2.length <= selectThreshold ? "select" : "dropdown");
+    if (type2 === "dropdown") {
+      return input(type2, node, context, {
+        items: options2,
+        labelField: "label",
+        valueField: "value",
+        placeholder: exampleOf(node)
+      });
+    }
+    return input(type2, node, context, {
+      options: options2,
+      placeholder: type2 === "select" ? exampleOf(node) : void 0
+    });
+  };
+  const multipleChoice = (node, context, forcedType) => {
+    const item = context.item(node);
+    const options2 = (item && context.enumOptions(item)) ?? [];
+    const type2 = forcedType ?? (options2.length <= selectThreshold ? "multiList" : "multiDropdown");
+    return input(type2, node, context, { items: options2, labelField: "label", valueField: "value" });
+  };
+  const repeater = (node, context) => {
+    const item = context.item(node);
+    if (item === void 0) {
+      return void 0;
+    }
+    const built = context.build(item);
+    const template = !Array.isArray(built) && built?.kind === "layout" ? built : layout("flex", { direction: "column", gap: 8 }, built ? [built].flat() : []);
+    if (template.children?.length === 0) {
+      context.diagnostic({
+        severity: "error",
+        code: "empty-repeater",
+        message: "The array items have no property the form can render, so the array is left out."
+      });
+      return null;
+    }
+    const label = context.label(node);
+    const itemTitle = typeof item.schema["title"] === "string" ? item.schema["title"] : void 0;
+    const itemName = itemTitle ?? (typeof label === "string" ? singular(label) : void 0);
+    return {
+      kind: "input",
+      type: "repeater",
+      path: node.path,
+      label,
+      defaultValue: defaultValueOf(node),
+      validator: context.validator(node),
+      props: {
+        title: itemTitle,
+        addLabel: itemName !== void 0 ? `Add ${itemName.toLowerCase()}` : "Add",
+        removeLabel: "Remove",
+        limit: typeof node.schema["maxItems"] === "number" ? node.schema["maxItems"] : void 0,
+        template
+      }
+    };
+  };
+  const tags = (node, context) => {
+    const item = context.item(node);
+    if (item !== void 0 && item.type !== "string") {
+      context.diagnostic({
+        severity: "warning",
+        code: "item-type-mismatch",
+        message: `The tags widget writes strings, and the schema expects ${item.type ?? "another type"} items.`
+      });
+    }
+    if (item !== void 0 && TAG_CONSTRAINTS.some((keyword) => keyword in item.schema)) {
+      context.diagnostic({
+        severity: "info",
+        code: "item-constraints-dropped",
+        message: "The tags widget does not check the constraints of each item."
+      });
+    }
+    return input("tags", node, context, { placeholder: exampleOf(node) ?? "Add and press Enter" });
+  };
+  const tuple = (node, context) => {
+    const children = context.buildChildren(node);
+    if (children.length === 0) {
+      return null;
+    }
+    if (node.schema["items"] !== false && node.schema["items"] !== void 0) {
+      context.diagnostic({
+        severity: "info",
+        code: "tuple-extra-items",
+        message: "The form edits the fixed positions only. Extra items the schema allows are not editable."
+      });
+    }
+    return layout("flex", { direction: "row", gap: 12 }, withTitle(children, context.label(node)));
+  };
+  const object = (node, context, type2) => {
+    const children = context.buildChildren(node);
+    if (children.length === 0) {
+      context.diagnostic({
+        severity: "warning",
+        code: "empty-object",
+        message: "The object has no property the form can render, so it is left out."
+      });
+      return null;
+    }
+    const title2 = isArrayItem(node) ? void 0 : context.label(node);
+    return type2 === "flex" ? group(children, { title: title2 }) : layout("grid", { columnGap: 12, rowGap: 12 }, withTitle(children, title2));
+  };
+  const rules = [
+    {
+      name: "gui constant",
+      when: (node) => "const" in node.schema && (node.type === "string" || isNumeric(node)),
+      build: (node, context) => ({
+        ...input(node.type === "string" ? "textinput" : "number", node, context),
+        readonly: true,
+        defaultValue: node.schema["const"]
+      })
+    },
+    {
+      name: "gui choice",
+      when: (node) => !isContainer(node) && isEnumeration(node.schema),
+      build: (node, context) => choice(node, context)
+    },
+    {
+      name: "gui date and time",
+      when: (node) => node.type === "string" && formatOf(node) in DATE_AND_TIME_WIDGETS,
+      build: (node, context) => {
+        if (formatOf(node) === "date-time") {
+          context.diagnostic({
+            severity: "info",
+            code: "local-datetime",
+            message: "The date-time widget writes the local date and time without a UTC offset, which a strict `date-time` check rejects."
+          });
+        }
+        return input(DATE_AND_TIME_WIDGETS[formatOf(node)], node, context);
+      }
+    },
+    {
+      name: "gui secret",
+      when: (node) => node.type === "string" && (formatOf(node) === "password" || node.schema["writeOnly"] === true || SECRET_NAME.test(node.name ?? "")),
+      build: (node, context) => textInput("password", node, context)
+    },
+    {
+      name: "gui markdown",
+      when: (node) => node.type === "string" && node.schema["contentMediaType"] === "text/markdown",
+      build: (node, context) => textInput("markdown", node, context)
+    },
+    {
+      name: "gui long text",
+      when: (node) => node.type === "string" && typeof node.schema["maxLength"] === "number" && node.schema["maxLength"] >= LONG_TEXT_MIN_LENGTH,
+      build: (node, context) => textInput("textarea", node, context)
+    },
+    {
+      name: "gui text",
+      when: (node) => node.type === "string",
+      build: (node, context) => textInput("textinput", node, context)
+    },
+    {
+      name: "gui number",
+      when: isNumeric,
+      build: (node, context) => textInput("number", node, context)
+    },
+    {
+      name: "gui boolean",
+      when: (node) => node.type === "boolean",
+      build: (node, context) => booleanInput("checkbox", node, context)
+    },
+    {
+      name: "gui array",
+      when: (node) => node.type === "array",
+      build: (node, context) => {
+        if (Array.isArray(node.schema["prefixItems"])) {
+          return tuple(node, context);
+        }
+        const item = context.item(node);
+        if (item === void 0) {
+          return void 0;
+        }
+        if (!isContainer(item) && isEnumeration(item.schema)) {
+          return multipleChoice(node, context);
+        }
+        if (item.type === "object") {
+          return repeater(node, context);
+        }
+        if (item.type === "string" || isNumeric(item)) {
+          return tags(node, context);
+        }
+        return void 0;
+      }
+    },
+    {
+      name: "gui object",
+      when: (node) => node.type === "object",
+      build: (node, context) => object(node, context, "flex")
+    }
+  ];
+  const widgets = {
+    textinput: (node, context) => textInput("textinput", node, context),
+    textarea: (node, context) => textInput("textarea", node, context),
+    password: (node, context) => textInput("password", node, context),
+    markdown: (node, context) => textInput("markdown", node, context),
+    number: (node, context) => textInput("number", node, context),
+    currency: (node, context) => input("currency", node, context),
+    checkbox: (node, context) => booleanInput("checkbox", node, context),
+    toggle: (node, context) => booleanInput("toggle", node, context),
+    select: (node, context) => choice(node, context, "select"),
+    radiogroup: (node, context) => choice(node, context, "radiogroup"),
+    dropdown: (node, context) => choice(node, context, "dropdown"),
+    multiList: (node, context) => multipleChoice(node, context, "multiList"),
+    multiDropdown: (node, context) => multipleChoice(node, context, "multiDropdown"),
+    tags: (node, context) => tags(node, context),
+    repeater: (node, context) => repeater(node, context),
+    flex: (node, context) => object(node, context, "flex"),
+    grid: (node, context) => object(node, context, "grid"),
+    ...Object.fromEntries(
+      [
+        "dateInput",
+        "datePicker",
+        "calendar",
+        "dateTimeInput",
+        "dateTimePicker",
+        "dateTimeCalendar",
+        "timeInput",
+        "timePicker"
+      ].map((type2) => [
+        type2,
+        (node, context) => input(type2, node, context)
+      ])
+    )
+  };
+  const root = (children) => {
+    const widgets2 = options.submitAction === false ? children : [
+      ...children,
+      {
+        kind: "action",
+        type: "button",
+        actionType: "submit",
+        label: options.submitLabel ?? "Submit",
+        props: { variant: "filled" }
+      }
+    ];
+    if (widgets2.length === 0 || options.rootLayout === void 0 || options.rootLayout === "vertical") {
+      return widgets2;
+    }
+    return [
+      options.rootLayout === "grid" ? layout("grid", { columnGap: 12, rowGap: 12 }, widgets2) : layout("flex", { direction: "row", gap: 12 }, widgets2)
+    ];
+  };
+  return {
+    name: "gui",
+    rules,
+    widgets,
+    validator: guiValidator,
+    group,
+    root,
+    schemaUrl: options.schemaUrl ?? DEFAULT_SCHEMA_URL
+  };
+}
+function input(type2, node, context, props = {}) {
+  return {
+    kind: "input",
+    type: type2,
+    path: node.path,
+    label: context.label(node),
+    readonly: node.schema["readOnly"] === true ? true : void 0,
+    defaultValue: defaultValueOf(node),
+    validator: context.validator(node),
+    props: definedOnly({ hint: descriptionOf(node), ...props })
+  };
+}
+function textInput(type2, node, context) {
+  return input(type2, node, context, { placeholder: exampleOf(node) });
+}
+function booleanInput(type2, node, context) {
+  const widget = input(type2, node, context);
+  if (widget["defaultValue"] === void 0 && node.required) {
+    widget["defaultValue"] = false;
+  }
+  return widget;
+}
+function layout(type2, props, children, fields = {}) {
+  return { kind: "layout", type: type2, ...fields, props, children };
+}
+function defaultValueOf(node) {
+  if ("default" in node.schema) {
+    return node.schema["default"];
+  }
+  if (node.parent !== void 0 && node.name !== void 0) {
+    const parentDefault = defaultValueOf(node.parent);
+    if (isRecord$2(parentDefault) && node.name in parentDefault) {
+      return parentDefault[node.name];
+    }
+  }
+  return void 0;
+}
+function descriptionOf(node) {
+  const description2 = node.schema["description"];
+  return typeof description2 === "string" && description2 !== "" ? description2 : void 0;
+}
+function exampleOf(node) {
+  const examples = node.schema["examples"];
+  const first = Array.isArray(examples) ? examples[0] : void 0;
+  return typeof first === "string" || typeof first === "number" ? String(first) : void 0;
+}
+function formatOf(node) {
+  return typeof node.schema["format"] === "string" ? node.schema["format"] : "";
+}
+function isNumeric(node) {
+  return node.type === "number" || node.type === "integer";
+}
+function isContainer(node) {
+  return node.type === "object" || node.type === "array";
+}
+function isArrayItem(node) {
+  return node.parent?.type === "array" && node.name === void 0;
+}
+function isEnumeration(schema) {
+  if (Array.isArray(schema["enum"])) {
+    return true;
+  }
+  return ["oneOf", "anyOf"].some((keyword) => {
+    const branches = schema[keyword];
+    return Array.isArray(branches) && branches.length > 0 && branches.every((branch) => isRecord$2(branch) && "const" in branch);
+  });
+}
+function definedOnly(props) {
+  const defined = Object.entries(props).filter(([, value]) => value !== void 0);
+  return defined.length > 0 ? Object.fromEntries(defined) : void 0;
+}
+function singular(label) {
+  if (label.endsWith("ies") && label.length > 3) {
+    return `${label.slice(0, -3)}y`;
+  }
+  if (/(ss|x|ch|sh)es$/.test(label)) {
+    return label.slice(0, -2);
+  }
+  if (label.endsWith("s") && !label.endsWith("ss")) {
+    return label.slice(0, -1);
+  }
+  return label;
+}
+function isRecord$2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+const IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function literal(value) {
+  if (typeof value !== "string") {
+    return JSON.stringify(value);
+  }
+  return JSON.stringify(value).replace(/\.(?=\d)/g, '." + "');
+}
+function pathExpression(scope, segments) {
+  return segments.reduce((expression, segment, index) => {
+    const chain = index === 0 ? "" : "?.";
+    if (IDENTIFIER.test(segment)) {
+      return `${expression}${chain === "" ? "." : chain}${segment}`;
+    }
+    return `${expression}${chain}[${literal(segment)}]`;
+  }, scope);
+}
+function innermostItemNode(node) {
+  for (let current = node; current; current = current.parent) {
+    const parent = current.parent;
+    if (parent?.type === "array" && current.path === `${parent.path}.items`) {
+      return current;
+    }
+  }
+  return void 0;
+}
+function dataReference(node, path) {
+  const row = innermostItemNode(node);
+  if (row === void 0) {
+    return pathExpression("$form", path.split("."));
+  }
+  const relative = path.slice(row.path.length + 1);
+  return relative === "" ? "$item" : pathExpression("$item", relative.split("."));
+}
+function equalsAny(reference, values) {
+  const tests = values.map((value) => `${reference} === ${literal(value)}`);
+  return tests.length === 1 ? tests[0] : `(${tests.join(" || ")})`;
+}
+const ANNOTATIONS = /* @__PURE__ */ new Set([
+  "title",
+  "description",
+  "$comment",
+  "examples",
+  "default",
+  "deprecated"
+]);
+function compileCondition(schema, reference) {
+  if (typeof schema === "boolean") {
+    return { expression: String(schema), vacuous: false, reads: [] };
+  }
+  if (!isRecord$1(schema)) {
+    return { unsupported: "a value that is not a schema" };
+  }
+  const state = { vacuous: false };
+  const compiled = objectTests(schema, [], reference, state);
+  if ("unsupported" in compiled) {
+    return compiled;
+  }
+  const properties2 = isRecord$1(schema["properties"]) ? Object.keys(schema["properties"]) : [];
+  const reads = [.../* @__PURE__ */ new Set([...properties2, ...requiredNames(schema)])];
+  return { expression: joinAnd(compiled.tests), vacuous: state.vacuous, reads };
+}
+function objectTests(schema, basePath, reference, state) {
+  for (const [keyword, value] of Object.entries(schema)) {
+    const constrainsNothing = keyword === "properties" || keyword === "required" || ANNOTATIONS.has(keyword) || keyword === "type" && value === "object";
+    if (!constrainsNothing) {
+      return { unsupported: keyword };
+    }
+  }
+  const required2 = requiredNames(schema);
+  const properties2 = isRecord$1(schema["properties"]) ? schema["properties"] : {};
+  const tests = [];
+  for (const [name, subschema] of Object.entries(properties2)) {
+    const segments = [...basePath, name];
+    const ref = reference(segments);
+    const compiled = valueTest(subschema, segments, reference, state);
+    if ("unsupported" in compiled) {
+      return compiled;
+    }
+    if (required2.includes(name)) {
+      tests.push(
+        compiled.impliesPresence ? compiled.test : `${ref} !== undefined && ${compiled.test}`
+      );
+    } else if (compiled.test !== "true") {
+      tests.push(`(${ref} === undefined || ${compiled.test})`);
+      state.vacuous = true;
+    }
+  }
+  for (const name of required2) {
+    if (!(name in properties2)) {
+      tests.push(`${reference([...basePath, name])} !== undefined`);
+    }
+  }
+  return { tests };
+}
+function valueTest(schema, segments, reference, state) {
+  if (schema === true) {
+    return { test: "true", impliesPresence: false };
+  }
+  if (schema === false) {
+    return { test: "false", impliesPresence: true };
+  }
+  if (!isRecord$1(schema)) {
+    return { unsupported: "a value that is not a schema" };
+  }
+  const ref = reference(segments);
+  const tests = [];
+  let impliesPresence = false;
+  for (const [keyword, value] of Object.entries(schema)) {
+    if (keyword === "type" || keyword === "properties" || keyword === "required" || ANNOTATIONS.has(keyword)) {
+      continue;
+    }
+    if (keyword === "const" && isLiteral$1(value)) {
+      tests.push(`${ref} === ${literal(value)}`);
+      impliesPresence ||= value !== null;
+    } else if (keyword === "enum" && Array.isArray(value) && value.every(isLiteral$1)) {
+      tests.push(equalsAny(ref, value));
+      impliesPresence ||= !value.includes(null);
+    } else if (keyword === "not" && negatedValues(value) !== void 0) {
+      tests.push(`!(${equalsAny(ref, negatedValues(value))})`);
+    } else if (BOUND_OPERATORS[keyword] !== void 0 && typeof value === "number") {
+      tests.push(`${ref} ${BOUND_OPERATORS[keyword]} ${value}`);
+      impliesPresence = true;
+    } else {
+      return { unsupported: keyword };
+    }
+  }
+  if ("properties" in schema || "required" in schema) {
+    const nested = objectTests(
+      { properties: schema["properties"], required: schema["required"] },
+      segments,
+      reference,
+      state
+    );
+    if ("unsupported" in nested) {
+      return nested;
+    }
+    tests.push(...nested.tests);
+  }
+  return { test: joinAnd(tests), impliesPresence };
+}
+const BOUND_OPERATORS = {
+  minimum: ">=",
+  maximum: "<=",
+  exclusiveMinimum: ">",
+  exclusiveMaximum: "<"
+};
+function negatedValues(schema) {
+  if (!isRecord$1(schema) || Object.keys(schema).length !== 1) {
+    return void 0;
+  }
+  if ("const" in schema && isLiteral$1(schema["const"])) {
+    return [schema["const"]];
+  }
+  if (Array.isArray(schema["enum"]) && schema["enum"].every(isLiteral$1)) {
+    return schema["enum"];
+  }
+  return void 0;
+}
+function joinAnd(tests) {
+  if (tests.length === 0) {
+    return "true";
+  }
+  return tests.join(" && ");
+}
+function requiredNames(schema) {
+  return Array.isArray(schema["required"]) ? schema["required"].filter((name) => typeof name === "string") : [];
+}
+function isLiteral$1(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isRecord$1(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isDeclarativeRule(rule) {
+  return "match" in rule && !("when" in rule);
+}
+const NODE_FIELDS = {
+  $type: (node) => node.type,
+  $path: (node) => node.path,
+  $name: (node) => node.name,
+  $defName: (node) => node.defName,
+  $required: (node) => node.required,
+  $inRepeater: (node) => node.repeaterDepth > 0
+};
+function matchesDeclarativeRule(rule, node) {
+  return Object.entries(rule.match).every(([key, expected]) => {
+    const readField = NODE_FIELDS[key];
+    const actual = readField ? readField(node) : node.schema[key];
+    if (isMatchOperator(expected)) {
+      return matchesOperator(actual, expected);
+    }
+    if (key === "$path" && typeof expected === "string" && typeof actual === "string") {
+      return matchesPathGlob(expected, actual);
+    }
+    return jsonEqual$2(actual, expected);
+  });
+}
+function isMatchOperator(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  return keys.length === 1 && ["$in", "$exists", "$regex"].includes(keys[0]);
+}
+function matchesOperator(actual, operator) {
+  if ("$in" in operator) {
+    return operator.$in.some((option) => jsonEqual$2(option, actual));
+  }
+  if ("$exists" in operator) {
+    return actual !== void 0 === operator.$exists;
+  }
+  return typeof actual === "string" && new RegExp(operator.$regex).test(actual);
+}
+function matchesPathGlob(glob, path) {
+  const matchFrom = (globSegments, pathSegments) => {
+    if (globSegments.length === 0) {
+      return pathSegments.length === 0;
+    }
+    const [head, ...rest] = globSegments;
+    if (head === "**") {
+      return pathSegments.some((_, skip) => matchFrom(rest, pathSegments.slice(skip))) || matchFrom(rest, []);
+    }
+    if (pathSegments.length === 0) {
+      return false;
+    }
+    return (head === "*" || head === pathSegments[0]) && matchFrom(rest, pathSegments.slice(1));
+  };
+  const segmentsOf = (dotPath) => dotPath === "" ? [] : dotPath.split(".");
+  return matchFrom(segmentsOf(glob), segmentsOf(path));
+}
+function jsonEqual$2(first, second) {
+  return first === second || JSON.stringify(first) === JSON.stringify(second);
+}
+function humanize(name) {
+  return name.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/\s+/g, " ").trim().replace(/^./, (first) => first.toUpperCase());
+}
+function enumOptionsOf(node) {
+  const { schema } = node;
+  if (Array.isArray(schema["enum"])) {
+    const names = Array.isArray(schema["enumNames"]) ? schema["enumNames"] : [];
+    const options = [];
+    schema["enum"].forEach((value, index) => {
+      if (isOptionValue(value)) {
+        const name = names[index];
+        options.push({ label: typeof name === "string" ? name : labelOf$1(value), value });
+      }
+    });
+    return options;
+  }
+  for (const keyword of ["oneOf", "anyOf"]) {
+    const branches = schema[keyword];
+    if (isConstUnion(branches)) {
+      return branches.filter((branch) => isOptionValue(branch["const"])).map((branch) => ({
+        label: typeof branch["title"] === "string" ? branch["title"] : labelOf$1(branch["const"]),
+        value: branch["const"]
+      }));
+    }
+  }
+  return void 0;
+}
+function isConstUnion(branches) {
+  return Array.isArray(branches) && branches.length > 0 && branches.every(isConstBranch);
+}
+function isConstBranch(branch) {
+  return branch !== null && typeof branch === "object" && "const" in branch;
+}
+function isOptionValue(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function labelOf$1(value) {
+  return typeof value === "string" ? humanize(value) : String(value);
+}
+const LOWER_BOUNDS = /* @__PURE__ */ new Set([
+  "minimum",
+  "exclusiveMinimum",
+  "minLength",
+  "minItems",
+  "minProperties",
+  "minContains"
+]);
+const UPPER_BOUNDS = /* @__PURE__ */ new Set([
+  "maximum",
+  "exclusiveMaximum",
+  "maxLength",
+  "maxItems",
+  "maxProperties",
+  "maxContains"
 ]);
-function buildStringValidator(s, required2) {
-  const v = { type: "string" };
-  let used = false;
-  if (required2) {
-    v.required = true;
-    used = true;
+const MUST_AGREE = /* @__PURE__ */ new Set([
+  "const",
+  "pattern",
+  "format",
+  "multipleOf",
+  "prefixItems",
+  "oneOf",
+  "anyOf",
+  "not",
+  "contains"
+]);
+const SUBSCHEMA_MAPS = /* @__PURE__ */ new Set(["properties", "patternProperties"]);
+const CONFLICT = /* @__PURE__ */ Symbol("conflict");
+function mergeSchemaParts(parts, pointers) {
+  const schema = {};
+  const conflicts = [];
+  let allowedTypes;
+  for (const part of parts) {
+    const typeIntersection = intersectTypes(allowedTypes, part.allowedTypes);
+    if (typeIntersection === CONFLICT) {
+      conflicts.push({ keyword: "type", pointer: part.pointer });
+    } else {
+      allowedTypes = typeIntersection;
+    }
+    for (const [keyword, value] of Object.entries(part.schema)) {
+      if (keyword === "type") {
+        continue;
+      }
+      if (!(keyword in schema)) {
+        schema[keyword] = value;
+        continue;
+      }
+      const combined = combineKeyword(keyword, schema[keyword], value, pointers);
+      if (combined === CONFLICT) {
+        conflicts.push({ keyword, pointer: part.pointer });
+      } else {
+        schema[keyword] = combined;
+      }
+    }
+  }
+  return { schema, allowedTypes, conflicts };
+}
+function declaredTypes(schema) {
+  const declared = typeof schema["type"] === "string" ? [schema["type"]] : Array.isArray(schema["type"]) ? schema["type"] : void 0;
+  if (declared === void 0) {
+    return void 0;
+  }
+  const types = declared.filter(isJsonType);
+  if (types.includes("number") && !types.includes("integer")) {
+    types.splice(types.indexOf("number") + 1, 0, "integer");
+  }
+  return types;
+}
+function isJsonType(value) {
+  return value === "string" || value === "number" || value === "integer" || value === "boolean" || value === "object" || value === "array" || value === "null";
+}
+function intersectTypes(current, next) {
+  if (next === void 0) {
+    return current;
+  }
+  if (current === void 0) {
+    return next;
+  }
+  const intersection = current.filter((type2) => next.includes(type2));
+  return intersection.length > 0 ? intersection : CONFLICT;
+}
+function combineKeyword(keyword, existing, value, pointers) {
+  if (jsonEqual$1(existing, value)) {
+    return existing;
+  }
+  if (typeof existing === "number" && typeof value === "number") {
+    if (LOWER_BOUNDS.has(keyword)) {
+      return Math.max(existing, value);
+    }
+    if (UPPER_BOUNDS.has(keyword)) {
+      return Math.min(existing, value);
+    }
+  }
+  if (keyword === "required" && Array.isArray(existing) && Array.isArray(value)) {
+    return [...existing, ...value.filter((name) => !existing.includes(name))];
+  }
+  if (keyword === "enum" && Array.isArray(existing) && Array.isArray(value)) {
+    const intersection = existing.filter(
+      (option) => value.some((other) => jsonEqual$1(option, other))
+    );
+    return intersection.length > 0 ? intersection : CONFLICT;
+  }
+  if (keyword === "uniqueItems") {
+    return existing === true || value === true;
+  }
+  if (SUBSCHEMA_MAPS.has(keyword) && isObject(existing) && isObject(value)) {
+    return mergeSubschemaMaps(existing, value, pointers);
+  }
+  if (keyword === "items") {
+    return allOfWrapper(existing, value, pointers);
+  }
+  if (MUST_AGREE.has(keyword)) {
+    return CONFLICT;
+  }
+  return existing;
+}
+function mergeSubschemaMaps(existing, added, pointers) {
+  const merged = { ...existing };
+  for (const [name, subschema] of Object.entries(added)) {
+    merged[name] = name in merged ? allOfWrapper(merged[name], subschema, pointers) : subschema;
+  }
+  return merged;
+}
+function allOfWrapper(first, second, pointers) {
+  if (jsonEqual$1(first, second)) {
+    return first;
+  }
+  const wrapper = { allOf: [first, second] };
+  const firstPointer = isObject(first) ? pointers.get(first) : void 0;
+  if (firstPointer !== void 0) {
+    pointers.set(wrapper, firstPointer);
+  }
+  return wrapper;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function jsonEqual$1(first, second) {
+  return first === second || JSON.stringify(first) === JSON.stringify(second);
+}
+function escapePointerSegment(segment) {
+  return segment.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function unescapePointerSegment(segment) {
+  return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function appendPointer(pointer, ...segments) {
+  return pointer + segments.map((segment) => `/${escapePointerSegment(String(segment))}`).join("");
+}
+function resolveRef(ref, root) {
+  const hashIndex = ref.indexOf("#");
+  const documentPart = hashIndex === -1 ? ref : ref.slice(0, hashIndex);
+  const fragment = hashIndex === -1 ? "" : ref.slice(hashIndex + 1);
+  if (documentPart !== "" && documentPart !== root["$id"]) {
+    return { error: `Only refs inside the same document are supported, found "${ref}".` };
+  }
+  if (fragment !== "" && !fragment.startsWith("/")) {
+    return { error: `Anchor refs are not supported, found "${ref}".` };
+  }
+  let target = root;
+  const segments = [];
+  for (const encodedSegment of fragment === "" ? [] : fragment.slice(1).split("/")) {
+    let segment;
+    try {
+      segment = unescapePointerSegment(decodeURIComponent(encodedSegment));
+    } catch {
+      return { error: `"${ref}" is not a valid URI fragment.` };
+    }
+    if (target === null || typeof target !== "object" || !Object.prototype.hasOwnProperty.call(target, segment)) {
+      return { error: `"${ref}" points to nothing in the document.` };
+    }
+    target = target[segment];
+    segments.push(segment);
+  }
+  return { target, pointer: appendPointer("", ...segments) };
+}
+function definitionNameOf(pointer) {
+  const match = /(?:^|\/)(?:\$defs|definitions|components\/schemas)\/([^/]+)$/.exec(pointer);
+  return match ? unescapePointerSegment(match[1]) : void 0;
+}
+const RESOLUTION_ONLY_KEYWORDS = [
+  "$defs",
+  "definitions",
+  "$schema",
+  "$id",
+  "$anchor",
+  "$dynamicAnchor"
+];
+function normalizeNode(raw, pointer, refTrail, environment) {
+  if (raw === false) {
+    return void 0;
+  }
+  if (raw === true || raw === void 0) {
+    return { schema: {}, nullable: false, conditionals: [], refTrail: [...refTrail] };
+  }
+  if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+    environment.report({
+      severity: "error",
+      code: "invalid-schema",
+      message: "This value is not a JSON Schema object or boolean.",
+      pointer
+    });
+    return void 0;
+  }
+  registerSubschemaPointers(raw, pointer, environment.pointers);
+  const own = rewriteDraftKeywords(raw, pointer);
+  let trail = [...refTrail];
+  let explicitNull = own.nullableKeyword;
+  let defName;
+  const conditionals = [...own.conditionals];
+  const ownPart = {
+    schema: own.schema,
+    pointer,
+    allowedTypes: withNull(declaredTypes(own.schema), own.nullableKeyword)
+  };
+  const parts = [ownPart];
+  const addPart = (node, partPointer, allowsNull = false) => {
+    parts.push({
+      schema: node.schema,
+      pointer: partPointer,
+      allowedTypes: withNull(node.allowedTypes, allowsNull)
+    });
+    conditionals.push(...node.conditionals);
+    trail = [...trail, ...node.refTrail.slice(refTrail.length)];
+  };
+  const ref = own.schema["$ref"];
+  delete own.schema["$ref"];
+  if (typeof ref === "string") {
+    const followed = followRef(ref, pointer, [...refTrail], environment);
+    if (followed === void 0) {
+      return void 0;
+    }
+    addPart(followed.node, followed.pointer);
+    defName = definitionNameOf(followed.pointer) ?? followed.node.defName;
+  }
+  const allOf2 = own.schema["allOf"];
+  delete own.schema["allOf"];
+  if (Array.isArray(allOf2)) {
+    const nodes = allOf2.map((branch, index) => {
+      const branchPointer = appendPointer(pointer, "allOf", index);
+      const node = normalizeNode(branch, branchPointer, refTrail, environment);
+      if (node !== void 0) {
+        addPart(node, branchPointer);
+      }
+      return node;
+    });
+    if (nodes.length === 1) {
+      defName ??= nodes[0]?.defName;
+    }
+  }
+  const pair = nullablePair(own.schema);
+  if (pair !== void 0) {
+    delete own.schema[pair.keyword];
+    const pairPointer = appendPointer(pointer, pair.keyword, pair.index);
+    const node = normalizeNode(pair.branch, pairPointer, refTrail, environment);
+    if (node === void 0) {
+      return void 0;
+    }
+    addPart(node, pairPointer, true);
+    explicitNull = true;
+    defName ??= node.defName;
+  }
+  const merged = mergeSchemaParts(parts, environment.pointers);
+  for (const conflict of merged.conflicts) {
+    environment.report({
+      severity: "warning",
+      code: "allof-conflict",
+      message: `The combined schemas disagree on \`${conflict.keyword}\`. The first value is used.`,
+      pointer: conflict.pointer
+    });
+  }
+  const schema = merged.schema;
+  if (Array.isArray(schema["enum"]) && schema["enum"].includes(null)) {
+    schema["enum"] = schema["enum"].filter((option) => option !== null);
+    explicitNull = true;
+  }
+  const resolved = resolveType(merged.allowedTypes, schema, pointer, environment);
+  if (resolved.type === void 0) {
+    delete schema["type"];
+  } else {
+    schema["type"] = resolved.type;
+  }
+  return {
+    schema,
+    type: resolved.type,
+    nullable: explicitNull || resolved.nullable,
+    defName,
+    conditionals,
+    refTrail: trail,
+    allowedTypes: merged.allowedTypes
+  };
+}
+function followRef(ref, pointer, trail, environment) {
+  const repetitions = trail.filter((entry) => entry === ref).length;
+  if (repetitions >= environment.maxRefDepth) {
+    environment.report({
+      severity: "warning",
+      code: "recursive-ref",
+      message: `"${ref}" repeats ${repetitions} times on this branch, so the form stops here.`,
+      pointer
+    });
+    return void 0;
+  }
+  const resolved = resolveRef(ref, environment.root);
+  if ("error" in resolved) {
+    environment.report({
+      severity: "error",
+      code: "unresolved-ref",
+      message: resolved.error,
+      pointer
+    });
+    return void 0;
+  }
+  if (resolved.target !== null && typeof resolved.target === "object") {
+    if (!environment.pointers.has(resolved.target)) {
+      environment.pointers.set(resolved.target, resolved.pointer);
+    }
+  }
+  const node = normalizeNode(resolved.target, resolved.pointer, [...trail, ref], environment);
+  return node === void 0 ? void 0 : { node, pointer: resolved.pointer };
+}
+function rewriteDraftKeywords(raw, pointer) {
+  const schema = { ...raw };
+  const conditionals = [];
+  for (const keyword of RESOLUTION_ONLY_KEYWORDS) {
+    delete schema[keyword];
+  }
+  if ("if" in schema) {
+    conditionals.push({
+      kind: "if",
+      if: schema["if"],
+      then: schema["then"],
+      else: schema["else"],
+      pointer
+    });
+  }
+  delete schema["if"];
+  delete schema["then"];
+  delete schema["else"];
+  for (const keyword of ["dependentRequired", "dependentSchemas", "dependencies"]) {
+    const entries = schema[keyword];
+    delete schema[keyword];
+    if (entries === null || typeof entries !== "object" || Array.isArray(entries)) {
+      continue;
+    }
+    for (const [property, value] of Object.entries(entries)) {
+      const entryPointer = appendPointer(pointer, keyword, property);
+      if (Array.isArray(value)) {
+        if (keyword !== "dependentSchemas") {
+          const required2 = value.filter((name) => typeof name === "string");
+          conditionals.push({
+            kind: "dependentRequired",
+            property,
+            required: required2,
+            pointer: entryPointer
+          });
+        }
+      } else if (keyword !== "dependentRequired") {
+        conditionals.push({
+          kind: "dependentSchemas",
+          property,
+          schema: value,
+          pointer: entryPointer
+        });
+      }
+    }
+  }
+  if (Array.isArray(schema["items"])) {
+    schema["prefixItems"] ??= schema["items"];
+    delete schema["items"];
+    if ("additionalItems" in schema) {
+      schema["items"] = schema["additionalItems"];
+    }
+  }
+  delete schema["additionalItems"];
+  for (const [exclusive, bound] of [
+    ["exclusiveMinimum", "minimum"],
+    ["exclusiveMaximum", "maximum"]
+  ]) {
+    if (schema[exclusive] === true && typeof schema[bound] === "number") {
+      schema[exclusive] = schema[bound];
+      delete schema[bound];
+    } else if (typeof schema[exclusive] === "boolean") {
+      delete schema[exclusive];
+    }
+  }
+  if ("example" in schema) {
+    schema["examples"] ??= [schema["example"]];
+    delete schema["example"];
+  }
+  const nullableKeyword = schema["nullable"] === true;
+  delete schema["nullable"];
+  return { schema, conditionals, nullableKeyword };
+}
+function nullablePair(schema) {
+  for (const keyword of ["oneOf", "anyOf"]) {
+    const branches = schema[keyword];
+    if (!Array.isArray(branches) || branches.length !== 2) {
+      continue;
+    }
+    const nullIndex = branches.findIndex(onlyAllowsNull);
+    if (nullIndex !== -1 && !onlyAllowsNull(branches[1 - nullIndex])) {
+      return { keyword, branch: branches[1 - nullIndex], index: 1 - nullIndex };
+    }
+  }
+  return void 0;
+}
+function onlyAllowsNull(schema) {
+  if (schema === null || typeof schema !== "object") {
+    return false;
+  }
+  const keywords = schema;
+  return keywords["type"] === "null" || keywords["const"] === null || Array.isArray(keywords["enum"]) && keywords["enum"].length === 1 && keywords["enum"][0] === null;
+}
+function withNull(types, addNull) {
+  if (types === void 0 || !addNull || types.includes("null")) {
+    return types;
+  }
+  return [...types, "null"];
+}
+function resolveType(allowedTypes, schema, pointer, environment) {
+  if (allowedTypes === void 0) {
+    return { type: inferType(schema), nullable: false };
+  }
+  const nonNull = allowedTypes.filter((type2) => type2 !== "null");
+  const distinct = nonNull.includes("number") ? nonNull.filter((type2) => type2 !== "integer") : nonNull;
+  if (distinct.length === 0) {
+    return { type: "null", nullable: false };
+  }
+  if (distinct.length > 1) {
+    environment.report({
+      severity: "warning",
+      code: "multi-type",
+      message: `The schema allows several types (${distinct.join(", ")}). The form uses the first one, ${distinct[0]}.`,
+      pointer
+    });
+  }
+  return { type: distinct[0], nullable: allowedTypes.includes("null") };
+}
+const STRING_KEYWORDS = ["format", "pattern", "minLength", "maxLength"];
+const NUMBER_KEYWORDS = [
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "multipleOf"
+];
+function inferType(schema) {
+  if (["properties", "additionalProperties", "patternProperties", "required"].some((k) => k in schema)) {
+    return "object";
+  }
+  if ("items" in schema || "prefixItems" in schema) {
+    return "array";
+  }
+  const values = "const" in schema ? [schema["const"]] : Array.isArray(schema["enum"]) ? schema["enum"] : constValues(schema["oneOf"]) ?? constValues(schema["anyOf"]);
+  if (values !== void 0 && values.length > 0) {
+    const types = [...new Set(values.map(typeOfValue))];
+    if (types.every((type2) => type2 === "integer" || type2 === "number")) {
+      return types.includes("number") ? "number" : "integer";
+    }
+    return types.length === 1 ? types[0] : void 0;
+  }
+  if (STRING_KEYWORDS.some((keyword) => keyword in schema)) {
+    return "string";
+  }
+  if (NUMBER_KEYWORDS.some((keyword) => keyword in schema)) {
+    return "number";
+  }
+  return void 0;
+}
+function constValues(branches) {
+  if (!Array.isArray(branches) || branches.length === 0) {
+    return void 0;
+  }
+  const values = [];
+  for (const branch of branches) {
+    if (branch === null || typeof branch !== "object" || !("const" in branch)) {
+      return void 0;
+    }
+    values.push(branch["const"]);
+  }
+  return values;
+}
+function typeOfValue(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? "integer" : "number";
+  }
+  if (typeof value === "string") {
+    return "string";
+  }
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
+  return "object";
+}
+const SINGLE_SUBSCHEMA_KEYWORDS = [
+  "additionalProperties",
+  "additionalItems",
+  "items",
+  "contains",
+  "not",
+  "if",
+  "then",
+  "else",
+  "propertyNames"
+];
+const SUBSCHEMA_LIST_KEYWORDS = ["allOf", "anyOf", "oneOf", "prefixItems", "items"];
+const SUBSCHEMA_MAP_KEYWORDS = [
+  "properties",
+  "patternProperties",
+  "dependentSchemas",
+  "dependencies"
+];
+function registerSubschemaPointers(schema, pointer, pointers) {
+  const register = (value, valuePointer) => {
+    if (value !== null && typeof value === "object" && !pointers.has(value)) {
+      pointers.set(value, valuePointer);
+    }
+  };
+  for (const keyword of SINGLE_SUBSCHEMA_KEYWORDS) {
+    if (!Array.isArray(schema[keyword])) {
+      register(schema[keyword], appendPointer(pointer, keyword));
+    }
+  }
+  for (const keyword of SUBSCHEMA_LIST_KEYWORDS) {
+    const list = schema[keyword];
+    if (Array.isArray(list)) {
+      list.forEach((value, index) => register(value, appendPointer(pointer, keyword, index)));
+    }
+  }
+  for (const keyword of SUBSCHEMA_MAP_KEYWORDS) {
+    const map = schema[keyword];
+    if (map !== null && typeof map === "object" && !Array.isArray(map)) {
+      for (const [name, value] of Object.entries(map)) {
+        register(value, appendPointer(pointer, keyword, name));
+      }
+    }
+  }
+}
+function discriminatorOf(unionSchema, branches) {
+  const openApi = unionSchema["discriminator"];
+  if (isRecord(openApi) && typeof openApi["propertyName"] === "string") {
+    const property = openApi["propertyName"];
+    const mapping = isRecord(openApi["mapping"]) ? openApi["mapping"] : {};
+    const values = branches.map(
+      (branch) => constOf(propertyOf(branch.schema, property)) ?? Object.keys(mapping).find((key) => mapping[key] === branch.ref) ?? branch.defName
+    );
+    return distinctValues(values) ? { property, values } : void 0;
+  }
+  const firstProperties = branches[0] ? propertiesOf(branches[0].schema) : {};
+  for (const property of Object.keys(firstProperties)) {
+    const values = branches.map((branch) => constOf(propertyOf(branch.schema, property)));
+    if (distinctValues(values)) {
+      return { property, values };
+    }
+  }
+  return void 0;
+}
+function distinctValues(values) {
+  return values.every((value) => value !== void 0) && new Set(values).size === values.length;
+}
+function constOf(schema) {
+  if (!isRecord(schema)) {
+    return void 0;
+  }
+  const value = "const" in schema ? schema["const"] : Array.isArray(schema["enum"]) && schema["enum"].length === 1 ? schema["enum"][0] : void 0;
+  return isLiteral(value) ? value : void 0;
+}
+function propertiesOf(schema) {
+  return isRecord(schema["properties"]) ? schema["properties"] : {};
+}
+function propertyOf(schema, property) {
+  return propertiesOf(schema)[property];
+}
+function isLiteral(value) {
+  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function asWidgetList(result) {
+  if (result === null || result === void 0) {
+    return [];
+  }
+  return Array.isArray(result) ? result : [result];
+}
+const COPIED_PATCH_FIELDS = [
+  "label",
+  "validator",
+  "defaultValue",
+  "readonly",
+  "size",
+  "uid"
+];
+function applyPatch(result, patch) {
+  const widgets = asWidgetList(result);
+  if (patch === void 0 || widgets.length === 0) {
+    return result;
+  }
+  const patched = { ...widgets[0] };
+  for (const field of COPIED_PATCH_FIELDS) {
+    if (patch[field] !== void 0) {
+      patched[field] = patch[field];
+    }
+  }
+  if (patch.props !== void 0) {
+    patched["props"] = { ...widgets[0].props, ...patch.props };
+  }
+  const patchedWidget = patched;
+  return Array.isArray(result) ? [patchedWidget, ...widgets.slice(1)] : patchedWidget;
+}
+function withIncludeCondition(result, when) {
+  const widgets = asWidgetList(result).map((widget) => {
+    const existing = widget.include;
+    const combined = existing !== void 0 && "when" in existing ? `(${existing.when}) && ${when}` : when;
+    return { ...widget, include: { when: combined } };
+  });
+  if (result === null || result === void 0) {
+    return result;
+  }
+  return Array.isArray(result) ? widgets : widgets[0];
+}
+function removeDuplicateWidgets(widgets, onRemoved) {
+  const seenPaths = /* @__PURE__ */ new Set();
+  const seenUids = /* @__PURE__ */ new Set();
+  const visitList = (list) => {
+    const kept = [];
+    for (const widget of list) {
+      if (widget.kind === "input" && typeof widget.path === "string") {
+        if (seenPaths.has(widget.path)) {
+          onRemoved(widget, "path");
+          continue;
+        }
+        seenPaths.add(widget.path);
+      }
+      if (typeof widget.uid === "string") {
+        if (seenUids.has(widget.uid)) {
+          onRemoved(widget, "uid");
+          continue;
+        }
+        seenUids.add(widget.uid);
+      }
+      kept.push(visitNested(widget));
+    }
+    return kept;
+  };
+  const visitNested = (widget) => {
+    let visited = widget;
+    if (Array.isArray(widget.children)) {
+      visited = { ...visited, children: visitList(widget.children) };
+    }
+    const template = widget.props?.["template"];
+    if (isWidget(template)) {
+      visited = { ...visited, props: { ...widget.props, template: visitNested(template) } };
+    }
+    return visited;
+  };
+  return visitList(widgets);
+}
+const KEY_ORDER = [
+  "kind",
+  "type",
+  "uid",
+  "actionType",
+  "path",
+  "label",
+  "include",
+  "exclude",
+  "disabled",
+  "readonly",
+  "defaultValue",
+  "validator",
+  "size",
+  "on",
+  "props",
+  "children"
+];
+function cleanWidget(widget) {
+  const rankOf = (key) => {
+    const rank = KEY_ORDER.indexOf(key.split(".")[0]);
+    return rank === -1 ? KEY_ORDER.length : rank;
+  };
+  const keys = Object.keys(widget).filter((key) => widget[key] !== void 0).map((key, position) => ({ key, position })).sort((first, second) => {
+    const byRank = rankOf(first.key) - rankOf(second.key);
+    if (byRank !== 0) {
+      return byRank;
+    }
+    const bySuffix = Number(first.key.includes(".")) - Number(second.key.includes("."));
+    return bySuffix !== 0 ? bySuffix : first.position - second.position;
+  });
+  const cleaned = {};
+  for (const { key } of keys) {
+    cleaned[key] = widget[key];
+  }
+  if (Array.isArray(widget.children)) {
+    cleaned["children"] = widget.children.map(cleanWidget);
+  }
+  if (widget.props !== void 0) {
+    const props = Object.fromEntries(
+      Object.entries(widget.props).filter(([, value]) => value !== void 0)
+    );
+    if (isWidget(props["template"])) {
+      props["template"] = cleanWidget(props["template"]);
+    }
+    cleaned["props"] = props;
+  }
+  return cleaned;
+}
+function isWidget(value) {
+  return value !== null && typeof value === "object" && typeof value.kind === "string" && typeof value.type === "string";
+}
+const DEFAULT_VENDOR_KEYWORD = "x-golemui";
+const DEFAULT_MAX_REF_DEPTH = 2;
+const DEFAULT_MAX_NODES = 2e3;
+const UNSUPPORTED_KEYWORDS = [
+  "not",
+  "contains",
+  "propertyNames",
+  "patternProperties",
+  "unevaluatedProperties",
+  "unevaluatedItems",
+  "$dynamicRef",
+  "$recursiveRef"
+];
+function fromJsonSchema(schema, options) {
+  return new Conversion(schema, options).run();
+}
+class Conversion {
+  constructor(schema, options) {
+    this.schema = schema;
+    this.options = options;
+    this.diagnostics = [];
+    this.pointers = /* @__PURE__ */ new WeakMap();
+    this.normalizedNodes = /* @__PURE__ */ new WeakMap();
+    this.childrenCache = /* @__PURE__ */ new WeakMap();
+    this.itemCache = /* @__PURE__ */ new WeakMap();
+    this.objectUnions = /* @__PURE__ */ new WeakMap();
+    this.states = /* @__PURE__ */ new Map();
+    this.stateCounters = /* @__PURE__ */ new Map();
+    this.widgetNodes = /* @__PURE__ */ new WeakMap();
+    this.builtNodes = 0;
+    this.preset = options.preset;
+    this.userRules = (options.rules ?? []).map(
+      (rule, index) => isDeclarativeRule(rule) ? this.declarativeRuleEntry(rule, `rule ${index}`) : {
+        name: rule.name ?? `rule ${index}`,
+        test: (node) => rule.when(node),
+        build: rule.build
+      }
+    );
+    const presetRules = this.preset.rules.map((rule, index) => ({
+      name: rule.name ?? `${this.preset.name} rule ${index}`,
+      test: (node) => rule.when(node),
+      build: rule.build
+    }));
+    this.allRules = [...this.userRules, ...presetRules];
+    this.refRoot = options.refRoot ?? (typeof schema === "object" ? schema : {});
+    this.vendorKeyword = options.vendorKeyword ?? DEFAULT_VENDOR_KEYWORD;
+    this.maxRefDepth = options.maxRefDepth ?? DEFAULT_MAX_REF_DEPTH;
+    this.maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
+  }
+  run() {
+    const root = this.createNode(this.schema, {
+      path: "",
+      pointer: "",
+      required: false,
+      repeaterDepth: 0,
+      refTrail: []
+    });
+    let widgets = [];
+    if (this.schema === false) {
+      this.diagnostics.push({
+        severity: "error",
+        code: "root-not-object",
+        message: "The root schema is `false`, so no data is valid and there is no form.",
+        path: "",
+        pointer: ""
+      });
+    } else if (root !== void 0 && root.type !== "object") {
+      this.report(root, {
+        severity: "error",
+        code: "root-not-object",
+        message: "Only an object schema at the root can become a form."
+      });
+    } else if (root !== void 0) {
+      widgets = this.buildRoot(root);
+    }
+    const form = removeDuplicateWidgets(this.preset.root(widgets), (widget, field) => {
+      const node = this.widgetNodes.get(widget);
+      this.diagnostics.push({
+        severity: "error",
+        code: field === "path" ? "duplicate-path" : "duplicate-uid",
+        message: `Two widgets have the ${field} \`${String(widget[field])}\`. The later one is removed.`,
+        path: node?.path ?? String(widget.path ?? ""),
+        pointer: node?.pointer ?? ""
+      });
+    });
+    const formDefinition = {
+      ...this.preset.schemaUrl === void 0 ? {} : { $schema: this.preset.schemaUrl },
+      ...this.states.size === 0 ? {} : {
+        states: Object.fromEntries(
+          [...this.states].map(([expression, name]) => [name, expression])
+        )
+      },
+      form: form.map(cleanWidget)
+    };
+    return {
+      formDefinition: this.options.transform?.(formDefinition) ?? formDefinition,
+      diagnostics: this.diagnostics
+    };
   }
-  if (typeof s.minLength === "number") {
-    v.minLength = s.minLength;
-    used = true;
+  /**
+   * The root object renders its properties directly. A layer that names a widget, or a user
+   * rule, can build it instead. The preset rules never do, they would wrap it in a group.
+   */
+  buildRoot(root) {
+    const patches = this.patchesFor(root);
+    const namedWidget = this.namedWidget(patches);
+    let result = namedWidget !== void 0 ? this.buildNamedWidget(namedWidget, root) : this.buildWithRules(root, 0, this.userRules);
+    if (result === void 0) {
+      return this.buildChildren(root);
+    }
+    for (const patch of patches) {
+      result = applyPatch(result, patch);
+    }
+    return asWidgetList(result);
   }
-  if (typeof s.maxLength === "number") {
-    v.maxLength = s.maxLength;
-    used = true;
+  /** Builds a node with every layer, see {@link fromJsonSchema}. */
+  buildNode(node) {
+    if (!this.countNode(node)) {
+      return null;
+    }
+    const patches = this.patchesFor(node);
+    if (patches.some((patch) => patch.skip === true)) {
+      return null;
+    }
+    const namedWidget = this.namedWidget(patches);
+    let result = namedWidget !== void 0 ? this.buildNamedWidget(namedWidget, node) : this.buildWithRules(node, 0, this.allRules);
+    if (result === void 0) {
+      this.report(node, {
+        severity: "error",
+        code: "unsupported-shape",
+        message: `No rule can build this ${node.type ?? "untyped"} schema, so it is not rendered.`
+      });
+      return null;
+    }
+    for (const patch of patches) {
+      result = applyPatch(result, patch);
+    }
+    for (const widget of asWidgetList(result)) {
+      this.widgetNodes.set(widget, node);
+    }
+    return result;
   }
-  if (typeof s.pattern === "string") {
-    v.pattern = s.pattern;
-    used = true;
+  /** The first rule from `startIndex` on that matches and does not decline builds the node. */
+  buildWithRules(node, startIndex, rules) {
+    for (let index = startIndex; index < rules.length; index++) {
+      const rule = rules[index];
+      let result;
+      try {
+        if (!rule.test(node)) {
+          continue;
+        }
+        result = rule.build(node, this.contextFor(node, index, rules));
+      } catch (error) {
+        this.report(node, {
+          severity: "warning",
+          code: "rule-error",
+          message: `${rule.name} threw (${errorMessage(error)}), so the next rule is used.`
+        });
+        continue;
+      }
+      if (result !== void 0) {
+        return applyPatch(result, rule.patch);
+      }
+    }
+    return void 0;
   }
-  if (typeof s.format === "string" && SUPPORTED_STRING_FORMATS.has(s.format)) {
-    if (s.format !== "date" && s.format !== "date-time") {
-      v.format = s.format;
-      used = true;
+  /**
+   * Builds the widget type a layer names. A type the preset does not know is most likely a
+   * custom widget of the app, so it becomes a plain input of that type.
+   */
+  buildNamedWidget(type2, node) {
+    const builder = this.preset.widgets[type2];
+    const context = this.contextFor(node, -1, this.allRules);
+    if (builder === void 0) {
+      this.report(node, {
+        severity: "info",
+        code: "custom-widget",
+        message: `The ${this.preset.name} preset has no \`${type2}\` widget, so a plain input of that type is built.`
+      });
+      return {
+        kind: "input",
+        type: type2,
+        path: node.path,
+        label: context.label(node),
+        validator: context.validator(node)
+      };
+    }
+    try {
+      return builder(node, context);
+    } catch (error) {
+      this.report(node, {
+        severity: "warning",
+        code: "rule-error",
+        message: `The \`${type2}\` builder threw (${errorMessage(error)}), so the rules are used.`
+      });
+      return this.buildWithRules(node, 0, this.allRules);
     }
   }
-  if (s.const !== void 0) {
-    v.const = s.const;
-    used = true;
+  /** @param ruleIndex - The rule that builds the node, `-1` for a named widget. */
+  contextFor(node, ruleIndex, rules) {
+    return {
+      next: (target = node) => this.buildWithRules(target, ruleIndex + 1, rules),
+      build: (target) => this.buildNode(target),
+      children: (target) => this.childrenOf(target),
+      buildChildren: (target) => this.buildChildren(target),
+      item: (target) => this.itemOf(target),
+      label: (target) => labelOf(target),
+      validator: (target) => this.preset.validator(target),
+      enumOptions: (target) => enumOptionsOf(target),
+      diagnostic: (diagnostic) => this.diagnostics.push({
+        ...diagnostic,
+        path: diagnostic.path ?? node.path,
+        pointer: diagnostic.pointer ?? node.pointer
+      })
+    };
   }
-  if (Array.isArray(s.enum)) {
-    v.enum = s.enum;
-    used = true;
+  buildChildren(node) {
+    const children = this.childrenOf(node);
+    const union = this.objectUnions.get(node.schema);
+    const widgets = union ? this.buildUnionChildren(node, children, union) : children.flatMap((child) => asWidgetList(this.buildNode(child)));
+    return this.applyConditionals(node, children, widgets);
   }
-  return used ? v : void 0;
-}
-function buildNumberValidator(s, required2, t) {
-  const v = { type: t };
-  let used = false;
-  if (required2) {
-    v.required = true;
-    used = true;
+  /**
+   * Compiles the conditionals of an object (`if/then/else`, `dependentRequired`,
+   * `dependentSchemas`) into its widgets:
+   * - a property only a branch defines is built once, visible for the branches that define it,
+   *   and placed after the last property the condition reads;
+   * - a declared property that a branch constrains gets a `validator.<state>` for that branch.
+   */
+  applyConditionals(owner, children, widgets) {
+    const branches = this.compileConditionals(owner);
+    if (branches.length === 0) {
+      return widgets;
+    }
+    const declared = new Map(
+      children.flatMap((child) => child.name === void 0 ? [] : [[child.name, child]])
+    );
+    const overlays = /* @__PURE__ */ new Map();
+    const definitions = /* @__PURE__ */ new Map();
+    const add = (map, name, entry) => map.set(name, [...map.get(name) ?? [], entry]);
+    for (const branch of branches) {
+      const schema = branch.schema?.schema ?? {};
+      const properties2 = recordOf(schema["properties"]);
+      const required2 = [...requiredOf(schema), ...branch.requiredNames].filter(
+        (name) => typeof name === "string"
+      );
+      for (const [name, raw] of Object.entries(properties2)) {
+        if (declared.has(name)) {
+          add(overlays, name, { branch, raw, required: required2.includes(name) });
+        } else {
+          add(definitions, name, {
+            branch,
+            raw,
+            required: required2.includes(name),
+            pointer: this.pointerOf(raw) ?? appendPointer(branch.schemaPointer, "properties", name)
+          });
+        }
+      }
+      for (const name of required2) {
+        if (!(name in properties2) && declared.has(name)) {
+          add(overlays, name, { branch, raw: void 0, required: true });
+        }
+      }
+    }
+    const withOverlays = this.applyOverlays(owner, declared, overlays, widgets);
+    return this.insertBranchProperties(owner, definitions, withOverlays);
   }
-  if (typeof s.minimum === "number") {
-    v.minimum = s.minimum;
-    used = true;
+  compileConditionals(owner) {
+    const conditionals = this.normalizedNodes.get(owner)?.conditionals ?? [];
+    const reference = (segments) => dataReference(owner, joinPath(owner.path, segments.join(".")));
+    const branches = [];
+    conditionals.forEach((conditional, group) => {
+      if (conditional.kind !== "if") {
+        branches.push({
+          condition: `${reference([conditional.property])} !== undefined`,
+          statePrefix: "dep",
+          group,
+          schema: conditional.kind === "dependentSchemas" ? this.normalizeBranch(owner, conditional.schema, conditional.pointer) : void 0,
+          schemaPointer: conditional.pointer,
+          requiredNames: conditional.kind === "dependentRequired" ? conditional.required : [],
+          reads: [conditional.property]
+        });
+        return;
+      }
+      const compiled = compileCondition(conditional.if, reference);
+      if ("unsupported" in compiled) {
+        this.diagnostics.push({
+          severity: "warning",
+          code: "if-unsupported",
+          message: `The \`if\` uses \`${compiled.unsupported}\`, which has no expression equivalent. The \`then\` and \`else\` properties are always shown and optional.`,
+          path: owner.path,
+          pointer: appendPointer(conditional.pointer, "if")
+        });
+      } else if (compiled.vacuous) {
+        this.diagnostics.push({
+          severity: "info",
+          code: "if-vacuous",
+          message: "The `if` also holds when a property it tests is absent, because that property is not in `if.required`. JSON Schema defines it that way.",
+          path: owner.path,
+          pointer: appendPointer(conditional.pointer, "if")
+        });
+      }
+      const condition = "unsupported" in compiled ? void 0 : compiled.expression;
+      for (const side of ["then", "else"]) {
+        const raw = conditional[side];
+        if (raw === void 0) {
+          continue;
+        }
+        const schemaPointer = appendPointer(conditional.pointer, side);
+        branches.push({
+          condition: condition === void 0 ? void 0 : side === "then" ? condition : `!(${condition})`,
+          statePrefix: "if",
+          group,
+          side,
+          schema: this.normalizeBranch(owner, raw, schemaPointer),
+          schemaPointer,
+          requiredNames: [],
+          reads: "unsupported" in compiled ? [] : compiled.reads
+        });
+      }
+    });
+    return branches;
   }
-  if (typeof s.maximum === "number") {
-    v.maximum = s.maximum;
-    used = true;
+  normalizeBranch(owner, raw, pointer) {
+    const branchPointer = this.pointerOf(raw) ?? pointer;
+    const node = normalizeNode(
+      raw,
+      branchPointer,
+      this.refTrailOf(owner),
+      this.environmentFor(owner.path)
+    );
+    if (node !== void 0 && node.conditionals.length > 0) {
+      this.diagnostics.push({
+        severity: "warning",
+        code: "nested-conditional",
+        message: "A conditional inside a conditional branch is not supported, so it is not applied.",
+        path: owner.path,
+        pointer: branchPointer
+      });
+    }
+    return node;
   }
-  if (typeof s.exclusiveMinimum === "number") {
-    v.exclusiveMinimum = s.exclusiveMinimum;
-    used = true;
+  /**
+   * Adds `validator.<state>` to the widget of each declared property a branch constrains. One
+   * state applies per field at a time, so only these combinations are expressible: required
+   * from any number of conditions (one state that ORs them), or the branches of one conditional
+   * (they never hold together). Anything else keeps the first conditional and warns.
+   */
+  applyOverlays(owner, declared, overlays, widgets) {
+    let updated = widgets;
+    for (const [name, list] of overlays) {
+      const child = declared.get(name);
+      const compiled = list.filter((overlay) => overlay.branch.condition !== void 0);
+      if (compiled.length === 0) {
+        continue;
+      }
+      if (innermostItemNode(owner) !== void 0) {
+        this.report(child, {
+          severity: "warning",
+          code: "conditional-validator-in-repeater",
+          message: `Inside a repeater a condition can only show or hide widgets, so the conditional constraints of \`${name}\` are not applied.`
+        });
+        continue;
+      }
+      const validators = {};
+      for (const selected of this.selectOverlays(child, compiled)) {
+        const state = this.stateFor(selected.prefix, selected.condition);
+        const validator = this.preset.validator(
+          this.derivedNode(child, selected.raw, selected.required || child.required)
+        );
+        if (validator !== void 0) {
+          validators[`validator.${state}`] = validator;
+        }
+      }
+      const index = updated.findIndex(
+        (widget) => widget.kind === "input" && widget.path === child.path
+      );
+      if (index === -1) {
+        this.report(child, {
+          severity: "warning",
+          code: "overlay-limit",
+          message: `\`${name}\` is not built as one input, so its conditional constraints are not applied.`
+        });
+        continue;
+      }
+      updated = [...updated];
+      updated[index] = { ...updated[index], ...validators };
+    }
+    return updated;
   }
-  if (typeof s.exclusiveMaximum === "number") {
-    v.exclusiveMaximum = s.exclusiveMaximum;
-    used = true;
+  selectOverlays(child, overlays) {
+    if (overlays.every((overlay) => overlay.raw === void 0)) {
+      const conditions = [
+        ...new Set(overlays.map((overlay) => overlay.branch.condition))
+      ];
+      return [
+        {
+          condition: orConditions(conditions),
+          raw: void 0,
+          required: true,
+          prefix: conditions.length === 1 ? overlays[0].branch.statePrefix : "required"
+        }
+      ];
+    }
+    const firstGroup = overlays[0].branch.group;
+    const inFirstGroup = overlays.filter((overlay) => overlay.branch.group === firstGroup);
+    if (inFirstGroup.length < overlays.length) {
+      this.report(child, {
+        severity: "warning",
+        code: "overlay-limit",
+        message: `\`${child.name}\` gets constraints from several conditions. Only the first condition is applied.`
+      });
+    }
+    return inFirstGroup.map((overlay) => ({
+      condition: overlay.branch.condition,
+      raw: overlay.raw,
+      required: overlay.required,
+      prefix: overlay.branch.statePrefix
+    }));
   }
-  if (typeof s.multipleOf === "number") {
-    v.multipleOf = s.multipleOf;
-    used = true;
+  /** The node with the constraints of a branch merged in, for the validator of that branch. */
+  derivedNode(node, raw, required2) {
+    if (raw === void 0) {
+      return { ...node, required: required2 };
+    }
+    const merged = normalizeNode(
+      { allOf: [node.schema, raw] },
+      node.pointer,
+      this.refTrailOf(node),
+      this.environmentFor(node.path)
+    );
+    return merged === void 0 ? { ...node, required: required2 } : { ...node, schema: merged.schema, type: merged.type ?? node.type, required: required2 };
   }
-  return used ? v : void 0;
-}
-function buildBooleanValidator(s, required2) {
-  const v = { type: "boolean" };
-  let used = false;
-  if (required2) {
-    v.required = true;
-    used = true;
+  /**
+   * Builds each property that only conditional branches define, once, visible when one of those
+   * branches applies. It goes after the last property its condition reads, or at the end.
+   */
+  insertBranchProperties(owner, definitions, widgets) {
+    const result = [...widgets];
+    const inserted = /* @__PURE__ */ new Set();
+    for (const [name, list] of definitions) {
+      const [first] = list;
+      const path = joinPath(owner.path, name);
+      if (!this.isValidPropertyName(name, path, first.pointer)) {
+        continue;
+      }
+      const unconditional = list.some((definition) => definition.branch.condition === void 0);
+      const child = this.createNode(first.raw, {
+        parent: owner,
+        name,
+        path,
+        pointer: first.pointer,
+        required: !unconditional && list.every((definition) => definition.required),
+        repeaterDepth: owner.repeaterDepth,
+        refTrail: first.branch.schema?.refTrail ?? this.refTrailOf(owner)
+      });
+      if (child === void 0) {
+        continue;
+      }
+      if (list.some((entry) => !jsonEqual(entry.raw, first.raw) || entry.required !== first.required)) {
+        this.report(child, {
+          severity: "warning",
+          code: "branch-schema-conflict",
+          message: `The branches define \`${name}\` differently. The form uses the first definition.`
+        });
+      }
+      let built = this.buildNode(child);
+      if (!unconditional && !coversBothSides(list)) {
+        const conditions = [
+          ...new Set(list.map((definition) => definition.branch.condition))
+        ];
+        built = withIncludeCondition(built, orConditions(conditions));
+      }
+      const readPaths = first.branch.reads.map((read) => joinPath(owner.path, read));
+      let position = result.reduce(
+        (last, widget, index) => readPaths.includes(String(widget.path)) ? index + 1 : last,
+        result.length
+      );
+      if (position < result.length || readPaths.length > 0) {
+        while (position < result.length && inserted.has(result[position])) {
+          position++;
+        }
+      }
+      const builtWidgets = asWidgetList(built);
+      builtWidgets.forEach((widget) => inserted.add(widget));
+      result.splice(position, 0, ...builtWidgets);
+    }
+    return result;
   }
-  if (s.const !== void 0) {
-    v.const = s.const;
-    used = true;
+  /** The name of the state for an expression. The same expression always gets the same state. */
+  stateFor(prefix, expression) {
+    const existing = this.states.get(expression);
+    if (existing !== void 0) {
+      return existing;
+    }
+    const count = (this.stateCounters.get(prefix) ?? 0) + 1;
+    this.stateCounters.set(prefix, count);
+    const name = `${prefix}${String(count).padStart(2, "0")}`;
+    this.states.set(expression, name);
+    return name;
   }
-  return used ? v : void 0;
-}
-const SECRET_HINTS = /(password|secret|api[_-]?key|token)/i;
-const LONG_TEXT_MIN_LENGTH = 200;
-const SELECT_THRESHOLD = 6;
-function jsonSchemaToGui(schema, opts = {}) {
-  const unmapped = [];
-  const root = unwrap(schema);
-  const fields = [];
-  if (root.type === "object" || root.properties) {
-    const required2 = new Set(root.required ?? []);
-    for (const [name, propSchema] of Object.entries(root.properties ?? {})) {
-      const widget = mapProperty(name, unwrap(propSchema), required2.has(name), "", unmapped);
-      if (widget) fields.push(widget);
+  /**
+   * Builds an object whose `oneOf`/`anyOf` branches are objects. The discriminator becomes one
+   * selector, in its own place when the object declares it, after the declared properties
+   * otherwise. Then every branch property is built once, visible only for the branches that
+   * define it, so no two widgets ever share a path.
+   */
+  buildUnionChildren(owner, children, union) {
+    const { discriminator } = union;
+    const widgets = [];
+    let selectorBuilt = false;
+    for (const child of children) {
+      if (discriminator !== void 0 && child.name === discriminator.property) {
+        widgets.push(...this.buildSelector(owner, union, discriminator));
+        selectorBuilt = true;
+      } else {
+        widgets.push(...asWidgetList(this.buildNode(child)));
+      }
     }
-  } else {
-    unmapped.push({
-      path: "",
-      reason: "Top-level JSON Schema is not an object — only object schemas map to forms."
+    if (discriminator === void 0) {
+      this.report(owner, {
+        severity: "warning",
+        code: "no-discriminator",
+        message: `No property tells the \`${union.keyword}\` branches apart (a \`const\` in every branch, or \`discriminator.propertyName\`). Every branch property is rendered, optional and always visible.`
+      });
+    } else if (!selectorBuilt) {
+      widgets.push(...this.buildSelector(owner, union, discriminator));
+    }
+    widgets.push(...this.buildUnionProperties(owner, union));
+    return widgets;
+  }
+  /**
+   * The discriminator as an enumeration of the branch values, labelled by the branch titles. A
+   * declaration next to the union keeps its annotations, e.g. its title.
+   */
+  buildSelector(owner, union, discriminator) {
+    const { property, values } = discriminator;
+    const declared = recordOf(owner.schema["properties"])[property];
+    const firstBranchDeclaration = recordOf(union.branches[0].normalized.schema["properties"])[property];
+    const choices = {
+      oneOf: union.branches.map((branch, index) => ({
+        const: values[index],
+        title: branchTitle(branch, values[index])
+      }))
+    };
+    const raw = declared !== void 0 ? { allOf: [declared, choices] } : { title: recordOf(firstBranchDeclaration)["title"], ...choices };
+    const node = this.createNode(raw, {
+      parent: owner,
+      name: property,
+      path: joinPath(owner.path, property),
+      pointer: this.pointerOf(declared) ?? this.pointerOf(firstBranchDeclaration) ?? appendPointer(owner.pointer, "properties", property),
+      required: requiredOf(owner.schema).includes(property) || union.branches.every((branch) => requiredOf(branch.normalized.schema).includes(property)),
+      repeaterDepth: owner.repeaterDepth,
+      refTrail: this.refTrailOf(owner)
     });
+    return node === void 0 ? [] : asWidgetList(this.buildNode(node));
   }
-  if (opts.submitAction !== false) {
-    fields.push({
-      kind: "action",
-      type: "button",
-      actionType: "submit",
-      label: opts.submitLabel ?? "Submit",
-      props: { variant: "filled" }
+  /** Builds each branch property once, see {@link Conversion.buildUnionChildren}. */
+  buildUnionProperties(owner, union) {
+    const { discriminator } = union;
+    const declared = recordOf(owner.schema["properties"]);
+    const definitions = /* @__PURE__ */ new Map();
+    union.branches.forEach((branch, branchIndex) => {
+      const required2 = requiredOf(branch.normalized.schema);
+      for (const [name, raw] of Object.entries(recordOf(branch.normalized.schema["properties"]))) {
+        if (name === discriminator?.property) {
+          continue;
+        }
+        const pointer = this.pointerOf(raw) ?? appendPointer(branch.pointer, "properties", name);
+        if (name in declared) {
+          if (!jsonEqual(raw, declared[name])) {
+            this.diagnostics.push({
+              severity: "warning",
+              code: "branch-schema-conflict",
+              message: `\`${name}\` is declared next to the union and again in a branch. The declaration next to the union is used.`,
+              path: joinPath(owner.path, name),
+              pointer
+            });
+          }
+          continue;
+        }
+        const list = definitions.get(name) ?? [];
+        list.push({
+          branchIndex,
+          raw,
+          required: required2.includes(name),
+          pointer,
+          refTrail: branch.normalized.refTrail
+        });
+        definitions.set(name, list);
+      }
     });
+    const widgets = [];
+    for (const [name, list] of definitions) {
+      const [first] = list;
+      const path = joinPath(owner.path, name);
+      if (!this.isValidPropertyName(name, path, first.pointer)) {
+        continue;
+      }
+      const child = this.createNode(first.raw, {
+        parent: owner,
+        name,
+        path,
+        pointer: first.pointer,
+        // Without a discriminator no branch is known to be active, so nothing is required.
+        required: discriminator !== void 0 && first.required,
+        repeaterDepth: owner.repeaterDepth,
+        refTrail: first.refTrail
+      });
+      if (child === void 0) {
+        continue;
+      }
+      if (list.some((entry) => !jsonEqual(entry.raw, first.raw) || entry.required !== first.required)) {
+        this.report(child, {
+          severity: "warning",
+          code: "branch-schema-conflict",
+          message: `The branches define \`${name}\` differently. The form uses the first definition.`
+        });
+      }
+      let result = this.buildNode(child);
+      if (discriminator !== void 0 && list.length < union.branches.length) {
+        const reference = dataReference(owner, joinPath(owner.path, discriminator.property));
+        const branchValues = list.map((entry) => discriminator.values[entry.branchIndex]);
+        result = withIncludeCondition(result, equalsAny(reference, branchValues));
+      }
+      widgets.push(...asWidgetList(result));
+    }
+    return widgets;
   }
-  const wrapped = opts.layout && opts.layout !== "vertical" ? [
-    {
-      kind: "layout",
-      type: opts.layout === "grid" ? "grid" : "flex",
-      props: opts.layout === "grid" ? { columnGap: 12, rowGap: 12 } : { direction: "row", gap: 12 },
-      children: fields
+  /**
+   * The union of object branches of a node, `undefined` when it has none. The branches are
+   * normalized once, here, and the result is cached.
+   */
+  objectUnionOf(normalized, pointer, path) {
+    const cached = this.objectUnions.get(normalized.schema);
+    if (cached !== void 0) {
+      return cached ?? void 0;
     }
-  ] : fields;
-  return {
-    formDefinition: { $schema: FORM_SCHEMA_URL, form: wrapped },
-    unmapped
-  };
-}
-function unwrap(schema) {
-  if (schema.oneOf?.length === 2) {
-    const nonNull = schema.oneOf.find((s) => s.type !== "null");
-    if (nonNull) return { ...nonNull, ...stripBranches(schema) };
+    let union = null;
+    const keyword = ["oneOf", "anyOf"].find(
+      (candidate) => Array.isArray(normalized.schema[candidate]) && !isConstUnion(normalized.schema[candidate])
+    );
+    if (keyword !== void 0) {
+      const environment = this.environmentFor(path);
+      const branches = normalized.schema[keyword].flatMap((raw, index) => {
+        const branchPointer = this.pointerOf(raw) ?? appendPointer(pointer, keyword, index);
+        const node = normalizeNode(raw, branchPointer, normalized.refTrail, environment);
+        return node === void 0 ? [] : [{ raw, pointer: branchPointer, normalized: node }];
+      });
+      if (branches.length > 0 && branches.every((branch) => branch.normalized.type === "object")) {
+        const discriminator = discriminatorOf(
+          normalized.schema,
+          branches.map((branch) => ({
+            schema: branch.normalized.schema,
+            ref: refOf(branch.raw),
+            defName: branch.normalized.defName
+          }))
+        );
+        union = { keyword, branches, discriminator };
+      }
+    }
+    this.objectUnions.set(normalized.schema, union);
+    return union ?? void 0;
   }
-  if (schema.anyOf?.length === 2) {
-    const nonNull = schema.anyOf.find((s) => s.type !== "null");
-    if (nonNull) return { ...nonNull, ...stripBranches(schema) };
+  /** The hint, the `$defs` override and the path override of a node, least specific first. */
+  patchesFor(node) {
+    const overrides = this.options.overrides ?? {};
+    const definitionOverride = node.defName !== void 0 ? overrides[`$defs/${node.defName}`] : void 0;
+    return [node.hint, definitionOverride, overrides[node.path]].filter(
+      (patch) => patch !== void 0
+    );
   }
-  return schema;
-}
-function stripBranches(s) {
-  const { oneOf: oneOf2, anyOf, ...rest } = s;
-  return rest;
-}
-function mapProperty(name, schema, required2, parentPath, unmapped) {
-  const path = parentPath ? `${parentPath}.${name}` : name;
-  const label = humanLabel(schema.title ?? name);
-  const t = Array.isArray(schema.type) ? schema.type.find((x) => x !== "null") : schema.type;
-  if (Array.isArray(schema.enum) && schema.enum.every((v) => typeof v === "string")) {
-    return buildEnumField(path, name, label, schema, required2);
+  namedWidget(patches) {
+    return [...patches].reverse().find((patch) => patch.widget !== void 0)?.widget;
   }
-  switch (t) {
-    case "string":
-      return buildStringField(path, name, label, schema, required2);
-    case "number":
-    case "integer":
-      return buildNumberField(path, label, schema, required2, t);
-    case "boolean":
-      return buildBooleanField(path, label, schema, required2);
-    case "object":
-      return buildObjectGroup(path, name, label, schema, unmapped);
-    case "array":
-      return buildArrayField(path, name, label, schema, required2, unmapped);
-    default:
-      unmapped.push({
+  declarativeRuleEntry(rule, fallbackName) {
+    return {
+      name: rule.name ?? fallbackName,
+      test: (node) => matchesDeclarativeRule(rule, node),
+      build: (node, context) => {
+        if (rule.skip === true) {
+          return null;
+        }
+        return rule.widget !== void 0 ? this.buildNamedWidget(rule.widget, node) : context.next();
+      },
+      patch: {
+        label: rule.label,
+        props: rule.props,
+        validator: rule.validator,
+        defaultValue: rule.defaultValue,
+        readonly: rule.readonly,
+        size: rule.size,
+        uid: rule.uid
+      }
+    };
+  }
+  /** The child nodes of an object or a tuple, see {@link BuildContext.children}. */
+  childrenOf(node) {
+    const cached = this.childrenCache.get(node);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const children = node.type === "object" ? this.propertyNodes(node) : node.type === "array" ? this.tupleNodes(node) : [];
+    this.childrenCache.set(node, children);
+    return children;
+  }
+  propertyNodes(node) {
+    const properties2 = node.schema["properties"];
+    if (properties2 === null || typeof properties2 !== "object") {
+      return [];
+    }
+    const required2 = Array.isArray(node.schema["required"]) ? node.schema["required"] : [];
+    const children = [];
+    for (const name of this.orderedNames(node, Object.keys(properties2))) {
+      const path = joinPath(node.path, name);
+      const pointer = appendPointer(node.pointer, "properties", name);
+      if (!this.isValidPropertyName(name, path, pointer)) {
+        continue;
+      }
+      const child = this.createNode(properties2[name], {
+        parent: node,
+        name,
         path,
-        reason: `Unsupported JSON Schema type \`${schema.type ?? "undefined"}\`.`
+        pointer,
+        required: required2.includes(name),
+        repeaterDepth: node.repeaterDepth,
+        refTrail: this.refTrailOf(node)
       });
-      return null;
+      if (child !== void 0) {
+        children.push(child);
+      }
+    }
+    return children;
   }
-}
-function buildStringField(path, name, label, schema, required2) {
-  const validator = buildStringValidator(schema, required2);
-  const isSecret = SECRET_HINTS.test(name);
-  const isLong = (schema.maxLength ?? 0) >= LONG_TEXT_MIN_LENGTH;
-  if (schema.format === "date") {
-    return cleanFields({ kind: "input", type: "dateInput", path, label, validator });
+  /** False for a name that cannot be a path segment. Warns about a name the form reads as an index. */
+  isValidPropertyName(name, path, pointer) {
+    if (name === "" || name.includes(".")) {
+      this.diagnostics.push({
+        severity: "error",
+        code: "invalid-property-name",
+        message: `The property name "${name}" cannot be part of a form path, so it is not rendered.`,
+        path,
+        pointer
+      });
+      return false;
+    }
+    if (/^\d+$/.test(name)) {
+      this.diagnostics.push({
+        severity: "warning",
+        code: "numeric-property-name",
+        message: `The form writes "${name}" as an array index, so this object becomes an array.`,
+        path,
+        pointer
+      });
+    }
+    return true;
   }
-  if (schema.format === "date-time") {
-    return cleanFields({ kind: "input", type: "datePicker", path, label, validator });
+  /**
+   * Property names in the `order` of the most specific layer that has one: the path override,
+   * the `$defs` override, the hint, then the first matching declarative rule.
+   */
+  orderedNames(node, names) {
+    const order = [...this.patchesFor(node)].reverse().find((patch) => patch.order)?.order ?? this.declarativeOrder(node);
+    if (order === void 0) {
+      return names;
+    }
+    const listed = order.filter((name) => name !== "*" && names.includes(name));
+    const rest = names.filter((name) => !listed.includes(name));
+    const restIndex = order.indexOf("*");
+    if (restIndex === -1) {
+      return [...listed, ...rest];
+    }
+    const before = order.slice(0, restIndex).filter((name) => listed.includes(name));
+    const after = order.slice(restIndex + 1).filter((name) => listed.includes(name));
+    return [...before, ...rest, ...after];
   }
-  if (isSecret) {
-    return cleanFields({ kind: "input", type: "password", path, label, validator });
+  declarativeOrder(node) {
+    for (const rule of this.options.rules ?? []) {
+      if (!isDeclarativeRule(rule) || rule.order === void 0) {
+        continue;
+      }
+      try {
+        if (matchesDeclarativeRule(rule, node)) {
+          return rule.order;
+        }
+      } catch {
+      }
+    }
+    return void 0;
   }
-  if (isLong) {
-    return cleanFields({
-      kind: "input",
-      type: "textarea",
-      path,
-      label,
-      validator,
-      props: schema.description ? { hint: schema.description } : void 0
+  tupleNodes(node) {
+    const positions = node.schema["prefixItems"];
+    if (!Array.isArray(positions)) {
+      return [];
+    }
+    const minItems = typeof node.schema["minItems"] === "number" ? node.schema["minItems"] : 0;
+    return positions.flatMap((raw, index) => {
+      const child = this.createNode(raw, {
+        parent: node,
+        path: joinPath(node.path, String(index)),
+        pointer: appendPointer(node.pointer, "prefixItems", index),
+        required: index < minItems,
+        repeaterDepth: node.repeaterDepth,
+        refTrail: this.refTrailOf(node)
+      });
+      return child === void 0 ? [] : [child];
     });
   }
-  return cleanFields({
-    kind: "input",
-    type: "textinput",
-    path,
-    label,
-    validator,
-    props: schema.description ? { hint: schema.description } : void 0
-  });
-}
-function buildEnumField(path, name, label, schema, required2) {
-  const values = schema.enum ?? [];
-  const validator = required2 ? { type: "string", required: true, enum: values } : { type: "string", enum: values };
-  if (values.length <= SELECT_THRESHOLD) {
-    return cleanFields({
-      kind: "input",
-      type: "select",
+  itemOf(node) {
+    if (this.itemCache.has(node)) {
+      return this.itemCache.get(node);
+    }
+    const items = node.schema["items"];
+    const item = node.type === "array" && items !== void 0 && items !== false ? this.createNode(items, {
+      parent: node,
+      path: joinPath(node.path, "items"),
+      pointer: appendPointer(node.pointer, "items"),
+      required: false,
+      repeaterDepth: node.repeaterDepth + 1,
+      refTrail: this.refTrailOf(node)
+    }) : void 0;
+    this.itemCache.set(node, item);
+    return item;
+  }
+  createNode(raw, placement) {
+    const pointer = this.pointerOf(raw) ?? placement.pointer;
+    const normalized = normalizeNode(
+      raw,
+      pointer,
+      placement.refTrail,
+      this.environmentFor(placement.path)
+    );
+    if (normalized === void 0) {
+      return void 0;
+    }
+    if (this.objectUnionOf(normalized, pointer, placement.path) && normalized.type === void 0) {
+      normalized.type = "object";
+      normalized.schema["type"] = "object";
+    }
+    const node = {
+      schema: normalized.schema,
+      type: normalized.type,
+      nullable: normalized.nullable,
+      path: placement.path,
+      name: placement.name,
+      defName: normalized.defName,
+      pointer,
+      required: placement.required,
+      repeaterDepth: placement.repeaterDepth,
+      hint: this.hintOf(normalized, placement.path, pointer),
+      parent: placement.parent
+    };
+    this.normalizedNodes.set(node, normalized);
+    this.reportUnsupported(node, normalized);
+    return node;
+  }
+  hintOf(normalized, path, pointer) {
+    if (this.vendorKeyword === false || !(this.vendorKeyword in normalized.schema)) {
+      return void 0;
+    }
+    const hint = normalized.schema[this.vendorKeyword];
+    if (hint !== null && typeof hint === "object" && !Array.isArray(hint)) {
+      return hint;
+    }
+    this.diagnostics.push({
+      severity: "warning",
+      code: "invalid-hint",
+      message: `\`${this.vendorKeyword}\` must be an object, so it is ignored.`,
       path,
-      label,
-      validator,
-      props: {
-        options: values.map((v) => ({ label: humanLabel(v), value: v }))
-      }
+      pointer
     });
+    return void 0;
   }
-  return cleanFields({
-    kind: "input",
-    type: "dropdown",
-    path,
-    label,
-    validator,
-    props: {
-      labelField: "label",
-      valueField: "value",
-      items: values.map((v) => ({ label: humanLabel(v), value: v }))
+  reportUnsupported(node, normalized) {
+    for (const keyword of UNSUPPORTED_KEYWORDS) {
+      if (keyword in node.schema) {
+        this.report(node, {
+          severity: "warning",
+          code: "unsupported-keyword",
+          message: `\`${keyword}\` has no form equivalent, so the form does not check it.`
+        });
+      }
+    }
+    const additional = node.schema["additionalProperties"];
+    if (additional !== null && typeof additional === "object") {
+      this.report(node, {
+        severity: "warning",
+        code: "unsupported-keyword",
+        message: "No widget edits free-form keys (`additionalProperties` with a schema). Only the declared properties are rendered."
+      });
+    }
+    const objectUnion = this.objectUnions.get(node.schema);
+    for (const keyword of ["oneOf", "anyOf"]) {
+      const branches = node.schema[keyword];
+      if (Array.isArray(branches) && !isConstUnion(branches) && objectUnion?.keyword !== keyword) {
+        this.report(node, {
+          severity: "warning",
+          code: "unsupported-keyword",
+          message: `\`${keyword}\` is only supported with object branches, so its branches are not rendered.`
+        });
+      }
+    }
+    if (node.type !== "object") {
+      for (const conditional of normalized.conditionals) {
+        this.diagnostics.push({
+          severity: "warning",
+          code: "unsupported-keyword",
+          message: `\`${conditional.kind}\` is only supported on objects, so it is not applied.`,
+          path: node.path,
+          pointer: conditional.pointer
+        });
+      }
     }
-  });
-}
-function buildNumberField(path, label, schema, required2, t) {
-  const validator = buildNumberValidator(schema, required2, t);
-  return cleanFields({
-    kind: "input",
-    type: "number",
-    path,
-    label,
-    validator,
-    props: schema.description ? { hint: schema.description } : void 0
-  });
-}
-function buildBooleanField(path, label, schema, required2) {
-  const validator = buildBooleanValidator(schema, required2);
-  return cleanFields({ kind: "input", type: "checkbox", path, label, validator });
-}
-function buildObjectGroup(path, _name, _label, schema, unmapped) {
-  const required2 = new Set(schema.required ?? []);
-  const children = [];
-  for (const [childName, childSchema] of Object.entries(schema.properties ?? {})) {
-    const w = mapProperty(childName, unwrap(childSchema), required2.has(childName), path, unmapped);
-    if (w) children.push(w);
   }
-  if (!children.length) {
-    unmapped.push({ path, reason: "Object has no mappable properties." });
-    return null;
+  refTrailOf(node) {
+    return this.normalizedNodes.get(node)?.refTrail ?? [];
   }
-  return {
-    kind: "layout",
-    type: "flex",
-    props: { direction: "column", gap: 8 },
-    children
-  };
-}
-function buildArrayField(path, _name, label, schema, required2, unmapped) {
-  const items = schema.items ? unwrap(schema.items) : void 0;
-  if (!items) {
-    unmapped.push({ path, reason: "Array without `items` schema cannot be mapped." });
-    return null;
+  /** The document pointer recorded for a subschema object. */
+  pointerOf(raw) {
+    return raw !== null && typeof raw === "object" ? this.pointers.get(raw) : void 0;
   }
-  if (items.type === "object") {
-    const templateChildren = [];
-    const required22 = new Set(items.required ?? []);
-    const childParent = `${path}.items`;
-    for (const [childName, childSchema] of Object.entries(items.properties ?? {})) {
-      const w = mapProperty(
-        childName,
-        unwrap(childSchema),
-        required22.has(childName),
-        childParent,
-        unmapped
-      );
-      if (w) templateChildren.push(w);
-    }
-    if (!templateChildren.length) {
-      unmapped.push({ path, reason: "Array of objects has no mappable item properties." });
-      return null;
-    }
+  /** Normalization problems get the form data path of the node being normalized. */
+  environmentFor(path) {
     return {
-      kind: "input",
-      type: "repeater",
-      path,
-      label,
-      props: {
-        addLabel: `Add ${singular(label).toLowerCase()}`,
-        removeLabel: "Remove",
-        template: {
-          kind: "layout",
-          type: "flex",
-          props: { direction: "column", gap: 8 },
-          children: templateChildren
-        }
-      }
+      root: this.refRoot,
+      maxRefDepth: this.maxRefDepth,
+      pointers: this.pointers,
+      report: (problem) => this.diagnostics.push({ ...problem, path })
     };
   }
-  if (items.type === "string" || items.type === "number" || items.type === "integer") {
-    const validator = buildArrayValidator(schema, required2);
-    return cleanFields({
-      kind: "input",
-      type: "tags",
-      path,
-      label,
-      validator,
-      props: schema.description ? { placeholder: "Add and press Enter", hint: schema.description } : { placeholder: "Add and press Enter" }
-    });
+  /** Counts a node, false once `maxNodes` is reached. The limit is reported once. */
+  countNode(node) {
+    this.builtNodes++;
+    if (this.builtNodes === this.maxNodes + 1) {
+      this.report(node, {
+        severity: "error",
+        code: "max-nodes",
+        message: `The schema has more than ${this.maxNodes} nodes, so the rest is not rendered.`
+      });
+    }
+    return this.builtNodes <= this.maxNodes;
   }
-  unmapped.push({
-    path,
-    reason: "Array shape is not mappable (only arrays of objects → repeater, or arrays of strings/numbers → tags)."
-  });
-  return null;
-}
-function buildArrayValidator(s, required2) {
-  const v = { type: "array" };
-  let used = false;
-  if (required2) {
-    v.required = true;
-    used = true;
+  report(node, diagnostic) {
+    this.diagnostics.push({ ...diagnostic, path: node.path, pointer: node.pointer });
   }
-  if (typeof s.minItems === "number") {
-    v.minItems = s.minItems;
-    used = true;
+}
+function labelOf(node) {
+  const title2 = node.schema["title"];
+  if (typeof title2 === "string" && title2 !== "") {
+    return title2;
   }
-  if (typeof s.maxItems === "number") {
-    v.maxItems = s.maxItems;
-    used = true;
+  return node.name !== void 0 ? humanize(node.name) : void 0;
+}
+function orConditions(conditions) {
+  return conditions.length === 1 ? conditions[0] : conditions.map((condition) => `(${condition})`).join(" || ");
+}
+function coversBothSides(definitions) {
+  return definitions.some(
+    (definition) => definition.branch.side === "then" && definitions.some(
+      (other) => other.branch.group === definition.branch.group && other.branch.side === "else"
+    )
+  );
+}
+function branchTitle(branch, value) {
+  const title2 = branch.normalized.schema["title"];
+  if (typeof title2 === "string" && title2 !== "") {
+    return title2;
   }
-  if (s.uniqueItems === true) {
-    v.uniqueItems = true;
-    used = true;
+  if (branch.normalized.defName !== void 0) {
+    return humanize(branch.normalized.defName);
   }
-  return used ? v : void 0;
+  return typeof value === "string" ? humanize(value) : String(value);
 }
-function humanLabel(name) {
-  if (!name) return "";
-  return name.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/\s+/g, " ").trim().replace(/^./, (c) => c.toUpperCase());
+function recordOf(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function singular(label) {
-  if (label.endsWith("ies") && label.length > 3) return label.slice(0, -3) + "y";
-  if (label.endsWith("s") && !label.endsWith("ss")) return label.slice(0, -1);
-  return label;
+function requiredOf(schema) {
+  return Array.isArray(schema["required"]) ? schema["required"] : [];
+}
+function refOf(raw) {
+  const ref = recordOf(raw)["$ref"];
+  return typeof ref === "string" ? ref : void 0;
 }
-function cleanFields(o) {
-  for (const k of Object.keys(o)) {
-    if (o[k] === void 0) delete o[k];
+function jsonEqual(first, second) {
+  return first === second || JSON.stringify(first) === JSON.stringify(second);
+}
+function joinPath(parent, segment) {
+  return parent === "" ? segment : `${parent}.${segment}`;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+const FORM_SCHEMA_URL = "https://golemui.com/schemas/form.schema.json";
+const CUSTOMIZATION_INPUT_PROPERTIES = {
+  rules: {
+    type: "array",
+    description: 'Optional rules that choose or change widgets, checked in order before the gui defaults. Each rule has a `match` object plus widget fields. `match` compares schema keywords by deep equality or with `{ "$in": [...] }`, `{ "$exists": true }` or `{ "$regex": "..." }`, and node fields with `$type`, `$path` (a glob: `*` is one segment, `**` any number), `$name`, `$defName`, `$required` and `$inRepeater`. The widget fields are `widget` (a GolemUI widget type), `label`, `props`, `validator`, `defaultValue`, `readonly`, `size`, `uid`, `skip` and `order`. A rule without `widget` only changes the default widget. Example: `{ "match": { "format": "email" }, "props": { "icon": "mail" } }`.',
+    items: {
+      type: "object",
+      additionalProperties: true,
+      properties: { match: { type: "object", additionalProperties: true } },
+      required: ["match"]
+    }
+  },
+  overrides: {
+    type: "object",
+    description: 'Optional widget fields by form data path, e.g. `{ "address.street": { "widget": "textarea" } }`. Inside arrays the path uses the `items` token (`lines.items.quantity`), and `""` is the root. A key `$defs/<Name>` applies to every node that comes from that definition. The fields are the same as in `rules`. A path override wins over a definition override, and both win over `rules` and over the `x-golemui` keyword in the schema.',
+    additionalProperties: { type: "object", additionalProperties: true }
   }
-  return o;
+};
+function jsonSchemaToGui(schema, options = {}) {
+  const { formDefinition, diagnostics } = fromJsonSchema(schema, {
+    preset: guiPreset({
+      submitAction: options.submitAction,
+      submitLabel: options.submitLabel,
+      rootLayout: options.layout,
+      schemaUrl: FORM_SCHEMA_URL
+    }),
+    rules: options.rules,
+    overrides: options.overrides,
+    refRoot: options.refRoot
+  });
+  const unmapped = diagnostics.filter((diagnostic) => diagnostic.severity !== "info").map((diagnostic) => ({ path: diagnostic.path, reason: diagnostic.message }));
+  return { formDefinition, unmapped, diagnostics };
 }
-function generateFromJsonSchema(input) {
-  const opts = {
-    submitAction: input.submitAction,
-    submitLabel: input.submitLabel,
-    layout: input.layout
-  };
-  const { formDefinition, unmapped } = jsonSchemaToGui(input.jsonSchema, opts);
+function generateFromJsonSchema(input2) {
+  const { formDefinition, unmapped, diagnostics } = jsonSchemaToGui(input2.jsonSchema, {
+    submitAction: input2.submitAction,
+    submitLabel: input2.submitLabel,
+    layout: input2.layout,
+    rules: input2.rules,
+    overrides: input2.overrides
+  });
   const validation = validateFormDefinition({ formDefinition });
-  return { formDefinition, unmapped, validation };
+  return { formDefinition, unmapped, diagnostics, validation };
 }
 const JSON_GENERATE_FROM_SCHEMA_TOOL = {
   name: "json_generate_from_schema",
-  description: "Generate a GolemUI form definition from a JSON Schema describing the form data shape (typically an API request body or a Zod-derived schema). The result is validated against the GolemUI JSON Schemas before being returned, so it is guaranteed to be syntactically correct. Anything the mapper cannot handle is reported in `unmapped` rather than silently dropped — use that list to surface remaining work to the user.",
+  description: "Generate a GolemUI form definition from a JSON Schema describing the form data shape (typically an API request body or a Zod-derived schema). The result is validated against the GolemUI JSON Schemas before being returned, so it is guaranteed to be syntactically correct. `diagnostics` lists everything the form cannot express exactly, each with a `severity` (`error`: not rendered, `warning`: rendered approximately, `info`: a note), a `code`, the data `path` and the JSON `pointer` into the input. `unmapped` repeats the errors and warnings as `{ path, reason }`: surface them to the user. Pass `rules` or `overrides` to choose other widgets.",
   inputSchema: {
     type: "object",
     properties: {
       jsonSchema: {
         type: "object",
         additionalProperties: true,
-        description: "A standard JSON Schema. The top level must be an `object` schema with a `properties` map. Supports primitive types (string/number/integer/boolean) with formats and constraints, enums, nested objects, and arrays of objects (rendered as repeaters)."
+        description: "A standard JSON Schema (draft-07 to 2020-12). The top level must be an object schema. Supports primitive types with formats and constraints, enums, local `$ref`/`$defs`, `allOf`, nested objects, arrays (repeaters, multi-selects, tags, tuples), discriminated `oneOf`/`anyOf`, and `if`/`then`/`else`, `dependentRequired`, `dependentSchemas` compiled to conditions and form states."
       },
       submitAction: {
         type: "boolean",
@@ -2421,45 +4505,51 @@ const JSON_GENERATE_FROM_SCHEMA_TOOL = {
         type: "string",
         enum: ["vertical", "horizontal", "grid"],
         description: "Top-level layout. Defaults to vertical (one field per row)."
-      }
+      },
+      ...CUSTOMIZATION_INPUT_PROPERTIES
     },
     required: ["jsonSchema"]
   }
 };
 const METHODS = ["get", "post", "put", "patch", "delete"];
-async function generateFromOpenapi(input) {
-  if (!input.document && !input.documentUrl) {
+async function generateFromOpenapi(input2) {
+  if (!input2.document && !input2.documentUrl) {
     throw new Error("Provide either `document` (parsed OpenAPI object) or `documentUrl`.");
   }
-  const doc = input.document ?? await fetchDoc(input.documentUrl);
-  const resolved = findOperation(doc, input.operation);
+  const doc = input2.document ?? await fetchDoc(input2.documentUrl);
+  const resolved = findOperation(doc, input2.operation);
   if (!resolved) {
     throw new Error(
-      `Operation \`${input.operation}\` not found. Use the form "METHOD /path" (e.g. "POST /users") or an exact operationId.`
+      `Operation \`${input2.operation}\` not found. Use the form "METHOD /path" (e.g. "POST /users") or an exact operationId.`
     );
   }
   const { method, path, operation } = resolved;
-  let bodySchema = operation.requestBody?.content?.["application/json"]?.schema;
-  if (bodySchema) bodySchema = derefSchema(bodySchema, doc);
-  let assembled;
-  if (bodySchema && (bodySchema.type === "object" || bodySchema.properties)) {
-    assembled = bodySchema;
-  } else if (operation.parameters?.length) {
-    assembled = paramsToSchema(operation.parameters, doc);
-  } else {
-    throw new Error(
-      `Operation \`${method.toUpperCase()} ${path}\` has no JSON request body and no parameters — nothing to render as a form.`
-    );
-  }
-  const { formDefinition, unmapped } = jsonSchemaToGui(assembled, {
-    submitAction: input.submitAction ?? true,
-    submitLabel: input.submitLabel ?? defaultSubmitLabel(method, operation)
+  const convert = (schema) => jsonSchemaToGui(schema, {
+    submitAction: input2.submitAction ?? true,
+    submitLabel: input2.submitLabel ?? defaultSubmitLabel(method, operation),
+    rules: input2.rules,
+    overrides: input2.overrides,
+    // `$ref`s in the operation point into the document, e.g. `#/components/schemas/User`.
+    refRoot: doc
   });
+  const bodySchema = operation.requestBody?.content?.["application/json"]?.schema;
+  let converted = bodySchema ? convert(bodySchema) : void 0;
+  const bodyIsObject = converted !== void 0 && !converted.diagnostics.some((diagnostic) => diagnostic.code === "root-not-object");
+  if (!bodyIsObject) {
+    if (!operation.parameters?.length) {
+      throw new Error(
+        `Operation \`${method.toUpperCase()} ${path}\` has no JSON request body and no parameters — nothing to render as a form.`
+      );
+    }
+    converted = convert(paramsToSchema(operation.parameters));
+  }
+  const { formDefinition, unmapped, diagnostics } = converted;
   const validation = validateFormDefinition({ formDefinition });
   return {
     resolvedOperation: { method: method.toUpperCase(), path, operationId: operation.operationId },
     formDefinition,
     unmapped,
+    diagnostics,
     validation
   };
 }
@@ -2501,13 +4591,15 @@ function findOperation(doc, ref) {
   }
   return null;
 }
-function paramsToSchema(parameters, doc) {
+function paramsToSchema(parameters) {
   const properties2 = {};
   const required2 = [];
-  for (const p of parameters) {
-    const s = p.schema ? derefSchema(p.schema, doc) : { type: "string" };
-    properties2[p.name] = { ...s, description: p.description ?? s.description };
-    if (p.required) required2.push(p.name);
+  for (const parameter of parameters) {
+    const schema = parameter.schema ?? { type: "string" };
+    properties2[parameter.name] = parameter.description === void 0 ? schema : { ...schema, description: parameter.description };
+    if (parameter.required) {
+      required2.push(parameter.name);
+    }
   }
   return { type: "object", properties: properties2, required: required2 };
 }
@@ -2522,40 +4614,9 @@ function defaultSubmitLabel(method, op) {
   };
   return verbs[method.toLowerCase()] ?? "Submit";
 }
-function derefSchema(schema, doc, depth = 0) {
-  if (depth > 16) return schema;
-  if (typeof schema.$ref === "string") {
-    const target = resolveLocalRef(schema.$ref, doc);
-    if (target) return derefSchema(target, doc, depth + 1);
-    return schema;
-  }
-  const result = { ...schema };
-  if (result.properties) {
-    result.properties = Object.fromEntries(
-      Object.entries(result.properties).map(([k, v]) => [k, derefSchema(v, doc, depth + 1)])
-    );
-  }
-  if (result.items) result.items = derefSchema(result.items, doc, depth + 1);
-  if (result.oneOf) result.oneOf = result.oneOf.map((s) => derefSchema(s, doc, depth + 1));
-  if (result.anyOf) result.anyOf = result.anyOf.map((s) => derefSchema(s, doc, depth + 1));
-  return result;
-}
-function resolveLocalRef(ref, doc) {
-  if (!ref.startsWith("#/")) return null;
-  const parts = ref.slice(2).split("/");
-  let cur = doc;
-  for (const p of parts) {
-    if (cur && typeof cur === "object") {
-      cur = cur[p];
-    } else {
-      return null;
-    }
-  }
-  return cur ?? null;
-}
 const JSON_GENERATE_FROM_OPENAPI_TOOL = {
   name: "json_generate_from_openapi",
-  description: 'Generate a GolemUI form for a specific OpenAPI 3.x operation (e.g. "POST /users"). Resolves the operation\'s JSON request body, dereferences `$ref`s, then maps it to a form definition that is validated against the GolemUI JSON Schemas before being returned, so it is guaranteed syntactically correct. Falls back to operation parameters when no request body is present. Anything the mapper cannot handle is reported in `unmapped` rather than silently dropped — use that list to surface remaining work to the user. Pass either a parsed `document` or a `documentUrl` to fetch.',
+  description: 'Generate a GolemUI form for a specific OpenAPI 3.x operation (e.g. "POST /users"). Converts the operation\'s JSON request body, with its `$ref`s into the document, to a form definition that is validated against the GolemUI JSON Schemas before being returned, so it is guaranteed syntactically correct. Falls back to operation parameters when no object request body is present. Returns `diagnostics` and `unmapped` like `json_generate_from_schema`: surface them to the user. Pass either a parsed `document` or a `documentUrl` to fetch, and `rules` or `overrides` to choose other widgets.',
   inputSchema: {
     type: "object",
     properties: {
@@ -2579,7 +4640,8 @@ const JSON_GENERATE_FROM_OPENAPI_TOOL = {
       submitLabel: {
         type: "string",
         description: "Label for the submit button. Defaults to the operation summary or a verb derived from the HTTP method."
-      }
+      },
+      ...CUSTOMIZATION_INPUT_PROPERTIES
     },
     required: ["operation"]
   }
@@ -2962,20 +5024,20 @@ function synthesizeExample(widgetType, schema) {
   if (props?.["label"]) ex["label"] = "Field";
   return ex;
 }
-function getWidgetSpec(input) {
-  const schema = COMPONENT_SCHEMAS[input.widgetType];
+function getWidgetSpec(input2) {
+  const schema = COMPONENT_SCHEMAS[input2.widgetType];
   if (!schema) {
     const known = Object.keys(COMPONENT_SCHEMAS).sort().join(", ");
-    throw new Error(`Unknown widget type \`${input.widgetType}\`. Known: ${known}.`);
+    throw new Error(`Unknown widget type \`${input2.widgetType}\`. Known: ${known}.`);
   }
   const props = schema["properties"];
   const kindProp = props?.["kind"]?.const ?? "unknown";
   return {
-    widgetType: input.widgetType,
+    widgetType: input2.widgetType,
     schema,
     kind: kindProp,
-    example: EXAMPLES[input.widgetType] ?? synthesizeExample(input.widgetType, schema),
-    notes: NOTES[input.widgetType] ?? []
+    example: EXAMPLES[input2.widgetType] ?? synthesizeExample(input2.widgetType, schema),
+    notes: NOTES[input2.widgetType] ?? []
   };
 }
 const JSON_GET_WIDGET_SPEC_TOOL = {
@@ -3714,11 +5776,11 @@ const CONCEPTS = {
   icons: ICONS_CONCEPT,
   "host-services": HOST_SERVICES_CONCEPT
 };
-function getConcept(input) {
-  const result = CONCEPTS[input.concept];
+function getConcept(input2) {
+  const result = CONCEPTS[input2.concept];
   if (!result) {
     const known = Object.keys(CONCEPTS).sort().map((c) => `\`${c}\``).join(", ");
-    throw new Error(`Unknown concept \`${input.concept}\`. Known concepts: ${known}.`);
+    throw new Error(`Unknown concept \`${input2.concept}\`. Known concepts: ${known}.`);
   }
   return result;
 }