@petrarca/sonnet-schema-designer 0.7.0 → 0.9.0

package/dist/chunk-MVPNMAVL.js

@@ -0,0 +1,3178 @@
+// src/questionnaire/answerTypes.ts
+import {
+  valueRefOf as valueRefOf2
+} from "@petrarca/sonnet-core/schema";
+
+// src/questionnaire/limits.ts
+var TEXT_LIMITS = ["minLength", "maxLength", "pattern"];
+var NUMBER_LIMITS = ["minimum", "maximum"];
+var COUNT_LIMITS = ["minItems", "maxItems"];
+var TIME_LIMITS = ["formatMinimum", "formatMaximum"];
+var ANSWER_TYPE_LIMITS = {
+  shortText: TEXT_LIMITS,
+  longText: TEXT_LIMITS,
+  integer: NUMBER_LIMITS,
+  decimal: NUMBER_LIMITS,
+  multipleChoice: COUNT_LIMITS,
+  listOfText: COUNT_LIMITS,
+  date: TIME_LIMITS,
+  time: TIME_LIMITS,
+  dateTime: TIME_LIMITS
+};
+var LIMIT_LABELS = {
+  minLength: "Minimum length",
+  maxLength: "Maximum length",
+  pattern: "Pattern",
+  minimum: "Minimum",
+  maximum: "Maximum",
+  minItems: "At least",
+  maxItems: "At most",
+  formatMinimum: "Earliest",
+  formatMaximum: "Latest"
+};
+function limitsFor(type) {
+  return ANSWER_TYPE_LIMITS[type] ?? [];
+}
+function limitsOf(prop2, type) {
+  const values = prop2;
+  return Object.fromEntries(
+    limitsFor(type).filter((k) => values[k] !== void 0).map((k) => [k, values[k]])
+  );
+}
+
+// src/questionnaire/valueTypes.ts
+import {
+  bindingOf,
+  CODEABLE_CONCEPT_TYPE,
+  CODING_TYPE,
+  QUANTITY_TYPE,
+  unitRangesKeywords,
+  unitRangesOf,
+  valueRefKeywords,
+  valueRefOf
+} from "@petrarca/sonnet-core/schema";
+
+// src/questionnaire/optionsListName.ts
+var OPTIONS_LIST_WIDGET = "options-list";
+var SHOW_IF_WIDGET = "show-if";
+
+// src/questionnaire/valueTypes.ts
+function readUnits(prop2, ui) {
+  const labels = new Map(
+    (ui["x-ui-options"]?.units ?? []).map(
+      (u) => [u.value, u.label]
+    )
+  );
+  const ranges = unitRangesOf(prop2) ?? {};
+  return (prop2.properties?.unit?.enum ?? []).map((v) => ({
+    value: String(v),
+    label: labels.get(String(v)) ?? String(v),
+    ...withoutNone(ranges[String(v)] ?? {})
+  }));
+}
+function withoutNone(range) {
+  return Object.fromEntries(
+    Object.entries(range).filter(([, v]) => v !== void 0)
+  );
+}
+function writeUnits(units) {
+  const ranges = Object.fromEntries(
+    units.map((u) => [u.value, { min: u.min, max: u.max }])
+  );
+  return {
+    prop: {
+      properties: units.length ? { unit: { enum: units.map((u) => u.value) } } : void 0,
+      ...unitRangesKeywords(ranges)
+    },
+    options: {
+      units: units.length ? units.map((u) => ({ value: u.value, label: u.label || u.value })) : void 0
+    }
+  };
+}
+var QUANTITY_ANSWER = {
+  type: QUANTITY_TYPE,
+  keywords: ["properties", "allOf"],
+  options: ["units"],
+  accepts(prop2) {
+    const { unit, ...others } = prop2.properties ?? {};
+    const narrowsUnits = !unit || Object.keys(unit).length === 1 && Array.isArray(unit.enum);
+    const units = (unit?.enum ?? []).map(String);
+    const ranges = unitRangesOf(prop2);
+    const rangesOfUnits = !!ranges && Object.keys(ranges).every((u) => units.includes(u));
+    return Object.keys(others).length === 0 && narrowsUnits && rangesOfUnits;
+  },
+  settings: {
+    fields: {
+      units: {
+        type: "array",
+        title: "Units",
+        description: "The units offered, by their UCUM code (kg, cm, mm[Hg]) and label, and the range of each. None: any unit, typed.",
+        "x-ui-widget": OPTIONS_LIST_WIDGET,
+        "x-ui-options": { itemLabel: "unit" },
+        items: {
+          type: "object",
+          properties: {
+            value: { type: "string", title: "Code" },
+            label: { type: "string", title: "Label" },
+            min: { type: "number", title: "Min" },
+            max: { type: "number", title: "Max" }
+          }
+        }
+      }
+    },
+    read: (prop2, ui) => ({ units: readUnits(prop2, ui) }),
+    write: (values) => writeUnits(
+      (values.units ?? []).filter((u) => u.value)
+    )
+  }
+};
+function listOf(binding) {
+  if (binding?.system && !binding.valueSet)
+    return { list: binding.system, listKind: "system" };
+  return { list: binding?.valueSet ?? "", listKind: "valueSet" };
+}
+function readCoding(prop2, ui) {
+  const binding = bindingOf(prop2);
+  const mode2 = ui["x-ui-options"]?.mode;
+  return {
+    ...listOf(binding),
+    version: binding?.version ?? "",
+    strength: binding?.strength ?? "required",
+    several: valueRefOf(prop2)?.multiple ?? false,
+    mode: mode2 ?? "auto"
+  };
+}
+function codingBindingOf(values) {
+  const list2 = String(values.list ?? "").trim();
+  if (!list2) return void 0;
+  const version2 = String(values.version ?? "").trim();
+  return {
+    [values.listKind === "system" ? "system" : "valueSet"]: list2,
+    ...version2 && { version: version2 },
+    strength: values.strength === "extensible" ? "extensible" : "required"
+  };
+}
+var CODING_ANSWER = {
+  type: CODING_TYPE,
+  keywords: ["x-binding"],
+  options: ["mode"],
+  // Narrowed only by its binding, and that one list.
+  accepts(prop2) {
+    const binding = prop2["x-binding"];
+    return !prop2.properties && !(binding?.valueSet && binding?.system);
+  },
+  settings: {
+    fields: {
+      list: {
+        type: "string",
+        title: "List",
+        description: "The codes offered: a list the terminology service knows, by its identifier."
+      },
+      listKind: {
+        type: "string",
+        title: "The list is a",
+        enum: ["valueSet", "system"],
+        "x-ui-widget": "radio",
+        "x-ui-options": {
+          enumNames: { valueSet: "Value set", system: "Code system" },
+          orientation: "horizontal"
+        }
+      },
+      version: {
+        type: "string",
+        title: "Version",
+        description: "None: the list's current version."
+      },
+      strength: {
+        type: "string",
+        title: "Answers",
+        enum: ["required", "extensible"],
+        "x-ui-widget": "radio",
+        "x-ui-options": {
+          enumNames: {
+            required: "Only the list's codes",
+            extensible: "The list's codes, or another answer"
+          }
+        }
+      },
+      several: { type: "boolean", title: "Several answers" },
+      mode: {
+        type: "string",
+        title: "Shown as",
+        enum: ["auto", "list", "search"],
+        "x-ui-widget": "radio",
+        "x-ui-options": {
+          enumNames: {
+            auto: "As the list's size decides",
+            list: "The whole list",
+            search: "A search"
+          }
+        }
+      }
+    },
+    read: readCoding,
+    // An open list takes a text of one's own too: a coding, or a text; several, an array of them.
+    write(values) {
+      const binding = codingBindingOf(values);
+      return {
+        prop: {
+          ...valueRefKeywords(
+            CODING_TYPE.id,
+            binding?.strength === "extensible",
+            values.several === true
+          ),
+          "x-binding": binding
+        },
+        options: {
+          mode: values.mode === "list" || values.mode === "search" ? values.mode : void 0
+        }
+      };
+    }
+  }
+};
+function readLists(binding) {
+  return (binding?.additional ?? []).map((a) => ({
+    value: a.valueSet ?? a.system ?? "",
+    label: a.title ?? "",
+    ...a.required ? { required: true } : {},
+    ...a.valueSet ? { kind: "valueSet" } : {},
+    ...a.purpose ? { purpose: a.purpose } : {}
+  }));
+}
+function writeLists(rows) {
+  return (rows ?? []).filter((r) => r.value.trim()).map((r) => ({
+    [r.kind === "valueSet" ? "valueSet" : "system"]: r.value.trim(),
+    ...r.label ? { title: r.label } : {},
+    ...r.required ? { required: true } : {},
+    ...r.purpose ? { purpose: r.purpose } : {}
+  }));
+}
+var { list, listKind, version, strength, mode } = CODING_ANSWER.settings.fields;
+var CODEABLE_CONCEPT_ANSWER = {
+  type: CODEABLE_CONCEPT_TYPE,
+  keywords: ["x-binding"],
+  options: ["mode", "text"],
+  // Narrowed only by its binding, and that one first list.
+  accepts(prop2) {
+    const binding = prop2["x-binding"];
+    return !prop2.properties && !(binding?.valueSet && binding?.system);
+  },
+  settings: {
+    fields: {
+      list,
+      listKind,
+      version,
+      strength,
+      additional: {
+        type: "array",
+        title: "Further lists",
+        description: "Where the concept's other codes come from -- an identifier the terminology service knows. Required: a value with codes needs one of it.",
+        "x-ui-widget": OPTIONS_LIST_WIDGET,
+        "x-ui-options": { itemLabel: "list", wide: true },
+        items: {
+          type: "object",
+          properties: {
+            value: { type: "string", title: "Identifier" },
+            label: { type: "string", title: "Title" },
+            required: { type: "boolean", title: "Required" }
+          }
+        }
+      },
+      mode,
+      // Not `text`: the panel's own field of that name is the question's text.
+      offerText: {
+        type: "boolean",
+        title: "Offer a text",
+        description: "An answer in words beside the codes -- or when no code fits."
+      }
+    },
+    read(prop2, ui) {
+      const { several: _several, ...first } = readCoding(prop2, ui);
+      const options = ui["x-ui-options"];
+      return {
+        ...first,
+        additional: readLists(bindingOf(prop2)),
+        offerText: options?.text === true
+      };
+    },
+    write(values) {
+      const binding = codingBindingOf(values);
+      const additional = writeLists(values.additional);
+      return {
+        prop: {
+          "x-binding": binding && {
+            ...binding,
+            ...additional.length ? { additional } : {}
+          }
+        },
+        options: {
+          mode: values.mode === "list" || values.mode === "search" ? values.mode : void 0,
+          text: values.offerText === true ? true : void 0
+        }
+      };
+    }
+  }
+};
+var DEFAULT_VALUE_TYPES = [
+  QUANTITY_ANSWER,
+  CODING_ANSWER,
+  CODEABLE_CONCEPT_ANSWER
+];
+function valueTypeOf(prop2, types) {
+  const ref = valueRefOf(prop2)?.ref;
+  const found = ref ? types.find((t) => t.type.id === ref) : void 0;
+  return found && (found.accepts?.(prop2) ?? true) ? found : void 0;
+}
+function valueTypeAnswer(answerType, types) {
+  return types.find((t) => t.type.id === answerType);
+}
+
+// src/questionnaire/answerTypes.ts
+var ANSWER_TYPE_LABELS = {
+  yesNo: "Yes / no",
+  shortText: "Short text",
+  longText: "Long text",
+  integer: "Integer",
+  decimal: "Decimal",
+  date: "Date",
+  time: "Time",
+  dateTime: "Date and time",
+  singleChoice: "Single choice",
+  multipleChoice: "Multiple choice",
+  choiceWithText: "Choice with text",
+  listOfText: "List of text",
+  parts: "Parts"
+};
+function isBuiltinAnswerType(type) {
+  return type in ANSWER_TYPE_LABELS;
+}
+function answerTypeLabel(type, types = DEFAULT_VALUE_TYPES) {
+  if (isBuiltinAnswerType(type)) return ANSWER_TYPE_LABELS[type];
+  return types.find((t) => t.type.id === type)?.type.label ?? type;
+}
+var CHOICE_WITH_TEXT_WIDGET = "choice-with-text";
+var CONTAINER_TYPES = ["choiceWithText", "parts"];
+function isContainerType(type) {
+  return CONTAINER_TYPES.includes(type);
+}
+var CHILD_TYPES = {
+  choiceWithText: { choice: ["singleChoice"], text: ["shortText", "longText"] },
+  parts: [
+    "yesNo",
+    "shortText",
+    "longText",
+    "integer",
+    "decimal",
+    "date",
+    "time",
+    "dateTime",
+    "singleChoice"
+  ]
+};
+var QUESTION_KEYWORDS = ["title", "description", "readOnly"];
+var QUESTION_HINTS = ["x-ui-title", "x-ui-description", "x-ui-placeholder"];
+function pattern(type, keywords, widgets = [void 0], options) {
+  return { type, keywords, widgets, options };
+}
+var STRING_FORMATS = {
+  date: "date",
+  time: "time",
+  "date-time": "dateTime"
+};
+var SCALAR_PATTERNS = {
+  boolean: pattern("yesNo", ["type"], [void 0, "checkbox"]),
+  integer: pattern("integer", ["type"], [void 0, "number"]),
+  number: pattern("decimal", ["type"], [void 0, "number"])
+};
+function patternOf(prop2, widget, types) {
+  const valueType = valueTypeOrRef(prop2, types);
+  if (valueType !== void 0) return valueType;
+  if (isSingleChoice(prop2)) {
+    return pattern(
+      "singleChoice",
+      ["type", "enum"],
+      [void 0, "select", "radio"],
+      ["enumNames"]
+    );
+  }
+  if (prop2.type === "string") return stringPattern(prop2, widget);
+  if (prop2.type === "array") return arrayPattern(prop2);
+  if (prop2.type === "object") return objectPattern(prop2, widget);
+  return (prop2.type && SCALAR_PATTERNS[prop2.type]) ?? null;
+}
+function valueTypeOrRef(prop2, types) {
+  const valueType = valueRefOf2(prop2) && valueTypePattern(prop2, types);
+  if (valueType) return valueType;
+  return prop2.$ref ? null : void 0;
+}
+function isSingleChoice(prop2) {
+  const hasEnum = Array.isArray(prop2.enum) && prop2.enum.length > 0;
+  return hasEnum && (prop2.type === "string" || prop2.type === void 0);
+}
+function valueTypePattern(prop2, types) {
+  const found = valueTypeOf(prop2, types);
+  if (!found) return null;
+  const widget = found.type.definition["x-ui-widget"];
+  return pattern(
+    found.type.id,
+    ["$ref", "anyOf", "type", "items", ...found.keywords ?? []],
+    [void 0, ...typeof widget === "string" ? [widget] : []],
+    found.options
+  );
+}
+function stringPattern(prop2, widget) {
+  const byFormat = prop2.format ? STRING_FORMATS[prop2.format] : void 0;
+  if (byFormat) {
+    const widgetName = byFormat === "dateTime" ? "date-time" : byFormat;
+    return pattern(byFormat, ["type", "format"], [void 0, widgetName]);
+  }
+  if (widget === "textarea") return pattern("longText", ["type"], ["textarea"]);
+  return pattern("shortText", ["type"], [void 0, "text"]);
+}
+function arrayPattern(prop2) {
+  const items = prop2.items;
+  if (!items || items.type !== "string" || hasOtherKeys(items, ["type", "enum"])) {
+    return null;
+  }
+  return Array.isArray(items.enum) && items.enum.length > 0 ? pattern(
+    "multipleChoice",
+    ["type", "items", "uniqueItems"],
+    [void 0, "select", "checkbox-group"],
+    ["enumNames"]
+  ) : pattern("listOfText", ["type", "items"], [void 0, "tags"]);
+}
+function objectPattern(prop2, widget) {
+  if (widget === CHOICE_WITH_TEXT_WIDGET && isChoiceWithText(prop2)) {
+    return pattern(
+      "choiceWithText",
+      ["type", "properties", "required", "allOf"],
+      [CHOICE_WITH_TEXT_WIDGET]
+    );
+  }
+  if (isParts(prop2)) {
+    return pattern("parts", [
+      "type",
+      "properties",
+      "required",
+      "x-ui-order",
+      "x-ui-layout"
+    ]);
+  }
+  return null;
+}
+function isChoiceWithText(prop2) {
+  const children = choiceWithTextChildren(prop2);
+  if (!children) return false;
+  const { choice, text } = children;
+  return Array.isArray(choice.enum) && choice.enum.length > 0 && text.type === "string" && !text.enum;
+}
+function choiceTextWhen(prop2) {
+  const member = prop2.allOf?.length === 1 ? prop2.allOf[0] : void 0;
+  const constraint = member?.if?.properties?.choice;
+  return constraint && "const" in constraint ? String(constraint.const) : void 0;
+}
+function otherTextMember(when, text) {
+  return {
+    if: { properties: { choice: { const: when } }, required: ["choice"] },
+    then: { properties: { text }, required: ["text"] }
+  };
+}
+function choiceWithTextChildren(prop2) {
+  const p = prop2.properties ?? {};
+  const keys = Object.keys(p).sort().join(",");
+  if (keys === "choice,text" && !prop2.allOf)
+    return { choice: p.choice, text: p.text };
+  return keys === "choice" ? otherVariantChildren(prop2) : null;
+}
+function otherVariantChildren(prop2) {
+  const { choice, text } = rawChoiceAndText(prop2);
+  const when = choiceTextWhen(prop2);
+  if (!choice || !text || when === void 0 || prop2.allOf?.length !== 1)
+    return null;
+  const isOption = (choice.enum ?? []).map(String).includes(when);
+  const exact = JSON.stringify(prop2.allOf[0]) === JSON.stringify(otherTextMember(when, text));
+  return isOption && exact ? { choice, text } : null;
+}
+function rawChoiceAndText(prop2) {
+  const conditional = prop2.allOf?.[0]?.then?.properties?.text;
+  return {
+    choice: prop2.properties?.choice,
+    text: prop2.properties?.text ?? conditional
+  };
+}
+function isParts(prop2) {
+  const p = prop2.properties;
+  const rows = prop2["x-ui-layout"]?.rows;
+  if (!p || !rows || rows.length !== 1) return false;
+  const keys = Object.keys(p);
+  const inRow = new Set(rows[0].fields);
+  return keys.length > 0 && keys.every((k) => inRow.has(k)) && keys.every((k) => p[k].type !== "object" && p[k].type !== "array");
+}
+function hasOtherKeys(obj, allowed) {
+  return Object.keys(obj).some((k) => !allowed.includes(k));
+}
+function hintExtras(ui, p) {
+  const extras = [];
+  const container = CONTAINER_TYPES.includes(p.type);
+  for (const key of Object.keys(ui)) {
+    if (QUESTION_HINTS.includes(key) || key === "x-ui-widget") continue;
+    if (container && key === "x-ui-fields") continue;
+    if (key === "x-ui-options") {
+      const options = Object.keys(ui[key] ?? {});
+      extras.push(
+        ...options.filter((o) => !p.options?.includes(o)).map((o) => `x-ui-options.${o}`)
+      );
+      continue;
+    }
+    extras.push(key);
+  }
+  return extras;
+}
+function recognizeAnswerType(prop2, ui, types = DEFAULT_VALUE_TYPES) {
+  const widget = ui["x-ui-widget"];
+  const p = patternOf(prop2, widget, types);
+  if (!p) return null;
+  const known = /* @__PURE__ */ new Set([
+    ...QUESTION_KEYWORDS,
+    ...p.keywords,
+    ...limitsFor(p.type),
+    ...isContainerType(p.type) ? [] : ["default"]
+  ]);
+  const schemaExtras = Object.keys(prop2).filter(
+    (k) => !known.has(k) && !k.startsWith("x-ui-")
+  );
+  const widgetExtra = p.widgets.includes(widget) ? [] : ["x-ui-widget"];
+  const extras = [...schemaExtras, ...widgetExtra, ...hintExtras(ui, p)];
+  if (!CONTAINER_TYPES.includes(p.type)) return { type: p.type, extras };
+  const children = childExtras(prop2, ui, p.type);
+  return children ? { type: p.type, extras: [...extras, ...children] } : null;
+}
+function childExtras(prop2, ui, type) {
+  const fields = ui["x-ui-fields"] ?? {};
+  const allowed = CHILD_TYPES[type];
+  const extras = [];
+  for (const [key, child] of Object.entries(containerChildren(prop2, type))) {
+    const childUi = { ...embeddedHints(child), ...fields[key] };
+    const answer = recognizeAnswerType(child, childUi);
+    const types = Array.isArray(allowed) ? allowed : allowed?.[key];
+    if (!answer || !types?.includes(answer.type)) return null;
+    extras.push(...answer.extras.map((e) => `${key}.${e}`));
+  }
+  return extras;
+}
+function containerChildren(prop2, type) {
+  if (type !== "choiceWithText") return prop2.properties ?? {};
+  const children = choiceWithTextChildren(prop2);
+  return children ? { choice: children.choice, text: children.text } : {};
+}
+function embeddedHints(prop2) {
+  const hints = {};
+  for (const [key, value] of Object.entries(prop2)) {
+    if (key.startsWith("x-ui-") && key !== "x-ui-layout" && key !== "x-ui-order") {
+      hints[key] = value;
+    }
+  }
+  return hints;
+}
+var NEW_OPTIONS = ["option_1", "option_2"];
+var FRAGMENTS = {
+  yesNo: () => ({ prop: { type: "boolean" }, ui: {} }),
+  shortText: () => ({ prop: { type: "string" }, ui: {} }),
+  longText: () => ({
+    prop: { type: "string" },
+    ui: { "x-ui-widget": "textarea" }
+  }),
+  integer: () => ({ prop: { type: "integer" }, ui: {} }),
+  decimal: () => ({ prop: { type: "number" }, ui: {} }),
+  date: () => ({ prop: { type: "string", format: "date" }, ui: {} }),
+  time: () => ({ prop: { type: "string", format: "time" }, ui: {} }),
+  dateTime: () => ({ prop: { type: "string", format: "date-time" }, ui: {} }),
+  singleChoice: (options) => ({
+    prop: { type: "string", enum: [...options] },
+    ui: {}
+  }),
+  multipleChoice: (options) => ({
+    prop: {
+      type: "array",
+      items: { type: "string", enum: [...options] },
+      uniqueItems: true
+    },
+    ui: {}
+  }),
+  listOfText: () => ({
+    prop: { type: "array", items: { type: "string" } },
+    ui: {}
+  }),
+  choiceWithText: (options) => ({
+    prop: {
+      type: "object",
+      properties: {
+        choice: { type: "string", enum: [...options] },
+        text: { type: "string" }
+      }
+    },
+    ui: { "x-ui-widget": CHOICE_WITH_TEXT_WIDGET }
+  }),
+  parts: () => ({
+    prop: {
+      type: "object",
+      properties: { part_1: { type: "string" }, part_2: { type: "string" } },
+      "x-ui-layout": { rows: [{ fields: ["part_1", "part_2"] }] }
+    },
+    ui: {}
+  })
+};
+function answerTypeFragment(type, options = NEW_OPTIONS) {
+  if (!isBuiltinAnswerType(type)) return { prop: { $ref: type }, ui: {} };
+  return FRAGMENTS[type](options);
+}
+
+// src/questionnaire/classify.ts
+import { isOneOf as isOneOf3 } from "@petrarca/sonnet-core/schema";
+
+// src/model/paths.ts
+import {
+  isOneOf,
+  getDiscriminator,
+  getBranchLabel
+} from "@petrarca/sonnet-core/schema";
+function isReservedKey(key) {
+  return /^#(branch|condition|def|slot):/.test(key);
+}
+function prop(key) {
+  return { kind: "prop", key };
+}
+function branch(index) {
+  return { kind: "branch", index };
+}
+function condition(index, combinator = "allOf") {
+  return { kind: "condition", combinator, index };
+}
+function slot(name) {
+  return { kind: "slot", slot: name };
+}
+function def(name) {
+  return { kind: "def", name };
+}
+var SEP = "/";
+function escapeToken(raw) {
+  return raw.replace(/\\/g, "\\\\").replace(/\//g, "\\/");
+}
+function unescapeToken(raw) {
+  return raw.replace(/\\\//g, "/").replace(/\\\\/g, "\\");
+}
+function encodeSegment(seg) {
+  switch (seg.kind) {
+    case "prop":
+      return escapeToken(seg.key);
+    case "branch":
+      return `#branch:${seg.index}`;
+    case "condition":
+      return `#condition:${seg.combinator}:${seg.index}`;
+    case "slot":
+      return `#slot:${seg.slot}`;
+    case "def":
+      return `#def:${escapeToken(seg.name)}`;
+  }
+}
+var VALID_SLOTS = ["then", "else", "items"];
+function safeIndex(raw) {
+  const n = Number(raw);
+  return Number.isInteger(n) && n >= 0 ? n : 0;
+}
+function decodeCondition(rest) {
+  const sep = rest.indexOf(":");
+  const combinatorRaw = sep >= 0 ? rest.slice(0, sep) : "allOf";
+  const combinator = combinatorRaw === "anyOf" ? "anyOf" : "allOf";
+  const index = safeIndex(sep >= 0 ? rest.slice(sep + 1) : rest);
+  return { kind: "condition", combinator, index };
+}
+function decodeSegment(token) {
+  if (token.startsWith("#branch:")) {
+    return { kind: "branch", index: safeIndex(token.slice("#branch:".length)) };
+  }
+  if (token.startsWith("#condition:")) {
+    return decodeCondition(token.slice("#condition:".length));
+  }
+  if (token.startsWith("#slot:")) {
+    const s = token.slice("#slot:".length);
+    return { kind: "slot", slot: VALID_SLOTS.includes(s) ? s : "items" };
+  }
+  if (token.startsWith("#def:")) {
+    return { kind: "def", name: unescapeToken(token.slice("#def:".length)) };
+  }
+  return { kind: "prop", key: unescapeToken(token) };
+}
+function splitTokens(key) {
+  const tokens = [];
+  let current = "";
+  for (let i = 0; i < key.length; i++) {
+    const ch = key[i];
+    if (ch === "\\" && i + 1 < key.length) {
+      current += ch + key[i + 1];
+      i++;
+    } else if (ch === SEP) {
+      tokens.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  tokens.push(current);
+  return tokens;
+}
+function pathKey(path) {
+  return path.map(encodeSegment).join(SEP);
+}
+function parsePathKey(key) {
+  if (key === "") return [];
+  return splitTokens(key).map(decodeSegment);
+}
+function segmentIdentity(seg) {
+  switch (seg.kind) {
+    case "prop":
+      return `prop:${seg.key}`;
+    case "branch":
+      return `branch:${seg.index}`;
+    case "condition":
+      return `condition:${seg.combinator}:${seg.index}`;
+    case "slot":
+      return `slot:${seg.slot}`;
+    case "def":
+      return `def:${seg.name}`;
+  }
+}
+function sameSegment(a, b) {
+  return segmentIdentity(a) === segmentIdentity(b);
+}
+function samePath(a, b) {
+  if (a === null || b === null) return a === b;
+  return a.length === b.length && a.every((seg, i) => sameSegment(seg, b[i]));
+}
+function childContainer(prop2) {
+  const typeIsObjectLike = prop2.type === "object" || prop2.type === void 0;
+  if (typeIsObjectLike && prop2.properties && !prop2.oneOf)
+    return prop2.properties;
+  if (prop2.type === "array" && prop2.items?.type === "object") {
+    return prop2.items.properties;
+  }
+  return void 0;
+}
+function isConditionalMember(member) {
+  return !!member.if;
+}
+function membersOfCombinator(property, combinator) {
+  const arr = property[combinator];
+  if (!Array.isArray(arr)) return [];
+  return arr.map((member, index) => ({ member, combinator, index })).filter(({ member }) => isConditionalMember(member));
+}
+function conditionalMembers(property) {
+  return [
+    ...membersOfCombinator(property, "allOf"),
+    ...membersOfCombinator(property, "anyOf")
+  ];
+}
+function conditionLabel(member) {
+  const field = Object.keys(member.if?.properties ?? {})[0] ?? member.if?.required?.[0];
+  return field ? `if ${field}` : "if ...";
+}
+function conditionalSlots(member) {
+  const slots = [];
+  const add = (name, sub) => {
+    if (sub) {
+      slots.push({
+        segment: slot(name),
+        label: name,
+        property: sub,
+        kind: "conditional",
+        removable: false,
+        reorderable: false
+      });
+    }
+  };
+  add("then", member.then);
+  add("else", member.else);
+  return slots;
+}
+function definitionsOf(property) {
+  return property.$defs ?? property.definitions;
+}
+function definitionSlots(property) {
+  const defs = definitionsOf(property);
+  if (!defs) return [];
+  return Object.keys(defs).map((name) => ({
+    segment: def(name),
+    label: name,
+    property: defs[name],
+    kind: "definition",
+    removable: true,
+    reorderable: false
+  }));
+}
+function childSlots(property) {
+  if (isConditionalMember(property)) return conditionalSlots(property);
+  if (isOneOf(property)) {
+    const discriminator = getDiscriminator(property);
+    return (property.oneOf ?? []).map((b, index) => ({
+      segment: branch(index),
+      label: getBranchLabel(b, discriminator, index),
+      property: b,
+      kind: "branch",
+      removable: true,
+      reorderable: true
+    }));
+  }
+  const container = childContainer(property);
+  const propertySlots = container ? Object.keys(container).map((key) => ({
+    segment: prop(key),
+    label: key,
+    property: container[key],
+    kind: "property",
+    removable: true,
+    reorderable: true
+  })) : [];
+  const conditionSlots = conditionalMembers(property).map(
+    ({ member, combinator, index }) => ({
+      segment: condition(index, combinator),
+      label: conditionLabel(member),
+      property: member,
+      kind: "conditional",
+      removable: true,
+      reorderable: false
+    })
+  );
+  return [...propertySlots, ...conditionSlots, ...definitionSlots(property)];
+}
+function stepInto(parent, seg) {
+  if (seg.kind === "prop") return childContainer(parent)?.[seg.key];
+  if (seg.kind === "branch") return parent.oneOf?.[seg.index];
+  if (seg.kind === "condition") return parent[seg.combinator]?.[seg.index];
+  if (seg.kind === "def") return definitionsOf(parent)?.[seg.name];
+  if (seg.slot === "items") return parent.items;
+  return parent[seg.slot];
+}
+function schemaAsRootProp(schema) {
+  return {
+    type: "object",
+    properties: schema.properties,
+    required: schema.required,
+    "x-ui-order": schema["x-ui-order"],
+    allOf: schema.allOf,
+    anyOf: schema.anyOf,
+    $defs: schema.$defs,
+    definitions: schema.definitions
+  };
+}
+function getProperty(schema, path) {
+  if (path.length === 0) return void 0;
+  const root = schemaAsRootProp(schema);
+  let current = root;
+  for (const seg of path) {
+    if (!current) return void 0;
+    current = stepInto(current, seg);
+  }
+  return current;
+}
+function isContainer(prop2) {
+  return childSlots(prop2).length > 0 || childContainer(prop2) !== void 0;
+}
+
+// src/model/mutate.ts
+function segKey(seg) {
+  return seg && seg.kind === "prop" ? seg.key : void 0;
+}
+function propKeys(path) {
+  return path.flatMap((s) => s.kind === "prop" ? [s.key] : []);
+}
+function clone(v) {
+  return structuredClone(v);
+}
+function newProperty(kind) {
+  switch (kind) {
+    case "object":
+      return { type: "object", properties: {} };
+    case "array":
+      return { type: "array", items: { type: "object", properties: {} } };
+    case "oneOf":
+      return {
+        type: "object",
+        discriminator: { propertyName: "kind" },
+        oneOf: [newBranch("option_1"), newBranch("option_2")]
+      };
+    default:
+      return { type: "string" };
+  }
+}
+function newBranch(value) {
+  return {
+    title: value,
+    properties: { kind: { const: value } }
+  };
+}
+function resolveContainer(schema, parentPath) {
+  if (parentPath.length === 0) {
+    return {
+      properties: schema.properties,
+      getOrder: () => schema["x-ui-order"],
+      setOrder: (o) => {
+        if (o) schema["x-ui-order"] = o;
+        else delete schema["x-ui-order"];
+      },
+      getRequired: () => schema.required,
+      setRequired: (r) => {
+        if (r && r.length) schema.required = r;
+        else delete schema.required;
+      }
+    };
+  }
+  const owner = getProperty(schema, parentPath);
+  if (!owner) return null;
+  if (owner.oneOf) return null;
+  const target = owner.type === "array" ? owner.items : owner;
+  if (!target) return null;
+  if (!target.properties) target.properties = {};
+  const properties = target.properties;
+  return {
+    properties,
+    getOrder: () => target["x-ui-order"],
+    setOrder: (o) => {
+      if (o) target["x-ui-order"] = o;
+      else delete target["x-ui-order"];
+    },
+    getRequired: () => target.required,
+    setRequired: (r) => {
+      if (r && r.length) target.required = r;
+      else delete target.required;
+    }
+  };
+}
+function uniqueKey(base, properties) {
+  if (!(base in properties)) return base;
+  let i = 2;
+  while (`${base}_${i}` in properties) i++;
+  return `${base}_${i}`;
+}
+function addProperty(model, parentPath, kind) {
+  const schema = clone(model.schema);
+  const container = resolveContainer(schema, parentPath);
+  if (!container) return { model, path: parentPath };
+  const key = uniqueKey("property", container.properties);
+  container.properties[key] = newProperty(kind);
+  const order = container.getOrder();
+  if (order) container.setOrder([...order, key]);
+  return {
+    model: { schema, uiSchema: model.uiSchema },
+    path: [...parentPath, prop(key)]
+  };
+}
+function uniqueBranchValue(oneOf) {
+  const existing = new Set(oneOf.map((b) => b.title).filter(Boolean));
+  let i = 1;
+  while (existing.has(`option_${i}`)) i++;
+  return `option_${i}`;
+}
+function addBranch(model, path) {
+  const schema = clone(model.schema);
+  const owner = getProperty(schema, path);
+  if (!owner || !owner.oneOf) return { model, path };
+  const index = owner.oneOf.length;
+  owner.oneOf.push(newBranch(uniqueBranchValue(owner.oneOf)));
+  return {
+    model: { schema, uiSchema: model.uiSchema },
+    path: [...path, branch(index)]
+  };
+}
+function removeBranch(model, path) {
+  const last = path[path.length - 1];
+  if (!last || last.kind !== "branch") return model;
+  const schema = clone(model.schema);
+  const owner = getProperty(schema, path.slice(0, -1));
+  if (!owner?.oneOf) return model;
+  owner.oneOf.splice(last.index, 1);
+  return { schema, uiSchema: model.uiSchema };
+}
+function moveBranch(model, path, direction) {
+  const last = path[path.length - 1];
+  if (!last || last.kind !== "branch") return model;
+  const schema = clone(model.schema);
+  const owner = getProperty(schema, path.slice(0, -1));
+  if (!owner?.oneOf) return model;
+  const from = last.index;
+  const to = from + direction;
+  if (to < 0 || to >= owner.oneOf.length) return model;
+  const [moved] = owner.oneOf.splice(from, 1);
+  owner.oneOf.splice(to, 0, moved);
+  return { schema, uiSchema: model.uiSchema };
+}
+function newCondition() {
+  return { if: { properties: {} }, then: { properties: {} } };
+}
+function addConditional(model, objectPath, combinator = "allOf") {
+  const schema = clone(model.schema);
+  const owner = conditionalOwner(schema, objectPath);
+  if (!owner) return { model, path: objectPath };
+  if (!Array.isArray(owner[combinator])) owner[combinator] = [];
+  const arr = owner[combinator];
+  const index = arr.length;
+  arr.push(newCondition());
+  return {
+    model: { schema, uiSchema: model.uiSchema },
+    path: [...objectPath, condition(index, combinator)]
+  };
+}
+function conditionalOwner(schema, objectPath) {
+  if (objectPath.length === 0) return schema;
+  const owner = getProperty(schema, objectPath);
+  if (!owner) return null;
+  const objectLike = owner.type === "object" || owner.type === void 0;
+  if (!objectLike || owner.oneOf) return null;
+  return owner;
+}
+function removeConditional(model, path) {
+  const last = path[path.length - 1];
+  if (!last || last.kind !== "condition") return model;
+  const schema = clone(model.schema);
+  const owner = conditionalOwner(schema, path.slice(0, -1));
+  const arr = owner?.[last.combinator];
+  if (!arr) return model;
+  arr.splice(last.index, 1);
+  if (arr.length === 0) delete owner[last.combinator];
+  return { schema, uiSchema: model.uiSchema };
+}
+function setCondition(model, path, ifSchema) {
+  const last = path[path.length - 1];
+  if (!last || last.kind !== "condition") return model;
+  const schema = clone(model.schema);
+  const member = getProperty(schema, path);
+  if (!member) return model;
+  member.if = ifSchema;
+  if (!member.then) member.then = { properties: {} };
+  return { schema, uiSchema: model.uiSchema };
+}
+function addElse(model, path) {
+  const last = path[path.length - 1];
+  if (!last || last.kind !== "condition") return model;
+  const schema = clone(model.schema);
+  const member = getProperty(schema, path);
+  if (!member || member.else) return model;
+  member.else = { properties: {} };
+  return { schema, uiSchema: model.uiSchema };
+}
+function removeElse(model, path) {
+  const last = path[path.length - 1];
+  if (!last || last.kind !== "condition") return model;
+  const schema = clone(model.schema);
+  const member = getProperty(schema, path);
+  if (!member || !member.else) return model;
+  delete member.else;
+  return { schema, uiSchema: model.uiSchema };
+}
+function otherCombinator(c) {
+  return c === "allOf" ? "anyOf" : "allOf";
+}
+function setConditionalBehavior(model, objectPath, next) {
+  const schema = clone(model.schema);
+  const owner = conditionalOwner(schema, objectPath);
+  if (!owner) return model;
+  const from = otherCombinator(next);
+  const source = owner[from];
+  if (!Array.isArray(source)) return model;
+  const conditionals = source.filter((m) => !!m.if);
+  if (conditionals.length === 0) return model;
+  const rest = source.filter((m) => !m.if);
+  if (rest.length > 0) owner[from] = rest;
+  else delete owner[from];
+  owner[next] = [...owner[next] ?? [], ...conditionals];
+  return { schema, uiSchema: model.uiSchema };
+}
+function deleteProperty(model, path) {
+  if (path.length === 0) return model;
+  const schema = clone(model.schema);
+  const parentPath = path.slice(0, -1);
+  const key = segKey(path[path.length - 1]);
+  if (key === void 0) return model;
+  const container = resolveContainer(schema, parentPath);
+  if (!container || !(key in container.properties)) return model;
+  delete container.properties[key];
+  const order = container.getOrder();
+  if (order) container.setOrder(order.filter((k) => k !== key));
+  const required = container.getRequired();
+  if (required) container.setRequired(required.filter((k) => k !== key));
+  const uiSchema = getUiEntryAtPath(model.uiSchema, path) ? setEntryIn(model.uiSchema, propKeys(path), void 0) : model.uiSchema;
+  return { schema, uiSchema };
+}
+function renameKeyInPlace(properties, prevKey, nextKey) {
+  const rebuilt = {};
+  for (const [k, v] of Object.entries(properties)) {
+    rebuilt[k === prevKey ? nextKey : k] = v;
+  }
+  for (const k of Object.keys(properties)) delete properties[k];
+  Object.assign(properties, rebuilt);
+}
+function renameUiEntry(uiSchema, path, nextKey) {
+  const entry = getUiEntryAtPath(uiSchema, path);
+  if (!entry) return uiSchema;
+  const keys = propKeys(path);
+  const cleared = setEntryIn(uiSchema, keys, void 0);
+  return setEntryIn(cleared, [...keys.slice(0, -1), nextKey], entry);
+}
+function updateContainerRefs(container, prevKey, nextKey) {
+  const rename = (k) => k === prevKey ? nextKey : k;
+  const order = container.getOrder();
+  if (order) container.setOrder(order.map(rename));
+  const required = container.getRequired();
+  if (required) container.setRequired(required.map(rename));
+}
+function renameProperty(model, path, nextKey) {
+  if (path.length === 0) return { model, path };
+  const parentPath = path.slice(0, -1);
+  const prevKey = segKey(path[path.length - 1]);
+  if (prevKey === void 0) return { model, path };
+  if (nextKey === prevKey || !nextKey || isReservedKey(nextKey))
+    return { model, path };
+  const schema = clone(model.schema);
+  const container = resolveContainer(schema, parentPath);
+  if (!container || !(prevKey in container.properties)) return { model, path };
+  if (nextKey in container.properties) return { model, path };
+  renameKeyInPlace(container.properties, prevKey, nextKey);
+  updateContainerRefs(container, prevKey, nextKey);
+  const uiSchema = renameUiEntry(model.uiSchema, path, nextKey);
+  return {
+    model: { schema, uiSchema },
+    path: [...parentPath, prop(nextKey)]
+  };
+}
+function moveProperty(model, path, direction) {
+  if (path.length === 0) return model;
+  const schema = clone(model.schema);
+  const parentPath = path.slice(0, -1);
+  const key = segKey(path[path.length - 1]);
+  if (key === void 0) return model;
+  const container = resolveContainer(schema, parentPath);
+  if (!container) return model;
+  const keys = Object.keys(container.properties);
+  const order = container.getOrder() ?? keys;
+  const full = [...order.filter((k) => keys.includes(k))];
+  for (const k of keys) if (!full.includes(k)) full.push(k);
+  const idx = full.indexOf(key);
+  const swap = idx + direction;
+  if (idx < 0 || swap < 0 || swap >= full.length) return model;
+  [full[idx], full[swap]] = [full[swap], full[idx]];
+  container.setOrder(full);
+  return { schema, uiSchema: model.uiSchema };
+}
+function setRequired(model, path, required) {
+  if (path.length === 0) return model;
+  const schema = clone(model.schema);
+  const parentPath = path.slice(0, -1);
+  const key = segKey(path[path.length - 1]);
+  if (key === void 0) return model;
+  const container = resolveContainer(schema, parentPath);
+  if (!container) return model;
+  const current = new Set(container.getRequired() ?? []);
+  if (required) current.add(key);
+  else current.delete(key);
+  container.setRequired([...current]);
+  return { schema, uiSchema: model.uiSchema };
+}
+function updateProperty(model, path, patch) {
+  if (path.length === 0) return model;
+  const schema = clone(model.schema);
+  const prop2 = getProperty(schema, path);
+  if (!prop2) return model;
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === void 0) delete prop2[k];
+    else prop2[k] = v;
+  }
+  return { schema, uiSchema: model.uiSchema };
+}
+function currentTypeChoice(prop2) {
+  return prop2.oneOf ? "oneOf" : prop2.type ?? "string";
+}
+function changePropertyType(model, path, next) {
+  if (path.length === 0 || !next) return model;
+  const schema = clone(model.schema);
+  const prop2 = getProperty(schema, path);
+  if (!prop2 || !prop2.$ref && currentTypeChoice(prop2) === next) return model;
+  delete prop2.properties;
+  delete prop2.items;
+  delete prop2.enum;
+  delete prop2.oneOf;
+  delete prop2.discriminator;
+  delete prop2.const;
+  delete prop2.$ref;
+  if (next !== "object") {
+    delete prop2.allOf;
+    delete prop2.anyOf;
+  }
+  delete prop2.minLength;
+  delete prop2.maxLength;
+  delete prop2.pattern;
+  delete prop2.format;
+  delete prop2.minimum;
+  delete prop2.maximum;
+  delete prop2.minItems;
+  delete prop2.maxItems;
+  if (next === "oneOf") {
+    const seed = newProperty("oneOf");
+    prop2.type = seed.type;
+    prop2.discriminator = seed.discriminator;
+    prop2.oneOf = seed.oneOf;
+  } else {
+    prop2.type = next;
+    if (next === "object") prop2.properties = {};
+    if (next === "array") prop2.items = { type: "string" };
+  }
+  return { schema, uiSchema: model.uiSchema };
+}
+function defPointer(name) {
+  return `#/$defs/${name}`;
+}
+function setReference(model, path, name) {
+  if (path.length === 0 || !name) return model;
+  const schema = clone(model.schema);
+  const prop2 = getProperty(schema, path);
+  if (!prop2) return model;
+  const defs = schema.$defs ?? schema.definitions;
+  if (!defs || !(name in defs)) return model;
+  if (prop2.type === "array") {
+    prop2.items = { $ref: defPointer(name) };
+    return { schema, uiSchema: model.uiSchema };
+  }
+  makeReference(prop2, name);
+  return { schema, uiSchema: model.uiSchema };
+}
+function makeReference(prop2, name) {
+  delete prop2.properties;
+  delete prop2.items;
+  delete prop2.enum;
+  delete prop2.oneOf;
+  delete prop2.discriminator;
+  delete prop2.const;
+  delete prop2.allOf;
+  delete prop2.anyOf;
+  delete prop2.type;
+  delete prop2.minLength;
+  delete prop2.maxLength;
+  delete prop2.pattern;
+  delete prop2.format;
+  delete prop2.minimum;
+  delete prop2.maximum;
+  delete prop2.minItems;
+  delete prop2.maxItems;
+  prop2.$ref = defPointer(name);
+}
+function walkSchemaNodes(node, visitor, parentKey) {
+  if (Array.isArray(node)) {
+    for (const item of node) walkSchemaNodes(item, visitor, parentKey);
+    return;
+  }
+  if (!node || typeof node !== "object") return;
+  const obj = node;
+  visitor(obj, parentKey);
+  for (const key of Object.keys(obj)) {
+    walkSchemaNodes(obj[key], visitor, key);
+  }
+}
+function rewriteRefs(node, from, to) {
+  walkSchemaNodes(node, (obj, key) => {
+    if (key !== "$ref" && obj.$ref === from) obj.$ref = to;
+  });
+}
+function countRefUsages(schema, name) {
+  let count = 0;
+  const pointers = /* @__PURE__ */ new Set([`#/$defs/${name}`, `#/definitions/${name}`]);
+  walkSchemaNodes(schema, (obj) => {
+    if (typeof obj.$ref === "string" && pointers.has(obj.$ref)) count++;
+  });
+  return count;
+}
+function addDefinition(model, name) {
+  const schema = clone(model.schema);
+  if (!schema.$defs) schema.$defs = {};
+  const key = uniqueKey(name ?? "Definition", schema.$defs);
+  schema.$defs[key] = { type: "object", properties: {} };
+  return {
+    model: { schema, uiSchema: model.uiSchema },
+    path: [def(key)]
+  };
+}
+function renameDefinition(model, oldName, newName) {
+  const path = [def(oldName)];
+  if (!newName || newName === oldName || isReservedKey(newName))
+    return { model, path };
+  const schema = clone(model.schema);
+  const defs = schema.$defs ?? schema.definitions;
+  if (!defs || !(oldName in defs) || newName in defs) return { model, path };
+  renameKeyInPlace(defs, oldName, newName);
+  rewriteRefs(schema, `#/$defs/${oldName}`, `#/$defs/${newName}`);
+  rewriteRefs(schema, `#/definitions/${oldName}`, `#/$defs/${newName}`);
+  return {
+    model: { schema, uiSchema: model.uiSchema },
+    path: [def(newName)]
+  };
+}
+function removeDefinition(model, name) {
+  const schema = clone(model.schema);
+  const inDefs = schema.$defs && name in schema.$defs;
+  const inDefs7 = schema.definitions && name in schema.definitions;
+  if (!inDefs && !inDefs7) return model;
+  if (countRefUsages(schema, name) > 0) return model;
+  if (inDefs) {
+    delete schema.$defs[name];
+    if (Object.keys(schema.$defs).length === 0) delete schema.$defs;
+  } else {
+    delete schema.definitions[name];
+    if (Object.keys(schema.definitions).length === 0)
+      delete schema.definitions;
+  }
+  return { schema, uiSchema: model.uiSchema };
+}
+function definitionUsageCount(schema, name) {
+  return countRefUsages(schema, name);
+}
+function normalizeChoices(choices) {
+  const seen = /* @__PURE__ */ new Set();
+  const clean = [];
+  for (const c of choices) {
+    const value = c.value.trim();
+    if (!value || seen.has(value)) continue;
+    seen.add(value);
+    clean.push({ value, label: c.label?.trim() || void 0 });
+  }
+  return clean;
+}
+function withEnumNames(entry, choices) {
+  const enumNames = {};
+  for (const c of choices) if (c.label) enumNames[c.value] = c.label;
+  const next = { ...entry ?? {} };
+  const options = {
+    ...next["x-ui-options"] ?? {}
+  };
+  if (Object.keys(enumNames).length) options.enumNames = enumNames;
+  else delete options.enumNames;
+  if (Object.keys(options).length) next["x-ui-options"] = options;
+  else delete next["x-ui-options"];
+  return Object.keys(next).length ? next : void 0;
+}
+function setEnum(model, path, choices) {
+  if (path.length === 0) return model;
+  const schema = clone(model.schema);
+  const prop2 = getProperty(schema, path);
+  if (!prop2) return model;
+  const clean = normalizeChoices(choices);
+  if (clean.length === 0) delete prop2.enum;
+  else prop2.enum = clean.map((c) => c.value);
+  const nextEntry = withEnumNames(
+    getUiEntryAtPath(model.uiSchema, path),
+    clean
+  );
+  const uiSchema = setEntryIn(model.uiSchema, propKeys(path), nextEntry);
+  return { schema, uiSchema };
+}
+function readEnumChoices(prop2, uiEntry) {
+  if (!Array.isArray(prop2.enum)) return [];
+  const enumNames = uiEntry?.["x-ui-options"]?.enumNames ?? {};
+  return prop2.enum.map((v) => {
+    const value = String(v);
+    return { value, label: enumNames[value] };
+  });
+}
+function setTableHints(model, path, hints) {
+  if (path.length === 0) return model;
+  const schema = clone(model.schema);
+  const prop2 = getProperty(schema, path);
+  if (!prop2) return model;
+  if (hints.cell) prop2["x-ui-cell"] = hints.cell;
+  else delete prop2["x-ui-cell"];
+  if (hints.cellOptions && Object.keys(hints.cellOptions).length > 0) {
+    prop2["x-ui-cell-options"] = hints.cellOptions;
+  } else {
+    delete prop2["x-ui-cell-options"];
+  }
+  if (hints.column && Object.keys(hints.column).length > 0) {
+    prop2["x-ui-column"] = hints.column;
+  } else {
+    delete prop2["x-ui-column"];
+  }
+  return { schema, uiSchema: model.uiSchema };
+}
+function readTableHints(prop2) {
+  return {
+    cell: typeof prop2["x-ui-cell"] === "string" ? prop2["x-ui-cell"] : void 0,
+    cellOptions: prop2["x-ui-cell-options"],
+    column: prop2["x-ui-column"]
+  };
+}
+function getUiEntryAtPath(uiSchema, path) {
+  const keys = propKeys(path);
+  if (keys.length === 0) return void 0;
+  let entry = uiSchema[keys[0]];
+  for (let i = 1; i < keys.length && entry; i++) {
+    const fields = entry["x-ui-fields"];
+    entry = fields?.[keys[i]];
+  }
+  return entry;
+}
+function setEntryIn(map, keys, entry) {
+  const [head, ...rest] = keys;
+  const next = { ...map };
+  if (rest.length === 0) {
+    if (entry && Object.keys(entry).length > 0) next[head] = entry;
+    else delete next[head];
+    return next;
+  }
+  const current = { ...next[head] ?? {} };
+  const childFields = current["x-ui-fields"] ?? {};
+  const updatedFields = setEntryIn(childFields, rest, entry);
+  if (Object.keys(updatedFields).length > 0) {
+    current["x-ui-fields"] = updatedFields;
+  } else {
+    delete current["x-ui-fields"];
+  }
+  if (Object.keys(current).length > 0) next[head] = current;
+  else delete next[head];
+  return next;
+}
+function setUiEntry(model, path, entry) {
+  if (path.length === 0) return model;
+  const uiSchema = setEntryIn(model.uiSchema, propKeys(path), entry);
+  return { schema: model.schema, uiSchema };
+}
+function setPropertyLayout(model, path, layout) {
+  if (path.length === 0) return model;
+  const schema = clone(model.schema);
+  const prop2 = getProperty(schema, path);
+  if (!prop2) return model;
+  const target = prop2.type === "array" ? prop2.items : prop2;
+  if (!target) return model;
+  if (layout) target["x-ui-layout"] = layout;
+  else delete target["x-ui-layout"];
+  return { schema, uiSchema: model.uiSchema };
+}
+function setRootLayout(model, layout) {
+  const uiSchema = { ...model.uiSchema };
+  if (layout) uiSchema["x-ui-layout"] = layout;
+  else delete uiSchema["x-ui-layout"];
+  return { schema: model.schema, uiSchema };
+}
+function setRootLayoutRows(model, rows) {
+  const uiSchema = { ...model.uiSchema };
+  const layout = { ...uiSchema["x-ui-layout"] ?? {} };
+  if (rows && rows.length > 0) layout.rows = rows;
+  else delete layout.rows;
+  if (Object.keys(layout).length > 0) uiSchema["x-ui-layout"] = layout;
+  else delete uiSchema["x-ui-layout"];
+  return { schema: model.schema, uiSchema };
+}
+function setScopedLayoutRows(model, scopePath, rows) {
+  if (scopePath.length === 0) return setRootLayoutRows(model, rows);
+  const schema = clone(model.schema);
+  const prop2 = getProperty(schema, scopePath);
+  if (!prop2) return model;
+  const target = prop2.type === "array" ? prop2.items : prop2;
+  if (!target) return model;
+  const layout = { ...target["x-ui-layout"] ?? {} };
+  if (rows && rows.length > 0) layout.rows = rows;
+  else delete layout.rows;
+  if (Object.keys(layout).length > 0) target["x-ui-layout"] = layout;
+  else delete target["x-ui-layout"];
+  return { schema, uiSchema: model.uiSchema };
+}
+function getScopedLayout(schema, uiSchema, scopePath) {
+  if (scopePath.length === 0) {
+    return uiSchema["x-ui-layout"];
+  }
+  const prop2 = getProperty(schema, scopePath);
+  const target = prop2?.type === "array" ? prop2.items : prop2;
+  return target?.["x-ui-layout"];
+}
+function setScopedLayoutOptions(model, scopePath, options) {
+  const current = getScopedLayout(model.schema, model.uiSchema, scopePath) ?? {};
+  const merged = { ...current };
+  for (const key of ["direction", "gap", "labels", "compact"]) {
+    const v = options[key];
+    if (v === void 0 || typeof v === "number" && Number.isNaN(v))
+      delete merged[key];
+    else merged[key] = v;
+  }
+  const layout = Object.keys(merged).length > 0 ? merged : void 0;
+  if (scopePath.length === 0) return setRootLayout(model, layout);
+  return setPropertyLayout(model, scopePath, layout);
+}
+function setScopedLayoutGroups(model, scopePath, groups) {
+  const current = getScopedLayout(model.schema, model.uiSchema, scopePath) ?? {};
+  const merged = { ...current };
+  if (groups && groups.length > 0) {
+    merged.groups = groups;
+    delete merged.rows;
+  } else {
+    delete merged.groups;
+  }
+  const layout = Object.keys(merged).length > 0 ? merged : void 0;
+  if (scopePath.length === 0) return setRootLayout(model, layout);
+  return setPropertyLayout(model, scopePath, layout);
+}
+function groupsOf(model, scopePath) {
+  return getScopedLayout(model.schema, model.uiSchema, scopePath)?.groups ?? [];
+}
+function addLayoutGroup(model, scopePath, label) {
+  const groups = groupsOf(model, scopePath);
+  const next = { label: label ?? `Group ${groups.length + 1}`, rows: [] };
+  return setScopedLayoutGroups(model, scopePath, [...groups, next]);
+}
+function renameLayoutGroup(model, scopePath, groupIndex, label) {
+  const groups = groupsOf(model, scopePath);
+  if (!groups[groupIndex] || !label.trim()) return model;
+  return setScopedLayoutGroups(
+    model,
+    scopePath,
+    groups.map((group, i) => i === groupIndex ? { ...group, label } : group)
+  );
+}
+function placeFieldInGroup(model, scopePath, key, target) {
+  const groups = groupsOf(model, scopePath);
+  if (!key || groups.length === 0) return model;
+  const stripped = groups.map((group) => ({
+    ...group,
+    rows: group.rows.map((row2) => ({
+      ...row2,
+      fields: row2.fields.filter((f) => f !== key)
+    }))
+  }));
+  if (!target) return setScopedLayoutGroups(model, scopePath, stripped);
+  const { groupIndex, rowIndex } = target;
+  const row = stripped[groupIndex]?.rows[rowIndex];
+  if (!row) return setScopedLayoutGroups(model, scopePath, stripped);
+  stripped[groupIndex].rows = stripped[groupIndex].rows.map(
+    (r, i) => i === rowIndex ? { ...r, fields: [...r.fields, key] } : r
+  );
+  return setScopedLayoutGroups(model, scopePath, stripped);
+}
+function moveLayoutGroup(model, scopePath, groupIndex, direction) {
+  const groups = groupsOf(model, scopePath);
+  const target = groupIndex + direction;
+  if (!groups[groupIndex] || target < 0 || target >= groups.length)
+    return model;
+  const next = [...groups];
+  [next[groupIndex], next[target]] = [next[target], next[groupIndex]];
+  return setScopedLayoutGroups(model, scopePath, next);
+}
+function setLayoutGroupRule(model, scopePath, groupIndex, rule) {
+  const groups = groupsOf(model, scopePath);
+  if (!groups[groupIndex]) return model;
+  const next = groups.map((group, i) => {
+    if (i !== groupIndex) return group;
+    const { rule: _drop, ...rest } = group;
+    return rule ? { ...rest, rule } : rest;
+  });
+  return setScopedLayoutGroups(model, scopePath, next);
+}
+function setScopedLayoutVariant(model, scopePath, variant) {
+  const current = getScopedLayout(model.schema, model.uiSchema, scopePath) ?? {};
+  const merged = { ...current };
+  if (variant && variant !== "groups") merged.variant = variant;
+  else delete merged.variant;
+  const layout = Object.keys(merged).length > 0 ? merged : void 0;
+  if (scopePath.length === 0) return setRootLayout(model, layout);
+  return setPropertyLayout(model, scopePath, layout);
+}
+function removeLayoutGroup(model, scopePath, groupIndex) {
+  const groups = groupsOf(model, scopePath);
+  if (!groups[groupIndex]) return model;
+  const remaining = groups.filter((_, i) => i !== groupIndex);
+  if (remaining.length > 0) {
+    return setScopedLayoutGroups(model, scopePath, remaining);
+  }
+  const cleared = setScopedLayoutGroups(model, scopePath, []);
+  return setScopedLayoutRows(cleared, scopePath, groups[groupIndex].rows);
+}
+function setScopedGroupRows(model, scopePath, groupIndex, rows) {
+  const groups = getScopedLayout(
+    model.schema,
+    model.uiSchema,
+    scopePath
+  )?.groups;
+  if (!groups?.[groupIndex]) return model;
+  const next = groups.map(
+    (group, i) => i === groupIndex ? { ...group, rows } : group
+  );
+  return setScopedLayoutGroups(model, scopePath, next);
+}
+function setScopedLayoutMode(model, scopePath, mode2) {
+  const layout = getScopedLayout(model.schema, model.uiSchema, scopePath) ?? {};
+  const groups = layout.groups ?? [];
+  const rows = layout.rows ?? [];
+  if (mode2 === "groups") {
+    if (groups.length > 0) return model;
+    return setScopedLayoutGroups(model, scopePath, [
+      { label: "Group 1", rows }
+    ]);
+  }
+  if (groups.length === 0) return model;
+  const flattened = [...rows, ...groups.flatMap((group) => group.rows)];
+  const cleared = setScopedLayoutGroups(model, scopePath, []);
+  return setScopedLayoutRows(cleared, scopePath, flattened);
+}
+function setGlobalOptions(model, options) {
+  const uiSchema = { ...model.uiSchema };
+  if (options) uiSchema["x-ui-globalOptions"] = options;
+  else delete uiSchema["x-ui-globalOptions"];
+  return { schema: model.schema, uiSchema };
+}
+
+// src/model/view.ts
+import { isOneOf as isOneOf2 } from "@petrarca/sonnet-core/schema";
+function propertyKind(prop2) {
+  if (prop2.if) return "conditional";
+  if (isOneOf2(prop2)) return "oneOf";
+  if (prop2.type === "object" && prop2.properties) return "object";
+  if (prop2.type === "array") return "array";
+  if (Array.isArray(prop2.enum) && prop2.enum.length > 0) return "enum";
+  return "scalar";
+}
+function arrayCardinality(min, max) {
+  if (min == null && max == null) return "";
+  if (min != null && min === max) return `${min}`;
+  return `${min ?? ""}..${max ?? ""}`;
+}
+function unionLabelOf(prop2) {
+  const members = prop2.anyOf;
+  if (Array.isArray(members) && members.length > 0 && members.every((m) => !m.if)) {
+    return members.map(typeLabelOf).join(" | ");
+  }
+  const type = prop2.type;
+  return Array.isArray(type) ? type.join(" | ") : void 0;
+}
+function typeLabelOf(prop2) {
+  if (prop2.if) return "if/then/else";
+  if (isOneOf2(prop2)) return "oneOf";
+  const union = unionLabelOf(prop2);
+  if (union) return union;
+  if (prop2.type === "array") {
+    const itemType = prop2.items?.type ?? "any";
+    return `${itemType}[${arrayCardinality(prop2.minItems, prop2.maxItems)}]`;
+  }
+  return prop2.type ?? "any";
+}
+function orderedKeys(properties, order) {
+  const keys = Object.keys(properties);
+  if (!order || order.length === 0) return keys;
+  const inOrder = order.filter((k) => k in properties);
+  const rest = keys.filter((k) => !inOrder.includes(k));
+  return [...inOrder, ...rest];
+}
+function requiredOf(prop2) {
+  if (prop2.type === "object") return prop2.required;
+  if (prop2.type === "array") return prop2.items?.required;
+  return void 0;
+}
+function orderOf(prop2) {
+  if (prop2.type === "array") return prop2.items?.["x-ui-order"];
+  return prop2["x-ui-order"];
+}
+function nodeKind(slot2, prop2) {
+  if (slot2.kind === "branch") return "object";
+  if (slot2.segment.kind === "def") return "definition";
+  if (slot2.segment.kind === "slot") return "object";
+  return propertyKind(prop2);
+}
+function requiredForChildren(prop2, isSlot) {
+  return isSlot ? prop2.required : requiredOf(prop2);
+}
+function resolveRefTarget(prop2, resolve) {
+  if (!prop2.$ref || !resolve) return void 0;
+  const target = resolve(prop2.$ref);
+  if (!target) return void 0;
+  const { $ref: _drop, ...overrides } = prop2;
+  return { ...target, ...overrides };
+}
+function refShapeOf(slot2, prop2, resolve) {
+  const refTarget = resolveRefTarget(prop2, resolve);
+  if (refTarget) {
+    return {
+      kind: "reference",
+      typeLabel: refLabel(prop2.$ref),
+      reference: prop2.$ref,
+      container: refTarget,
+      childrenFromRef: true
+    };
+  }
+  if (prop2.type === "array" && prop2.items?.$ref) {
+    const itemTarget = resolveRefTarget(prop2.items, resolve);
+    if (itemTarget) {
+      return {
+        kind: "array",
+        typeLabel: arrayItemLabel(prop2.items.$ref, prop2),
+        reference: prop2.items.$ref,
+        container: itemTarget,
+        childrenFromRef: true
+      };
+    }
+  }
+  return {
+    kind: nodeKind(slot2, prop2),
+    typeLabel: typeLabelOf(prop2),
+    container: prop2,
+    childrenFromRef: false
+  };
+}
+function buildNode(slot2, parentPath, required, resolve, inRef) {
+  const path = [...parentPath, slot2.segment];
+  const prop2 = slot2.property;
+  const widget = typeof prop2["x-ui-widget"] === "string" ? prop2["x-ui-widget"] : void 0;
+  const ref = refShapeOf(slot2, prop2, resolve);
+  const node = {
+    path,
+    key: slot2.label,
+    property: prop2,
+    kind: ref.kind,
+    slotKind: slot2.kind,
+    required,
+    typeLabel: ref.typeLabel,
+    widget,
+    reference: ref.reference,
+    readOnly: inRef || void 0,
+    children: []
+  };
+  if (isContainer(ref.container)) {
+    const isSlot = slot2.segment.kind === "slot";
+    const req = requiredForChildren(ref.container, isSlot);
+    const childrenInRef = inRef || ref.childrenFromRef;
+    node.children = orderedSlots(ref.container).map(
+      (child) => buildNode(
+        child,
+        path,
+        child.kind === "property" ? !!req?.includes(child.label) : false,
+        resolve,
+        childrenInRef
+      )
+    );
+  }
+  return node;
+}
+function refName(ref) {
+  const local = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+  return local ? local[1] : ref.split("/").pop() || ref;
+}
+function refLabel(ref) {
+  return `\u2192 ${refName(ref)}`;
+}
+function arrayItemLabel(ref, prop2) {
+  return `${refName(ref)}[${arrayCardinality(prop2.minItems, prop2.maxItems)}]`;
+}
+function orderedSlots(prop2) {
+  const slots = childSlots(prop2);
+  const propertySlots = slots.filter((s) => s.kind === "property");
+  const otherSlots = slots.filter((s) => s.kind !== "property");
+  const order = orderOf(prop2);
+  if (propertySlots.length === 0 || !order || order.length === 0) return slots;
+  const byLabel = new Map(propertySlots.map((s) => [s.label, s]));
+  const inOrder = order.filter((k) => byLabel.has(k)).map((k) => byLabel.get(k));
+  const rest = propertySlots.filter((s) => !order.includes(s.label));
+  return [...inOrder, ...rest, ...otherSlots];
+}
+function buildPropertyTree(schema, resolve) {
+  const effective = withInDocumentFallback(schema, resolve);
+  const rootProp = schemaAsRootProp(schema);
+  return orderedSlots(rootProp).map(
+    (slot2) => buildNode(
+      slot2,
+      [],
+      !!schema.required?.includes(slot2.label),
+      effective,
+      false
+    )
+  );
+}
+function withInDocumentFallback(schema, resolve) {
+  const defs = schema.$defs ?? schema.definitions;
+  if (!defs) return resolve;
+  const local = (ref) => {
+    const m = ref.match(/^#\/(?:\$defs|definitions)\/(.+)$/);
+    return m ? defs[m[1]] : void 0;
+  };
+  return resolve ? (ref) => resolve(ref) ?? local(ref) : local;
+}
+function layoutScopes(schema) {
+  const scopes = [{ path: [], label: "Form (root)" }];
+  const walk = (nodes, labelPrefix) => {
+    for (const node of nodes) {
+      const allProps = node.path.every((s) => s.kind === "prop");
+      if (allProps && (node.kind === "object" || node.kind === "array")) {
+        const labels = [...labelPrefix, node.key];
+        const suffix = node.kind === "array" ? " (items)" : "";
+        scopes.push({
+          path: node.path,
+          label: labels.join(" \u203A ") + suffix
+        });
+        walk(node.children, labels);
+      }
+    }
+  };
+  walk(buildPropertyTree(schema), []);
+  return scopes;
+}
+
+// src/questionnaire/showIf.ts
+import {
+  bindingOf as bindingOf2,
+  codeToken,
+  CODEABLE_CONCEPT_TYPE_ID,
+  CODING_TYPE_ID,
+  parseCodeToken,
+  valueRefOf as valueRefOf3
+} from "@petrarca/sonnet-core/schema";
+
+// src/model/conditions.ts
+var CONDITION_OPERATORS = [
+  "=",
+  "!=",
+  ">",
+  ">=",
+  "<",
+  "<=",
+  "exists"
+];
+var CONDITION_OPERATOR_LABELS = {
+  "=": "equals",
+  "!=": "not equals",
+  ">": "greater than",
+  ">=": "greater or equal",
+  "<": "less than",
+  "<=": "less or equal",
+  exists: "exists"
+};
+var OPERATOR_OPTIONS = CONDITION_OPERATORS.map((op) => ({
+  value: op,
+  label: CONDITION_OPERATOR_LABELS[op]
+}));
+var NUMERIC_OPS = /* @__PURE__ */ new Set([
+  ">",
+  ">=",
+  "<",
+  "<="
+]);
+function coerceValue(value) {
+  if (value.trim() === "") return value;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : value;
+}
+function coerceForScope(value, operator, type) {
+  if (NUMERIC_OPS.has(operator)) return coerceValue(value);
+  if (type === "boolean") return value === "true";
+  if (type === "number" || type === "integer") return coerceValue(value);
+  return value;
+}
+function operatorToConstraint(operator, value, type) {
+  const v = coerceForScope(value, operator, type);
+  switch (operator) {
+    case "=":
+      return { const: v };
+    case "!=":
+      return { not: { const: v } };
+    case ">":
+      return { exclusiveMinimum: v };
+    case ">=":
+      return { minimum: v };
+    case "<":
+      return { exclusiveMaximum: v };
+    case "<=":
+      return { maximum: v };
+    case "exists":
+      return {};
+  }
+}
+function conditionToIf(condition2, type) {
+  const { field, operator } = condition2;
+  if (!field) return void 0;
+  if (operator === "exists") {
+    return { required: [field] };
+  }
+  return {
+    properties: {
+      [field]: operatorToConstraint(operator, condition2.value, type)
+    },
+    required: [field]
+  };
+}
+function constraintToOperator(c) {
+  if (c.not && "const" in c.not)
+    return { operator: "!=", value: String(c.not.const) };
+  if (c.exclusiveMinimum !== void 0)
+    return { operator: ">", value: String(c.exclusiveMinimum) };
+  if (c.minimum !== void 0)
+    return { operator: ">=", value: String(c.minimum) };
+  if (c.exclusiveMaximum !== void 0)
+    return { operator: "<", value: String(c.exclusiveMaximum) };
+  if (c.maximum !== void 0)
+    return { operator: "<=", value: String(c.maximum) };
+  if ("const" in c) return { operator: "=", value: String(c.const) };
+  return { operator: "exists", value: "" };
+}
+function ifToCondition(ifSchema) {
+  const empty = { field: "", operator: "=", value: "" };
+  if (!ifSchema) return empty;
+  const props = ifSchema.properties ?? {};
+  const field = Object.keys(props)[0] ?? ifSchema.required?.[0] ?? "";
+  if (!field) return empty;
+  const constraint = props[field];
+  if (!constraint) return { field, operator: "exists", value: "" };
+  const { operator, value } = constraintToOperator(constraint);
+  return { field, operator, value };
+}
+
+// src/questionnaire/showIf.ts
+function codedKind(field) {
+  const ref = field && valueRefOf3(field)?.ref;
+  if (ref === CODING_TYPE_ID) return "coding";
+  return ref === CODEABLE_CONCEPT_TYPE_ID ? "concept" : void 0;
+}
+function codingIs(token, field) {
+  const { system, code } = parseCodeToken(token, bindingOf2(field)?.system);
+  return {
+    type: "object",
+    properties: {
+      ...system ? { system: { const: system } } : {},
+      code: { const: code }
+    },
+    required: ["code"]
+  };
+}
+function codedIs(c, field, kind) {
+  if (kind === "coding")
+    return c.asText ? { const: c.value } : codingIs(c.value, field);
+  return c.asText ? { properties: { text: { const: c.value } }, required: ["text"] } : {
+    properties: { codings: { contains: codingIs(c.value, field) } },
+    required: ["codings"]
+  };
+}
+function conditionIf(c, field) {
+  const kind = codedKind(field);
+  if (!field || !kind || c.operator !== "=" && c.operator !== "!=")
+    return conditionToIf(c, field?.type);
+  const one = codedIs(c, field, kind);
+  const is = valueRefOf3(field)?.multiple ? { contains: one } : one;
+  return {
+    properties: { [c.field]: c.operator === "=" ? is : { not: is } },
+    required: [c.field]
+  };
+}
+function codeOf(is, field) {
+  const code = is.properties?.code?.const;
+  if (typeof code !== "string") return void 0;
+  const system = is.properties?.system?.const;
+  return codeToken(
+    { system: typeof system === "string" ? system : void 0, code },
+    bindingOf2(field)?.system
+  );
+}
+function asCodingConstraint(one) {
+  const text = one?.properties?.text?.const;
+  if (typeof text === "string") return { const: text };
+  return one?.properties?.codings?.contains;
+}
+function codedOf(constraint, field, kind) {
+  const one = kind === "concept" ? asCodingConstraint(constraint) : constraint;
+  if (!one) return void 0;
+  if (typeof one.const === "string") return { value: one.const, asText: true };
+  const value = codeOf(one, field);
+  return value === void 0 ? void 0 : { value };
+}
+function readCoding2(constraint, field) {
+  const kind = codedKind(field);
+  if (!field || !kind) return void 0;
+  const negated = constraint.not;
+  const is = negated ?? constraint;
+  const one = valueRefOf3(field)?.multiple ? is.contains : is;
+  const read = codedOf(one, field, kind);
+  return read && { operator: negated ? "!=" : "=", ...read };
+}
+function allIf(conditions, typeOf) {
+  const properties = {};
+  const required = [];
+  for (const c of conditions) {
+    const one = conditionIf(c, typeOf(c.field));
+    Object.assign(properties, one?.properties ?? {});
+    for (const r of one?.required ?? [])
+      if (!required.includes(r)) required.push(r);
+  }
+  return {
+    ...Object.keys(properties).length ? { properties } : {},
+    required
+  };
+}
+function showIfToIf(showIf, typeOf) {
+  if (showIf.behavior === "any" && showIf.conditions.length > 1) {
+    return { anyOf: showIf.conditions.map((c) => allIf([c], typeOf)) };
+  }
+  return allIf(showIf.conditions, typeOf);
+}
+function readAll(ifSchema, typeOf) {
+  const props = ifSchema.properties ?? {};
+  const fields = [
+    .../* @__PURE__ */ new Set([...Object.keys(props), ...ifSchema.required ?? []])
+  ];
+  return fields.map((field) => {
+    const constraint = props[field];
+    if (!constraint) return { field, operator: "exists", value: "" };
+    return {
+      field,
+      ...readCoding2(constraint, typeOf(field)) ?? constraintToOperator(constraint)
+    };
+  });
+}
+function readShowIf(ifSchema, typeOf) {
+  if (Array.isArray(ifSchema.anyOf)) {
+    return {
+      behavior: "any",
+      conditions: ifSchema.anyOf.flatMap((m) => readAll(m, typeOf))
+    };
+  }
+  return { behavior: "all", conditions: readAll(ifSchema, typeOf) };
+}
+function canonical(value) {
+  return JSON.stringify(
+    value,
+    (_, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(
+      Object.keys(v).sort().map((k) => [k, v[k]])
+    ) : v
+  );
+}
+function readConditional(member, sectionKeys, typeOf) {
+  const { if: ifSchema, then } = member;
+  if (!ifSchema || !then?.properties || Object.keys(member).some((k) => k !== "if" && k !== "then"))
+    return null;
+  if (Object.keys(then).some((k) => k !== "properties" && k !== "required"))
+    return null;
+  const showIf = readShowIf(ifSchema, typeOf);
+  if (showIf.conditions.length === 0) return null;
+  if (showIf.conditions.some((c) => !sectionKeys.has(c.field))) return null;
+  if (canonical(showIfToIf(showIf, typeOf)) !== canonical(ifSchema))
+    return null;
+  return { showIf, properties: then.properties, required: then.required ?? [] };
+}
+
+// src/questionnaire/reasons.ts
+var ABSENT_KEY = "absent";
+var ABSENT_WIDGET = "absent-reasons";
+function absentProperty(reasons) {
+  return {
+    type: "object",
+    title: "Not answered",
+    additionalProperties: { type: "string", enum: reasons.map((r) => r.value) },
+    "x-ui-widget": ABSENT_WIDGET,
+    // A pick is final: the reasons apply at once, also in a deferred form.
+    "x-ui-options": {
+      enumNames: Object.fromEntries(reasons.map((r) => [r.value, r.label])),
+      immediate: true
+    }
+  };
+}
+function readReasons(prop2) {
+  const values = prop2?.additionalProperties?.enum;
+  if (!prop2 || !Array.isArray(values)) return void 0;
+  const names = prop2["x-ui-options"]?.enumNames ?? {};
+  const reasons = values.map((v) => ({
+    value: String(v),
+    label: names[String(v)] ?? String(v)
+  }));
+  return JSON.stringify(prop2) === JSON.stringify(absentProperty(reasons)) ? reasons : void 0;
+}
+function unlessReasonMember(key) {
+  return {
+    if: {
+      not: {
+        properties: { [ABSENT_KEY]: { required: [key] } },
+        required: [ABSENT_KEY]
+      }
+    },
+    then: { required: [key] }
+  };
+}
+function unlessReasonKey(member) {
+  const key = member.then?.required?.[0];
+  return key !== void 0 && JSON.stringify(member) === JSON.stringify(unlessReasonMember(key)) ? key : void 0;
+}
+function answeredOrExcused(answers, key) {
+  const value = answers?.[key];
+  const answered = value !== void 0 && value !== null && value !== "" && !(Array.isArray(value) && value.length === 0);
+  return answered || answers?.[ABSENT_KEY]?.[key] !== void 0;
+}
+
+// src/questionnaire/classify.ts
+var SECTION_KEYWORDS = [
+  "type",
+  "title",
+  "description",
+  "properties",
+  "required",
+  "x-ui-order"
+];
+var REPEATING_KEYWORDS = [
+  "type",
+  "title",
+  "description",
+  "items",
+  "minItems",
+  "maxItems"
+];
+var TEXT_KEYWORDS = ["type", "title", "description"];
+var ROOT_KEYWORDS = [
+  "$schema",
+  "$id",
+  "type",
+  "title",
+  "description",
+  "properties",
+  "required",
+  "x-ui-order"
+];
+var ROOT_UI_KEYS = ["x-ui-layout", "x-ui-globalOptions"];
+function effectiveHints(model, prop2, path) {
+  return { ...embeddedHints(prop2), ...getUiEntryAtPath(model.uiSchema, path) };
+}
+function hintText(ui, key) {
+  const value = ui[key];
+  return typeof value === "string" ? value : void 0;
+}
+function extrasOf(prop2, known) {
+  return Object.keys(prop2).filter((k) => !known.includes(k));
+}
+function optionsOf(prop2, ui, type) {
+  const source = choiceSource(prop2, ui, type);
+  if (!source) return void 0;
+  const names = source.ui["x-ui-options"]?.enumNames ?? {};
+  return source.values.map((v) => ({
+    value: String(v),
+    label: names[String(v)] ?? String(v)
+  }));
+}
+function choiceSource(prop2, ui, type) {
+  if (type === "singleChoice") return { values: prop2.enum ?? [], ui };
+  if (type === "multipleChoice") return { values: prop2.items?.enum ?? [], ui };
+  return type === "choiceWithText" ? innerChoiceSource(prop2, ui) : void 0;
+}
+function innerChoiceSource(prop2, ui) {
+  const choice = prop2.properties?.choice;
+  if (!choice) return void 0;
+  const fields = ui["x-ui-fields"] ?? {};
+  return {
+    values: choice.enum ?? [],
+    ui: { ...embeddedHints(choice), ...fields.choice }
+  };
+}
+function lockReason(prop2) {
+  if (prop2.$ref) return "a reference to a shared definition ($ref)";
+  if (isOneOf3(prop2)) return "alternative structures (oneOf)";
+  if (prop2.if) return "a condition (if / then)";
+  if (Array.isArray(prop2.anyOf)) return "a union of types (anyOf)";
+  if (Array.isArray(prop2.allOf)) return "combined schemas (allOf)";
+  return `a ${prop2.type ?? "property"} of no answer type's shape`;
+}
+function lockedMember(member, combinator, index, path) {
+  return {
+    kind: "locked",
+    key: `${combinator}[${index}]`,
+    path: [...path, condition(index, combinator)],
+    title: member.if ? "Condition" : "Combined schema",
+    reason: member.if ? "a condition (if / then)" : `combined schemas (${combinator})`
+  };
+}
+function containerItems(r, container, path) {
+  const properties = questionProperties(container);
+  const fields = containerFields(container);
+  const keys = new Set(Object.keys(fields));
+  const typeOf = (field) => fields[field];
+  const requiredUnless = new Set(
+    (container.allOf ?? []).map(unlessReasonKey).filter((k) => k !== void 0)
+  );
+  const isRequired = (key) => (container.required?.includes(key) ?? false) || requiredUnless.has(key);
+  const byKey = /* @__PURE__ */ new Map();
+  for (const [key, prop2] of Object.entries(properties)) {
+    byKey.set(
+      key,
+      classifyItem(r, key, prop2, [...path, prop(key)], isRequired(key))
+    );
+  }
+  const locked = [];
+  (container.allOf ?? []).forEach((member, index) => {
+    if (unlessReasonKey(member) !== void 0) return;
+    const read = readConditional(member, keys, typeOf);
+    if (!read || Object.keys(read.properties).some((k) => byKey.has(k))) {
+      locked.push(lockedMember(member, "allOf", index, path));
+      return;
+    }
+    for (const [key, prop2] of Object.entries(read.properties)) {
+      const itemPath = [
+        ...path,
+        condition(index, "allOf"),
+        slot("then"),
+        prop(key)
+      ];
+      byKey.set(key, {
+        ...classifyItem(r, key, prop2, itemPath, read.required.includes(key)),
+        showIf: read.showIf
+      });
+    }
+  });
+  (container.anyOf ?? []).forEach(
+    (member, index) => locked.push(lockedMember(member, "anyOf", index, path))
+  );
+  const order = orderedKeys(
+    Object.fromEntries([...byKey.keys()].map((k) => [k, {}])),
+    container["x-ui-order"]
+  );
+  return [...order.map((k) => byKey.get(k)), ...locked];
+}
+function questionProperties(container) {
+  const { [ABSENT_KEY]: absent, ...rest } = container.properties ?? {};
+  return absent && !readReasons(absent) ? { ...rest, [ABSENT_KEY]: absent } : rest;
+}
+function containerFields(container) {
+  return Object.assign(
+    {},
+    ...(container.allOf ?? []).map((m) => m.then?.properties ?? {}),
+    questionProperties(container)
+  );
+}
+function containerOrder(container) {
+  const conditional = (container.allOf ?? []).flatMap(
+    (m) => Object.keys(m.then?.properties ?? {})
+  );
+  const keys = [...Object.keys(questionProperties(container)), ...conditional];
+  return orderedKeys(
+    Object.fromEntries(keys.map((k) => [k, {}])),
+    container["x-ui-order"]
+  );
+}
+function partsOf(r, prop2, path, textWhen) {
+  const own = classifyItems(
+    r,
+    prop2.properties,
+    prop2["x-ui-order"],
+    prop2.required,
+    path
+  );
+  const text = textWhen === void 0 ? void 0 : prop2.allOf?.[0]?.then?.properties?.text;
+  if (!text) return own;
+  const textPath = [
+    ...path,
+    condition(0, "allOf"),
+    slot("then"),
+    prop("text")
+  ];
+  return [
+    ...own,
+    classifyItem(r, "text", text, textPath, true)
+  ];
+}
+function classifyItems(r, properties, order, required, path) {
+  if (!properties) return [];
+  return orderedKeys(properties, order).map(
+    (key) => classifyItem(
+      r,
+      key,
+      properties[key],
+      [...path, prop(key)],
+      required?.includes(key) ?? false
+    )
+  );
+}
+function classifyItem(r, key, prop2, path, required) {
+  const ui = effectiveHints(r.model, prop2, path);
+  const title = hintText(ui, "x-ui-title") ?? prop2.title ?? key;
+  if (prop2.type === "null") {
+    return {
+      kind: "text",
+      key,
+      path,
+      title: prop2.title,
+      text: prop2.description,
+      extras: extrasOf(prop2, TEXT_KEYWORDS)
+    };
+  }
+  const answer = recognizeAnswerType(prop2, ui, r.types);
+  if (answer)
+    return questionItem(r, { key, prop: prop2, path, required, title, ui }, answer);
+  const section = classifySection(r, key, prop2, path, required, title);
+  return section ?? { kind: "locked", key, path, title, reason: lockReason(prop2) };
+}
+function presentationOf(ui, extras) {
+  const widget = ui["x-ui-widget"];
+  return typeof widget === "string" && !extras.includes("x-ui-widget") ? widget : void 0;
+}
+function questionItem(r, at, answer) {
+  const { key, prop: prop2, path, required, title, ui } = at;
+  const options = optionsOf(prop2, ui, answer.type);
+  const textWhen = answer.type === "choiceWithText" ? choiceTextWhen(prop2) : void 0;
+  const limits = limitsOf(prop2, answer.type);
+  const settings = settingsOf(r, answer.type, prop2, ui);
+  const parts = isContainerType(answer.type) ? partsOf(r, prop2, path, textWhen) : void 0;
+  const presentation = presentationOf(ui, answer.extras);
+  return {
+    kind: "question",
+    key,
+    path,
+    title,
+    help: hintText(ui, "x-ui-description") ?? prop2.description,
+    placeholder: hintText(ui, "x-ui-placeholder"),
+    required,
+    readOnly: prop2.readOnly === true,
+    answerType: answer.type,
+    ...presentation ? { presentation } : {},
+    ...options ? { options } : {},
+    ...parts ? { parts } : {},
+    ...textWhen !== void 0 ? { textWhen } : {},
+    ...Object.keys(limits).length ? { limits } : {},
+    ...settings ? { settings } : {},
+    ...defaultOf(prop2, answer.type),
+    extras: answer.extras
+  };
+}
+function defaultOf(prop2, type) {
+  return prop2.default !== void 0 && !isContainerType(type) ? { defaultAnswer: prop2.default } : {};
+}
+function settingsOf(r, type, prop2, ui) {
+  return valueTypeAnswer(type, r.types)?.settings?.read(prop2, ui);
+}
+function countOf(prop2) {
+  return {
+    ...prop2.minItems !== void 0 ? { minItems: prop2.minItems } : {},
+    ...prop2.maxItems !== void 0 ? { maxItems: prop2.maxItems } : {}
+  };
+}
+function classifySection(r, key, prop2, path, required, title) {
+  if (prop2.$ref || isOneOf3(prop2) || prop2.if) return null;
+  const repeats = prop2.type === "array";
+  const body = repeats ? prop2.items : prop2;
+  if (!body || body.type !== "object" || !body.properties) return null;
+  const extras = repeats ? [
+    ...extrasOf(prop2, REPEATING_KEYWORDS),
+    ...extrasOf(body, SECTION_KEYWORDS).map((k) => `items.${k}`)
+  ] : extrasOf(prop2, SECTION_KEYWORDS);
+  return {
+    kind: "section",
+    key,
+    path,
+    title,
+    description: prop2.description,
+    repeats,
+    required,
+    ...repeats ? { limits: countOf(prop2) } : {},
+    items: containerItems(r, body, path),
+    extras: extras.filter(
+      (k) => !["allOf", "anyOf", "items.allOf", "items.anyOf"].includes(k)
+    )
+  };
+}
+function rootReasons(schema) {
+  return readReasons(schema.properties?.[ABSENT_KEY]);
+}
+function itemsOf(items) {
+  return items.flatMap(
+    (i) => i.kind === "section" ? [i, ...itemsOf(i.items)] : [i]
+  );
+}
+function classifyQuestionnaire(model, types = DEFAULT_VALUE_TYPES) {
+  const { schema, uiSchema } = model;
+  const r = { model, types };
+  const rootUi = uiSchema;
+  return {
+    title: schema.title,
+    description: schema.description,
+    items: containerItems(r, schema, []),
+    ...rootReasons(schema) ? { reasons: rootReasons(schema) } : {},
+    extras: [
+      ...Object.keys(schema).filter(
+        (k) => !ROOT_KEYWORDS.includes(k) && k !== "allOf" && k !== "anyOf"
+      ),
+      ...ROOT_UI_KEYS.filter((k) => rootUi[k] !== void 0).map(
+        (k) => `uiSchema.${k}`
+      )
+    ]
+  };
+}
+
+// src/questionnaire/edit.ts
+var KEY_RE = /^[a-z][a-z0-9_]*$/;
+var MAX_KEY_LENGTH = 40;
+function keyFromText(text, taken) {
+  const base = text.replace(/ß/g, "ss").normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/^(\d)/, "q_$1").slice(0, MAX_KEY_LENGTH).replace(/_+$/, "") || "question";
+  const used = new Set(taken);
+  if (!used.has(base)) return base;
+  let i = 2;
+  while (used.has(`${base}_${i}`)) i++;
+  return `${base}_${i}`;
+}
+function isValidKey(key) {
+  return KEY_RE.test(key) && !isReservedKey(key);
+}
+function containerProperties(model, path) {
+  if (path.length === 0) return model.schema.properties ?? {};
+  const owner = getProperty(model.schema, path);
+  const target = owner?.type === "array" ? owner.items : owner;
+  return target?.properties ?? {};
+}
+function hintsAt(model, path) {
+  const prop2 = getProperty(model.schema, path);
+  return {
+    ...prop2 ? embeddedHints(prop2) : {},
+    ...getUiEntryAtPath(model.uiSchema, path)
+  };
+}
+function replaceProperty(model, path, next) {
+  const current = getProperty(model.schema, path);
+  if (!current) return model;
+  const patch = Object.fromEntries(
+    Object.keys(current).map((k) => [k, void 0])
+  );
+  return updateProperty(model, path, { ...patch, ...next });
+}
+function newItemFragment(item, text) {
+  if (item.kind === "text")
+    return { prop: { type: "null", title: text }, ui: {} };
+  if (item.kind === "section")
+    return { prop: { type: "object", title: text, properties: {} }, ui: {} };
+  const fragment = answerTypeFragment(item.answerType);
+  return { prop: { ...fragment.prop, title: text }, ui: fragment.ui };
+}
+function addItem(model, parentPath, item, text) {
+  const key = keyFromText(
+    text,
+    Object.keys(containerProperties(model, parentPath))
+  );
+  const added = addProperty(model, parentPath, "scalar");
+  if (added.path === parentPath) return { model, path: parentPath };
+  const renamed = renameProperty(added.model, added.path, key);
+  const { prop: prop2, ui } = newItemFragment(item, text);
+  const replaced = replaceProperty(renamed.model, renamed.path, prop2);
+  const withUi = Object.keys(ui).length ? setUiEntry(replaced, renamed.path, ui) : replaced;
+  const reasons = declaredReasons(withUi);
+  if (item.kind !== "section" || !reasons)
+    return { model: withUi, path: renamed.path };
+  const section = { ...getProperty(withUi.schema, renamed.path) };
+  section.properties = {
+    ...section.properties,
+    [ABSENT_KEY]: absentProperty(reasons)
+  };
+  return {
+    model: updateProperty(withUi, renamed.path, {
+      properties: section.properties
+    }),
+    path: renamed.path
+  };
+}
+function setItemText(model, path, text) {
+  return updateProperty(model, path, { title: text || void 0 });
+}
+function setHelp(model, path, help) {
+  return updateProperty(model, path, { description: help || void 0 });
+}
+function setReadOnly(model, path, readOnly) {
+  return updateProperty(model, path, { readOnly: readOnly || void 0 });
+}
+function setHint(model, path, key, value) {
+  const entry = { ...getUiEntryAtPath(model.uiSchema, path) };
+  if (value === void 0 || value === "")
+    delete entry[key];
+  else entry[key] = value;
+  return setUiEntry(model, path, Object.keys(entry).length ? entry : void 0);
+}
+function setPresentation(model, path, widget) {
+  return setHint(model, path, "x-ui-widget", widget);
+}
+var isEmptyAnswer = (value) => value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+function setDefaultAnswer(model, path, value) {
+  return updateProperty(model, path, {
+    default: isEmptyAnswer(value) ? void 0 : value
+  });
+}
+function setPlaceholder(model, path, example) {
+  return setHint(model, path, "x-ui-placeholder", example);
+}
+function setKey(model, path, key) {
+  const { containerPath, key: prev } = locate(path);
+  const container = containerAt(model.schema, containerPath);
+  if (!isValidKey(key) || !container || containerOrder(container).includes(key))
+    return { model, path };
+  const renamed = renameProperty(model, path, key);
+  if (renamed.path === path) return { model, path };
+  const target = containerAt(renamed.model.schema, containerPath);
+  if (target["x-ui-order"])
+    target["x-ui-order"] = target["x-ui-order"].map(
+      (k) => k === prev ? key : k
+    );
+  renameInConditions(target, prev, key);
+  if (removeUnlessReason(target, prev))
+    target.allOf = [...target.allOf ?? [], unlessReasonMember(key)];
+  return renamed;
+}
+function choicePath(model, path) {
+  const prop2 = getProperty(model.schema, path);
+  if (prop2?.type === "object")
+    return { path: [...path, prop("choice")], onItems: false };
+  return { path, onItems: prop2?.type === "array" };
+}
+function setOptions(model, path, options) {
+  const prop2 = getProperty(model.schema, path);
+  const when = prop2?.type === "object" ? choiceTextWhen(prop2) : void 0;
+  if (when !== void 0 && !options.some((o) => o.value === when)) {
+    return setOptions(setChoiceTextWhen(model, path, null), path, options);
+  }
+  const target = choicePath(model, path);
+  const choices = options.map((o) => ({
+    value: o.value,
+    label: o.label === o.value ? "" : o.label
+  }));
+  if (!target.onItems) return setEnum(model, target.path, choices);
+  return setItemsOptions(model, path, options, choices);
+}
+var CHOICE_TYPES = [
+  "singleChoice",
+  "multipleChoice",
+  "choiceWithText"
+];
+var KEPT_HINTS = ["x-ui-title", "x-ui-description", "x-ui-placeholder"];
+function changeAnswerType(model, path, type, types = DEFAULT_VALUE_TYPES, keep = []) {
+  const current = currentAnswer(model, path, types);
+  if (!current || current.type === type) return { model, lost: [] };
+  const { prop: prop2, options, extras } = current;
+  const keepOptions = CHOICE_TYPES.includes(type) && options.length > 0;
+  const limits = limitsAcross(prop2, current.type, type);
+  const rewritten = rewriteAs(
+    model,
+    path,
+    prop2,
+    type,
+    keepOptions ? options : [],
+    [...limits.kept, ...keep]
+  );
+  const dropped = extras.filter((e) => !keep.includes(e));
+  return {
+    model: keepOptions ? setOptions(rewritten, path, options) : rewritten,
+    lost: [
+      ...lostSettings(model, path, dropped, options.length > 0 && !keepOptions),
+      ...limits.lost,
+      ...lostDefault(prop2, current.type)
+    ]
+  };
+}
+function lostDefault(prop2, from) {
+  return from && !isContainerType(from) && prop2.default !== void 0 ? ["default answer"] : [];
+}
+function limitsAcross(prop2, from, to) {
+  const limits = Object.keys(from ? limitsOf(prop2, from) : {});
+  const kept = limits.filter((k) => limitsFor(to).includes(k));
+  return {
+    kept,
+    lost: limits.filter((k) => !kept.includes(k)).map((k) => LIMIT_LABELS[k].toLowerCase())
+  };
+}
+function currentAnswer(model, path, types) {
+  const prop2 = getProperty(model.schema, path);
+  if (!prop2) return null;
+  const hints = hintsAt(model, path);
+  const answer = recognizeAnswerType(prop2, hints, types);
+  if (!answer) return { prop: prop2, options: [], extras: [] };
+  return {
+    prop: prop2,
+    type: answer.type,
+    options: optionsOf(prop2, hints, answer.type) ?? [],
+    extras: [...answer.extras, ...settingsSet(prop2, hints, answer.type, types)]
+  };
+}
+function settingsSet(prop2, hints, type, types) {
+  const settings = valueTypeAnswer(type, types)?.settings;
+  if (!settings) return [];
+  return Object.entries(settings.read(prop2, hints)).filter(([, v]) => Array.isArray(v) ? v.length > 0 : v !== void 0).map(([k]) => (settings.fields[k]?.title ?? k).toLowerCase());
+}
+function rewriteAs(model, path, prop2, type, options, limits) {
+  const fragment = answerTypeFragment(
+    type,
+    options.length ? options.map((o) => o.value) : void 0
+  );
+  const next = {
+    ...fragment.prop,
+    ...pick(prop2, ["title", "description", "readOnly", ...limits]),
+    ...pick(prop2, KEPT_HINTS)
+  };
+  const ui = {
+    ...fragment.ui,
+    ...pick(getUiEntryAtPath(model.uiSchema, path) ?? {}, KEPT_HINTS)
+  };
+  return setUiEntry(
+    replaceProperty(model, path, next),
+    path,
+    Object.keys(ui).length ? ui : void 0
+  );
+}
+function lostSettings(model, path, extras, optionsDropped) {
+  const childHints = getUiEntryAtPath(model.uiSchema, path)?.["x-ui-fields"] ? ["the parts' settings"] : [];
+  return [...extras, ...optionsDropped ? ["options"] : [], ...childHints];
+}
+function pick(obj, keys) {
+  return Object.fromEntries(
+    Object.entries(obj).filter(([k]) => keys.includes(k))
+  );
+}
+function setKeywords(model, path, keywords) {
+  if (path.length > 0)
+    return updateProperty(model, path, keywords);
+  const schema = { ...model.schema };
+  for (const [k, v] of Object.entries(keywords)) {
+    if (v === void 0) delete schema[k];
+    else schema[k] = v;
+  }
+  return { schema, uiSchema: model.uiSchema };
+}
+var SECTION_OWN = ["title", "description", "readOnly"];
+function setSectionRepeats(model, path, repeats) {
+  const prop2 = getProperty(model.schema, path);
+  if (!prop2 || prop2.type === "array" === repeats) return model;
+  const outer = repeats ? prop2 : prop2.items ?? {};
+  const own = pick(prop2, SECTION_OWN);
+  const { type: _, ...body } = Object.fromEntries(
+    Object.entries(outer).filter(([k]) => !SECTION_OWN.includes(k))
+  );
+  const next = repeats ? { type: "array", ...own, items: { type: "object", ...body } } : { ...own, type: "object", ...body };
+  return replaceProperty(model, path, next);
+}
+function setLimit(model, path, keyword, value) {
+  return updateProperty(model, path, {
+    [keyword]: value === "" || value === null ? void 0 : value
+  });
+}
+function setQuestionnaireText(model, text) {
+  const schema = { ...model.schema };
+  if (text.title !== void 0) schema.title = text.title;
+  if (text.description !== void 0) {
+    if (text.description) schema.description = text.description;
+    else delete schema.description;
+  }
+  return { schema, uiSchema: model.uiSchema };
+}
+function sectionPathOf(path) {
+  return locate(path).containerPath;
+}
+function locate(path) {
+  const key = path[path.length - 1].key;
+  const c = path[path.length - 3];
+  if (path.length >= 3 && c?.kind === "condition" && c.combinator === "allOf") {
+    return { containerPath: path.slice(0, -3), member: c.index, key };
+  }
+  return { containerPath: path.slice(0, -1), key };
+}
+function containerAt(schema, path) {
+  if (path.length === 0) return schema;
+  const owner = getProperty(schema, path);
+  return owner?.type === "array" ? owner.items : owner;
+}
+function withoutKey(obj, list2, key) {
+  const values = obj[list2]?.filter((k) => k !== key);
+  if (values?.length) obj[list2] = values;
+  else delete obj[list2];
+}
+function dropEmptyMember(container, index) {
+  const member = container.allOf?.[index];
+  if (!member || Object.keys(member.then?.properties ?? {}).length > 0) return;
+  container.allOf.splice(index, 1);
+  if (container.allOf.length === 0) delete container.allOf;
+}
+function setShowIf(model, path, showIf) {
+  const schema = structuredClone(model.schema);
+  const { containerPath, member, key } = locate(path);
+  const container = containerAt(schema, containerPath);
+  const item = getProperty(schema, path);
+  if (!container || !item) return { model, path };
+  if (rewriteOwnCondition(container, member, showIf)) {
+    return { model: { schema, uiSchema: model.uiSchema }, path };
+  }
+  container["x-ui-order"] = containerOrder(container);
+  const required = takeOut(container, member, key);
+  if (required === null) return { model, path };
+  const next = { schema, uiSchema: model.uiSchema };
+  if (!showIf || showIf.conditions.length === 0) {
+    container.properties = { ...container.properties ?? {}, [key]: item };
+    if (required) container.required = [...container.required ?? [], key];
+    return { model: next, path: [...containerPath, prop(key)] };
+  }
+  const index = putConditional(container, key, item, required, showIf);
+  return {
+    model: next,
+    path: [
+      ...containerPath,
+      condition(index, "allOf"),
+      slot("then"),
+      prop(key)
+    ]
+  };
+}
+function rewriteOwnCondition(container, member, showIf) {
+  const own = member === void 0 ? void 0 : container.allOf?.[member];
+  if (!own || !showIf?.conditions.length || Object.keys(own.then?.properties ?? {}).length !== 1)
+    return false;
+  own.if = showIfToIf(showIf, (field) => containerFields(container)[field]);
+  return true;
+}
+function takeOut(container, member, key) {
+  const holder = member === void 0 ? container : container.allOf?.[member]?.then;
+  if (!holder?.properties?.[key]) return null;
+  const required = holder.required?.includes(key) ?? false;
+  delete holder.properties[key];
+  withoutKey(holder, "required", key);
+  if (member !== void 0) dropEmptyMember(container, member);
+  return required;
+}
+function putConditional(container, key, item, required, showIf) {
+  const typeOf = (field) => containerFields(container)[field];
+  const conditional = {
+    if: showIfToIf(showIf, typeOf),
+    then: {
+      properties: { [key]: item },
+      ...required ? { required: [key] } : {}
+    }
+  };
+  container.allOf = [...container.allOf ?? [], conditional];
+  return container.allOf.length - 1;
+}
+function moveItem(model, path, direction) {
+  const schema = structuredClone(model.schema);
+  const { containerPath, key } = locate(path);
+  const container = containerAt(schema, containerPath);
+  if (!container) return model;
+  const order = containerOrder(container);
+  const i = order.indexOf(key);
+  const j = i + direction;
+  if (i < 0 || j < 0 || j >= order.length) return model;
+  [order[i], order[j]] = [order[j], order[i]];
+  container["x-ui-order"] = order;
+  return { schema, uiSchema: model.uiSchema };
+}
+function reorderItem(model, path, beforeKey) {
+  const schema = structuredClone(model.schema);
+  const { containerPath, key } = locate(path);
+  const container = containerAt(schema, containerPath);
+  if (!container || key === beforeKey) return model;
+  const order = containerOrder(container).filter((k) => k !== key);
+  const at = beforeKey === null ? order.length : order.indexOf(beforeKey);
+  if (at < 0) return model;
+  order.splice(at, 0, key);
+  container["x-ui-order"] = order;
+  return { schema, uiSchema: model.uiSchema };
+}
+function deleteItem(model, path) {
+  const deleted = deleteProperty(model, path);
+  if (deleted === model) return model;
+  const { containerPath, member, key } = locate(path);
+  const container = containerAt(deleted.schema, containerPath);
+  if (!container) return deleted;
+  withoutKey(container, "x-ui-order", key);
+  if (member !== void 0) dropEmptyMember(container, member);
+  else removeUnlessReason(container, key);
+  return deleted;
+}
+function renameInConditions(container, prev, next) {
+  const renameIn = (ifSchema) => {
+    if (!ifSchema) return;
+    if (ifSchema.properties && prev in ifSchema.properties) {
+      ifSchema.properties = Object.fromEntries(
+        Object.entries(ifSchema.properties).map(([k, v]) => [
+          k === prev ? next : k,
+          v
+        ])
+      );
+    }
+    if (ifSchema.required)
+      ifSchema.required = ifSchema.required.map((k) => k === prev ? next : k);
+    ifSchema.anyOf?.forEach(renameIn);
+  };
+  container.allOf?.forEach((m) => renameIn(m.if));
+}
+function setItemsOptions(model, path, options, choices) {
+  const prop2 = getProperty(model.schema, path);
+  const items = {
+    ...prop2?.items ?? { type: "string" },
+    enum: options.map((o) => o.value)
+  };
+  const withValues = updateProperty(model, path, { items });
+  const labels = Object.fromEntries(
+    choices.filter((c) => c.label).map((c) => [c.value, c.label])
+  );
+  const current = getUiEntryAtPath(withValues.uiSchema, path)?.["x-ui-options"] ?? {};
+  const { enumNames: _, ...rest } = current;
+  const next = Object.keys(labels).length ? { ...rest, enumNames: labels } : rest;
+  return setHint(
+    withValues,
+    path,
+    "x-ui-options",
+    Object.keys(next).length ? next : void 0
+  );
+}
+function setValueTypeSettings(model, path, answer, values) {
+  if (!answer.settings) return model;
+  const written = answer.settings.write(values);
+  const withProp = updateProperty(model, path, written.prop);
+  const current = getUiEntryAtPath(withProp.uiSchema, path)?.["x-ui-options"] ?? {};
+  const next = { ...current };
+  for (const [k, v] of Object.entries(written.options)) {
+    if (v === void 0) delete next[k];
+    else next[k] = v;
+  }
+  return setHint(
+    withProp,
+    path,
+    "x-ui-options",
+    Object.keys(next).length ? next : void 0
+  );
+}
+var OTHER_OPTION = { value: "other", label: "Other" };
+function setChoiceTextWhen(model, path, when) {
+  const prop2 = getProperty(model.schema, path);
+  const { choice, text } = prop2 ? rawChoiceAndText(prop2) : {};
+  if (!prop2 || !choice || !text) return model;
+  if (when === null) {
+    return updateProperty(model, path, {
+      properties: { choice, text },
+      allOf: void 0
+    });
+  }
+  const { model: withOption, value } = withAskingOption(
+    model,
+    path,
+    prop2,
+    when
+  );
+  const nextChoice = getProperty(withOption.schema, [
+    ...path,
+    prop("choice")
+  ]);
+  return updateProperty(withOption, path, {
+    properties: { choice: nextChoice },
+    allOf: [otherTextMember(value, text)]
+  });
+}
+function withAskingOption(model, path, prop2, when) {
+  const options = optionsOf(prop2, hintsAt(model, path), "choiceWithText") ?? [];
+  if (options.some((o) => o.value === when)) return { model, value: when };
+  if (options.some((o) => o.value === OTHER_OPTION.value))
+    return { model, value: OTHER_OPTION.value };
+  return {
+    model: setOptions(model, path, [...options, OTHER_OPTION]),
+    value: OTHER_OPTION.value
+  };
+}
+function declaredReasons(model) {
+  return readReasons(model.schema.properties?.[ABSENT_KEY]);
+}
+function removeUnlessReason(container, key) {
+  const index = (container.allOf ?? []).findIndex(
+    (m) => unlessReasonKey(m) === key
+  );
+  if (index < 0) return false;
+  container.allOf.splice(index, 1);
+  if (container.allOf.length === 0) delete container.allOf;
+  return true;
+}
+function setQuestionRequired(model, path, required) {
+  const { containerPath, member, key } = locate(path);
+  if (member !== void 0 || !declaredReasons(model))
+    return setRequired(model, path, required);
+  const schema = structuredClone(model.schema);
+  const container = containerAt(schema, containerPath);
+  if (!container) return model;
+  removeUnlessReason(container, key);
+  withoutKey(container, "required", key);
+  if (required)
+    container.allOf = [...container.allOf ?? [], unlessReasonMember(key)];
+  return { schema, uiSchema: model.uiSchema };
+}
+function sectionPaths(items) {
+  return itemsOf(items).filter((i) => i.kind === "section").map((i) => i.path);
+}
+function withReasons(container, reasons) {
+  container["x-ui-order"] = containerOrder(container);
+  container.properties = {
+    ...container.properties ?? {},
+    [ABSENT_KEY]: absentProperty(reasons)
+  };
+  const required = (container.required ?? []).filter((k) => k !== ABSENT_KEY);
+  delete container.required;
+  for (const key of required) {
+    if (!(container.allOf ?? []).some((m) => unlessReasonKey(m) === key)) {
+      container.allOf = [...container.allOf ?? [], unlessReasonMember(key)];
+    }
+  }
+}
+function withoutReasons(container) {
+  if (container.properties) delete container.properties[ABSENT_KEY];
+  const keys = (container.allOf ?? []).map(unlessReasonKey).filter((k) => k !== void 0);
+  for (const key of keys) removeUnlessReason(container, key);
+  if (keys.length)
+    container.required = [...container.required ?? [], ...keys];
+}
+function setReasons(model, reasons) {
+  const paths = [
+    [],
+    ...sectionPaths(classifyQuestionnaire(model).items)
+  ];
+  const schema = structuredClone(model.schema);
+  for (const path of paths) {
+    const container = containerAt(schema, path);
+    if (!container) continue;
+    if (reasons?.length) withReasons(container, reasons);
+    else withoutReasons(container);
+  }
+  return { schema, uiSchema: model.uiSchema };
+}
+
+// src/questionnaire/completion.ts
+var COMPARE = {
+  "=": (a, v) => String(a) === v,
+  "!=": (a, v) => String(a) !== v,
+  ">": (a, v) => Number(a) > Number(v),
+  ">=": (a, v) => Number(a) >= Number(v),
+  "<": (a, v) => Number(a) < Number(v),
+  "<=": (a, v) => Number(a) <= Number(v)
+};
+function holds(c, answers) {
+  const value = answers[c.field];
+  if (c.operator === "exists")
+    return value !== void 0 && value !== null && value !== "";
+  return value !== void 0 && value !== null && COMPARE[c.operator](value, c.value);
+}
+function isAsked(showIf, answers) {
+  if (!showIf || showIf.conditions.length === 0) return true;
+  const results = showIf.conditions.map((c) => holds(c, answers));
+  return showIf.behavior === "any" ? results.some(Boolean) : results.every(Boolean);
+}
+function missingIn(items, answers, prefix) {
+  return items.flatMap((item) => {
+    if (item.kind === "text" || item.kind === "locked" || !isAsked(item.showIf, answers))
+      return [];
+    const at = prefix + item.key;
+    if (item.kind === "question")
+      return answeredOrExcused(answers, item.key) ? [] : [at];
+    const value = answers[item.key];
+    if (!item.repeats)
+      return missingIn(
+        item.items,
+        value ?? {},
+        `${at}.`
+      );
+    const entries = Array.isArray(value) ? value : [];
+    return entries.flatMap(
+      (entry, i) => missingIn(item.items, entry ?? {}, `${at}.${i}.`)
+    );
+  });
+}
+function isComplete(view, answers) {
+  const missing = missingIn(view.items, answers, "");
+  return { complete: missing.length === 0, missing };
+}
+
+// src/questionnaire/capabilities.ts
+import { z } from "zod";
+import { warnLog } from "@petrarca/sonnet-core/logger";
+var BUILTIN_ANSWER_TYPES = Object.keys(ANSWER_TYPE_LABELS);
+var questionnaireCapabilitiesSchema = z.object({
+  answerTypes: z.array(z.string()).optional().meta({
+    description: "The answer types offered for a new or changed question, in order -- the built-in ones by name, a value type by its id. Default: all."
+  }),
+  sections: z.boolean().default(true).meta({ description: "Whether sections may be added." }),
+  logic: z.boolean().default(true).meta({ description: 'Whether "show only if" is offered.' }),
+  reasons: z.boolean().default(true).meta({
+    description: "Whether reasons for no answer may be declared."
+  }),
+  switchToDesigner: z.boolean().default(true).meta({
+    description: "Whether the way to the schema designer is shown (when the application offers one)."
+  }),
+  previews: z.array(z.enum(["form", "json", "capabilities"])).default(["form", "json"]).meta({
+    description: 'The tabs of the centre pane, in order: the form, its JSON, and the profile itself ("capabilities", edited live).'
+  })
+}).meta({
+  id: "QuestionnaireDesignerCapabilities",
+  title: "QuestionnaireDesignerCapabilities",
+  description: "What a questionnaire author may build. Every field optional, defaulting to the most permissive value."
+});
+function validateQuestionnaireCapabilities(input) {
+  const parsed = questionnaireCapabilitiesSchema.safeParse(input);
+  if (parsed.success)
+    return { ok: true, value: input };
+  return {
+    ok: false,
+    errors: parsed.error.issues.map(
+      (i) => `${i.path.length ? i.path.join(".") : "(root)"}: ${i.message}`
+    )
+  };
+}
+function resolveQuestionnaireCapabilities(capabilities, valueTypes = DEFAULT_VALUE_TYPES) {
+  const parsed = questionnaireCapabilitiesSchema.safeParse(capabilities ?? {});
+  if (!parsed.success) {
+    warnLog(
+      "[QuestionnaireDesigner] Invalid capabilities -- falling back to defaults.",
+      parsed.error.issues
+    );
+  }
+  const value = parsed.success ? parsed.data : questionnaireCapabilitiesSchema.parse({});
+  const all = [...BUILTIN_ANSWER_TYPES, ...valueTypes.map((t) => t.type.id)];
+  return { ...value, answerTypes: knownAnswerTypes(value.answerTypes, all) };
+}
+function knownAnswerTypes(named, all) {
+  const known = (named ?? []).filter((t) => all.includes(t));
+  const unknown = (named ?? []).filter((t) => !all.includes(t));
+  if (unknown.length)
+    warnLog(
+      "[QuestionnaireDesigner] Unknown answer types in the profile -- ignored.",
+      unknown
+    );
+  return known.length ? known : all;
+}
+
+export {
+  isReservedKey,
+  prop,
+  branch,
+  condition,
+  slot,
+  def,
+  pathKey,
+  parsePathKey,
+  sameSegment,
+  samePath,
+  childContainer,
+  definitionsOf,
+  childSlots,
+  schemaAsRootProp,
+  getProperty,
+  isContainer,
+  propertyKind,
+  orderedKeys,
+  buildPropertyTree,
+  layoutScopes,
+  newProperty,
+  newBranch,
+  addProperty,
+  addBranch,
+  removeBranch,
+  moveBranch,
+  newCondition,
+  addConditional,
+  removeConditional,
+  setCondition,
+  addElse,
+  removeElse,
+  setConditionalBehavior,
+  deleteProperty,
+  renameProperty,
+  moveProperty,
+  setRequired,
+  updateProperty,
+  changePropertyType,
+  setReference,
+  addDefinition,
+  renameDefinition,
+  removeDefinition,
+  definitionUsageCount,
+  setEnum,
+  readEnumChoices,
+  setTableHints,
+  readTableHints,
+  getUiEntryAtPath,
+  setUiEntry,
+  setPropertyLayout,
+  setRootLayout,
+  setRootLayoutRows,
+  setScopedLayoutRows,
+  getScopedLayout,
+  setScopedLayoutOptions,
+  setScopedLayoutGroups,
+  addLayoutGroup,
+  renameLayoutGroup,
+  placeFieldInGroup,
+  moveLayoutGroup,
+  setLayoutGroupRule,
+  setScopedLayoutVariant,
+  removeLayoutGroup,
+  setScopedGroupRows,
+  setScopedLayoutMode,
+  setGlobalOptions,
+  CONDITION_OPERATORS,
+  CONDITION_OPERATOR_LABELS,
+  OPERATOR_OPTIONS,
+  operatorToConstraint,
+  conditionToIf,
+  constraintToOperator,
+  ifToCondition,
+  ANSWER_TYPE_LIMITS,
+  LIMIT_LABELS,
+  limitsFor,
+  limitsOf,
+  OPTIONS_LIST_WIDGET,
+  SHOW_IF_WIDGET,
+  QUANTITY_ANSWER,
+  codingBindingOf,
+  CODING_ANSWER,
+  CODEABLE_CONCEPT_ANSWER,
+  DEFAULT_VALUE_TYPES,
+  valueTypeOf,
+  valueTypeAnswer,
+  ANSWER_TYPE_LABELS,
+  isBuiltinAnswerType,
+  answerTypeLabel,
+  CHOICE_WITH_TEXT_WIDGET,
+  isContainerType,
+  choiceTextWhen,
+  otherTextMember,
+  rawChoiceAndText,
+  recognizeAnswerType,
+  embeddedHints,
+  answerTypeFragment,
+  showIfToIf,
+  readConditional,
+  ABSENT_KEY,
+  ABSENT_WIDGET,
+  absentProperty,
+  readReasons,
+  unlessReasonMember,
+  unlessReasonKey,
+  answeredOrExcused,
+  optionsOf,
+  containerFields,
+  containerOrder,
+  itemsOf,
+  classifyQuestionnaire,
+  keyFromText,
+  isValidKey,
+  addItem,
+  setItemText,
+  setHelp,
+  setReadOnly,
+  setPresentation,
+  setDefaultAnswer,
+  setPlaceholder,
+  setKey,
+  setOptions,
+  changeAnswerType,
+  setKeywords,
+  setSectionRepeats,
+  setLimit,
+  setQuestionnaireText,
+  sectionPathOf,
+  setShowIf,
+  moveItem,
+  reorderItem,
+  deleteItem,
+  setValueTypeSettings,
+  OTHER_OPTION,
+  setChoiceTextWhen,
+  declaredReasons,
+  setQuestionRequired,
+  setReasons,
+  isAsked,
+  isComplete,
+  questionnaireCapabilitiesSchema,
+  validateQuestionnaireCapabilities,
+  resolveQuestionnaireCapabilities
+};
+//# sourceMappingURL=chunk-MVPNMAVL.js.map