tiptap-model-language 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1725 @@
+'use strict';
+
+var modelLanguage = require('model-language');
+var dateFns = require('date-fns');
+var core = require('@tiptap/core');
+var state = require('@tiptap/pm/state');
+var view = require('@tiptap/pm/view');
+var react$1 = require('@tiptap/react');
+var suggestion = require('@tiptap/suggestion');
+var tippy = require('tippy.js');
+var react = require('react');
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var tippy__default = /*#__PURE__*/_interopDefault(tippy);
+
+// src/index.ts
+
+// src/schema/namespaces.ts
+var CONTACT_NAMESPACE_KEY = "contact";
+var FLOW_NAMESPACE_KEY = "flow";
+var STATIC_NAMESPACES = [
+  {
+    key: "system",
+    label: "System",
+    fields: [
+      { key: "now", type: "datetime", label: "Current date/time" },
+      { key: "timezone", type: "string", label: "Timezone" }
+    ]
+  },
+  {
+    key: "conversation",
+    label: "Conversation",
+    fields: [
+      { key: "id", type: "string", label: "Conversation ID" },
+      { key: "integrationId", type: "string", label: "Integration ID" },
+      { key: "title", type: "string", label: "Title" },
+      { key: "unreadCount", type: "number", label: "Unread count" }
+    ]
+  },
+  {
+    key: "organisation",
+    label: "Organisation",
+    fields: [
+      { key: "id", type: "string", label: "Org ID" },
+      { key: "name", type: "string", label: "Name" },
+      { key: "website", type: "string", label: "Website" },
+      { key: "phone", type: "string", label: "Phone" },
+      { key: "email", type: "string", label: "Email" },
+      { key: "description", type: "string", label: "Description" }
+    ]
+  },
+  {
+    key: "lastMessage",
+    label: "Last message",
+    fields: [
+      { key: "text", type: "string", label: "Text" },
+      { key: "deliveryStatus", type: "string", label: "Delivery status" }
+    ]
+  }
+];
+var DATE_FORMATS = [
+  "yyyy-MM-dd",
+  "MMM d, yyyy",
+  "HH:mm",
+  "h:mm A",
+  "EEEE"
+];
+var ML_FILTERS = [
+  // text (string / enum)
+  {
+    name: "default",
+    hint: "Fallback when empty",
+    argTemplate: ': "there"',
+    inputs: "any"
+  },
+  {
+    name: "upper",
+    hint: "UPPERCASE",
+    inputs: ["string", "enum"],
+    output: "string"
+  },
+  {
+    name: "lower",
+    hint: "lowercase",
+    inputs: ["string", "enum"],
+    output: "string"
+  },
+  {
+    name: "capitalize",
+    hint: "Capitalise first letter",
+    inputs: ["string", "enum"],
+    output: "string"
+  },
+  {
+    name: "trim",
+    hint: "Trim whitespace",
+    inputs: ["string"],
+    output: "string"
+  },
+  {
+    name: "truncate",
+    hint: "Shorten to N chars",
+    argTemplate: ": 40",
+    inputs: ["string"],
+    output: "string"
+  },
+  {
+    name: "replace",
+    hint: "Replace text",
+    argTemplate: ': "a", "b"',
+    inputs: ["string"],
+    output: "string"
+  },
+  // number
+  {
+    name: "round",
+    hint: "Round to N decimals",
+    argTemplate: ": 2",
+    inputs: ["number"],
+    output: "number"
+  },
+  { name: "floor", hint: "Round down", inputs: ["number"], output: "number" },
+  { name: "ceil", hint: "Round up", inputs: ["number"], output: "number" },
+  { name: "abs", hint: "Absolute value", inputs: ["number"], output: "number" },
+  {
+    name: "percent",
+    hint: "Format as a percentage",
+    inputs: ["number"],
+    output: "string"
+  },
+  {
+    name: "currency",
+    hint: "Format as currency",
+    argTemplate: ': "USD"',
+    inputs: ["number"],
+    output: "string"
+  },
+  // datetime
+  {
+    name: "date",
+    hint: 'Format a date, e.g. "HH:mm"',
+    argTemplate: ': "MMM d, yyyy"',
+    inputs: ["datetime"],
+    output: "string"
+  },
+  {
+    name: "days_ago",
+    hint: "Whole days since (number)",
+    inputs: ["datetime"],
+    output: "number"
+  },
+  {
+    name: "days_until",
+    hint: "Whole days until (number)",
+    inputs: ["datetime"],
+    output: "number"
+  },
+  {
+    name: "is_past",
+    hint: "True if in the past",
+    inputs: ["datetime"],
+    output: "boolean"
+  },
+  {
+    name: "is_future",
+    hint: "True if in the future",
+    inputs: ["datetime"],
+    output: "boolean"
+  },
+  // array
+  {
+    name: "count",
+    hint: "Number of items",
+    inputs: ["array"],
+    output: "number"
+  },
+  {
+    name: "join",
+    hint: "Join a list",
+    argTemplate: ': ", "',
+    inputs: ["array"],
+    output: "string"
+  },
+  { name: "first", hint: "First item", inputs: ["array"] },
+  { name: "last", hint: "Last item", inputs: ["array"] },
+  {
+    name: "limit",
+    hint: "Keep the first N",
+    argTemplate: ": 3",
+    inputs: ["array"],
+    output: "array"
+  },
+  {
+    name: "pluck",
+    hint: "Pull one field from each",
+    argTemplate: ': "name"',
+    inputs: ["array"],
+    output: "array"
+  },
+  {
+    name: "where",
+    hint: "Filter a list",
+    argTemplate: ': "status", "==", "open"',
+    inputs: ["array"],
+    output: "array"
+  },
+  {
+    name: "sort",
+    hint: "Sort a list",
+    argTemplate: ': "field"',
+    inputs: ["array"],
+    output: "array"
+  },
+  { name: "sum", hint: "Sum a list", inputs: ["array"], output: "number" },
+  { name: "max", hint: "Largest", inputs: ["array"], output: "number" },
+  { name: "min", hint: "Smallest", inputs: ["array"], output: "number" }
+];
+var DIRECTIVE_RE = /^(#|\/[a-z]|(?:if|elseif|else|for|end|include)\b)/i;
+function splitPipes(inner) {
+  const out = [];
+  let cur = "";
+  let quote = null;
+  for (const ch of inner) {
+    if (quote) {
+      cur += ch;
+      if (ch === quote) quote = null;
+    } else if (ch === '"' || ch === "'") {
+      quote = ch;
+      cur += ch;
+    } else if (ch === "|") {
+      out.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  out.push(cur);
+  return out;
+}
+function parseModelToken(inner) {
+  const trimmed = inner.trim();
+  const directive = DIRECTIVE_RE.test(trimmed);
+  const parts = splitPipes(inner);
+  const path = (parts[0] ?? "").trim();
+  const dot = path.indexOf(".");
+  const filters = parts.slice(1).map((p) => {
+    const seg = p.trim();
+    const colon = seg.indexOf(":");
+    return colon < 0 ? { name: seg, args: "" } : { name: seg.slice(0, colon).trim(), args: seg.slice(colon + 1).trim() };
+  });
+  return {
+    path,
+    namespace: dot < 0 ? path : path.slice(0, dot),
+    field: dot < 0 ? "" : path.slice(dot + 1),
+    filters,
+    directive
+  };
+}
+
+// src/autocomplete/options.ts
+var COMMON_TZ = [
+  "UTC",
+  "Europe/Kyiv",
+  "Europe/London",
+  "Europe/Berlin",
+  "Europe/Paris",
+  "America/New_York",
+  "America/Los_Angeles",
+  "Asia/Dubai",
+  "Asia/Tokyo"
+];
+function previewDateFormat(token) {
+  const t = token.replace(/\[([^\]]*)\]/g, "'$1'").replace(/YYYY/g, "yyyy").replace(/YY/g, "yy").replace(/DD/g, "dd").replace(/dddd/g, "EEEE").replace(/ddd/g, "EEE").replace(/A/g, "a");
+  try {
+    return dateFns.format(/* @__PURE__ */ new Date(), t);
+  } catch {
+    return "";
+  }
+}
+function timezoneOptions(frag) {
+  let zones = [];
+  try {
+    zones = Intl.supportedValuesOf?.("timeZone") ?? [];
+  } catch {
+    zones = [];
+  }
+  if (!zones.length) zones = COMMON_TZ;
+  const q = frag.toLowerCase();
+  return zones.filter((z) => !q || z.toLowerCase().includes(q));
+}
+function resolveType(namespaces, expr) {
+  const parts = expr.split("|").map((s) => s.trim()).filter(Boolean);
+  if (!parts.length) return "any";
+  let type = "any";
+  const f = findField(namespaces, parts[0]);
+  if (f) type = f.type;
+  for (let i = 1; i < parts.length; i++) {
+    const meta = ML_FILTERS.find(
+      (x) => x.name === parts[i].split(":")[0].trim()
+    );
+    if (meta?.output) type = meta.output;
+  }
+  return type;
+}
+function filterApplies(f, type) {
+  if (f.inputs === "any" || type === "any") return true;
+  const t = type === "enum" ? "string" : type;
+  return f.inputs.includes(t);
+}
+function findField(namespaces, path) {
+  const dot = path.indexOf(".");
+  if (dot < 0) return void 0;
+  const ns = namespaces.find((n) => n.key === path.slice(0, dot));
+  return ns?.fields.find((f) => f.key === path.slice(dot + 1));
+}
+function fieldMatches(namespaces, frag) {
+  const out = [];
+  const q = frag.toLowerCase();
+  for (const ns of namespaces) {
+    for (const f of ns.fields) {
+      const path = `${ns.key}.${f.key}`;
+      if (q && !path.toLowerCase().includes(q) && !f.label.toLowerCase().includes(q))
+        continue;
+      out.push({ path, f });
+    }
+  }
+  return out;
+}
+function operatorOptions(lead, path, f) {
+  const g = { group: "Operator", kind: "block", hint: `${f.type}` };
+  const valOp = (op) => ({
+    ...g,
+    insert: f.values?.length ? `${lead}${path} ${op} ` : `${lead}${path} ${op} ""`,
+    label: f.values?.length ? `${op} \u2026` : `${op} "\u2026"`,
+    close: false
+  });
+  const notValOp = (op) => ({
+    ...g,
+    insert: `${lead}not ${path} ${op} ""`,
+    label: `not ${op} "\u2026"`,
+    close: false
+  });
+  const listOp = (op) => ({
+    ...g,
+    insert: `${lead}${path} ${op} [""]`,
+    label: `${op} [\u2026]`,
+    close: false
+  });
+  const arrValOp = (op) => ({
+    ...g,
+    insert: `${lead}${path} ${op} [`,
+    label: `${op} [\u2026]`,
+    close: false
+  });
+  const numOp = (op) => ({
+    ...g,
+    insert: `${lead}${path} ${op} `,
+    label: `${op} \u2026`,
+    close: false
+  });
+  const bare = (op) => ({
+    ...g,
+    insert: `${lead}${path} ${op} `,
+    label: op,
+    close: false
+  });
+  const notBare = (op) => ({
+    ...g,
+    insert: `${lead}not ${path} ${op} `,
+    label: `not ${op}`,
+    close: false
+  });
+  const dateFilter = (name, tail = "") => ({
+    ...g,
+    insert: `${lead}${path} | ${name}${tail}`,
+    label: `| ${name}${tail}`,
+    close: false
+  });
+  switch (f.type) {
+    case "boolean":
+      return [
+        { ...g, insert: `${lead}${path}`, label: "is true", close: true },
+        { ...g, insert: `${lead}not ${path}`, label: "is false", close: true }
+      ];
+    case "number":
+      return [
+        numOp("=="),
+        numOp("!="),
+        numOp(">"),
+        numOp("<"),
+        numOp(">="),
+        numOp("<="),
+        listOp("in"),
+        bare("exists"),
+        notBare("exists")
+      ];
+    case "datetime":
+      return [
+        dateFilter("is_past"),
+        dateFilter("is_future"),
+        dateFilter("days_ago", " > 30"),
+        dateFilter("days_until", " < 30"),
+        bare("exists"),
+        notBare("exists")
+      ];
+    case "array":
+      return [
+        valOp("contains"),
+        notValOp("contains"),
+        arrValOp("contains_any"),
+        arrValOp("contains_all"),
+        bare("is_empty"),
+        notBare("is_empty"),
+        bare("exists")
+      ];
+    case "enum":
+      return [
+        valOp("=="),
+        valOp("!="),
+        arrValOp("in"),
+        bare("exists"),
+        notBare("exists")
+      ];
+    default:
+      return [
+        valOp("=="),
+        valOp("!="),
+        valOp("contains"),
+        notValOp("contains"),
+        valOp("startsWith"),
+        valOp("endsWith"),
+        valOp("matches"),
+        listOp("in"),
+        bare("is_empty"),
+        bare("exists"),
+        notBare("exists")
+      ];
+  }
+}
+var BLOCK_SNIPPETS = [
+  { insert: "if ", label: "if \u2026", hint: "condition block", close: false },
+  {
+    insert: "elseif ",
+    label: "elseif \u2026",
+    hint: "another branch",
+    close: false
+  },
+  { insert: "else", label: "else", hint: "fallback branch", close: true },
+  { insert: "/if", label: "/if", hint: "close the if block", close: true },
+  {
+    insert: "for item in ",
+    label: "for \u2026 in \u2026",
+    hint: "loop over a list",
+    close: false
+  },
+  { insert: "/for", label: "/for", hint: "close the for loop", close: true },
+  {
+    insert: "#priority ",
+    label: "#priority \u2026",
+    hint: "set priority level",
+    close: false
+  },
+  {
+    insert: "/priority",
+    label: "/priority",
+    hint: "close the priority block",
+    close: true
+  },
+  {
+    insert: 'include "signature"',
+    label: "include \u2026",
+    hint: "reusable snippet",
+    close: true
+  }
+];
+function buildModelOptions(namespaces, query) {
+  const pipe = query.lastIndexOf("|");
+  if (pipe >= 0) {
+    const left = query.slice(0, pipe).trim();
+    const seg = query.slice(pipe + 1);
+    const dateTz = seg.match(/^\s*date\s*:\s*"([^"]*)"\s*,\s*"?([^"]*)$/i);
+    if (dateTz) {
+      const [, fmt, tzFrag] = dateTz;
+      return timezoneOptions(tzFrag).map((z) => ({
+        insert: `${left} | date: "${fmt}", "${z}"`,
+        label: z,
+        hint: "timezone",
+        group: "Timezone",
+        kind: "filter",
+        close: true
+      }));
+    }
+    const dateArg = seg.match(/^\s*date\s*:\s*"?([^"]*)$/i);
+    if (dateArg) {
+      const dq = dateArg[1].toLowerCase();
+      return DATE_FORMATS.filter(
+        (d) => !dq || d.toLowerCase().includes(dq)
+      ).map((d) => {
+        const eg = previewDateFormat(d);
+        return {
+          insert: `${left} | date: "${d}"`,
+          label: `"${d}"`,
+          // Show what the token renders as right now, e.g. "Jul 6, 2026".
+          hint: eg ? `e.g. ${eg}` : "date/time format",
+          group: "Date format",
+          kind: "filter",
+          close: true
+        };
+      });
+    }
+    const defArg = seg.match(/^\s*default\s*:\s*(.*)$/i);
+    if (defArg) {
+      const field = findField(namespaces, left.split("|")[0].trim());
+      const dtype = resolveType(namespaces, left);
+      const frag = defArg[1].trim().replace(/^"|"$/g, "").toLowerCase();
+      const mk = (val, label) => ({
+        insert: `${left} | default: ${val}`,
+        label,
+        hint: "default value",
+        group: "Default",
+        kind: "filter",
+        close: true
+      });
+      if (field?.values?.length)
+        return field.values.filter((v) => !frag || v.toLowerCase().includes(frag)).map((v) => mk(`"${v}"`, `"${v}"`));
+      if (dtype === "boolean")
+        return [mk("true", "true"), mk("false", "false")].filter(
+          (o) => !frag || o.label.toLowerCase().includes(frag)
+        );
+      if (dtype === "number") return [mk("0", "0")];
+      return [mk('""', '"\u2026"')];
+    }
+    const fq = seg.trim().toLowerCase();
+    const type = resolveType(namespaces, left);
+    const inCondition = /^(if|elseif)\s/i.test(query);
+    return ML_FILTERS.filter(
+      (f) => (!fq || f.name.includes(fq)) && filterApplies(f, type) && (!inCondition || f.output === "boolean" || f.output === "number")
+    ).map((f) => ({
+      insert: f.name === "date" ? `${left} | date: ` : f.name === "default" ? `${left} | default: ` : `${left} | ${f.name}${f.argTemplate ?? ""}`,
+      label: `| ${f.name}`,
+      hint: f.hint,
+      group: "Filters",
+      kind: "filter",
+      close: f.name !== "date" && f.name !== "default"
+    }));
+  }
+  const prm = query.match(/^#priority\s+(\w*)$/i);
+  if (prm) {
+    const pq = prm[1].toLowerCase();
+    return ["high", "medium", "low"].filter((l) => !pq || l.startsWith(pq)).map((l) => ({
+      insert: `#priority ${l}`,
+      label: l,
+      hint: "priority level",
+      group: "Priority",
+      kind: "block",
+      close: true
+    }));
+  }
+  const cm = query.match(/^(if|elseif)\s+(.*)$/i);
+  if (cm) {
+    const kw = cm[1].toLowerCase();
+    const rest = cm[2];
+    const conn = rest.match(/^(.*\b(?:and|or)\s+)(.*)$/i);
+    const prefix = conn ? conn[1] : "";
+    let clause = conn ? conn[2] : rest;
+    let lead = `${kw} ${prefix}`;
+    const negate = clause.match(/^(not\s+)(.*)$/i);
+    if (negate) {
+      lead += negate[1];
+      clause = negate[2];
+    }
+    if (/(?:"[^"]*"|\]|\b(?:exists|is_empty|is_past|is_future)\b|>\s*\d|\d)\s+$/i.test(
+      clause
+    )) {
+      const cur = `${kw} ${rest.trim()}`;
+      return [
+        {
+          insert: `${cur} and `,
+          label: "and",
+          hint: "both must match",
+          group: "Connector",
+          kind: "block",
+          close: false
+        },
+        {
+          insert: `${cur} or `,
+          label: "or",
+          hint: "either matches",
+          group: "Connector",
+          kind: "block",
+          close: false
+        },
+        {
+          insert: cur,
+          label: "\xB7 finish \xB7",
+          hint: "close the condition",
+          group: "Connector",
+          kind: "block",
+          close: true
+        }
+      ];
+    }
+    const am = clause.match(
+      /^([\w.]+)\s+(in|contains_any|contains_all)\s+\[([^\]]*)$/
+    );
+    if (am) {
+      const f = findField(namespaces, am[1]);
+      if (!f?.values?.length) return [];
+      const body = am[3];
+      const picked = [...body.matchAll(/"([^"]*)"/g)].map((x) => x[1]);
+      const fragMatch = body.match(/(?:^|,)\s*"?([^",\]]*)$/);
+      const frag = (fragMatch ? fragMatch[1] : "").toLowerCase();
+      const prefix2 = picked.map((v) => `"${v}"`).join(", ");
+      const open = `${lead}${am[1]} ${am[2]} [${prefix2}${prefix2 ? ", " : ""}`;
+      const opts2 = f.values.filter(
+        (v) => !picked.includes(v) && (!frag || v.toLowerCase().includes(frag))
+      ).map((v) => ({
+        insert: `${open}"${v}", `,
+        label: `"${v}"`,
+        hint: f.label,
+        group: "Value",
+        kind: "block",
+        close: false
+      }));
+      if (picked.length)
+        opts2.push({
+          insert: `${lead}${am[1]} ${am[2]} [${prefix2}] `,
+          label: "\xB7 done \xB7",
+          hint: "close the list",
+          group: "Value",
+          kind: "block",
+          close: false
+        });
+      return opts2;
+    }
+    const vm = clause.match(/^([\w.]+)\s+(==|!=|contains)\s+"?([^"]*)$/);
+    if (vm) {
+      const f = findField(namespaces, vm[1]);
+      if (f?.values?.length) {
+        const vq = vm[3].toLowerCase();
+        return f.values.filter((v) => !vq || v.toLowerCase().includes(vq)).map((v) => ({
+          insert: `${lead}${vm[1]} ${vm[2]} "${v}" `,
+          label: `"${v}"`,
+          hint: f.label,
+          group: "Value",
+          kind: "block",
+          close: false
+        }));
+      }
+      return [];
+    }
+    const om = clause.match(/^([\w.]+)\s+([^\s]*)$/);
+    if (om) {
+      const f = findField(namespaces, om[1]);
+      if (!f) return [];
+      const of = om[2].toLowerCase();
+      return operatorOptions(lead, om[1], f).filter(
+        (o) => !of || o.label.toLowerCase().includes(of)
+      );
+    }
+    const pm = clause.match(/^([\w.]*)$/);
+    if (pm) {
+      return fieldMatches(namespaces, pm[1]).map(({ path, f }) => ({
+        insert: `${lead}${path} `,
+        label: path,
+        hint: `${f.label} \xB7 ${f.type}`,
+        group: "Field",
+        kind: "path",
+        close: false
+      }));
+    }
+    return [];
+  }
+  const fm = query.match(/^for\s+\w+\s+in\s+([\w.]*)$/i);
+  if (fm) {
+    return fieldMatches(namespaces, fm[1]).map(({ path, f }) => ({
+      insert: `for item in ${path}`,
+      label: path,
+      hint: `${f.label} \xB7 ${f.type}`,
+      group: "Loop over",
+      kind: "path",
+      close: true
+    }));
+  }
+  const bv = query.match(/^([\w.]+)\s+$/);
+  if (bv) {
+    const f = findField(namespaces, bv[1]);
+    if (f) {
+      const out = [
+        {
+          insert: bv[1],
+          label: "\xB7 insert \xB7",
+          hint: "use as-is",
+          group: "Finish",
+          kind: "block",
+          close: true
+        }
+      ];
+      for (const flt of ML_FILTERS.filter((x) => filterApplies(x, f.type))) {
+        out.push({
+          insert: flt.name === "date" ? `${bv[1]} | date: ` : flt.name === "default" ? `${bv[1]} | default: ` : `${bv[1]} | ${flt.name}${flt.argTemplate ?? ""}`,
+          label: `| ${flt.name}`,
+          hint: flt.hint,
+          group: "Filters",
+          kind: "filter",
+          close: flt.name !== "date" && flt.name !== "default"
+        });
+      }
+      return out;
+    }
+  }
+  const q = query.trim().toLowerCase();
+  const opts = [];
+  for (const b of BLOCK_SNIPPETS) {
+    if (q && !b.label.toLowerCase().includes(q) && !b.insert.toLowerCase().includes(q))
+      continue;
+    opts.push({ ...b, group: "Blocks", kind: "block" });
+  }
+  for (const { path, f } of fieldMatches(namespaces, query.trim())) {
+    opts.push({
+      insert: `${path} `,
+      label: path,
+      hint: f.values?.length ? `${f.label}: ${f.values.join(", ")}` : f.label,
+      group: "Variables",
+      kind: "path",
+      close: false
+    });
+  }
+  return opts;
+}
+function optionGroups(options) {
+  const seen = [];
+  for (const o of options) if (!seen.includes(o.group)) seen.push(o.group);
+  return seen;
+}
+function capOptions(options, perGroup = 8) {
+  const counts = /* @__PURE__ */ new Map();
+  return options.filter((o) => {
+    const n = counts.get(o.group) ?? 0;
+    if (n >= perGroup) return false;
+    counts.set(o.group, n + 1);
+    return true;
+  });
+}
+
+// src/core/types.ts
+var DEFAULT_LABELS = {
+  expectedOperator: "Expected an operator (e.g. ==, contains)",
+  unclosedBlock: (name) => `Unclosed, needs {{/${name}}}`,
+  noOpenBlock: (name) => `No open {{${name}}}`,
+  addDefault: "Add default",
+  changeTo: (operator) => `Change to ${operator}`,
+  addCloseTag: (tag) => `Add ${tag}`,
+  quickFix: "Quick fix",
+  noMatches: "No variables match.",
+  severity: { error: "error", warning: "warning", info: "info" }
+};
+function resolveLabels(overrides) {
+  return overrides ? { ...DEFAULT_LABELS, ...overrides } : DEFAULT_LABELS;
+}
+
+// src/display.ts
+function modelTokenDisplay(inner, namespaces) {
+  const p = parseModelToken(inner);
+  if (p.directive) return inner.trim();
+  const ns = namespaces.find((n) => n.key === p.namespace);
+  const field = ns?.fields.find((f) => f.key === p.field);
+  const base = field?.label ?? p.field ?? p.path;
+  const label = ns ? base : p.path;
+  return p.filters.length ? `${label} \xB7 ${p.filters.map((f) => f.name).join(" \xB7 ")}` : label;
+}
+function modelTokenTone(inner, namespaces) {
+  const p = parseModelToken(inner);
+  if (p.directive) return "directive";
+  if (p.namespace === "flow" || p.namespace === "contact") return "value";
+  const ns = namespaces.find((n) => n.key === p.namespace);
+  if (!ns) return "unknown";
+  return ns.dynamic || ns.fields.some((f) => f.key === p.field) ? "value" : "unknown";
+}
+var key = new state.PluginKey("modelSyntax");
+function cn(...inputs) {
+  return tailwindMerge.twMerge(clsx.clsx(inputs));
+}
+var ModelTokenList = react.forwardRef(function ModelTokenList2({ items, command, emptyLabel }, ref) {
+  const [selected, setSelected] = react.useState(0);
+  react.useEffect(() => setSelected(0), [items]);
+  react.useImperativeHandle(
+    ref,
+    () => ({
+      onKeyDown: (event) => {
+        if (items.length === 0) return false;
+        if (event.key === "ArrowDown") {
+          setSelected((s) => (s + 1) % items.length);
+          return true;
+        }
+        if (event.key === "ArrowUp") {
+          setSelected((s) => (s - 1 + items.length) % items.length);
+          return true;
+        }
+        if (event.key === "Enter" || event.key === "Tab") {
+          if (items[selected]) {
+            command(items[selected]);
+            return true;
+          }
+        }
+        return false;
+      }
+    }),
+    [items, selected, command]
+  );
+  if (items.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-popover text-muted-foreground w-72 rounded-md border p-3 text-center text-xs shadow-md", children: emptyLabel ?? "No variables match." });
+  }
+  const grouped = optionGroups(items).map((g) => ({
+    group: g,
+    items: items.filter((o) => o.group === g)
+  }));
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "bg-popover text-popover-foreground max-h-72 w-80 overflow-y-auto rounded-md border p-1 shadow-md", children: grouped.map((section) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mb-1 last:mb-0", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-muted-foreground px-2 pt-1.5 pb-0.5 text-[10px] font-semibold tracking-wide uppercase", children: section.group }),
+    section.items.map((o) => {
+      const idx = items.indexOf(o);
+      const active = idx === selected;
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          type: "button",
+          onMouseDown: (e) => {
+            e.preventDefault();
+            command(o);
+          },
+          onMouseEnter: () => setSelected(idx),
+          className: cn(
+            "flex w-full items-start gap-2 rounded-sm px-2 py-1.5 text-left",
+            active && "bg-accent"
+          ),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                className: cn(
+                  "mt-1 size-1.5 shrink-0 rounded-full",
+                  o.kind === "block" ? "bg-violet-500" : o.kind === "filter" ? "bg-sky-500" : "bg-muted-foreground/50"
+                )
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "min-w-0 flex-1", children: [
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "block truncate font-mono text-xs", children: o.label }),
+              /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-muted-foreground block truncate text-[11px]", children: o.hint })
+            ] })
+          ]
+        },
+        o.insert
+      );
+    })
+  ] }, section.group)) });
+});
+
+// src/autocomplete/suggestion.ts
+function createSuggestionPlugin(deps) {
+  const { editor, ctx, onOpen, labels } = deps;
+  return suggestion.Suggestion({
+    editor,
+    char: "{{",
+    pluginKey: new state.PluginKey("modelSyntaxSuggestion"),
+    allowSpaces: true,
+    startOfLine: false,
+    decorationClass: "model-lang-suggestion",
+    findSuggestionMatch: ({ $position }) => {
+      const before = $position.doc.textBetween(
+        Math.max(0, $position.pos - 200),
+        $position.pos,
+        "\n",
+        "\0"
+      );
+      const mm = before.match(/\{\{([^}\n]*)$/);
+      if (!mm) return null;
+      if (((mm[1].match(/"/g) || []).length & 1) === 1) return null;
+      const start = $position.pos - (before.length - (mm.index ?? 0));
+      const docSize = $position.doc.content.size;
+      const after = $position.doc.textBetween(
+        $position.pos,
+        Math.min(docSize, $position.pos + 200),
+        "\n",
+        "\0"
+      );
+      const closedToken = after.match(/^[^{}\n]*\}\}/);
+      if (closedToken && !ctx.lastTrDocChanged && (ctx.lastTrSelectionMoved || !ctx.suggestionActive))
+        return null;
+      const wordTail = after.match(/^[\w.]*/);
+      const to = $position.pos + (wordTail ? wordTail[0].length : 0);
+      return { range: { from: start, to }, query: mm[1] ?? "", text: mm[0] };
+    },
+    items: ({ query }) => {
+      const st = key.getState(editor.state);
+      return capOptions(buildModelOptions(st?.namespaces ?? [], query));
+    },
+    command: ({ editor: editor2, range, props }) => {
+      const docSize = editor2.state.doc.content.size;
+      const tail = editor2.state.doc.textBetween(
+        range.to,
+        Math.min(docSize, range.to + 200),
+        "\n",
+        "\0"
+      );
+      const alreadyClosed = /^[^{}\n]*\}\}/.test(tail);
+      const needBraces = props.close && !alreadyClosed;
+      let content = needBraces ? `{{${props.insert}}}` : `{{${props.insert}`;
+      if (/^\s*("|\[|-?\d|true\b|false\b)/.test(tail))
+        content = content.replace(/\s*(?:""|\[""\])$/, "");
+      if (content.endsWith(" ") && tail.startsWith(" "))
+        content = content.slice(0, -1);
+      editor2.chain().focus().deleteRange(range).insertContent({ type: "text", text: content }).run();
+      const q = content.indexOf('""');
+      if (needBraces) {
+        if (q >= 0) editor2.commands.setTextSelection(range.from + q + 1);
+      } else {
+        editor2.commands.setTextSelection(
+          q >= 0 ? range.from + q + 1 : range.from + content.length
+        );
+      }
+    },
+    render: () => {
+      let component;
+      let popup;
+      const onScroll = (e) => {
+        const el = popup?.[0]?.popper;
+        if (el && e.target instanceof Node && el.contains(e.target)) return;
+        popup?.[0]?.hide();
+      };
+      return {
+        onStart: (props) => {
+          ctx.suggestionActive = true;
+          onOpen();
+          window.addEventListener("scroll", onScroll, true);
+          component = new react$1.ReactRenderer(ModelTokenList, {
+            props: {
+              items: props.items,
+              command: props.command,
+              emptyLabel: labels.noMatches
+            },
+            editor: props.editor
+          });
+          if (!props.clientRect) return;
+          popup = tippy__default.default("body", {
+            getReferenceClientRect: props.clientRect,
+            appendTo: () => document.body,
+            content: component.element,
+            showOnCreate: props.items.length > 0,
+            interactive: true,
+            trigger: "manual",
+            placement: "bottom-start",
+            popperOptions: {
+              modifiers: [
+                {
+                  name: "flip",
+                  options: {
+                    boundary: "viewport",
+                    fallbackPlacements: ["top-start", "bottom-start"],
+                    padding: 8
+                  }
+                },
+                {
+                  name: "preventOverflow",
+                  options: { boundary: "viewport", padding: 8 }
+                }
+              ]
+            }
+          });
+        },
+        onUpdate: (props) => {
+          component.updateProps({
+            items: props.items,
+            command: props.command,
+            emptyLabel: labels.noMatches
+          });
+          if (props.items.length === 0) popup?.[0]?.hide();
+          else popup?.[0]?.show();
+          if (props.clientRect) {
+            popup?.[0]?.setProps({
+              getReferenceClientRect: props.clientRect
+            });
+          }
+        },
+        onKeyDown: (props) => {
+          if (props.event.key === "Escape") {
+            popup?.[0]?.hide();
+            return true;
+          }
+          return component.ref?.onKeyDown(props.event) ?? false;
+        },
+        onExit: () => {
+          ctx.suggestionActive = false;
+          window.removeEventListener("scroll", onScroll, true);
+          popup?.[0]?.destroy();
+          component?.destroy();
+        }
+      };
+    }
+  });
+}
+
+// src/core/constants.ts
+var BRACE_CLASS = "text-muted-foreground/60";
+var DIAG_CLASS = {
+  error: "underline decoration-wavy decoration-red-500 underline-offset-2",
+  warning: "underline decoration-wavy decoration-amber-500 underline-offset-2",
+  info: "underline decoration-dotted decoration-sky-500 underline-offset-2"
+};
+var SEV_COLOR = {
+  error: "#ef4444",
+  warning: "#f59e0b",
+  info: "#0ea5e9"
+};
+var SEV_RANK = {
+  error: 3,
+  warning: 2,
+  info: 1
+};
+
+// src/validation/diagnostics.ts
+function diagnosticsByPath(diags) {
+  const m = /* @__PURE__ */ new Map();
+  for (const d of diags) {
+    if (!d.fieldPath) continue;
+    const prev = m.get(d.fieldPath);
+    if (!prev || SEV_RANK[d.severity] > SEV_RANK[prev.severity]) {
+      m.set(d.fieldPath, {
+        severity: d.severity,
+        message: d.message,
+        code: d.code
+      });
+    }
+  }
+  return m;
+}
+function addsDefault(d) {
+  return d.code === "ML210" || /\bdefault\b/i.test(d.message);
+}
+function defaultFilterFor(field) {
+  if (field?.values?.length) return ` | default: "${field.values[0]}"`;
+  switch (field?.type) {
+    case "number":
+      return " | default: 0";
+    case "boolean":
+      return " | default: false";
+    default:
+      return ' | default: ""';
+  }
+}
+var OPERATOR_WORDS = [
+  "contains",
+  "contains_any",
+  "contains_all",
+  "in",
+  "is_empty",
+  "exists",
+  "startsWith",
+  "endsWith",
+  "matches"
+];
+function suggestOperator(word) {
+  const w = word.toLowerCase();
+  if (!w) return null;
+  const hits = OPERATOR_WORDS.filter((o) => o.toLowerCase().startsWith(w));
+  if (!hits.length) return null;
+  return hits.sort((a, b) => a.length - b.length)[0];
+}
+
+// src/highlight/highlight.ts
+var HL_CLASS = {
+  keyword: "text-violet-600 dark:text-violet-400 font-medium",
+  // if / for / else
+  operator: "text-pink-600 dark:text-pink-400",
+  // == contains exists and or
+  math: "text-orange-600 dark:text-orange-400",
+  // + - * / ( )
+  string: "text-emerald-600 dark:text-emerald-400",
+  // "..."
+  number: "text-orange-500 dark:text-orange-300",
+  // 123 true false
+  filter: "text-teal-600 dark:text-teal-400",
+  // | default
+  func: "text-cyan-600 dark:text-cyan-400",
+  // calculate(
+  path: "text-sky-600 dark:text-sky-400",
+  // contact.first_name
+  punct: "text-muted-foreground"
+  // , : |
+};
+var KEYWORDS = /* @__PURE__ */ new Set(["if", "elseif", "else", "for", "end", "include"]);
+var WORD_OPS = /* @__PURE__ */ new Set([
+  "and",
+  "or",
+  "not",
+  "in",
+  "contains",
+  "contains_any",
+  "contains_all",
+  "is_empty",
+  "exists",
+  "startswith",
+  "endswith",
+  "matches"
+]);
+var LITERALS = /* @__PURE__ */ new Set(["true", "false", "null"]);
+var SCAN = /(\s+)|("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')|(\d+(?:\.\d+)?)|([#/]?[A-Za-z_][\w.]*)|(==|!=|<=|>=|[<>=])|(\|\||\||[-+*/()])|([,:])|(.)/y;
+function tokenizeExpression(s) {
+  const out = [];
+  SCAN.lastIndex = 0;
+  let afterPipe = false;
+  let m;
+  while (m = SCAN.exec(s)) {
+    const start = m.index;
+    const end = start + m[0].length;
+    if (end === start) {
+      SCAN.lastIndex++;
+      continue;
+    }
+    if (m[1]) continue;
+    let kind = "punct";
+    if (m[2]) kind = "string";
+    else if (m[3]) kind = "number";
+    else if (m[4]) {
+      const raw = m[4];
+      const lower = raw.toLowerCase();
+      if (raw[0] === "#" || raw[0] === "/") kind = "keyword";
+      else if (KEYWORDS.has(lower)) kind = "keyword";
+      else if (WORD_OPS.has(lower)) kind = "operator";
+      else if (LITERALS.has(lower)) kind = "number";
+      else if (afterPipe) kind = "filter";
+      else kind = /^\s*\(/.test(s.slice(end)) ? "func" : "path";
+    } else if (m[5]) kind = "operator";
+    else if (m[6]) {
+      if (m[0] === "|") {
+        out.push({ start, end, kind: "punct" });
+        afterPipe = true;
+        continue;
+      }
+      kind = m[0] === "||" ? "operator" : "math";
+    } else if (m[7]) kind = "punct";
+    out.push({ start, end, kind });
+    afterPipe = false;
+  }
+  return out;
+}
+
+// src/highlight/decorations.ts
+var TOKEN_RE = /\{\{[^{}]*\}\}/g;
+function buildDecorations(doc, st, opts) {
+  const { labels } = opts;
+  const show = (sev) => opts.severities.includes(sev);
+  const showErr = show("error");
+  const decos = [];
+  let flat = "";
+  const posAt = [];
+  let prevEnd = -1;
+  doc.descendants((node, pos) => {
+    if (!node.isText || !node.text) return;
+    if (prevEnd >= 0 && pos !== prevEnd) {
+      flat += "\n";
+      posAt.push(-1);
+    }
+    const text = node.text;
+    for (let k = 0; k < text.length; k++) {
+      flat += text[k];
+      posAt.push(pos + k);
+    }
+    prevEnd = pos + text.length;
+  });
+  const painter = {
+    paint(a, b, attrs) {
+      let from = -1;
+      let to = -1;
+      for (let i = a; i < b; i++) {
+        const p = posAt[i];
+        if (p < 0) {
+          if (from >= 0) decos.push(view.Decoration.inline(from, to, attrs));
+          from = -1;
+          continue;
+        }
+        if (from < 0) {
+          from = p;
+          to = p + 1;
+        } else if (p === to) {
+          to = p + 1;
+        } else {
+          decos.push(view.Decoration.inline(from, to, attrs));
+          from = p;
+          to = p + 1;
+        }
+      }
+      if (from >= 0) decos.push(view.Decoration.inline(from, to, attrs));
+    },
+    pos(i) {
+      for (let k = i; k < posAt.length; k++) if (posAt[k] >= 0) return posAt[k];
+      return doc.content.size;
+    }
+  };
+  const blocks = [];
+  TOKEN_RE.lastIndex = 0;
+  let m;
+  while (m = TOKEN_RE.exec(flat)) {
+    const start = m.index;
+    const end = start + m[0].length;
+    const rawInner = m[0].slice(2, -2);
+    const inner = rawInner.trim();
+    const parsed = parseModelToken(inner);
+    const innerStart = start + 2;
+    blocks.push({ start, end, inner });
+    if (parsed.namespace === "flow" && parsed.field) {
+      painter.paint(start, end, {
+        "data-card-id": parsed.field.split(".")[0]
+      });
+    }
+    painter.paint(start, start + 2, { class: BRACE_CLASS });
+    painter.paint(end - 2, end, { class: BRACE_CLASS });
+    for (const tok of tokenizeExpression(rawInner)) {
+      painter.paint(innerStart + tok.start, innerStart + tok.end, {
+        class: HL_CLASS[tok.kind]
+      });
+    }
+    const hasDefaultFilter = parsed.filters.some((f) => f.name === "default");
+    const fieldFor = (path) => {
+      const dot = path.indexOf(".");
+      if (dot < 0) return void 0;
+      const ns = st.namespaces.find((n) => n.key === path.slice(0, dot));
+      return ns?.fields.find((f) => f.key === path.slice(dot + 1));
+    };
+    for (const [fp, d] of st.byPath) {
+      if (!fp || !show(d.severity)) continue;
+      if ((parsed.directive || hasDefaultFilter) && addsDefault(d)) continue;
+      let idx = rawInner.indexOf(fp);
+      while (idx >= 0) {
+        const prev = rawInner[idx - 1];
+        const next = rawInner[idx + fp.length];
+        const bounded = (prev === void 0 || !/[\w.]/.test(prev)) && (next === void 0 || !/[\w.]/.test(next));
+        if (bounded) {
+          const attrs = {
+            class: DIAG_CLASS[d.severity],
+            "data-ml-error": d.message,
+            "data-ml-sev": d.severity,
+            "data-ml-code": d.code
+          };
+          if (addsDefault(d)) {
+            attrs["data-ml-fix-kind"] = "insert";
+            attrs["data-ml-fix-pos"] = String(
+              painter.pos(innerStart + idx + fp.length)
+            );
+            attrs["data-ml-fix-text"] = defaultFilterFor(fieldFor(fp));
+            attrs["data-ml-fix-label"] = labels.addDefault;
+          }
+          painter.paint(innerStart + idx, innerStart + idx + fp.length, attrs);
+        }
+        idx = rawInner.indexOf(fp, idx + fp.length);
+      }
+    }
+    if (showErr && /^(if|elseif)\b/i.test(inner)) {
+      const toks = tokenizeExpression(rawInner);
+      for (let i = 0; i + 2 < toks.length; i++) {
+        if (toks[i].kind === "path" && toks[i + 1].kind === "path") {
+          const bad = toks[i + 1];
+          const word = rawInner.slice(bad.start, bad.end);
+          const attrs = {
+            class: DIAG_CLASS.error,
+            "data-ml-error": labels.expectedOperator,
+            "data-ml-sev": "error",
+            "data-ml-code": "ML001"
+          };
+          const suggest = suggestOperator(word);
+          if (suggest) {
+            attrs["data-ml-fix-kind"] = "replace";
+            attrs["data-ml-fix-pos"] = String(
+              painter.pos(innerStart + bad.start)
+            );
+            attrs["data-ml-fix-end"] = String(
+              painter.pos(innerStart + bad.end)
+            );
+            attrs["data-ml-fix-text"] = suggest;
+            attrs["data-ml-fix-label"] = labels.changeTo(suggest);
+          }
+          painter.paint(innerStart + bad.start, innerStart + bad.end, attrs);
+        }
+      }
+    }
+  }
+  if (showErr) addBlockBalance(blocks, painter, labels);
+  return view.DecorationSet.create(doc, decos);
+}
+function addBlockBalance(blocks, painter, labels) {
+  const errAttrs = (msg, fix) => {
+    const a = {
+      class: DIAG_CLASS.error,
+      "data-ml-error": msg,
+      "data-ml-sev": "error",
+      "data-ml-code": "ML001"
+    };
+    return a;
+  };
+  const flagUnclosed = (s, boundary) => {
+    const tag = `{{/${s.close}}}`;
+    const a = {
+      class: DIAG_CLASS.error,
+      "data-ml-error": labels.unclosedBlock(s.close),
+      "data-ml-sev": "error",
+      "data-ml-code": "ML001",
+      "data-ml-fix-text": tag,
+      "data-ml-fix-label": labels.addCloseTag(tag)
+    };
+    if (boundary != null) {
+      a["data-ml-fix-kind"] = "insertLine";
+      a["data-ml-fix-pos"] = String(painter.pos(boundary));
+    } else {
+      a["data-ml-fix-kind"] = "append";
+    }
+    painter.paint(s.start, s.end, a);
+  };
+  const stack = [];
+  for (const b of blocks) {
+    let mm;
+    if (/^if\b/i.test(b.inner))
+      stack.push({ close: "if", start: b.start, end: b.start + 4 });
+    else if (/^for\b/i.test(b.inner))
+      stack.push({ close: "for", start: b.start, end: b.start + 5 });
+    else if (mm = b.inner.match(/^#(\w+)/))
+      stack.push({
+        close: mm[1].toLowerCase(),
+        start: b.start,
+        end: b.start + 2 + mm[0].length
+      });
+    else if (mm = b.inner.match(/^(elseif|else)\b/i)) {
+      const branchesFor = mm[1].toLowerCase() === "else";
+      let matched = false;
+      while (stack.length) {
+        const top = stack[stack.length - 1];
+        if (top.close === "if" || branchesFor && top.close === "for") {
+          matched = true;
+          break;
+        }
+        flagUnclosed(top, b.start);
+        stack.pop();
+      }
+      if (!matched)
+        painter.paint(b.start, b.end, errAttrs(labels.noOpenBlock("if")));
+    } else if (mm = b.inner.match(/^\/(\w+)/)) {
+      const name = mm[1].toLowerCase();
+      let idx = -1;
+      for (let k = stack.length - 1; k >= 0; k--)
+        if (stack[k].close === name) {
+          idx = k;
+          break;
+        }
+      if (idx === -1)
+        painter.paint(b.start, b.end, errAttrs(labels.noOpenBlock(name)));
+      else {
+        for (let k = stack.length - 1; k > idx; k--)
+          flagUnclosed(stack[k], b.start);
+        stack.length = idx;
+      }
+    }
+  }
+  for (const s of stack) flagUnclosed(s, null);
+}
+
+// src/schema/build-schema.ts
+function buildValidateSchema(namespaces, orgSchema) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const ns of namespaces)
+    for (const f of ns.fields)
+      byPath.set(`${ns.key}.${f.key}`, {
+        path: `${ns.key}.${f.key}`,
+        type: f.type,
+        values: f.values,
+        // Dynamic (flow) values are runtime — don't nag for a default on them.
+        nullable: ns.dynamic ? false : void 0,
+        name: f.label
+      });
+  for (const d of orgSchema) byPath.set(d.path, d);
+  return [...byPath.values()];
+}
+function createDiagnosticTooltip(deps) {
+  const { editor, ctx, labels } = deps;
+  let errTip;
+  let errEl = null;
+  let errTipInteractive = false;
+  let hoverTimer;
+  let hideTimer;
+  let ptrX = 0;
+  let ptrY = 0;
+  const setPointer = (x, y) => {
+    ptrX = x;
+    ptrY = y;
+  };
+  const cancelHide = () => {
+    if (hideTimer) clearTimeout(hideTimer);
+    hideTimer = void 0;
+  };
+  const hideError = () => {
+    cancelHide();
+    if (hoverTimer) clearTimeout(hoverTimer);
+    hoverTimer = void 0;
+    errTip?.destroy();
+    errTip = void 0;
+    errEl = null;
+    errTipInteractive = false;
+  };
+  const hideErrorSoon = () => {
+    cancelHide();
+    hideTimer = setTimeout(hideError, 500);
+  };
+  const applyFix = (kind, fixText, pos, end) => {
+    if (kind === "replace" && pos != null && end != null) {
+      editor.chain().focus().insertContentAt({ from: pos, to: end }, fixText).run();
+      return;
+    }
+    if (kind === "insertLine" && pos != null) {
+      const hasBreak2 = !!editor.schema.nodes.hardBreak;
+      const content2 = hasBreak2 ? [{ type: "text", text: fixText }, { type: "hardBreak" }] : `${fixText}
+`;
+      editor.chain().focus().insertContentAt(pos, content2).run();
+      return;
+    }
+    if (kind === "insert" && pos != null) {
+      editor.chain().focus().insertContentAt(pos, fixText).run();
+      const q = fixText.indexOf('""');
+      if (q >= 0) editor.commands.setTextSelection(pos + q + 1);
+      return;
+    }
+    const docEnd = editor.state.doc.content.size;
+    const hasBreak = !!editor.schema.nodes.hardBreak;
+    const content = hasBreak ? [{ type: "hardBreak" }, { type: "text", text: fixText }] : `
+${fixText}`;
+    editor.chain().focus("end").insertContentAt(docEnd, content).run();
+  };
+  const renderError = (el) => {
+    const x = ptrX;
+    const y = ptrY;
+    const msg = el.getAttribute("data-ml-error");
+    if (!msg) return;
+    const sev = el.getAttribute("data-ml-sev") ?? "error";
+    const code = el.getAttribute("data-ml-code") ?? "";
+    const fixKind = el.getAttribute("data-ml-fix-kind");
+    const fixText = el.getAttribute("data-ml-fix-text");
+    const fixLabel = el.getAttribute("data-ml-fix-label");
+    const fixPosAttr = el.getAttribute("data-ml-fix-pos");
+    const fixEndAttr = el.getAttribute("data-ml-fix-end");
+    const fix = !!fixKind && !!fixText;
+    const color = SEV_COLOR[sev] ?? SEV_COLOR.error;
+    const box = document.createElement("div");
+    box.style.cssText = "background:#18181b;color:#e4e4e7;border:1px solid #3f3f46;border-radius:8px;padding:7px 10px;box-shadow:0 8px 24px rgba(0,0,0,.5);font-size:12px;line-height:1.4;max-width:300px";
+    const head = document.createElement("div");
+    head.style.cssText = "display:flex;gap:7px;align-items:center;margin-bottom:2px";
+    const sevEl = document.createElement("span");
+    sevEl.textContent = labels.severity[sev] ?? sev;
+    sevEl.style.cssText = `font-size:10px;font-weight:700;text-transform:uppercase;letter-spacing:.03em;color:${color}`;
+    head.appendChild(sevEl);
+    if (code) {
+      const codeEl = document.createElement("span");
+      codeEl.textContent = code;
+      codeEl.style.cssText = "font-family:ui-monospace,monospace;font-size:10.5px;color:#71717a";
+      head.appendChild(codeEl);
+    }
+    const bodyEl = document.createElement("div");
+    bodyEl.textContent = msg;
+    box.appendChild(head);
+    box.appendChild(bodyEl);
+    if (fix) {
+      const btn = document.createElement("button");
+      btn.type = "button";
+      btn.textContent = fixLabel ?? labels.quickFix;
+      btn.style.cssText = "margin-top:7px;padding:3px 9px;border-radius:6px;border:1px solid #3f3f46;background:#27272a;color:#93c5fd;font-size:11px;font-weight:500;cursor:pointer";
+      btn.addEventListener("mousedown", (e) => {
+        e.preventDefault();
+        applyFix(
+          fixKind,
+          fixText,
+          fixPosAttr != null ? Number(fixPosAttr) : void 0,
+          fixEndAttr != null ? Number(fixEndAttr) : void 0
+        );
+        hideError();
+      });
+      box.appendChild(btn);
+    }
+    errTip?.destroy();
+    errTipInteractive = true;
+    errTip = tippy__default.default(document.body, {
+      getReferenceClientRect: () => ({
+        width: 0,
+        height: 0,
+        x,
+        y,
+        top: y,
+        bottom: y,
+        left: x,
+        right: x
+      }),
+      content: box,
+      showOnCreate: true,
+      trigger: "manual",
+      placement: "bottom-start",
+      offset: [0, 8],
+      maxWidth: "none",
+      appendTo: () => document.body,
+      interactive: true,
+      interactiveBorder: 32
+    });
+    errTip.popper.addEventListener("mouseenter", cancelHide);
+    errTip.popper.addEventListener("mouseleave", hideError);
+  };
+  const scheduleError = (target, x, y) => {
+    ptrX = x;
+    ptrY = y;
+    const el = target?.closest?.("[data-ml-error]") ?? null;
+    if (el === errEl) {
+      cancelHide();
+      return;
+    }
+    if (!el) {
+      if (errTip && errTipInteractive) hideErrorSoon();
+      else hideError();
+      return;
+    }
+    hideError();
+    errEl = el;
+    if (ctx.suggestionActive) return;
+    hoverTimer = setTimeout(() => renderError(el), 900);
+  };
+  const handleEditorMouseLeave = () => {
+    if (errTip && errTipInteractive) hideErrorSoon();
+    else hideError();
+  };
+  return { scheduleError, setPointer, hideError, handleEditorMouseLeave };
+}
+function runValidation(editor, options, storage) {
+  const { skipValidation, debounceMs, onResult, translateDiagnostic } = options;
+  if (storage.timer) clearTimeout(storage.timer);
+  if (skipValidation) return;
+  storage.timer = setTimeout(() => {
+    if (!editor || editor.isDestroyed) return;
+    const template = editor.getText({ blockSeparator: "\n" });
+    const push = (byPath) => {
+      if (editor.isDestroyed) return;
+      editor.view.dispatch(editor.state.tr.setMeta(key, { byPath }));
+    };
+    const schema = key.getState(editor.state)?.schema ?? [];
+    if (!schema.length || !template.includes("{{")) {
+      push(/* @__PURE__ */ new Map());
+      onResult?.({ diagnostics: [], maxTokenEstimate: null });
+      return;
+    }
+    let result;
+    try {
+      result = modelLanguage.validate(template, schema);
+    } catch {
+      return;
+    }
+    const diagnostics = result.diagnostics.map((d) => {
+      const base = {
+        code: d.code,
+        severity: d.severity,
+        message: d.message,
+        fieldPath: d.fieldPath ?? null
+      };
+      return { ...base, message: translateDiagnostic?.(base) ?? base.message };
+    });
+    push(diagnosticsByPath(diagnostics));
+    onResult?.({ diagnostics, maxTokenEstimate: result.maxTokenEstimate });
+  }, debounceMs);
+}
+
+// src/extension.ts
+var ModelSyntax = core.Extension.create({
+  name: "modelSyntax",
+  addOptions() {
+    return {
+      namespaces: [],
+      schema: [],
+      skipValidation: false,
+      debounceMs: 300,
+      severities: ["error", "warning", "info"],
+      labels: {},
+      translateDiagnostic: void 0,
+      onResult: void 0
+    };
+  },
+  addStorage() {
+    return { timer: null };
+  },
+  addCommands() {
+    return {
+      setModelData: ({ namespaces, schema }) => ({ tr, dispatch, editor }) => {
+        if (dispatch) {
+          dispatch(
+            tr.setMeta(key, {
+              namespaces,
+              schema: buildValidateSchema(namespaces, schema ?? [])
+            })
+          );
+          runValidation(editor, this.options, this.storage);
+        }
+        return true;
+      }
+    };
+  },
+  onCreate() {
+    runValidation(this.editor, this.options, this.storage);
+  },
+  onUpdate({ transaction }) {
+    if (!transaction.docChanged) return;
+    runValidation(this.editor, this.options, this.storage);
+  },
+  onDestroy() {
+    if (this.storage.timer) clearTimeout(this.storage.timer);
+  },
+  addProseMirrorPlugins() {
+    const labels = resolveLabels(this.options.labels);
+    const severities = this.options.severities;
+    const initialNamespaces = this.options.namespaces;
+    const initialSchema = buildValidateSchema(
+      this.options.namespaces,
+      this.options.schema
+    );
+    const ctx = {
+      lastTrDocChanged: false,
+      lastTrSelectionMoved: false,
+      suggestionActive: false
+    };
+    const tooltip = createDiagnosticTooltip({
+      editor: this.editor,
+      ctx,
+      labels
+    });
+    const main = new state.Plugin({
+      key,
+      state: {
+        init: () => ({
+          namespaces: initialNamespaces,
+          schema: initialSchema,
+          byPath: /* @__PURE__ */ new Map()
+        }),
+        apply(tr, value, oldState, newState) {
+          ctx.lastTrDocChanged = tr.docChanged;
+          ctx.lastTrSelectionMoved = !oldState.selection.eq(newState.selection);
+          const meta = tr.getMeta(key);
+          return meta ? { ...value, ...meta } : value;
+        }
+      },
+      props: {
+        decorations(state) {
+          const st = key.getState(state);
+          return st ? buildDecorations(state.doc, st, { severities, labels }) : view.DecorationSet.empty;
+        },
+        handleDOMEvents: {
+          mousemove: (_view, event) => {
+            tooltip.setPointer(event.clientX, event.clientY);
+            return false;
+          },
+          mouseover: (_view, event) => {
+            const target = event.target;
+            tooltip.scheduleError(target, event.clientX, event.clientY);
+            const id = target?.closest?.("[data-card-id]")?.getAttribute("data-card-id");
+            if (id)
+              document.querySelector(`[data-id="${id}"]`)?.classList.add("variable-hover-highlight");
+            return false;
+          },
+          mouseout: (_view, event) => {
+            const id = event.target?.closest?.("[data-card-id]")?.getAttribute("data-card-id");
+            if (id)
+              document.querySelector(`[data-id="${id}"]`)?.classList.remove("variable-hover-highlight");
+            return false;
+          },
+          mouseleave: () => {
+            tooltip.handleEditorMouseLeave();
+            return false;
+          }
+        }
+      }
+    });
+    const suggestion = createSuggestionPlugin({
+      editor: this.editor,
+      ctx,
+      onOpen: tooltip.hideError,
+      labels
+    });
+    return [main, suggestion];
+  }
+});
+
+Object.defineProperty(exports, "parse", {
+  enumerable: true,
+  get: function () { return modelLanguage.parse; }
+});
+Object.defineProperty(exports, "render", {
+  enumerable: true,
+  get: function () { return modelLanguage.render; }
+});
+Object.defineProperty(exports, "serialize", {
+  enumerable: true,
+  get: function () { return modelLanguage.serialize; }
+});
+Object.defineProperty(exports, "validate", {
+  enumerable: true,
+  get: function () { return modelLanguage.validate; }
+});
+exports.CONTACT_NAMESPACE_KEY = CONTACT_NAMESPACE_KEY;
+exports.DATE_FORMATS = DATE_FORMATS;
+exports.DEFAULT_LABELS = DEFAULT_LABELS;
+exports.FLOW_NAMESPACE_KEY = FLOW_NAMESPACE_KEY;
+exports.HL_CLASS = HL_CLASS;
+exports.ML_FILTERS = ML_FILTERS;
+exports.ModelSyntax = ModelSyntax;
+exports.STATIC_NAMESPACES = STATIC_NAMESPACES;
+exports.buildModelOptions = buildModelOptions;
+exports.buildValidateSchema = buildValidateSchema;
+exports.defaultFilterFor = defaultFilterFor;
+exports.diagnosticsByPath = diagnosticsByPath;
+exports.modelTokenDisplay = modelTokenDisplay;
+exports.modelTokenTone = modelTokenTone;
+exports.parseModelToken = parseModelToken;
+exports.resolveLabels = resolveLabels;
+exports.suggestOperator = suggestOperator;
+exports.tokenizeExpression = tokenizeExpression;