@jxsuite/studio 4.1.0 → 5.1.0

package/dist/chunks/studio-sbjyc8bt.js

@@ -0,0 +1,954 @@
+import {
+  errorMessage2
+} from "./studio-yxa81f45.js";
+import {
+  getPlatform2
+} from "./studio-6nzaktvy.js";
+import {
+  reactive,
+  notify2
+} from "./studio-p1dw8wfw.js";
+import {
+  projectState
+} from "./studio-6ewqv390.js";
+import {
+  paneRegion,
+  registerSurface,
+  mountSurface
+} from "./studio-vfq8qpjt.js";
+import {
+  mountSchemaForm,
+  resolveContextPointer
+} from "./studio-js8nv53n.js";
+import {
+  validateProjectConfig2
+} from "./studio-kcgff4r0.js";
+import {
+  deriveSecretEnvName
+} from "./studio-pxbgypmg.js";
+import {
+  paneOfContainer
+} from "./studio-1z1kcjv4.js";
+import {
+  commitProjectConfig
+} from "./studio-qk90fgqm.js";
+// src/surfaces/settings-contributed.json
+var settings_contributed_default = {
+  $schema: "https://jxsuite.com/schema/v1",
+  $id: "StudioSettingsContributed",
+  $description: 'The generic settings section behind `$studio.settings` (specs/extensions.md §9.1), as a Jx document over the kit. One document serves both layouts an extension may declare: "form" is a single schema form over the whole section value, "map" is master-detail — the entry keys on the left, the selected entry\'s form on the right. The adapter (`surfaces/settings-contributed.ts`) hands in the title, the layout, the entry rows already marked as selected, and whatever the reader is part-way through typing; `settings/contributed-section.ts` decides what an entry may be named, what reaches `project.json`, and what the validator said about it. The schema form itself is an ISLAND: this document renders `form-host` and nothing inside it, because a form built from a JSON Schema is `ui/schema-form.ts`\'s surface rather than this one\'s — the section places the element that surface hands back. The actions row is the second island: `panels/data-grid.ts` contributes it, and that one is still lit over Spectrum.',
+  tagName: "section",
+  attributes: {
+    part: "contributed"
+  },
+  style: {
+    $description: "What `.settings-section-title`, `.settings-two-col`, `.settings-list-panel`, `.settings-editor-panel`, `.settings-editor-header`, `.settings-empty-state` and `.settings-inline-form` said in `styles/overlays.css`, keyed on `part` and re-pointed at the studio token layer. This section was the LAST emitter of every one of them except `.settings-empty-state`, which `panels/settings-pane.ts` still writes when a project closes with the editor open — so those rules are dead in the stylesheet from here, and a central sweep removes them rather than this change, which owns no stylesheet. Two values could not come across. `.settings-editor-header h3` read `var(--spectrum-font-size-100, 14px)`, and a document is mounted in the pane rather than inside `<sp-theme>`, so it would have taken its hard-coded fallback every time; the entry name is a kit textfield now and carries the kit's own type ramp. And `.entry-name-input`, `.settings-form-panel`, `.settings-section` and `.contributed-section` had no rule anywhere at all — they were four entries on `check-styles.ts`'s orphan ledger, which is the ledger's point.",
+    display: "block",
+    '& [part="title"]': {
+      margin: "0 0 16px",
+      fontSize: "16px",
+      fontWeight: "600",
+      color: "var(--fg)"
+    },
+    '& [part="actions"]': {
+      $description: "The host-contributed actions row — Test Connection, Push Schema, Open Data Grid on the data sections. `.data-section-actions` never had a rule anywhere, so the row was whatever the buttons stacked up to; it is a row with a gap under it now.",
+      display: "flex",
+      alignItems: "center",
+      flexWrap: "wrap",
+      gap: "8px",
+      marginBottom: "12px"
+    },
+    '& [part="columns"]': {
+      $description: "The 1px gap over the border colour is the divider between the two columns: two panels on `--bg-panel` with `--border` showing through the gap, so nothing draws a rule of its own.",
+      display: "flex",
+      height: "100%",
+      gap: "1px",
+      background: "var(--border)"
+    },
+    '& [part="list"]': {
+      display: "flex",
+      flexDirection: "column",
+      gap: "4px",
+      padding: "12px",
+      width: "200px",
+      minWidth: "200px",
+      background: "var(--bg-panel)",
+      overflowY: "auto"
+    },
+    '& [part="entry"], & [part="new-open"]': {
+      width: "100%"
+    },
+    '& [part="entry"] > [part="control"], & [part="new-open"] > [part="control"]': {
+      $description: "`.settings-list-panel sp-action-button` said `width: 100%; justify-content: flex-start`, and both halves belong to the button the row is made of rather than to the row: a kit action button centres its glyph and its label, which reads as a list of centred names.",
+      width: "100%",
+      justifyContent: "flex-start"
+    },
+    '& [part="new-form"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "6px"
+    },
+    '& [part="new-field"]': {
+      flex: "1",
+      minWidth: "0"
+    },
+    '& [part="empty"]': {
+      flex: "1",
+      display: "flex",
+      alignItems: "center",
+      justifyContent: "center",
+      background: "var(--bg-panel)",
+      color: "var(--fg-dim)",
+      fontSize: "13px"
+    },
+    '& [part="editor"]': {
+      $description: "`min-width: 0` is the one line `.settings-editor-panel` did not have and needed: a flex child's floor is its content, and the schema form inside this one is a whole form rather than the short cards Data Shapes puts here — so a long pointer or a wide row pushed the column past the right edge of the pane instead of scrolling inside it.",
+      flex: "1",
+      padding: "16px",
+      background: "var(--bg-panel)",
+      overflowY: "auto",
+      minWidth: "0"
+    },
+    '& [part="editor-header"]': {
+      display: "flex",
+      alignItems: "center",
+      gap: "12px",
+      marginBottom: "16px"
+    },
+    '& [part="entry-name"]': {
+      flex: "1",
+      minWidth: "0",
+      maxWidth: "220px"
+    }
+  },
+  children: [
+    {
+      tagName: "h3",
+      attributes: {
+        part: "title"
+      },
+      textContent: "${state.title}"
+    },
+    {
+      tagName: "div",
+      attributes: {
+        part: "actions-slot",
+        role: "none"
+      },
+      style: {
+        display: "contents"
+      },
+      $switch: {
+        $ref: "#/state/actionsState"
+      },
+      cases: {
+        slot: {
+          $description: "An island: the host renders its own actions into this node and the document renders nothing inside it.",
+          tagName: "div",
+          attributes: {
+            part: "actions"
+          }
+        }
+      }
+    },
+    {
+      tagName: "div",
+      attributes: {
+        part: "body-slot",
+        role: "none"
+      },
+      style: {
+        display: "contents"
+      },
+      $switch: {
+        $ref: "#/state/layout"
+      },
+      cases: {
+        form: {
+          $description: "An island: `ui/schema-form.ts` draws the whole section value into this node.",
+          tagName: "div",
+          attributes: {
+            part: "form-host"
+          }
+        },
+        map: {
+          tagName: "div",
+          attributes: {
+            part: "columns"
+          },
+          children: [
+            {
+              tagName: "div",
+              attributes: {
+                part: "list"
+              },
+              children: [
+                {
+                  $prototype: "Array",
+                  items: {
+                    $ref: "#/state/entries"
+                  },
+                  key: {
+                    $ref: "$map/item/key"
+                  },
+                  map: {
+                    tagName: "jx-action-button",
+                    attributes: {
+                      part: "entry",
+                      "data-entry": "${$map.item.key}",
+                      "data-jx-region": "${$map.item.region}"
+                    },
+                    $props: {
+                      label: "${$map.item.key}",
+                      selected: {
+                        $ref: "$map/item/selected"
+                      },
+                      quiet: true,
+                      size: "sm"
+                    },
+                    onclick: {
+                      $prototype: "Function",
+                      body: [
+                        {
+                          operator: "call",
+                          target: {
+                            $ref: "#/state/select"
+                          },
+                          value: [
+                            {
+                              $ref: "$map/item/key"
+                            }
+                          ]
+                        }
+                      ]
+                    },
+                    children: [
+                      {
+                        tagName: "span",
+                        textContent: "${$map.item.key}"
+                      }
+                    ]
+                  }
+                },
+                {
+                  tagName: "div",
+                  attributes: {
+                    part: "new-slot",
+                    role: "none"
+                  },
+                  style: {
+                    display: "contents"
+                  },
+                  $switch: {
+                    $ref: "#/state/newState"
+                  },
+                  cases: {
+                    closed: {
+                      tagName: "jx-action-button",
+                      attributes: {
+                        part: "new-open"
+                      },
+                      $props: {
+                        label: "New Entry",
+                        icon: "plus",
+                        quiet: true,
+                        size: "sm"
+                      },
+                      onclick: {
+                        $prototype: "Function",
+                        body: [
+                          {
+                            operator: "call",
+                            target: {
+                              $ref: "#/state/openNew"
+                            },
+                            value: []
+                          }
+                        ]
+                      },
+                      children: [
+                        {
+                          tagName: "span",
+                          textContent: "New Entry"
+                        }
+                      ]
+                    },
+                    open: {
+                      tagName: "div",
+                      attributes: {
+                        part: "new-form"
+                      },
+                      children: [
+                        {
+                          tagName: "jx-textfield",
+                          attributes: {
+                            part: "new-field"
+                          },
+                          $props: {
+                            label: "New entry name",
+                            placeholder: "entry-name",
+                            size: "sm",
+                            value: {
+                              $ref: "#/state/newName"
+                            }
+                          },
+                          oninput: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                operator: "call",
+                                target: {
+                                  $ref: "#/state/editNew"
+                                },
+                                value: [
+                                  {
+                                    $ref: "event#/target/value"
+                                  }
+                                ]
+                              }
+                            ]
+                          },
+                          onkeydown: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                $switch: {
+                                  $ref: "event#/key"
+                                },
+                                cases: {
+                                  Enter: [
+                                    {
+                                      preventDefault: true
+                                    },
+                                    {
+                                      operator: "call",
+                                      target: {
+                                        $ref: "#/state/createNew"
+                                      },
+                                      value: []
+                                    }
+                                  ],
+                                  Escape: [
+                                    {
+                                      preventDefault: true
+                                    },
+                                    {
+                                      operator: "call",
+                                      target: {
+                                        $ref: "#/state/cancelNew"
+                                      },
+                                      value: []
+                                    }
+                                  ]
+                                }
+                              }
+                            ]
+                          }
+                        },
+                        {
+                          tagName: "jx-button",
+                          attributes: {
+                            part: "new-create"
+                          },
+                          $props: {
+                            size: "sm"
+                          },
+                          onclick: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                operator: "call",
+                                target: {
+                                  $ref: "#/state/createNew"
+                                },
+                                value: []
+                              }
+                            ]
+                          },
+                          children: [
+                            {
+                              tagName: "span",
+                              textContent: "Create"
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            },
+            {
+              tagName: "div",
+              attributes: {
+                part: "editor-slot",
+                role: "none"
+              },
+              style: {
+                display: "contents"
+              },
+              $switch: {
+                $ref: "#/state/editorState"
+              },
+              cases: {
+                empty: {
+                  tagName: "div",
+                  attributes: {
+                    part: "empty"
+                  },
+                  textContent: "Select or create an entry"
+                },
+                editing: {
+                  tagName: "div",
+                  attributes: {
+                    part: "editor",
+                    "data-jx-region": "${state.editorRegion}"
+                  },
+                  children: [
+                    {
+                      tagName: "div",
+                      attributes: {
+                        part: "editor-header"
+                      },
+                      children: [
+                        {
+                          tagName: "jx-textfield",
+                          attributes: {
+                            part: "entry-name"
+                          },
+                          $props: {
+                            label: "Entry name",
+                            size: "sm",
+                            value: {
+                              $ref: "#/state/entryName"
+                            }
+                          },
+                          onchange: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                operator: "call",
+                                target: {
+                                  $ref: "#/state/renameEntry"
+                                },
+                                value: [
+                                  {
+                                    $ref: "event#/target/value"
+                                  }
+                                ]
+                              }
+                            ]
+                          },
+                          onkeydown: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                $switch: {
+                                  $ref: "event#/key"
+                                },
+                                cases: {
+                                  Enter: [
+                                    {
+                                      operator: "call",
+                                      target: {
+                                        $ref: "#/state/renameEntry"
+                                      },
+                                      value: [
+                                        {
+                                          $ref: "event#/target/value"
+                                        }
+                                      ]
+                                    }
+                                  ],
+                                  Escape: [
+                                    {
+                                      operator: "call",
+                                      target: {
+                                        $ref: "#/state/cancelRename"
+                                      },
+                                      value: [
+                                        {
+                                          $ref: "event#/target/value"
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              }
+                            ]
+                          }
+                        },
+                        {
+                          tagName: "jx-action-button",
+                          attributes: {
+                            part: "delete-entry"
+                          },
+                          $props: {
+                            label: "Delete entry",
+                            hint: "Delete entry",
+                            icon: "trash",
+                            quiet: true,
+                            size: "sm"
+                          },
+                          onclick: {
+                            $prototype: "Function",
+                            body: [
+                              {
+                                operator: "call",
+                                target: {
+                                  $ref: "#/state/removeEntry"
+                                },
+                                value: []
+                              }
+                            ]
+                          }
+                        }
+                      ]
+                    },
+                    {
+                      $description: "An island: `ui/schema-form.ts` draws the selected entry into this node.",
+                      tagName: "div",
+                      attributes: {
+                        part: "form-host"
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          ]
+        }
+      }
+    }
+  ]
+};
+
+// src/surfaces/settings-contributed.ts
+registerSurface("settings-contributed", settings_contributed_default);
+function emptyView() {
+  return {
+    actionsState: "none",
+    editorRegion: "",
+    editorState: "empty",
+    entries: [],
+    entryName: "",
+    layout: "form",
+    newName: "",
+    newState: "closed",
+    title: ""
+  };
+}
+function partOf(def) {
+  const attributes = def?.attributes;
+  const part = attributes?.["part"];
+  return typeof part === "string" ? part : "";
+}
+function mountContributedSurface(host, actions, islands) {
+  host.textContent = "";
+  const scope = reactive({ ...emptyView(), ...actions });
+  let mounted = null;
+  let disposed = false;
+  const ready = mountSurface("settings-contributed", scope, host, {
+    onNodeCreated: (element, _path, def) => {
+      if (!(element instanceof HTMLElement)) {
+        return;
+      }
+      const part = partOf(def);
+      if (part === "form-host") {
+        islands.formSlot(element);
+      } else if (part === "actions") {
+        islands.actionsSlot(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;
+    },
+    host,
+    ready,
+    update(view) {
+      scope.actionsState = view.actionsState;
+      scope.editorRegion = view.editorRegion;
+      scope.editorState = view.editorState;
+      scope.entries = view.entries;
+      scope.entryName = view.entryName;
+      scope.layout = view.layout;
+      scope.newName = view.newName;
+      scope.newState = view.newState;
+      scope.title = view.title;
+    }
+  };
+}
+
+// src/settings/contributed-section.ts
+var selectedEntries = new Map;
+var newEntryOpen = new Set;
+var newEntryNames = new Map;
+function selectContributedEntry(sectionKey, entryKey) {
+  const section = projectState?.projectConfig?.[sectionKey];
+  const entries = section && typeof section === "object" && !Array.isArray(section) ? section : {};
+  if (!Object.hasOwn(entries, entryKey)) {
+    return Object.keys(entries);
+  }
+  selectedEntries.set(sectionKey, entryKey);
+  return null;
+}
+var diagnostics = new Map;
+function routeDiagnostics(base, messages) {
+  const fields = {};
+  const section = [];
+  for (const message of messages) {
+    const at = message.indexOf(": ");
+    const pointer = at === -1 ? "" : message.slice(0, at);
+    const text = at === -1 ? message : message.slice(at + 2);
+    if (pointer === base) {
+      section.push(text);
+      continue;
+    }
+    if (!pointer.startsWith(`${base}/`)) {
+      continue;
+    }
+    const [prop] = pointer.slice(base.length + 1).split("/");
+    if (prop && fields[prop] === undefined) {
+      fields[prop] = text;
+    }
+  }
+  return { fields, section };
+}
+async function saveProjectConfig(base, rerender) {
+  const config = projectState.projectConfig;
+  const commit = await commitProjectConfig();
+  if (!commit.ok) {
+    return;
+  }
+  let messages = [];
+  try {
+    messages = await validateProjectConfig2(config);
+  } catch (error) {
+    notify2.warn(`Could not validate project.json — ${errorMessage2(error)}`, {
+      key: "settings:validator",
+      path: "project.json",
+      source: "Settings",
+      tier: "problem"
+    });
+    return;
+  }
+  diagnostics.set(base, routeDiagnostics(base, messages).fields);
+  rerender();
+}
+function applyPatch(target, patch) {
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === undefined) {
+      delete target[key];
+    } else {
+      target[key] = value;
+    }
+  }
+}
+function slugify(name) {
+  return name.toLowerCase().replaceAll(/\s+/g, "-").replaceAll(/[^a-z0-9-]/g, "");
+}
+function instantiateNewEntry(template, key) {
+  if (!template) {
+    return {};
+  }
+  const substitute = (value) => {
+    if (typeof value === "string") {
+      return value.replaceAll("${key}", key);
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => substitute(item));
+    }
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = substitute(v);
+      }
+      return out;
+    }
+    return value;
+  };
+  return substitute(template);
+}
+function buildContext(sectionKey, opts, entryKey = null) {
+  const platform = getPlatform2();
+  return {
+    fieldKeyPrefix: `$settings.${sectionKey}`,
+    resolvePointer: (pointer, scope) => resolveContextPointer(pointer, {
+      projectConfig: projectState?.projectConfig ?? {},
+      ...scope !== undefined && { scope },
+      ...opts.formats !== undefined && { formats: opts.formats }
+    }),
+    ...typeof platform.setSecrets === "function" ? {
+      commitSecret: async (key, value) => {
+        const envName = deriveSecretEnvName(sectionKey, entryKey, key);
+        await platform.setSecrets({ set: { [envName]: value } });
+        return envName;
+      }
+    } : {}
+  };
+}
+function sectionValue(key) {
+  const config = projectState?.projectConfig;
+  if (!config) {
+    return null;
+  }
+  const existing = config[key];
+  if (existing && typeof existing === "object" && !Array.isArray(existing)) {
+    return existing;
+  }
+  const fresh = {};
+  config[key] = fresh;
+  return fresh;
+}
+var mounts = new WeakMap;
+function redraw(record) {
+  renderContributedSection(record.container, record.contribution, record.opts);
+}
+function say(record, value) {
+  record.echo = value;
+  redraw(record);
+}
+function project(record) {
+  const { container, contribution, opts } = record;
+  const sectionKey = contribution.key;
+  const title = contribution.title ?? sectionKey;
+  const actionsState = opts.actions ? "slot" : "none";
+  const paneId = paneOfContainer(container);
+  const editorRegion = paneRegion(paneId, "editor");
+  if ((contribution.settings.layout ?? "form") !== "map") {
+    return {
+      actionsState,
+      editorRegion,
+      editorState: "empty",
+      entries: [],
+      entryName: "",
+      layout: "form",
+      newName: "",
+      newState: "closed",
+      title
+    };
+  }
+  const entries = sectionValue(sectionKey) ?? {};
+  const selected = selectedEntries.get(sectionKey) ?? null;
+  const value = selected === null ? undefined : entries[selected];
+  const editing = selected !== null && value !== undefined && value !== null && typeof value === "object";
+  return {
+    actionsState,
+    editorRegion,
+    editorState: editing ? "editing" : "empty",
+    entries: Object.keys(entries).map((name) => ({
+      key: name,
+      region: paneRegion(paneId, `entry:${name}`),
+      selected: name === selected
+    })),
+    entryName: record.echo ?? (editing ? selected : ""),
+    layout: "map",
+    newName: newEntryNames.get(sectionKey) ?? "",
+    newState: newEntryOpen.has(sectionKey) ? "open" : "closed",
+    title
+  };
+}
+function paintForm(record) {
+  const host = record.formHost;
+  if (!host) {
+    return;
+  }
+  const { contribution, opts } = record;
+  const sectionKey = contribution.key;
+  const ui = contribution.settings.entry?.ui;
+  const rerender = () => redraw(record);
+  const place = (form) => {
+    if (form.parentNode !== host) {
+      host.replaceChildren(form);
+    }
+  };
+  if ((contribution.settings.layout ?? "form") !== "map") {
+    const base = `/${sectionKey}`;
+    place(mountSchemaForm(`section:${sectionKey}`, contribution.entrySchema, sectionValue(sectionKey) ?? {}, {
+      context: buildContext(sectionKey, opts, null),
+      errors: diagnostics.get(base) ?? {},
+      onChange: (patch) => {
+        const target = sectionValue(sectionKey);
+        if (!target) {
+          return;
+        }
+        applyPatch(target, patch);
+        rerender();
+        saveProjectConfig(base, rerender);
+      },
+      rerender,
+      ...ui !== undefined && { ui }
+    }));
+    return;
+  }
+  const entries = sectionValue(sectionKey) ?? {};
+  const selected = selectedEntries.get(sectionKey) ?? null;
+  const value = selected === null ? undefined : entries[selected];
+  if (selected === null || !value || typeof value !== "object") {
+    host.replaceChildren();
+    return;
+  }
+  const entry = value;
+  const base = `/${sectionKey}/${selected}`;
+  place(mountSchemaForm(`section:${sectionKey}:${selected}`, contribution.entrySchema, entry, {
+    context: buildContext(sectionKey, opts, selected),
+    errors: diagnostics.get(base) ?? {},
+    onChange: (patch) => {
+      applyPatch(entry, patch);
+      rerender();
+      saveProjectConfig(base, rerender);
+    },
+    rerender,
+    ...ui !== undefined && { ui }
+  }));
+}
+function paintActions(record) {
+  const host = record.actionsHost;
+  const { actions } = record.opts;
+  if (!host) {
+    return;
+  }
+  if (!actions) {
+    host.replaceChildren();
+    return;
+  }
+  const sectionKey = record.contribution.key;
+  const selected = (record.contribution.settings.layout ?? "form") === "map" ? selectedEntries.get(sectionKey) ?? null : null;
+  actions(host, { rerender: () => redraw(record), sectionKey, selected });
+}
+function actionsFor(record) {
+  const done = (base) => {
+    record.echo = null;
+    redraw(record);
+    saveProjectConfig(base, () => redraw(record));
+  };
+  const refuse = () => {
+    record.echo = null;
+    redraw(record);
+  };
+  const keyOf = () => record.contribution.key;
+  return {
+    cancelNew() {
+      newEntryOpen.delete(keyOf());
+      newEntryNames.delete(keyOf());
+      redraw(record);
+    },
+    cancelRename(held) {
+      say(record, held);
+      refuse();
+    },
+    createNew() {
+      const sectionKey = keyOf();
+      const slug = slugify(newEntryNames.get(sectionKey) ?? "");
+      const target = sectionValue(sectionKey);
+      if (!slug || !target || target[slug]) {
+        return;
+      }
+      target[slug] = instantiateNewEntry(record.contribution.settings.entry?.newEntry, slug);
+      selectedEntries.set(sectionKey, slug);
+      newEntryOpen.delete(sectionKey);
+      newEntryNames.delete(sectionKey);
+      done(`/${sectionKey}`);
+    },
+    editNew(value) {
+      newEntryNames.set(keyOf(), value);
+      redraw(record);
+    },
+    openNew() {
+      newEntryOpen.add(keyOf());
+      redraw(record);
+    },
+    removeEntry() {
+      const sectionKey = keyOf();
+      const selected = selectedEntries.get(sectionKey) ?? null;
+      const target = sectionValue(sectionKey);
+      if (!selected || !target?.[selected]) {
+        return;
+      }
+      delete target[selected];
+      selectedEntries.set(sectionKey, null);
+      done(`/${sectionKey}`);
+    },
+    renameEntry(value) {
+      say(record, value);
+      const sectionKey = keyOf();
+      const selected = selectedEntries.get(sectionKey) ?? null;
+      const target = sectionValue(sectionKey);
+      const slug = slugify(value.trim());
+      if (!selected || !target || !slug || slug === selected || target[slug]) {
+        refuse();
+        return;
+      }
+      const next = {};
+      for (const [k, v] of Object.entries(target)) {
+        next[k === selected ? slug : k] = v;
+        delete target[k];
+      }
+      Object.assign(target, next);
+      selectedEntries.set(sectionKey, slug);
+      done(`/${sectionKey}`);
+    },
+    select(name) {
+      selectedEntries.set(keyOf(), name);
+      record.echo = null;
+      redraw(record);
+    }
+  };
+}
+function renderContributedSection(container, contribution, opts = {}) {
+  let record = mounts.get(container);
+  if (record) {
+    record.contribution = contribution;
+    record.opts = opts;
+  }
+  if (!record?.handle.attached()) {
+    record?.handle.dispose();
+    const fresh = {
+      actionsHost: null,
+      container,
+      contribution,
+      echo: null,
+      formHost: null,
+      handle: undefined,
+      opts
+    };
+    mounts.set(container, fresh);
+    fresh.handle = mountContributedSurface(container, actionsFor(fresh), {
+      actionsSlot: (host) => {
+        fresh.actionsHost = host;
+        paintActions(fresh);
+      },
+      formSlot: (host) => {
+        fresh.formHost = host;
+        paintForm(fresh);
+      }
+    });
+    record = fresh;
+  }
+  record.handle.update(project(record));
+  paintActions(record);
+  paintForm(record);
+}
+
+export { selectContributedEntry, renderContributedSection };
+
+//# debugId=E288D4A2952F914964756E2164756E21
+//# sourceMappingURL=studio-sbjyc8bt.js.map