@kubohiroya/turbowarp-extension-data-editor 0.2.2 → 0.3.1

package/dist/webpack4/rjsf.js

@@ -4917,7 +4917,7 @@ var require_react_is_development = __commonJS({
         var ContextProvider = REACT_PROVIDER_TYPE;
         var Element = REACT_ELEMENT_TYPE;
         var ForwardRef = REACT_FORWARD_REF_TYPE;
-        var Fragment4 = REACT_FRAGMENT_TYPE;
+        var Fragment5 = REACT_FRAGMENT_TYPE;
         var Lazy = REACT_LAZY_TYPE;
         var Memo = REACT_MEMO_TYPE;
         var Portal = REACT_PORTAL_TYPE;
@@ -4985,7 +4985,7 @@ var require_react_is_development = __commonJS({
         exports2.ContextProvider = ContextProvider;
         exports2.Element = Element;
         exports2.ForwardRef = ForwardRef;
-        exports2.Fragment = Fragment4;
+        exports2.Fragment = Fragment5;
         exports2.Lazy = Lazy;
         exports2.Memo = Memo;
         exports2.Portal = Portal;
@@ -5027,7 +5027,317 @@ var require_react_is = __commonJS({
 });
 
 // dist/rjsf.js
-import * as React4 from "react";
+import * as React6 from "react";
+
+// dist/config/feature-flags.js
+function captureFeatureFlags(options = {}) {
+  if (options.commonLayout !== void 0 && typeof options.commonLayout !== "boolean") {
+    throw new TypeError("Invalid common layout feature flag.");
+  }
+  return Object.freeze({ commonLayout: options.commonLayout === true });
+}
+
+// dist/layout-view.js
+import * as React2 from "react";
+
+// dist/form-presentation.js
+import * as React from "react";
+function propertyLabel(key) {
+  if (/^[a-z]{1,3}$/.test(key))
+    return key;
+  const text = key.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b(id|uri|url|json)\b/gi, (word) => word.toUpperCase());
+  return text ? text[0].toUpperCase() + text.slice(1) : "\u8A2D\u5B9A";
+}
+function FormHelp({ description, id }) {
+  if (typeof description !== "string" || !description.trim())
+    return null;
+  return description.length > 130 ? React.createElement(
+    "details",
+    { className: "editor-form-help", id },
+    React.createElement("summary", null, "\u8AAC\u660E\u3092\u8868\u793A"),
+    React.createElement("p", null, description)
+  ) : React.createElement("p", { className: "editor-form-hint", id }, description);
+}
+var formStyles = `
+[data-editor-form]{--editor-accent:var(--block-editor-accent,#426ad6);--editor-line:var(--block-editor-border,#dde3ed);--editor-muted:var(--block-editor-muted,var(--block-editor-text,#637086));color:var(--block-editor-text,#25334a);font:14px/1.5 system-ui,sans-serif;min-width:0}
+[data-editor-form] *,[data-editor-form] *:before,[data-editor-form] *:after{box-sizing:border-box}
+[data-editor-form] fieldset{min-width:0}
+[data-editor-form] fieldset.editor-form-binding,[data-editor-form] .editor-form-section,[data-editor-form] .rjsf fieldset{padding:0;border:0;margin:0 0 18px}
+[data-editor-form] .editor-form-section>legend,[data-editor-form] .rjsf fieldset>legend{font-size:15px;font-weight:650;padding:0;margin:0 0 10px;color:inherit}
+[data-editor-form] .editor-form-field,[data-editor-form] .rjsf .form-group{margin:0 0 14px;min-width:0}
+[data-editor-form] .editor-form-field>label,[data-editor-form] .rjsf .control-label{display:block;font-size:13px;font-weight:600;margin:0 0 6px;color:inherit}
+[data-editor-form] .required{color:var(--editor-accent);margin-left:3px}
+[data-editor-form] input:not([type=checkbox]):not([type=radio]),[data-editor-form] select,[data-editor-form] textarea{display:block;width:100%;min-height:38px;margin:0;padding:8px 11px;border:1px solid var(--editor-line);border-radius:7px;background:var(--block-editor-input,white);color:inherit;font:inherit;box-shadow:0 1px 2px #172b4d05}
+[data-editor-form] textarea{min-height:76px;resize:vertical}
+[data-editor-form] input:focus-visible,[data-editor-form] select:focus-visible,[data-editor-form] textarea:focus-visible,[data-editor-form] button:focus-visible,[data-editor-form] summary:focus-visible{outline:2px solid var(--editor-accent);outline-offset:2px}
+[data-editor-form] input[readonly]{background:var(--block-editor-subtle,var(--block-editor-background,#f5f7fb));color:var(--editor-muted)}
+[data-editor-form] input[type=checkbox]{width:17px;height:17px;margin:0;accent-color:var(--editor-accent)}
+[data-editor-form] .editor-form-field>label.editor-form-toggle,[data-editor-form] .rjsf .checkbox>label{display:flex;align-items:center;gap:8px;font-weight:500;margin:8px 0}
+[data-editor-form] button{font:inherit;cursor:pointer;border:1px solid var(--editor-line);border-radius:6px;background:var(--block-editor-input,white);color:inherit;padding:6px 10px;margin:0}
+[data-editor-form] button:disabled{cursor:default;opacity:.5}
+[data-editor-form] .editor-form-hint,[data-editor-form] .editor-form-help{color:var(--editor-muted);font-size:12px;line-height:1.5;margin:5px 0 10px}
+[data-editor-form] .editor-form-help>summary{display:list-item;list-style:disclosure-closed inside;cursor:pointer;width:fit-content;font-weight:500}
+[data-editor-form] .editor-form-help[open]>summary{list-style-type:disclosure-open}
+[data-editor-form] .editor-form-help p{margin:8px 0}
+[data-editor-form] .block-editor-layout-tabs>[role=tablist]{display:flex;gap:4px;flex-wrap:wrap;padding:5px;background:var(--block-editor-subtle,var(--block-editor-background,#f1f4f9));border:1px solid var(--editor-line);border-radius:9px;margin:4px 0 20px}
+[data-editor-form] .block-editor-layout-tabs>[role=tablist]>button{border:0;border-radius:6px;background:transparent;color:var(--editor-muted);padding:8px 18px;margin:0;font-weight:550;text-decoration:none;min-width:76px}
+[data-editor-form] .block-editor-layout-tabs>[role=tablist]>[aria-selected=true]{background:var(--block-editor-input,white);color:var(--editor-accent);box-shadow:0 1px 4px #1d30431a}
+[data-editor-form] .editor-form-error-badge{display:inline-flex;align-items:center;justify-content:center;min-width:18px;margin-left:7px;padding:0 5px;border-radius:10px;background:#fff0f0;color:#b53d45;font-size:11px}
+[data-editor-form] fieldset.block-editor-layout-group{border:1px solid var(--editor-line);border-radius:10px;padding:16px 18px 4px;margin:0 0 18px;background:var(--block-editor-background,white)}
+[data-editor-form] fieldset.block-editor-layout-group>legend{padding:0 6px;font-size:13px;font-weight:650}
+[data-editor-form] .block-editor-layout-grid{display:grid;gap:0 18px;grid-template-columns:repeat(var(--editor-columns),minmax(0,1fr));align-items:start}
+[data-editor-form] .block-editor-layout-grid>*{min-width:0}
+[data-editor-form] .block-editor-layout-tabs>[hidden]{display:none!important}
+[data-editor-form] .editor-form-toolbar{display:flex;align-items:start;justify-content:space-between;gap:12px;margin:0 0 18px;padding-bottom:14px;border-bottom:1px solid var(--editor-line)}
+[data-editor-form] .editor-form-modes{display:flex;gap:3px;border:1px solid var(--editor-line);border-radius:8px;padding:3px;background:var(--block-editor-subtle,var(--block-editor-background,#f1f4f9))}
+[data-editor-form] .editor-form-modes>button{border:0;border-radius:5px;padding:5px 14px;background:transparent;color:var(--editor-muted);margin:0}
+[data-editor-form] .editor-form-modes>[aria-pressed=true]{background:var(--block-editor-input,white);color:var(--editor-accent);box-shadow:0 1px 3px #1d30431a}
+[data-editor-form] .editor-form-tools{font-size:12px;color:var(--editor-muted);margin:0 0 12px}
+[data-editor-form] .editor-form-tools>summary{cursor:pointer;padding:5px 0;list-style-position:inside}
+[data-editor-form] .editor-form-tools[open]{padding:10px 12px;border:1px solid var(--editor-line);border-radius:8px;background:var(--block-editor-subtle,var(--block-editor-background,#f7f9fc))}
+[data-editor-form] .editor-form-tools button{border:1px solid var(--editor-line);border-radius:6px;background:var(--block-editor-input,white);padding:5px 9px;margin:5px 5px 5px 0;color:inherit}
+[data-editor-form] .editor-form-tools label{display:flex;align-items:center;justify-content:space-between;gap:10px;margin:5px 0}
+[data-editor-form] .editor-form-invalid{font-size:12px;color:#b53d45;margin:5px 0}
+[data-editor-form] [data-source-error=true]>input,[data-editor-form] [data-source-error=true]>textarea{border-color:#b53d45}
+[data-editor-form] .editor-form-array-item{display:flex;align-items:start;gap:10px}
+[data-editor-form] .editor-form-array-item>.editor-form-field{flex:1;min-width:0}
+@media(max-width:600px){[data-editor-form] .block-editor-layout-grid{grid-template-columns:minmax(0,1fr)}[data-editor-form] fieldset.block-editor-layout-group{padding:12px 12px 0}[data-editor-form] .block-editor-layout-tabs>[role=tablist]>button{padding:7px 12px;min-width:60px}[data-editor-form] .editor-form-toolbar{flex-wrap:wrap}}
+`;
+
+// dist/layout.js
+var record = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+function resolveEditorLayout(ui, knownFields) {
+  if (!record(ui) || !record(ui["ui:options"]) || !Object.hasOwn(ui["ui:options"], "extensionDataLayout"))
+    return { kind: "absent" };
+  const input = ui["ui:options"].extensionDataLayout;
+  const known = new Set(knownFields), fields2 = /* @__PURE__ */ new Set();
+  let count = 0;
+  const fail2 = (message) => {
+    throw new TypeError(message);
+  };
+  const keys2 = (node, expected) => {
+    if (Object.keys(node).some((key) => !expected.includes(key)))
+      fail2("Unknown layout option.");
+  };
+  const label = (text) => typeof text === "string" && text.trim().length > 0 && text.length <= 128 ? text : fail2("Invalid layout label.");
+  const items = (value, depth) => {
+    if (depth > 8 || !Array.isArray(value) || value.length > 256)
+      return fail2("Layout limit exceeded.");
+    return value.map((node) => {
+      if (++count > 256 || !record(node))
+        return fail2("Invalid layout item or limit exceeded.");
+      if (Object.hasOwn(node, "field")) {
+        keys2(node, ["field"]);
+        if (typeof node.field !== "string" || !known.has(node.field))
+          return fail2("Unknown layout field.");
+        if (fields2.has(node.field))
+          return fail2("Duplicate layout field.");
+        fields2.add(node.field);
+        return { field: node.field };
+      }
+      if (Object.hasOwn(node, "group")) {
+        keys2(node, ["group", "items"]);
+        return { group: label(node.group), items: items(node.items, depth + 1) };
+      }
+      if (Object.hasOwn(node, "grid")) {
+        keys2(node, ["grid", "items"]);
+        if (typeof node.grid !== "number" || !Number.isInteger(node.grid) || node.grid < 1 || node.grid > 4)
+          return fail2("Grid columns must be 1\u20134.");
+        return { grid: node.grid, items: items(node.items, depth + 1) };
+      }
+      if (Object.hasOwn(node, "tabs")) {
+        keys2(node, ["tabs"]);
+        if (!Array.isArray(node.tabs) || !node.tabs.length || node.tabs.length > 16)
+          return fail2("Invalid tab count.");
+        return { tabs: node.tabs.map((tab) => {
+          if (++count > 256 || !record(tab))
+            return fail2("Invalid tab or limit exceeded.");
+          keys2(tab, ["label", "items"]);
+          return { label: label(tab.label), items: items(tab.items, depth + 1) };
+        }) };
+      }
+      return fail2("Unknown layout item.");
+    });
+  };
+  try {
+    if (!record(input) || input.version !== 1)
+      return fail2("Unsupported layout version.");
+    keys2(input, ["version", "items"]);
+    return { kind: "layout", items: items(input.items, 0), fields: fields2 };
+  } catch (error) {
+    return { kind: "invalid", diagnostic: error instanceof Error ? error.message : "Invalid layout." };
+  }
+}
+
+// dist/layout-view.js
+var Environment = React2.createContext({ enabled: false, reveal: 0, disabled: false });
+var useCommonLayout = () => React2.useContext(Environment).enabled;
+var nextId = 0;
+function LayoutHost({ enabled, context, children }) {
+  const [reveal, setReveal] = React2.useState(0);
+  const [status, setStatus] = React2.useState(context.getState().status);
+  const root2 = React2.useRef(null);
+  React2.useLayoutEffect(() => {
+    let saving = context.getState().status === "saving";
+    let active = true;
+    const stop = context.subscribe(() => {
+      const state = context.getState();
+      const failed = saving && state.status === "editing" && state.issues.length > 0;
+      saving = state.status === "saving";
+      setStatus(state.status);
+      if (failed)
+        void Promise.resolve().then(() => {
+          if (active)
+            setReveal((n2) => n2 + 1);
+        });
+    });
+    return () => {
+      active = false;
+      stop();
+    };
+  }, [context]);
+  React2.useEffect(() => {
+    if (!enabled || !reveal)
+      return;
+    const timer = setTimeout(() => {
+      var _a, _b, _c;
+      const controls = (_a = root2.current) === null || _a === void 0 ? void 0 : _a.querySelectorAll('[data-layout-error="true"] input, [data-layout-error="true"] textarea, [data-layout-error="true"] select');
+      const candidates = Array.from(controls !== null && controls !== void 0 ? controls : []).filter((control) => !control.closest("[hidden]") && !control.matches(":disabled") && !control.hasAttribute("data-source-type-control"));
+      const target = (_c = (_b = candidates.find((control) => {
+        var _a2;
+        return ((_a2 = control.closest("[data-source-path]")) === null || _a2 === void 0 ? void 0 : _a2.getAttribute("data-source-error")) === "true";
+      })) !== null && _b !== void 0 ? _b : candidates.find((control) => {
+        var _a2;
+        return (_a2 = control.closest(".form-group")) === null || _a2 === void 0 ? void 0 : _a2.classList.contains("has-error");
+      })) !== null && _c !== void 0 ? _c : candidates.find((control) => {
+        var _a2;
+        return ((_a2 = control.closest("[data-layout-field]")) === null || _a2 === void 0 ? void 0 : _a2.getAttribute("data-layout-error")) === "true";
+      });
+      target === null || target === void 0 ? void 0 : target.focus();
+    }, 0);
+    return () => clearTimeout(timer);
+  }, [enabled, reveal]);
+  return React2.createElement(Environment.Provider, { value: { enabled, reveal, disabled: status !== "editing" } }, enabled ? React2.createElement(
+    "div",
+    { ref: root2, "data-editor-form": "" },
+    React2.createElement("style", null, formStyles),
+    children
+  ) : children);
+}
+function names(items) {
+  return items.flatMap((item) => "field" in item ? [item.field] : "tabs" in item ? item.tabs.flatMap((tab) => names(tab.items)) : names(item.items));
+}
+function Items({ items, fields: fields2 }) {
+  return React2.createElement(React2.Fragment, null, items.map((item, index) => {
+    if ("field" in item) {
+      const field = fields2.get(item.field);
+      return field ? React2.createElement("div", { key: index, "data-layout-field": item.field, "data-layout-error": !!field.errors }, field.content) : null;
+    }
+    if ("tabs" in item)
+      return React2.createElement(Tabs, { key: index, tabs: item.tabs, fields: fields2 });
+    if ("group" in item)
+      return React2.createElement(
+        "fieldset",
+        { className: "block-editor-layout-group", key: index },
+        React2.createElement("legend", null, item.group),
+        React2.createElement(Items, { items: item.items, fields: fields2 })
+      );
+    return React2.createElement(
+      "div",
+      { key: index, className: "block-editor-layout-grid", style: { "--editor-columns": item.grid } },
+      React2.createElement(Items, { items: item.items, fields: fields2 })
+    );
+  }));
+}
+function Tabs({ tabs, fields: fields2 }) {
+  const { reveal, disabled } = React2.useContext(Environment);
+  const [selected, select] = React2.useState(0);
+  const [id] = React2.useState(() => `block-editor-layout-${++nextId}`);
+  const buttons = React2.useRef([]);
+  const counts = tabs.map((tab) => names(tab.items).reduce((total, name) => {
+    var _a, _b;
+    return total + ((_b = (_a = fields2.get(name)) === null || _a === void 0 ? void 0 : _a.errors) !== null && _b !== void 0 ? _b : 0);
+  }, 0));
+  const errors = counts.join(",");
+  const handled = React2.useRef(0);
+  React2.useEffect(() => {
+    if (reveal <= handled.current)
+      return;
+    const first = counts.findIndex((count) => count > 0);
+    if (first >= 0) {
+      handled.current = reveal;
+      select(first);
+    }
+  }, [reveal, errors]);
+  const current = Math.min(selected, tabs.length - 1);
+  return React2.createElement(
+    "div",
+    { className: "block-editor-layout-tabs", "data-layout-errors": errors },
+    React2.createElement("div", { role: "tablist", "aria-label": "\u30D5\u30A9\u30FC\u30E0\u306E\u9805\u76EE" }, tabs.map((tab, index) => React2.createElement(
+      "button",
+      { key: index, ref: (element) => {
+        buttons.current[index] = element;
+      }, type: "button", role: "tab", id: `${id}-tab-${index}`, "aria-controls": `${id}-panel-${index}`, "aria-selected": current === index, disabled, tabIndex: current === index ? 0 : -1, onClick: () => select(index), onKeyDown: (event) => {
+        var _a;
+        if (event.nativeEvent.isComposing || event.keyCode === 229)
+          return;
+        let target;
+        switch (event.key) {
+          case "ArrowRight":
+            target = (index + 1) % tabs.length;
+            break;
+          case "ArrowLeft":
+            target = (index + tabs.length - 1) % tabs.length;
+            break;
+          case "Home":
+            target = 0;
+            break;
+          case "End":
+            target = tabs.length - 1;
+            break;
+          default:
+            return;
+        }
+        event.preventDefault();
+        event.stopPropagation();
+        select(target);
+        (_a = buttons.current[target]) === null || _a === void 0 ? void 0 : _a.focus();
+      } },
+      tab.label,
+      counts[index] ? React2.createElement("span", { className: "editor-form-error-badge", "aria-label": `\u30A8\u30E9\u30FC ${counts[index]} \u4EF6` }, counts[index]) : null
+    ))),
+    tabs.map((tab, index) => React2.createElement(
+      "div",
+      { key: index, role: "tabpanel", id: `${id}-panel-${index}`, "aria-labelledby": `${id}-tab-${index}`, hidden: current !== index },
+      React2.createElement(Items, { items: tab.items, fields: fields2 })
+    ))
+  );
+}
+function ObjectLayout({ ui, fields: fields2, knownFields, fallback }) {
+  const { enabled } = React2.useContext(Environment);
+  const resolution = enabled ? resolveEditorLayout(ui, knownFields) : { kind: "absent" };
+  if (resolution.kind === "absent")
+    return React2.createElement(React2.Fragment, null, fallback);
+  if (resolution.kind === "invalid")
+    return React2.createElement(
+      React2.Fragment,
+      null,
+      React2.createElement(
+        "p",
+        { role: "status", "data-layout-diagnostic": "" },
+        "\u30EC\u30A4\u30A2\u30A6\u30C8\u3092\u9069\u7528\u3067\u304D\u307E\u305B\u3093: ",
+        resolution.diagnostic
+      ),
+      fallback
+    );
+  const map2 = new Map(fields2.map((field) => [field.name, field]));
+  return React2.createElement(
+    React2.Fragment,
+    null,
+    React2.createElement(Items, { items: resolution.items, fields: map2 }),
+    fields2.filter((field) => !resolution.fields.has(field.name)).map((field) => React2.createElement("div", { key: field.name, "data-layout-field": field.name, "data-layout-error": !!field.errors }, field.content))
+  );
+}
 
 // node_modules/.pnpm/yaml@2.9.1/node_modules/yaml/browser/dist/nodes/identity.js
 var ALIAS = /* @__PURE__ */ Symbol.for("yaml.alias");
@@ -11403,7 +11713,7 @@ function sameData(left, right) {
 function fail() {
   throw new Error("Source cannot be edited without changing unedited data.");
 }
-function record(value) {
+function record2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function equal(left, right) {
@@ -11412,7 +11722,7 @@ function equal(left, right) {
   if (Array.isArray(left) && Array.isArray(right)) {
     return left.length === right.length && left.every((value, index) => equal(value, right[index]));
   }
-  if (record(left) && record(right)) {
+  if (record2(left) && record2(right)) {
     const keys2 = Object.keys(left);
     return keys2.length === Object.keys(right).length && keys2.every((key) => Object.hasOwn(right, key) && equal(left[key], right[key]));
   }
@@ -11577,7 +11887,7 @@ function patchJson(source, original, edited) {
   const visit3 = (node, before, after) => {
     if (equal(before, after))
       return;
-    if (record(before) && record(after) && node.kind === "object") {
+    if (record2(before) && record2(after) && node.kind === "object") {
       const entries = node.entries;
       const last2 = /* @__PURE__ */ new Map();
       entries.forEach((entry, index) => last2.set(entry.key, index));
@@ -11686,11 +11996,11 @@ function patchYaml(source, original, edited) {
     if (!node || isAlias(node) || "anchor" in node && node.anchor || node.tag)
       fail();
     const [start, end] = yamlRange(node);
-    if (isMap(node) && record(before) && record(after) || isSeq(node) && Array.isArray(before) && Array.isArray(after)) {
+    if (isMap(node) && record2(before) && record2(after) || isSeq(node) && Array.isArray(before) && Array.isArray(after)) {
       const entries = [];
       const items = [];
       const additions = [];
-      if (isMap(node) && record(before) && record(after)) {
+      if (isMap(node) && record2(before) && record2(after)) {
         for (const pair of node.items) {
           if (!isScalar(pair.key) || typeof pair.key.value !== "string")
             fail();
@@ -11818,9 +12128,130 @@ function prepareSourceVariant(variant) {
 }
 
 // dist/source-view.js
-import * as React from "react";
+import * as React3 from "react";
 import * as ReactDOM from "react-dom";
-var record2 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+
+// dist/schema-presentation.js
+var schemaRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var jsonTypes = ["object", "array", "string", "number", "boolean", "null"];
+var valueType = (value) => value === null ? "null" : Array.isArray(value) ? "array" : typeof value;
+function presentationTypes(schema4, reference = () => void 0, seen = /* @__PURE__ */ new Set()) {
+  if (schema4 === false)
+    return /* @__PURE__ */ new Set();
+  if (!schemaRecord(schema4) || seen.has(schema4))
+    return new Set(jsonTypes);
+  const visited = new Set(seen);
+  visited.add(schema4);
+  let types = new Set(jsonTypes);
+  const intersect = (other) => {
+    types = new Set([...types].filter((type) => other.has(type)));
+  };
+  const infer = (child) => presentationTypes(child, reference, visited);
+  if (typeof schema4.$ref === "string")
+    intersect(infer(reference(schema4.$ref)));
+  if (schema4.type !== void 0) {
+    const declared = Array.isArray(schema4.type) ? schema4.type : [schema4.type];
+    intersect(new Set(declared.map((type) => type === "integer" ? "number" : type)));
+  }
+  if (Object.hasOwn(schema4, "const"))
+    intersect(/* @__PURE__ */ new Set([valueType(schema4.const)]));
+  if (Array.isArray(schema4.enum))
+    intersect(new Set(schema4.enum.map(valueType)));
+  if (Array.isArray(schema4.allOf))
+    schema4.allOf.forEach((child) => intersect(infer(child)));
+  for (const keyword of ["anyOf", "oneOf"]) {
+    const children = schema4[keyword];
+    if (Array.isArray(children))
+      intersect(new Set(children.flatMap((child) => [...infer(child)])));
+  }
+  return types;
+}
+function presentationInitial(schema4) {
+  if (schemaRecord(schema4)) {
+    if (Object.hasOwn(schema4, "const"))
+      return schema4.const;
+    if (Array.isArray(schema4.enum) && schema4.enum.length)
+      return schema4.enum[0];
+  }
+  const types = presentationTypes(schema4);
+  if (types.size !== 1)
+    return null;
+  switch ([...types][0]) {
+    case "object":
+      return {};
+    case "array":
+      return [];
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    default:
+      return null;
+  }
+}
+function presentationCondition(schema4, data, reference, seen = /* @__PURE__ */ new Set()) {
+  if (typeof schema4 === "boolean")
+    return schema4;
+  if (!schemaRecord(schema4) || seen.has(schema4))
+    return void 0;
+  const supported = ["type", "const", "enum", "required", "properties", "allOf", "anyOf", "oneOf", "not", "$ref", "$id", "$schema", "title", "description", "$comment"];
+  if (Object.keys(schema4).some((key) => !supported.includes(key)))
+    return void 0;
+  const visited = new Set(seen);
+  visited.add(schema4);
+  const test = (child, value = data) => presentationCondition(child, value, reference, visited);
+  const equal2 = (a2, b2) => {
+    if (a2 === b2)
+      return true;
+    if (Array.isArray(a2) && Array.isArray(b2))
+      return a2.length === b2.length && a2.every((child, index) => equal2(child, b2[index]));
+    return schemaRecord(a2) && schemaRecord(b2) && Object.keys(a2).length === Object.keys(b2).length && Object.keys(a2).every((key) => Object.hasOwn(b2, key) && equal2(a2[key], b2[key]));
+  };
+  const results = [];
+  if (typeof schema4.$ref === "string")
+    results.push(test(reference(schema4.$ref)));
+  if (schema4.type !== void 0) {
+    const types = Array.isArray(schema4.type) ? schema4.type : [schema4.type];
+    results.push(types.some((type) => type === "integer" ? typeof data === "number" && Number.isInteger(data) : type === valueType(data)));
+  }
+  if (Object.hasOwn(schema4, "const"))
+    results.push(equal2(data, schema4.const));
+  if (Array.isArray(schema4.enum))
+    results.push(schema4.enum.some((item) => equal2(data, item)));
+  if (schemaRecord(data)) {
+    if (Array.isArray(schema4.required))
+      results.push(schema4.required.every((key) => typeof key === "string" && Object.hasOwn(data, key)));
+    if (schemaRecord(schema4.properties)) {
+      for (const [key, child] of Object.entries(schema4.properties))
+        if (Object.hasOwn(data, key))
+          results.push(test(child, data[key]));
+    }
+  }
+  if (Array.isArray(schema4.allOf))
+    results.push(...schema4.allOf.map((child) => test(child)));
+  for (const keyword of ["anyOf", "oneOf"]) {
+    const children = schema4[keyword];
+    if (!Array.isArray(children))
+      continue;
+    const states = children.map((child) => test(child));
+    if (keyword === "anyOf")
+      results.push(states.includes(true) ? true : states.includes(void 0) ? void 0 : false);
+    else
+      results.push(states.includes(void 0) ? void 0 : states.filter(Boolean).length === 1);
+  }
+  if (Object.hasOwn(schema4, "not")) {
+    const result = test(schema4.not);
+    results.push(result === void 0 ? void 0 : !result);
+  }
+  return results.includes(false) ? false : results.includes(void 0) ? void 0 : true;
+}
+
+// dist/source-view.js
+var nextFieldId = 0;
+var SourcePaths = React3.createContext([]);
+var record3 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 var pointer = (path, key) => `${path}/${key.replace(/~/g, "~0").replace(/\//g, "~1")}`;
 var typeOf = (v2) => v2 === null ? "null" : Array.isArray(v2) ? "array" : typeof v2;
 var initial = (type) => {
@@ -11841,11 +12272,13 @@ var initial = (type) => {
 };
 function mergeHints(left, right) {
   const result = { ...left, ...right };
+  if (Array.isArray(left.required) && Array.isArray(right.required))
+    result.required = [.../* @__PURE__ */ new Set([...left.required, ...right.required])];
   for (const field of ["properties", "patternProperties"]) {
-    if (!record2(left[field]) && !record2(right[field]))
+    if (!record3(left[field]) && !record3(right[field]))
       continue;
-    const a2 = record2(left[field]) ? left[field] : {};
-    const b2 = record2(right[field]) ? right[field] : {};
+    const a2 = record3(left[field]) ? left[field] : {};
+    const b2 = record3(right[field]) ? right[field] : {};
     const combined = { ...a2 };
     for (const [key, child] of Object.entries(b2))
       Object.defineProperty(combined, key, {
@@ -11861,9 +12294,9 @@ function mergeHints(left, right) {
 }
 function propertyHint(hints, key) {
   const matches = [];
-  if (record2(hints.properties) && Object.hasOwn(hints.properties, key))
+  if (record3(hints.properties) && Object.hasOwn(hints.properties, key))
     matches.push(hints.properties[key]);
-  if (record2(hints.patternProperties))
+  if (record3(hints.patternProperties))
     for (const [pattern, schema4] of Object.entries(hints.patternProperties)) {
       try {
         if (new RegExp(pattern, "u").test(key))
@@ -11873,54 +12306,61 @@ function propertyHint(hints, key) {
     }
   return matches.length > 1 ? { allOf: matches } : matches.length ? matches[0] : hints.additionalProperties;
 }
-function resolveHints(variant, schema4, data, seen = /* @__PURE__ */ new Set()) {
+function sourceReference(variant, ref) {
+  const hash = ref.indexOf("#");
+  const uri2 = hash < 0 ? ref : ref.slice(0, hash);
+  const resources = [variant.schemaBundle.root, ...variant.schemaBundle.resources];
+  const resource = uri2 ? resources.find((r2) => r2.retrievalUri === uri2 || record3(r2.document) && r2.document.$id === uri2) : variant.schemaBundle.root;
+  let target = resource === null || resource === void 0 ? void 0 : resource.document;
+  const fragment = hash < 0 ? "" : decodeURIComponent(ref.slice(hash + 1));
+  if (fragment.startsWith("/"))
+    for (const part of fragment.slice(1).split("/")) {
+      target = record3(target) || Array.isArray(target) ? target[part.replace(/~1/g, "/").replace(/~0/g, "~")] : void 0;
+    }
+  return !fragment || fragment.startsWith("/") ? target : void 0;
+}
+function resolveHints(variant, schema4, data, seen = /* @__PURE__ */ new Set(), conditional = false) {
   var _a;
-  if (!record2(schema4) || seen.has(schema4))
+  if (!record3(schema4) || seen.has(schema4))
     return {};
   seen.add(schema4);
   let result = { ...schema4 };
   if (typeof schema4.$ref === "string") {
-    const ref = schema4.$ref;
-    const hash = ref.indexOf("#");
-    const uri2 = hash < 0 ? ref : ref.slice(0, hash);
-    const resources = [variant.schemaBundle.root, ...variant.schemaBundle.resources];
-    const resource = uri2 ? resources.find((r2) => r2.retrievalUri === uri2 || record2(r2.document) && r2.document.$id === uri2) : variant.schemaBundle.root;
-    let target = resource === null || resource === void 0 ? void 0 : resource.document;
-    const fragment = hash < 0 ? "" : decodeURIComponent(ref.slice(hash + 1));
-    if (fragment.startsWith("/"))
-      for (const part of fragment.slice(1).split("/")) {
-        target = record2(target) || Array.isArray(target) ? target[part.replace(/~1/g, "/").replace(/~0/g, "~")] : void 0;
-      }
-    if (!fragment || fragment.startsWith("/"))
-      result = mergeHints(resolveHints(variant, target, data, seen), result);
+    result = mergeHints(resolveHints(variant, sourceReference(variant, schema4.$ref), data, seen, conditional), result);
   }
   if (Array.isArray(schema4.allOf))
     for (const part of schema4.allOf) {
-      const next = resolveHints(variant, part, data, seen);
+      const next = resolveHints(variant, part, data, seen, conditional);
       result = mergeHints(result, next);
     }
+  if (conditional && Object.hasOwn(schema4, "if")) {
+    const matches = presentationCondition(schema4.if, data, (ref) => sourceReference(variant, ref));
+    const branch = matches === true ? schema4.then : matches === false ? schema4.else : void 0;
+    if (branch !== void 0)
+      result = mergeHints(result, resolveHints(variant, branch, data, seen, conditional));
+  }
   const alternatives = (_a = schema4.oneOf) !== null && _a !== void 0 ? _a : schema4.anyOf;
   if (Array.isArray(alternatives)) {
     const choices = alternatives.filter((part) => {
-      if (!record2(part))
+      if (!record3(part))
         return false;
       if (typeof part.type === "string" && part.type !== typeOf(data) && !(part.type === "integer" && typeof data === "number"))
         return false;
-      if (record2(part.properties) && record2(data))
+      if (record3(part.properties) && record3(data))
         for (const [key, child] of Object.entries(part.properties)) {
-          if (record2(child) && Object.hasOwn(child, "const") && data[key] !== child.const)
+          if (record3(child) && Object.hasOwn(child, "const") && data[key] !== child.const)
             return false;
         }
       return true;
     });
     if (choices.length === 1)
-      result = mergeHints(result, resolveHints(variant, choices[0], data, seen));
+      result = mergeHints(result, resolveHints(variant, choices[0], data, seen, conditional));
   }
   if (!Array.isArray(result.enum)) {
     if (Object.hasOwn(result, "const"))
       result.enum = [result.const];
     else if (Array.isArray(alternatives)) {
-      const enums = alternatives.map((part) => resolveHints(variant, part, data, new Set(seen)));
+      const enums = alternatives.map((part) => resolveHints(variant, part, data, new Set(seen), conditional));
       if (enums.length && enums.every((part) => Array.isArray(part.enum))) {
         const values = enums.flatMap((part) => part.enum);
         result.enum = [...new Map(values.map((value) => [JSON.stringify(value), value])).values()];
@@ -11929,135 +12369,236 @@ function resolveHints(variant, schema4, data, seen = /* @__PURE__ */ new Set())
   }
   return result;
 }
-function Tree({ value, path, schema: schema4, ui, variant, invalidNumbers, change: onChange }) {
+function Tree({ value, path, schema: schema4, ui, variant, invalidNumbers, required, change: onChange }) {
   var _a;
-  const hints = resolveHints(variant, schema4, value);
-  const uiHints = record2(ui) ? ui : {};
-  const [newKey, setNewKey] = React.useState("");
+  const errors = React3.useContext(SourcePaths);
+  const commonLayout = useCommonLayout();
+  const hints = resolveHints(variant, schema4, value, /* @__PURE__ */ new Set(), commonLayout);
+  const uiHints = record3(ui) ? ui : {};
+  const [newKey, setNewKey] = React3.useState("");
+  const [id] = React3.useState(() => `source-field-${++nextFieldId}`);
   const change = (next, edit = { path }) => onChange(next, edit);
   const choices = Array.isArray(hints.enum) ? hints.enum : Array.isArray(uiHints["ui:enum"]) ? uiHints["ui:enum"] : void 0;
-  const label = typeof hints.title === "string" ? hints.title : path || "/";
-  const props = { "aria-label": label };
+  const key = path.slice(path.lastIndexOf("/") + 1).replace(/~1/g, "/").replace(/~0/g, "~");
+  const label = commonLayout && typeof uiHints["ui:title"] === "string" ? uiHints["ui:title"] : typeof hints.title === "string" ? hints.title : commonLayout ? propertyLabel(key) : path || "/";
   const type = typeOf(value);
+  const allowed = presentationTypes(schema4, (ref) => sourceReference(variant, ref));
+  const fixedType = allowed.size === 1 && allowed.has(type);
+  const readonly = commonLayout && (hints.readOnly === true || uiHints["ui:readonly"] === true || uiHints["ui:disabled"] === true);
+  const props = { "aria-label": label, ...commonLayout ? { id, disabled: readonly, "aria-describedby": typeof hints.description === "string" && hints.description.trim() ? `${id}-help` : void 0 } : {} };
+  const typeControl = !commonLayout || !fixedType ? React3.createElement("select", { "data-source-type-control": "", "aria-label": `Type ${path || "/"}`, disabled: readonly, value: type, onChange: (e2) => change(initial(e2.target.value)) }, (commonLayout && allowed.size ? [.../* @__PURE__ */ new Set([type, ...allowed])] : jsonTypes).map((t) => React3.createElement("option", { key: t }, t))) : null;
+  const seed = (hint) => cloneJson(presentationInitial(hint));
   let field;
   if (choices) {
     const serialized2 = JSON.stringify(value);
     const options = choices.map((item) => JSON.stringify(item));
     if (!options.includes(serialized2))
       options.unshift(serialized2);
-    field = React.createElement("select", { ...props, value: serialized2, onChange: (e2) => change(JSON.parse(e2.target.value)) }, options.map((item) => React.createElement("option", { key: item, value: item }, item)));
+    field = commonLayout && options.length === 1 ? React3.createElement("input", { ...props, readOnly: true, value: typeof value === "string" ? value : serialized2 }) : React3.createElement("select", { ...props, value: serialized2, onChange: (e2) => change(JSON.parse(e2.target.value)) }, options.map((item) => React3.createElement("option", { key: item, value: item }, commonLayout && typeof JSON.parse(item) === "string" ? JSON.parse(item) : item)));
   } else if (typeof value === "string") {
-    field = React.createElement("textarea", { ...props, value, onChange: (e2) => change(e2.target.value) });
+    field = commonLayout && uiHints["ui:widget"] !== "textarea" && !value.includes("\n") ? React3.createElement("input", { ...props, type: "text", value, onChange: (e2) => change(e2.target.value) }) : React3.createElement("textarea", { ...props, value, onChange: (e2) => change(e2.target.value) });
   } else if (typeof value === "number") {
-    field = React.createElement("input", { ...props, type: "text", inputMode: "decimal", value: (_a = invalidNumbers[path]) !== null && _a !== void 0 ? _a : String(value), onChange: (e2) => {
+    field = React3.createElement("input", { ...props, type: "text", inputMode: "decimal", value: (_a = invalidNumbers[path]) !== null && _a !== void 0 ? _a : String(value), onChange: (e2) => {
       const text = e2.target.value;
       const number = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?$/.test(text) ? Number(text) : NaN;
       change(Number.isFinite(number) ? number : value, { path, ...Number.isFinite(number) ? {} : { invalidText: text } });
     } });
   } else if (typeof value === "boolean") {
-    field = React.createElement("input", { ...props, type: "checkbox", checked: value, onChange: (e2) => change(e2.target.checked) });
+    field = React3.createElement("input", { ...props, type: "checkbox", checked: value, onChange: (e2) => change(e2.target.checked) });
   } else if (Array.isArray(value)) {
-    field = React.createElement(
+    const itemHint = (index) => {
+      var _a2, _b;
+      return Array.isArray(hints.prefixItems) ? (_a2 = hints.prefixItems[index]) !== null && _a2 !== void 0 ? _a2 : hints.items : Array.isArray(hints.items) ? (_b = hints.items[index]) !== null && _b !== void 0 ? _b : hints.additionalItems : hints.items;
+    };
+    const tuple = Array.isArray(hints.prefixItems) || Array.isArray(hints.items);
+    const canRemove = !commonLayout || value.length > (typeof hints.minItems === "number" ? hints.minItems : 0);
+    const canAdd = !commonLayout || itemHint(value.length) !== false && (typeof hints.maxItems !== "number" || value.length < hints.maxItems);
+    field = React3.createElement(
       "div",
       null,
-      value.map((child, index) => {
-        var _a2;
-        return React.createElement(
-          "div",
-          { key: index },
-          React.createElement(Tree, { invalidNumbers, value: child, path: pointer(path, String(index)), variant, schema: Array.isArray(hints.prefixItems) ? (_a2 = hints.prefixItems[index]) !== null && _a2 !== void 0 ? _a2 : hints.items : Array.isArray(hints.items) ? hints.items[index] : hints.items, ui: uiHints.items, change: (next, edit) => {
-            const copy = [...value];
-            copy[index] = next;
-            change(copy, edit);
-          } }),
-          React.createElement("button", { type: "button", "aria-label": `Remove ${pointer(path, String(index))}`, onClick: () => change(value.filter((_2, i2) => i2 !== index), { path, removeIndex: index }) }, "Remove"),
-          React.createElement("button", { type: "button", disabled: index === 0, "aria-label": `Move up ${pointer(path, String(index))}`, onClick: () => {
-            const copy = [...value];
-            [copy[index - 1], copy[index]] = [copy[index], copy[index - 1]];
-            change(copy, { path, swap: [index - 1, index] });
-          } }, "\u2191")
-        );
-      }),
-      React.createElement("button", { type: "button", "aria-label": `Add item ${path || "/"}`, onClick: () => change([...value, null], { path: pointer(path, String(value.length)) }) }, "Add item")
+      commonLayout && value.length === 0 && React3.createElement("p", { className: "editor-form-hint" }, "\u9805\u76EE\u306A\u3057"),
+      value.map((child, index) => React3.createElement(
+        "div",
+        { key: index, className: commonLayout ? "editor-form-array-item" : void 0 },
+        React3.createElement(Tree, { invalidNumbers, value: child, path: pointer(path, String(index)), variant, schema: itemHint(index), ui: uiHints.items, change: (next, edit) => {
+          const copy = [...value];
+          copy[index] = next;
+          change(copy, edit);
+        } }),
+        canRemove && React3.createElement("button", { type: "button", "aria-label": `Remove ${pointer(path, String(index))}`, onClick: () => change(value.filter((_2, i2) => i2 !== index), { path, removeIndex: index }) }, "Remove"),
+        (!commonLayout || !tuple && value.length > 1) && React3.createElement("button", { type: "button", disabled: index === 0, "aria-label": `Move up ${pointer(path, String(index))}`, onClick: () => {
+          const copy = [...value];
+          [copy[index - 1], copy[index]] = [copy[index], copy[index - 1]];
+          change(copy, { path, swap: [index - 1, index] });
+        } }, "\u2191")
+      )),
+      canAdd && React3.createElement("button", { type: "button", "aria-label": `Add item ${path || "/"}`, onClick: () => change([...value, commonLayout ? seed(resolveHints(variant, itemHint(value.length), null)) : null], { path: pointer(path, String(value.length)) }) }, "Add item")
     );
   } else if (value !== null && typeof value === "object") {
-    const properties = record2(hints.properties) ? hints.properties : {};
-    field = React.createElement(
-      "div",
-      null,
-      Object.entries(value).map(([key, child]) => React.createElement(
+    const properties = record3(hints.properties) ? hints.properties : {};
+    const requiredKeys = new Set(Array.isArray(hints.required) ? hints.required : []);
+    const optional = Object.keys(properties).filter((name) => !requiredKeys.has(name));
+    const missing = Object.keys(properties).filter((name) => !Object.hasOwn(value, name));
+    const remove = (name) => {
+      const copy = cloneJson(value);
+      delete copy[name];
+      change(copy, { path: pointer(path, name) });
+    };
+    const add = (name) => {
+      const hint = resolveHints(variant, propertyHint(hints, name), null);
+      const copy = cloneJson(value);
+      Object.defineProperty(copy, name, { value: seed(hint), enumerable: true, writable: true, configurable: true });
+      change(copy, { path: pointer(path, name) });
+      setNewKey("");
+    };
+    const fields2 = Object.entries(value).map(([name, child]) => ({
+      name,
+      errors: errors.filter((error) => error === pointer(path, name) || error.startsWith(pointer(path, name) + "/")).length,
+      content: React3.createElement(
         "div",
-        { key },
-        React.createElement(Tree, { invalidNumbers, value: child, path: pointer(path, key), variant, schema: propertyHint(hints, key), ui: uiHints[key], change: (next, edit) => {
+        { key: name },
+        React3.createElement(Tree, { invalidNumbers, value: child, path: pointer(path, name), variant, schema: propertyHint(hints, name), required: requiredKeys.has(name), ui: uiHints[name], change: (next, edit) => {
           const copy = cloneJson(value);
-          Object.defineProperty(copy, key, { value: next, enumerable: true, writable: true, configurable: true });
+          Object.defineProperty(copy, name, { value: next, enumerable: true, writable: true, configurable: true });
           change(copy, edit);
         } }),
-        React.createElement("button", { type: "button", "aria-label": `Remove ${pointer(path, key)}`, onClick: () => {
+        (!commonLayout || !Object.hasOwn(properties, name) && !requiredKeys.has(name)) && React3.createElement("button", { type: "button", "aria-label": `Remove ${pointer(path, name)}`, onClick: () => remove(name) }, "Remove")
+      )
+    }));
+    const dynamic = hints.additionalProperties !== false || record3(hints.patternProperties);
+    field = React3.createElement(
+      "div",
+      null,
+      React3.createElement(ObjectLayout, { ui: uiHints, knownFields: [.../* @__PURE__ */ new Set([...Object.keys(properties), ...Object.keys(value)])], fields: fields2, fallback: fields2.map((item) => item.content) }),
+      commonLayout ? React3.createElement(
+        React3.Fragment,
+        null,
+        (missing.length > 0 || optional.some((name) => Object.hasOwn(value, name))) && React3.createElement(
+          "details",
+          { className: "editor-form-tools" },
+          React3.createElement("summary", null, "\u9805\u76EE\u3092\u7BA1\u7406"),
+          missing.map((name) => React3.createElement(
+            "button",
+            { type: "button", key: name, onClick: () => add(name) },
+            propertyLabel(name),
+            "\u3092\u8FFD\u52A0"
+          )),
+          optional.filter((name) => Object.hasOwn(value, name)).map((name) => React3.createElement(
+            "label",
+            { key: name },
+            propertyLabel(name),
+            React3.createElement("button", { type: "button", "aria-label": `Remove ${pointer(path, name)}`, onClick: () => remove(name) }, "\u5024\u3092\u89E3\u9664")
+          ))
+        ),
+        dynamic && React3.createElement(
+          "details",
+          { className: "editor-form-tools" },
+          React3.createElement("summary", null, "\u8FFD\u52A0\u306E\u30D7\u30ED\u30D1\u30C6\u30A3"),
+          React3.createElement("label", { htmlFor: `${id}-key` }, "\u9805\u76EE\u540D"),
+          React3.createElement("input", { id: `${id}-key`, "aria-label": `New property ${path || "/"}`, value: newKey, onChange: (e2) => setNewKey(e2.target.value) }),
+          React3.createElement("button", { type: "button", disabled: !newKey || Object.hasOwn(value, newKey) || propertyHint(hints, newKey) === false, onClick: () => add(newKey) }, "Add property")
+        )
+      ) : React3.createElement(
+        React3.Fragment,
+        null,
+        React3.createElement(
+          "label",
+          null,
+          "Property ",
+          React3.createElement("input", { "aria-label": `New property ${path || "/"}`, value: newKey, onChange: (e2) => setNewKey(e2.target.value) })
+        ),
+        React3.createElement(
+          "select",
+          { "aria-label": `Known property ${path || "/"}`, value: "", onChange: (e2) => setNewKey(e2.target.value) },
+          React3.createElement("option", { value: "" }, "Choose property"),
+          missing.map((name) => React3.createElement("option", { key: name }, name))
+        ),
+        React3.createElement("button", { type: "button", disabled: !newKey || Object.hasOwn(value, newKey), onClick: () => {
           const copy = cloneJson(value);
-          delete copy[key];
-          change(copy, { path: pointer(path, key) });
-        } }, "Remove")
-      )),
-      React.createElement(
+          Object.defineProperty(copy, newKey, { value: null, enumerable: true, writable: true, configurable: true });
+          change(copy, { path: pointer(path, newKey) });
+          setNewKey("");
+        } }, "Add property")
+      )
+    );
+  } else
+    field = React3.createElement("span", null, "null");
+  const containerProps = { "data-source-path": path, "data-source-error": commonLayout && errors.includes(path) };
+  if (commonLayout && !Array.isArray(value) && !record3(value))
+    return React3.createElement(
+      "div",
+      { ...containerProps, className: "editor-form-field" },
+      typeof value === "boolean" && !choices ? React3.createElement(
         "label",
+        { className: "editor-form-toggle", htmlFor: id },
+        field,
+        React3.createElement("span", null, label)
+      ) : React3.createElement(
+        React3.Fragment,
         null,
-        "Property ",
-        React.createElement("input", { "aria-label": `New property ${path || "/"}`, value: newKey, onChange: (e2) => setNewKey(e2.target.value) })
-      ),
-      React.createElement(
-        "select",
-        { "aria-label": `Known property ${path || "/"}`, value: "", onChange: (e2) => setNewKey(e2.target.value) },
-        React.createElement("option", { value: "" }, "Choose property"),
-        Object.keys(properties).filter((key) => !Object.hasOwn(value, key)).map((key) => React.createElement("option", { key }, key))
+        React3.createElement(
+          "label",
+          { htmlFor: id },
+          label,
+          required && React3.createElement("span", { className: "required" }, " *")
+        ),
+        field
       ),
-      React.createElement("button", { type: "button", disabled: !newKey || Object.hasOwn(value, newKey), onClick: () => {
-        const copy = cloneJson(value);
-        Object.defineProperty(copy, newKey, { value: null, enumerable: true, writable: true, configurable: true });
-        change(copy, { path: pointer(path, newKey) });
-        setNewKey("");
-      } }, "Add property")
+      typeControl,
+      React3.createElement(FormHelp, { description: hints.description, id: `${id}-help` }),
+      invalidNumbers[path] !== void 0 && React3.createElement("p", { className: "editor-form-invalid", role: "alert" }, "\u6709\u52B9\u306A\u6570\u5024\u3092\u5165\u529B\u3057\u3066\u304F\u3060\u3055\u3044\u3002")
     );
-  } else
-    field = React.createElement("span", null, "null");
-  return React.createElement(
+  return React3.createElement(
     "fieldset",
-    { "data-source-path": path },
-    React.createElement("legend", null, label),
-    React.createElement("select", { "aria-label": `Type ${path || "/"}`, value: type, onChange: (e2) => change(initial(e2.target.value)) }, ["object", "array", "string", "number", "boolean", "null"].map((t) => React.createElement("option", { key: t }, t))),
+    { ...containerProps, className: commonLayout ? "editor-form-section" : void 0, disabled: readonly },
+    React3.createElement("legend", null, label),
+    commonLayout && React3.createElement(FormHelp, { description: hints.description }),
+    typeControl,
     field
   );
 }
-function liveIssues(draft, bindings) {
+function liveIssues(draft, bindings, commonLayout = false) {
+  var _a;
   const issues = [];
   const sources = draft.sources;
   for (const binding of bindings) {
     const entry = sources[binding.argument];
     try {
-      if (entry.invalidForm === true)
-        throw new TypeError();
-      const doc = record2(entry.creating) ? { ...entry.creating, data: entry.data } : readSourceDocument(binding, entry.source);
+      if (entry.invalidForm === true) {
+        if (!commonLayout || !record3(entry.invalidNumbers) || !Object.keys(entry.invalidNumbers).length)
+          throw new TypeError();
+        for (const path of Object.keys((_a = entry.invalidNumbers) !== null && _a !== void 0 ? _a : {}))
+          issues.push({ message: "Enter a valid JSON number.", path: pointer("", binding.argument) + path });
+      }
+      const doc = record3(entry.creating) ? { ...entry.creating, data: entry.data } : readSourceDocument(binding, entry.source);
       const validator = binding.validators.get(JSON.stringify([doc.format, doc.variantId]));
-      if (validator && validator.validate(entry.mode === "form" ? entry.data : doc.data).kind !== "valid") {
-        issues.push({ message: "Value does not satisfy the schema.", path: `/${binding.argument}` });
+      if (validator) {
+        const result = validator.validate(entry.mode === "form" ? entry.data : doc.data);
+        if (result.kind !== "valid") {
+          if (commonLayout)
+            for (const diagnostic of result.diagnostics)
+              issues.push({ message: "Value does not satisfy the schema.", path: pointer("", binding.argument) + ("dataPath" in diagnostic ? diagnostic.dataPath : "") });
+          else
+            issues.push({ message: "Value does not satisfy the schema.", path: `/${binding.argument}` });
+        }
       }
-    } catch (_a) {
+    } catch (_b) {
       issues.push({ message: "Repair the invalid source or form value.", path: `/${binding.argument}` });
     }
   }
   return issues;
 }
-function SourceView({ context, bindings }) {
-  const [, redraw] = React.useState(0);
-  const [creating, selectCreateVariant] = React.useState({});
-  React.useEffect(() => {
+function SourceView({ context, bindings, commonLayout }) {
+  const [, redraw] = React3.useState(0);
+  const [creating, selectCreateVariant] = React3.useState({});
+  React3.useLayoutEffect(() => {
     const stop = context.subscribe(() => redraw((n2) => n2 + 1));
-    context.setValidationIssues(liveIssues(context.getDraft(), bindings));
+    context.setValidationIssues(liveIssues(context.getDraft(), bindings, commonLayout));
     return stop;
-  }, [context, bindings]);
+  }, [context, bindings, commonLayout]);
   const state = context.getState();
   if (state.status !== "editing" && state.status !== "saving")
-    return React.createElement(React.Fragment, null);
+    return React3.createElement(React3.Fragment, null);
   const draft = context.getDraft();
   const sources = draft.sources;
   const disabled = context.getState().status !== "editing";
@@ -12066,10 +12607,10 @@ function SourceView({ context, bindings }) {
     const nextSources = next.sources;
     Object.defineProperty(nextSources, argument, { value: entry, enumerable: true, configurable: true, writable: true });
     context.setDraft(next);
-    context.setValidationIssues(liveIssues(next, bindings));
+    context.setValidationIssues(liveIssues(next, bindings, commonLayout));
   };
-  return React.createElement("div", { className: "block-editor-source-forms" }, bindings.map((binding) => {
-    var _a, _b;
+  return React3.createElement("div", { className: "block-editor-source-forms" }, bindings.map((binding) => {
+    var _a, _b, _c;
     const entry = sources[binding.argument];
     const selectedCreation = Object.hasOwn(creating, binding.argument) ? creating[binding.argument] : "";
     let document2;
@@ -12077,33 +12618,41 @@ function SourceView({ context, bindings }) {
     try {
       document2 = readSourceDocument(binding, entry.source);
       variant = binding.presentationVariants.find((v2) => v2.format === document2.format && v2.variantId === document2.variantId);
-    } catch (_c) {
+    } catch (_d) {
     }
-    if (record2(entry.creating)) {
+    if (record3(entry.creating)) {
       const creation = entry.creating;
       variant = binding.presentationVariants.find((v2) => v2.format === creation.format && v2.variantId === creation.variantId);
     }
-    return React.createElement(
-      "fieldset",
-      { key: binding.argument, disabled },
-      React.createElement("legend", null, (_a = binding.label) !== null && _a !== void 0 ? _a : binding.argument),
-      React.createElement("button", { type: "button", "aria-pressed": entry.mode === "source", onClick: () => {
-        try {
-          if (entry.invalidForm === true)
-            throw new TypeError();
-          const source = record2(entry.creating) ? createSourceCandidate(entry.creating.format, entry.data) : entry.mode === "form" && document2 && Object.hasOwn(entry, "data") ? patchDecodedSource(document2, entry.data, (source2) => readSourceDocument(binding, source2)) : entry.source;
-          const next = { ...entry, mode: "source", source, invalidForm: false, invalidNumbers: {} };
-          delete next.creating;
-          update(binding.argument, next);
-        } catch (_a2) {
-          context.setValidationIssues([{ message: "This edit cannot preserve the source. Repair the Source explicitly." }]);
-        }
-      } }, "Source"),
-      React.createElement(
+    const argumentPath = pointer("", binding.argument);
+    const errorPaths = [...new Set(state.issues.flatMap((issue2) => {
+      var _a2;
+      return ((_a2 = issue2.path) === null || _a2 === void 0 ? void 0 : _a2.startsWith(argumentPath + "/")) ? [issue2.path.slice(argumentPath.length)] : [];
+    }).concat(Object.keys((_a = entry.invalidNumbers) !== null && _a !== void 0 ? _a : {})))];
+    const sourceButton = React3.createElement("button", { type: "button", "aria-pressed": entry.mode === "source", onClick: () => {
+      try {
+        if (entry.invalidForm === true)
+          throw new TypeError();
+        const source = record3(entry.creating) ? createSourceCandidate(entry.creating.format, entry.data) : entry.mode === "form" && document2 && Object.hasOwn(entry, "data") ? patchDecodedSource(document2, entry.data, (source2) => readSourceDocument(binding, source2)) : entry.source;
+        const next = { ...entry, mode: "source", source, invalidForm: false, invalidNumbers: {} };
+        delete next.creating;
+        update(binding.argument, next);
+      } catch (_a2) {
+        context.setValidationIssues([{ message: "This edit cannot preserve the source. Repair the Source explicitly." }]);
+      }
+    } }, "Source");
+    const formButton = React3.createElement("button", { type: "button", disabled: !variant, "aria-pressed": entry.mode === "form", onClick: () => {
+      if (document2 || entry.creating)
+        update(binding.argument, { ...entry, mode: "form", data: Object.hasOwn(entry, "data") ? entry.data : document2.data });
+    } }, "Form");
+    const creationTools = React3.createElement(
+      React3.Fragment,
+      null,
+      React3.createElement(
         "select",
         { "aria-label": `${binding.argument} New format and variant`, value: selectedCreation, onChange: (e2) => selectCreateVariant({ ...creating, [binding.argument]: e2.target.value }) },
-        React.createElement("option", { value: "" }, "Choose new format and variant"),
-        binding.presentationVariants.map((v2) => React.createElement(
+        React3.createElement("option", { value: "" }, "Choose new format and variant"),
+        binding.presentationVariants.map((v2) => React3.createElement(
           "option",
           { key: JSON.stringify([v2.format, v2.variantId]), value: JSON.stringify([v2.format, v2.variantId]) },
           v2.format,
@@ -12111,54 +12660,87 @@ function SourceView({ context, bindings }) {
           v2.variantId
         ))
       ),
-      React.createElement("button", { type: "button", disabled: !selectedCreation, onClick: () => {
+      React3.createElement("button", { type: "button", disabled: !selectedCreation, onClick: () => {
         const [format, variantId] = JSON.parse(selectedCreation);
         const chosen = binding.presentationVariants.find((v2) => v2.format === format && v2.variantId === variantId);
         const root2 = chosen.schemaBundle.root.document;
-        const type = record2(root2) && typeof root2.type === "string" ? root2.type : "null";
+        const type = record3(root2) && typeof root2.type === "string" ? root2.type : "null";
         update(binding.argument, { mode: "form", source: entry.source, sourceEdited: true, creating: { format, variantId }, data: initial(type) });
-      } }, "Create document (replace source)"),
-      React.createElement("button", { type: "button", disabled: !variant, "aria-pressed": entry.mode === "form", onClick: () => {
-        if (document2 || entry.creating)
-          update(binding.argument, { ...entry, mode: "form", data: Object.hasOwn(entry, "data") ? entry.data : document2.data });
-      } }, "Form"),
-      entry.mode === "form" && React.createElement("button", { type: "button", onClick: () => {
-        var _a2;
-        return update(binding.argument, { mode: "source", source: entry.source, sourceEdited: (_a2 = entry.sourceEdited) !== null && _a2 !== void 0 ? _a2 : false });
-      } }, "Discard form edits"),
-      entry.mode === "form" && variant && Object.hasOwn(entry, "data") ? React.createElement(Tree, { invalidNumbers: (_b = entry.invalidNumbers) !== null && _b !== void 0 ? _b : {}, value: entry.data, path: "", schema: variant.schemaBundle.root.document, ui: variant.uiSchema, variant, change: (data, edit = { path: "" }) => {
-        var _a2;
-        const pending = (_a2 = entry.invalidNumbers) !== null && _a2 !== void 0 ? _a2 : {};
-        const invalidNumbers = {};
-        const prefix = `${edit.path}/`;
-        for (const [path, text] of Object.entries(pending)) {
-          let target = path;
-          if (edit.removeIndex !== void 0 || edit.swap) {
-            if (path.startsWith(prefix)) {
-              const [head, ...tail] = path.slice(prefix.length).split("/");
-              let index = Number(head);
-              if (index === edit.removeIndex)
-                continue;
-              if (edit.removeIndex !== void 0 && index > edit.removeIndex)
-                index--;
-              if (edit.swap)
-                index = index === edit.swap[0] ? edit.swap[1] : index === edit.swap[1] ? edit.swap[0] : index;
-              target = `${prefix}${index}${tail.length ? "/" + tail.join("/") : ""}`;
-            }
-          } else if (path === edit.path || path.startsWith(prefix))
-            continue;
-          Object.defineProperty(invalidNumbers, target, { value: text, enumerable: true });
-        }
-        if (edit.invalidText !== void 0)
-          Object.defineProperty(invalidNumbers, edit.path, { value: edit.invalidText, enumerable: true });
-        update(binding.argument, { ...entry, data, invalidNumbers, invalidForm: Object.keys(invalidNumbers).length > 0 });
-      } }) : React.createElement("textarea", { "aria-label": `${binding.argument} Source`, value: entry.source, onChange: (e2) => update(binding.argument, { mode: "source", source: e2.target.value, sourceEdited: true }) }),
-      entry.invalidForm === true && React.createElement("p", { role: "alert" }, "Enter a valid JSON number.")
+      } }, "Create document (replace source)")
+    );
+    const discard = entry.mode === "form" && React3.createElement("button", { type: "button", onClick: () => {
+      var _a2;
+      return update(binding.argument, { mode: "source", source: entry.source, sourceEdited: (_a2 = entry.sourceEdited) !== null && _a2 !== void 0 ? _a2 : false });
+    } }, "Discard form edits");
+    return React3.createElement(
+      "fieldset",
+      { key: binding.argument, disabled, className: commonLayout ? "editor-form-binding" : void 0 },
+      (!commonLayout || binding.label || bindings.length > 1) && React3.createElement("legend", null, (_b = binding.label) !== null && _b !== void 0 ? _b : binding.argument),
+      commonLayout ? React3.createElement(
+        "div",
+        { className: "editor-form-toolbar" },
+        React3.createElement(
+          "div",
+          { className: "editor-form-modes" },
+          sourceButton,
+          formButton
+        ),
+        React3.createElement(
+          "details",
+          { className: "editor-form-tools" },
+          React3.createElement("summary", null, "\u6587\u66F8\u306E\u64CD\u4F5C"),
+          creationTools,
+          discard
+        )
+      ) : React3.createElement(
+        React3.Fragment,
+        null,
+        sourceButton,
+        creationTools,
+        formButton,
+        discard
+      ),
+      entry.mode === "form" && variant && Object.hasOwn(entry, "data") ? React3.createElement(
+        SourcePaths.Provider,
+        { value: errorPaths },
+        React3.createElement(Tree, { invalidNumbers: (_c = entry.invalidNumbers) !== null && _c !== void 0 ? _c : {}, value: entry.data, path: "", schema: variant.schemaBundle.root.document, ui: variant.uiSchema, variant, change: (data, edit = { path: "" }) => {
+          var _a2;
+          const pending = (_a2 = entry.invalidNumbers) !== null && _a2 !== void 0 ? _a2 : {};
+          const invalidNumbers = {};
+          const prefix = `${edit.path}/`;
+          for (const [path, text] of Object.entries(pending)) {
+            let target = path;
+            if (edit.removeIndex !== void 0 || edit.swap) {
+              if (path.startsWith(prefix)) {
+                const [head, ...tail] = path.slice(prefix.length).split("/");
+                let index = Number(head);
+                if (index === edit.removeIndex)
+                  continue;
+                if (edit.removeIndex !== void 0 && index > edit.removeIndex)
+                  index--;
+                if (edit.swap)
+                  index = index === edit.swap[0] ? edit.swap[1] : index === edit.swap[1] ? edit.swap[0] : index;
+                target = `${prefix}${index}${tail.length ? "/" + tail.join("/") : ""}`;
+              }
+            } else if (path === edit.path || path.startsWith(prefix))
+              continue;
+            Object.defineProperty(invalidNumbers, target, { value: text, enumerable: true });
+          }
+          if (edit.invalidText !== void 0)
+            Object.defineProperty(invalidNumbers, edit.path, { value: edit.invalidText, enumerable: true });
+          update(binding.argument, { ...entry, data, invalidNumbers, invalidForm: Object.keys(invalidNumbers).length > 0 });
+        } })
+      ) : React3.createElement("textarea", { "aria-label": `${binding.argument} Source`, value: entry.source, onChange: (e2) => update(binding.argument, { mode: "source", source: e2.target.value, sourceEdited: true }) }),
+      entry.invalidForm === true && React3.createElement("p", { role: "alert" }, "Enter a valid JSON number.")
     );
   }));
 }
-function mountSourceView(container, context, bindings) {
-  ReactDOM.render(React.createElement(SourceView, { context, bindings }), container);
+function mountSourceView(container, context, bindings, commonLayout = false) {
+  ReactDOM.render(React3.createElement(
+    LayoutHost,
+    { enabled: commonLayout, context },
+    React3.createElement(SourceView, { context, bindings, commonLayout })
+  ), container);
   return () => {
     ReactDOM.unmountComponentAtNode(container);
   };
@@ -12209,21 +12791,22 @@ function entryFor(draft, argument) {
   }
   return entry;
 }
-function createSourceEditor(options) {
+function createSourceEditor(options, featureOptions = {}) {
   var _a;
+  const features = captureFeatureFlags(featureOptions);
   const { apiVersion, extensionId, editorId, validationContext: provider } = options;
   if (apiVersion !== 1 || typeof provider !== "function" || !Array.isArray(options.bindings) || !options.bindings.length) {
     throw new TypeError("Invalid source editor options.");
   }
   const inputBindings = options.bindings;
   const bindings = [];
-  const names = /* @__PURE__ */ new Set();
+  const names2 = /* @__PURE__ */ new Set();
   for (let i2 = 0; i2 < inputBindings.length; i2++) {
     const binding = inputBindings[i2];
     const { argument, label, decode, validateSource } = binding;
-    if (typeof argument !== "string" || !argument || names.has(argument) || typeof decode !== "function" || typeof validateSource !== "function" || label !== void 0 && typeof label !== "string")
+    if (typeof argument !== "string" || !argument || names2.has(argument) || typeof decode !== "function" || typeof validateSource !== "function" || label !== void 0 && typeof label !== "string")
       throw new TypeError("Invalid source binding.");
-    names.add(argument);
+    names2.add(argument);
     const variants = snapshotJson(binding.variants);
     if (!Array.isArray(variants) || !variants.length)
       throw new TypeError("Source variants are required.");
@@ -12249,7 +12832,7 @@ function createSourceEditor(options) {
     extensionId,
     editorId,
     opcodes: Object.freeze([...options.opcodes]),
-    editableArguments: Object.freeze([...names]),
+    editableArguments: Object.freeze([...names2]),
     saveContract: "prepared-source-v1",
     read: (snapshot2) => {
       const sources = {};
@@ -12299,7 +12882,11 @@ function createSourceEditor(options) {
         try {
           const entry = entryFor(draft, binding.argument);
           if (entry.invalidForm === true) {
-            issues.push(issue("form-value-invalid", path));
+            if (features.commonLayout && isJsonRecord(entry.invalidNumbers) && Object.keys(entry.invalidNumbers).length > 0) {
+              for (const pointer2 of Object.keys(entry.invalidNumbers))
+                issues.push(issue("form-value-invalid", path + pointer2));
+            } else
+              issues.push(issue("form-value-invalid", path));
             continue;
           }
           const slot = snapshot2.arguments[binding.argument];
@@ -12350,7 +12937,13 @@ function createSourceEditor(options) {
           if (validation.result.kind !== "valid") {
             if (!["invalid", "execution-error", "schema-error"].includes(validation.result.kind))
               throw new TypeError();
-            issues.push(issue("owner-input-invalid", path));
+            if (features.commonLayout && validation.result.diagnostics.length) {
+              for (const diagnostic of validation.result.diagnostics) {
+                const pointer2 = typeof diagnostic.dataPath === "string" && diagnostic.dataPath.startsWith("/") ? diagnostic.dataPath : "";
+                issues.push(issue("owner-input-invalid", path + pointer2));
+              }
+            } else
+              issues.push(issue("owner-input-invalid", path));
             continue;
           }
           if (validation.result.diagnostics.length)
@@ -12364,7 +12957,11 @@ function createSourceEditor(options) {
           if (validator) {
             const result = validator.validate(document2.data, { consumerId: context.consumerId });
             if (result.kind !== "valid") {
-              issues.push(issue("schema-data-invalid", path));
+              if (features.commonLayout)
+                for (const diagnostic of result.diagnostics)
+                  issues.push(issue("schema-data-invalid", path + ("dataPath" in diagnostic ? diagnostic.dataPath : "")));
+              else
+                issues.push(issue("schema-data-invalid", path));
               continue;
             }
           } else if (entry.mode === "form" || candidate !== slot.value && !((_a2 = binding.sourceOnlyVariants) === null || _a2 === void 0 ? void 0 : _a2.some((v2) => v2.variantId === document2.variantId && v2.format === document2.format))) {
@@ -12379,12 +12976,12 @@ function createSourceEditor(options) {
       }
       return issues.length ? { kind: "invalid", issues } : { kind: "ready", changes };
     },
-    mount: (container, context) => mountSourceView(container, context, bindings)
+    mount: (container, context) => mountSourceView(container, context, bindings, features.commonLayout)
   });
 }
 
 // dist/fixed-input-view.js
-import * as React2 from "react";
+import * as React4 from "react";
 import * as ReactDOM2 from "react-dom";
 var defaultMessages = Object.freeze({
   reset: "Reset",
@@ -12421,7 +13018,7 @@ function resolveFixedInputMessages(source) {
     throw error;
   }
 }
-var record3 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+var record4 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 var display = (value) => typeof value === "string" ? value : typeof value === "number" && Object.is(value, -0) ? "-0" : value === void 0 ? "" : JSON.stringify(value);
 var serialized = (value) => value === void 0 ? "unavailable" : JSON.stringify(value);
 function preview(value) {
@@ -12439,9 +13036,9 @@ function describe(context) {
 }
 var nextFixedViewId = 0;
 function FixedInputView({ context, messages }) {
-  const [, redraw] = React2.useState(0);
-  const [viewId] = React2.useState(() => `block-editor-fixed-${++nextFixedViewId}`);
-  React2.useEffect(() => {
+  const [, redraw] = React4.useState(0);
+  const [viewId] = React4.useState(() => `block-editor-fixed-${++nextFixedViewId}`);
+  React4.useEffect(() => {
     const stop = context.subscribe(() => redraw((value) => value + 1));
     if (context.getState().status === "editing" && !context.getState().issues.length) {
       context.setValidationIssues(describe(context).issues);
@@ -12450,10 +13047,10 @@ function FixedInputView({ context, messages }) {
   }, [context]);
   const state = context.getState();
   if (state.status !== "editing" && state.status !== "saving")
-    return React2.createElement(React2.Fragment, null);
+    return React4.createElement(React4.Fragment, null);
   const description = describe(context);
   const draft = context.getDraft();
-  const inputs = record3(draft.inputs) ? draft.inputs : {};
+  const inputs = record4(draft.inputs) ? draft.inputs : {};
   const update = (argument, value, buffer) => {
     if (context.getState().status !== "editing")
       return;
@@ -12461,28 +13058,28 @@ function FixedInputView({ context, messages }) {
     if (!latest || latest.state !== "editable")
       return;
     const next = context.getDraft();
-    if (!record3(next.inputs))
+    if (!record4(next.inputs))
       throw new TypeError("Invalid fixed form draft.");
     const previous = next.inputs[argument];
     const entry = { value, changed: true };
     if (buffer !== void 0)
       entry.buffer = buffer;
-    if (record3(previous) && (previous.readOnly === true || previous.repair === true))
+    if (record4(previous) && (previous.readOnly === true || previous.repair === true))
       entry.repair = true;
     Object.defineProperty(next.inputs, argument, { value: entry, enumerable: true, configurable: true, writable: true });
     context.setDraft(next);
     context.setValidationIssues(describe(context).issues);
   };
-  const hasInactiveEdits = Object.entries(description.inputs).some(([argument, input]) => input.state === "hidden" && record3(inputs[argument]) && inputs[argument].changed === true);
-  return React2.createElement(
+  const hasInactiveEdits = Object.entries(description.inputs).some(([argument, input]) => input.state === "hidden" && record4(inputs[argument]) && inputs[argument].changed === true);
+  return React4.createElement(
     "div",
     { className: "block-editor-fixed-inputs" },
-    hasInactiveEdits && React2.createElement("p", { className: "block-editor-fixed-inactive", "data-fixed-inactive-draft": "", role: "status" }, messages.inactiveDraft),
+    hasInactiveEdits && React4.createElement("p", { className: "block-editor-fixed-inactive", "data-fixed-inactive-draft": "", role: "status" }, messages.inactiveDraft),
     Object.entries(description.inputs).map(([argument, input], index) => {
       var _a, _b, _c, _d, _e2;
       if (input.state === "hidden")
         return null;
-      const entry = record3(inputs[argument]) ? inputs[argument] : {};
+      const entry = record4(inputs[argument]) ? inputs[argument] : {};
       const value = Object.hasOwn(entry, "value") ? entry.value : void 0;
       const label = (_a = input.label) !== null && _a !== void 0 ? _a : argument;
       const text = typeof entry.buffer === "string" ? entry.buffer : value === void 0 ? (_b = input.rawDisplay) !== null && _b !== void 0 ? _b : "" : display(value);
@@ -12505,31 +13102,31 @@ function FixedInputView({ context, messages }) {
       };
       let control;
       if (input.state === "readonly") {
-        control = React2.createElement(
-          React2.Fragment,
+        control = React4.createElement(
+          React4.Fragment,
           null,
-          React2.createElement("output", { "aria-label": label, ...attributes }, (_c = input.rawDisplay) !== null && _c !== void 0 ? _c : text),
-          React2.createElement("p", { id: reasonId, className: "block-editor-fixed-readonly" }, messages.readOnly)
+          React4.createElement("output", { "aria-label": label, ...attributes }, (_c = input.rawDisplay) !== null && _c !== void 0 ? _c : text),
+          React4.createElement("p", { id: reasonId, className: "block-editor-fixed-readonly" }, messages.readOnly)
         );
       } else if (input.control === "enum") {
         const choices = (_d = input.choices) !== null && _d !== void 0 ? _d : [];
         const current = serialized(value);
         const known = choices.some((choice) => serialized(choice.value) === current);
-        control = React2.createElement(
+        control = React4.createElement(
           "select",
           { "aria-label": label, ...attributes, value: known ? current : "existing-raw", disabled, onChange: (event) => {
             const choice = choices.find((item) => serialized(item.value) === event.target.value);
             if (choice)
               update(argument, choice.value);
           } },
-          !known && React2.createElement("option", { value: "existing-raw", disabled: true }, ((_e2 = input.rawDisplay) !== null && _e2 !== void 0 ? _e2 : text) || messages.currentValue),
+          !known && React4.createElement("option", { value: "existing-raw", disabled: true }, ((_e2 = input.rawDisplay) !== null && _e2 !== void 0 ? _e2 : text) || messages.currentValue),
           choices.map((choice, index2) => {
             var _a2;
-            return React2.createElement("option", { key: index2, value: serialized(choice.value) }, (_a2 = choice.label) !== null && _a2 !== void 0 ? _a2 : display(choice.value));
+            return React4.createElement("option", { key: index2, value: serialized(choice.value) }, (_a2 = choice.label) !== null && _a2 !== void 0 ? _a2 : display(choice.value));
           })
         );
       } else if (input.control === "number") {
-        control = React2.createElement("input", { "aria-label": label, ...attributes, type: "text", inputMode: "decimal", value: text, disabled, onChange: (event) => {
+        control = React4.createElement("input", { "aria-label": label, ...attributes, type: "text", inputMode: "decimal", value: text, disabled, onChange: (event) => {
           const buffer = event.target.value;
           if (input.valueType === "string" || input.valueType === void 0 && typeof value === "string") {
             update(argument, buffer);
@@ -12540,36 +13137,36 @@ function FixedInputView({ context, messages }) {
         } });
       } else if (input.control === "color") {
         const color = preview(text);
-        control = React2.createElement(
+        control = React4.createElement(
           "div",
           { className: "block-editor-fixed-color" },
-          React2.createElement("input", { "aria-label": label, ...attributes, type: "text", value: text, disabled, onChange: (event) => update(argument, event.target.value) }),
-          color !== void 0 && React2.createElement("input", { type: "color", "aria-label": `${label} ${messages.colorPicker}`, ...attributes, value: color, disabled, onChange: (event) => update(argument, event.target.value) })
+          React4.createElement("input", { "aria-label": label, ...attributes, type: "text", value: text, disabled, onChange: (event) => update(argument, event.target.value) }),
+          color !== void 0 && React4.createElement("input", { type: "color", "aria-label": `${label} ${messages.colorPicker}`, ...attributes, value: color, disabled, onChange: (event) => update(argument, event.target.value) })
         );
       } else
-        control = React2.createElement("textarea", { "aria-label": label, ...attributes, value: text, disabled, onChange: (event) => update(argument, event.target.value) });
-      return React2.createElement(
+        control = React4.createElement("textarea", { "aria-label": label, ...attributes, value: text, disabled, onChange: (event) => update(argument, event.target.value) });
+      return React4.createElement(
         "fieldset",
         { key: argument, "data-fixed-argument": argument, disabled },
-        React2.createElement("legend", null, label),
+        React4.createElement("legend", null, label),
         control,
-        input.state === "editable" && input.reset !== void 0 && React2.createElement("button", { type: "button", disabled, "aria-label": `${label} ${messages.reset}`, onClick: () => update(argument, input.reset) }, messages.reset),
-        showOriginal && React2.createElement(
+        input.state === "editable" && input.reset !== void 0 && React4.createElement("button", { type: "button", disabled, "aria-label": `${label} ${messages.reset}`, onClick: () => update(argument, input.reset) }, messages.reset),
+        showOriginal && React4.createElement(
           "p",
           { id: originalId, className: "block-editor-fixed-original", "data-fixed-original-value": "" },
           messages.currentValue,
           ": ",
-          React2.createElement("output", null, input.rawDisplay)
+          React4.createElement("output", null, input.rawDisplay)
         ),
-        invalid && React2.createElement("p", { id: errorId2, className: "block-editor-fixed-error" }, messages.invalidValue),
-        input.unverified && React2.createElement("p", { id: unverifiedId, className: "block-editor-fixed-unverified" }, messages.unverified)
+        invalid && React4.createElement("p", { id: errorId2, className: "block-editor-fixed-error" }, messages.invalidValue),
+        input.unverified && React4.createElement("p", { id: unverifiedId, className: "block-editor-fixed-unverified" }, messages.unverified)
       );
     })
   );
 }
 function mountFixedInputView(container, context, messages = defaultMessages) {
   describe(context);
-  ReactDOM2.render(React2.createElement(FixedInputView, { context, messages }), container);
+  ReactDOM2.render(React4.createElement(FixedInputView, { context, messages }), container);
   return () => {
     ReactDOM2.unmountComponentAtNode(container);
   };
@@ -17225,7 +17822,7 @@ function getTemplate(name, registry, uiOptions = {}) {
 // node_modules/.pnpm/@rjsf+utils@5.24.13_react@16.14.0/node_modules/@rjsf/utils/lib/getWidget.js
 var import_react_is = __toESM(require_react_is());
 import { jsx as _jsx } from "react/jsx-runtime.js";
-import { createElement as createElement3 } from "react";
+import { createElement as createElement5 } from "react";
 var widgetMap = {
   boolean: {
     checkbox: "CheckboxWidget",
@@ -17291,7 +17888,7 @@ function mergeWidgetOptions(AWidget) {
 }
 function getWidget(schema4, widget, registeredWidgets = {}) {
   const type = getSchemaType(schema4);
-  if (typeof widget === "function" || widget && import_react_is.default.isForwardRef(createElement3(widget)) || import_react_is.default.isMemo(widget)) {
+  if (typeof widget === "function" || widget && import_react_is.default.isForwardRef(createElement5(widget)) || import_react_is.default.isMemo(widget)) {
     return mergeWidgetOptions(widget);
   }
   if (typeof widget !== "string") {
@@ -18604,12 +19201,12 @@ var MultiSchemaField_default = AnyOfField;
 
 // node_modules/.pnpm/@rjsf+core@5.24.13_@rjsf+utils@5.24.13_react@16.14.0__react@16.14.0/node_modules/@rjsf/core/lib/components/fields/NumberField.js
 import { jsx as _jsx5 } from "react/jsx-runtime.js";
-import { useState as useState3, useCallback } from "react";
+import { useState as useState4, useCallback } from "react";
 var trailingCharMatcherWithPrefix = /\.([0-9]*0)*$/;
 var trailingCharMatcher = /[0.]0*$/;
 function NumberField(props) {
   const { registry, onChange, formData, value: initialValue } = props;
-  const [lastValue, setLastValue] = useState3(initialValue);
+  const [lastValue, setLastValue] = useState4(initialValue);
   const { StringField: StringField2 } = registry.fields;
   let value = formData;
   const handleChange = useCallback((value2, errorSchema, id) => {
@@ -19782,7 +20379,7 @@ var templates_default = templates;
 
 // node_modules/.pnpm/@rjsf+core@5.24.13_@rjsf+utils@5.24.13_react@16.14.0__react@16.14.0/node_modules/@rjsf/core/lib/components/widgets/AltDateWidget.js
 import { jsx as _jsx27, jsxs as _jsxs14 } from "react/jsx-runtime.js";
-import { useCallback as useCallback4, useEffect as useEffect4, useReducer, useState as useState4 } from "react";
+import { useCallback as useCallback4, useEffect as useEffect4, useReducer, useState as useState5 } from "react";
 function readyForChange(state) {
   return Object.values(state).every((value) => value !== -1);
 }
@@ -19793,7 +20390,7 @@ function DateElement({ type, range, value, select, rootId, name, disabled, reado
 }
 function AltDateWidget({ time = false, disabled = false, readonly = false, autofocus = false, options, id, name, registry, onBlur, onFocus, onChange, value }) {
   const { translateString } = registry;
-  const [lastValue, setLastValue] = useState4(value);
+  const [lastValue, setLastValue] = useState5(value);
   const [state, setState] = useReducer((state2, action) => {
     return { ...state2, ...action };
   }, parseDateString(value, time));
@@ -21303,17 +21900,93 @@ function fieldErrors(issues) {
 }
 
 // dist/rjsf-templates.js
-import * as React3 from "react";
-var ItemNumber = React3.createContext(1);
-var PropertyKey = React3.createContext(void 0);
+import * as React5 from "react";
+var ItemNumber = React5.createContext(1);
+var PropertyKey = React5.createContext(void 0);
+function errorCount(value) {
+  if (!value || typeof value !== "object")
+    return 0;
+  if (Array.isArray(value))
+    return value.length;
+  return Object.values(value).reduce((count, child) => count + errorCount(child), 0);
+}
+function layoutObjectTemplate(DefaultTemplate) {
+  return function LayoutObject(props) {
+    var _a, _b;
+    const enabled = useCommonLayout();
+    const title = enabled && !props.schema.title && !((_a = props.uiSchema) === null || _a === void 0 ? void 0 : _a["ui:title"]) ? propertyLabel(props.title) : props.title;
+    const view = { ...props, title };
+    const knownFields = [.../* @__PURE__ */ new Set([...Object.keys((_b = props.schema.properties) !== null && _b !== void 0 ? _b : {}), ...props.properties.map((property2) => property2.name)])];
+    const resolution = enabled ? resolveEditorLayout(props.uiSchema, knownFields) : { kind: "absent" };
+    if (resolution.kind === "absent")
+      return React5.createElement(DefaultTemplate, { ...view });
+    if (resolution.kind === "invalid")
+      return React5.createElement(
+        React5.Fragment,
+        null,
+        React5.createElement(
+          "p",
+          { role: "status", "data-layout-diagnostic": "" },
+          "\u30EC\u30A4\u30A2\u30A6\u30C8\u3092\u9069\u7528\u3067\u304D\u307E\u305B\u3093: ",
+          resolution.diagnostic
+        ),
+        React5.createElement(DefaultTemplate, { ...props })
+      );
+    const content = React5.createElement(ObjectLayout, { key: "__editor_layout__", ui: props.uiSchema, knownFields, fallback: null, fields: props.properties.map((property2) => {
+      var _a2;
+      return {
+        name: property2.name,
+        content: property2.content,
+        errors: errorCount((_a2 = props.errorSchema) === null || _a2 === void 0 ? void 0 : _a2[property2.name])
+      };
+    }) });
+    return React5.createElement(DefaultTemplate, { ...view, properties: [{ name: "__editor_layout__", content, hidden: false, disabled: !!props.disabled, readonly: !!props.readonly }] });
+  };
+}
+function compactDescriptionTemplate(DefaultTemplate) {
+  return function CompactDescription(props) {
+    const enabled = useCommonLayout();
+    return enabled && typeof props.description === "string" ? React5.createElement(FormHelp, { id: props.id, description: props.description }) : React5.createElement(DefaultTemplate, { ...props });
+  };
+}
+function compactArrayTitleTemplate(DefaultTemplate) {
+  return function CompactArrayTitle(props) {
+    var _a;
+    const enabled = useCommonLayout();
+    if (!enabled || !props.title || props.schema.title || ((_a = props.uiSchema) === null || _a === void 0 ? void 0 : _a["ui:title"]))
+      return React5.createElement(DefaultTemplate, { ...props });
+    return React5.createElement(DefaultTemplate, { ...props, title: propertyLabel(props.title) });
+  };
+}
+function compactArrayTemplate(DefaultTemplate) {
+  return function CompactArray(props) {
+    const enabled = useCommonLayout();
+    return React5.createElement(
+      React5.Fragment,
+      null,
+      React5.createElement(DefaultTemplate, { ...props }),
+      enabled && props.items.length === 0 && React5.createElement("p", { className: "editor-form-hint" }, "\u9805\u76EE\u306A\u3057")
+    );
+  };
+}
+function compactCheckboxWidget(DefaultWidget) {
+  return function CompactCheckbox(props) {
+    var _a;
+    const enabled = useCommonLayout();
+    const label = enabled && !props.schema.title && !((_a = props.uiSchema) === null || _a === void 0 ? void 0 : _a["ui:title"]) && !props.options.title ? propertyLabel(props.label) : props.label;
+    return React5.createElement(DefaultWidget, { ...props, label });
+  };
+}
 function valueFieldTemplate(DefaultTemplate, flag) {
   return function ValueField2(props) {
+    var _a;
+    const enabled = useCommonLayout();
     if (!(flag in props.schema))
-      return React3.createElement(DefaultTemplate, { ...props });
-    return React3.createElement(
+      return React5.createElement(DefaultTemplate, { ...props, label: enabled && !props.schema.title && !((_a = props.uiSchema) === null || _a === void 0 ? void 0 : _a["ui:title"]) ? propertyLabel(props.label) : props.label });
+    return React5.createElement(
       PropertyKey.Provider,
       { value: props.label },
-      React3.createElement(DefaultTemplate, { ...props, label: "\u5024" })
+      React5.createElement(DefaultTemplate, { ...props, label: "\u5024" })
     );
   };
 }
@@ -21325,49 +21998,49 @@ function numberedObjectTemplate(DefaultTemplate, flag) {
       const schema4 = (_a = props.schema.properties) === null || _a === void 0 ? void 0 : _a[property2.name];
       if (!schema4 || typeof schema4 !== "object" || !(flag in schema4) || property2.hidden)
         return property2;
-      return { ...property2, content: React3.createElement(ItemNumber.Provider, { key: property2.name, value: ++number }, property2.content) };
+      return { ...property2, content: React5.createElement(ItemNumber.Provider, { key: property2.name, value: ++number }, property2.content) };
     });
-    return React3.createElement(DefaultTemplate, { ...props, properties });
+    return React5.createElement(DefaultTemplate, { ...props, properties });
   };
 }
 function additionalItemTemplate(flag) {
   return function AdditionalItem2(props) {
-    const number = React3.useContext(ItemNumber);
-    const propertyKey = React3.useContext(PropertyKey);
+    const number = React5.useContext(ItemNumber);
+    const propertyKey = React5.useContext(PropertyKey);
     const { id, classNames, style, children, schema: schema4, label, disabled, readonly, onKeyChange, onDropPropertyClick } = props;
     if (!(flag in schema4))
-      return React3.createElement("div", { className: classNames, style }, children);
+      return React5.createElement("div", { className: classNames, style }, children);
     const key = propertyKey !== null && propertyKey !== void 0 ? propertyKey : label;
-    return React3.createElement(
+    return React5.createElement(
       "div",
       { className: classNames, style, "data-block-editor-item": "" },
-      React3.createElement(
+      React5.createElement(
         "div",
         { "data-block-editor-item-heading": "" },
-        React3.createElement(
+        React5.createElement(
           "span",
           null,
           "\u30FB\u9805\u76EE",
           number
         ),
-        React3.createElement(ItemMenu, { disabled: disabled || readonly, onClick: onDropPropertyClick(key) })
+        React5.createElement(ItemMenu, { disabled: disabled || readonly, onClick: onDropPropertyClick(key) })
       ),
-      React3.createElement(
+      React5.createElement(
         "div",
         { "data-block-editor-pair-row": "" },
-        React3.createElement("label", { htmlFor: `${id}-key` }, "\u30AD\u30FC"),
-        React3.createElement("input", { id: `${id}-key`, type: "text", defaultValue: key, disabled, readOnly: readonly, onBlur: (event) => onKeyChange(event.target.value) })
+        React5.createElement("label", { htmlFor: `${id}-key` }, "\u30AD\u30FC"),
+        React5.createElement("input", { id: `${id}-key`, type: "text", defaultValue: key, disabled, readOnly: readonly, onBlur: (event) => onKeyChange(event.target.value) })
       ),
-      React3.createElement("div", { "data-block-editor-pair-row": "" }, children)
+      React5.createElement("div", { "data-block-editor-pair-row": "" }, children)
     );
   };
 }
 function ItemMenu({ disabled, onClick }) {
-  const [open, setOpen] = React3.useState(false);
-  const container = React3.useRef(null);
-  const trigger = React3.useRef(null);
-  const item = React3.useRef(null);
-  React3.useEffect(() => {
+  const [open, setOpen] = React5.useState(false);
+  const container = React5.useRef(null);
+  const trigger = React5.useRef(null);
+  const item = React5.useRef(null);
+  React5.useEffect(() => {
     var _a;
     if (!open)
       return;
@@ -21394,11 +22067,11 @@ function ItemMenu({ disabled, onClick }) {
       document.removeEventListener("mousedown", closeOutside);
     };
   }, [open]);
-  React3.useEffect(() => {
+  React5.useEffect(() => {
     if (disabled)
       setOpen(false);
   }, [disabled]);
-  return React3.createElement(
+  return React5.createElement(
     "div",
     { "data-block-editor-item-menu": "", ref: container, onBlur: (event) => {
       if (!event.currentTarget.contains(event.relatedTarget))
@@ -21418,11 +22091,11 @@ function ItemMenu({ disabled, onClick }) {
           setOpen(true);
       }
     } },
-    React3.createElement("button", { "aria-label": "\u9805\u76EE\u306E\u30E1\u30CB\u30E5\u30FC", "aria-haspopup": "menu", "aria-expanded": open && !disabled, disabled, ref: trigger, type: "button", onClick: () => setOpen(!open) }, "\u2026"),
-    open && !disabled ? React3.createElement(
+    React5.createElement("button", { "aria-label": "\u9805\u76EE\u306E\u30E1\u30CB\u30E5\u30FC", "aria-haspopup": "menu", "aria-expanded": open && !disabled, disabled, ref: trigger, type: "button", onClick: () => setOpen(!open) }, "\u2026"),
+    open && !disabled ? React5.createElement(
       "div",
       { role: "menu", "aria-label": "\u9805\u76EE\u306E\u64CD\u4F5C" },
-      React3.createElement("button", { ref: item, role: "menuitem", type: "button", onClick: (event) => {
+      React5.createElement("button", { ref: item, role: "menuitem", type: "button", onClick: (event) => {
         var _a;
         setOpen(false);
         (_a = trigger.current) === null || _a === void 0 ? void 0 : _a.focus();
@@ -21432,34 +22105,34 @@ function ItemMenu({ disabled, onClick }) {
   );
 }
 function AddItemButton({ disabled, onClick, className }) {
-  return React3.createElement("button", { className, "data-block-editor-add-item": "", disabled, type: "button", onClick }, "\u2795\u9805\u76EE\u3092\u8FFD\u52A0");
+  return React5.createElement("button", { className, "data-block-editor-add-item": "", disabled, type: "button", onClick }, "\u2795\u9805\u76EE\u3092\u8FFD\u52A0");
 }
 function ArrayItem(props) {
   const { children, className, disabled, readonly, index, hasMoveUp, hasMoveDown, hasCopy, hasRemove, onReorderClick, onCopyIndexClick, onDropIndexClick } = props;
   const locked = disabled || readonly;
-  return React3.createElement(
+  return React5.createElement(
     "div",
     { className, "data-block-editor-item": "" },
-    React3.createElement(
+    React5.createElement(
       "div",
       { "data-block-editor-item-heading": "" },
-      React3.createElement(
+      React5.createElement(
         "span",
         null,
         "\u30FB\u9805\u76EE",
         index + 1
       ),
-      React3.createElement(
+      React5.createElement(
         "div",
         { "data-block-editor-item-actions": "" },
-        hasMoveUp || hasMoveDown ? React3.createElement(
-          React3.Fragment,
+        hasMoveUp || hasMoveDown ? React5.createElement(
+          React5.Fragment,
           null,
-          React3.createElement("button", { "aria-label": "\u9805\u76EE\u3092\u4E0A\u3078\u79FB\u52D5", disabled: locked || !hasMoveUp, type: "button", onClick: onReorderClick(index, index - 1) }, "\u2191"),
-          React3.createElement("button", { "aria-label": "\u9805\u76EE\u3092\u4E0B\u3078\u79FB\u52D5", disabled: locked || !hasMoveDown, type: "button", onClick: onReorderClick(index, index + 1) }, "\u2193")
+          React5.createElement("button", { "aria-label": "\u9805\u76EE\u3092\u4E0A\u3078\u79FB\u52D5", disabled: locked || !hasMoveUp, type: "button", onClick: onReorderClick(index, index - 1) }, "\u2191"),
+          React5.createElement("button", { "aria-label": "\u9805\u76EE\u3092\u4E0B\u3078\u79FB\u52D5", disabled: locked || !hasMoveDown, type: "button", onClick: onReorderClick(index, index + 1) }, "\u2193")
         ) : null,
-        hasCopy ? React3.createElement("button", { disabled: locked, type: "button", onClick: onCopyIndexClick(index) }, "\u9805\u76EE\u3092\u8907\u88FD") : null,
-        hasRemove ? React3.createElement(ItemMenu, { disabled: locked, onClick: onDropIndexClick(index) }) : null
+        hasCopy ? React5.createElement("button", { disabled: locked, type: "button", onClick: onCopyIndexClick(index) }, "\u9805\u76EE\u3092\u8907\u88FD") : null,
+        hasRemove ? React5.createElement(ItemMenu, { disabled: locked, onClick: onDropIndexClick(index) }) : null
       )
     ),
     children
@@ -21475,11 +22148,15 @@ var Form2 = moduleExports4(lib_exports2).default;
 var { getDefaultFormState: getDefaultFormState2, ADDITIONAL_PROPERTY_FLAG: ADDITIONAL_PROPERTY_FLAG2 } = moduleExports4(lib_exports);
 var { customizeValidator: customizeValidator2 } = moduleExports4(lib_exports3);
 var defaultTemplates = moduleExports4(lib_exports2).getDefaultRegistry().templates;
-var ObjectItems = numberedObjectTemplate(defaultTemplates.ObjectFieldTemplate, ADDITIONAL_PROPERTY_FLAG2);
+var ObjectItems = numberedObjectTemplate(layoutObjectTemplate(defaultTemplates.ObjectFieldTemplate), ADDITIONAL_PROPERTY_FLAG2);
 var AdditionalItem = additionalItemTemplate(ADDITIONAL_PROPERTY_FLAG2);
 var ValueField = valueFieldTemplate(defaultTemplates.FieldTemplate, ADDITIONAL_PROPERTY_FLAG2);
+var Description = compactDescriptionTemplate(defaultTemplates.DescriptionFieldTemplate);
+var ArrayTitle = compactArrayTitleTemplate(defaultTemplates.ArrayFieldTitleTemplate);
+var ArrayBody = compactArrayTemplate(defaultTemplates.ArrayFieldTemplate);
+var Checkbox = compactCheckboxWidget(moduleExports4(lib_exports2).getDefaultRegistry().widgets.CheckboxWidget);
 var nextViewId = 0;
-function createSchemaBundleEditor(options) {
+function createSchemaBundleEditor(options, features = {}) {
   const { schemaBundle, validationContext: provider, ownerValidate, apiVersion, extensionId, editorId, opcodes, argument, format, uiSchema, validateData } = options;
   let bundle;
   try {
@@ -21524,9 +22201,10 @@ function createSchemaBundleEditor(options) {
     ...format === void 0 ? {} : { format },
     ...uiSchema === void 0 ? {} : { uiSchema },
     ...validateData === void 0 ? {} : { validateData }
-  }, { issuesFor, dialect: result.validator.dialect });
+  }, { issuesFor, dialect: result.validator.dialect }, captureFeatureFlags(features));
 }
 function createBlockEditorService(options) {
+  const features = captureFeatureFlags(options);
   if ((options === null || options === void 0 ? void 0 : options.fixedInputs) !== void 0 && typeof options.fixedInputs !== "boolean")
     throw new TypeError("Invalid fixed input capability option.");
   const messageSource = options === null || options === void 0 ? void 0 : options.fixedInputMessages;
@@ -21557,7 +22235,7 @@ function createBlockEditorService(options) {
     apiVersion: EDITOR_API_VERSION,
     register: (definition) => {
       const custom = definition;
-      const editor = !custom.mount && Object.hasOwn(definition, "schema") ? createSchemaEditor(definition) : custom;
+      const editor = !custom.mount && Object.hasOwn(definition, "schema") ? createSchemaEditor(definition, features) : custom;
       if (typeof editor.mount !== "function")
         throw new TypeError("A block editor must provide mount().");
       const remove = registry.register(editor);
@@ -21571,10 +22249,10 @@ function createBlockEditorService(options) {
         notify();
       };
     },
-    registerSchema: (definition) => api.register(createSchemaEditor(definition)),
-    registerSchemaBundle: (definition) => api.register(createSchemaBundleEditor(definition)),
+    registerSchema: (definition) => api.register(createSchemaEditor(definition, features)),
+    registerSchemaBundle: (definition) => api.register(createSchemaBundleEditor(definition, features)),
     registerSourceEditor: (definition) => {
-      const remove = registry.registerPrepared(createSourceEditor(definition));
+      const remove = registry.registerPrepared(createSourceEditor(definition, features));
       notify();
       let active = true;
       return () => {
@@ -21593,10 +22271,10 @@ function createBlockEditorService(options) {
     };
   } };
 }
-function createSchemaEditor(options) {
-  return createSchemaEditorImpl(options);
+function createSchemaEditor(options, features = {}) {
+  return createSchemaEditorImpl(options, void 0, captureFeatureFlags(features));
 }
-function createSchemaEditorImpl(options, bundle) {
+function createSchemaEditorImpl(options, bundle, features = captureFeatureFlags()) {
   var _a, _b;
   if (options.apiVersion !== EDITOR_API_VERSION || typeof options.argument !== "string" || !options.argument) {
     throw new TypeError("A supported API version and JSON argument name are required.");
@@ -21606,7 +22284,7 @@ function createSchemaEditorImpl(options, bundle) {
   if (format !== "json" && format !== "yaml")
     throw new TypeError("Unsupported source format.");
   const schema4 = cloneJson(options.schema);
-  const uiSchema = options.uiSchema ? cloneJson(options.uiSchema) : {};
+  const uiSchema = options.uiSchema ? snapshotJson(options.uiSchema) : {};
   const validateData = options.validateData;
   const validator = customizeValidator2({
     ...(bundle === null || bundle === void 0 ? void 0 : bundle.dialect) === "2020-12" ? { AjvClass: import__3.Ajv2020 } : {},
@@ -21675,11 +22353,15 @@ function createSchemaEditorImpl(options, bundle) {
           uiSchema,
           validator,
           idPrefix,
+          widgets: { CheckboxWidget: Checkbox },
           templates: {
             ArrayFieldItemTemplate: ArrayItem,
+            ArrayFieldTitleTemplate: ArrayTitle,
+            ArrayFieldTemplate: ArrayBody,
             ObjectFieldTemplate: ObjectItems,
             WrapIfAdditionalTemplate: AdditionalItem,
             FieldTemplate: ValueField,
+            DescriptionFieldTemplate: Description,
             ButtonTemplates: { AddButton: AddItemButton, RemoveButton: ItemMenu }
           },
           formData: dataFor(context.getDraft()),
@@ -21702,7 +22384,7 @@ function createSchemaEditorImpl(options, bundle) {
             context.setValidationIssues(issuesFor(data));
           }
         };
-        ReactDOM3.render(React4.createElement(Form2, props, React4.createElement("span", { hidden: true })), container);
+        ReactDOM3.render(React6.createElement(LayoutHost, { enabled: features.commonLayout, context, children: React6.createElement(Form2, props, React6.createElement("span", { hidden: true })) }), container);
       };
       const schedule = () => {
         if (scheduled || !active)