@jxsuite/studio 2.0.1 → 2.1.0

package/dist/chunks/studio-c6s5getc.js

@@ -0,0 +1,4232 @@
+import {
+  live
+} from "./studio-xmvbhg31.js";
+import {
+  BLESSED_GLOBALS,
+  BLESSED_OPERATORS,
+  PURE_METHOD_OPS,
+  intlHelpersClause,
+  rectOf,
+  renderEmptyState
+} from "./studio-v96qfnww.js";
+import {
+  LANGUAGE_TAG_PATTERN,
+  activeTab,
+  getLayerSlot
+} from "./studio-41exgzhq.js";
+import {
+  classMap,
+  ifDefined,
+  styleMap
+} from "./studio-ckwz4d3x.js";
+import {
+  ref
+} from "./studio-p471gg5n.js";
+import {
+  html,
+  nothing,
+  render
+} from "./studio-5x5774ak.js";
+import {
+  isFunctionDef,
+  isJsonObject,
+  isNamedFormulaDef,
+  isRef,
+  isTemplateString
+} from "./studio-cjm7fdjf.js";
+import {
+  cloneValue
+} from "./studio-5ehhackm.js";
+
+// src/panels/provenance.ts
+var PROVENANCE_TITLES = {
+  bound: "Bound",
+  default: "Not set",
+  inherited: "Inherited",
+  mixed: "Mixed",
+  set: "Set here"
+};
+function provenanceText(p) {
+  if (p.state === "inherited") {
+    return p.donor ? `from ${p.donor}` : "inherited";
+  }
+  if (p.state === "bound") {
+    return p.donor ?? "bound";
+  }
+  if (p.state === "mixed") {
+    return p.donor ? `mixed (${p.donor})` : "mixed";
+  }
+  return "";
+}
+function provenanceTitle(prop, p) {
+  if (p.title) {
+    return p.title;
+  }
+  const lead = PROVENANCE_TITLES[p.state];
+  if (p.state === "inherited") {
+    return `${lead} from ${p.donor ?? "the cascade"} — click to go there`;
+  }
+  if (p.state === "bound") {
+    return p.donor ? `${lead} to ${p.donor} — click to open it` : lead;
+  }
+  if (p.state === "set") {
+    return `${lead} — click to clear ${prop}`;
+  }
+  if (p.state === "mixed") {
+    const count = p.donor ? `${p.donor} selected elements` : "the selected elements";
+    return `${lead} — ${count} have different values for ${prop}; typing sets them all`;
+  }
+  return `${lead} — ${prop} falls back to the browser default`;
+}
+function renderProvenanceChip(prop, p) {
+  if (p.state === "default") {
+    return nothing;
+  }
+  const text = provenanceText(p);
+  const title = provenanceTitle(prop, p);
+  const isDot = p.state === "set";
+  const classes = classMap({
+    "provenance-chip": true,
+    [`provenance-chip--${p.state}`]: true,
+    "set-dot": isDot
+  });
+  const { onClick } = p;
+  if (!onClick) {
+    return html`<span class=${classes} title=${title}>${text}</span>`;
+  }
+  const activate = (e) => {
+    e.stopPropagation();
+    e.preventDefault();
+    onClick();
+  };
+  return isDot ? html`<span class=${classes} title=${title} @click=${activate}>${text}</span>` : html`<button type="button" class=${classes} title=${title} @click=${activate}>
+        ${text}
+      </button>`;
+}
+function countProvenance(states) {
+  const counts = { bound: 0, inherited: 0, mixed: 0, set: 0 };
+  for (const state of states) {
+    if (state !== "default") {
+      counts[state] += 1;
+    }
+  }
+  return counts;
+}
+function hasProvenance(counts) {
+  return counts.set > 0 || counts.inherited > 0 || counts.bound > 0 || counts.mixed > 0;
+}
+function provenanceSummaryText(counts) {
+  const parts = [];
+  if (counts.set > 0) {
+    parts.push(`${counts.set} set here`);
+  }
+  if (counts.inherited > 0) {
+    parts.push(`${counts.inherited} inherited`);
+  }
+  if (counts.bound > 0) {
+    parts.push(`${counts.bound} bound`);
+  }
+  if (counts.mixed > 0) {
+    parts.push(`${counts.mixed} mixed`);
+  }
+  return parts.length > 0 ? parts.join(" · ") : "nothing set";
+}
+function renderProvenanceDots(counts, opts = {}) {
+  if (!hasProvenance(counts)) {
+    return nothing;
+  }
+  const summary = provenanceSummaryText(counts);
+  return html`
+    <span class="provenance-dots" title=${summary} aria-label=${summary}>
+      ${counts.set > 0 ? renderProvenanceChip("section", {
+    state: "set",
+    title: opts.clearTitle ?? summary,
+    ...opts.onClearSet ? { onClick: opts.onClearSet } : {}
+  }) : nothing}
+      ${counts.inherited > 0 ? html`<span
+              class="provenance-chip provenance-chip--inherited set-dot"
+              title=${summary}
+            ></span>` : nothing}
+      ${counts.bound > 0 ? html`<span
+              class="provenance-chip provenance-chip--bound set-dot"
+              title=${summary}
+            ></span>` : nothing}
+      ${counts.mixed > 0 ? html`<span
+              class="provenance-chip provenance-chip--mixed set-dot"
+              title=${summary}
+            ></span>` : nothing}
+    </span>
+  `;
+}
+
+// src/ui/field-row.ts
+function renderFieldRow({
+  prop,
+  label,
+  hasValue,
+  onClear,
+  widget,
+  labelExtra,
+  span,
+  warning,
+  provenance,
+  error,
+  errorCount
+}) {
+  const invalid = Boolean(error);
+  const chip = provenance ?? (hasValue && onClear ? { onClick: onClear, state: "set", title: `Clear ${prop}` } : undefined);
+  return html`
+    <div
+      class=${classMap({
+    "style-row": true,
+    "style-row--invalid": invalid,
+    "style-row--warning": Boolean(warning) && !invalid
+  })}
+      data-prop=${prop}
+      style=${span === 2 ? "grid-column: 1 / -1" : ""}
+    >
+      <div class="style-row-label">
+        ${chip ? renderProvenanceChip(prop, chip) : nothing}
+        <sp-field-label size="s" title=${prop}>${label}</sp-field-label>
+        ${labelExtra ?? nothing}
+      </div>
+      ${widget}
+      ${invalid ? html`<p class="style-row-error" role="alert">
+              ${error}${errorCount !== undefined && errorCount > 1 ? html`<span class="style-row-error-count">×${errorCount}</span>` : nothing}
+            </p>` : nothing}
+    </div>
+  `;
+}
+function renderKvRow({
+  name,
+  value,
+  onCommit,
+  onDelete,
+  placeholderFor,
+  debounceMs = 400
+}) {
+  let debounce;
+  let currentName = name;
+  let currentValue = value;
+  const commit = () => {
+    clearTimeout(debounce);
+    debounce = setTimeout(() => onCommit(currentName, currentValue), debounceMs);
+  };
+  return html`
+    <div class="kv-row" data-prop=${name}>
+      <sp-textfield
+        size="s"
+        class="kv-key"
+        .value=${name}
+        @input=${(e) => {
+    currentName = e.target.value;
+    commit();
+  }}
+        @change=${placeholderFor ? (e) => {
+    const cell = e.target.closest(".kv-row")?.querySelector(".kv-val");
+    cell?.setAttribute("placeholder", placeholderFor(e.target.value));
+  } : nothing}
+      ></sp-textfield>
+      <sp-textfield
+        size="s"
+        class="kv-val"
+        .value=${value}
+        placeholder=${placeholderFor ? placeholderFor(name) : ""}
+        @input=${(e) => {
+    currentValue = e.target.value;
+    commit();
+  }}
+      ></sp-textfield>
+      <sp-action-button size="xs" quiet title="Remove ${name}" @click=${onDelete}>
+        <sp-icon-close slot="icon"></sp-icon-close>
+      </sp-action-button>
+    </div>
+  `;
+}
+function renderStaticKvRow({ name, detail, value, tags }) {
+  return html`
+    <div class="kv-static-row" data-prop=${name}>
+      <code class="kv-static-name">${name}</code>
+      ${detail ? html`<span class="kv-static-detail">${detail}</span>` : nothing}
+      ${value ? html`<span class="kv-static-value">${value}</span>` : nothing}
+      ${(tags ?? []).map((tag) => html`<span class="kv-static-tag">${tag}</span>`)}
+    </div>
+  `;
+}
+
+// src/ui/formula-chips.ts
+function isExprNode(value) {
+  return isJsonObject(value) && typeof value.operator === "string";
+}
+function refLabel(ref2) {
+  if (ref2.startsWith("#/state/")) {
+    return ref2.slice("#/state/".length);
+  }
+  if (ref2.startsWith("window#/")) {
+    return ref2.slice("window#/".length).replaceAll("/", ".");
+  }
+  return ref2 || "?";
+}
+function operandLabel(value) {
+  if (isRef(value)) {
+    return refLabel(value.$ref);
+  }
+  if (isExprNode(value)) {
+    return `(${chipSummary(value)})`;
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+function targetPath(basePath, hops) {
+  return [...basePath, ...Array.from({ length: hops }, () => "target")];
+}
+function unrollChain(node, basePath) {
+  const nodes = [];
+  let current = node;
+  for (;; ) {
+    nodes.push(current);
+    const next = current.target;
+    if (isExprNode(next)) {
+      current = next;
+    } else {
+      break;
+    }
+  }
+  const deepest = nodes.at(-1);
+  const head = "target" in deepest || deepest.target !== undefined ? { path: targetPath(basePath, nodes.length), value: deepest.target } : null;
+  const rootFirst = nodes.map((n, i) => ({ node: n, path: targetPath(basePath, i) }));
+  return { head, links: rootFirst.toReversed() };
+}
+function chipSummary(node) {
+  if (!isExprNode(node)) {
+    return operandLabel(node);
+  }
+  const { head, links } = unrollChain(node, []);
+  const parts = [];
+  if (head) {
+    parts.push(operandLabel(head.value));
+  }
+  for (const link of links) {
+    parts.push(String(link.node.operator));
+  }
+  return parts.join(" › ");
+}
+var CHIP_STYLE = "display:inline-flex;align-items:center;gap:4px;max-width:180px;padding:1px 7px;" + "border:1px solid var(--spectrum-gray-300, #3c3c3c);border-radius:10px;cursor:pointer;" + "background:var(--spectrum-gray-100, #232323);color:var(--spectrum-gray-800, #d0d0d0);" + "font-size:11px;font-family:var(--spectrum-code-font-family, monospace);line-height:18px";
+function renderChipBadge(preview, pathKey) {
+  const text = preview?.values.get(pathKey);
+  if (text === undefined) {
+    return nothing;
+  }
+  return html`
+    <span
+      class="expr-live-badge"
+      title=${text}
+      style="font-family:var(--spectrum-code-font-family, monospace);font-size:10px;line-height:16px;padding:0 5px;border-radius:4px;background:var(--spectrum-gray-200, #323232);color:var(--spectrum-seafoam-900, #35a690);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:120px;flex-shrink:1"
+      >${text}</span
+    >
+  `;
+}
+function renderChip(label, path, onSelect, preview, group = false) {
+  return html`
+    <button
+      type="button"
+      class=${group ? "formula-chip formula-chip--group" : "formula-chip"}
+      data-path=${path.join("/")}
+      style=${CHIP_STYLE}
+      title=${label}
+      @click=${() => onSelect(path)}
+    >
+      <span style="white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:110px"
+        >${label}</span
+      >
+      ${renderChipBadge(preview, path.join("/"))}
+    </button>
+  `;
+}
+function groupChips(link, onSelect, preview) {
+  const chips = [];
+  const add = (operand, path) => {
+    if (isExprNode(operand)) {
+      chips.push(renderChip(`(${chipSummary(operand)})`, path, onSelect, preview, true));
+    }
+  };
+  const { value, initial, cases } = link.node;
+  if (Array.isArray(value)) {
+    for (const [i, item] of value.entries()) {
+      add(item, [...link.path, "value", i]);
+    }
+  } else {
+    add(value, [...link.path, "value"]);
+  }
+  add(initial, [...link.path, "initial"]);
+  if (isJsonObject(cases)) {
+    for (const [key, operand] of Object.entries(cases)) {
+      add(operand, [...link.path, "cases", key]);
+    }
+  }
+  add(link.node.default, [...link.path, "default"]);
+  return chips;
+}
+function renderFormulaChips(node, onSelect, opts = {}) {
+  if (!isExprNode(node)) {
+    return html`${nothing}`;
+  }
+  const preview = opts.preview ?? null;
+  const basePath = opts.path ?? [];
+  const { head, links } = unrollChain(node, basePath);
+  const chips = [];
+  if (head) {
+    chips.push(renderChip(operandLabel(head.value), head.path, onSelect, preview));
+  }
+  for (const link of links) {
+    chips.push(renderChip(String(link.node.operator), link.path, onSelect, preview), ...groupChips(link, onSelect, preview));
+  }
+  return html`
+    <div
+      class="formula-chips"
+      style="display:flex;flex-wrap:wrap;gap:4px;align-items:center;padding:2px 0 6px"
+    >
+      ${chips}
+    </div>
+  `;
+}
+
+// ../formulas/src/catalog.ts
+var catalog = [
+  {
+    description: "Arithmetic mean of an array of numbers; 0 for an empty array.",
+    expression: {
+      operator: "?:",
+      target: {
+        $ref: "$args/values/length"
+      },
+      value: {
+        operator: "/",
+        target: {
+          operator: "reduce",
+          target: {
+            $ref: "$args/values"
+          },
+          initial: 0,
+          value: {
+            operator: "+",
+            target: {
+              $ref: "$reduce/acc"
+            },
+            value: {
+              $ref: "$map/item"
+            }
+          }
+        },
+        value: {
+          $ref: "$args/values/length"
+        }
+      },
+      initial: 0
+    },
+    name: "average",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "number[]"
+        }
+      }
+    ]
+  },
+  {
+    description: "Uppercase the first character of a string, leaving the rest unchanged (the CSS text-transform: capitalize shape for a single word).",
+    expression: {
+      operator: "+",
+      target: {
+        operator: "toUpperCase",
+        target: {
+          operator: "charAt",
+          target: {
+            $ref: "$args/text"
+          },
+          value: 0
+        }
+      },
+      value: {
+        operator: "slice",
+        target: {
+          $ref: "$args/text"
+        },
+        value: 1
+      }
+    },
+    name: "capitalize",
+    parameters: [
+      {
+        name: "text",
+        type: {
+          text: "string"
+        }
+      }
+    ]
+  },
+  {
+    description: "Bound a number to the [min, max] range (the TC39 Math.clamp shape): returns min when below, max when above, the value itself otherwise.",
+    expression: {
+      operator: "call",
+      target: {
+        $ref: "window#/Math/min"
+      },
+      value: [
+        {
+          operator: "call",
+          target: {
+            $ref: "window#/Math/max"
+          },
+          value: [
+            {
+              $ref: "$args/value"
+            },
+            {
+              $ref: "$args/min"
+            }
+          ]
+        },
+        {
+          $ref: "$args/max"
+        }
+      ]
+    },
+    name: "clamp",
+    parameters: [
+      {
+        name: "value",
+        type: {
+          text: "number"
+        }
+      },
+      {
+        name: "min",
+        type: {
+          text: "number"
+        }
+      },
+      {
+        name: "max",
+        type: {
+          text: "number"
+        }
+      }
+    ]
+  },
+  {
+    description: "A copy of an array with the falsy elements removed (Array.prototype.filter on truthiness).",
+    expression: {
+      operator: "filter",
+      target: {
+        $ref: "$args/values"
+      },
+      value: {
+        operator: "!",
+        target: {
+          operator: "!",
+          target: {
+            $ref: "$map/item"
+          }
+        }
+      }
+    },
+    name: "compact",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "unknown[]"
+        }
+      }
+    ]
+  },
+  {
+    description: "The length of an array or string, or 0 when the value is missing.",
+    expression: {
+      operator: "??",
+      target: {
+        $ref: "$args/values/length"
+      },
+      value: 0
+    },
+    name: "count",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "unknown[] | string"
+        }
+      }
+    ]
+  },
+  {
+    description: "The first element of an array (index 0), or null when empty.",
+    expression: {
+      operator: "??",
+      target: {
+        $ref: "$args/values/0"
+      },
+      value: null
+    },
+    name: "first",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "unknown[]"
+        }
+      }
+    ]
+  },
+  {
+    description: 'The uppercase first letters of each whitespace-separated word, joined (e.g. "ada lovelace" → "AL").',
+    expression: {
+      operator: "join",
+      target: {
+        operator: "map",
+        target: {
+          operator: "split",
+          target: {
+            $ref: "$args/name"
+          },
+          value: " "
+        },
+        value: {
+          operator: "toUpperCase",
+          target: {
+            operator: "charAt",
+            target: {
+              $ref: "$map/item"
+            },
+            value: 0
+          }
+        }
+      },
+      value: ""
+    },
+    name: "initials",
+    parameters: [
+      {
+        name: "name",
+        type: {
+          text: "string"
+        }
+      }
+    ]
+  },
+  {
+    description: "True when an array or string has no elements (length 0 — a missing value counts as empty).",
+    expression: {
+      operator: "===",
+      target: {
+        operator: "??",
+        target: {
+          $ref: "$args/value/length"
+        },
+        value: 0
+      },
+      value: 0
+    },
+    name: "isEmpty",
+    parameters: [
+      {
+        name: "value",
+        type: {
+          text: "unknown[] | string"
+        }
+      }
+    ]
+  },
+  {
+    description: "The last element of an array (Array.prototype.at(-1)), or undefined when empty.",
+    expression: {
+      operator: "at",
+      target: {
+        $ref: "$args/values"
+      },
+      value: -1
+    },
+    name: "last",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "unknown[]"
+        }
+      }
+    ]
+  },
+  {
+    description: "The largest number in an array (Math.max folded over the values); undefined for an empty array.",
+    expression: {
+      operator: "reduce",
+      target: {
+        $ref: "$args/values"
+      },
+      initial: {
+        $ref: "$args/values/0"
+      },
+      value: {
+        operator: "call",
+        target: {
+          $ref: "window#/Math/max"
+        },
+        value: [
+          {
+            $ref: "$reduce/acc"
+          },
+          {
+            $ref: "$map/item"
+          }
+        ]
+      }
+    },
+    name: "max",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "number[]"
+        }
+      }
+    ]
+  },
+  {
+    description: "The smallest number in an array (Math.min folded over the values); undefined for an empty array.",
+    expression: {
+      operator: "reduce",
+      target: {
+        $ref: "$args/values"
+      },
+      initial: {
+        $ref: "$args/values/0"
+      },
+      value: {
+        operator: "call",
+        target: {
+          $ref: "window#/Math/min"
+        },
+        value: [
+          {
+            $ref: "$reduce/acc"
+          },
+          {
+            $ref: "$map/item"
+          }
+        ]
+      }
+    },
+    name: "min",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "number[]"
+        }
+      }
+    ]
+  },
+  {
+    description: "part / whole as a percentage (0 when the whole is 0 or missing).",
+    expression: {
+      operator: "?:",
+      target: {
+        $ref: "$args/whole"
+      },
+      value: {
+        operator: "*",
+        target: {
+          operator: "/",
+          target: {
+            $ref: "$args/part"
+          },
+          value: {
+            $ref: "$args/whole"
+          }
+        },
+        value: 100
+      },
+      initial: 0
+    },
+    name: "percent",
+    parameters: [
+      {
+        name: "part",
+        type: {
+          text: "number"
+        }
+      },
+      {
+        name: "whole",
+        type: {
+          text: "number"
+        }
+      }
+    ]
+  },
+  {
+    description: "Round a number to the given decimal places (Math.round against a Math.pow(10, digits) scale).",
+    expression: {
+      operator: "/",
+      target: {
+        operator: "call",
+        target: {
+          $ref: "window#/Math/round"
+        },
+        value: [
+          {
+            operator: "*",
+            target: {
+              $ref: "$args/value"
+            },
+            value: {
+              operator: "call",
+              target: {
+                $ref: "window#/Math/pow"
+              },
+              value: [
+                10,
+                {
+                  $ref: "$args/digits"
+                }
+              ]
+            }
+          }
+        ]
+      },
+      value: {
+        operator: "call",
+        target: {
+          $ref: "window#/Math/pow"
+        },
+        value: [
+          10,
+          {
+            $ref: "$args/digits"
+          }
+        ]
+      }
+    },
+    name: "roundTo",
+    parameters: [
+      {
+        name: "value",
+        type: {
+          text: "number"
+        }
+      },
+      {
+        name: "digits",
+        type: {
+          text: "number"
+        },
+        default: 0
+      }
+    ]
+  },
+  {
+    description: "Add every number in an array (Array.prototype.reduce with +, seeded at 0).",
+    expression: {
+      operator: "reduce",
+      target: {
+        $ref: "$args/values"
+      },
+      initial: 0,
+      value: {
+        operator: "+",
+        target: {
+          $ref: "$reduce/acc"
+        },
+        value: {
+          $ref: "$map/item"
+        }
+      }
+    },
+    name: "sum",
+    parameters: [
+      {
+        name: "values",
+        type: {
+          text: "number[]"
+        }
+      }
+    ]
+  },
+  {
+    description: "Shorten a string to at most the given length, appending a horizontal ellipsis when cut.",
+    expression: {
+      operator: "?:",
+      target: {
+        operator: ">",
+        target: {
+          $ref: "$args/text/length"
+        },
+        value: {
+          $ref: "$args/length"
+        }
+      },
+      value: {
+        operator: "+",
+        target: {
+          operator: "slice",
+          target: {
+            $ref: "$args/text"
+          },
+          value: [
+            0,
+            {
+              $ref: "$args/length"
+            }
+          ]
+        },
+        value: "…"
+      },
+      initial: {
+        $ref: "$args/text"
+      }
+    },
+    name: "truncate",
+    parameters: [
+      {
+        name: "text",
+        type: {
+          text: "string"
+        }
+      },
+      {
+        name: "length",
+        type: {
+          text: "number"
+        }
+      }
+    ]
+  }
+];
+// src/ui/formula-catalog.ts
+function applyCatalogPick(entry, onChange, opts) {
+  if (entry.ensure && !opts?.stateEntries?.[entry.ensure.name]) {
+    opts?.onInsertDef?.(entry.ensure.name, entry.ensure.def);
+  }
+  onChange(entry.insert());
+}
+var REF_TARGET = { description: "Writable pointer the operation applies to", name: "target" };
+var LEFT = { description: "Left operand", name: "target" };
+var RIGHT = { description: "Right operand", name: "value" };
+function assignMeta(op, verb) {
+  return {
+    description: `${verb} assignment operator (ECMA \`${op}\`): stores the result at the target pointer.`,
+    group: "Assignment",
+    insert: () => ({ operator: op, target: { $ref: "" }, value: null }),
+    parameters: [REF_TARGET, { description: "Value assigned to the target", name: "value" }]
+  };
+}
+function binaryMeta(group, op, description) {
+  return {
+    description,
+    group,
+    insert: () => ({ operator: op, target: null, value: null }),
+    parameters: [LEFT, RIGHT]
+  };
+}
+function arrayMeta(op, description, withValue) {
+  return {
+    description,
+    group: "Array methods",
+    insert: () => withValue ? { operator: op, target: { $ref: "" }, value: null } : { operator: op, target: { $ref: "" } },
+    parameters: withValue ? [REF_TARGET, { description: "Element to add", name: "value" }] : [REF_TARGET]
+  };
+}
+function aggregateMeta(op, description, withInitial) {
+  const node = {
+    operator: op,
+    target: { $ref: "" },
+    value: { operator: "!", target: null }
+  };
+  return {
+    description,
+    group: "Aggregate",
+    insert: () => withInitial ? { ...node, initial: 0 } : { ...node },
+    parameters: [
+      { description: "Array pointer to iterate", name: "target" },
+      { description: "Per-item expression ($map/item, $map/index)", name: "value" },
+      ...withInitial ? [{ description: "Initial accumulator ($reduce/acc)", name: "initial" }] : []
+    ]
+  };
+}
+var OPERATOR_META = {
+  "!": {
+    description: "Logical NOT operator (ECMA `!`): coerces the operand to boolean and negates it.",
+    group: "Unary",
+    insert: () => ({ operator: "!", target: null }),
+    parameters: [{ description: "Operand to negate", name: "target" }]
+  },
+  "!==": binaryMeta("Comparison", "!==", "Strict inequality operator (ECMA `!==`): true when the operands differ without coercion."),
+  "%": binaryMeta("Arithmetic", "%", "Remainder operator (ECMA `%`): remainder of dividing the left operand by the right."),
+  "&&": binaryMeta("Logical", "&&", "Logical AND operator (ECMA `&&`): yields the right operand when the left is truthy."),
+  "*": binaryMeta("Arithmetic", "*", "Multiplication operator (ECMA `*`): numeric product of the operands."),
+  "*=": assignMeta("*=", "Multiplication"),
+  "+": binaryMeta("Arithmetic", "+", "Addition operator (ECMA `+`): numeric addition, or string concatenation."),
+  "+=": assignMeta("+=", "Addition"),
+  "-": binaryMeta("Arithmetic", "-", "Subtraction operator (ECMA `-`); with no value operand it is unary negation."),
+  "-=": assignMeta("-=", "Subtraction"),
+  "/": binaryMeta("Arithmetic", "/", "Division operator (ECMA `/`): quotient of the operands."),
+  "/=": assignMeta("/=", "Division"),
+  "<": binaryMeta("Comparison", "<", "Less-than operator (ECMA `<`): relational comparison of the operands."),
+  "<=": binaryMeta("Comparison", "<=", "Less-than-or-equal operator (ECMA `<=`): relational comparison of the operands."),
+  "=": assignMeta("=", "Simple"),
+  "===": binaryMeta("Comparison", "===", "Strict equality operator (ECMA `===`): true when the operands are equal without coercion."),
+  ">": binaryMeta("Comparison", ">", "Greater-than operator (ECMA `>`): relational comparison of the operands."),
+  ">=": binaryMeta("Comparison", ">=", "Greater-than-or-equal operator (ECMA `>=`): relational comparison of the operands."),
+  "??": binaryMeta("Logical", "??", "Nullish coalescing operator (ECMA `??`): yields the right operand when the left is null or undefined."),
+  "?:": {
+    description: "Conditional operator (ECMA `?:`): evaluates the test in target, yielding value when truthy, initial otherwise.",
+    group: "Conditional",
+    insert: () => ({ initial: null, operator: "?:", target: null, value: null }),
+    parameters: [
+      { description: "Test condition", name: "target" },
+      { description: "Result when the test is truthy", name: "value" },
+      { description: "Result when the test is falsy", name: "initial" }
+    ]
+  },
+  "||": binaryMeta("Logical", "||", "Logical OR operator (ECMA `||`): yields the right operand when the left is falsy."),
+  call: {
+    description: "Function.prototype.call (ECMA): invokes a named formula (#/state/…) or blessed pure global (window#/…) with positional arguments.",
+    group: "Function",
+    insert: () => ({ operator: "call", target: { $ref: "" }, value: [] }),
+    parameters: [
+      { description: "Callee pointer: #/state/<formula> or window#/<global>", name: "target" },
+      { description: "Positional argument list", name: "value" }
+    ]
+  },
+  filter: aggregateMeta("filter", "Array.prototype.filter (ECMA): keeps elements whose per-item expression is truthy.", false),
+  map: aggregateMeta("map", "Array.prototype.map (ECMA): transforms each element via the per-item expression.", false),
+  pop: arrayMeta("pop", "Array.prototype.pop (ECMA): removes and returns the last element of the target array.", false),
+  push: arrayMeta("push", "Array.prototype.push (ECMA): appends the value to the target array.", true),
+  reduce: aggregateMeta("reduce", "Array.prototype.reduce (ECMA): folds the array into an accumulator via the per-item expression.", true),
+  shift: arrayMeta("shift", "Array.prototype.shift (ECMA): removes and returns the first element of the target array.", false),
+  splice: {
+    description: "Array.prototype.splice (ECMA): removes and/or inserts elements at an index of the target array.",
+    group: "Array methods",
+    insert: () => ({ operator: "splice", target: { $ref: "" }, value: [null] }),
+    parameters: [
+      REF_TARGET,
+      { description: "Arguments: start, deleteCount, items…", name: "value" }
+    ]
+  },
+  switch: {
+    description: "Switch selection (ECMA `switch` semantics): matches the target's string form against case keys, falling back to default.",
+    group: "Conditional",
+    insert: () => ({ cases: {}, default: null, operator: "switch", target: null }),
+    parameters: [
+      { description: "Discriminant value", name: "target" },
+      { description: "Matched value → result operand map", name: "cases" },
+      { description: "Result when no case matches", name: "default" }
+    ]
+  },
+  unshift: arrayMeta("unshift", "Array.prototype.unshift (ECMA): prepends the value to the target array.", true)
+};
+function operatorEntries() {
+  const out = [];
+  for (const op of BLESSED_OPERATORS) {
+    const meta = Object.hasOwn(OPERATOR_META, op) ? OPERATOR_META[op] : undefined;
+    if (meta) {
+      out.push({
+        description: meta.description,
+        group: meta.group,
+        insert: meta.insert,
+        kind: "operator",
+        label: op,
+        name: op,
+        parameters: meta.parameters
+      });
+    } else if (PURE_METHOD_OPS.has(op)) {
+      out.push(pureMethodEntry(op));
+    }
+  }
+  return out;
+}
+var PURE_METHOD_PROTO = {
+  at: "Array/String",
+  charAt: "String",
+  concat: "Array/String",
+  endsWith: "String",
+  flat: "Array",
+  includes: "Array/String",
+  indexOf: "Array/String",
+  join: "Array",
+  lastIndexOf: "Array/String",
+  normalize: "String",
+  padEnd: "String",
+  padStart: "String",
+  repeat: "String",
+  replaceAll: "String",
+  slice: "Array/String",
+  split: "String",
+  startsWith: "String",
+  toFixed: "Number",
+  toLocaleLowerCase: "String",
+  toLocaleString: "Number",
+  toLocaleUpperCase: "String",
+  toLowerCase: "String",
+  toPrecision: "Number",
+  toReversed: "Array",
+  toSorted: "Array",
+  toSpliced: "Array",
+  toUpperCase: "String",
+  trim: "String",
+  trimEnd: "String",
+  trimStart: "String",
+  with: "Array"
+};
+var ZERO_ARG_METHODS = new Set([
+  "flat",
+  "normalize",
+  "toLocaleLowerCase",
+  "toLocaleString",
+  "toLocaleUpperCase",
+  "toLowerCase",
+  "toReversed",
+  "toSorted",
+  "toUpperCase",
+  "trim",
+  "trimEnd",
+  "trimStart"
+]);
+function pureMethodEntry(op) {
+  const proto = PURE_METHOD_PROTO[op] ?? "Standard library";
+  return {
+    description: `${proto}.prototype.${op} (ECMA) — pure: never mutates the receiver. Receiver in target; argument (or argument list) in value.`,
+    group: `${proto} methods`,
+    insert: () => ZERO_ARG_METHODS.has(op) ? { operator: op, target: { $ref: "" } } : { operator: op, target: { $ref: "" }, value: null },
+    kind: "operator",
+    label: op,
+    name: op,
+    parameters: []
+  };
+}
+var HELPER_DESCRIPTIONS = {
+  "Intl/formatDate": "Intl.formatDate(value, locale?, options?) — blessed helper wrapping new Intl.DateTimeFormat(locale, options).format(new Date(value)).",
+  "Intl/formatNumber": "Intl.formatNumber(value, locale?, options?) — blessed helper wrapping new Intl.NumberFormat(locale, options).format(value).",
+  "Intl/formatRelativeTime": "Intl.formatRelativeTime(value, unit, locale?, options?) — blessed helper wrapping new Intl.RelativeTimeFormat(locale, options).format(value, unit)."
+};
+function globalEntries() {
+  const out = [];
+  for (const name of BLESSED_GLOBALS) {
+    const slash = name.indexOf("/");
+    const group = slash === -1 ? "globalThis" : name.slice(0, slash);
+    const label = name.replaceAll("/", ".");
+    out.push({
+      description: HELPER_DESCRIPTIONS[name] ?? `${label} — blessed pure global from the ECMAScript standard library, invoked via the call operator (window#/${name}).`,
+      group,
+      insert: () => ({ operator: "call", target: { $ref: `window#/${name}` }, value: [] }),
+      kind: "global",
+      label,
+      name,
+      parameters: []
+    });
+  }
+  return out;
+}
+function toParameterInfo(p) {
+  if (typeof p === "string") {
+    return p ? { name: p } : null;
+  }
+  if (!isJsonObject(p) || typeof p.name !== "string" || !p.name) {
+    return null;
+  }
+  const info = { name: p.name };
+  const { type } = p;
+  if (typeof type === "string") {
+    info.type = type;
+  } else if (isJsonObject(type)) {
+    if (typeof type.text === "string") {
+      info.type = type.text;
+    } else if (typeof type.type === "string") {
+      info.type = type.type;
+    }
+  }
+  if (typeof p.description === "string") {
+    info.description = p.description;
+  }
+  if ("default" in p && p.default !== undefined) {
+    info.default = p.default;
+  }
+  return info;
+}
+function namedFormulaEntries(state) {
+  const out = [];
+  for (const [key, def] of Object.entries(state ?? {})) {
+    if (!isNamedFormulaDef(def)) {
+      continue;
+    }
+    const parameters = def.parameters.map((p) => toParameterInfo(p)).filter((p) => p !== null);
+    const description = typeof def.description === "string" && def.description ? def.description : typeof def.$title === "string" && def.$title ? def.$title : `Named formula "${key}" from document state.`;
+    out.push({
+      description,
+      group: "Formulas",
+      insert: () => ({
+        operator: "call",
+        target: { $ref: `#/state/${key}` },
+        value: parameters.map((p) => p.default ?? null)
+      }),
+      kind: "formula",
+      label: key,
+      name: key,
+      parameters
+    });
+  }
+  return out;
+}
+function packagedFormulaEntries(state) {
+  const out = [];
+  for (const formula of catalog) {
+    if (state?.[formula.name]) {
+      continue;
+    }
+    const parameters = formula.parameters.map((p) => toParameterInfo(p)).filter((p) => p !== null);
+    out.push({
+      description: formula.description,
+      ensure: {
+        def: {
+          $description: formula.description,
+          $expression: formula.expression,
+          parameters: formula.parameters
+        },
+        name: formula.name
+      },
+      group: "Formulas library",
+      insert: () => ({
+        operator: "call",
+        target: { $ref: `#/state/${formula.name}` },
+        value: parameters.map((p) => p.default ?? null)
+      }),
+      kind: "formula",
+      label: formula.name,
+      name: formula.name,
+      parameters
+    });
+  }
+  return out;
+}
+function formulaCatalog(state) {
+  return [
+    ...namedFormulaEntries(state),
+    ...packagedFormulaEntries(state),
+    ...operatorEntries(),
+    ...globalEntries()
+  ];
+}
+function calleeEntry(ref2, state) {
+  if (ref2.startsWith("window#/")) {
+    const name = ref2.slice("window#/".length);
+    return globalEntries().find((e) => e.name === name);
+  }
+  if (ref2.startsWith("#/state/")) {
+    const key = ref2.slice("#/state/".length);
+    return namedFormulaEntries(state).find((e) => e.name === key);
+  }
+  return;
+}
+
+// src/ui/formula-palette.ts
+var _open = false;
+var _opts = null;
+var _query = "";
+var _selectedIndex = 0;
+function getContainer() {
+  return getLayerSlot("popover", "formula-palette");
+}
+function openFormulaPalette(opts) {
+  _open = true;
+  _opts = opts;
+  _query = "";
+  _selectedIndex = 0;
+  renderOverlay();
+}
+function closeFormulaPalette() {
+  _open = false;
+  _opts = null;
+  renderOverlay();
+}
+function filteredEntries() {
+  const entries = _opts?.entries ?? [];
+  const needle = _query.trim().toLowerCase();
+  if (!needle) {
+    return entries;
+  }
+  return entries.filter((e) => e.label.toLowerCase().includes(needle) || e.name.toLowerCase().includes(needle) || e.group.toLowerCase().includes(needle) || e.description.toLowerCase().includes(needle));
+}
+function groupedEntries(entries) {
+  const groups = new Map;
+  for (const entry of entries) {
+    const bucket = groups.get(entry.group);
+    if (bucket) {
+      bucket.push(entry);
+    } else {
+      groups.set(entry.group, [entry]);
+    }
+  }
+  return [...groups.entries()];
+}
+function pickEntry(entry) {
+  const opts = _opts;
+  closeFormulaPalette();
+  opts?.onPick(entry);
+}
+function onInput(e) {
+  _query = e.target.value;
+  _selectedIndex = 0;
+  renderOverlay();
+}
+function onKeydown(e) {
+  const entries = filteredEntries();
+  switch (e.key) {
+    case "ArrowDown": {
+      e.preventDefault();
+      _selectedIndex = Math.min(_selectedIndex + 1, entries.length - 1);
+      renderOverlay();
+      break;
+    }
+    case "ArrowUp": {
+      e.preventDefault();
+      _selectedIndex = Math.max(_selectedIndex - 1, 0);
+      renderOverlay();
+      break;
+    }
+    case "Enter": {
+      e.preventDefault();
+      if (entries[_selectedIndex]) {
+        pickEntry(entries[_selectedIndex]);
+      }
+      break;
+    }
+    case "Escape": {
+      e.preventDefault();
+      closeFormulaPalette();
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+function panelStyle() {
+  const anchor = _opts?.anchor;
+  if (!anchor) {
+    return "";
+  }
+  const rect = rectOf(anchor);
+  if (!rect || rect.top === 0 && rect.left === 0 && rect.width === 0) {
+    return "";
+  }
+  const left = Math.max(8, Math.min(rect.left, (globalThis.innerWidth || 1200) - 568));
+  return `position:fixed;left:${left}px;top:${rect.bottom + 4}px;margin:0`;
+}
+function renderOverlay() {
+  const container = getContainer();
+  if (!_open) {
+    render(nothing, container);
+    return;
+  }
+  const entries = filteredEntries();
+  const groups = groupedEntries(entries);
+  const hasQuery = _query.trim().length > 0;
+  const tpl = html`
+    <div class="quick-search-overlay formula-palette-overlay" @click=${closeFormulaPalette}>
+      <div
+        class="quick-search-panel formula-palette"
+        style=${panelStyle()}
+        @click=${(e) => e.stopPropagation()}
+      >
+        <input
+          class="quick-search-input formula-palette-input"
+          type="text"
+          placeholder="Search formulas, operators, globals…"
+          .value=${live(_query)}
+          @input=${onInput}
+          @keydown=${onKeydown}
+          ${ref((el) => {
+    if (el) {
+      requestAnimationFrame(() => el.focus());
+    }
+  })}
+        />
+        <div class="quick-search-results">
+          ${entries.length === 0 ? html`<div class="quick-search-empty">
+                  ${hasQuery ? "No results" : "No entries available"}
+                </div>` : nothing}
+          ${groups.map(([group, groupEntries]) => html`
+              <div class="quick-search-section-label">${group}</div>
+              ${groupEntries.map((entry) => {
+    const index = entries.indexOf(entry);
+    return html`
+                  <div
+                    class=${classMap({
+      "quick-search-item": true,
+      selected: index === _selectedIndex
+    })}
+                    @click=${() => pickEntry(entry)}
+                    @mouseenter=${() => {
+      _selectedIndex = index;
+      renderOverlay();
+    }}
+                  >
+                    <span
+                      class="quick-search-name"
+                      style="font-family:var(--spectrum-code-font-family, monospace)"
+                      >${entry.label}</span
+                    >
+                    <span class="quick-search-path" title=${entry.description}
+                      >${entry.description}</span
+                    >
+                    <span class="quick-search-badge">${entry.kind}</span>
+                  </div>
+                `;
+  })}
+            `)}
+        </div>
+      </div>
+    </div>
+  `;
+  render(tpl, container);
+}
+
+// ../schema/defs/tag-expression.schema.ts
+var tagExpressionSchema = {
+  anyOf: [
+    {
+      additionalProperties: false,
+      description: "Two-way: `target` is the test, `value` the tag when it is truthy, `initial` the tag when it is not.",
+      properties: {
+        initial: { $ref: "#/$defs/TagName" },
+        operator: { const: "?:", type: "string" },
+        target: { $ref: "#/$defs/ExpressionOperand" },
+        value: { $ref: "#/$defs/TagName" }
+      },
+      required: ["operator", "target", "value", "initial"],
+      title: "?: — the tag when the test holds, and the tag when it does not"
+    },
+    {
+      additionalProperties: false,
+      description: "Multiway: `target` is the discriminant, matched against case keys by its string form. " + "`default` is required — an element with no tag cannot exist.",
+      properties: {
+        cases: {
+          additionalProperties: { $ref: "#/$defs/TagName" },
+          type: "object"
+        },
+        default: { $ref: "#/$defs/TagName" },
+        operator: { const: "switch", type: "string" },
+        target: { $ref: "#/$defs/ExpressionOperand" }
+      },
+      required: ["operator", "target", "cases", "default"],
+      title: "switch — one tag per discriminant value, with a required fallback"
+    }
+  ],
+  description: "A tag name chosen at element creation. Every branch resolves to a `TagName`, so the candidate " + "set is enumerable without evaluating anything."
+};
+var elementTagNameSchema = {
+  anyOf: [
+    { $ref: "#/$defs/TagName" },
+    {
+      additionalProperties: false,
+      properties: { $expression: { $ref: "#/$defs/TagExpression" } },
+      required: ["$expression"],
+      type: "object"
+    }
+  ]
+};
+// ../schema/defs/tag-name.schema.ts
+var tagNameSchema = {
+  description: "HTML element tag name or custom element name (must contain a hyphen per Web Components spec). " + "A NAME, never an expression: no `${…}` position in the pipeline evaluates a tagName. Use " + "`$switch`/`cases` to vary the element.",
+  minLength: 1,
+  pattern: "^[a-zA-Z][a-zA-Z0-9._-]*$",
+  type: "string"
+};
+// ../schema/defs/string-or-ref.schema.ts
+var stringOrRefSchema = {
+  oneOf: [{ type: "string" }, { $ref: "#/$defs/RefObject" }]
+};
+// ../schema/defs/head-entry.schema.ts
+var headEntrySchema = {
+  additionalProperties: true,
+  description: "A page-level <head> entry. Defines meta tags, link tags, script tags, etc.",
+  properties: {
+    attributes: {
+      additionalProperties: {
+        oneOf: [{ type: "string" }, { type: "boolean" }]
+      },
+      type: "object"
+    },
+    children: { items: { $ref: "#/$defs/HeadEntry" }, type: "array" },
+    tagName: { type: "string" },
+    textContent: {
+      description: "Element content. An object is serialized to JSON inside the tag — that is how a " + 'JSON-LD block (`<script type="application/ld+json">`) is authored.',
+      oneOf: [{ type: "string" }, { type: "object" }]
+    }
+  },
+  required: ["tagName"],
+  type: "object"
+};
+// ../schema/defs/cem.schema.ts
+var cemParameterSchema = {
+  description: "A CEM-compatible parameter definition for a function. " + "Follows the Custom Elements Manifest Parameter shape.",
+  properties: {
+    default: { description: "Default value for the parameter." },
+    description: { description: "Parameter documentation.", type: "string" },
+    name: { description: "Parameter name.", type: "string" },
+    optional: { description: "Whether the parameter is optional.", type: "boolean" },
+    type: { description: "Parameter type (JSON Schema or CEM { text } format)." }
+  },
+  required: ["name"],
+  type: "object"
+};
+// ../schema/defs/image-config.schema.ts
+var imageConfigSchema = {
+  description: "Image optimization configuration for the project.",
+  properties: {
+    formats: { items: { type: "string" }, type: "array" },
+    lazyLoad: { type: "boolean" },
+    optimize: { type: "boolean" },
+    picture: {
+      description: "Wrap a multi-format image in a <picture> with one <source> per format (default true). " + "With it off the <img> carries a srcset in the preferred format alone, which browsers " + "that cannot decode that format will still select from.",
+      type: "boolean"
+    },
+    quality: {
+      properties: {
+        avif: { type: "number" },
+        jpeg: { type: "number" },
+        png: { type: "number" },
+        webp: { type: "number" }
+      },
+      type: "object"
+    },
+    remoteDomains: {
+      description: "Hostnames whose remote (https) images are optimized through /cdn-cgi/image transform " + 'URLs (cloudflare service only), e.g. ["drive.usercontent.google.com"]. Remote sources ' + "from other hosts are left untouched.",
+      items: { type: "string" },
+      type: "array"
+    },
+    service: {
+      description: 'How images are optimized: "build" runs Sharp at build time; "cloudflare" emits ' + "/cdn-cgi/image transform URLs served by Cloudflare Image Transformations (requires " + "the feature to be enabled on the serving zone).",
+      enum: ["build", "cloudflare"],
+      type: "string"
+    },
+    sizes: { type: "string" },
+    widths: { items: { type: "number" }, type: "array" }
+  },
+  type: "object"
+};
+// ../schema/defs/ref-object.schema.ts
+var refObjectSchema = {
+  additionalProperties: false,
+  description: "A $ref binding. Resolves to a state entry (reactive) or plain value (static).",
+  properties: { $ref: { $ref: "#/$defs/AnyRef" } },
+  required: ["$ref"],
+  type: "object"
+};
+// ../schema/defs/style-object.schema.ts
+var styleObjectSchema = {
+  additionalProperties: {
+    oneOf: [{ type: "string" }, { type: "number" }, { $ref: "#/$defs/StyleObject" }]
+  },
+  description: "CSS style definition. camelCase property names follow CSSOM convention. " + "Keys starting with :, ., &, or [ are treated as nested CSS selectors. " + "Keys matching $media breakpoint names (or other @-prefixed at-rules) group nested rules. " + "Nesting is recursive: selector and at-rule groups may nest to arbitrary depth " + "(e.g. breakpoint → selector → pseudo-class), mirroring the compiler's recursive emission.",
+  properties: {},
+  type: "object"
+};
+// ../schema/defs/children-value.schema.ts
+var arrayNamespaceSchema = {
+  additionalProperties: false,
+  description: "Dynamic mapped list. Re-renders when the items state entry changes.",
+  properties: {
+    $prototype: { const: "Array", type: "string" },
+    filter: { $ref: "#/$defs/RefObject" },
+    items: {
+      oneOf: [{ $ref: "#/$defs/RefObject" }, { type: "array" }]
+    },
+    map: { $ref: "#/$defs/ElementDef" },
+    sort: { $ref: "#/$defs/RefObject" }
+  },
+  required: ["$prototype", "items", "map"],
+  type: "object"
+};
+var childrenValueSchema = {
+  description: "Array of child definitions — elements, text, or Array namespaces (dynamic lists) mixed " + "freely. A bare Array namespace (the whole children slot is one dynamic list) is also " + "accepted for backward compatibility, as is a ${…} template string that resolves at build " + "time to an array of child definitions.",
+  oneOf: [
+    {
+      items: {
+        anyOf: [
+          { $ref: "#/$defs/ElementDef" },
+          { $ref: "#/$defs/SwitchNode" },
+          { $ref: "#/$defs/ArrayNamespace" },
+          { type: "string" },
+          { type: "number" }
+        ]
+      },
+      type: "array"
+    },
+    { $ref: "#/$defs/ArrayNamespace" },
+    {
+      description: "Computed children — a ${…} template that resolves at build time to an array of child " + 'definitions (e.g. "${state.entry.$children}" for parsed content). A bare plain-text ' + "string is NOT a valid children value; text children must be array items.",
+      pattern: "\\$\\{",
+      type: "string"
+    }
+  ]
+};
+// ../schema/defs/element-def.schema.ts
+var attributesObjectSchema = {
+  additionalProperties: {
+    oneOf: [
+      { type: "string" },
+      { type: "number" },
+      { type: "boolean" },
+      { $ref: "#/$defs/RefObject" }
+    ]
+  },
+  description: "HTML attributes and ARIA attributes set via element.setAttribute().",
+  type: "object"
+};
+var propsObjectSchema = {
+  additionalProperties: {
+    anyOf: [
+      { type: "string" },
+      { type: "number" },
+      { type: "boolean" },
+      { type: "array" },
+      { type: "object" },
+      { $ref: "#/$defs/RefObject" }
+    ]
+  },
+  description: "Explicit prop passing at a component boundary.",
+  type: "object"
+};
+var elementPropertyValueSchema = {
+  oneOf: [
+    { type: "string" },
+    { type: "number" },
+    { type: "boolean" },
+    { type: "null" },
+    { $ref: "#/$defs/RefObject" }
+  ]
+};
+var switchDefSchema = {
+  additionalProperties: false,
+  description: "Reactive $ref that drives which case to render.",
+  properties: { $ref: { $ref: "#/$defs/StateRef" } },
+  required: ["$ref"],
+  type: "object"
+};
+var elementDefSchema = {
+  additionalProperties: { $ref: "#/$defs/ElementPropertyValue" },
+  description: "A Jx element definition. Maps directly to a DOM element.",
+  properties: {
+    "$map/index": { $ref: "#/$defs/RefObject" },
+    "$map/item": { $ref: "#/$defs/RefObject" },
+    $props: { $ref: "#/$defs/PropsObject" },
+    $ref: { $ref: "#/$defs/ExternalRef" },
+    $switch: { $ref: "#/$defs/SwitchDef" },
+    alt: { $ref: "#/$defs/StringOrRef" },
+    attributes: { $ref: "#/$defs/AttributesObject" },
+    cases: {
+      additionalProperties: {
+        oneOf: [{ $ref: "#/$defs/ElementDef" }, { $ref: "#/$defs/ExternalComponentRef" }]
+      },
+      description: "Switch cases for this element. Maps case values to element definitions or external " + "component refs, rendered according to the reactive $switch discriminant.",
+      type: "object"
+    },
+    checked: { $ref: "#/$defs/BoolOrRef" },
+    children: { $ref: "#/$defs/ChildrenValue" },
+    className: { $ref: "#/$defs/StringOrRef" },
+    dir: { enum: ["ltr", "rtl", "auto"], type: "string" },
+    disabled: { $ref: "#/$defs/BoolOrRef" },
+    hidden: { $ref: "#/$defs/BoolOrRef" },
+    href: { $ref: "#/$defs/StringOrRef" },
+    id: { type: "string" },
+    innerHTML: { $ref: "#/$defs/StringOrRef" },
+    innerText: { $ref: "#/$defs/StringOrRef" },
+    lang: { $ref: "#/$defs/StringOrRef" },
+    name: { $ref: "#/$defs/StringOrRef" },
+    placeholder: { $ref: "#/$defs/StringOrRef" },
+    selected: { $ref: "#/$defs/BoolOrRef" },
+    src: { $ref: "#/$defs/StringOrRef" },
+    style: { $ref: "#/$defs/StyleObject" },
+    tabIndex: { $ref: "#/$defs/NumberOrRef" },
+    tagName: { $ref: "#/$defs/ElementTagName" },
+    textContent: { $ref: "#/$defs/StringOrRef" },
+    title: { $ref: "#/$defs/StringOrRef" },
+    type: { $ref: "#/$defs/StringOrRef" },
+    value: { $ref: "#/$defs/StringOrRef" }
+  },
+  required: ["tagName"],
+  type: "object"
+};
+// ../schema/defs/typed-state-def.schema.ts
+var typedStateDefSchema = {
+  description: "A typed reactive state variable with explicit type and default value. " + "The type property is a JSON Schema or $ref to a $defs type definition. " + "The default property is the initial runtime value.",
+  not: { required: ["$prototype"] },
+  properties: {
+    $ref: { description: "Reference to a shared type definition.", type: "string" },
+    attribute: {
+      description: "Linked HTML attribute name for CEM extraction.",
+      type: "string"
+    },
+    default: { description: "Initial state value." },
+    deprecated: {
+      description: "Deprecation notice for CEM extraction.",
+      oneOf: [{ type: "boolean" }, { type: "string" }]
+    },
+    description: { type: "string" },
+    examples: { type: "array" },
+    reflects: {
+      description: "Whether property changes reflect back to the HTML attribute.",
+      type: "boolean"
+    },
+    type: {
+      description: "JSON Schema type definition, $ref to a $defs type, or JSON Schema type string.",
+      oneOf: [{ type: "string" }, { type: "object" }]
+    }
+  },
+  required: ["default"],
+  type: "object"
+};
+// ../schema/defs/function-def.schema.ts
+var functionDefSchema = {
+  additionalProperties: false,
+  description: 'A function declaration. $prototype must be "Function". ' + "body (inline) and $src (external) are mutually exclusive. " + "First parameter is always state (the reactive scope).",
+  properties: {
+    $export: {
+      description: "Named export in $src module. Defaults to the state key name.",
+      type: "string"
+    },
+    $prototype: { const: "Function", type: "string" },
+    $src: {
+      description: "External module specifier. Mutually exclusive with body.",
+      examples: ["./counter.js", "npm:@myorg/validators"],
+      type: "string"
+    },
+    arguments: {
+      description: "Legacy alias for parameters: bare string parameter names (state may be listed " + "explicitly as the first name). Superseded by parameters.",
+      examples: [["state", "event"]],
+      items: { type: "string" },
+      type: "array"
+    },
+    body: {
+      description: "Inline function body: an opaque JS source string (first implicit parameter is state), or a structured statement array (spec §20) — explicit structured function declaration, analyzable by tooling and editable visually. The escalation ladder within the shape is structured statements → JS string.",
+      examples: [
+        "state.count++",
+        'state.items.push({ id: Date.now(), text: "", done: false })',
+        'return state.score >= 90 ? "gold" : "silver"',
+        [
+          { operator: "push", target: { $ref: "#/state/cart" }, value: 1 },
+          { dispatchEvent: "cart-changed", detail: { $ref: "#/state/cart" } }
+        ]
+      ],
+      oneOf: [{ type: "string" }, { $ref: "#/$defs/StatementList" }]
+    },
+    description: { type: "string" },
+    emits: {
+      description: "Array of CEM-compatible Event objects this function dispatches. " + "Used for CEM extraction and studio event discovery.",
+      items: { $ref: "#/$defs/CemEvent" },
+      type: "array"
+    },
+    name: {
+      description: "Explicit function name. Defaults to the state key name.",
+      type: "string"
+    },
+    parameters: {
+      description: "Function parameters (after the implicit state parameter). " + "Accepts CEM-compatible parameter objects or bare string names for backward compatibility.",
+      examples: [
+        ["event"],
+        [{ name: "event", type: { text: "Event" } }],
+        [{ description: "Item identifier", name: "id", type: { text: "number" } }]
+      ],
+      items: {
+        oneOf: [{ type: "string" }, { $ref: "#/$defs/CemParameter" }]
+      },
+      type: "array"
+    },
+    type: {
+      description: "Return type for tooling (JSON Schema or CEM { text } format)."
+    }
+  },
+  required: ["$prototype"],
+  type: "object"
+};
+// ../schema/defs/external-class-def.schema.ts
+var externalClassDefSchema = {
+  description: 'An external class / data source. $prototype is a constructor name (not "Function"). ' + "When $prototype is not in the built-in registry, $src is required. " + "All state entries are reactive by default.",
+  properties: {
+    $export: {
+      description: "Named export in $src module. Defaults to the $prototype value.",
+      type: "string"
+    },
+    $prototype: {
+      description: "Constructor name — built-in Web API class or external class name.",
+      examples: [
+        "Request",
+        "URLSearchParams",
+        "FormData",
+        "LocalStorage",
+        "SessionStorage",
+        "Cookie",
+        "IndexedDB",
+        "Array",
+        "Set",
+        "Map",
+        "Blob",
+        "ReadableStream",
+        "MarkdownCollection",
+        "MyParser"
+      ],
+      not: { const: "Function" },
+      type: "string"
+    },
+    $src: {
+      description: "External module specifier. Required when $prototype is not a built-in.",
+      examples: ["@jxsuite/md", "./lib/my-parser.js", "npm:@myorg/data"],
+      type: "string"
+    },
+    autoIncrement: { type: "boolean" },
+    body: {},
+    database: { type: "string" },
+    debounce: { minimum: 0, type: "integer" },
+    default: {},
+    description: { type: "string" },
+    domain: { type: "string" },
+    filter: {
+      anyOf: [
+        { $ref: "#/$defs/RefObject" },
+        { description: "A single filter object, e.g. an equality shorthand.", type: "object" },
+        {
+          description: 'Ordered filter rules, e.g. [{ field: "Slug", op: "not empty" }].',
+          items: { type: "object" },
+          type: "array"
+        }
+      ],
+      description: "Filter configuration: a reactive $ref binding, a single filter object, or an ordered " + "array of rules."
+    },
+    headers: { additionalProperties: { type: "string" }, type: "object" },
+    indexes: {
+      items: {
+        properties: {
+          keyPath: {
+            oneOf: [{ type: "string" }, { items: { type: "string" }, type: "array" }]
+          },
+          name: { type: "string" },
+          unique: { type: "boolean" }
+        },
+        required: ["name", "keyPath"],
+        type: "object"
+      },
+      type: "array"
+    },
+    items: {},
+    key: { type: "string" },
+    keyPath: { type: "string" },
+    manual: { type: "boolean" },
+    map: { $ref: "#/$defs/ElementDef" },
+    maxAge: { type: "integer" },
+    method: {
+      enum: ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"],
+      type: "string"
+    },
+    name: { type: "string" },
+    path: { type: "string" },
+    responseType: {
+      enum: ["json", "text", "blob", "arraybuffer", "document", ""],
+      type: "string"
+    },
+    sameSite: { enum: ["strict", "lax", "none"], type: "string" },
+    secure: { type: "boolean" },
+    sort: {
+      anyOf: [
+        { $ref: "#/$defs/RefObject" },
+        { description: "A single sort rule, e.g. { field, order }.", type: "object" },
+        {
+          description: 'Ordered sort rules, e.g. [{ field: "date", order: "desc" }].',
+          items: { type: "object" },
+          type: "array"
+        }
+      ],
+      description: "Sort configuration: a reactive $ref binding, a single { field, order } rule, or an " + "ordered array of rules."
+    },
+    src: {
+      description: "Configuration property passed to external class constructor.",
+      type: "string"
+    },
+    store: { type: "string" },
+    timing: { enum: ["compiler", "server", "client"], type: "string" },
+    url: { $ref: "#/$defs/StringOrRef" },
+    version: { minimum: 1, type: "integer" }
+  },
+  required: ["$prototype"],
+  type: "object"
+};
+// ../schema/defs/pure-type-def.schema.ts
+var pureTypeDefSchema = {
+  description: "A reusable JSON Schema type definition for tooling only. " + "No function, no runtime artifact. " + "Referenced from state entries via $ref. " + "Naming convention: PascalCase.",
+  not: {
+    anyOf: [{ required: ["default"] }, { required: ["$prototype"] }]
+  },
+  properties: {
+    description: { type: "string" },
+    enum: { type: "array" },
+    examples: { type: "array" },
+    items: {},
+    maxLength: { minimum: 0, type: "integer" },
+    maximum: { type: "number" },
+    minLength: { minimum: 0, type: "integer" },
+    minimum: { type: "number" },
+    pattern: { type: "string" },
+    properties: { type: "object" },
+    required: { items: { type: "string" }, type: "array" },
+    type: { $ref: "#/$defs/JsonSchemaType" }
+  },
+  required: ["type"],
+  type: "object"
+};
+// ../schema/defs/expression-node.schema.ts
+var expressionNodeSchema = {
+  additionalProperties: false,
+  description: "The core expression node. operator + target, with value gated by arity.",
+  oneOf: [
+    {
+      not: { anyOf: [{ required: ["value"] }, { required: ["initial"] }] },
+      properties: { operator: { $ref: "#/$defs/UnaryOperator" } },
+      required: ["operator"],
+      title: "Unary — target only, no value"
+    },
+    {
+      not: { required: ["initial"] },
+      properties: { operator: { $ref: "#/$defs/BinaryOperator" } },
+      required: ["operator", "value"],
+      title: "Binary — left in target, right in value"
+    },
+    {
+      not: { required: ["initial"] },
+      properties: {
+        operator: { $ref: "#/$defs/AssignmentOperator" },
+        target: { $ref: "#/$defs/ExpressionPointer" }
+      },
+      required: ["operator", "value"],
+      title: "Assignment — writable target, value required"
+    },
+    {
+      not: { anyOf: [{ required: ["value"] }, { required: ["initial"] }] },
+      properties: {
+        operator: { $ref: "#/$defs/NoArgMethod" },
+        target: { $ref: "#/$defs/ExpressionPointer" }
+      },
+      required: ["operator"],
+      title: "pop / shift — array receiver, no value"
+    },
+    {
+      not: { required: ["initial"] },
+      properties: {
+        operator: { $ref: "#/$defs/OneArgMethod" },
+        target: { $ref: "#/$defs/ExpressionPointer" }
+      },
+      required: ["operator", "value"],
+      title: "push / unshift — array receiver, single value argument"
+    },
+    {
+      not: { required: ["initial"] },
+      properties: {
+        operator: { $ref: "#/$defs/SpliceMethod" },
+        target: { $ref: "#/$defs/ExpressionPointer" },
+        value: { items: { $ref: "#/$defs/ExpressionOperand" }, minItems: 1, type: "array" }
+      },
+      required: ["operator", "value"],
+      title: "splice — array receiver, [start, deleteCount, ...items]"
+    },
+    {
+      properties: {
+        operator: { $ref: "#/$defs/ReduceMethod" },
+        target: {
+          anyOf: [{ $ref: "#/$defs/ExpressionPointer" }, { $ref: "#/$defs/ExpressionNode" }]
+        },
+        value: { $ref: "#/$defs/ExpressionNode" }
+      },
+      required: ["operator", "value", "initial"],
+      title: "reduce — pure fold over a pointer or derived array; seed in initial"
+    },
+    {
+      not: { required: ["initial"] },
+      properties: {
+        operator: { $ref: "#/$defs/MapFilterMethod" },
+        target: {
+          anyOf: [{ $ref: "#/$defs/ExpressionPointer" }, { $ref: "#/$defs/ExpressionNode" }]
+        },
+        value: { $ref: "#/$defs/ExpressionNode" }
+      },
+      required: ["operator", "value"],
+      title: "map / filter — pure over a pointer or derived array; per-item expression in value"
+    },
+    {
+      description: "The ECMAScript conditional (ternary) operator, pure: target is the test, value the consequent, initial the alternate (the reduce precedent for repurposing initial). Chain else-if by nesting another ?: node in initial.",
+      properties: { operator: { $ref: "#/$defs/ConditionalOperator" } },
+      required: ["operator", "value", "initial"],
+      title: "?: — pure conditional; test in target, consequent in value, alternate in initial"
+    },
+    {
+      description: "Value-keyed multiway selection, pure: target is the discriminant (matched against case keys by its string form, like element-level $switch), cases maps matched values to result operands, default is the operand when no case matches (result is undefined without it). Condition-chain branching composes from nested ?: nodes instead.",
+      not: { anyOf: [{ required: ["value"] }, { required: ["initial"] }] },
+      properties: {
+        cases: {
+          additionalProperties: { $ref: "#/$defs/ExpressionOperand" },
+          type: "object"
+        },
+        default: { $ref: "#/$defs/ExpressionOperand" },
+        operator: { $ref: "#/$defs/SwitchOperator" }
+      },
+      required: ["operator", "cases"],
+      title: "switch — pure value-keyed selection; discriminant in target, results in cases/default"
+    },
+    {
+      description: "A pure standard-library method call: target is the receiver (any operand — never mutated; change-by-copy names replace the mutating originals), value the optional argument (bare scalar) or argument list (array). A missing receiver or method yields undefined, matching null-safe path reads.",
+      not: { required: ["initial"] },
+      properties: { operator: { $ref: "#/$defs/PureMethod" } },
+      required: ["operator"],
+      title: "Pure method — genuine prototype methods; receiver in target, args in value"
+    },
+    {
+      description: "Invoke a callable, pure in formula position: target is the callee pointer — a named formula entry (#/state/…) or a blessed pure global via window#/ (Math.*, JSON.*, Object.keys/values/entries, and " + `${intlHelpersClause()}) — and value is the positional argument list (the splice args-in-value precedent). Argument order follows the callee's declared parameters.`,
+      not: { required: ["initial"] },
+      properties: {
+        operator: { $ref: "#/$defs/CallOperator" },
+        target: { $ref: "#/$defs/ExpressionPointer" },
+        value: { items: { $ref: "#/$defs/ExpressionOperand" }, type: "array" }
+      },
+      required: ["operator"],
+      title: "call — invoke a named formula or blessed global; callee in target, args in value"
+    }
+  ],
+  properties: {
+    cases: {
+      additionalProperties: { $ref: "#/$defs/ExpressionOperand" },
+      description: "switch only: matched discriminant value (string form) → result operand.",
+      type: "object"
+    },
+    default: {
+      $ref: "#/$defs/ExpressionOperand",
+      description: "switch only: result operand when no case key matches."
+    },
+    initial: { $ref: "#/$defs/ExpressionOperand" },
+    operator: { type: "string" },
+    target: { $ref: "#/$defs/ExpressionOperand" },
+    value: { $ref: "#/$defs/ExpressionOperand" }
+  },
+  required: ["operator", "target"],
+  type: "object"
+};
+var expressionEntrySchema = {
+  additionalProperties: false,
+  description: "A declarative expression entry (Shape 5). Used as a state entry or inline event handler. With parameters it is a named formula: a pure, reusable computation invoked via the call operator, its parameters resolved through $args/<name> refs in the body.",
+  properties: {
+    $description: { type: "string" },
+    $expression: { $ref: "#/$defs/ExpressionNode" },
+    $title: { type: "string" },
+    parameters: {
+      description: "Named-formula parameters (CEM convention, as on Function entries): bare names or CEM parameter objects. Present ⇒ the entry is callable, not a computed value.",
+      items: { anyOf: [{ type: "string" }, { $ref: "#/$defs/CemParameter" }] },
+      type: "array"
+    }
+  },
+  required: ["$expression"],
+  type: "object"
+};
+// ../schema/defs/state-entry.schema.ts
+var stateEntrySchema = {
+  description: "A single state entry. Shape is determined by value type: " + "scalar/array → naked reactive property, string with ${} → computed, " + 'object with $prototype: "Function" → function, ' + "object with $prototype: <other> → data source, " + "object with type and default → typed reactive property, " + "plain object → naked object reactive property.",
+  oneOf: [
+    { type: "number" },
+    { type: "boolean" },
+    { type: "null" },
+    { type: "string" },
+    { type: "array" },
+    { $ref: "#/$defs/TypedStateDef" },
+    { $ref: "#/$defs/FunctionDef" },
+    { $ref: "#/$defs/ExternalClassDef" },
+    { $ref: "#/$defs/ExpressionEntry" },
+    {
+      not: {
+        anyOf: [
+          { required: ["$prototype"] },
+          { required: ["default"] },
+          { required: ["type"] },
+          { required: ["$expression"] }
+        ]
+      },
+      type: "object"
+    }
+  ]
+};
+var stateMapSchema = {
+  additionalProperties: { $ref: "#/$defs/StateEntry" },
+  description: "Map of runtime variables. Keys are camelCase (public) or #-prefixed (private). " + "All entries are reactive by default.",
+  type: "object"
+};
+var defsMapSchema = {
+  additionalProperties: { $ref: "#/$defs/TypeDefEntry" },
+  description: "Map of reusable JSON Schema type definitions. " + "Keys are PascalCase type names. No runtime artifacts are produced.",
+  type: "object"
+};
+var typeDefEntrySchema = {
+  description: "A $defs type definition entry. Must be a pure JSON Schema type " + "definition or a class definition (.class.json format).",
+  oneOf: [{ $ref: "#/$defs/PureTypeDef" }, { $ref: "#/$defs/ClassDef" }]
+};
+// ../schema/defs/class-def.schema.ts
+var CLASS_METHOD_ROLES = [
+  "method",
+  "accessor",
+  "parse",
+  "serialize",
+  "discover",
+  "load",
+  "projectData",
+  "resolvePaths",
+  "lower",
+  "emit",
+  "head",
+  "assets",
+  "mount",
+  "dialect",
+  "deploySchema",
+  "bindings",
+  "testConnection"
+];
+var classMethodDefSchema = {
+  description: "A class method or accessor definition. Capability roles (parse, serialize, discover, load) " + "mark static methods that hosts (compiler, server, studio) invoke for format dispatch.",
+  properties: {
+    $prototype: { const: "Function", type: "string" },
+    access: { enum: ["public", "private", "protected"], type: "string" },
+    body: {
+      oneOf: [{ type: "string" }, { items: { type: "string" }, type: "array" }]
+    },
+    description: { type: "string" },
+    getter: {
+      properties: { body: { type: "string" } },
+      type: "object"
+    },
+    identifier: { type: "string" },
+    parameters: {
+      items: {
+        oneOf: [
+          {
+            additionalProperties: false,
+            properties: { $ref: { type: "string" } },
+            required: ["$ref"],
+            type: "object"
+          },
+          { $ref: "#/$defs/ClassParameterDef" }
+        ]
+      },
+      type: "array"
+    },
+    returnType: {},
+    role: {
+      enum: CLASS_METHOD_ROLES,
+      type: "string"
+    },
+    scope: { enum: ["instance", "static"], type: "string" },
+    setter: {
+      properties: {
+        body: { type: "string" },
+        parameters: { type: "array" }
+      },
+      type: "object"
+    },
+    timing: {
+      description: "Execution environments allowed to call this capability directly. " + "Hosts outside the list round-trip through the dev server.",
+      items: { enum: ["compiler", "server", "client"], type: "string" },
+      type: "array"
+    }
+  },
+  type: "object"
+};
+var formatDefSchema = {
+  description: "Format participation marker. A class carrying this block is auto-discovered from the " + "project imports map and used for file-extension dispatch by the compiler, server, and studio.",
+  properties: {
+    documentKinds: {
+      description: '"page"/"component" allow the extension in pages/components discovery; ' + '"content" allows it as a content-type source.',
+      items: { enum: ["page", "component", "content"], type: "string" },
+      type: "array"
+    },
+    exportTarget: {
+      description: "When true, site builds emit a serialized sidecar per page in this format.",
+      type: "boolean"
+    },
+    extensions: {
+      description: 'File extensions this format claims, with leading dot (e.g. [".md"]).',
+      items: { pattern: "^\\.", type: "string" },
+      minItems: 1,
+      type: "array"
+    },
+    mediaType: {
+      description: "MIME type for the format (icons, labels, HTTP).",
+      type: "string"
+    },
+    remote: {
+      description: "When true, the load capability accepts http(s) URLs as sources.",
+      type: "boolean"
+    }
+  },
+  required: ["extensions"],
+  type: "object"
+};
+var projectBlockDefSchema = {
+  additionalProperties: false,
+  description: "Project-section admission block (specs/extensions.md §9). A class carrying this block owns " + "the project.json section named by `key`; hosts dispatch that section's data through the " + "class's projectData/resolvePaths capabilities.",
+  properties: {
+    description: { type: "string" },
+    key: {
+      description: "The project.json top-level section this class owns (exclusive per project).",
+      type: "string"
+    },
+    referenceable: {
+      description: "Whether section entries can be referenced from documents (e.g. content types).",
+      type: "boolean"
+    },
+    title: { type: "string" }
+  },
+  required: ["key"],
+  type: "object"
+};
+var serverBlockDefSchema = {
+  additionalProperties: false,
+  description: "Server-mount admission block (specs/extensions.md §11). A class carrying this block mounts " + "routes under its /_jx/ basePath in the site worker and dev server.",
+  properties: {
+    basePath: {
+      description: "Route subtree this class mounts — must be under /_jx/ (exclusive per project).",
+      examples: ["/_jx/data", "/_jx/auth"],
+      type: "string"
+    },
+    module: {
+      description: "Module specifier exporting the mount handler.",
+      type: "string"
+    },
+    order: {
+      description: "Mount order (ascending; default 100).",
+      type: "number"
+    }
+  },
+  required: ["basePath"],
+  type: "object"
+};
+var connectorBlockDefSchema = {
+  description: "Connection-provider admission block (specs/extensions.md §12). A class carrying this block " + "provides database connections of the given provider/kind.",
+  properties: {
+    kind: {
+      description: "SQL dialect family the provider speaks.",
+      enum: ["sqlite", "postgres"],
+      type: "string"
+    },
+    local: {
+      description: "Local-development substitute provider (e.g. sqlite for D1).",
+      type: "string"
+    },
+    module: {
+      description: "Module specifier exporting the provider implementation.",
+      type: "string"
+    },
+    provider: {
+      description: "Provider identifier (e.g. d1, supabase, sqlite).",
+      type: "string"
+    },
+    serve: {
+      description: "Module specifier exporting the serve-time worker binding.",
+      type: "string"
+    }
+  },
+  required: ["provider", "kind"],
+  type: "object"
+};
+var studioHintsSchema = {
+  description: "Studio control-surface hints for a format class: editor modes, document-mode rules, " + "templates, and the element/nesting constraints that gate structural editing.",
+  properties: {
+    documentMode: {
+      properties: {
+        componentWhen: {
+          description: "Treat the document as a component when this top-level/frontmatter key matches the regex.",
+          properties: {
+            frontmatterKey: { type: "string" },
+            matches: { type: "string" }
+          },
+          type: "object"
+        },
+        default: { enum: ["content", "component"], type: "string" }
+      },
+      type: "object"
+    },
+    elements: {
+      description: "Element allowlist and nesting constraints for structural editing.",
+      properties: {
+        block: { items: { type: "string" }, type: "array" },
+        inline: { items: { type: "string" }, type: "array" },
+        nesting: {
+          additionalProperties: {
+            properties: {
+              block: { type: "boolean" },
+              directive: { type: "boolean" },
+              inline: { type: "boolean" },
+              only: { items: { type: "string" }, type: "array" }
+            },
+            type: "object"
+          },
+          description: 'Per-parent child rules keyed by tag (or "_root"): ' + "{ block, inline, directive } booleans or { only: [tags] }.",
+          type: "object"
+        },
+        textOnly: { items: { type: "string" }, type: "array" },
+        void: { items: { type: "string" }, type: "array" }
+      },
+      type: "object"
+    },
+    icon: { type: "string" },
+    modes: {
+      description: "Editor modes the studio offers for documents of this format.",
+      items: { type: "string" },
+      type: "array"
+    },
+    newFileTemplate: {
+      description: "Initial source text for newly created files of this format.",
+      type: "string"
+    }
+  },
+  type: "object"
+};
+var classDefSchema = {
+  additionalProperties: false,
+  description: 'A .class.json schema-defined class. $prototype must be "Class". ' + "Defines fields, constructor, methods, and type parameters via $defs. " + "Optionally points to a JS module via $implementation for hybrid execution.",
+  properties: {
+    $defs: {
+      description: "Class members: parameters, returnTypes, fields, constructor, methods.",
+      properties: {
+        constructor: { $ref: "#/$defs/ClassConstructorDef" },
+        fields: {
+          additionalProperties: { $ref: "#/$defs/ClassFieldDef" },
+          description: "Class fields with role, access, scope, and type information.",
+          type: "object"
+        },
+        methods: {
+          additionalProperties: { $ref: "#/$defs/ClassMethodDef" },
+          description: "Class methods and accessors.",
+          type: "object"
+        },
+        parameters: {
+          additionalProperties: { $ref: "#/$defs/ClassParameterDef" },
+          description: "Reusable typed parameter schemas, keyed by name.",
+          type: "object"
+        },
+        returnTypes: {
+          additionalProperties: { type: "object" },
+          description: "Output type schemas, keyed by name.",
+          type: "object"
+        }
+      },
+      type: "object"
+    },
+    $id: { type: "string" },
+    $implementation: {
+      description: "Relative path to a JS module containing the actual class implementation.",
+      type: "string"
+    },
+    $prototype: { const: "Class", type: "string" },
+    $schema: { type: "string" },
+    $studio: { $ref: "#/$defs/StudioHints" },
+    connector: { $ref: "#/$defs/ConnectorBlockDef" },
+    description: { type: "string" },
+    extends: {
+      description: "Base class — string name or $ref to another .class.json.",
+      oneOf: [
+        { type: "string" },
+        { properties: { $ref: { type: "string" } }, required: ["$ref"], type: "object" }
+      ]
+    },
+    format: { $ref: "#/$defs/FormatDef" },
+    project: { $ref: "#/$defs/ProjectBlockDef" },
+    server: { $ref: "#/$defs/ServerBlockDef" },
+    title: {
+      description: "PascalCase class name, used as the export name.",
+      type: "string"
+    }
+  },
+  required: ["$prototype", "title"],
+  type: "object"
+};
+// ../schema/defs/project-config.schema.ts
+var REDIRECT_STATUSES = [301, 302, 303, 307, 308];
+var projectConfigSchema = {
+  description: "Schema for Jx project.json files. " + "A project.json file is the root anchor file for a Jx project, " + "declaring site metadata, default settings, global styles, extensions, " + "and build configuration. Open by design: extension-contributed sections " + "(e.g. `content`) are opaque top-level keys; the generated per-project " + "entry document (project.schema.json) closes the composition.",
+  properties: {
+    $defs: {
+      description: "Global type definitions available to all pages.",
+      type: "object"
+    },
+    $elements: {
+      description: "Global custom element dependencies available to all pages. " + "Items are $ref objects or npm package specifier strings.",
+      items: {
+        oneOf: [
+          {
+            additionalProperties: false,
+            properties: { $ref: { type: "string" } },
+            required: ["$ref"],
+            type: "object"
+          },
+          { type: "string" }
+        ]
+      },
+      type: "array"
+    },
+    $head: {
+      description: "Global <head> entries applied to all pages. " + "Array of element definitions for meta tags, link tags, script tags, etc.",
+      examples: [
+        [
+          { attributes: { href: "/favicon.svg", rel: "icon" }, tagName: "link" },
+          { attributes: { content: "Jx", name: "generator" }, tagName: "meta" }
+        ]
+      ],
+      items: {
+        properties: {
+          attributes: {
+            additionalProperties: { type: "string" },
+            type: "object"
+          },
+          tagName: { type: "string" }
+        },
+        type: "object"
+      },
+      type: "array"
+    },
+    $media: {
+      additionalProperties: { type: "string" },
+      description: "Named media breakpoints following CSS @custom-media convention. " + "Available in all component style objects. Declaring a pure color-scheme " + 'query (e.g. "--dark": "(prefers-color-scheme: dark)") additionally opts the ' + "site into the forced-scheme contract: @--dark style blocks are dual-emitted " + "so a data-color-scheme attribute on <html> overrides the OS preference, " + "color-scheme is declared on :root, and a pre-paint script restores the " + "visitor's persisted choice (spec §9.5).",
+      examples: [
+        {
+          "--dark": "(prefers-color-scheme: dark)",
+          "--lg": "(min-width: 1024px)",
+          "--md": "(min-width: 768px)",
+          "--sm": "(min-width: 640px)"
+        }
+      ],
+      type: "object"
+    },
+    $schema: {
+      description: "Relative path to the generated per-project schema (conventionally " + "./project.schema.json, written by `jx schema`).",
+      type: "string"
+    },
+    build: {
+      description: "Build configuration.",
+      properties: {
+        adapter: {
+          description: "Platform adapter for deployment-specific output.",
+          enum: ["static", "cloudflare-pages", "cloudflare-workers", "node", "bun"],
+          type: "string"
+        },
+        deploy: {
+          additionalProperties: false,
+          description: "Deployment tracking: the hosting project this repo publishes to. Identifiers " + "only (no secrets) — safe to commit; Studio uses it to tell whether the publish " + "workflow already exists. `adapter` says how the build is packaged; `deploy` says " + "where it ships.",
+          properties: {
+            accountId: {
+              description: "Hosting account id (e.g. the Cloudflare account id).",
+              type: "string"
+            },
+            productionUrl: {
+              description: "Production URL of the connected hosting project.",
+              type: "string"
+            },
+            projectName: {
+              description: "Hosting project name (e.g. the Cloudflare Pages project).",
+              pattern: "^[a-z0-9][a-z0-9-]*$",
+              type: "string"
+            },
+            provider: {
+              description: "Hosting provider the project is connected to.",
+              enum: ["cloudflare-pages"],
+              type: "string"
+            }
+          },
+          required: ["provider", "accountId", "projectName"],
+          type: "object"
+        },
+        format: {
+          default: "directory",
+          description: "Reserved; currently unused. Accepted for forward compatibility with single-file output (desktop single-file mode) — the build emits per-route directories regardless.",
+          enum: ["directory", "single"],
+          type: "string"
+        },
+        outDir: {
+          default: "./dist",
+          description: "Output directory for compiled site.",
+          type: "string"
+        },
+        headers: {
+          additionalProperties: false,
+          description: "Emit dist/_headers — the response headers only the build can know. Honored by " + "Cloudflare Pages/Workers assets and Netlify; on the node/bun adapters the file " + "documents what a reverse proxy in front of them must send.",
+          properties: {
+            cache: {
+              default: "auto",
+              description: '"auto" marks the content-addressed image variants immutable (RFC 8246) and ' + 'revalidates everything else (RFC 9111). "off" emits no Cache-Control at all.',
+              enum: ["auto", "off"],
+              type: "string"
+            },
+            enabled: { default: true, type: "boolean" },
+            rules: {
+              additionalProperties: { additionalProperties: { type: "string" }, type: "object" },
+              description: "Verbatim rules, merged after the generated block.",
+              propertyNames: { pattern: "^/" },
+              type: "object"
+            },
+            security: {
+              additionalProperties: false,
+              properties: {
+                contentTypeOptions: { default: true, type: "boolean" },
+                csp: {
+                  default: false,
+                  description: "CSP Level 3. Off by default: unlike the other security headers this one " + "governs code the build cannot see — a third-party script that loads a " + "second script, a widget that opens a frame — so turning it on is a change " + "to verify in the browser console, not a safe default. `script-src` is " + "derived from the inline scripts and external origins the build emitted; " + "`style-src` keeps 'unsafe-inline', because per-page <style> blocks and " + "per-element style attributes have no site-wide hash.",
+                  oneOf: [
+                    { type: "boolean" },
+                    { const: "report-only" },
+                    {
+                      additionalProperties: false,
+                      properties: {
+                        directives: {
+                          additionalProperties: {
+                            oneOf: [{ type: "string" }, { const: false }]
+                          },
+                          description: "Replace (string) or remove (false) a computed directive. A " + "replacement is wholesale, so an addition restates the defaults.",
+                          type: "object"
+                        },
+                        mode: { default: "enforce", enum: ["enforce", "report-only"] },
+                        reportUri: { format: "uri-reference", type: "string" }
+                      },
+                      type: "object"
+                    }
+                  ]
+                },
+                frameOptions: {
+                  default: "SAMEORIGIN",
+                  oneOf: [{ enum: ["DENY", "SAMEORIGIN"], type: "string" }, { const: false }]
+                },
+                hsts: {
+                  default: false,
+                  description: "RFC 6797. Off by default: a wrong max-age locks the apex domain to HTTPS " + "for that long, and the mistake is invisible until a certificate lapses. " + "`preload` requires `includeSubDomains` and is a build error without it.",
+                  oneOf: [
+                    { type: "boolean" },
+                    {
+                      additionalProperties: false,
+                      properties: {
+                        includeSubDomains: { default: true, type: "boolean" },
+                        maxAge: { default: 31536000, minimum: 0, type: "integer" },
+                        preload: { default: false, type: "boolean" }
+                      },
+                      type: "object"
+                    }
+                  ]
+                },
+                permissionsPolicy: {
+                  default: "camera=(), microphone=(), geolocation=()",
+                  oneOf: [{ type: "string" }, { const: false }]
+                },
+                referrerPolicy: {
+                  default: "strict-origin-when-cross-origin",
+                  oneOf: [
+                    {
+                      enum: [
+                        "no-referrer",
+                        "no-referrer-when-downgrade",
+                        "origin",
+                        "origin-when-cross-origin",
+                        "same-origin",
+                        "strict-origin",
+                        "strict-origin-when-cross-origin",
+                        "unsafe-url"
+                      ],
+                      type: "string"
+                    },
+                    { const: false }
+                  ]
+                }
+              },
+              type: "object"
+            }
+          },
+          type: "object"
+        },
+        sitemap: {
+          default: true,
+          description: "Generate sitemap.xml from the route table (requires `url`). Set false to disable.",
+          type: "boolean"
+        },
+        trailingSlash: {
+          default: "always",
+          description: "Trailing slash behavior for generated URLs.",
+          enum: ["always", "never", "ignore"],
+          type: "string"
+        }
+      },
+      type: "object"
+    },
+    copy: {
+      additionalProperties: { type: "string" },
+      description: "Declarative file copy map. Keys are source paths (relative to project root), values are destination paths (relative to outDir).",
+      type: "object"
+    },
+    defaults: {
+      description: "Default settings applied to all pages unless overridden.",
+      properties: {
+        charset: {
+          default: "utf8",
+          description: "Default charset for the page.",
+          type: "string"
+        },
+        dir: {
+          description: "Base direction for the <html> element. Omitted when unset — a page's `$dir` " + "overrides it. Right-to-left content renders left-to-right without this.",
+          enum: ["ltr", "rtl", "auto"],
+          type: "string"
+        },
+        lang: {
+          default: "en",
+          description: "Default lang attribute for the <html> element. A page's `$lang` overrides it.",
+          type: "string"
+        },
+        layout: {
+          default: null,
+          description: "Default layout file path applied to all pages. " + "Set to null to render pages without a layout.",
+          examples: ["./layouts/base.json"],
+          oneOf: [{ type: "string" }, { type: "null" }]
+        },
+        shadow: {
+          default: false,
+          description: "Default shadow-DOM mode for every component (spec.md §16.6). Off unless set: a " + "shadow root isolates component styles from the page and replaces the <slot> " + "emulation with real slot distribution. A component's own `$shadow` overrides this " + "in both directions.",
+          oneOf: [
+            { enum: ["open", "closed"], type: "string" },
+            { const: false, type: "boolean" }
+          ]
+        }
+      },
+      type: "object"
+    },
+    extensions: {
+      description: "Extension packages: bare package names (resolved project-first through the package " + "exports map) or relative paths. Each must export jx-extension.json.",
+      examples: [["@jxsuite/parser"]],
+      items: { type: "string" },
+      type: "array"
+    },
+    manifest: {
+      additionalProperties: false,
+      description: 'W3C Web App Manifest, emitted as manifest.webmanifest with a <link rel="manifest"> ' + "on every page. Absent means no manifest: it is a claim that a site is meant to be " + "installed, and most are not.",
+      properties: {
+        backgroundColor: { type: "string" },
+        categories: { items: { type: "string" }, type: "array" },
+        description: { type: "string" },
+        dir: { enum: ["ltr", "rtl", "auto"], type: "string" },
+        display: {
+          default: "standalone",
+          enum: ["fullscreen", "standalone", "minimal-ui", "browser"],
+          type: "string"
+        },
+        enabled: { default: true, type: "boolean" },
+        icons: {
+          description: "Icons at 192px and 512px are what browsers require before offering to install " + "the site; the build warns when either is missing.",
+          items: {
+            additionalProperties: false,
+            properties: {
+              purpose: { type: "string" },
+              sizes: { examples: ["192x192"], type: "string" },
+              src: { type: "string" },
+              type: { type: "string" }
+            },
+            required: ["src"],
+            type: "object"
+          },
+          type: "array"
+        },
+        lang: { type: "string" },
+        name: { description: "Defaults to the project name.", type: "string" },
+        orientation: { type: "string" },
+        scope: { type: "string" },
+        shortName: { type: "string" },
+        startUrl: { default: "/", type: "string" },
+        themeColor: { type: "string" }
+      },
+      type: "object"
+    },
+    serviceWorker: {
+      default: false,
+      description: "W3C Service Worker, emitted as sw.js. Off unless declared — a worker is sticky, so it " + "is the one output that can keep breaking visitors after a deploy tries to fix them. " + "**Turning it off means `false`, not deleting the key**: `false` emits a tombstone at " + "the same URL that unregisters the old worker and clears its caches, and a 404 there is " + "not an instruction to stop. HTML is always network-first; only the content-addressed " + "/images/_optimized/* is served cache-first.",
+      oneOf: [
+        { type: "boolean" },
+        {
+          additionalProperties: false,
+          properties: {
+            enabled: { default: true, type: "boolean" },
+            offlineFallback: {
+              description: "Page served for a failed navigation. Added to `precache` if not already there.",
+              type: "string"
+            },
+            precache: {
+              description: "Site-absolute URLs fetched at install time. Each must be a file this build " + "produces; one that is not fails the build, because a single unreachable entry " + "stops the worker installing at all.",
+              items: { pattern: "^/", type: "string" },
+              type: "array"
+            },
+            scope: { default: "/", type: "string" }
+          },
+          type: "object"
+        }
+      ]
+    },
+    securityTxt: {
+      additionalProperties: false,
+      description: "RFC 9116 security.txt, emitted at .well-known/security.txt. `expires` is required by " + "§2.5.5 and an absent or past value is a build error — an expired file advertises a " + "reporting channel while telling the reporter not to trust it. A hand-placed " + "public/.well-known/security.txt shadows this, which is how a clearsigned file ships.",
+      properties: {
+        acknowledgments: { items: { type: "string" }, type: "array" },
+        canonical: { type: "string" },
+        contact: {
+          description: "At least one mailto:, https: or tel: URI (§2.5.3).",
+          items: { type: "string" },
+          type: "array"
+        },
+        enabled: { default: true, type: "boolean" },
+        encryption: { items: { type: "string" }, type: "array" },
+        expires: { format: "date-time", type: "string" },
+        hiring: { items: { type: "string" }, type: "array" },
+        policy: { items: { type: "string" }, type: "array" },
+        preferredLanguages: {
+          description: "BCP 47 tags, validated and canonicalized like i18n.locales.",
+          items: { pattern: LANGUAGE_TAG_PATTERN, type: "string" },
+          type: "array"
+        }
+      },
+      type: "object"
+    },
+    i18n: {
+      description: "Internationalization configuration.",
+      properties: {
+        defaultLocale: {
+          description: "Default locale, as a BCP 47 language tag. The pattern catches shape errors " + "(`en_US`, `en--US`); the build is the authority on well-formedness.",
+          examples: ["en"],
+          pattern: LANGUAGE_TAG_PATTERN,
+          type: "string"
+        },
+        locales: {
+          description: "Available locales, as BCP 47 language tags.",
+          examples: [["en", "fr", "de"]],
+          items: { pattern: LANGUAGE_TAG_PATTERN, type: "string" },
+          type: "array"
+        },
+        routing: {
+          description: "Locale routing strategy.",
+          enum: ["prefix-except-default", "prefix-always"],
+          type: "string"
+        }
+      },
+      type: "object"
+    },
+    images: { $ref: "#/$defs/ImageConfig" },
+    imports: {
+      additionalProperties: { type: "string" },
+      description: "Global import map: $prototype names to .class.json file paths. " + "Makes external classes available by name in all pages.",
+      examples: [
+        {
+          Markdown: "@jxsuite/parser/Markdown.class.json",
+          MarkdownCollection: "@jxsuite/parser/MarkdownCollection.class.json"
+        }
+      ],
+      type: "object"
+    },
+    name: {
+      default: "Jx Site",
+      description: "Human-readable project name.",
+      examples: ["My Portfolio", "Jx Example Site"],
+      type: "string"
+    },
+    redirects: {
+      additionalProperties: {
+        oneOf: [
+          { description: "Destination path or URL; implies a 301.", type: "string" },
+          {
+            additionalProperties: false,
+            description: "A redirect with an explicit RFC 9110 §15.4 status.",
+            properties: {
+              destination: { type: "string" },
+              status: {
+                default: 301,
+                description: "RFC 9110 §15.4 redirection status. 307 and 308 preserve the request method; " + "301 and 302 historically do not.",
+                enum: [...REDIRECT_STATUSES],
+                type: "integer"
+              }
+            },
+            required: ["destination"],
+            type: "object"
+          },
+          {
+            additionalProperties: false,
+            description: "A rewrite (proxy): the destination's content is served AT the source URL, with no " + "redirect. Emitted as status 200 in `_redirects`, which is the host convention — " + "not an HTTP redirection status.",
+            properties: {
+              destination: { type: "string" },
+              rewrite: { const: true, type: "boolean" }
+            },
+            required: ["destination", "rewrite"],
+            type: "object"
+          }
+        ]
+      },
+      description: "Static redirect and rewrite rules. Keys are source paths in URLPattern pathname syntax.",
+      examples: [
+        {
+          "/api/*": { destination: "https://api.example.com/*", rewrite: true },
+          "/legacy/*": { destination: "/archive/*", status: 308 },
+          "/old-about": "/about"
+        }
+      ],
+      propertyNames: { pattern: "^/" },
+      type: "object"
+    },
+    state: {
+      description: "Site-wide reactive state available to all pages.",
+      type: "object"
+    },
+    style: {
+      additionalProperties: {
+        oneOf: [{ type: "string" }, { type: "number" }, { $ref: "#/$defs/StyleObject" }]
+      },
+      description: "Global CSS styles applied to the <body> element. " + "Uses the same camelCase CSSOM convention and recursive selector/at-rule " + "nesting as component styles.",
+      type: "object"
+    },
+    url: {
+      description: "Production URL of the deployed site.",
+      examples: ["https://example.com", "https://jxsuite.com"],
+      type: "string"
+    }
+  },
+  type: "object"
+};
+// ../schema/defs/extension-manifest.schema.ts
+var extensionManifestSchema = {
+  additionalProperties: false,
+  description: "Schema for jx-extension.json manifests. Located at the extension package root and " + "exported so hosts can resolve <package>/jx-extension.json through the exports map.",
+  properties: {
+    $schema: { type: "string" },
+    classes: {
+      additionalProperties: { type: "string" },
+      description: "$prototype-visible class name → class descriptor path, relative to the manifest.",
+      type: "object"
+    },
+    description: { description: "One-line description.", type: "string" },
+    name: { description: "Package name; must match package.json.", type: "string" },
+    schemas: {
+      additionalProperties: false,
+      description: "Schema fragments this package contributes, relative to the manifest.",
+      properties: {
+        document: {
+          description: "Document-schema fragment (positions like $paths values).",
+          type: "string"
+        },
+        fields: {
+          description: "Field-union fragment: its $defs members are unioned into the per-project " + "field-schema resource as extension field extras (specs/extensions.md §5.3).",
+          type: "string"
+        },
+        project: {
+          description: "Project-schema fragment (top-level project.json sections).",
+          type: "string"
+        }
+      },
+      type: "object"
+    },
+    title: { description: "Human-readable name for studio surfaces.", type: "string" }
+  },
+  required: ["name"],
+  type: "object"
+};
+// src/ui/value-source.ts
+var SLOT_MODE_ORDER = ["literal", "ref", "template", "expression", "function"];
+var VALUE_SOURCE_LABELS = {
+  expression: "Formula",
+  function: "Inline function",
+  literal: "Fixed value",
+  ref: "From data…",
+  template: "Mixed text"
+};
+var VALUE_SOURCE_HINTS = {
+  expression: "Computed from other values, built up operator by operator.",
+  function: "Code that runs when this fires.",
+  literal: "A value you type here, the same every time.",
+  ref: "The current value of a signal, picked from a list.",
+  template: "Text with ${…} placeholders that fill in from signals."
+};
+function slotMode(value) {
+  if (isRef(value)) {
+    return "ref";
+  }
+  if (isFunctionDef(value)) {
+    return "function";
+  }
+  if (isTemplateString(value)) {
+    return "template";
+  }
+  if (value && typeof value === "object" && "$expression" in value) {
+    return "expression";
+  }
+  return "literal";
+}
+var EVENT_HANDLER_SCHEMA = {
+  oneOf: [
+    { $ref: "#/$defs/RefObject" },
+    { $ref: "#/$defs/ExpressionEntry" },
+    { $ref: "#/$defs/FunctionDef" }
+  ]
+};
+var REACHABLE_DEFS = {
+  ExpressionEntry: expressionEntrySchema,
+  FunctionDef: functionDefSchema,
+  RefObject: refObjectSchema,
+  StyleObject: styleObjectSchema
+};
+function isRefObjectSchema(node) {
+  const { required } = node;
+  return Array.isArray(required) && required.includes("$ref") && Boolean(node.properties?.$ref);
+}
+function isExpressionEntrySchema(node) {
+  const { required } = node;
+  return Array.isArray(required) && required.includes("$expression");
+}
+function isFunctionDefSchema(node) {
+  const proto = node.properties?.$prototype;
+  return proto?.const === "Function";
+}
+function isFreeStringSchema(node) {
+  return node.type === "string" && node.pattern === undefined && node.enum === undefined && node.const === undefined;
+}
+var SCALAR_TYPES = new Set(["array", "boolean", "integer", "null", "number", "object", "string"]);
+function walk(node, state) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  const schema = node;
+  if (state.seen.has(schema)) {
+    return;
+  }
+  state.seen.add(schema);
+  const pointer = typeof schema.$ref === "string" ? schema.$ref : undefined;
+  if (pointer !== undefined && Object.keys(schema).length === 1) {
+    const name = pointer.startsWith("#/$defs/") ? pointer.slice("#/$defs/".length) : pointer;
+    const target = REACHABLE_DEFS[name];
+    if (target) {
+      walk(target, state);
+    } else {
+      state.unresolved.add(pointer);
+    }
+    return;
+  }
+  if (isRefObjectSchema(schema)) {
+    state.found.add("ref");
+    return;
+  }
+  if (isExpressionEntrySchema(schema)) {
+    state.found.add("expression");
+    return;
+  }
+  if (isFunctionDefSchema(schema)) {
+    state.found.add("function");
+    return;
+  }
+  let composed = false;
+  for (const key of ["oneOf", "anyOf", "allOf"]) {
+    const branches = schema[key];
+    if (Array.isArray(branches)) {
+      composed = true;
+      for (const branch of branches) {
+        walk(branch, state);
+      }
+    }
+  }
+  if (composed) {
+    return;
+  }
+  if (isFreeStringSchema(schema)) {
+    state.found.add("literal");
+    state.found.add("template");
+    return;
+  }
+  if (schema.enum !== undefined || schema.const !== undefined) {
+    state.found.add("literal");
+    return;
+  }
+  if (typeof schema.type === "string" && SCALAR_TYPES.has(schema.type)) {
+    state.found.add("literal");
+  }
+}
+function deriveSlotCapsDetailed(schema) {
+  const state = { found: new Set, seen: new Set, unresolved: new Set };
+  walk(schema, state);
+  return {
+    caps: SLOT_MODE_ORDER.filter((m) => state.found.has(m)),
+    unresolved: [...state.unresolved].toSorted()
+  };
+}
+function deriveSlotCaps(schema) {
+  return deriveSlotCapsDetailed(schema).caps;
+}
+var ELEMENT_TAG_SCHEMA = {
+  anyOf: [tagNameSchema, ...elementTagNameSchema.anyOf.slice(1)]
+};
+var SLOT_POSITION_SCHEMAS = {
+  attribute: attributesObjectSchema.additionalProperties,
+  componentProp: propsObjectSchema.additionalProperties,
+  elementProperty: elementPropertyValueSchema,
+  eventHandler: EVENT_HANDLER_SCHEMA,
+  repeaterFilter: arrayNamespaceSchema.properties.filter,
+  repeaterItems: arrayNamespaceSchema.properties.items,
+  repeaterSort: arrayNamespaceSchema.properties.sort,
+  styleProperty: styleObjectSchema.additionalProperties,
+  switchDiscriminant: switchDefSchema,
+  elementTag: ELEMENT_TAG_SCHEMA,
+  textProperty: stringOrRefSchema
+};
+var capsCache = new Map;
+function capsForPosition(position) {
+  const hit = capsCache.get(position);
+  if (hit) {
+    return hit;
+  }
+  const derived = deriveSlotCaps(SLOT_POSITION_SCHEMAS[position]);
+  capsCache.set(position, derived);
+  return derived;
+}
+function slotCaps(source) {
+  return typeof source === "string" ? capsForPosition(source) : deriveSlotCaps(source.schema);
+}
+function configFieldSchema(field) {
+  const declared = deriveSlotCaps(field).length > 0 ? field : { type: "string" };
+  return { anyOf: [declared, { $ref: "#/$defs/RefObject" }] };
+}
+
+// src/ui/expression-editor.ts
+var UNARY_OPS = new Set(["!", "-"]);
+var BINARY_OPS = new Set([
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "===",
+  "!==",
+  "<",
+  "<=",
+  ">",
+  ">=",
+  "&&",
+  "||",
+  "??"
+]);
+var ASSIGN_OPS = new Set(["=", "+=", "-=", "*=", "/="]);
+function isActionExpression(node) {
+  const op = node?.operator;
+  return typeof op === "string" && ASSIGN_OPS.has(op);
+}
+var NO_ARG_OPS = new Set(["pop", "shift"]);
+var ONE_ARG_OPS = new Set(["push", "unshift"]);
+var ZERO_ARG_METHOD_OPS = new Set([
+  "flat",
+  "normalize",
+  "toLocaleLowerCase",
+  "toLocaleString",
+  "toLocaleUpperCase",
+  "toLowerCase",
+  "toReversed",
+  "toSorted",
+  "toUpperCase",
+  "trim",
+  "trimEnd",
+  "trimStart"
+]);
+var OPERATOR_GROUPS = [
+  { label: "Assignment", ops: ["=", "+=", "-=", "*=", "/="] },
+  { label: "Unary", ops: ["!", "-"] },
+  { label: "Arithmetic", ops: ["+", "-", "*", "/", "%"] },
+  { label: "Comparison", ops: ["===", "!==", "<", "<=", ">", ">="] },
+  { label: "Logical", ops: ["&&", "||", "??"] },
+  { label: "Conditional", ops: ["?:", "switch"] },
+  {
+    label: "Array methods",
+    ops: ["push", "pop", "shift", "unshift", "splice"]
+  },
+  {
+    label: "Pure methods (String)",
+    ops: [
+      "toUpperCase",
+      "toLowerCase",
+      "trim",
+      "trimStart",
+      "trimEnd",
+      "split",
+      "startsWith",
+      "endsWith",
+      "padStart",
+      "padEnd",
+      "replaceAll",
+      "repeat",
+      "charAt",
+      "normalize"
+    ]
+  },
+  {
+    label: "Pure methods (Array)",
+    ops: [
+      "includes",
+      "indexOf",
+      "lastIndexOf",
+      "join",
+      "slice",
+      "concat",
+      "at",
+      "flat",
+      "toSorted",
+      "toReversed",
+      "toSpliced",
+      "with"
+    ]
+  },
+  { label: "Pure methods (Number)", ops: ["toFixed", "toPrecision", "toLocaleString"] },
+  { label: "Aggregate", ops: ["reduce", "map", "filter"] },
+  { label: "Function", ops: ["call"] }
+];
+var INFO_DEFAULTS = {
+  callArgs: false,
+  needsInitial: false,
+  needsValue: false,
+  spliceArray: false,
+  switchCases: false,
+  targetMustBeRef: false,
+  valueIsNode: false
+};
+function operatorInfo(op) {
+  if (UNARY_OPS.has(op)) {
+    return { ...INFO_DEFAULTS };
+  }
+  if (op === "?:") {
+    return { ...INFO_DEFAULTS, needsInitial: true, needsValue: true };
+  }
+  if (op === "switch") {
+    return { ...INFO_DEFAULTS, switchCases: true };
+  }
+  if (op === "call") {
+    return { ...INFO_DEFAULTS, callArgs: true, targetMustBeRef: true };
+  }
+  if (PURE_METHOD_OPS.has(op)) {
+    return { ...INFO_DEFAULTS, needsValue: !ZERO_ARG_METHOD_OPS.has(op) };
+  }
+  if (BINARY_OPS.has(op)) {
+    return { ...INFO_DEFAULTS, needsValue: true };
+  }
+  if (ASSIGN_OPS.has(op)) {
+    return { ...INFO_DEFAULTS, needsValue: true, targetMustBeRef: true };
+  }
+  if (NO_ARG_OPS.has(op)) {
+    return { ...INFO_DEFAULTS, targetMustBeRef: true };
+  }
+  if (ONE_ARG_OPS.has(op)) {
+    return { ...INFO_DEFAULTS, needsValue: true, targetMustBeRef: true };
+  }
+  if (op === "splice") {
+    return { ...INFO_DEFAULTS, needsValue: true, spliceArray: true, targetMustBeRef: true };
+  }
+  if (op === "reduce") {
+    return {
+      ...INFO_DEFAULTS,
+      needsInitial: true,
+      needsValue: true,
+      targetMustBeRef: true,
+      valueIsNode: true
+    };
+  }
+  if (op === "map" || op === "filter") {
+    return { ...INFO_DEFAULTS, needsValue: true, targetMustBeRef: true, valueIsNode: true };
+  }
+  return { ...INFO_DEFAULTS };
+}
+function operandMode(operand) {
+  if (operand && typeof operand === "object") {
+    if ("$ref" in operand) {
+      return "ref";
+    }
+    if ("operator" in operand) {
+      return "expression";
+    }
+  }
+  return "literal";
+}
+function calleeParamLabels(target, state) {
+  const ref2 = isRef(target) ? target.$ref : "";
+  const entry = ref2 ? calleeEntry(ref2, state) : undefined;
+  return entry?.kind === "formula" ? entry.parameters.map((p) => p.name) : [];
+}
+function defaultForMode(mode) {
+  if (mode === "ref") {
+    return { $ref: "" };
+  }
+  if (mode === "expression") {
+    return { operator: "!", target: null };
+  }
+  return null;
+}
+function literalType(val) {
+  if (val === null || val === undefined) {
+    return "null";
+  }
+  if (typeof val === "boolean") {
+    return "boolean";
+  }
+  if (typeof val === "number") {
+    return "number";
+  }
+  return "string";
+}
+function defaultForLiteralType(type) {
+  if (type === "number") {
+    return 0;
+  }
+  if (type === "boolean") {
+    return false;
+  }
+  if (type === "null") {
+    return null;
+  }
+  return "";
+}
+function expressionHint(node) {
+  if (!isJsonObject(node) || typeof node.operator !== "string") {
+    return "$expression";
+  }
+  const expr = node;
+  const op = expr.operator;
+  const { target } = expr;
+  const targetLabel = isRef(target) ? target.$ref.replace("#/state/", "") : isJsonObject(target) && typeof target.operator === "string" ? `(${target.operator}…)` : String(target ?? "?");
+  if (ASSIGN_OPS.has(op) || ONE_ARG_OPS.has(op)) {
+    return `${op} ${targetLabel}`;
+  }
+  if (NO_ARG_OPS.has(op)) {
+    return `${op}(${targetLabel})`;
+  }
+  if (op === "splice") {
+    return `splice(${targetLabel})`;
+  }
+  if (op === "call") {
+    return `${targetLabel.replace("window#/", "").replaceAll("/", ".")}(…)`;
+  }
+  if (op === "reduce" || op === "map" || op === "filter" || PURE_METHOD_OPS.has(op)) {
+    return `${op}(${targetLabel})`;
+  }
+  if (op === "?:") {
+    return `${targetLabel} ? … : …`;
+  }
+  if (op === "switch") {
+    return `switch(${targetLabel})`;
+  }
+  if (UNARY_OPS.has(op)) {
+    return `${op}${targetLabel}`;
+  }
+  return `${targetLabel} ${op} …`;
+}
+function renderValueBadge(preview, pathKey) {
+  const text = preview?.values.get(pathKey);
+  if (text === undefined) {
+    return nothing;
+  }
+  return html`<span class="expr-live-badge" title=${text}>${text}</span>`;
+}
+function renderRefPicker(refVal, onRefChange, opts) {
+  const stateRefs = (opts.stateDefs || []).map((k) => `#/state/${k}`);
+  const eventRefs = opts.allowEventRef ? ["event#/detail", "event#/target/value"] : [];
+  const allRefs = [...stateRefs, ...eventRefs];
+  const isCustom = refVal && !allRefs.includes(refVal);
+  if (allRefs.length === 0 && !refVal) {
+    return renderEmptyState({
+      compact: true,
+      detail: "Add one in the State panel and it shows up here.",
+      message: "A binding points at a value this page holds."
+    });
+  }
+  return html`
+    <sp-picker
+      size="s"
+      class="expr-ref"
+      placeholder="Select…"
+      .value=${live(isCustom ? "__custom__" : refVal || "")}
+      @change=${(e) => {
+    const val = e.target.value;
+    if (val === "__custom__") {
+      return;
+    }
+    onRefChange(val);
+  }}
+    >
+      ${stateRefs.map((r) => html`<sp-menu-item value=${r}>${r.replace("#/state/", "")}</sp-menu-item>`)}
+      ${eventRefs.length > 0 ? html`
+              <sp-menu-divider></sp-menu-divider>
+              ${eventRefs.map((r) => html`<sp-menu-item value=${r}>${r}</sp-menu-item>`)}
+            ` : nothing}
+    </sp-picker>
+  `;
+}
+function renderLiteralEditor(operand, onChange) {
+  const type = literalType(operand);
+  return html`
+    <div class="expr-literal">
+      <sp-picker
+        size="s"
+        class="expr-literal-type"
+        .value=${live(type)}
+        @change=${(e) => {
+    const newType = e.target.value;
+    onChange(defaultForLiteralType(newType));
+  }}
+      >
+        <sp-menu-item value="string">str</sp-menu-item>
+        <sp-menu-item value="number">num</sp-menu-item>
+        <sp-menu-item value="boolean">bool</sp-menu-item>
+        <sp-menu-item value="null">null</sp-menu-item>
+      </sp-picker>
+      ${type === "string" ? html`<sp-textfield
+              size="s"
+              class="expr-literal-value"
+              .value=${live(String(operand ?? ""))}
+              @input=${(e) => onChange(e.target.value)}
+            ></sp-textfield>` : type === "number" ? html`<sp-number-field
+                size="s"
+                class="expr-literal-value"
+                .value=${live(Number(operand ?? 0))}
+                @change=${(e) => onChange(Number(e.target.value))}
+              ></sp-number-field>` : type === "boolean" ? html`<sp-checkbox
+                  size="s"
+                  class="expr-literal-bool"
+                  ?checked=${Boolean(operand)}
+                  @change=${(e) => onChange(e.target.checked)}
+                  >true</sp-checkbox
+                >` : html`<span class="expr-literal-null">null</span>`}
+    </div>
+  `;
+}
+function renderOperandEditor(operand, onChange, opts) {
+  if (opts.mustBeRef) {
+    const refVal = operand?.$ref ?? "";
+    return html`
+      <div class="expr-operand">${renderRefPicker(refVal, (r) => onChange({ $ref: r }), opts)}</div>
+    `;
+  }
+  const mode = operandMode(operand);
+  return html`
+    <div class="expr-operand">
+      <sp-picker
+        size="s"
+        class="expr-operand-mode"
+        label="Value source"
+        .value=${live(mode)}
+        @change=${(e) => {
+    const newMode = e.target.value;
+    onChange(defaultForMode(newMode));
+  }}
+      >
+        <sp-menu-item value="literal">${VALUE_SOURCE_LABELS.literal}</sp-menu-item>
+        <sp-menu-item value="ref">${VALUE_SOURCE_LABELS.ref}</sp-menu-item>
+        <sp-menu-item value="expression">${VALUE_SOURCE_LABELS.expression}</sp-menu-item>
+      </sp-picker>
+      ${mode === "literal" ? renderLiteralEditor(operand, onChange) : mode === "ref" ? renderRefPicker(operand?.$ref ?? "", (r) => onChange({ $ref: r }), opts) : renderExpressionEditor(operand, onChange, {
+    ...opts,
+    depth: opts.depth + 1
+  })}
+    </div>
+  `;
+}
+function renderSpliceArgsEditor(args, onChange, opts, naming = {}) {
+  const safeArgs = Array.isArray(args) ? args : [];
+  const labels = naming.labels ?? ["start", "del", "item"];
+  const fallbackLabel = naming.fallbackLabel ?? "item";
+  return html`
+    <div class="array-object-field">
+      ${safeArgs.map((arg, idx) => html`
+          <div class="array-object-row">
+            <span class="array-object-label">${labels[idx] ?? fallbackLabel}</span>
+            ${renderOperandEditor(arg, (newArg) => {
+    const updated = [...safeArgs];
+    updated[idx] = newArg;
+    onChange(updated);
+  }, { ...opts, mustBeRef: false })}
+            <sp-action-button
+              quiet
+              size="xs"
+              @click=${() => {
+    const updated = safeArgs.filter((_, i) => i !== idx);
+    onChange(updated.length > 0 ? updated : [null]);
+  }}
+            >
+              <sp-icon-delete slot="icon"></sp-icon-delete>
+            </sp-action-button>
+          </div>
+        `)}
+      <sp-action-button quiet size="s" @click=${() => onChange([...safeArgs, null])}>
+        + Add arg
+      </sp-action-button>
+    </div>
+  `;
+}
+var _operatorMenuCache = OPERATOR_GROUPS.map((group, i) => html`
+    ${i > 0 ? html`<sp-menu-divider></sp-menu-divider>` : nothing}
+    <sp-menu-group>
+      <span slot="header">${group.label}</span>
+      ${group.ops.map((op) => html`<sp-menu-item value=${op}>${op}</sp-menu-item>`)}
+    </sp-menu-group>
+  `);
+function renderExpressionEditor(node, onChange, opts) {
+  const depth = opts.depth ?? 0;
+  const safeNode = node && typeof node === "object" ? node : { operator: "=", target: null };
+  const op = safeNode.operator || "=";
+  const info = operatorInfo(op);
+  const preview = opts.preview ?? null;
+  const path = opts.path ?? [];
+  const pathKey = path.join("/");
+  const sub = (...segs) => [...path, ...segs].join("/");
+  const withBadge = (widget, key) => html`<div class="expr-widget">${widget}${renderValueBadge(preview, key)}</div>`;
+  const rootBadge = depth === 0 && preview && !preview.mutating ? renderValueBadge(preview, pathKey) : nothing;
+  return html`
+    <div class=${depth > 0 ? "expression-editor expression-editor--nested" : "expression-editor"}>
+      ${depth === 0 ? renderFormulaChips(safeNode, opts.onChipSelect ?? (() => {}), { path, preview }) : nothing}
+      ${depth === 0 && preview?.error ? html`<div class="expr-error">${preview.error}</div>` : nothing}
+      ${renderFieldRow({
+    hasValue: false,
+    label: "Operator",
+    prop: "operator",
+    widget: html`
+          <div class="expr-widget">
+            <sp-picker
+              size="s"
+              class="expr-operator"
+              .value=${live(op)}
+              @change=${(e) => {
+      const newOp = e.target.value;
+      const newInfo = operatorInfo(newOp);
+      const updated = {
+        operator: newOp,
+        target: safeNode.target
+      };
+      if (newInfo.targetMustBeRef && operandMode(safeNode.target) !== "ref") {
+        updated.target = { $ref: "" };
+      }
+      if (newInfo.needsValue) {
+        if (newInfo.valueIsNode) {
+          const val = safeNode.value;
+          updated.value = val?.operator ? safeNode.value : { operator: "!", target: null };
+        } else if (newInfo.spliceArray) {
+          updated.value = Array.isArray(safeNode.value) ? safeNode.value : [null];
+        } else {
+          updated.value = safeNode.value ?? null;
+        }
+      }
+      if (newInfo.needsInitial) {
+        updated.initial = safeNode.initial ?? (newOp === "?:" ? null : 0);
+      }
+      if (newInfo.switchCases) {
+        updated.cases = isJsonObject(safeNode.cases) ? safeNode.cases : {};
+        if ("default" in safeNode) {
+          updated.default = safeNode.default;
+        }
+      }
+      if (newInfo.callArgs) {
+        updated.value = Array.isArray(safeNode.value) ? safeNode.value : [];
+      }
+      onChange(updated);
+    }}
+            >
+              ${_operatorMenuCache}
+            </sp-picker>
+            <sp-action-button
+              quiet
+              size="s"
+              class="expr-browse-catalog"
+              title="Browse catalog"
+              @click=${(e) => openFormulaPalette({
+      anchor: e.currentTarget,
+      entries: formulaCatalog(opts.stateEntries),
+      onPick: (entry) => applyCatalogPick(entry, onChange, {
+        onInsertDef: opts.onInsertDef,
+        stateEntries: opts.stateEntries
+      })
+    })}
+            >
+              <sp-icon-brackets slot="icon"></sp-icon-brackets>
+            </sp-action-button>
+            ${rootBadge}
+          </div>
+        `
+  })}
+      ${renderFieldRow({
+    hasValue: false,
+    label: op === "?:" ? "If" : op === "switch" ? "On" : op === "call" ? "Callee" : "Target",
+    prop: "target",
+    widget: withBadge(renderOperandEditor(safeNode.target, (t) => onChange({ ...safeNode, target: t }), {
+      ...opts,
+      depth,
+      mustBeRef: info.targetMustBeRef,
+      path: [...path, "target"]
+    }), sub("target"))
+  })}
+      ${info.needsValue && !info.valueIsNode && !info.spliceArray ? renderFieldRow({
+    hasValue: false,
+    label: op === "?:" ? "Then" : "Value",
+    prop: "value",
+    widget: withBadge(renderOperandEditor(safeNode.value, (v) => onChange({ ...safeNode, value: v }), {
+      ...opts,
+      depth,
+      mustBeRef: false,
+      path: [...path, "value"]
+    }), sub("value"))
+  }) : nothing}
+      ${info.needsValue && info.valueIsNode ? html`
+              <div class="expr-subsection">
+                ${renderFieldRow({
+    hasValue: false,
+    label: "Per-item",
+    prop: "value",
+    widget: nothing
+  })}
+                ${renderExpressionEditor(safeNode.value?.operator ? safeNode.value : { operator: "!", target: null }, (v) => onChange({ ...safeNode, value: v }), { ...opts, depth: depth + 1, path: [...path, "value"] })}
+              </div>
+            ` : nothing}
+      ${info.spliceArray ? html`
+              <div class="expr-subsection">
+                ${renderFieldRow({
+    hasValue: false,
+    label: "Args",
+    prop: "value",
+    widget: nothing
+  })}
+                ${renderSpliceArgsEditor(safeNode.value, (v) => onChange({ ...safeNode, value: v }), {
+    ...opts,
+    depth
+  })}
+              </div>
+            ` : nothing}
+      ${info.callArgs ? html`
+              <div class="expr-subsection">
+                ${renderFieldRow({
+    hasValue: false,
+    label: "Args",
+    prop: "value",
+    widget: nothing
+  })}
+                ${renderSpliceArgsEditor(safeNode.value, (v) => onChange({ ...safeNode, value: v }), { ...opts, depth }, {
+    fallbackLabel: "arg",
+    labels: calleeParamLabels(safeNode.target, opts.stateEntries)
+  })}
+              </div>
+            ` : nothing}
+      ${info.switchCases ? renderSwitchCasesEditor(safeNode, onChange, { ...opts, depth, path }, withBadge) : nothing}
+      ${info.needsInitial ? renderFieldRow({
+    hasValue: false,
+    label: op === "?:" ? "Else" : "Initial",
+    prop: "initial",
+    widget: withBadge(renderOperandEditor(safeNode.initial, (v) => onChange({ ...safeNode, initial: v }), {
+      ...opts,
+      depth,
+      mustBeRef: false,
+      path: [...path, "initial"]
+    }), sub("initial"))
+  }) : nothing}
+    </div>
+  `;
+}
+function renderSwitchCasesEditor(safeNode, onChange, opts, withBadge) {
+  const cases = isJsonObject(safeNode.cases) ? safeNode.cases : {};
+  const entries = Object.entries(cases);
+  const setCases = (next) => onChange({ ...safeNode, cases: next });
+  return html`
+    <div class="switch-cases">
+      ${entries.map(([key, operand]) => html`
+          <div class="switch-case-row">
+            <sp-textfield
+              size="s"
+              class="switch-case-key"
+              placeholder="value"
+              .value=${live(key)}
+              @change=${(e) => {
+    const newKey = e.target.value;
+    if (newKey === key) {
+      return;
+    }
+    const next = {};
+    for (const [k, v] of entries) {
+      next[k === key ? newKey : k] = v;
+    }
+    setCases(next);
+  }}
+            ></sp-textfield>
+            ${withBadge(renderOperandEditor(operand, (v) => setCases({ ...cases, [key]: v }), {
+    ...opts,
+    mustBeRef: false,
+    path: [...opts.path, "cases", key]
+  }), [...opts.path, "cases", key].join("/"))}
+            <sp-action-button
+              quiet
+              size="xs"
+              @click=${() => {
+    const next = { ...cases };
+    delete next[key];
+    setCases(next);
+  }}
+            >
+              <sp-icon-delete slot="icon"></sp-icon-delete>
+            </sp-action-button>
+          </div>
+        `)}
+      <div class="switch-case-row">
+        <span class="switch-case-key switch-case-default">default</span>
+        ${withBadge(renderOperandEditor(safeNode.default, (v) => onChange({ ...safeNode, default: v }), {
+    ...opts,
+    mustBeRef: false,
+    path: [...opts.path, "default"]
+  }), [...opts.path, "default"].join("/"))}
+      </div>
+      <sp-action-button
+        quiet
+        size="s"
+        @click=${() => {
+    let n = entries.length + 1;
+    let key = `case ${n}`;
+    while (Object.hasOwn(cases, key)) {
+      n += 1;
+      key = `case ${n}`;
+    }
+    setCases({ ...cases, [key]: null });
+  }}
+      >
+        + Add case
+      </sp-action-button>
+    </div>
+  `;
+}
+
+// src/ui/dynamic-slot.ts
+var slotModeMemory = new Map;
+var slotModeRendered = new Map;
+function memoryKey(fieldKey, mode) {
+  return `${activeTab.value?.id ?? "-"}|${fieldKey}|${mode}`;
+}
+function fieldScopeKey(fieldKey) {
+  return `${activeTab.value?.id ?? "-"}|${fieldKey}`;
+}
+function stashSlotValue(fieldKey, mode, value) {
+  slotModeMemory.set(memoryKey(fieldKey, mode), cloneValue(value));
+}
+function hasStashedSlotValue(fieldKey, mode) {
+  return slotModeMemory.has(memoryKey(fieldKey, mode));
+}
+function recallSlotValue(fieldKey, mode) {
+  return cloneValue(slotModeMemory.get(memoryKey(fieldKey, mode)));
+}
+function setSlotMode(fieldKey, mode) {
+  slotModeRendered.set(fieldScopeKey(fieldKey), mode);
+}
+function isTextEditRung(mode) {
+  return mode === "literal" || mode === "template";
+}
+function effectiveSlotMode(fieldKey, value) {
+  const key = fieldScopeKey(fieldKey);
+  const sniffed = slotMode(value);
+  const previous = slotModeRendered.get(key);
+  const mode = previous !== undefined && isTextEditRung(previous) && isTextEditRung(sniffed) ? previous : sniffed;
+  slotModeRendered.set(key, mode);
+  return mode;
+}
+function hasRefOptions(opts) {
+  return opts.stateDefs.length > 0 || Boolean(opts.extraSignals?.length);
+}
+function defaultForSlotMode(mode, opts) {
+  switch (mode) {
+    case "ref": {
+      const [first] = opts.stateDefs;
+      return first ? { $ref: `#/state/${first}` } : { $ref: opts.extraSignals?.[0]?.value ?? "" };
+    }
+    case "template": {
+      const [first] = opts.stateDefs;
+      return first ? `\${state.${first}}` : "${}";
+    }
+    case "expression": {
+      return { $expression: { operator: "??", target: null, value: null } };
+    }
+    case "function": {
+      return { $prototype: "Function", body: "", parameters: [] };
+    }
+    default: {
+      return opts.literalDefault;
+    }
+  }
+}
+function refOptions(opts) {
+  return [
+    ...opts.stateDefs.map((name) => ({ label: name, value: `#/state/${name}` })),
+    ...opts.extraSignals ?? []
+  ];
+}
+function renderCustomRefWidget(refVal, opts) {
+  return html`
+    <jx-value-selector
+      size="s"
+      style="flex:1"
+      placeholder="#/state/…"
+      .value=${refVal}
+      .options=${refOptions(opts)}
+      @change=${(e) => {
+    const v = (e.detail?.value ?? e.target.value ?? "").trim();
+    if (v) {
+      opts.onChange({ $ref: v });
+    } else {
+      opts.onChange();
+    }
+  }}
+    ></jx-value-selector>
+  `;
+}
+function renderRefWidget(refVal, opts) {
+  if (opts.allowCustomRef) {
+    return renderCustomRefWidget(refVal, opts);
+  }
+  return html`
+    <sp-picker
+      size="s"
+      quiet
+      style="flex:1"
+      placeholder="— select signal —"
+      value=${refVal || nothing}
+      @change=${(e) => {
+    const v = e.target.value;
+    if (v) {
+      opts.onChange({ $ref: v });
+    } else {
+      opts.onChange();
+    }
+  }}
+    >
+      ${opts.stateDefs.map((name) => html`<sp-menu-item value=${`#/state/${name}`}>${name}</sp-menu-item>`)}
+      ${opts.extraSignals?.length ? html`
+              <sp-menu-divider></sp-menu-divider>
+              ${opts.extraSignals.map((sig) => html`<sp-menu-item value=${sig.value}>${sig.label}</sp-menu-item>`)}
+            ` : nothing}
+    </sp-picker>
+  `;
+}
+function renderTemplateWidget(value, opts) {
+  return html`
+    <sp-textfield
+      size="s"
+      style="flex:1;font-family:var(--spectrum-code-font-family, monospace)"
+      placeholder="\${state.…}"
+      .value=${live(String(value ?? ""))}
+      @change=${(e) => opts.onChange(e.target.value)}
+    ></sp-textfield>
+  `;
+}
+function switchSlotMode(fieldKey, from, to, current, seed) {
+  stashSlotValue(fieldKey, from, current);
+  setSlotMode(fieldKey, to);
+  return hasStashedSlotValue(fieldKey, to) ? recallSlotValue(fieldKey, to) : seed;
+}
+function chipId(fieldKey) {
+  return `value-source-${fieldKey.replaceAll(/[^\dA-Za-z]+/g, "-")}`;
+}
+function renderModeChip(mode, caps, opts) {
+  const color = mode === "literal" ? "color:var(--spectrum-gray-600, #808080)" : "color:var(--spectrum-accent-content-color-default, #5c9dff)";
+  const offered = caps.filter((m) => m !== "ref" || hasRefOptions(opts));
+  const label = VALUE_SOURCE_LABELS[mode];
+  if (!offered.some((m) => m !== mode)) {
+    const hint2 = `Value source: ${label} (no other source available here)`;
+    return html`
+      <sp-action-button
+        size="xs"
+        quiet
+        disabled
+        class="dynamic-slot-mode"
+        style=${color}
+        title=${hint2}
+        aria-label=${hint2}
+        >${label}</sp-action-button
+      >
+    `;
+  }
+  const id = chipId(opts.fieldKey);
+  const hint = `Value source: ${label} — click to change`;
+  const choose = (next) => {
+    if (next === mode) {
+      return;
+    }
+    if (mode === "ref" && opts.literalDefault !== undefined && !hasStashedSlotValue(opts.fieldKey, "literal")) {
+      stashSlotValue(opts.fieldKey, "literal", opts.literalDefault);
+    }
+    opts.onChange(switchSlotMode(opts.fieldKey, mode, next, cloneValue(opts.value), opts.seedFor?.(next) ?? defaultForSlotMode(next, opts)));
+  };
+  return html`
+    <sp-action-button
+      id=${id}
+      size="xs"
+      quiet
+      class="dynamic-slot-mode"
+      style=${color}
+      title=${hint}
+      aria-label=${hint}
+      >${label}</sp-action-button
+    >
+    <sp-overlay trigger="${id}@click" placement="bottom-start" type="auto">
+      <sp-popover>
+        <sp-menu size="s" label="Value source">
+          ${offered.map((m) => html`
+              <sp-menu-item data-mode=${m} ?selected=${m === mode} @click=${() => choose(m)}
+                >${VALUE_SOURCE_LABELS[m]}
+                <span slot="description">${VALUE_SOURCE_HINTS[m]}</span></sp-menu-item
+              >
+            `)}
+        </sp-menu>
+      </sp-popover>
+    </sp-overlay>
+  `;
+}
+function renderDynamicSlot(opts) {
+  const caps = slotCaps(opts.caps);
+  const mode = effectiveSlotMode(opts.fieldKey, opts.value);
+  const widget = mode === "ref" ? renderRefWidget(isRef(opts.value) ? opts.value.$ref : "", opts) : mode === "template" ? renderTemplateWidget(opts.value, opts) : mode === "expression" ? renderExpressionEditor(opts.value.$expression, (node) => opts.onChange({ $expression: node }), {
+    allowEventRef: opts.allowEventRef ?? false,
+    preview: opts.preview ?? null,
+    stateDefs: opts.stateDefs,
+    stateEntries: opts.stateEntries ?? null
+  }) : opts.staticWidget;
+  return {
+    modeButton: renderModeChip(mode, caps, opts),
+    widget: html`
+      <div class="dynamic-slot" style="display:flex;flex:1;min-width:0">
+        <div style="flex:1;min-width:0">${widget}</div>
+      </div>
+    `
+  };
+}
+
+// src/ui/schema-form.ts
+var controlRegistry = new Map;
+function registerFormControl(name, control) {
+  controlRegistry.set(name, control);
+}
+function getFormControl(name) {
+  return controlRegistry.get(name);
+}
+var CONTENT_REF = /^#\/content\/([^/]+)$/;
+function referenceTarget(schema) {
+  const match = typeof schema?.$ref === "string" ? CONTENT_REF.exec(schema.$ref) : null;
+  return match ? match[1] : null;
+}
+var NULL_FORM_CONTEXT = {
+  resolvePointer: () => {}
+};
+function resolveFormEnum(enumDef, ctx, scope) {
+  if (Array.isArray(enumDef)) {
+    return enumDef;
+  }
+  let pointer;
+  if (enumDef && typeof enumDef === "object") {
+    const ref2 = enumDef.$ref;
+    if (typeof ref2 === "string") {
+      pointer = ref2;
+    }
+  } else if (typeof enumDef === "string") {
+    pointer = enumDef;
+  }
+  if (pointer === undefined || !ctx) {
+    return;
+  }
+  const resolved = ctx.resolvePointer(pointer, scope);
+  if (Array.isArray(resolved)) {
+    return resolved.map(String);
+  }
+  if (resolved && typeof resolved === "object") {
+    return Object.keys(resolved);
+  }
+  return;
+}
+function parseNumericField(raw, integer) {
+  if (raw.trim() === "") {
+    return Number.NaN;
+  }
+  return integer ? Math.trunc(Number(raw)) : Number(raw);
+}
+function refTextField(key, refVal, onChange) {
+  return html`<sp-textfield
+    size="s"
+    label=${key}
+    placeholder=${key}
+    .value=${live(refVal)}
+    @change=${(e) => {
+    const v = e.target.value.trim();
+    onChange(v ? { $ref: v } : undefined);
+  }}
+  ></sp-textfield>`;
+}
+function renderInlineField(key, schema, value, onChange, ctx, scope, rerender) {
+  if (isRef(value)) {
+    return refTextField(key, value.$ref, onChange);
+  }
+  const referenceControl = referenceTarget(schema) === null ? undefined : controlRegistry.get("reference");
+  if (referenceControl) {
+    return referenceControl({
+      ctx: ctx ?? NULL_FORM_CONTEXT,
+      key,
+      onChange,
+      rerender,
+      schema,
+      value
+    });
+  }
+  const enumValues = resolveFormEnum(schema.enum, ctx, scope);
+  if (enumValues) {
+    return html`<sp-picker
+      size="s"
+      label=${key}
+      value=${value !== undefined ? String(value) : "__none__"}
+      @change=${(e) => onChange(e.target.value === "__none__" ? undefined : e.target.value)}
+    >
+      <sp-menu-item value="__none__">—</sp-menu-item>
+      ${enumValues.map((v) => html`<sp-menu-item value=${v}>${v}</sp-menu-item>`)}
+    </sp-picker>`;
+  }
+  if (schema.type === "boolean") {
+    return html`<sp-switch
+      size="s"
+      ?checked=${Boolean(value)}
+      @change=${(e) => onChange(e.target.checked)}
+      >${key}</sp-switch
+    >`;
+  }
+  if (schema.type === "integer" || schema.type === "number") {
+    return html`<sp-number-field
+      size="s"
+      label=${key}
+      .value=${value !== undefined ? value : nothing}
+      step=${schema.type === "integer" ? "1" : nothing}
+      @change=${(e) => {
+      const parsed = parseNumericField(e.target.value, schema.type === "integer");
+      onChange(Number.isNaN(parsed) ? undefined : parsed);
+    }}
+    ></sp-number-field>`;
+  }
+  return html`<sp-textfield
+    size="s"
+    label=${key}
+    placeholder=${key}
+    .value=${value ?? ""}
+    @input=${(e) => onChange(e.target.value || undefined)}
+  ></sp-textfield>`;
+}
+function renderJsonTextField(currentValue, ps, commit) {
+  let debounce;
+  return html`<sp-textfield
+    multiline
+    size="s"
+    style="min-height:40px"
+    .value=${currentValue !== undefined ? JSON.stringify(currentValue, null, 2) : ""}
+    placeholder=${ps.default !== undefined ? JSON.stringify(ps.default) : nothing}
+    @input=${(e) => {
+    clearTimeout(debounce);
+    debounce = setTimeout(() => {
+      try {
+        commit(JSON.parse(e.target.value));
+      } catch {}
+    }, 500);
+  }}
+  ></sp-textfield>`;
+}
+function renderPropertyControl(prop, ps, value, required, opts, ctx) {
+  const currentValue = value[prop];
+  const commit = (next) => opts.onChange({ [prop]: next });
+  const controlArgs = {
+    ctx,
+    key: prop,
+    onChange: commit,
+    rerender: opts.rerender,
+    schema: ps,
+    value: currentValue
+  };
+  const overrideName = opts.ui?.[prop]?.control;
+  if (overrideName) {
+    const custom = controlRegistry.get(overrideName);
+    if (custom) {
+      return custom(controlArgs);
+    }
+  }
+  if (isRef(currentValue) && isBindableField(ps)) {
+    return refTextField(prop, currentValue.$ref, commit);
+  }
+  if (referenceTarget(ps) !== null) {
+    const referenceControl = controlRegistry.get("reference");
+    if (referenceControl) {
+      return referenceControl(controlArgs);
+    }
+  }
+  const enumValues = resolveFormEnum(opts.ui?.[prop]?.enum ?? ps.enum, ctx, value);
+  if (enumValues) {
+    return html`
+      <sp-picker
+        size="s"
+        value=${currentValue !== undefined ? String(currentValue) : ps.default !== undefined ? String(ps.default) : "__none__"}
+        @change=${(e) => commit(e.target.value === "__none__" ? undefined : e.target.value)}
+      >
+        ${!required.has(prop) ? html`<sp-menu-item value="__none__">—</sp-menu-item>` : nothing}
+        ${enumValues.map((val) => html`<sp-menu-item value=${val}>${val}</sp-menu-item>`)}
+      </sp-picker>
+    `;
+  }
+  if (ps.type === "boolean") {
+    return html`<sp-checkbox
+      ?checked=${currentValue ?? ps.default ?? false}
+      @change=${(e) => commit(e.target.checked)}
+    ></sp-checkbox>`;
+  }
+  if (ps.type === "integer" || ps.type === "number") {
+    let debounce2;
+    return html`<sp-number-field
+      size="s"
+      min=${ifDefined(ps.minimum)}
+      max=${ifDefined(ps.maximum)}
+      step=${ps.type === "integer" ? "1" : nothing}
+      .value=${currentValue !== undefined ? currentValue : nothing}
+      placeholder=${ps.default != null ? String(ps.default) : nothing}
+      @change=${(e) => {
+      clearTimeout(debounce2);
+      debounce2 = setTimeout(() => {
+        const parsed = parseNumericField(e.target.value, ps.type === "integer");
+        commit(Number.isNaN(parsed) ? undefined : parsed);
+      }, 400);
+    }}
+    ></sp-number-field>`;
+  }
+  if (ps.format === "json-schema") {
+    const hasValue = currentValue && typeof currentValue === "object" && Object.keys(currentValue).length > 0;
+    const cv = currentValue;
+    const isSchemaRef = hasValue && cv.$ref;
+    let debounce2;
+    return html`
+      <div class="schema-param-editor">
+        ${hasValue && !isSchemaRef && cv.properties ? html`
+                <div style="display:flex;flex-wrap:wrap;gap:3px;margin-bottom:4px">
+                  ${Object.entries(cv.properties).map(([k, v]) => html`
+                      <span
+                        style="background:var(--bg);padding:1px 6px;border-radius:var(--radius);font-size:10px;color:var(--fg-dim)"
+                        >${k}: ${v.type ?? "any"}</span
+                      >
+                    `)}
+                </div>
+              ` : nothing}
+        <sp-textfield
+          multiline
+          size="s"
+          style=${styleMap({
+      fontFamily: "monospace",
+      fontSize: "11px",
+      minHeight: hasValue ? "80px" : "40px"
+    })}
+          .value=${currentValue !== undefined ? JSON.stringify(currentValue, null, 2) : ""}
+          placeholder=${ps.description ?? "JSON Schema defining the data shape…"}
+          @input=${(e) => {
+      clearTimeout(debounce2);
+      debounce2 = setTimeout(() => {
+        try {
+          commit(JSON.parse(e.target.value));
+        } catch {}
+      }, 500);
+    }}
+        ></sp-textfield>
+      </div>
+    `;
+  }
+  if (ps.type === "array" && ps.items?.type === "object" && ps.items?.properties) {
+    const rows = Array.isArray(currentValue) ? currentValue : [];
+    const itemProps = ps.items.properties;
+    return html`
+      <div class="array-object-field">
+        ${rows.map((row, idx) => html`
+            <div
+              class="array-object-row"
+              style="display:flex;gap:4px;align-items:center;margin-bottom:4px"
+            >
+              ${Object.entries(itemProps).map(([propKey, propSchema]) => renderInlineField(propKey, propSchema, row[propKey], (val) => {
+      const updated = [...rows];
+      updated[idx] = { ...updated[idx], [propKey]: val };
+      commit(updated);
+    }, ctx, value, opts.rerender))}
+              <sp-action-button
+                quiet
+                size="s"
+                @click=${() => {
+      const updated = rows.filter((_, i) => i !== idx);
+      commit(updated.length > 0 ? updated : undefined);
+      opts.rerender?.();
+    }}
+              >
+                <sp-icon-delete slot="icon"></sp-icon-delete>
+              </sp-action-button>
+            </div>
+          `)}
+        <sp-action-button
+          quiet
+          size="s"
+          @click=${(e) => {
+      e.stopPropagation();
+      const newRow = {};
+      for (const [k, v] of Object.entries(itemProps)) {
+        if (v.default !== undefined) {
+          newRow[k] = v.default;
+        }
+      }
+      commit([...rows, newRow]);
+      opts.rerender?.();
+    }}
+          >+ Add</sp-action-button
+        >
+      </div>
+    `;
+  }
+  if (ps.type === "array" || ps.type === "object") {
+    return renderJsonTextField(currentValue, ps, commit);
+  }
+  let debounce;
+  const ph = ps.default !== undefined ? String(ps.default) : ps.examples?.[0] ?? "";
+  return html`<sp-textfield
+    size="s"
+    style="flex:1"
+    .value=${currentValue ?? ""}
+    placeholder=${ph || nothing}
+    title=${ps.description || nothing}
+    @input=${(e) => {
+    clearTimeout(debounce);
+    debounce = setTimeout(() => commit(e.target.value || undefined), 400);
+  }}
+  ></sp-textfield>`;
+}
+function isBindableField(ps) {
+  return ps.format !== "json-schema" && ps.type !== "object" && ps.type !== "array";
+}
+function refSourcesFor(ctx) {
+  return [
+    ...(ctx.signals ?? []).map((name) => ({ label: name, value: `#/state/${name}` })),
+    ...(ctx.params ?? []).map((name) => ({ label: `$params/${name}`, value: `#/$params/${name}` }))
+  ];
+}
+function validateFieldValue(schema, value, isRequired) {
+  if (isRef(value)) {
+    return "";
+  }
+  const empty = value === undefined || value === null || value === "";
+  if (empty) {
+    return isRequired ? "Required." : "";
+  }
+  if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
+    return `Choose one of: ${schema.enum.map(String).join(", ")}.`;
+  }
+  if (schema.type === "number" || schema.type === "integer") {
+    const n = typeof value === "number" ? value : Number(value);
+    if (!Number.isFinite(n)) {
+      return "Enter a number.";
+    }
+    if (schema.type === "integer" && !Number.isInteger(n)) {
+      return "Enter a whole number.";
+    }
+    if (schema.minimum !== undefined && n < schema.minimum) {
+      return `Must be ${schema.minimum} or more.`;
+    }
+    if (schema.maximum !== undefined && n > schema.maximum) {
+      return `Must be ${schema.maximum} or less.`;
+    }
+    return "";
+  }
+  if (schema.type === "boolean" && typeof value !== "boolean") {
+    return "Must be true or false.";
+  }
+  if (schema.type === "array" && !Array.isArray(value)) {
+    return "Must be a list.";
+  }
+  if (schema.type === "object" && (typeof value !== "object" || Array.isArray(value))) {
+    return "Must be an object.";
+  }
+  return "";
+}
+function renderForm(schema, value, opts) {
+  const required = new Set(schema.required);
+  const ctx = opts.context ?? NULL_FORM_CONTEXT;
+  const refSources = refSourcesFor(ctx);
+  const propertyFields = Object.entries(schema.properties ?? {}).map(([prop, ps]) => {
+    const labelText = prop + (required.has(prop) ? " *" : "");
+    const error = opts.errors?.[prop] || validateFieldValue(ps, value[prop], Boolean(opts.showRequired) && required.has(prop));
+    const count = opts.errorCounts?.[prop];
+    const staticWidget = renderPropertyControl(prop, ps, value, required, opts, ctx);
+    const laddered = refSources.length > 0 && isBindableField(ps) && !opts.ui?.[prop]?.control ? renderDynamicSlot({
+      allowCustomRef: true,
+      caps: { schema: configFieldSchema(ps) },
+      extraSignals: refSources,
+      fieldKey: `${ctx.fieldKeyPrefix ?? ""}.${prop}`,
+      onChange: (v) => opts.onChange({ [prop]: v }),
+      staticWidget,
+      stateDefs: [],
+      value: value[prop]
+    }) : null;
+    return renderFieldRow({
+      hasValue: false,
+      label: labelText,
+      prop: ps.name || prop,
+      widget: laddered ? laddered.widget : staticWidget,
+      ...laddered ? { labelExtra: laddered.modeButton } : {},
+      ...error ? { error } : {},
+      ...count === undefined ? {} : { errorCount: count }
+    });
+  });
+  return html`${propertyFields}`;
+}
+
+// src/services/context-resolver.ts
+var PARAM_SEGMENT = /^\{@(\w+)\}$/;
+function resolveContextPointer(pointer, opts) {
+  if (!pointer.startsWith("#/$context/")) {
+    return;
+  }
+  const segments = [];
+  for (const raw of pointer.slice("#/$context/".length).split("/")) {
+    const match = raw.match(PARAM_SEGMENT);
+    if (match) {
+      const value = opts.scope?.[match[1]];
+      if (typeof value !== "string" && typeof value !== "number") {
+        return;
+      }
+      const substituted = String(value);
+      if (!substituted) {
+        return;
+      }
+      segments.push(substituted);
+    } else {
+      segments.push(raw);
+    }
+  }
+  if (segments[0] === "$formats") {
+    if (segments.length !== 1) {
+      return;
+    }
+    return (opts.formats ?? []).map((format) => format.name);
+  }
+  let node = opts.projectConfig;
+  for (const segment of segments) {
+    if (node === null || typeof node !== "object") {
+      return;
+    }
+    node = node[segment];
+  }
+  return node;
+}
+
+export { renderProvenanceChip, countProvenance, renderProvenanceDots, renderFieldRow, renderKvRow, renderStaticKvRow, chipSummary, renderFormulaChips, applyCatalogPick, globalEntries, namedFormulaEntries, formulaCatalog, openFormulaPalette, REDIRECT_STATUSES, VALUE_SOURCE_LABELS, slotMode, capsForPosition, isActionExpression, expressionHint, renderOperandEditor, renderExpressionEditor, switchSlotMode, renderDynamicSlot, registerFormControl, getFormControl, referenceTarget, NULL_FORM_CONTEXT, renderForm, resolveContextPointer };
+
+//# debugId=D548DF8319DDE4D664756E2164756E21
+//# sourceMappingURL=studio-c6s5getc.js.map