@wildwinter/expr-editor 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1621 @@
+'use strict';
+
+var expr = require('@wildwinter/expr');
+
+// src/ast.ts
+var boolLit = (value) => ({ kind: "bool", value });
+var numLit = (value) => ({ kind: "number", value });
+var strLit = (value) => ({ kind: "string", value });
+var scopedVar = (scope, name) => ({ kind: "scopedvar", scope, name: name.toLowerCase() });
+var binary = (op, left, right) => ({ kind: "binary", op, left, right });
+var notNode = (operand) => ({ kind: "unary", op: "not", operand });
+var callNode = (name, args) => ({ kind: "call", name, args });
+var flagDelta = (sign, name) => ({ kind: "flagdelta", sign, name });
+var placeholderForOp = (op) => boolLit(op === "and");
+var isPlaceholderForOp = (node, op) => node.kind === "bool" && node.value === (op === "and");
+var COMPARISON = /* @__PURE__ */ new Set(["==", "!=", ">", ">=", "<", "<="]);
+var isComparisonOp = (op) => COMPARISON.has(op);
+function getNodeAt(ast, path) {
+  let node = ast;
+  for (let i = 0; i < path.length; i++) {
+    if (!node) return null;
+    const seg = path[i];
+    if (node.kind === "binary" && seg === "left") node = node.left;
+    else if (node.kind === "binary" && seg === "right") node = node.right;
+    else if (node.kind === "unary" && seg === "operand") node = node.operand;
+    else if (node.kind === "call" && seg === "args") {
+      node = node.args[path[++i]] ?? null;
+    } else return null;
+  }
+  return node;
+}
+function setNodeAt(ast, path, next) {
+  if (path.length === 0) return next;
+  const [seg, ...rest] = path;
+  if (ast.kind === "binary" && seg === "left") return { ...ast, left: setNodeAt(ast.left, rest, next) };
+  if (ast.kind === "binary" && seg === "right") return { ...ast, right: setNodeAt(ast.right, rest, next) };
+  if (ast.kind === "unary" && seg === "operand") return { ...ast, operand: setNodeAt(ast.operand, rest, next) };
+  if (ast.kind === "call" && seg === "args") {
+    const idx = rest[0];
+    const args = ast.args.map((a, i) => i === idx ? setNodeAt(a, rest.slice(1), next) : a);
+    return { ...ast, args };
+  }
+  throw new Error(`cannot descend into ${ast.kind} via '${String(seg)}'`);
+}
+function deleteAt(ast, path) {
+  if (path.length === 0) return null;
+  const last = path[path.length - 1];
+  if (typeof last === "number" && path[path.length - 2] === "args") {
+    const callPath = path.slice(0, -2);
+    const call = getNodeAt(ast, callPath);
+    if (call?.kind !== "call") return ast;
+    return setNodeAt(ast, callPath, { ...call, args: call.args.filter((_, i) => i !== last) });
+  }
+  const parentPath = path.slice(0, -1);
+  const parent = getNodeAt(ast, parentPath);
+  if (parent?.kind === "binary") {
+    const survivor = last === "left" ? parent.right : parent.left;
+    return setNodeAt(ast, parentPath, survivor);
+  }
+  if (parent?.kind === "unary") {
+    return setNodeAt(ast, parentPath, parent.operand);
+  }
+  return ast;
+}
+function insertSiblingClauseAt(ast, path, op, side, clause) {
+  const target = getNodeAt(ast, path);
+  if (!target) return ast;
+  const wrapped = side === "right" ? binary(op, target, clause) : binary(op, clause, target);
+  return setNodeAt(ast, path, wrapped);
+}
+function isWrappedInNot(ast, path) {
+  if (path[path.length - 1] !== "operand") return false;
+  const parent = getNodeAt(ast, path.slice(0, -1));
+  return parent?.kind === "unary" && parent.op === "not";
+}
+function wrapInNotAt(ast, path) {
+  const target = getNodeAt(ast, path);
+  return target ? setNodeAt(ast, path, notNode(target)) : ast;
+}
+function toggleNotAt(ast, path) {
+  if (isWrappedInNot(ast, path)) {
+    const inner = getNodeAt(ast, path);
+    return inner ? setNodeAt(ast, path.slice(0, -1), inner) : ast;
+  }
+  return wrapInNotAt(ast, path);
+}
+function findEnumPeer(ast, path) {
+  const last = path[path.length - 1];
+  if (last !== "left" && last !== "right") return null;
+  const parent = getNodeAt(ast, path.slice(0, -1));
+  if (parent?.kind !== "binary" || parent.op !== "==" && parent.op !== "!=") return null;
+  const other = last === "left" ? parent.right : parent.left;
+  return other.kind === "scopedvar" ? { scope: other.scope, name: other.name } : null;
+}
+function firstEmptyLeafPath(node, base = []) {
+  switch (node.kind) {
+    case "string":
+      return node.value === "" ? base : null;
+    case "flagdelta":
+      return node.name === "" ? base : null;
+    case "unary":
+      return firstEmptyLeafPath(node.operand, [...base, "operand"]);
+    case "binary":
+      return firstEmptyLeafPath(node.left, [...base, "left"]) ?? firstEmptyLeafPath(node.right, [...base, "right"]);
+    case "call": {
+      for (let i = 0; i < node.args.length; i++) {
+        const p = firstEmptyLeafPath(node.args[i], [...base, "args", i]);
+        if (p) return p;
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+
+// src/tree.ts
+var isLogical = (n) => n != null && n.kind === "binary" && (n.op === "and" || n.op === "or");
+function collectChain(node, path, op) {
+  if (node.kind === "binary" && node.op === op) {
+    return [
+      ...collectChain(node.left, [...path, "left"], op),
+      ...collectChain(node.right, [...path, "right"], op)
+    ];
+  }
+  return [astToTree(node, path)];
+}
+function containerRow(chain, chainPath, negated, path) {
+  return {
+    kind: "container",
+    op: chain.op,
+    negated,
+    path,
+    chainPath,
+    children: [
+      ...collectChain(chain.left, [...chainPath, "left"], chain.op),
+      ...collectChain(chain.right, [...chainPath, "right"], chain.op)
+    ]
+  };
+}
+function astToTree(node, path = []) {
+  if (node.kind === "unary" && node.op === "not" && isLogical(node.operand)) {
+    return containerRow(node.operand, [...path, "operand"], true, path);
+  }
+  if (isLogical(node)) return containerRow(node, path, false, path);
+  if (node.kind === "unary" && node.op === "not" && node.operand.kind === "binary" && isComparisonOp(node.operand.op)) {
+    const inner = node.operand;
+    return { kind: "comparison", left: inner.left, op: inner.op, right: inner.right, negated: true, path, contentPath: [...path, "operand"] };
+  }
+  if (node.kind === "binary" && isComparisonOp(node.op)) {
+    return { kind: "comparison", left: node.left, op: node.op, right: node.right, negated: false, path, contentPath: path };
+  }
+  if (node.kind === "unary" && node.op === "not") {
+    return { kind: "wrapped", node: node.operand, negated: true, path, contentPath: [...path, "operand"] };
+  }
+  return { kind: "wrapped", node, negated: false, path, contentPath: path };
+}
+function addChildToContainer(ast, chainPath, clause) {
+  const node = getNodeAt(ast, chainPath);
+  if (!node) return ast;
+  const op = isLogical(node) ? node.op : "and";
+  return setNodeAt(ast, chainPath, binary(op, node, clause));
+}
+function flipContainerOp(ast, chainPath, newOp) {
+  const node = getNodeAt(ast, chainPath);
+  if (!isLogical(node) || node.op === newOp) return ast;
+  const oldOp = node.op;
+  const flip = (n) => {
+    if (n.kind === "binary" && n.op === oldOp) return binary(newOp, flip(n.left), flip(n.right));
+    if (isPlaceholderForOp(n, oldOp)) return placeholderForOp(newOp);
+    return n;
+  };
+  return setNodeAt(ast, chainPath, flip(node));
+}
+function toggleContainerNot(ast, path) {
+  const node = getNodeAt(ast, path);
+  if (!node) return ast;
+  if (node.kind === "unary" && node.op === "not") return setNodeAt(ast, path, node.operand);
+  return setNodeAt(ast, path, { kind: "unary", op: "not", operand: node });
+}
+function buildSubGroupClause(parentOp, firstClause) {
+  const childOp = parentOp === "and" ? "or" : "and";
+  return binary(childOp, firstClause, placeholderForOp(childOp));
+}
+var chainNodes = (node, op) => node.kind === "binary" && node.op === op ? [...chainNodes(node.left, op), ...chainNodes(node.right, op)] : [node];
+var buildChain = (op, nodes) => nodes.reduce((acc, n) => acc ? binary(op, acc, n) : n);
+function redirectDeleteForPlaceholderSibling(ast, path) {
+  if (path.length === 0) return path;
+  const last = path[path.length - 1];
+  if (last !== "left" && last !== "right") return path;
+  const parentPath = path.slice(0, -1);
+  const parent = getNodeAt(ast, parentPath);
+  if (!isLogical(parent)) return path;
+  const sibling = last === "left" ? parent.right : parent.left;
+  return isPlaceholderForOp(sibling, parent.op) ? parentPath : path;
+}
+function moveChildInContainer(ast, chainPath, from, to) {
+  const node = getNodeAt(ast, chainPath);
+  if (!isLogical(node)) return ast;
+  const arr = chainNodes(node, node.op);
+  if (from < 0 || to < 0 || from >= arr.length || to >= arr.length || from === to) return ast;
+  const [moved] = arr.splice(from, 1);
+  arr.splice(to, 0, moved);
+  return setNodeAt(ast, chainPath, buildChain(node.op, arr));
+}
+
+// src/ops.ts
+var BINARY_LABEL = {
+  and: "AND",
+  or: "OR",
+  "==": "is",
+  "!=": "\u2260",
+  ">": ">",
+  ">=": "\u2265",
+  "<": "<",
+  "<=": "\u2264",
+  "+": "+",
+  "-": "\u2212",
+  "*": "\xD7",
+  "/": "\xF7"
+};
+var UNARY_LABEL = { not: "NOT", neg: "\u2212" };
+var COMPARISON_OPS = ["==", "!=", ">", ">=", "<", "<="];
+var ARITHMETIC_OPS = ["+", "-", "*", "/"];
+function opSwapGroup(op) {
+  if (COMPARISON_OPS.includes(op)) return COMPARISON_OPS;
+  if (ARITHMETIC_OPS.includes(op)) return ARITHMETIC_OPS;
+  return null;
+}
+var PREC = {
+  or: 1,
+  and: 2,
+  "==": 4,
+  "!=": 4,
+  ">": 4,
+  ">=": 4,
+  "<": 4,
+  "<=": 4,
+  "+": 5,
+  "-": 5,
+  "*": 6,
+  "/": 6
+};
+function needsParens(childOp, parentOp, side) {
+  if (PREC[childOp] < PREC[parentOp]) return true;
+  return PREC[childOp] === PREC[parentOp] && side === "right" && (parentOp === "-" || parentOp === "/");
+}
+function formatNumber(n) {
+  if (Number.isInteger(n)) return String(n);
+  return String(parseFloat(n.toFixed(12)));
+}
+
+// src/schema.ts
+var refOf = (e, defaultScope) => e.scope === defaultScope ? `@${e.name}` : `@${e.scope}.${e.name}`;
+var displayName = (e, defaultScope) => e.scope === defaultScope ? e.name : `${e.scope}.${e.name}`;
+function filterCatalogue(entries, filter = {}) {
+  return entries.filter(
+    (e) => (!filter.acceptTypes || filter.acceptTypes.includes(e.type)) && (!filter.acceptScopes || filter.acceptScopes.includes(e.scope))
+  );
+}
+function searchCatalogue(entries, query, defaultScope) {
+  const q = query.trim().toLowerCase();
+  if (!q) return [...entries];
+  return entries.filter((e) => displayName(e, defaultScope).toLowerCase().includes(q) || (e.purpose ?? "").toLowerCase().includes(q));
+}
+function groupByScope(entries, scopeOrder = []) {
+  const byScope = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const list = byScope.get(e.scope) ?? [];
+    list.push(e);
+    byScope.set(e.scope, list);
+  }
+  const rank = (s) => {
+    const i = scopeOrder.indexOf(s);
+    return i === -1 ? scopeOrder.length : i;
+  };
+  return [...byScope.keys()].sort((a, b) => rank(a) - rank(b) || a.localeCompare(b)).map((scope) => ({ scope, entries: byScope.get(scope).slice().sort((a, b) => a.name.localeCompare(b.name)) }));
+}
+function lookup(entries, scope, name) {
+  const n = name.toLowerCase();
+  return entries.find((e) => e.scope === scope && e.name.toLowerCase() === n) ?? null;
+}
+var pathKey = (p) => p.join("/");
+function validateSource(src, schema, dialect) {
+  const r = expr.parseAndValidate(src, schema, dialect);
+  const byPath = /* @__PURE__ */ new Map();
+  for (const issue of r.issues) {
+    const k = pathKey(issue.path);
+    const list = byPath.get(k) ?? [];
+    list.push(issue);
+    byPath.set(k, list);
+  }
+  const unparseable = r.issues.some((i) => i.kind === "unparseable");
+  return { ...r, byPath, unparseable };
+}
+var issuesAt = (byPath, path) => byPath.get(pathKey(path)) ?? [];
+
+// src/dom.ts
+function el(tag, cls, children) {
+  const node = document.createElement(tag);
+  if (cls) node.className = cls;
+  for (const c of children ?? []) {
+    if (c == null) continue;
+    node.append(typeof c === "string" ? document.createTextNode(c) : c);
+  }
+  return node;
+}
+function button(cls, label, onClick, title) {
+  const b = el("button", cls, [label]);
+  b.type = "button";
+  if (title) b.title = title;
+  b.addEventListener("click", onClick);
+  return b;
+}
+function openPopover(anchor, render, onClose) {
+  const pop = el("div", "exed-pop");
+  let closed = false;
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    document.removeEventListener("pointerdown", onDown, true);
+    document.removeEventListener("keydown", onKey, true);
+    pop.remove();
+    onClose?.();
+  };
+  const onDown = (e) => {
+    const t = e.target;
+    if (!pop.contains(t) && !anchor.contains(t)) close();
+  };
+  const onKey = (e) => {
+    if (e.key === "Escape") {
+      e.stopPropagation();
+      close();
+    }
+  };
+  pop.append(render(close));
+  document.body.append(pop);
+  const a = anchor.getBoundingClientRect();
+  const ph = pop.getBoundingClientRect();
+  let top = a.bottom + 4;
+  if (top + ph.height > window.innerHeight - 8 && a.top - ph.height - 4 > 8) top = a.top - ph.height - 4;
+  let left = a.left;
+  if (left + ph.width > window.innerWidth - 8) left = Math.max(8, window.innerWidth - 8 - ph.width);
+  pop.style.top = `${Math.round(top + window.scrollY)}px`;
+  pop.style.left = `${Math.round(left + window.scrollX)}px`;
+  setTimeout(() => {
+    document.addEventListener("pointerdown", onDown, true);
+    document.addEventListener("keydown", onKey, true);
+  }, 0);
+  return { el: pop, close };
+}
+function textField(opts) {
+  const wrap = el("div", "exed-field");
+  if (opts.caption) wrap.append(el("div", "exed-field-cap", [opts.caption]));
+  const input = el("input", "exed-input");
+  input.type = "text";
+  input.value = opts.initial ?? "";
+  if (opts.placeholder) input.placeholder = opts.placeholder;
+  const submit = button("exed-btn primary", opts.submitLabel ?? "Apply", () => commit());
+  const ok = () => opts.validate ? opts.validate(input.value) : true;
+  const sync = () => {
+    submit.disabled = !ok();
+  };
+  const commit = () => {
+    if (ok()) opts.onCommit(input.value);
+  };
+  input.addEventListener("input", sync);
+  input.addEventListener("keydown", (e) => {
+    if (e.key === "Enter") {
+      e.preventDefault();
+      e.stopPropagation();
+      commit();
+    }
+  });
+  sync();
+  wrap.append(el("div", "exed-field-row", [input, submit]));
+  setTimeout(() => input.focus(), 0);
+  return wrap;
+}
+
+// src/flat.ts
+var FLAG_FNS = /* @__PURE__ */ new Set(["check_flags", "set_flags"]);
+var TAG_ARG0_FNS = /* @__PURE__ */ new Set(["seen", "patter_seen", "visits", "patter_visits"]);
+function pill(kind, label, onClick, opts = {}) {
+  const b = button(`exed-pill exed-pill-${kind}${opts.issue ? " exed-pill-err" : ""}`, label, () => onClick(b), opts.issue ?? opts.title);
+  if (opts.path) b.dataset["exedPath"] = opts.path.join("/");
+  return b;
+}
+var issueText = (ctx, path) => {
+  const list = issuesAt(ctx.byPath, path);
+  return list.length ? list.map((i) => i.message).join("; ") : void 0;
+};
+var replace = (ctx, path, next) => ctx.apply(setNodeAt(ctx.getAst(), path, next));
+function renderNode(node, path, ctx, parentOp, side) {
+  const issue = issueText(ctx, path);
+  switch (node.kind) {
+    case "bool":
+      return pill("bool", node.value ? "true" : "false", (b) => boolEditor(ctx, path, node.value, b), { issue });
+    case "number":
+      return pill("number", formatNumber(node.value), (b) => numberEditor(ctx, path, node.value, b), { issue });
+    case "string": {
+      const isArg = path[path.length - 2] === "args";
+      const call = isArg ? getNodeAt(ctx.getAst(), path.slice(0, -2)) : null;
+      const isNodeRef = !!ctx.pickNode && call?.kind === "call" && TAG_ARG0_FNS.has(call.name) && path[path.length - 1] === 0;
+      if (isNodeRef) {
+        const openPick = (b) => ctx.pickNode(b, node.value, (id) => replace(ctx, path, strLit(id)));
+        return node.value === "" ? pill("placeholder", "pick a node\u2026", openPick, { issue, path }) : pill("node", ctx.nodeLabel?.(node.value) ?? node.value, openPick, { issue, title: node.value });
+      }
+      if (node.value === "")
+        return pill("placeholder", isArg ? "set a tag\u2026" : "set a value\u2026", (b) => stringEditor(ctx, path, node, b), { issue, path });
+      return pill(isArg ? "tag" : "string", node.value, (b) => stringEditor(ctx, path, node, b), { issue });
+    }
+    case "scopedvar": {
+      const entry = lookup(ctx.catalogue, node.scope, node.name);
+      const label = displayName({ scope: node.scope, name: node.name }, ctx.defaultScope);
+      return pill("var", label, (b) => variableEditor(ctx, path, node, b), { issue: issue ?? (entry ? void 0 : `Unknown property ${label}`) });
+    }
+    case "flagdelta":
+      return pill(node.sign === "+" ? "flagpos" : "flagneg", `${node.sign}${node.name || "flag"}`, (b) => flagEditor(ctx, path, node, b), { issue, path });
+    case "call": {
+      const row = el("span", "exed-call");
+      row.append(pill("func", node.name, (b) => callEditor(ctx, path, node, b), { issue }));
+      row.append(el("span", "exed-paren", ["("]));
+      node.args.forEach((arg, i) => {
+        if (i > 0) row.append(el("span", "exed-comma", [", "]));
+        row.append(renderNode(arg, [...path, "args", i], ctx));
+      });
+      row.append(el("span", "exed-paren", [")"]));
+      return row;
+    }
+    case "unary": {
+      const row = el("span", "exed-unary");
+      row.append(pill("op", UNARY_LABEL[node.op], () => ctx.apply(deleteOrUnwrapNot(ctx, path, node)), { title: "remove" }));
+      row.append(renderNode(node.operand, [...path, "operand"], ctx));
+      return row;
+    }
+    case "binary": {
+      const row = el("span", "exed-binary");
+      const wrap = parentOp && needsParens(node.op, parentOp, side ?? "left");
+      if (wrap) row.append(el("span", "exed-paren", ["("]));
+      row.append(renderNode(node.left, [...path, "left"], ctx, node.op, "left"));
+      const swap = opSwapGroup(node.op);
+      const opPill = pill("op", BINARY_LABEL[node.op], (b) => {
+        if (swap) operatorEditor(ctx, path, node.op, swap, b);
+      }, { title: swap ? "swap operator" : void 0 });
+      if (!swap) opPill.classList.add("exed-op-structural");
+      row.append(opPill);
+      row.append(renderNode(node.right, [...path, "right"], ctx, node.op, "right"));
+      if (wrap) row.append(el("span", "exed-paren", [")"]));
+      return row;
+    }
+  }
+}
+var deleteOrUnwrapNot = (ctx, path, node) => (
+  // clicking the NOT pill strips it (keeps the operand)
+  setNodeAt(ctx.getAst(), path, node.operand)
+);
+function boolEditor(ctx, path, value, anchor) {
+  ctx.openPopover(anchor, (close) => {
+    const wrap = el("div", "exed-menu");
+    wrap.append(el("div", "exed-menu-head", ["Boolean value"]));
+    for (const v of [true, false]) {
+      wrap.append(button(`exed-opt${v === value ? " sel" : ""}`, String(v), () => {
+        replace(ctx, path, boolLit(v));
+        close();
+      }));
+    }
+    return wrap;
+  });
+}
+function numberEditor(ctx, path, value, anchor) {
+  ctx.openPopover(anchor, (close) => textField({
+    initial: formatNumber(value),
+    caption: "Number value",
+    placeholder: "0",
+    validate: (v) => v.trim() !== "" && Number.isFinite(Number(v)),
+    onCommit: (v) => {
+      replace(ctx, path, numLit(Number(v)));
+      close();
+    }
+  }));
+}
+function stringEditor(ctx, path, node, anchor) {
+  const peer = findEnumPeer(ctx.getAst(), path);
+  const enumEntry = peer ? lookup(ctx.catalogue, peer.scope, peer.name) : null;
+  ctx.openPopover(anchor, (close) => {
+    if (enumEntry?.enumValues?.length) {
+      const wrap = el("div", "exed-menu");
+      wrap.append(el("div", "exed-menu-head", [`${displayName(enumEntry, ctx.defaultScope)} value`]));
+      for (const v of enumEntry.enumValues) {
+        wrap.append(button(`exed-opt${v === node.value ? " sel" : ""}`, v, () => {
+          replace(ctx, path, strLit(v));
+          close();
+        }));
+      }
+      return wrap;
+    }
+    return textField({
+      initial: node.value,
+      caption: "Text value",
+      placeholder: "value",
+      onCommit: (v) => {
+        replace(ctx, path, strLit(v));
+        close();
+      }
+    });
+  });
+}
+function operatorEditor(ctx, path, current, group, anchor) {
+  ctx.openPopover(anchor, (close) => {
+    const wrap = el("div", "exed-menu");
+    wrap.append(el("div", "exed-menu-head", ["Operator"]));
+    for (const op of group) {
+      wrap.append(button(`exed-opt${op === current ? " sel" : ""}`, `${BINARY_LABEL[op]}  ${op}`, () => {
+        const node = ctx.getAst();
+        const cur = setNodeAt(node, path, { ...getBinary(ctx, path), op });
+        ctx.apply(cur);
+        close();
+      }));
+    }
+    return wrap;
+  });
+}
+var getBinary = (ctx, path) => {
+  const n = getNodeAt(ctx.getAst(), path);
+  if (n?.kind !== "binary") throw new Error("expected binary");
+  return n;
+};
+function flagEditor(ctx, path, node, anchor) {
+  const callPath = path.slice(0, -2);
+  const call = getNodeAt(ctx.getAst(), callPath);
+  const flagsVar = call?.kind === "call" ? call.args[0] : void 0;
+  const entry = flagsVar?.kind === "scopedvar" ? lookup(ctx.catalogue, flagsVar.scope, flagsVar.name) : null;
+  const used = call?.kind === "call" ? call.args.filter((a, i) => a.kind === "flagdelta" && i !== path[path.length - 1]).map((a) => a.name) : [];
+  ctx.openPopover(anchor, (close) => {
+    const wrap = el("div", "exed-menu");
+    wrap.append(el("div", "exed-menu-head", ["Flag set?"]));
+    const signRow = el("div", "exed-field-row");
+    for (const s of ["+", "-"]) {
+      signRow.append(button(`exed-opt${s === node.sign ? " sel" : ""}`, s === "+" ? "+ set" : "\u2212 unset", () => {
+        replace(ctx, path, flagDelta(s, node.name));
+        close();
+      }));
+    }
+    wrap.append(signRow);
+    const names = (entry?.enumValues ?? []).filter((n) => !used.includes(n));
+    if (names.length) {
+      wrap.append(el("div", "exed-menu-head", ["Flag"]));
+      for (const n of names) wrap.append(button(`exed-opt${n === node.name ? " sel" : ""}`, n, () => {
+        replace(ctx, path, flagDelta(node.sign, n));
+        close();
+      }));
+    } else {
+      wrap.append(textField({ initial: node.name, caption: "Flag name", onCommit: (v) => {
+        replace(ctx, path, flagDelta(node.sign, v));
+        close();
+      } }));
+    }
+    return wrap;
+  });
+}
+function callEditor(ctx, path, node, anchor) {
+  ctx.openPopover(anchor, (close) => {
+    const wrap = el("div", "exed-menu");
+    wrap.append(el("div", "exed-menu-head", [node.name]));
+    wrap.append(el("div", "exed-hint", ["Edit the arguments by clicking each one."]));
+    if (FLAG_FNS.has(node.name)) {
+      wrap.append(button("exed-opt", "+ add flag", () => {
+        replace(ctx, path, { ...node, args: [...node.args, flagDelta("+", "")] });
+        close();
+      }));
+    }
+    wrap.append(button("exed-opt danger", "Delete", () => {
+      ctx.apply(deleteAt(ctx.getAst(), path));
+      close();
+    }));
+    return wrap;
+  });
+}
+function variableEditor(ctx, path, node, anchor) {
+  ctx.openPopover(anchor, (close) => propertyPicker(ctx, {
+    current: refOf(node, ctx.defaultScope),
+    onPick: (entry) => {
+      replace(ctx, path, scopedVar(entry.scope, entry.name));
+      close();
+    },
+    footer: button("exed-opt danger", "Delete", () => {
+      ctx.apply(deleteAt(ctx.getAst(), path));
+      close();
+    })
+  }));
+}
+function propertyPicker(ctx, opts) {
+  const wrap = el("div", "exed-picker");
+  const search = el("input", "exed-input");
+  search.type = "text";
+  search.placeholder = "Search properties\u2026";
+  const list = el("div", "exed-picker-list");
+  const pool = filterCatalogue(ctx.catalogue, { acceptTypes: opts.accept });
+  const draw = () => {
+    list.replaceChildren();
+    const groups = groupByScope(searchCatalogue(pool, search.value, ctx.defaultScope), ctx.scopeOrder);
+    if (!groups.length) {
+      list.append(el("div", "exed-hint", ["No matching properties."]));
+      return;
+    }
+    for (const g of groups) {
+      list.append(el("div", "exed-picker-scope", [g.scope]));
+      for (const e of g.entries) {
+        const label = displayName(e, ctx.defaultScope);
+        const sel = opts.current === refOf(e, ctx.defaultScope);
+        const row = button(`exed-opt${sel ? " sel" : ""}`, "", () => opts.onPick(e));
+        row.append(el("span", "exed-opt-name", [label]), el("span", "exed-opt-type", [e.type]));
+        if (e.purpose) row.append(el("span", "exed-opt-purpose", [e.purpose]));
+        list.append(row);
+      }
+    }
+  };
+  search.addEventListener("input", draw);
+  draw();
+  wrap.append(search, list);
+  if (opts.footer) wrap.append(el("div", "exed-picker-foot", [opts.footer]));
+  setTimeout(() => search.focus(), 0);
+  return wrap;
+}
+
+// src/clausewizard.ts
+var EQUALITY = ["==", "!="];
+var OP_WORD = {
+  "==": "equals",
+  "!=": "not equal to",
+  ">": "greater than",
+  ">=": "at least",
+  "<": "less than",
+  "<=": "at most"
+};
+var opButton = (o, onClick) => {
+  const b = button("exed-opt", "", onClick);
+  b.append(el("span", "exed-opt-name", [BINARY_LABEL[o]]), el("span", "exed-opt-purpose", [OP_WORD[o] ?? ""]));
+  return b;
+};
+var opsForType = (t) => t === "number" ? COMPARISON_OPS : EQUALITY;
+var rhsTypesFor = (t) => t === "number" ? ["number"] : t === "boolean" ? ["boolean"] : t === "enum" ? ["enum", "string"] : ["string", "enum"];
+function header(host, title, back, cancel) {
+  const h = el("div", "exed-vwiz-head");
+  if (back) h.append(button("exed-vwiz-back", "\u2190", back, "Back"));
+  else if (cancel) h.append(button("exed-vwiz-back", "\u2715", cancel, "Cancel"));
+  h.append(el("span", "exed-vwiz-title", [title]));
+  host.append(h);
+}
+var mono = (s) => el("span", "exed-vwiz-mono", [s]);
+var pickCtxOf = (w) => ({ catalogue: w.catalogue, defaultScope: w.defaultScope, scopeOrder: w.scopeOrder });
+function valueStep(host, w, lhs, op, back, cancel, commit) {
+  let mode = "value";
+  const draw = () => {
+    host.replaceChildren();
+    header(host, el("span", void 0, [mono(lhs.ref), " ", BINARY_LABEL[op], " \u2026"]), back, cancel);
+    const body = el("div", "exed-vwiz-body");
+    host.append(body);
+    const swap = () => button("exed-vwiz-other", mode === "value" ? "\u21A9 use a property instead" : "\u21A9 use a value instead", () => {
+      mode = mode === "value" ? "property" : "value";
+      draw();
+    });
+    const done = (rhs) => commit(binary(op, lhsVar(w, lhs.ref), rhs));
+    if (mode === "property") {
+      body.append(propertyPicker(pickCtxOf(w), { accept: rhsTypesFor(lhs.type), onPick: (e) => done(scopedVar(e.scope, e.name)) }));
+      body.append(swap());
+      return;
+    }
+    if (lhs.type === "boolean") {
+      const row = el("div", "exed-field-row");
+      row.append(button("exed-opt", "true", () => done(boolLit(true))), button("exed-opt", "false", () => done(boolLit(false))));
+      body.append(row);
+    } else if (lhs.type === "enum" && lhs.enumValues?.length) {
+      for (const v of lhs.enumValues) body.append(button("exed-opt", v, () => done(strLit(v))));
+    } else if (lhs.type === "number") {
+      body.append(textField({ caption: "Number", placeholder: "e.g. 3", validate: (v) => v.trim() !== "" && Number.isFinite(Number(v)), onCommit: (v) => done(numLit(Number(v))) }));
+    } else {
+      body.append(textField({ caption: "Text", placeholder: "e.g. autumn", onCommit: (v) => done(strLit(v)) }));
+    }
+    body.append(swap());
+  };
+  draw();
+}
+function lhsVar(w, ref) {
+  const bare = ref.replace(/^@/, "");
+  const dot = bare.indexOf(".");
+  return dot >= 0 ? scopedVar(bare.slice(0, dot), bare.slice(dot + 1)) : scopedVar(w.defaultScope, bare);
+}
+function comparisonWizard(host, w, commit, cancel) {
+  const pickLhs = () => {
+    host.replaceChildren();
+    header(host, "Pick a property to compare", void 0, cancel);
+    const body = el("div", "exed-vwiz-body");
+    host.append(body);
+    body.append(propertyPicker(pickCtxOf(w), {
+      accept: ["boolean", "number", "string", "enum"],
+      onPick: (e) => pickOp({ ref: refDisplay(w, e), type: e.type, ...e.enumValues ? { enumValues: e.enumValues } : {} })
+    }));
+  };
+  const pickOp = (lhs) => {
+    host.replaceChildren();
+    header(host, el("span", void 0, ["Operator for ", mono(lhs.ref)]), pickLhs, cancel);
+    const body = el("div", "exed-vwiz-body");
+    host.append(body);
+    for (const o of opsForType(lhs.type)) {
+      body.append(opButton(o, () => valueStep(host, w, lhs, o, () => pickOp(lhs), cancel, commit)));
+    }
+  };
+  pickLhs();
+}
+function booleanWizard(host, w, commit, cancel) {
+  host.replaceChildren();
+  header(host, "Pick a boolean property", void 0, cancel);
+  const body = el("div", "exed-vwiz-body");
+  host.append(body);
+  body.append(propertyPicker(pickCtxOf(w), { accept: ["boolean"], onPick: (e) => commit(scopedVar(e.scope, e.name)) }));
+}
+function checkFlagsWizard(host, w, commit, cancel) {
+  const pickProp = () => {
+    host.replaceChildren();
+    header(host, el("span", void 0, ["Flags property for ", mono("check_flags()")]), void 0, cancel);
+    const body = el("div", "exed-vwiz-body");
+    host.append(body);
+    body.append(propertyPicker(pickCtxOf(w), { accept: ["flags"], onPick: (e) => pickFlag(e) }));
+  };
+  const pickFlag = (prop) => {
+    let sign = "+";
+    const draw = () => {
+      host.replaceChildren();
+      header(host, el("span", void 0, ["Flag on ", mono(refDisplay(w, prop))]), pickProp, cancel);
+      const body = el("div", "exed-vwiz-body");
+      host.append(body);
+      const signRow = el("div", "exed-field-row");
+      signRow.append(
+        button(`exed-opt${sign === "+" ? " sel" : ""}`, "\uFF0B set", () => {
+          sign = "+";
+          draw();
+        }),
+        button(`exed-opt${sign === "-" ? " sel" : ""}`, "\uFF0D unset", () => {
+          sign = "-";
+          draw();
+        })
+      );
+      body.append(signRow);
+      const flags = prop.enumValues ?? [];
+      if (!flags.length) body.append(el("div", "exed-hint", [`${refDisplay(w, prop)} declares no flag values yet.`]));
+      for (const f of flags) body.append(button("exed-opt", f, () => commit(callNode("check_flags", [scopedVar(prop.scope, prop.name), flagDelta(sign, f)]))));
+    };
+    draw();
+  };
+  pickProp();
+}
+function randomWizard(host, w, commit, cancel) {
+  const pickRange = () => {
+    host.replaceChildren();
+    header(host, el("span", void 0, ["Range for ", mono("random(a, b)")]), void 0, cancel);
+    const body = el("div", "exed-vwiz-body");
+    host.append(body);
+    let a = "1";
+    body.append(textField({ caption: "Low (a)", initial: "1", placeholder: "e.g. 1", validate: numOk, onCommit: (v) => {
+      a = v;
+    } }));
+    body.append(textField({
+      caption: "High (b)",
+      initial: "6",
+      placeholder: "e.g. 6",
+      submitLabel: "Next \u2192",
+      validate: numOk,
+      onCommit: (b) => pickOp(Math.round(Number(a)), Math.round(Number(b)))
+    }));
+  };
+  const pickOp = (a, b) => {
+    host.replaceChildren();
+    header(host, el("span", void 0, ["Operator for ", mono(`random(${a}, ${b})`)]), pickRange, cancel);
+    const body = el("div", "exed-vwiz-body");
+    host.append(body);
+    for (const o of COMPARISON_OPS) {
+      body.append(opButton(o, () => pickValue(a, b, o)));
+    }
+  };
+  const pickValue = (a, b, op) => {
+    host.replaceChildren();
+    header(host, el("span", void 0, [mono(`random(${a}, ${b})`), ` ${BINARY_LABEL[op]} \u2026`]), () => pickOp(a, b), cancel);
+    const body = el("div", "exed-vwiz-body");
+    host.append(body);
+    body.append(textField({ caption: "Compare to", placeholder: "e.g. 1", validate: numOk, onCommit: (v) => commit(binary(op, callNode("random", [numLit(a), numLit(b)]), numLit(Number(v)))) }));
+  };
+  pickRange();
+}
+var numOk = (v) => v.trim() !== "" && Number.isFinite(Number(v));
+function genericWizard(host, spec, commit, cancel) {
+  const values = [];
+  const stepAt = (i) => {
+    const step = spec.steps[i];
+    if (!step) return;
+    host.replaceChildren();
+    const back = i > 0 ? () => {
+      values.length = i - 1;
+      stepAt(i - 1);
+    } : void 0;
+    header(host, step.title, back, cancel);
+    const body = el("div", "exed-vwiz-body");
+    host.append(body);
+    const last = i === spec.steps.length - 1;
+    const done = (v) => {
+      values[i] = v;
+      if (last) commit(spec.build(values));
+      else stepAt(i + 1);
+    };
+    switch (step.kind) {
+      case "string":
+        body.append(textField({
+          caption: step.caption ?? "Text",
+          placeholder: step.placeholder,
+          submitLabel: last ? "Apply" : "Next \u2192",
+          validate: (v) => v.trim() !== "",
+          onCommit: (v) => done(v.trim())
+        }));
+        break;
+      case "number":
+        body.append(textField({
+          caption: step.caption ?? "Number",
+          placeholder: step.placeholder,
+          initial: step.initial !== void 0 ? String(step.initial) : void 0,
+          submitLabel: last ? "Apply" : "Next \u2192",
+          validate: numOk,
+          onCommit: (v) => done(Number(v))
+        }));
+        break;
+      case "op":
+        for (const o of step.ops ?? COMPARISON_OPS) body.append(opButton(o, () => done(o)));
+        break;
+    }
+  };
+  stepAt(0);
+}
+function refDisplay(w, e) {
+  return e.scope === w.defaultScope ? `@${e.name}` : `@${e.scope}.${e.name}`;
+}
+
+// src/treeview.ts
+function requestFocusForInsert(ctx, clause, base) {
+  const rel = firstEmptyLeafPath(clause);
+  if (rel) ctx.requestFocus?.([...base, ...rel]);
+}
+function renderTree(ctx) {
+  const row = astToTree(ctx.getAst(), []);
+  const wrap = el("div", "exed-tree");
+  wrap.append(renderRow(ctx, row, { root: true }));
+  if (row.kind !== "container") wrap.append(rootAddBar(ctx));
+  return wrap;
+}
+function renderRow(ctx, row, env) {
+  if (row.kind === "container") return renderContainer(ctx, row, env);
+  return renderLeaf(ctx, row, env);
+}
+function notToggle(ctx, path) {
+  return button("exed-rowbtn", "NOT", () => ctx.apply(toggleContainerNot(ctx.getAst(), path)), "toggle NOT");
+}
+function rowActions(ctx, row, env) {
+  const acts = el("div", "exed-rowacts");
+  acts.append(notToggle(ctx, row.path));
+  if (env.chainPath && env.count != null && env.index != null) {
+    if (env.index > 0) acts.append(button("exed-rowbtn", "\u2191", () => ctx.apply(moveChildInContainer(ctx.getAst(), env.chainPath, env.index, env.index - 1)), "move up"));
+    if (env.index < env.count - 1) acts.append(button("exed-rowbtn", "\u2193", () => ctx.apply(moveChildInContainer(ctx.getAst(), env.chainPath, env.index, env.index + 1)), "move down"));
+  }
+  acts.append(button("exed-rowbtn danger", "\u2715", () => {
+    if (env.root) {
+      ctx.apply(null);
+      return;
+    }
+    const target = redirectDeleteForPlaceholderSibling(ctx.getAst(), row.path);
+    ctx.apply(deleteAt(ctx.getAst(), target));
+  }, "delete"));
+  return acts;
+}
+function renderLeaf(ctx, row, env) {
+  if (row.kind === "wrapped" && (isPlaceholderForOp(row.node, "and") || isPlaceholderForOp(row.node, "or"))) {
+    return placeholderRow(ctx, row.path);
+  }
+  const line = el("div", "exed-row");
+  if (row.negated) line.append(el("span", "exed-not", ["NOT"]));
+  const content = row.kind === "comparison" ? renderNode(nodeAtContent(ctx, row.contentPath), row.contentPath, ctx) : renderNode(row.node, row.contentPath, ctx);
+  line.append(el("span", "exed-rowcontent", [content]));
+  line.append(rowActions(ctx, row, env));
+  return line;
+}
+var nodeAtContent = (ctx, path) => {
+  return getNodeAt(ctx.getAst(), path);
+};
+function renderContainer(ctx, row, env) {
+  const box = el("div", `exed-group exed-group-${row.op}`);
+  const head = el("div", "exed-grouphead");
+  if (row.negated) head.append(el("span", "exed-not", ["NOT"]));
+  const label = row.op === "and" ? "ALL OF THESE:" : "ANY OF THESE:";
+  if (env.root) {
+    head.append(button("exed-flip", label, () => ctx.apply(flipContainerOp(ctx.getAst(), row.chainPath, row.op === "and" ? "or" : "and")), "switch AND / OR"));
+  } else {
+    head.append(el("span", "exed-grouplabel", [label]));
+  }
+  const headActs = el("div", "exed-rowacts");
+  headActs.append(notToggle(ctx, row.path));
+  if (!env.root) headActs.append(button("exed-rowbtn danger", "\u2715", () => ctx.apply(deleteAt(ctx.getAst(), row.path)), "delete group"));
+  head.append(headActs);
+  box.append(head);
+  const body = el("div", "exed-groupbody");
+  row.children.forEach((child, i) => {
+    const childRow = el("div", "exed-child");
+    childRow.append(el("span", "exed-connector", [i === 0 ? "" : row.op.toUpperCase()]));
+    childRow.append(renderRow(ctx, child, { index: i, count: row.children.length, chainPath: row.chainPath }));
+    body.append(childRow);
+  });
+  body.append(addBar(ctx, row.chainPath, row.op));
+  box.append(body);
+  return box;
+}
+function placeholderRow(ctx, path) {
+  const b = button("exed-placeholder", "Click to add condition", (e) => {
+    clauseMenu(ctx, e.currentTarget, (node) => {
+      requestFocusForInsert(ctx, node, path);
+      ctx.apply(replaceAt(ctx, path, node));
+    });
+  });
+  return b;
+}
+function addBar(ctx, chainPath, op) {
+  const bar = el("div", "exed-addbar");
+  bar.append(button("exed-add", "+ Add condition", (e) => {
+    clauseMenu(ctx, e.currentTarget, (node) => {
+      requestFocusForInsert(ctx, node, [...chainPath, "right"]);
+      ctx.apply(addChildToContainer(ctx.getAst(), chainPath, node));
+    });
+  }));
+  bar.append(button("exed-add", `+ Add ${op === "and" ? "OR" : "AND"} group`, () => {
+    ctx.apply(addChildToContainer(ctx.getAst(), chainPath, buildSubGroupClause(op, seedClause(ctx))));
+  }, "add a nested group"));
+  return bar;
+}
+function rootAddBar(ctx) {
+  const bar = el("div", "exed-addbar");
+  bar.append(button("exed-add", "+ Add condition", (e) => {
+    clauseMenu(ctx, e.currentTarget, (node) => {
+      requestFocusForInsert(ctx, node, ["right"]);
+      ctx.apply(addChildToContainer(ctx.getAst(), [], node));
+    });
+  }));
+  bar.append(button("exed-add", "+ Add group", () => {
+    ctx.apply(addChildToContainer(ctx.getAst(), [], buildSubGroupClause("and", seedClause(ctx))));
+  }));
+  return bar;
+}
+function seedClause(ctx) {
+  const first = ctx.catalogue[0];
+  if (!first) return { kind: "bool", value: true };
+  if (first.type === "boolean") return scopedVar(first.scope, first.name);
+  return binary("==", scopedVar(first.scope, first.name), first.type === "number" ? { kind: "number", value: 0 } : strLit(""));
+}
+function clauseMenu(ctx, anchor, onPick) {
+  ctx.openPopover(anchor, (close) => {
+    const wrap = el("div", "exed-menu");
+    wrap.append(el("div", "exed-menu-head", ["Add a clause"]));
+    const add = (label, hint, make, disabled = false) => {
+      const b = button(`exed-opt${disabled ? " disabled" : ""}`, "", () => {
+        if (disabled) return;
+        make();
+        close();
+      });
+      if (disabled) b.disabled = true;
+      b.append(el("span", "exed-opt-name", [label]));
+      if (hint) b.append(el("span", "exed-opt-purpose", [hint]));
+      wrap.append(b);
+    };
+    const wctx = { catalogue: ctx.catalogue, scopeOrder: ctx.scopeOrder, defaultScope: ctx.defaultScope };
+    const launch = (run) => {
+      ctx.openPopover(anchor, (close2) => {
+        const host = el("div", "exed-vwiz");
+        run(host, wctx, (node) => {
+          onPick(node);
+          close2();
+        }, close2);
+        return host;
+      });
+    };
+    const addFn = (fn) => add(fn.label, fn.hint, () => {
+      if (fn.wizard === "check_flags") launch(checkFlagsWizard);
+      else if (fn.wizard === "random") launch(randomWizard);
+      else if (fn.wizard && typeof fn.wizard === "object") {
+        const spec = fn.wizard;
+        launch((host, _w, commit, cancel) => genericWizard(host, spec, commit, cancel));
+      } else onPick(fn.build());
+    }, !!fn.disabled);
+    const flagFns = ctx.functions.filter((f) => f.name === "check_flags");
+    const otherFns = ctx.functions.filter((f) => f.name !== "check_flags");
+    flagFns.forEach(addFn);
+    add("Property comparison", "a property vs a value", () => launch(comparisonWizard));
+    add("Property is true", "a boolean property on its own", () => launch(booleanWizard));
+    otherFns.forEach(addFn);
+    return wrap;
+  });
+}
+var replaceAt = (ctx, path, node) => setNodeAt(ctx.getAst(), path, node);
+
+// src/mount.ts
+function mountExpressionEditor(host, opts) {
+  const defaultScope = opts.dialect.defaultScope;
+  let src = opts.value ?? "";
+  let raw = opts.text ?? false;
+  let activePopover = null;
+  let editing = false;
+  let pendingFocus = null;
+  host.classList.add("exed-root");
+  const emit = (next) => {
+    src = next;
+    opts.onChange(src);
+    render();
+  };
+  const toSrc = (ast) => ast ? expr.unparse(ast, { defaultScope }) : "";
+  const setEditing = (on) => {
+    if (on === editing) return;
+    editing = on;
+    opts.onEditingChange?.(on);
+  };
+  const closePopover = () => {
+    activePopover?.close();
+    activePopover = null;
+  };
+  function buildCtx(ast) {
+    const v = validateSource(src, opts.schema, opts.dialect);
+    return {
+      schema: opts.schema,
+      dialect: opts.dialect,
+      defaultScope,
+      catalogue: opts.catalogue,
+      scopeOrder: opts.scopeOrder ?? [],
+      functions: opts.functions ?? [],
+      byPath: v.byPath,
+      getAst: () => ast,
+      apply: (next) => emit(toSrc(next)),
+      openPopover: (anchor, r) => {
+        closePopover();
+        const pop = openPopover(anchor, r, () => {
+          if (activePopover === pop) activePopover = null;
+          setEditing(false);
+        });
+        activePopover = pop;
+        setEditing(true);
+      },
+      requestFocus: (p) => {
+        pendingFocus = p;
+      },
+      ...opts.pickNode ? { pickNode: opts.pickNode } : {},
+      ...opts.nodeLabel ? { nodeLabel: opts.nodeLabel } : {}
+    };
+  }
+  function render() {
+    closePopover();
+    host.replaceChildren();
+    const v = validateSource(src, opts.schema, opts.dialect);
+    if (raw || v.unparseable) {
+      host.append(rawArea());
+    } else if (!src.trim() || !v.ast) {
+      host.append(emptyState());
+    } else {
+      const ctx = buildCtx(v.ast);
+      const body = el("div", "exed-body");
+      if ((opts.mode ?? "tree") === "flat") {
+        const flat = el("div", "exed-flat", [renderNode(v.ast, [], ctx)]);
+        if (opts.addTerm) flat.append(addTermControl(ctx));
+        body.append(flat);
+      } else body.append(renderTree(ctx));
+      host.append(body);
+    }
+    if ((opts.messages ?? true) && (!v.unparseable || src.trim())) host.append(messages(v.issues));
+    if (pendingFocus) {
+      const key = pendingFocus.join("/");
+      pendingFocus = null;
+      host.querySelector(`[data-exed-path="${key}"]`)?.click();
+    }
+  }
+  function rawArea() {
+    const ta = el("textarea", "exed-raw");
+    ta.value = src;
+    ta.placeholder = "@gold > 0 and @met_anna";
+    ta.rows = 2;
+    ta.addEventListener("input", () => {
+      src = ta.value;
+      opts.onChange(src);
+      msgHost.replaceChildren(messages(validateSource(src, opts.schema, opts.dialect).issues));
+    });
+    const msgHost = el("div", "exed-rawmsg");
+    const wrap = el("div", "exed-rawwrap", [ta, msgHost]);
+    return wrap;
+  }
+  function emptyState() {
+    const wrap = el("div", "exed-empty");
+    wrap.append(el("span", "exed-pill exed-pill-always", [opts.nullLabel ?? "always"]));
+    const ctx = buildCtx(boolLit(true));
+    wrap.append(button("exed-add", "+ Add your first condition", (e) => {
+      clauseMenu(ctx, e.currentTarget, (node) => {
+        requestFocusForInsert(ctx, node, []);
+        emit(toSrc(node));
+      });
+    }));
+    return wrap;
+  }
+  function addTermControl(ctx) {
+    const boolean = opts.addTerm === "boolean";
+    const ops = boolean ? ["and", "or"] : ARITHMETIC_OPS;
+    const operandType = boolean ? "boolean" : "number";
+    return button("exed-add exed-addterm", "+ term", (e) => {
+      const anchor = e.currentTarget;
+      let op = ops[0];
+      ctx.openPopover(anchor, (close) => {
+        const wrap = el("div", "exed-menu");
+        wrap.append(el("div", "exed-menu-head", ["Add term"]));
+        const commit = (operand) => {
+          ctx.apply(binary(op, ctx.getAst(), operand));
+          close();
+        };
+        const opRow = el("div", "exed-field-row");
+        const drawOps = () => {
+          opRow.replaceChildren();
+          for (const o of ops) opRow.append(button(`exed-opt${o === op ? " sel" : ""}`, BINARY_LABEL[o], () => {
+            op = o;
+            drawOps();
+          }));
+        };
+        drawOps();
+        wrap.append(opRow);
+        if (boolean) {
+          const row = el("div", "exed-field-row");
+          row.append(button("exed-opt", "true", () => commit(boolLit(true))), button("exed-opt", "false", () => commit(boolLit(false))));
+          wrap.append(row);
+        } else {
+          wrap.append(textField({
+            caption: "by",
+            placeholder: "e.g. 1",
+            validate: (v) => v.trim() !== "" && Number.isFinite(Number(v)),
+            onCommit: (v) => commit(numLit(Number(v)))
+          }));
+        }
+        wrap.append(button("exed-opt", "\u2026or a property", () => {
+          ctx.openPopover(anchor, (c2) => propertyPicker(ctx, { accept: [operandType], onPick: (en) => {
+            commit(scopedVar(en.scope, en.name));
+            c2();
+          } }));
+        }));
+        return wrap;
+      });
+    }, boolean ? "add a logical term" : "add an arithmetic term");
+  }
+  function messages(issues) {
+    const box = el("div", "exed-msgs");
+    for (const i of issues) {
+      box.append(el("div", `exed-msg exed-msg-${i.severity}`, [i.severity === "error" ? "\u26A0 " : "\u25B3 ", i.message]));
+    }
+    return box;
+  }
+  render();
+  return {
+    setValue: (v) => {
+      src = v ?? "";
+      render();
+    },
+    // text mode is host-driven; don't reset it here
+    setText: (on) => {
+      raw = on;
+      render();
+    },
+    destroy: () => {
+      closePopover();
+      host.replaceChildren();
+      host.classList.remove("exed-root");
+    }
+  };
+}
+
+// src/valuewizard.ts
+var isIdent = (v) => /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(v);
+var enumSrc = (v) => isIdent(v) ? v : JSON.stringify(v);
+function valueWizard(opts) {
+  const host = el("div", "exed-vwiz");
+  const pickCtx = { catalogue: opts.catalogue, defaultScope: opts.defaultScope, scopeOrder: opts.scopeOrder };
+  const optBtn = (label, onClick) => button("exed-opt", label, onClick);
+  const head = (title) => {
+    const h = el("div", "exed-vwiz-head");
+    if (opts.onCancel) h.append(button("exed-vwiz-back", "\u2715", opts.onCancel, "Cancel"));
+    h.append(el("span", "exed-vwiz-title", [title]));
+    return h;
+  };
+  host.append(head("Pick a value"));
+  const body = el("div", "exed-vwiz-body");
+  host.append(body);
+  let kind = opts.expectedType === "number" ? "number" : opts.expectedType === "string" ? "text" : opts.expectedType === "boolean" ? "bool" : opts.expectedType === "enum" && opts.expectedEnumValues?.length ? "enum" : "menu";
+  const draw = () => {
+    body.replaceChildren();
+    const other = () => button("exed-vwiz-other", "\u21A9 a different kind", () => {
+      kind = "menu";
+      draw();
+    });
+    switch (kind) {
+      case "menu":
+        body.append(optBtn("A property\u2026", () => {
+          kind = "property";
+          draw();
+        }));
+        body.append(optBtn("A number", () => {
+          kind = "number";
+          draw();
+        }));
+        body.append(optBtn("Text", () => {
+          kind = "text";
+          draw();
+        }));
+        body.append(optBtn("True / False", () => {
+          kind = "bool";
+          draw();
+        }));
+        if (opts.expectedEnumValues?.length) body.append(optBtn("A listed value", () => {
+          kind = "enum";
+          draw();
+        }));
+        break;
+      case "property":
+        body.append(propertyPicker(pickCtx, { onPick: (e) => opts.onCommit(refOf(e, opts.defaultScope)) }));
+        body.append(other());
+        break;
+      case "number":
+        body.append(textField({ caption: "Number", placeholder: "e.g. 5 or 0.5", validate: (v) => v.trim() !== "" && Number.isFinite(Number(v)), onCommit: (v) => opts.onCommit(String(Number(v))) }));
+        body.append(other());
+        break;
+      case "text":
+        body.append(textField({ caption: "Text", placeholder: "e.g. autumn", onCommit: (v) => opts.onCommit(JSON.stringify(v)) }));
+        body.append(other());
+        break;
+      case "bool": {
+        const row = el("div", "exed-field-row");
+        row.append(optBtn("true", () => opts.onCommit("true")), optBtn("false", () => opts.onCommit("false")));
+        body.append(row, other());
+        break;
+      }
+      case "enum":
+        for (const v of opts.expectedEnumValues ?? []) body.append(optBtn(v, () => opts.onCommit(enumSrc(v))));
+        body.append(other());
+        break;
+    }
+  };
+  draw();
+  return host;
+}
+
+// src/effects.ts
+var clone = (list) => list.map((e) => e.kind === "set" ? { ...e } : { ...e, args: [...e.args] });
+var addSet = (list, target, value) => [...clone(list), { kind: "set", target, value }];
+var addEmit = (list, event) => [...clone(list), { kind: "emit", event, args: [] }];
+var removeAt = (list, i) => clone(list).filter((_, idx) => idx !== i);
+function moveAt(list, i, dir) {
+  const next = clone(list);
+  const j = i + dir;
+  if (j < 0 || j >= next.length) return next;
+  [next[i], next[j]] = [next[j], next[i]];
+  return next;
+}
+function updateAt(list, i, patch) {
+  const next = clone(list);
+  const cur = next[i];
+  if (!cur) return next;
+  next[i] = { ...cur, ...patch };
+  return next;
+}
+function setArgAt(list, i, argIdx, value) {
+  const next = clone(list);
+  const cur = next[i];
+  if (!cur || cur.kind !== "emit") return next;
+  cur.args[argIdx] = value;
+  return next;
+}
+function addArg(list, i, value = "0") {
+  const next = clone(list);
+  const cur = next[i];
+  if (!cur || cur.kind !== "emit") return next;
+  cur.args.push(value);
+  return next;
+}
+function removeArgAt(list, i, argIdx) {
+  const next = clone(list);
+  const cur = next[i];
+  if (!cur || cur.kind !== "emit") return next;
+  cur.args.splice(argIdx, 1);
+  return next;
+}
+function seedValueSrc(type, enumValues) {
+  switch (type) {
+    case "boolean":
+      return "true";
+    case "number":
+      return "0";
+    case "enum":
+      return JSON.stringify(enumValues?.[0] ?? "");
+    case "string":
+      return '""';
+    default:
+      return "0";
+  }
+}
+function mountEffectsEditor(host, opts) {
+  const defaultScope = opts.dialect.defaultScope;
+  let effects = clone(opts.effects ?? []);
+  let textMode = opts.text ?? false;
+  let popover = null;
+  const inner = [];
+  host.classList.add("exed-root", "exed-effects-root");
+  const closePopover = () => {
+    popover?.close();
+    popover = null;
+  };
+  const commit = (next) => {
+    effects = clone(next);
+    opts.onChange(effects);
+    render();
+  };
+  const openValueWizard = (anchor, expected, onCommit) => {
+    closePopover();
+    popover = openPopover(anchor, (close) => valueWizard({
+      catalogue: opts.catalogue,
+      scopeOrder: opts.scopeOrder ?? [],
+      defaultScope,
+      ...expected?.type ? { expectedType: expected.type } : {},
+      ...expected?.enumValues ? { expectedEnumValues: expected.enumValues } : {},
+      onCommit: (src) => {
+        onCommit(src);
+        close();
+      },
+      onCancel: close
+    }));
+  };
+  const targetType = (target) => opts.catalogue.find((e) => refOf(e, defaultScope) === target)?.type;
+  const valueDisplay = (value, onChange, type) => {
+    const sub = el("div", "exed-effect-value");
+    const addTerm = type === "number" ? "arithmetic" : type === "boolean" ? "boolean" : void 0;
+    inner.push(mountExpressionEditor(sub, {
+      value,
+      schema: opts.schema,
+      dialect: opts.dialect,
+      catalogue: opts.catalogue,
+      scopeOrder: opts.scopeOrder,
+      functions: opts.functions,
+      mode: "flat",
+      ...addTerm ? { addTerm } : {},
+      text: textMode,
+      onChange
+    }));
+    return sub;
+  };
+  const pickTarget = (anchor, accept, onPick) => {
+    closePopover();
+    popover = openPopover(anchor, (close) => {
+      const wrap = el("div", "exed-picker");
+      const search = el("input", "exed-input");
+      search.type = "text";
+      search.placeholder = "Search properties\u2026";
+      const list = el("div", "exed-picker-list");
+      const pool = filterCatalogue(opts.catalogue, { acceptTypes: accept });
+      const draw = () => {
+        list.replaceChildren();
+        const groups = groupByScope(searchCatalogue(pool, search.value, defaultScope), opts.scopeOrder ?? []);
+        if (!groups.length) {
+          list.append(el("div", "exed-hint", ["No matching properties."]));
+          return;
+        }
+        for (const g of groups) {
+          list.append(el("div", "exed-picker-scope", [g.scope]));
+          for (const e of g.entries) {
+            const row = button("exed-opt", "", () => {
+              onPick(e);
+              close();
+            });
+            row.append(el("span", "exed-opt-name", [displayName(e, defaultScope)]), el("span", "exed-opt-type", [e.type]));
+            if (e.purpose) row.append(el("span", "exed-opt-purpose", [e.purpose]));
+            list.append(row);
+          }
+        }
+      };
+      search.addEventListener("input", draw);
+      draw();
+      wrap.append(search, list);
+      setTimeout(() => search.focus(), 0);
+      return wrap;
+    });
+  };
+  const iconBtn = (glyph, title, onClick, danger = false) => button(`exed-eff-icon${danger ? " danger" : ""}`, glyph, onClick, title);
+  function setRow(eff, i) {
+    const row = el("div", "exed-effect exed-effect-set");
+    const targetBtn = button("exed-pill exed-pill-prop", eff.target || "(pick property)", (e) => {
+      pickTarget(e.currentTarget, void 0, (entry) => {
+        commit(updateAt(effects, i, { target: refOf(entry, defaultScope), value: seedValueSrc(entry.type, entry.enumValues) }));
+      });
+    }, "change the target property");
+    row.append(targetBtn, el("span", "exed-effect-eq", ["="]));
+    row.append(valueDisplay(eff.value, (src) => {
+      effects = updateAt(effects, i, { value: src });
+      opts.onChange(effects);
+    }, targetType(eff.target)));
+    row.append(rowActions2(i));
+    return row;
+  }
+  function emitRow(eff, i) {
+    const row = el("div", "exed-effect exed-effect-emit");
+    const head = el("div", "exed-effect-head");
+    head.append(el("span", "exed-effect-kw", ["emit"]));
+    const eventBtn = button("exed-pill exed-pill-event", eff.event ? `"${eff.event}"` : "(name)", (e) => {
+      editEvent(e.currentTarget, eff.event, (name) => commit(updateAt(effects, i, { event: name })));
+    }, "name the host event");
+    head.append(eventBtn);
+    head.append(rowActions2(i));
+    row.append(head);
+    const args = el("div", "exed-effect-args");
+    eff.args.forEach((a, ai) => {
+      const slot = el("div", "exed-effect-arg");
+      slot.append(valueDisplay(a, (src) => {
+        effects = setArgAt(effects, i, ai, src);
+        opts.onChange(effects);
+      }));
+      slot.append(iconBtn("\u2715", "remove argument", () => commit(removeArgAt(effects, i, ai)), true));
+      args.append(slot);
+    });
+    args.append(button("exed-eff-add", "+ argument", (e) => openValueWizard(e.currentTarget, void 0, (src) => commit(addArg(effects, i, src)))));
+    row.append(args);
+    return row;
+  }
+  const editEvent = (anchor, current, onName) => {
+    closePopover();
+    popover = openPopover(anchor, (close) => {
+      const wrap = el("div", "exed-picker");
+      const input = el("input", "exed-input");
+      input.type = "text";
+      input.value = current;
+      input.placeholder = "event name";
+      const apply = () => {
+        const v = input.value.trim();
+        if (v) onName(v);
+        close();
+      };
+      input.addEventListener("keydown", (e) => {
+        if (e.key === "Enter") {
+          e.preventDefault();
+          e.stopPropagation();
+          apply();
+        }
+      });
+      wrap.append(input);
+      for (const name of opts.events ?? []) {
+        if (name === current) continue;
+        wrap.append(button("exed-opt", name, () => {
+          onName(name);
+          close();
+        }));
+      }
+      wrap.append(button("exed-btn primary", "Apply", apply));
+      setTimeout(() => input.focus(), 0);
+      return wrap;
+    });
+  };
+  const rowActions2 = (i) => {
+    const acts = el("div", "exed-effect-acts");
+    if (i > 0) acts.append(iconBtn("\u2191", "move up", () => commit(moveAt(effects, i, -1))));
+    if (i < effects.length - 1) acts.append(iconBtn("\u2193", "move down", () => commit(moveAt(effects, i, 1))));
+    acts.append(iconBtn("\u2715", "remove effect", () => commit(removeAt(effects, i)), true));
+    return acts;
+  };
+  function render() {
+    closePopover();
+    for (const h of inner.splice(0)) h.destroy();
+    host.replaceChildren();
+    const listEl = el("div", "exed-effect-list");
+    if (!effects.length) listEl.append(el("div", "exed-effect-empty", ["No effects yet."]));
+    effects.forEach((eff, i) => listEl.append(eff.kind === "set" ? setRow(eff, i) : emitRow(eff, i)));
+    host.append(listEl);
+    const bar = el("div", "exed-effect-addbar");
+    bar.append(button("exed-eff-add", "+ set property", (e) => {
+      const anchor = e.currentTarget;
+      pickTarget(anchor, void 0, (entry) => openValueWizard(anchor, entry, (src) => commit(addSet(effects, refOf(entry, defaultScope), src))));
+    }));
+    if (opts.allowEmit !== false) {
+      bar.append(button("exed-eff-add", "+ emit event", (e) => editEvent(e.currentTarget, "", (name) => commit(addEmit(effects, name)))));
+    }
+    host.append(bar);
+  }
+  render();
+  return {
+    setValue: (next) => {
+      effects = clone(next ?? []);
+      render();
+    },
+    // Flip every live inline value editor in place — keeps any open target/wizard popover alive.
+    setText: (on) => {
+      textMode = on;
+      for (const h of inner) h.setText(on);
+    },
+    destroy: () => {
+      closePopover();
+      for (const h of inner.splice(0)) h.destroy();
+      host.replaceChildren();
+      host.classList.remove("exed-root", "exed-effects-root");
+    }
+  };
+}
+
+// src/preview.ts
+function frozenCtx(src, o) {
+  const v = validateSource(src, o.schema, o.dialect);
+  const ctx = {
+    schema: o.schema,
+    dialect: o.dialect,
+    defaultScope: o.dialect.defaultScope,
+    catalogue: o.catalogue,
+    scopeOrder: o.scopeOrder ?? [],
+    functions: [],
+    byPath: v.byPath,
+    getAst: () => v.ast,
+    apply: () => {
+    },
+    openPopover: () => {
+    },
+    pickNode: () => {
+    },
+    // enables labelled node pills; never fires (preview is read-only)
+    ...o.nodeLabel ? { nodeLabel: o.nodeLabel } : {}
+  };
+  return { ctx, ast: v.ast };
+}
+function exprPills(src, o) {
+  const { ctx, ast } = frozenCtx(src, o);
+  return ast ? renderNode(ast, [], ctx) : el("span", "exed-preview-raw", [src]);
+}
+function renderConditionPreview(src, o) {
+  return el("div", "exed-preview", [exprPills(src, o)]);
+}
+function renderEffectsPreview(effects, o) {
+  const wrap = el("div", "exed-preview exed-preview-effects");
+  for (const eff of effects) {
+    const row = el("div", "exed-preview-eff");
+    if (eff.kind === "set") {
+      row.append(el("span", "exed-pill exed-pill-prop", [eff.target || "(property)"]));
+      row.append(el("span", "exed-effect-eq", ["="]));
+      row.append(exprPills(eff.value, o));
+    } else {
+      row.append(el("span", "exed-effect-kw", ["emit"]));
+      row.append(el("span", "exed-pill exed-pill-event", [eff.event ? `"${eff.event}"` : "(name)"]));
+      row.append(el("span", "exed-paren", ["("]));
+      eff.args.forEach((a, i) => {
+        if (i > 0) row.append(el("span", "exed-comma", [", "]));
+        row.append(exprPills(a, o));
+      });
+      row.append(el("span", "exed-paren", [")"]));
+    }
+    wrap.append(row);
+  }
+  return wrap;
+}
+
+exports.ARITHMETIC_OPS = ARITHMETIC_OPS;
+exports.BINARY_LABEL = BINARY_LABEL;
+exports.COMPARISON_OPS = COMPARISON_OPS;
+exports.UNARY_LABEL = UNARY_LABEL;
+exports.addArg = addArg;
+exports.addChildToContainer = addChildToContainer;
+exports.addEmit = addEmit;
+exports.addSet = addSet;
+exports.astToTree = astToTree;
+exports.binary = binary;
+exports.boolLit = boolLit;
+exports.buildSubGroupClause = buildSubGroupClause;
+exports.callNode = callNode;
+exports.deleteAt = deleteAt;
+exports.displayName = displayName;
+exports.filterCatalogue = filterCatalogue;
+exports.findEnumPeer = findEnumPeer;
+exports.firstEmptyLeafPath = firstEmptyLeafPath;
+exports.flagDelta = flagDelta;
+exports.flipContainerOp = flipContainerOp;
+exports.formatNumber = formatNumber;
+exports.getNodeAt = getNodeAt;
+exports.groupByScope = groupByScope;
+exports.insertSiblingClauseAt = insertSiblingClauseAt;
+exports.isComparisonOp = isComparisonOp;
+exports.isPlaceholderForOp = isPlaceholderForOp;
+exports.isWrappedInNot = isWrappedInNot;
+exports.issuesAt = issuesAt;
+exports.lookup = lookup;
+exports.mountEffectsEditor = mountEffectsEditor;
+exports.mountExpressionEditor = mountExpressionEditor;
+exports.moveAt = moveAt;
+exports.moveChildInContainer = moveChildInContainer;
+exports.needsParens = needsParens;
+exports.notNode = notNode;
+exports.numLit = numLit;
+exports.opSwapGroup = opSwapGroup;
+exports.pathKey = pathKey;
+exports.placeholderForOp = placeholderForOp;
+exports.redirectDeleteForPlaceholderSibling = redirectDeleteForPlaceholderSibling;
+exports.refOf = refOf;
+exports.removeArgAt = removeArgAt;
+exports.removeAt = removeAt;
+exports.renderConditionPreview = renderConditionPreview;
+exports.renderEffectsPreview = renderEffectsPreview;
+exports.scopedVar = scopedVar;
+exports.searchCatalogue = searchCatalogue;
+exports.seedValueSrc = seedValueSrc;
+exports.setArgAt = setArgAt;
+exports.setNodeAt = setNodeAt;
+exports.strLit = strLit;
+exports.toggleContainerNot = toggleContainerNot;
+exports.toggleNotAt = toggleNotAt;
+exports.updateAt = updateAt;
+exports.validateSource = validateSource;
+exports.valueWizard = valueWizard;
+exports.wrapInNotAt = wrapInNotAt;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map