@jxsuite/studio 4.1.0 → 5.1.0

package/dist/chunks/studio-b4s9eykd.js

@@ -0,0 +1,2811 @@
+import {
+  loadFormats2,
+  formatByName2,
+  formatForPath2,
+  defaultContentFormat2,
+  formatSerialize2
+} from "./studio-vw7mzp6z.js";
+import {
+  effectScope,
+  effect,
+  reactive,
+  notify2
+} from "./studio-p1dw8wfw.js";
+import {
+  projectState
+} from "./studio-6ewqv390.js";
+import {
+  recordDocOp,
+  transactDoc,
+  mutateUpdateFrontmatter,
+  stringArg,
+  booleanArg,
+  enumArg,
+  argsSchema,
+  derivedEnumProperty,
+  booleanProperty,
+  stringProperty,
+  LOCALE_PLACEHOLDER,
+  collectionForDirectory,
+  camelToLabel,
+  toCamelCase,
+  workspace2,
+  activeTab2,
+  activateTab2
+} from "./studio-k75n7vhp.js";
+import {
+  errorMessage2
+} from "./studio-yxa81f45.js";
+import {
+  activeRegistry
+} from "./studio-kkqkcp3d.js";
+import {
+  paneRegion,
+  registerSurface,
+  mountSurface
+} from "./studio-vfq8qpjt.js";
+import {
+  registerFormControl,
+  referenceTarget,
+  mountSchemaForm,
+  resolveContextPointer
+} from "./studio-js8nv53n.js";
+import {
+  DRAFT_FIELD,
+  DRAFT_MEANING,
+  isDraftEntry,
+  hasDraftAxis,
+  setIncludeDrafts,
+  reloadDraftAwareGrids2
+} from "./studio-1knfqgy7.js";
+import {
+  serializeJson
+} from "./studio-qk90fgqm.js";
+import {
+  notePreviewOverlayEdit
+} from "./studio-gb13095a.js";
+import {
+  entryCollection,
+  entryCollections,
+  collectionOfPath,
+  seedEntry,
+  missingRequired
+} from "./studio-qhhm6hbt.js";
+import {
+  cloneValue2
+} from "./studio-727xh0e3.js";
+import {
+  __preload
+} from "./studio-5te5tqng.js";
+
+// src/settings/schema-field-ui.ts
+var FIELD_TYPES = ["string", "number", "boolean", "array", "object", "reference"];
+var FORMAT_OPTIONS = ["", "image", "date", "color"];
+function detectFieldType(schema) {
+  if (schema.$ref) {
+    return "reference";
+  }
+  return schema.type || "string";
+}
+function detectFieldFormat(schema) {
+  if (schema.type === "array" && schema.items?.format) {
+    return schema.items.format;
+  }
+  return schema.format || "";
+}
+function schemaForType(type, format) {
+  switch (type) {
+    case "number": {
+      return { type: "number" };
+    }
+    case "boolean": {
+      return { type: "boolean" };
+    }
+    case "array": {
+      return format ? { items: { format, type: "string" }, type: "array" } : { items: { type: "string" }, type: "array" };
+    }
+    case "object": {
+      return { properties: {}, required: [], type: "object" };
+    }
+    case "reference": {
+      return { $ref: "#/content/" };
+    }
+    default: {
+      return format ? { format, type: "string" } : { type: "string" };
+    }
+  }
+}
+// src/surfaces/schema-builder.json
+var schema_builder_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioSchemaBuilder",
+  $description: 'The `schema-builder` form control (specs/extensions.md §9.1): the visual editor for a JSON Schema object, drawn as one card per property. A descriptor names it with `"ui": { "<prop>": { "control": "schema-builder" } }`, and `ui/schema-form.ts` mounts it into the empty host its own document announces for that field. The adapter (`surfaces/schema-builder.ts`) hands in the fields already classified and every draft the reader is part-way through typing; `ui/form-controls.ts` decides what a field may be renamed to and what reaches the host\'s `onChange`. Nothing here reads a schema: a document that re-derived a field\'s type while drawing would be a second opinion about what one module already owns. **The card is `surfaces/settings-defs.json`\'s, part for part.** Data Shapes edits the project\'s `$defs` and this edits a content type\'s `schema`; they are the same object with the same six controls per row, so the row vocabulary — `card`, `field-row`, `field-label`, `field-name`, `field-type`, `field-format`, `field-required`, `field-delete`, `nested`, `nested-card`, `nested-add-name`/`-type`/`-button`, `ref-target`, `add-form` — is ONE vocabulary, and the row views it is drawn from are that surface\'s own types rather than a second declaration of them. What differs is only what encloses it: Data Shapes carries the two-column chrome that chooses WHICH shape is being edited, and this one is handed the object to edit.',
+  tagName: "div",
+  attributes: {
+    part: "builder"
+  },
+  style: {
+    $description: "What `.schema-builder`, `.schema-field-list`, `.schema-field-card`, `.schema-field-row`, `.schema-field-nested`, `.schema-field-name-input`, `.schema-nested-add`, `.schema-nested-add-name` and `.schema-add-field` said in `styles/overlays.css`, keyed on `part` and re-pointed at the studio token layer — the same translation `surfaces/settings-defs.json` carries, because it is the same card. Two values could not come with them. `.schema-field-card--nested` read `var(--spectrum-gray-300, #444)`, and the caption was an `sp-field-label` at whatever size Spectrum drew it; a document is mounted in the pane rather than inside `<sp-theme>`, so both would have taken their hard-coded fallback every time. The nested card takes the studio layer's `--border`, and the caption says what it is in the type ramp instead.",
+    display: "block",
+    '& [part="fields"]': {
+      display: "flex",
+      flexDirection: "column",
+      gap: "4px",
+      marginBottom: "12px"
+    },
+    '& [part="card"], & [part="nested-card"]': {
+      border: "1px solid var(--border)",
+      borderRadius: "var(--radius)",
+      padding: "6px 10px"
+    },
+    '& [part="field-row"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "8px"
+    },
+    '& [part="field-label"]': {
+      $description: "The field's name in words: a caption on the row rather than a label for a control, since the raw key beside it is what the reader edits and what carries the accessible name.",
+      flex: "none",
+      minWidth: "84px",
+      fontSize: "var(--jx-text-sm)",
+      color: "var(--fg-dim)",
+      overflowWrap: "anywhere"
+    },
+    '& [part="field-name"]': {
+      flex: "1",
+      maxWidth: "140px"
+    },
+    '& [part="nested"]': {
+      marginLeft: "16px",
+      marginTop: "6px",
+      paddingLeft: "8px",
+      borderLeft: "2px solid var(--border)",
+      display: "flex",
+      flexDirection: "column",
+      gap: "4px"
+    },
+    '& [part="ref-target"]': {
+      display: "flex",
+      marginTop: "6px",
+      maxWidth: "220px"
+    },
+    '& [part="nested-add"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "6px",
+      padding: "4px 0"
+    },
+    '& [part="nested-add-name"]': {
+      flex: "1",
+      maxWidth: "120px"
+    },
+    '& [part="add-form"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "8px",
+      padding: "8px 0"
+    }
+  },
+  children: [
+    {
+      tagName: "div",
+      attributes: {
+        part: "fields"
+      },
+      children: [
+        {
+          $prototype: "Array",
+          items: {
+            $ref: "#/state/fields"
+          },
+          key: {
+            $ref: "$map/item/key"
+          },
+          map: {
+            tagName: "div",
+            attributes: {
+              part: "card",
+              "data-field": "${$map.item.key}"
+            },
+            children: [
+              {
+                tagName: "div",
+                attributes: {
+                  part: "field-row"
+                },
+                children: [
+                  {
+                    tagName: "span",
+                    attributes: {
+                      part: "field-label"
+                    },
+                    textContent: "${$map.item.label}"
+                  },
+                  {
+                    tagName: "jx-textfield",
+                    attributes: {
+                      part: "field-name"
+                    },
+                    $props: {
+                      label: "Name for ${$map.item.label}",
+                      size: "sm",
+                      value: {
+                        $ref: "$map/item/name"
+                      }
+                    },
+                    onchange: {
+                      $prototype: "Function",
+                      body: [
+                        {
+                          operator: "call",
+                          target: {
+                            $ref: "#/state/renameField"
+                          },
+                          value: [
+                            {
+                              $ref: "$map/item/key"
+                            },
+                            {
+                              $ref: "event#/target/value"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    tagName: "jx-select",
+                    attributes: {
+                      part: "field-type"
+                    },
+                    $props: {
+                      label: "Type for ${$map.item.label}",
+                      size: "sm",
+                      options: {
+                        $ref: "#/state/typeOptions"
+                      },
+                      value: {
+                        $ref: "$map/item/type"
+                      }
+                    },
+                    onchange: {
+                      $prototype: "Function",
+                      body: [
+                        {
+                          operator: "call",
+                          target: {
+                            $ref: "#/state/setType"
+                          },
+                          value: [
+                            {
+                              $ref: "$map/item/key"
+                            },
+                            {
+                              $ref: "event#/target/value"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  },
+                  {
+                    tagName: "div",
+                    attributes: {
+                      part: "format-slot",
+                      role: "none"
+                    },
+                    style: {
+                      display: "contents"
+                    },
+                    $switch: {
+                      $ref: "$map/item/hasFormat"
+                    },
+                    cases: {
+                      true: {
+                        tagName: "jx-select",
+                        attributes: {
+                          part: "field-format"
+                        },
+                        $props: {
+                          label: "Format for ${$map.item.label}",
+                          size: "sm",
+                          options: {
+                            $ref: "#/state/formatOptions"
+                          },
+                          value: {
+                            $ref: "$map/item/format"
+                          }
+                        },
+                        onchange: {
+                          $prototype: "Function",
+                          body: [
+                            {
+                              operator: "call",
+                              target: {
+                                $ref: "#/state/setFormat"
+                              },
+                              value: [
+                                {
+                                  $ref: "$map/item/key"
+                                },
+                                {
+                                  $ref: "event#/target/value"
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      }
+                    }
+                  },
+                  {
+                    tagName: "jx-switch",
+                    $description: "Whether the object requires this field. The word on screen is the name: `Req` is slotted rather than passed as `label`, because the kit's switch wraps its control in the label the slot lands in, and a second name would be announced over the top of it. Which row it belongs to is the tooltip's job instead, which is what `hint` is.",
+                    attributes: {
+                      part: "field-required"
+                    },
+                    $props: {
+                      hint: "Require ${$map.item.label}",
+                      size: "sm",
+                      checked: {
+                        $ref: "$map/item/required"
+                      }
+                    },
+                    onchange: {
+                      $prototype: "Function",
+                      body: [
+                        {
+                          operator: "call",
+                          target: {
+                            $ref: "#/state/setRequired"
+                          },
+                          value: [
+                            {
+                              $ref: "$map/item/key"
+                            },
+                            {
+                              $ref: "event#/target/checked"
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    children: [
+                      {
+                        tagName: "span",
+                        textContent: "Req"
+                      }
+                    ]
+                  },
+                  {
+                    tagName: "jx-action-button",
+                    attributes: {
+                      part: "field-delete"
+                    },
+                    $props: {
+                      label: "Delete ${$map.item.label}",
+                      hint: "Delete ${$map.item.label}",
+                      icon: "trash",
+                      quiet: true,
+                      size: "sm"
+                    },
+                    onclick: {
+                      $prototype: "Function",
+                      body: [
+                        {
+                          operator: "call",
+                          target: {
+                            $ref: "#/state/removeField"
+                          },
+                          value: [
+                            {
+                              $ref: "$map/item/key"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                ]
+              },
+              {
+                tagName: "div",
+                attributes: {
+                  part: "extra-slot",
+                  role: "none"
+                },
+                style: {
+                  display: "contents"
+                },
+                $switch: {
+                  $ref: "$map/item/extra"
+                },
+                cases: {
+                  reference: {
+                    tagName: "div",
+                    attributes: {
+                      part: "ref-target"
+                    },
+                    children: [
+                      {
+                        tagName: "jx-select",
+                        attributes: {
+                          part: "ref-target-select"
+                        },
+                        $props: {
+                          label: "Target for ${$map.item.label}",
+                          size: "sm",
+                          options: {
+                            $ref: "#/state/targets"
+                          },
+                          value: {
+                            $ref: "$map/item/refTarget"
+                          }
+                        },
+                        onchange: {
+                          $prototype: "Function",
+                          body: [
+                            {
+                              operator: "call",
+                              target: {
+                                $ref: "#/state/setTarget"
+                              },
+                              value: [
+                                {
+                                  $ref: "$map/item/key"
+                                },
+                                {
+                                  $ref: "event#/target/value"
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      }
+                    ]
+                  },
+                  nested: {
+                    tagName: "div",
+                    attributes: {
+                      part: "nested"
+                    },
+                    children: [
+                      {
+                        $prototype: "Array",
+                        items: {
+                          $ref: "$map/item/children"
+                        },
+                        key: {
+                          $ref: "$map/item/key"
+                        },
+                        map: {
+                          tagName: "div",
+                          attributes: {
+                            part: "nested-card",
+                            "data-nested": "${$map.item.key}"
+                          },
+                          children: [
+                            {
+                              tagName: "div",
+                              attributes: {
+                                part: "field-row"
+                              },
+                              children: [
+                                {
+                                  tagName: "jx-textfield",
+                                  attributes: {
+                                    part: "field-name"
+                                  },
+                                  $props: {
+                                    label: "Name for ${$map.item.parent}.${$map.item.key}",
+                                    size: "sm",
+                                    value: {
+                                      $ref: "$map/item/name"
+                                    }
+                                  },
+                                  onchange: {
+                                    $prototype: "Function",
+                                    body: [
+                                      {
+                                        operator: "call",
+                                        target: {
+                                          $ref: "#/state/renameNested"
+                                        },
+                                        value: [
+                                          {
+                                            $ref: "$map/item/parent"
+                                          },
+                                          {
+                                            $ref: "$map/item/key"
+                                          },
+                                          {
+                                            $ref: "event#/target/value"
+                                          }
+                                        ]
+                                      }
+                                    ]
+                                  }
+                                },
+                                {
+                                  tagName: "jx-select",
+                                  attributes: {
+                                    part: "field-type"
+                                  },
+                                  $props: {
+                                    label: "Type for ${$map.item.parent}.${$map.item.key}",
+                                    size: "sm",
+                                    options: {
+                                      $ref: "#/state/typeOptions"
+                                    },
+                                    value: {
+                                      $ref: "$map/item/type"
+                                    }
+                                  },
+                                  onchange: {
+                                    $prototype: "Function",
+                                    body: [
+                                      {
+                                        operator: "call",
+                                        target: {
+                                          $ref: "#/state/setNestedType"
+                                        },
+                                        value: [
+                                          {
+                                            $ref: "$map/item/parent"
+                                          },
+                                          {
+                                            $ref: "$map/item/key"
+                                          },
+                                          {
+                                            $ref: "event#/target/value"
+                                          }
+                                        ]
+                                      }
+                                    ]
+                                  }
+                                },
+                                {
+                                  tagName: "div",
+                                  attributes: {
+                                    part: "format-slot",
+                                    role: "none"
+                                  },
+                                  style: {
+                                    display: "contents"
+                                  },
+                                  $switch: {
+                                    $ref: "$map/item/hasFormat"
+                                  },
+                                  cases: {
+                                    true: {
+                                      tagName: "jx-select",
+                                      attributes: {
+                                        part: "field-format"
+                                      },
+                                      $props: {
+                                        label: "Format for ${$map.item.parent}.${$map.item.key}",
+                                        size: "sm",
+                                        options: {
+                                          $ref: "#/state/formatOptions"
+                                        },
+                                        value: {
+                                          $ref: "$map/item/format"
+                                        }
+                                      },
+                                      onchange: {
+                                        $prototype: "Function",
+                                        body: [
+                                          {
+                                            operator: "call",
+                                            target: {
+                                              $ref: "#/state/setNestedFormat"
+                                            },
+                                            value: [
+                                              {
+                                                $ref: "$map/item/parent"
+                                              },
+                                              {
+                                                $ref: "$map/item/key"
+                                              },
+                                              {
+                                                $ref: "event#/target/value"
+                                              }
+                                            ]
+                                          }
+                                        ]
+                                      }
+                                    }
+                                  }
+                                },
+                                {
+                                  tagName: "jx-switch",
+                                  attributes: {
+                                    part: "field-required"
+                                  },
+                                  $props: {
+                                    hint: "Require ${$map.item.parent}.${$map.item.key}",
+                                    size: "sm",
+                                    checked: {
+                                      $ref: "$map/item/required"
+                                    }
+                                  },
+                                  onchange: {
+                                    $prototype: "Function",
+                                    body: [
+                                      {
+                                        operator: "call",
+                                        target: {
+                                          $ref: "#/state/setNestedRequired"
+                                        },
+                                        value: [
+                                          {
+                                            $ref: "$map/item/parent"
+                                          },
+                                          {
+                                            $ref: "$map/item/key"
+                                          },
+                                          {
+                                            $ref: "event#/target/checked"
+                                          }
+                                        ]
+                                      }
+                                    ]
+                                  },
+                                  children: [
+                                    {
+                                      tagName: "span",
+                                      textContent: "Req"
+                                    }
+                                  ]
+                                },
+                                {
+                                  tagName: "jx-action-button",
+                                  attributes: {
+                                    part: "field-delete"
+                                  },
+                                  $props: {
+                                    label: "Delete ${$map.item.parent}.${$map.item.key}",
+                                    hint: "Delete ${$map.item.parent}.${$map.item.key}",
+                                    icon: "trash",
+                                    quiet: true,
+                                    size: "sm"
+                                  },
+                                  onclick: {
+                                    $prototype: "Function",
+                                    body: [
+                                      {
+                                        operator: "call",
+                                        target: {
+                                          $ref: "#/state/removeNested"
+                                        },
+                                        value: [
+                                          {
+                                            $ref: "$map/item/parent"
+                                          },
+                                          {
+                                            $ref: "$map/item/key"
+                                          }
+                                        ]
+                                      }
+                                    ]
+                                  }
+                                }
+                              ]
+                            }
+                          ]
+                        }
+                      },
+                      {
+                        tagName: "div",
+                        attributes: {
+                          part: "nested-add"
+                        },
+                        children: [
+                          {
+                            tagName: "jx-textfield",
+                            attributes: {
+                              part: "nested-add-name"
+                            },
+                            $props: {
+                              label: "New field in ${$map.item.label}",
+                              placeholder: "field name",
+                              size: "sm",
+                              value: {
+                                $ref: "$map/item/draftName"
+                              }
+                            },
+                            oninput: {
+                              $prototype: "Function",
+                              body: [
+                                {
+                                  operator: "call",
+                                  target: {
+                                    $ref: "#/state/editDraftName"
+                                  },
+                                  value: [
+                                    {
+                                      $ref: "$map/item/key"
+                                    },
+                                    {
+                                      $ref: "event#/target/value"
+                                    }
+                                  ]
+                                }
+                              ]
+                            },
+                            onkeydown: {
+                              $prototype: "Function",
+                              body: [
+                                {
+                                  $switch: {
+                                    $ref: "event#/key"
+                                  },
+                                  cases: {
+                                    Enter: [
+                                      {
+                                        preventDefault: true
+                                      },
+                                      {
+                                        operator: "call",
+                                        target: {
+                                          $ref: "#/state/addNested"
+                                        },
+                                        value: [
+                                          {
+                                            $ref: "$map/item/key"
+                                          }
+                                        ]
+                                      }
+                                    ]
+                                  }
+                                }
+                              ]
+                            }
+                          },
+                          {
+                            tagName: "jx-select",
+                            attributes: {
+                              part: "nested-add-type"
+                            },
+                            $props: {
+                              label: "Type of the new field in ${$map.item.label}",
+                              size: "sm",
+                              options: {
+                                $ref: "#/state/typeOptions"
+                              },
+                              value: {
+                                $ref: "$map/item/draftType"
+                              }
+                            },
+                            onchange: {
+                              $prototype: "Function",
+                              body: [
+                                {
+                                  operator: "call",
+                                  target: {
+                                    $ref: "#/state/editDraftType"
+                                  },
+                                  value: [
+                                    {
+                                      $ref: "$map/item/key"
+                                    },
+                                    {
+                                      $ref: "event#/target/value"
+                                    }
+                                  ]
+                                }
+                              ]
+                            }
+                          },
+                          {
+                            tagName: "jx-action-button",
+                            attributes: {
+                              part: "nested-add-button"
+                            },
+                            $props: {
+                              label: "Add a field to ${$map.item.label}",
+                              hint: "Add a field to ${$map.item.label}",
+                              icon: "plus",
+                              quiet: true,
+                              size: "sm"
+                            },
+                            onclick: {
+                              $prototype: "Function",
+                              body: [
+                                {
+                                  operator: "call",
+                                  target: {
+                                    $ref: "#/state/addNested"
+                                  },
+                                  value: [
+                                    {
+                                      $ref: "$map/item/key"
+                                    }
+                                  ]
+                                }
+                              ]
+                            }
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              }
+            ]
+          }
+        }
+      ]
+    },
+    {
+      tagName: "div",
+      attributes: {
+        part: "add-slot",
+        role: "none"
+      },
+      style: {
+        display: "contents"
+      },
+      $switch: {
+        $ref: "#/state/addState"
+      },
+      cases: {
+        closed: {
+          tagName: "jx-action-button",
+          attributes: {
+            part: "add-open"
+          },
+          $props: {
+            label: "Add Field",
+            icon: "plus",
+            quiet: true,
+            size: "sm"
+          },
+          onclick: {
+            $prototype: "Function",
+            body: [
+              {
+                operator: "call",
+                target: {
+                  $ref: "#/state/openAdd"
+                },
+                value: []
+              }
+            ]
+          },
+          children: [
+            {
+              tagName: "span",
+              textContent: "Add Field"
+            }
+          ]
+        },
+        open: {
+          tagName: "div",
+          attributes: {
+            part: "add-form"
+          },
+          children: [
+            {
+              tagName: "jx-textfield",
+              attributes: {
+                part: "add-name"
+              },
+              $props: {
+                label: "New field name",
+                placeholder: "Field name",
+                size: "sm",
+                value: {
+                  $ref: "#/state/addName"
+                }
+              },
+              oninput: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/editAddName"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/target/value"
+                      }
+                    ]
+                  }
+                ]
+              },
+              onkeydown: {
+                $prototype: "Function",
+                body: [
+                  {
+                    $switch: {
+                      $ref: "event#/key"
+                    },
+                    cases: {
+                      Enter: [
+                        {
+                          preventDefault: true
+                        },
+                        {
+                          operator: "call",
+                          target: {
+                            $ref: "#/state/confirmAdd"
+                          },
+                          value: []
+                        }
+                      ],
+                      Escape: [
+                        {
+                          preventDefault: true
+                        },
+                        {
+                          operator: "call",
+                          target: {
+                            $ref: "#/state/cancelAdd"
+                          },
+                          value: []
+                        }
+                      ]
+                    }
+                  }
+                ]
+              }
+            },
+            {
+              tagName: "jx-select",
+              attributes: {
+                part: "add-type"
+              },
+              $props: {
+                label: "Type of the new field",
+                size: "sm",
+                options: {
+                  $ref: "#/state/typeOptions"
+                },
+                value: {
+                  $ref: "#/state/addType"
+                }
+              },
+              onchange: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/editAddType"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/target/value"
+                      }
+                    ]
+                  }
+                ]
+              }
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "add-format-slot",
+                role: "none"
+              },
+              style: {
+                display: "contents"
+              },
+              $switch: {
+                $ref: "#/state/addHasFormat"
+              },
+              cases: {
+                true: {
+                  tagName: "jx-select",
+                  attributes: {
+                    part: "add-format"
+                  },
+                  $props: {
+                    label: "Format of the new field",
+                    size: "sm",
+                    options: {
+                      $ref: "#/state/formatOptions"
+                    },
+                    value: {
+                      $ref: "#/state/addFormat"
+                    }
+                  },
+                  onchange: {
+                    $prototype: "Function",
+                    body: [
+                      {
+                        operator: "call",
+                        target: {
+                          $ref: "#/state/editAddFormat"
+                        },
+                        value: [
+                          {
+                            $ref: "event#/target/value"
+                          }
+                        ]
+                      }
+                    ]
+                  }
+                }
+              }
+            },
+            {
+              tagName: "jx-switch",
+              attributes: {
+                part: "add-required"
+              },
+              $props: {
+                hint: "Require the new field",
+                size: "sm",
+                checked: {
+                  $ref: "#/state/addRequired"
+                }
+              },
+              onchange: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/editAddRequired"
+                    },
+                    value: [
+                      {
+                        $ref: "event#/target/checked"
+                      }
+                    ]
+                  }
+                ]
+              },
+              children: [
+                {
+                  tagName: "span",
+                  textContent: "Required"
+                }
+              ]
+            },
+            {
+              tagName: "jx-button",
+              attributes: {
+                part: "add-confirm"
+              },
+              $props: {
+                size: "sm"
+              },
+              onclick: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/confirmAdd"
+                    },
+                    value: []
+                  }
+                ]
+              },
+              children: [
+                {
+                  tagName: "span",
+                  textContent: "Add"
+                }
+              ]
+            },
+            {
+              tagName: "jx-button",
+              attributes: {
+                part: "add-cancel"
+              },
+              $props: {
+                size: "sm",
+                quiet: true
+              },
+              onclick: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/cancelAdd"
+                    },
+                    value: []
+                  }
+                ]
+              },
+              children: [
+                {
+                  tagName: "span",
+                  textContent: "Cancel"
+                }
+              ]
+            }
+          ]
+        }
+      }
+    }
+  ]
+};
+
+// src/surfaces/schema-builder.ts
+registerSurface("schema-builder", schema_builder_default);
+function emptyView() {
+  return {
+    addFormat: "",
+    addHasFormat: true,
+    addName: "",
+    addRequired: false,
+    addState: "closed",
+    addType: "string",
+    fields: [],
+    formatOptions: [],
+    targets: [],
+    typeOptions: []
+  };
+}
+function mountSchemaBuilderSurface(host, actions) {
+  host.textContent = "";
+  const scope = reactive({ ...emptyView(), ...actions });
+  let handle = null;
+  let mounting = true;
+  let disposed = false;
+  const mount = () => mountSurface("schema-builder", scope, host).then((mounted) => {
+    mounting = false;
+    if (disposed) {
+      mounted.dispose();
+      return mounted.root;
+    }
+    handle = mounted;
+    return mounted.root;
+  });
+  const ready = mount();
+  return {
+    dispose() {
+      disposed = true;
+      handle?.dispose();
+      handle = null;
+      host.textContent = "";
+    },
+    host,
+    ready,
+    update(view) {
+      scope.addFormat = view.addFormat;
+      scope.addHasFormat = view.addHasFormat;
+      scope.addName = view.addName;
+      scope.addRequired = view.addRequired;
+      scope.addState = view.addState;
+      scope.addType = view.addType;
+      scope.fields = view.fields;
+      scope.formatOptions = view.formatOptions;
+      scope.targets = view.targets;
+      scope.typeOptions = view.typeOptions;
+      if (disposed || mounting || handle !== null && host.contains(handle.root)) {
+        return;
+      }
+      handle?.dispose();
+      handle = null;
+      mounting = true;
+      host.textContent = "";
+      mount();
+    }
+  };
+}
+// src/surfaces/reference-field.json
+var reference_field_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioReferenceField",
+  $description: 'The `reference` form control — site-architecture.md §6.1\'s `{ "$ref": "#/content/x" }` and §7.4\'s entry picker. Registered once and dispatched to by `ui/schema-form.ts` for any property whose `$ref` names a collection, so the settings forms, the entry editor and an array-of-objects cell all draw the same control without any of them knowing it exists. `ui/form-controls.ts` decides which of the three states the field is in and what each gesture commits; nothing here reads a schema or lists a directory. The three states are drawn as three different controls on purpose: a picker while the entries are known, a TEXT field while they are not — a failed read leaves the value editable with the reason beside it, because swapping it for an empty dropdown would present "no entries" and "could not find out" as the same screen — and a disabled picker saying so while the read is in flight.',
+  tagName: "div",
+  attributes: {
+    part: "reference",
+    role: "none"
+  },
+  style: {
+    $description: "The five `.reference-*` rules from `styles/inspector.css`, keyed on `part` and re-pointed at the studio token layer. Two values could not come with them. The note read `var(--spectrum-font-size-50, 11px)`, which resolves only inside `<sp-theme>` — this document is mounted in a settings pane, an entry editor or a frontmatter card, all outside that element, so it would silently have taken its hard-coded fallback every time. And `.reference-missing` coloured ONE row of the dropdown red; the kit's select offers a row a face, a swatch and a border style but no tone, so the dangling entry says what it is in words (\"— not found\") and the colour is not replaced by a second channel. The 6px gap comes onto the kit's spacing scale.",
+    display: "flex",
+    flex: "1",
+    minWidth: "0",
+    alignItems: "center",
+    gap: "var(--jx-space-2)",
+    '& [part="picker"], & [part="text"]': {
+      flex: "1",
+      minWidth: "0"
+    },
+    '& [part="note"]': {
+      margin: "0",
+      color: "var(--fg-dim)",
+      fontSize: "var(--jx-text-sm)",
+      lineHeight: "1.4"
+    },
+    '& [part="note"][data-tone="danger"]': {
+      $description: "A listing that failed is a FAULT rather than a fact about the project, and the two notes this control draws are otherwise the same sentence in the same place.",
+      color: "var(--danger)"
+    },
+    '& [part="retry"]': {
+      flex: "none"
+    }
+  },
+  children: [
+    {
+      tagName: "div",
+      attributes: {
+        part: "control-slot",
+        role: "none"
+      },
+      style: {
+        display: "contents"
+      },
+      $switch: {
+        $ref: "#/state/kind"
+      },
+      cases: {
+        picker: {
+          $description: "The collection's entries. The empty row is `\"\"` rather than a sentinel, because the kit's select treats the empty string as a legal value a reader can arrow to; a dangling reference is kept in the list and marked, since blanking the field would delete the evidence and the value in one repaint. While the read is in flight the same control is disabled and offers one row saying so.",
+          tagName: "jx-select",
+          attributes: {
+            part: "picker"
+          },
+          $props: {
+            size: "sm",
+            label: {
+              $ref: "#/state/label"
+            },
+            options: {
+              $ref: "#/state/options"
+            },
+            value: {
+              $ref: "#/state/value"
+            },
+            disabled: {
+              $ref: "#/state/disabled"
+            }
+          },
+          onchange: {
+            $prototype: "Function",
+            body: [
+              {
+                operator: "call",
+                target: {
+                  $ref: "#/state/choose"
+                },
+                value: [
+                  {
+                    $ref: "event#/target/value"
+                  }
+                ]
+              }
+            ]
+          }
+        },
+        text: {
+          $description: "The id as the string it is: what a reader gets when the choices could not be listed, and when the control was named by a `ui.control` override on a property that references nothing. Refusing to draw anything would lose the value that is already there.",
+          tagName: "jx-textfield",
+          attributes: {
+            part: "text"
+          },
+          $props: {
+            size: "sm",
+            label: {
+              $ref: "#/state/label"
+            },
+            value: {
+              $ref: "#/state/value"
+            }
+          },
+          onchange: {
+            $prototype: "Function",
+            body: [
+              {
+                operator: "call",
+                target: {
+                  $ref: "#/state/edit"
+                },
+                value: [
+                  {
+                    $ref: "event#/target/value"
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      }
+    },
+    {
+      tagName: "div",
+      attributes: {
+        part: "note-slot",
+        role: "none"
+      },
+      style: {
+        display: "contents"
+      },
+      $switch: {
+        $ref: "#/state/hasNote"
+      },
+      cases: {
+        true: {
+          tagName: "p",
+          attributes: {
+            part: "note",
+            "data-tone": "${state.noteTone}",
+            role: "status"
+          },
+          textContent: "${state.note}"
+        }
+      }
+    },
+    {
+      tagName: "div",
+      attributes: {
+        part: "retry-slot",
+        role: "none"
+      },
+      style: {
+        display: "contents"
+      },
+      $switch: {
+        $ref: "#/state/canRetry"
+      },
+      cases: {
+        true: {
+          $description: "Offered only where there is something to try again — a listing that failed. It used to be offered only where the HOST passed a repaint hook, because a template control cannot draw a second frame of its own and a button that cannot do the thing it is named after is worse than its absence. A mounted control redraws itself, so the condition is now the failure rather than the host.",
+          tagName: "jx-action-button",
+          attributes: {
+            part: "retry"
+          },
+          $props: {
+            size: "sm",
+            quiet: true,
+            label: "Retry listing entries"
+          },
+          onclick: {
+            $prototype: "Function",
+            body: [
+              {
+                operator: "call",
+                target: {
+                  $ref: "#/state/retry"
+                },
+                value: []
+              }
+            ]
+          },
+          children: [
+            {
+              tagName: "span",
+              textContent: "Retry"
+            }
+          ]
+        }
+      }
+    }
+  ]
+};
+
+// src/surfaces/reference-field.ts
+registerSurface("reference-field", reference_field_default);
+function emptyView2() {
+  return {
+    canRetry: false,
+    disabled: true,
+    hasNote: false,
+    kind: "picker",
+    label: "",
+    note: "",
+    noteTone: "dim",
+    options: [],
+    value: ""
+  };
+}
+function mountReferenceFieldSurface(host, actions) {
+  host.textContent = "";
+  const scope = reactive({ ...emptyView2(), ...actions });
+  let handle = null;
+  let mounting = true;
+  let disposed = false;
+  const mount = () => mountSurface("reference-field", scope, host).then((mounted) => {
+    mounting = false;
+    if (disposed) {
+      mounted.dispose();
+      return mounted.root;
+    }
+    handle = mounted;
+    return mounted.root;
+  });
+  const ready = mount();
+  return {
+    dispose() {
+      disposed = true;
+      handle?.dispose();
+      handle = null;
+      host.textContent = "";
+    },
+    host,
+    ready,
+    update(view) {
+      scope.canRetry = view.canRetry;
+      scope.disabled = view.disabled;
+      scope.hasNote = view.hasNote;
+      scope.kind = view.kind;
+      scope.label = view.label;
+      scope.note = view.note;
+      scope.noteTone = view.noteTone;
+      scope.options = view.options;
+      scope.value = view.value;
+      if (disposed || mounting || handle !== null && host.contains(handle.root)) {
+        return;
+      }
+      handle?.dispose();
+      handle = null;
+      mounting = true;
+      host.textContent = "";
+      mount();
+    }
+  };
+}
+// src/surfaces/secret-field.json
+var secret_field_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioSecretField",
+  $description: 'The `secret` form control (specs/extensions.md §9.1, §13): one password field whose VALUE goes to the platform\'s secret store and never to project.json. A descriptor names it with `"ui": { "<field>": { "control": "secret" } }`, and `ui/schema-form.ts` mounts it into the empty host its own document announces for that field. **A surface never renders back the secret it describes, and this document is where that is visible rather than remembered**: the only thing bound to the field\'s value is `#/state/shown`, a scope path whose whole purpose is to hold nothing. What the field is worth is said in the placeholder instead — the env NAME the store gave it, which is the only half of a secret a screen may carry. `ui/form-controls.ts` decides everything else: whether the host has a secret store at all, what the placeholder says, what a commit is worth and what the field persists.',
+  tagName: "div",
+  attributes: {
+    part: "secret",
+    role: "none"
+  },
+  style: {
+    $description: "`.secret-field` carried no rule anywhere — it was one of `check-styles.ts`'s ALLOWED_ORPHANS, a class emitted only so a test could find the control — so there is nothing to translate and the wrapper takes no box of its own. The field takes the width of the control host the form drew, which is the flex item; a kit field is inline-flex by default and would otherwise sit at its intrinsic width in a row sized for it.",
+    display: "contents",
+    '& [part="field"]': {
+      width: "100%"
+    }
+  },
+  children: [
+    {
+      $description: "`autocomplete: new-password` because this is a place to PUT a secret rather than to prove one: without it a password manager offers to fill the field with a credential belonging to whatever site the reader last logged in to, and the offer is the manager's own UI drawn over an editor. The value binding is `#/state/shown` and nothing else ever writes to it — see the document description.",
+      tagName: "jx-textfield",
+      attributes: {
+        part: "field"
+      },
+      $props: {
+        type: "password",
+        size: "sm",
+        autocomplete: "new-password",
+        label: {
+          $ref: "#/state/label"
+        },
+        placeholder: {
+          $ref: "#/state/placeholder"
+        },
+        disabled: {
+          $ref: "#/state/disabled"
+        },
+        value: {
+          $ref: "#/state/shown"
+        }
+      },
+      onchange: {
+        $prototype: "Function",
+        body: [
+          {
+            operator: "call",
+            target: {
+              $ref: "#/state/commit"
+            },
+            value: [
+              {
+                $ref: "event#/target/value"
+              }
+            ]
+          }
+        ],
+        description: "The change bubbles out of the field's own input, so what the reader typed is read off the event rather than off the element — and it is read here, handed to the flow, and never written back onto the scope."
+      }
+    }
+  ]
+};
+
+// src/surfaces/secret-field.ts
+registerSurface("secret-field", secret_field_default);
+function emptyView3() {
+  return { disabled: true, label: "", placeholder: "Not set" };
+}
+function mountSecretFieldSurface(host, actions) {
+  host.textContent = "";
+  const scope = reactive({ ...emptyView3(), ...actions, shown: "" });
+  let handle = null;
+  let mounting = true;
+  let disposed = false;
+  const mount = () => mountSurface("secret-field", scope, host).then((mounted) => {
+    mounting = false;
+    if (disposed) {
+      mounted.dispose();
+      return mounted.root;
+    }
+    handle = mounted;
+    return mounted.root;
+  });
+  const ready = mount();
+  return {
+    clear() {
+      scope.shown = " ";
+      scope.shown = "";
+    },
+    dispose() {
+      disposed = true;
+      handle?.dispose();
+      handle = null;
+      host.textContent = "";
+    },
+    host,
+    ready,
+    update(view) {
+      scope.disabled = view.disabled;
+      scope.label = view.label;
+      scope.placeholder = view.placeholder;
+      if (disposed || mounting || handle !== null && host.contains(handle.root)) {
+        return;
+      }
+      handle?.dispose();
+      handle = null;
+      mounting = true;
+      host.textContent = "";
+      mount();
+    }
+  };
+}
+
+// src/ui/form-controls.ts
+var TYPE_ROWS = FIELD_TYPES.map((type) => ({ label: type, value: type }));
+var FORMAT_ROWS = FORMAT_OPTIONS.map((format) => ({
+  label: format || "(none)",
+  value: format
+}));
+var BLANK_FIELD = { format: "", name: "", required: false, type: "string" };
+var targetRows = [];
+var targetNames = " ";
+function targetsFor(ctx) {
+  const content = ctx.resolvePointer("#/$context/content");
+  const names = content && typeof content === "object" && !Array.isArray(content) ? Object.keys(content) : [];
+  const id = names.join(" ");
+  if (id !== targetNames) {
+    targetNames = id;
+    targetRows = names.map((name) => ({ label: name, value: name }));
+  }
+  return targetRows;
+}
+function takesFormat(type) {
+  return type === "string" || type === "array";
+}
+function readSchema(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : { properties: {}, required: [], type: "object" };
+}
+function cloneSchema(value) {
+  const draft = JSON.parse(JSON.stringify(readSchema(value)));
+  draft.type ??= "object";
+  draft.properties ??= {};
+  draft.required ??= [];
+  return draft;
+}
+function nameId(key) {
+  return `name:${key}`;
+}
+function requiredId(key) {
+  return `required:${key}`;
+}
+function nestedId(parent, key) {
+  return `${parent} ${key}`;
+}
+function shown(ui, id, held) {
+  return ui.echo?.id === id ? ui.echo.value : held;
+}
+function nestedView(ui, parent, key, schema, required) {
+  const id = nestedId(parent, key);
+  const type = detectFieldType(schema);
+  return {
+    format: detectFieldFormat(schema),
+    hasFormat: takesFormat(type),
+    key,
+    name: shown(ui, nameId(id), key),
+    parent,
+    required: shown(ui, requiredId(id), required),
+    type
+  };
+}
+function fieldView(ui, key, schema, required, hasTargets) {
+  const type = detectFieldType(schema);
+  const nested = type === "object";
+  const draft = ui.drafts.get(key);
+  const childRequired = schema.required ?? [];
+  return {
+    children: nested ? Object.entries(schema.properties ?? {}).map(([child, sub]) => nestedView(ui, key, child, sub, childRequired.includes(child))) : [],
+    draftName: draft?.name ?? "",
+    draftType: draft?.type ?? "string",
+    extra: type === "reference" && hasTargets ? "reference" : nested ? "nested" : "none",
+    format: detectFieldFormat(schema),
+    hasFormat: takesFormat(type),
+    key,
+    label: camelToLabel(key),
+    name: shown(ui, nameId(key), key),
+    refTarget: schema.$ref ? schema.$ref.replace(/^#\/[^/]+\//, "") : "",
+    required: shown(ui, requiredId(key), required),
+    type
+  };
+}
+function renameKey(properties, from, to) {
+  const next = {};
+  for (const [key, value] of Object.entries(properties)) {
+    next[key === from ? to : key] = value;
+    delete properties[key];
+  }
+  Object.assign(properties, next);
+}
+function markRequired(holder, key, required) {
+  holder.required ??= [];
+  const at = holder.required.indexOf(key);
+  if (required && at === -1) {
+    holder.required.push(key);
+  }
+  if (!required && at !== -1) {
+    holder.required.splice(at, 1);
+  }
+}
+function mountSchemaBuilder(host, args) {
+  let latest = args;
+  let committed = null;
+  const ui = {
+    add: { ...BLANK_FIELD },
+    addOpen: false,
+    drafts: new Map,
+    echo: null
+  };
+  const source = () => committed ?? readSchema(latest.value);
+  const project = () => {
+    const schema = source();
+    const required = schema.required ?? [];
+    const rows = targetsFor(latest.ctx);
+    return {
+      addFormat: ui.add.format,
+      addHasFormat: takesFormat(ui.add.type),
+      addName: ui.add.name,
+      addRequired: ui.add.required,
+      addState: ui.addOpen ? "open" : "closed",
+      addType: ui.add.type,
+      fields: Object.entries(schema.properties ?? {}).map(([key, property]) => fieldView(ui, key, property, required.includes(key), rows.length > 0)),
+      formatOptions: FORMAT_ROWS,
+      targets: rows,
+      typeOptions: TYPE_ROWS
+    };
+  };
+  const redraw = () => surface.update(project());
+  const say = (id, value) => {
+    ui.echo = { id, value };
+    redraw();
+  };
+  const refuse = () => {
+    ui.echo = null;
+    redraw();
+  };
+  const write = (mutate) => {
+    const draft = cloneSchema(source());
+    if (!mutate(draft)) {
+      refuse();
+      return;
+    }
+    committed = draft;
+    ui.echo = null;
+    latest.onChange(draft);
+    redraw();
+  };
+  const parentOf = (draft, parent) => draft.properties[parent];
+  const draftOf = (parent) => {
+    let draft = ui.drafts.get(parent);
+    if (!draft) {
+      draft = { name: "", type: "string" };
+      ui.drafts.set(parent, draft);
+    }
+    return draft;
+  };
+  const surface = mountSchemaBuilderSurface(host, {
+    addNested(parent) {
+      const draft = draftOf(parent);
+      const name = toCamelCase(draft.name.trim());
+      if (!name) {
+        return;
+      }
+      write((next) => {
+        const holder = parentOf(next, parent);
+        if (!holder) {
+          return false;
+        }
+        holder.properties ??= {};
+        holder.properties[name] = schemaForType(draft.type || "string");
+        draft.name = "";
+        return true;
+      });
+    },
+    cancelAdd() {
+      ui.addOpen = false;
+      ui.add = { ...BLANK_FIELD };
+      redraw();
+    },
+    confirmAdd() {
+      const name = toCamelCase(ui.add.name.trim());
+      if (!name) {
+        return;
+      }
+      const { format, required, type } = ui.add;
+      ui.addOpen = false;
+      ui.add = { ...BLANK_FIELD };
+      write((next) => {
+        next.properties[name] = schemaForType(type, format || undefined);
+        if (required) {
+          markRequired(next, name, true);
+        }
+        return true;
+      });
+    },
+    editAddFormat(value) {
+      ui.add.format = value;
+      redraw();
+    },
+    editAddName(value) {
+      ui.add.name = value;
+      redraw();
+    },
+    editAddRequired(required) {
+      ui.add.required = required;
+      redraw();
+    },
+    editAddType(value) {
+      ui.add.type = value;
+      redraw();
+    },
+    editDraftName(parent, value) {
+      draftOf(parent).name = value;
+      redraw();
+    },
+    editDraftType(parent, value) {
+      draftOf(parent).type = value;
+      redraw();
+    },
+    openAdd() {
+      ui.addOpen = true;
+      ui.add = { ...BLANK_FIELD };
+      redraw();
+    },
+    removeField(key) {
+      write((next) => {
+        if (!next.properties[key]) {
+          return false;
+        }
+        delete next.properties[key];
+        next.required = next.required.filter((name) => name !== key);
+        return true;
+      });
+    },
+    removeNested(parent, key) {
+      write((next) => {
+        const holder = parentOf(next, parent);
+        if (!holder?.properties?.[key]) {
+          return false;
+        }
+        delete holder.properties[key];
+        if (holder.required) {
+          holder.required = holder.required.filter((name) => name !== key);
+        }
+        return true;
+      });
+    },
+    renameField(key, value) {
+      say(nameId(key), value);
+      const name = toCamelCase(value.trim());
+      write((next) => {
+        if (!next.properties[key] || !name || name === key || next.properties[name]) {
+          return false;
+        }
+        renameKey(next.properties, key, name);
+        next.required = next.required.map((entry) => entry === key ? name : entry);
+        return true;
+      });
+    },
+    renameNested(parent, key, value) {
+      say(nameId(nestedId(parent, key)), value);
+      const name = toCamelCase(value.trim());
+      write((next) => {
+        const holder = parentOf(next, parent);
+        if (!holder?.properties?.[key] || !name || name === key || holder.properties[name]) {
+          return false;
+        }
+        renameKey(holder.properties, key, name);
+        if (holder.required) {
+          holder.required = holder.required.map((entry) => entry === key ? name : entry);
+        }
+        return true;
+      });
+    },
+    setFormat(key, value) {
+      write((next) => {
+        const property = next.properties[key];
+        if (!property) {
+          return false;
+        }
+        next.properties[key] = schemaForType(property.type || "string", value || undefined);
+        return true;
+      });
+    },
+    setNestedFormat(parent, key, value) {
+      write((next) => {
+        const holder = parentOf(next, parent);
+        const property = holder?.properties?.[key];
+        if (!holder?.properties || !property) {
+          return false;
+        }
+        holder.properties[key] = schemaForType(property.type || "string", value || undefined);
+        return true;
+      });
+    },
+    setNestedRequired(parent, key, required) {
+      say(requiredId(nestedId(parent, key)), required);
+      write((next) => {
+        const holder = parentOf(next, parent);
+        if (!holder) {
+          return false;
+        }
+        markRequired(holder, key, required);
+        return true;
+      });
+    },
+    setNestedType(parent, key, value) {
+      write((next) => {
+        const holder = parentOf(next, parent);
+        const property = holder?.properties?.[key];
+        if (!holder?.properties || !property) {
+          return false;
+        }
+        const format = takesFormat(value) ? detectFieldFormat(property) : undefined;
+        holder.properties[key] = schemaForType(value, format || undefined);
+        return true;
+      });
+    },
+    setRequired(key, required) {
+      say(requiredId(key), required);
+      write((next) => {
+        if (!next.properties[key]) {
+          return false;
+        }
+        markRequired(next, key, required);
+        return true;
+      });
+    },
+    setTarget(key, value) {
+      write((next) => {
+        if (!next.properties[key]) {
+          return false;
+        }
+        next.properties[key] = { $ref: `#/content/${value}` };
+        return true;
+      });
+    },
+    setType(key, value) {
+      write((next) => {
+        const property = next.properties[key];
+        if (!property) {
+          return false;
+        }
+        const format = takesFormat(value) ? detectFieldFormat(property) : undefined;
+        next.properties[key] = schemaForType(value, format || undefined);
+        return true;
+      });
+    }
+  });
+  redraw();
+  return {
+    dispose: () => surface.dispose(),
+    update(next) {
+      latest = next;
+      committed = null;
+      ui.echo = null;
+      redraw();
+    }
+  };
+}
+var schemaBuilderControl = { mount: mountSchemaBuilder };
+registerFormControl("schema-builder", schemaBuilderControl);
+function envNameOf(value) {
+  return typeof value === "string" && value ? value : null;
+}
+function mountSecret(host, args) {
+  let latest = args;
+  const redraw = () => {
+    const envName = envNameOf(latest.value);
+    surface.update({
+      disabled: !latest.ctx.commitSecret,
+      label: latest.key,
+      placeholder: envName ? `Stored as ${envName}` : "Not set"
+    });
+  };
+  const surface = mountSecretFieldSurface(host, {
+    commit(value) {
+      const { commitSecret } = latest.ctx;
+      if (!commitSecret || !value) {
+        return;
+      }
+      surface.clear();
+      const { key, onChange } = latest;
+      const envName = envNameOf(latest.value);
+      Promise.resolve(commitSecret(key, value)).then((name) => {
+        if (typeof name === "string" && name && name !== envName) {
+          onChange(name);
+        }
+      });
+    }
+  });
+  redraw();
+  return {
+    dispose: () => surface.dispose(),
+    update(next) {
+      latest = next;
+      redraw();
+    }
+  };
+}
+var secretControl = { mount: mountSecret };
+registerFormControl("secret", secretControl);
+var entryIdCache = new Map;
+var entryIdResult = new Map;
+var entryIdWaiting = new Map;
+function invalidateReferenceEntries(collection) {
+  if (collection === undefined) {
+    entryIdCache.clear();
+    entryIdResult.clear();
+    entryIdWaiting.clear();
+  } else {
+    entryIdCache.delete(collection);
+    entryIdResult.delete(collection);
+    entryIdWaiting.delete(collection);
+  }
+}
+function entryIdsFor(collection) {
+  const known = entryIdCache.get(collection);
+  if (known) {
+    return known;
+  }
+  const pending = (__preload("5mex4x1h"), import("./content-source-5mex4x1h.js")).then((m) => m.listCollectionEntryIds(collection));
+  entryIdCache.set(collection, pending);
+  return pending;
+}
+function referenceEntryState(collection, onSettled) {
+  const done = entryIdResult.get(collection);
+  if (done) {
+    return done;
+  }
+  const pending = entryIdsFor(collection);
+  const waiting = entryIdWaiting.get(collection);
+  if (waiting) {
+    if (onSettled) {
+      waiting.add(onSettled);
+    }
+    return null;
+  }
+  entryIdWaiting.set(collection, new Set(onSettled ? [onSettled] : []));
+  const settle = (result) => {
+    if (entryIdCache.get(collection) !== pending) {
+      return;
+    }
+    const listeners = entryIdWaiting.get(collection);
+    entryIdWaiting.delete(collection);
+    entryIdResult.set(collection, result);
+    for (const run of listeners ?? []) {
+      run();
+    }
+  };
+  pending.then((ids) => settle({ ids }), (error) => settle({ error: errorMessage2(error) }));
+  return null;
+}
+function referenceView(args, onSettled) {
+  const current = typeof args.value === "string" ? args.value : "";
+  const base = {
+    canRetry: false,
+    disabled: false,
+    hasNote: false,
+    label: args.key,
+    note: "",
+    noteTone: "dim",
+    options: [],
+    value: current
+  };
+  const collection = referenceTarget(args.schema);
+  if (collection === null) {
+    return {
+      ...base,
+      hasNote: true,
+      kind: "text",
+      note: 'No collection referenced — add "$ref": "#/content/<type>" to this field.'
+    };
+  }
+  const state = referenceEntryState(collection, onSettled);
+  if (state === null) {
+    return {
+      ...base,
+      disabled: true,
+      kind: "picker",
+      options: [{ label: "Loading…", value: current }]
+    };
+  }
+  if ("error" in state) {
+    return {
+      ...base,
+      canRetry: true,
+      hasNote: true,
+      kind: "text",
+      note: `Could not list ${collection} entries — ${state.error}`,
+      noteTone: "danger"
+    };
+  }
+  const dangling = current !== "" && !state.ids.includes(current);
+  return {
+    ...base,
+    hasNote: state.ids.length === 0,
+    kind: "picker",
+    note: state.ids.length === 0 ? `No ${collection} entries yet.` : "",
+    options: [
+      { label: "—", value: "" },
+      ...dangling ? [{ label: `${current} — not found`, value: current }] : [],
+      ...state.ids.map((id) => ({ label: id, value: id }))
+    ]
+  };
+}
+function mountReference(host, args) {
+  let latest = args;
+  let disposed = false;
+  const redraw = () => {
+    if (!disposed) {
+      surface.update(referenceView(latest, redraw));
+    }
+  };
+  const surface = mountReferenceFieldSurface(host, {
+    choose(value) {
+      latest.onChange(value === "" ? undefined : value);
+    },
+    edit(value) {
+      latest.onChange(value.trim() || undefined);
+    },
+    retry() {
+      const collection = referenceTarget(latest.schema);
+      if (collection !== null) {
+        invalidateReferenceEntries(collection);
+      }
+      redraw();
+    }
+  });
+  redraw();
+  return {
+    dispose() {
+      disposed = true;
+      surface.dispose();
+    },
+    update(next) {
+      latest = next;
+      redraw();
+    }
+  };
+}
+var referenceControl = { mount: mountReference };
+registerFormControl("reference", referenceControl);
+// src/surfaces/entry-editor.json
+var entry_editor_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioEntryEditor",
+  $description: "The Entry editor (§7.4) — one content entry's fields, in a pane, as a Jx document over the kit. The adapter (`surfaces/entry-editor.ts`) hands in a projection; `content/entry-editor.ts` decides everything in it — which collection the file belongs to, which record its fields live in, which required keys are absent and what a draft flag commits into. The FORM is an island: a schema is `ui/schema-form.ts`'s subject, so this document renders an empty `fields` node and the flow places the element that engine hands back (studio-ui-guidelines.md §9.3, §9.4). That is the whole of the difference between this and the card the lit version drew, and it is why the engine converting in batch 7 is what unblocked this one.",
+  tagName: "div",
+  attributes: {
+    part: "entry",
+    "data-jx-region": "${state.region}"
+  },
+  style: {
+    $description: "What `.entry-editor`, `.entry-editor-header`, `.entry-editor-collection`, `.entry-draft-switch`, `.entry-editor-fields`, `.entry-editor-note` and `.entry-editor-empty` said in `styles/overlays.css`, keyed on `part` and re-pointed at the studio token layer. This editor was the only emitter of all seven, so those rules are dead in the stylesheet from here; a central sweep removes them rather than this change, which owns no stylesheet. Every `--spectrum-font-size-*` reference is gone rather than renamed: those names resolve only inside `<sp-theme>`, and a pane editor is mounted outside it, so each would silently have taken its hard-coded fallback.",
+    height: "100%",
+    padding: "var(--jx-space-5)",
+    overflowY: "auto",
+    background: "var(--bg-panel)",
+    '& [part="header"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "var(--jx-space-4)",
+      marginBottom: "var(--jx-space-5)"
+    },
+    '& [part="name"]': {
+      margin: "0",
+      fontSize: "var(--jx-text-lg)",
+      fontWeight: "600",
+      color: "var(--fg)"
+    },
+    '& [part="collection"]': {
+      padding: "1px var(--jx-space-3)",
+      borderRadius: "var(--radius)",
+      background: "var(--bg)",
+      color: "var(--fg-dim)",
+      fontSize: "var(--jx-text-sm)"
+    },
+    '& [part="draft"]': {
+      $description: "Pushed to the far end of the header rather than placed there: the heading and the collection chip are both content-width, so `margin-left: auto` is what keeps the switch on the right edge whatever the entry is called.",
+      marginLeft: "auto"
+    },
+    '& [part="fields"]': {
+      $description: "The schema form's host is `display: contents`, so its rows are the flex items of THIS box — which is why the column lives here and not inside the engine.",
+      display: "flex",
+      flexDirection: "column"
+    },
+    '& [part="note"]': {
+      margin: "0 0 var(--jx-space-4)",
+      color: "var(--fg-dim)",
+      fontSize: "var(--jx-text-md)",
+      lineHeight: "1.5"
+    },
+    '& [part="empty"]': {
+      display: "flex",
+      maxWidth: "46ch",
+      flexDirection: "column",
+      alignItems: "flex-start",
+      gap: "var(--jx-space-3)",
+      color: "var(--fg-dim)",
+      fontSize: "var(--jx-text-md)",
+      lineHeight: "1.5"
+    }
+  },
+  children: [
+    {
+      tagName: "div",
+      attributes: {
+        part: "stage-slot",
+        role: "none"
+      },
+      style: {
+        display: "contents"
+      },
+      $switch: {
+        $ref: "#/state/stage"
+      },
+      cases: {
+        entry: {
+          tagName: "div",
+          attributes: {
+            part: "body",
+            role: "none"
+          },
+          style: {
+            display: "contents"
+          },
+          children: [
+            {
+              tagName: "div",
+              attributes: {
+                part: "header"
+              },
+              children: [
+                {
+                  tagName: "h3",
+                  attributes: {
+                    part: "name"
+                  },
+                  textContent: "${state.name}"
+                },
+                {
+                  tagName: "span",
+                  attributes: {
+                    part: "collection"
+                  },
+                  textContent: "${state.collection}"
+                },
+                {
+                  tagName: "div",
+                  attributes: {
+                    part: "draft-slot",
+                    role: "none"
+                  },
+                  style: {
+                    display: "contents"
+                  },
+                  $switch: {
+                    $ref: "#/state/draftAxis"
+                  },
+                  cases: {
+                    shown: {
+                      $description: "No `label`: the slotted word is on screen and carries the name, so an aria-label would be read twice. The tooltip is `hint`, which is what DRAFT_MEANING has always been.",
+                      tagName: "jx-switch",
+                      attributes: {
+                        part: "draft"
+                      },
+                      $props: {
+                        checked: {
+                          $ref: "#/state/draft"
+                        },
+                        hint: "${state.draftHint}",
+                        size: "sm"
+                      },
+                      onchange: {
+                        $prototype: "Function",
+                        body: [
+                          {
+                            operator: "call",
+                            target: {
+                              $ref: "#/state/setDraft"
+                            },
+                            value: [
+                              {
+                                $ref: "event#/target/checked"
+                              }
+                            ]
+                          }
+                        ]
+                      },
+                      children: [
+                        {
+                          tagName: "span",
+                          textContent: "Draft"
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "note-slot",
+                role: "none"
+              },
+              style: {
+                display: "contents"
+              },
+              $switch: {
+                $ref: "#/state/noteState"
+              },
+              cases: {
+                shown: {
+                  tagName: "p",
+                  attributes: {
+                    part: "note"
+                  },
+                  textContent: "${state.note}"
+                }
+              }
+            },
+            {
+              $description: "An island: `ui/schema-form.ts` draws this entry's fields into this node, and nothing in this document knows what a schema is.",
+              tagName: "div",
+              attributes: {
+                part: "fields",
+                "data-jx-region": "${state.fieldsRegion}"
+              }
+            }
+          ]
+        },
+        empty: {
+          $description: "The mode is reachable from the palette and from `__jxAutomation` on any tab, so this state is real: it names the reason and the fix rather than drawing an empty form.",
+          tagName: "div",
+          attributes: {
+            part: "empty"
+          },
+          children: [
+            {
+              tagName: "p",
+              attributes: {
+                part: "empty-line"
+              },
+              textContent: "${state.emptyLine}"
+            },
+            {
+              tagName: "p",
+              attributes: {
+                part: "note"
+              },
+              children: [
+                {
+                  tagName: "span",
+                  textContent: "A collection is a "
+                },
+                {
+                  tagName: "code",
+                  textContent: "content"
+                },
+                {
+                  tagName: "span",
+                  textContent: " entry in "
+                },
+                {
+                  tagName: "code",
+                  textContent: "project.json"
+                },
+                {
+                  tagName: "span",
+                  textContent: " whose "
+                },
+                {
+                  tagName: "code",
+                  textContent: "source"
+                },
+                {
+                  tagName: "span",
+                  textContent: " directory contains this file and which declares a "
+                },
+                {
+                  tagName: "code",
+                  textContent: "schema"
+                },
+                {
+                  tagName: "span",
+                  textContent: "."
+                }
+              ]
+            },
+            {
+              tagName: "jx-action-button",
+              attributes: {
+                part: "content-types"
+              },
+              $props: {
+                label: "Content types",
+                size: "sm"
+              },
+              onclick: {
+                $prototype: "Function",
+                body: [
+                  {
+                    operator: "call",
+                    target: {
+                      $ref: "#/state/openContentTypes"
+                    },
+                    value: []
+                  }
+                ]
+              },
+              children: [
+                {
+                  tagName: "span",
+                  textContent: "Content types…"
+                }
+              ]
+            }
+          ]
+        }
+      }
+    }
+  ]
+};
+
+// src/surfaces/entry-editor.ts
+registerSurface("entry-editor", entry_editor_default);
+function project(scope, view) {
+  scope.region = view.region;
+  scope.fieldsRegion = view.fieldsRegion;
+  scope.stage = view.stage;
+  scope.name = view.name;
+  scope.collection = view.collection;
+  scope.draftAxis = view.draftAxis;
+  scope.draft = view.draft;
+  scope.draftHint = view.draftHint;
+  scope.noteState = view.noteState;
+  scope.note = view.note;
+  scope.emptyLine = view.emptyLine;
+}
+function partOf(def) {
+  const attributes = def?.attributes;
+  const part = attributes?.["part"];
+  return typeof part === "string" ? part : "";
+}
+function mountEntryEditorSurface(host, view, actions, islands) {
+  host.replaceChildren();
+  const scope = reactive({
+    collection: "",
+    draft: false,
+    draftAxis: "hidden",
+    draftHint: "",
+    emptyLine: "",
+    fieldsRegion: "",
+    name: "",
+    note: "",
+    noteState: "hidden",
+    openContentTypes: actions.openContentTypes,
+    region: "",
+    setDraft: actions.setDraft,
+    stage: "empty"
+  });
+  project(scope, view);
+  let mounted = null;
+  let disposed = false;
+  const ready = mountSurface("entry-editor", scope, host, {
+    onNodeCreated: (element, _path, def) => {
+      if (element instanceof HTMLElement && partOf(def) === "fields") {
+        islands.fieldsSlot(element);
+      }
+    }
+  }).then((surface) => {
+    if (disposed) {
+      surface.dispose();
+      return surface.root;
+    }
+    mounted = surface;
+    return surface.root;
+  });
+  return {
+    attached: () => {
+      if (disposed) {
+        return false;
+      }
+      const root = mounted?.root;
+      return root === undefined ? true : root instanceof HTMLElement && host.contains(root);
+    },
+    dispose() {
+      disposed = true;
+      mounted?.dispose();
+      mounted = null;
+    },
+    ready,
+    update: (next) => project(scope, next)
+  };
+}
+
+// src/content/entry-fields.ts
+function fieldsAreDocument(tab) {
+  return tab.doc.sourceFormat == null && tab.doc.mode !== "content";
+}
+function entryFields(tab) {
+  return fieldsAreDocument(tab) ? tab.doc.document : tab.doc.content?.frontmatter ?? {};
+}
+function mutateDocumentField(tab, field, value) {
+  const doc = tab.doc.document;
+  const before = Object.hasOwn(doc, field) ? cloneValue2(doc[field]) : undefined;
+  const deletes = value === undefined || value === null || value === "";
+  if (deletes) {
+    delete doc[field];
+  } else {
+    doc[field] = value;
+  }
+  const after = deletes ? undefined : cloneValue2(value);
+  recordDocOp({
+    forward: { key: field, op: "set-key", path: [], value: after },
+    inverse: { key: field, op: "set-key", path: [], value: before }
+  });
+  tab.doc.dirty = true;
+  notePreviewOverlayEdit();
+}
+function mutateEntryField(tab, field, value) {
+  if (fieldsAreDocument(tab)) {
+    mutateDocumentField(tab, field, value);
+  } else {
+    mutateUpdateFrontmatter(tab, field, value);
+  }
+}
+function commitEntryFields(tab, patch) {
+  transactDoc(tab, (t) => {
+    for (const [field, value] of Object.entries(patch)) {
+      mutateEntryField(t, field, value);
+    }
+  });
+}
+
+// src/content/entry-editor.ts
+var ENTRY_MODE = "entry";
+var ENTRY_TAB_MODES = [ENTRY_MODE];
+var _active = new Map;
+function activeIn(paneId) {
+  return _active.get(paneId) ?? null;
+}
+function entryPaneMounted(paneId, tab) {
+  const panel = activeIn(paneId);
+  return panel !== null && panel.tabId === tab.id && panel.wrap.isConnected && panel.surface.attached();
+}
+function detachEntryPane(paneId) {
+  const panel = _active.get(paneId);
+  if (!panel) {
+    return;
+  }
+  panel.scope.stop();
+  panel.surface.dispose();
+  _active.delete(paneId);
+}
+function setEntryDraft(tab, draft) {
+  transactDoc(tab, (t) => mutateEntryField(t, DRAFT_FIELD, draft));
+}
+function entryDraftPill(tab) {
+  const collection = collectionOfPath(tab.documentPath);
+  const fields = entryFields(tab);
+  if (!collection || !hasDraftAxis(collection.schema, fields)) {
+    return null;
+  }
+  const draft = isDraftEntry(fields);
+  return {
+    draft,
+    text: draft ? "Draft" : "Published",
+    title: draft ? DRAFT_MEANING : "Not marked a draft."
+  };
+}
+function formContext(tab) {
+  return {
+    fieldKeyPrefix: `entry:${tab.id}`,
+    resolvePointer: (pointer, scope) => resolveContextPointer(pointer, {
+      projectConfig: projectState?.projectConfig ?? {},
+      scope
+    })
+  };
+}
+function absentRequiredErrors(collection, fields) {
+  const errors = {};
+  for (const field of missingRequired(collection.schema, fields)) {
+    errors[field] = "Required — this entry does not have one.";
+  }
+  return errors;
+}
+function emptyLine(tab) {
+  return `${tab.documentPath ?? "This document"} is not an entry of any content collection, so there is no schema to draw a form from.`;
+}
+function entryView(paneId, tab, collection) {
+  const region = paneRegion(paneId, "entry");
+  const fieldsRegion = paneRegion(paneId, "entry/fields");
+  if (!collection) {
+    return {
+      collection: "",
+      draft: false,
+      draftAxis: "hidden",
+      draftHint: DRAFT_MEANING,
+      emptyLine: emptyLine(tab),
+      fieldsRegion,
+      name: "",
+      note: "",
+      noteState: "hidden",
+      region,
+      stage: "empty"
+    };
+  }
+  const fields = entryFields(tab);
+  const draft = isDraftEntry(fields);
+  return {
+    collection: collection.name,
+    draft,
+    draftAxis: hasDraftAxis(collection.schema, fields) ? "shown" : "hidden",
+    draftHint: DRAFT_MEANING,
+    emptyLine: "",
+    fieldsRegion,
+    name: tab.documentPath?.split("/").pop() ?? "Untitled",
+    note: DRAFT_MEANING,
+    noteState: draft ? "shown" : "hidden",
+    region,
+    stage: "entry"
+  };
+}
+function renderEntryMode(surface, tab) {
+  const { paneId, wrap: canvasWrap } = surface;
+  if (entryPaneMounted(paneId, tab)) {
+    return;
+  }
+  detachEntryPane(paneId);
+  let panel = null;
+  let formHost = null;
+  const redraw = () => {
+    if (panel !== null && activeIn(paneId) === panel) {
+      draw();
+    }
+  };
+  const paintForm = (collection) => {
+    if (!formHost || !collection) {
+      return;
+    }
+    const fields = entryFields(tab);
+    const form = mountSchemaForm(`entry:${paneId}`, collection.schema, fields, {
+      context: formContext(tab),
+      errors: absentRequiredErrors(collection, fields),
+      onChange: (patch) => commitEntryFields(tab, patch),
+      rerender: redraw
+    });
+    if (form.parentNode !== formHost) {
+      formHost.replaceChildren(form);
+    }
+  };
+  const draw = () => {
+    const collection = collectionOfPath(tab.documentPath);
+    if (!collection) {
+      formHost = null;
+    }
+    panel?.surface.update(entryView(paneId, tab, collection));
+    paintForm(collection);
+  };
+  const scope = effectScope();
+  const mounted = mountEntryEditorSurface(canvasWrap, entryView(paneId, tab, collectionOfPath(tab.documentPath)), {
+    openContentTypes: () => {
+      activeRegistry()?.run("settings.open", { section: "content" });
+    },
+    setDraft: (draft) => setEntryDraft(tab, draft)
+  }, {
+    fieldsSlot: (host) => {
+      formHost = host;
+      paintForm(collectionOfPath(tab.documentPath));
+    }
+  });
+  panel = { paneId, scope, surface: mounted, tabId: tab.id, wrap: canvasWrap };
+  _active.set(paneId, panel);
+  scope.run(() => {
+    effect(() => {
+      if (activeIn(paneId) !== panel) {
+        return;
+      }
+      tab.doc.document;
+      tab.doc.content?.frontmatter;
+      projectState?.projectConfig?.content;
+      draw();
+    });
+  });
+}
+async function openEntryEditor(path) {
+  const { openFileInTab } = await (__preload("hnxqxtsg"), import("./files-hnxqxtsg.js"));
+  await openFileInTab(path);
+  for (const [id, tab] of workspace2.tabs.entries()) {
+    if (tab.documentPath !== path) {
+      continue;
+    }
+    for (const mode of ENTRY_TAB_MODES) {
+      if (!tab.capabilities.modes.includes(mode)) {
+        tab.capabilities.modes.unshift(mode);
+      }
+    }
+    tab.session.ui.canvasMode = ENTRY_MODE;
+    tab.session.ui.preview = false;
+    activateTab2(id);
+    return tab;
+  }
+  return null;
+}
+
+// src/content/entry-commands.ts
+function creatableCollections() {
+  return entryCollections().map((collection) => collection.name);
+}
+async function seedText(collection) {
+  const seed = seedEntry(collection.schema);
+  const formatName = (collection.def.format ? formatByName2(collection.def.format)?.name : undefined) ?? formatForPath2(`untitled${collection.ext}`)?.name ?? defaultContentFormat2()?.name;
+  if (collection.ext === ".json" || formatName === undefined) {
+    return serializeJson(seed, null);
+  }
+  return formatSerialize2(formatName, { ...seed, children: [] }, { frontmatter: Object.keys(seed).length > 0, mode: "roundtrip" });
+}
+async function createEntry2(collectionName, opts = {}) {
+  const collection = entryCollection(collectionName);
+  if (!collection) {
+    notify2.error(`No content collection named "${collectionName}" to create an entry in.`, {
+      detail: "A collection needs a `content` entry in project.json whose `source` is a directory. A " + "collection whose source names a single file (a CSV catalogue) has rows, not entry files.",
+      source: "Content"
+    });
+    return null;
+  }
+  await loadFormats2().catch(() => {});
+  let content;
+  try {
+    content = await seedText(collection);
+  } catch (error) {
+    notify2.error(`Could not prepare a new ${collection.name} entry.`, {
+      detail: errorMessage2(error),
+      path: collection.dir,
+      source: "Content"
+    });
+    return null;
+  }
+  const requested = opts.dir;
+  const destination = requested !== undefined && collectionForDirectory(requested)?.name === collection.name ? requested : collection.dir;
+  if (destination.includes(LOCALE_PLACEHOLDER)) {
+    notify2.error(`"${collection.name}" is a localized collection.`, {
+      detail: `Its entries live in one directory per language (${collection.dir}). Open the folder for ` + "the language you are writing in and create the entry there.",
+      path: collection.dir,
+      source: "Content"
+    });
+    return null;
+  }
+  const { createFileIn } = await (__preload("hnxqxtsg"), import("./files-hnxqxtsg.js"));
+  const created = await createFileIn({
+    content,
+    dir: destination,
+    format: { ext: collection.ext, kind: "fixed" },
+    source: "Content",
+    suggestedName: "untitled",
+    title: `New ${collection.name} entry`
+  });
+  if (created === null) {
+    return null;
+  }
+  invalidateReferenceEntries(collection.name);
+  await openEntryEditor(created);
+  return created;
+}
+function activeEntryTab() {
+  const tab = activeTab2.value;
+  return tab && collectionOfPath(tab.documentPath) ? tab : null;
+}
+function contentCommands() {
+  return [
+    {
+      args: argsSchema({
+        collection: derivedEnumProperty(creatableCollections, "The content collection the entry is created in.")
+      }),
+      category: "File",
+      id: "content.newEntry",
+      level: "project",
+      menus: ["palette"],
+      group: "1_file",
+      requires: "a project with a directory-backed content collection",
+      when: (ctx) => ctx.project.open,
+      enablement: () => creatableCollections().length > 0,
+      undo: "project",
+      run: async (_ctx, args) => {
+        const names = creatableCollections();
+        await createEntry2(enumArg("content.newEntry", args, "collection", names));
+      },
+      title: "New Entry"
+    },
+    {
+      args: argsSchema({
+        path: stringProperty("Project-relative path of the entry file to open.")
+      }),
+      category: "File",
+      id: "content.openEntry",
+      level: "project",
+      menus: ["context/file", "palette"],
+      group: "1_file",
+      requires: "an open project",
+      when: (ctx) => ctx.project.open,
+      run: async (_ctx, args) => {
+        await openEntryEditor(stringArg("content.openEntry", args, "path"));
+      },
+      title: "Open Entry Form"
+    },
+    {
+      args: argsSchema({
+        draft: booleanProperty("True marks the open entry a draft; false marks it published. Written as a `draft` field on the entry.")
+      }),
+      category: "Document",
+      id: "content.setDraft",
+      level: "document",
+      menus: ["context/tab", "palette"],
+      group: "3_document",
+      requires: "a content entry open",
+      when: (ctx) => ctx.document.open,
+      enablement: () => activeEntryTab() !== null,
+      undo: "document",
+      run: (_ctx, args) => {
+        const tab = activeEntryTab();
+        if (!tab) {
+          throw new Error("content.setDraft: the active document is not a content entry");
+        }
+        setEntryDraft(tab, booleanArg("content.setDraft", args, "draft"));
+      },
+      title: "Set Draft"
+    },
+    {
+      args: argsSchema({
+        include: booleanProperty("True lists entries marked `draft: true` alongside the rest.")
+      }),
+      category: "View",
+      id: "content.setIncludeDrafts",
+      level: "project",
+      menus: ["palette"],
+      group: "2_view",
+      requires: "an open project",
+      when: (ctx) => ctx.project.open,
+      run: async (_ctx, args) => {
+        setIncludeDrafts(booleanArg("content.setIncludeDrafts", args, "include"));
+        await reloadDraftAwareGrids2();
+      },
+      title: "Include Drafts"
+    }
+  ];
+}
+function registerContentCommands2(registry) {
+  registry.registerAll(contentCommands());
+}
+
+export { FIELD_TYPES, FORMAT_OPTIONS, detectFieldType, detectFieldFormat, schemaForType, referenceEntryState, entryFields, entryPaneMounted, detachEntryPane, entryDraftPill, renderEntryMode, createEntry2, registerContentCommands2 };
+
+//# debugId=BCB2AC86669613BA64756E2164756E21
+//# sourceMappingURL=studio-b4s9eykd.js.map